mirror of https://github.com/azaion/admin.git synced 2026-04-22 22:26:34 +00:00

Files

T

Oleksandr Bezdieniezhnykh d96971b050 Update .gitignore to include .env and .DS_Store files

Add .cursor autodevelopment system

2026-03-25 17:41:10 +02:00

13 KiB

Raw Blame History

Existing Code Workflow

Workflow for projects with an existing codebase. Starts with documentation, produces test specs, decomposes and implements tests, verifies them, refactors with that safety net, then adds new functionality and deploys.

Step Reference Table

Step	Name	Sub-Skill	Internal SubSteps
1	Document	document/SKILL.md	Steps 1–8
2	Test Spec	test-spec/SKILL.md	Phase 1a–1b
3	Decompose Tests	decompose/SKILL.md (tests-only)	Step 1t + Step 3 + Step 4
4	Implement Tests	implement/SKILL.md	(batch-driven, no fixed sub-steps)
5	Run Tests	test-run/SKILL.md	Steps 1–4
6	Refactor	refactor/SKILL.md	Phases 0–5 (6-phase method)
7	New Task	new-task/SKILL.md	Steps 1–8 (loop)
8	Implement	implement/SKILL.md	(batch-driven, no fixed sub-steps)
9	Run Tests	test-run/SKILL.md	Steps 1–4
10	Security Audit	security/SKILL.md	Phase 1–5 (optional)
11	Performance Test	(autopilot-managed)	Load/stress tests (optional)
12	Deploy	deploy/SKILL.md	Step 1–7

After Step 12, the existing-code workflow is complete.

Detection Rules

Check rules in order — first match wins.

Step 1 — Document 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. Read and execute .cursor/skills/document/SKILL.md. After the document skill completes, re-detect state (the produced _docs/ artifacts will place the project at Step 2 or later).

Step 2 — 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/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/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 3 — Decompose Tests Condition: _docs/02_document/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/tests/ as input). The decompose skill will:

Run Step 1t (test infrastructure bootstrap)
Run Step 3 (blackbox test task decomposition)
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 4 — Implement Tests Condition: _docs/02_tasks/ contains task files AND _dependencies_table.md exists AND the autopilot state shows Step 3 (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 5 — Run Tests Condition: _docs/03_implementation/FINAL_implementation_report.md exists AND the autopilot state shows Step 4 (Implement Tests) is completed AND the autopilot state does NOT show Step 5 (Run Tests) as completed

Action: Read and execute .cursor/skills/test-run/SKILL.md

Verifies the implemented test suite passes before proceeding to refactoring. The tests form the safety net for all subsequent code changes.

Step 6 — Refactor Condition: the autopilot state shows Step 5 (Run Tests) is completed AND _docs/04_refactoring/FINAL_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_refactoring/ has phase reports, the refactor skill detects completed phases and continues.

Step 7 — New Task Condition: the autopilot state shows Step 6 (Refactor) is completed AND the autopilot state does NOT show Step 7 (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 8 — Implement Condition: the autopilot state shows Step 7 (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 4 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 9 — Run Tests Condition: the autopilot state shows Step 8 (Implement) is completed AND the autopilot state does NOT show Step 9 (Run Tests) as completed

Action: Read and execute .cursor/skills/test-run/SKILL.md

Step 10 — Security Audit (optional) Condition: the autopilot state shows Step 9 (Run Tests) is completed AND the autopilot state does NOT show Step 10 (Security Audit) as completed or skipped AND (_docs/04_deploy/ does not exist or is incomplete)

Action: Present using Choose format:

══════════════════════════════════════
 DECISION REQUIRED: Run security audit before deploy?
══════════════════════════════════════
 A) Run security audit (recommended for production deployments)
 B) Skip — proceed directly to deploy
══════════════════════════════════════
 Recommendation: A — catches vulnerabilities before production
══════════════════════════════════════

If user picks A → Read and execute .cursor/skills/security/SKILL.md. After completion, auto-chain to Step 11 (Performance Test).
If user picks B → Mark Step 10 as skipped in the state file, auto-chain to Step 11 (Performance Test).

Step 11 — Performance Test (optional) Condition: the autopilot state shows Step 10 (Security Audit) is completed or skipped AND the autopilot state does NOT show Step 11 (Performance Test) as completed or skipped AND (_docs/04_deploy/ does not exist or is incomplete)

Action: Present using Choose format:

══════════════════════════════════════
 DECISION REQUIRED: Run performance/load tests before deploy?
══════════════════════════════════════
 A) Run performance tests (recommended for latency-sensitive or high-load systems)
 B) Skip — proceed directly to deploy
