mirror of
https://github.com/azaion/detections.git
synced 2026-04-22 22:26:33 +00:00
Oleksandr Bezdieniezhnykh
182 lines
9.8 KiB
Markdown
182 lines
9.8 KiB
Markdown
# Existing Code Workflow
|
||
|
||
Workflow for projects with an existing codebase. Starts with documentation, produces test specs, decomposes and implements tests, refactors with that safety net, then adds new functionality and deploys.
|
||
|
||
## Step Reference Table
|
||
|
||
| Step | Name | Sub-Skill | Internal SubSteps |
|
||
|------|-------------------------|---------------------------------|---------------------------------------|
|
||
| — | Document (pre-step) | document/SKILL.md | Steps 1–8 |
|
||
| 2b | Blackbox Test Spec | blackbox-test-spec/SKILL.md | Phase 1a–1b |
|
||
| 2c | Decompose Tests | decompose/SKILL.md (tests-only) | Step 1t + Step 3 + Step 4 |
|
||
| 2d | Implement Tests | implement/SKILL.md | (batch-driven, no fixed sub-steps) |
|
||
| 2e | Refactor | refactor/SKILL.md | Phases 0–5 (6-phase method) |
|
||
| 2f | New Task | new-task/SKILL.md | Steps 1–8 (loop) |
|
||
| 2g | Implement | implement/SKILL.md | (batch-driven, no fixed sub-steps) |
|
||
| 2h | Run Tests | (autopilot-managed) | Unit tests → Integration/blackbox tests |
|
||
| 2i | Deploy | deploy/SKILL.md | Steps 1–7 |
|
||
|
||
After Step 2i, the existing-code workflow is complete.
|
||
|
||
## Detection Rules
|
||
|
||
Check rules in order — first match wins.
|
||
|
||
---
|
||
|
||
**Pre-Step — Existing Codebase Detection**
|
||
Condition: `_docs/` does not exist AND the workspace contains source code files (e.g., `*.py`, `*.cs`, `*.rs`, `*.ts`, `src/`, `Cargo.toml`, `*.csproj`, `package.json`)
|
||
|
||
Action: An existing codebase without documentation was detected. Present using Choose format:
|
||
|
||
```
|
||
══════════════════════════════════════
|
||
DECISION REQUIRED: Existing codebase detected
|
||
══════════════════════════════════════
|
||
A) Start fresh — define the problem from scratch (greenfield workflow)
|
||
B) Document existing codebase first — run /document to reverse-engineer docs, then continue
|
||
══════════════════════════════════════
|
||
Recommendation: B — the /document skill analyzes your code
|
||
bottom-up and produces _docs/ artifacts automatically,
|
||
then you can continue with test specs, refactor, and new features.
|
||
══════════════════════════════════════
|
||
```
|
||
|
||
- If user picks A → proceed to Step 0 (Problem Gathering) in the greenfield flow
|
||
- If user picks B → read and execute `.cursor/skills/document/SKILL.md`. After document skill completes, re-detect state (the produced `_docs/` artifacts will place the project at Step 2b or later).
|
||
|
||
---
|
||
|
||
**Step 2b — Blackbox Test Spec**
|
||
Condition: `_docs/02_document/FINAL_report.md` exists AND workspace contains source code files (e.g., `*.py`, `*.cs`, `*.rs`, `*.ts`) AND `_docs/02_document/integration_tests/traceability_matrix.md` does not exist AND the autopilot state shows Document was run (check `Completed Steps` for "Document" entry)
|
||
|
||
Action: Read and execute `.cursor/skills/blackbox-test-spec/SKILL.md`
|
||
|
||
This step applies when the codebase was documented via the `/document` skill. Test specifications must be produced before refactoring or further development.
|
||
|
||
---
|
||
|
||
**Step 2c — Decompose Tests**
|
||
Condition: `_docs/02_document/integration_tests/traceability_matrix.md` exists AND workspace contains source code files AND the autopilot state shows Document was run AND (`_docs/02_tasks/` does not exist or has no task files)
|
||
|
||
Action: Read and execute `.cursor/skills/decompose/SKILL.md` in **tests-only mode** (pass `_docs/02_document/integration_tests/` as input). The decompose skill will:
|
||
1. Run Step 1t (test infrastructure bootstrap)
|
||
2. Run Step 3 (integration test task decomposition)
|
||
3. Run Step 4 (cross-verification against test coverage)
|
||
|
||
If `_docs/02_tasks/` has some task files already, the decompose skill's resumability handles it.
|
||
|
||
---
|
||
|
||
**Step 2d — Implement Tests**
|
||
Condition: `_docs/02_tasks/` contains task files AND `_dependencies_table.md` exists AND the autopilot state shows Step 2c (Decompose Tests) is completed AND `_docs/03_implementation/FINAL_implementation_report.md` does not exist
|
||
|
||
Action: Read and execute `.cursor/skills/implement/SKILL.md`
|
||
|
||
The implement skill reads test tasks from `_docs/02_tasks/` and implements them.
|
||
|
||
If `_docs/03_implementation/` has batch reports, the implement skill detects completed tasks and continues.
|
||
|
||
---
|
||
|
||
**Step 2e — Refactor**
|
||
Condition: `_docs/03_implementation/FINAL_implementation_report.md` exists AND the autopilot state shows Step 2d (Implement Tests) is completed AND `_docs/04_refactor/FINAL_refactor_report.md` does not exist
|
||
|
||
Action: Read and execute `.cursor/skills/refactor/SKILL.md`
|
||
|
||
The refactor skill runs the full 6-phase method using the implemented tests as a safety net.
|
||
|
||
If `_docs/04_refactor/` has phase reports, the refactor skill detects completed phases and continues.
|
||
|
||
---
|
||
|
||
**Step 2f — New Task**
|
||
Condition: `_docs/04_refactor/FINAL_refactor_report.md` exists AND the autopilot state shows Step 2e (Refactor) is completed AND the autopilot state does NOT show Step 2f (New Task) as completed
|
||
|
||
Action: Read and execute `.cursor/skills/new-task/SKILL.md`
|
||
|
||
The new-task skill interactively guides the user through defining new functionality. It loops until the user is done adding tasks. New task files are written to `_docs/02_tasks/`.
|
||
|
||
---
|
||
|
||
**Step 2g — Implement**
|
||
Condition: the autopilot state shows Step 2f (New Task) is completed AND `_docs/03_implementation/` does not contain a FINAL report covering the new tasks (check state for distinction between test implementation and feature implementation)
|
||
|
||
Action: Read and execute `.cursor/skills/implement/SKILL.md`
|
||
|
||
The implement skill reads the new tasks from `_docs/02_tasks/` and implements them. Tasks already implemented in Step 2d are skipped (the implement skill tracks completed tasks in batch reports).
|
||
|
||
If `_docs/03_implementation/` has batch reports from this phase, the implement skill detects completed tasks and continues.
|
||
|
||
---
|
||
|
||
**Step 2h — Run Tests**
|
||
Condition: the autopilot state shows Step 2g (Implement) is completed AND the autopilot state does NOT show Step 2h (Run Tests) as completed
|
||
|
||
Action: Run the full test suite to verify the implementation before deployment.
|
||
|
||
1. **Unit tests**: detect the project's test runner (e.g., `pytest`, `dotnet test`, `cargo test`, `npm test`) and run all unit tests
|
||
2. **Integration / blackbox tests**: if `docker-compose.test.yml` or an equivalent test environment exists, spin it up and run the integration test suite
|
||
3. **Report results**: present a summary of passed/failed/skipped tests
|
||
|
||
If all tests pass → auto-chain to Step 2i (Deploy).
|
||
|
||
If tests fail → present using Choose format:
|
||
|
||
```
|
||
══════════════════════════════════════
|
||
TEST RESULTS: [N passed, M failed, K skipped]
|
||
══════════════════════════════════════
|
||
A) Fix failing tests and re-run
|
||
B) Proceed to deploy anyway (not recommended)
|
||
C) Abort — fix manually
|
||
══════════════════════════════════════
|
||
Recommendation: A — fix failures before deploying
|
||
══════════════════════════════════════
|
||
```
|
||
|
||
---
|
||
|
||
**Step 2i — Deploy**
|
||
Condition: the autopilot state shows Step 2h (Run Tests) is completed AND (`_docs/04_deploy/` does not exist or is incomplete)
|
||
|
||
Action: Read and execute `.cursor/skills/deploy/SKILL.md`
|
||
|
||
After deployment completes, the existing-code workflow is done.
|
||
|
||
---
|
||
|
||
**Re-Entry After Completion**
|
||
Condition: the autopilot state shows `step: done` OR all steps through 2i (Deploy) are completed
|
||
|
||
Action: The project completed a full cycle. Present status and loop back to New Task:
|
||
|
||
```
|
||
══════════════════════════════════════
|
||
PROJECT CYCLE COMPLETE
|
||
══════════════════════════════════════
|
||
The previous cycle finished successfully.
|
||
You can now add new functionality.
|
||
══════════════════════════════════════
|
||
A) Add new features (start New Task)
|
||
B) Done — no more changes needed
|
||
══════════════════════════════════════
|
||
```
|
||
|
||
- If user picks A → set `step: 2f`, `status: not_started` in the state file, then auto-chain to Step 2f (New Task). Previous cycle history stays in Completed Steps.
|
||
- If user picks B → report final project status and exit.
|
||
|
||
## Auto-Chain Rules
|
||
|
||
| Completed Step | Next Action |
|
||
|---------------|-------------|
|
||
| Document (existing code) | Auto-chain → Blackbox Test Spec (Step 2b) |
|
||
| Blackbox Test Spec (Step 2b) | Auto-chain → Decompose Tests (Step 2c) |
|
||
| Decompose Tests (Step 2c) | **Session boundary** — suggest new conversation before Implement Tests |
|
||
| Implement Tests (Step 2d) | Auto-chain → Refactor (Step 2e) |
|
||
| Refactor (Step 2e) | Auto-chain → New Task (Step 2f) |
|
||
| New Task (Step 2f) | **Session boundary** — suggest new conversation before Implement |
|
||
| Implement (Step 2g) | Auto-chain → Run Tests (Step 2h) |
|
||
| Run Tests (Step 2h, all pass) | Auto-chain → Deploy (Step 2i) |
|
||
| Deploy (Step 2i) | **Workflow complete** — existing-code flow done |
|