══════════════════════════════════════
 Recommendation: [A or B — base on whether acceptance criteria
 include latency, throughput, or load requirements]
══════════════════════════════════════

If user picks A → Run performance tests:
1. If scripts/run-performance-tests.sh exists (generated by the test-spec skill Phase 4), execute it
2. Otherwise, check if _docs/02_document/tests/performance-tests.md exists for test scenarios, detect appropriate load testing tool (k6, locust, artillery, wrk, or built-in benchmarks), and execute performance test scenarios against the running system
3. Present results vs acceptance criteria thresholds
4. If thresholds fail → present Choose format: A) Fix and re-run, B) Proceed anyway, C) Abort
5. After completion, auto-chain to Step 12 (Deploy)
If user picks B → Mark Step 11 as skipped in the state file, auto-chain to Step 12 (Deploy).

Step 12 — Deploy Condition: the autopilot state shows Step 9 (Run Tests) is completed AND (Step 10 is completed or skipped) AND (Step 11 is completed or skipped) 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 12 (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: 7, status: not_started in the state file, then auto-chain to Step 7 (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 (1)	Auto-chain → Test Spec (2)
Test Spec (2)	Auto-chain → Decompose Tests (3)
Decompose Tests (3)	Session boundary — suggest new conversation before Implement Tests
Implement Tests (4)	Auto-chain → Run Tests (5)
Run Tests (5, all pass)	Auto-chain → Refactor (6)
Refactor (6)	Auto-chain → New Task (7)
New Task (7)	Session boundary — suggest new conversation before Implement
Implement (8)	Auto-chain → Run Tests (9)
Run Tests (9, all pass)	Auto-chain → Security Audit choice (10)
Security Audit (10, done or skipped)	Auto-chain → Performance Test choice (11)
Performance Test (11, done or skipped)	Auto-chain → Deploy (12)
Deploy (12)	Workflow complete — existing-code flow done

Status Summary Template

═══════════════════════════════════════════════════
 AUTOPILOT STATUS (existing-code)
═══════════════════════════════════════════════════
 Step 1   Document            [DONE / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 2   Test Spec           [DONE / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 3   Decompose Tests     [DONE (N tasks) / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 4   Implement Tests     [DONE / IN PROGRESS (batch M) / NOT STARTED / FAILED (retry N/3)]
 Step 5   Run Tests           [DONE (N passed, M failed) / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 6   Refactor            [DONE / IN PROGRESS (phase N) / NOT STARTED / FAILED (retry N/3)]
 Step 7   New Task            [DONE (N tasks) / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 8   Implement           [DONE / IN PROGRESS (batch M of ~N) / NOT STARTED / FAILED (retry N/3)]
 Step 9   Run Tests           [DONE (N passed, M failed) / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 10  Security Audit      [DONE / SKIPPED / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 11  Performance Test    [DONE / SKIPPED / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
 Step 12  Deploy              [DONE / IN PROGRESS / NOT STARTED / FAILED (retry N/3)]
═══════════════════════════════════════════════════
 Current: Step N — Name
 SubStep: M — [sub-skill internal step name]
 Retry:   [N/3 if retrying, omit if 0]
 Action:  [what will happen next]
═══════════════════════════════════════════════════

13 KiB Raw Blame History Unescape Escape