devflow-agent-cli 0.1.0

package/templates/adapters/cursor/.cursor/rules/typescript.md

@@ -0,0 +1,15 @@
+# Devflow TypeScript Rule
+
+Prefer:
+
+- explicit types at boundaries
+- small readable functions
+- early returns over nested conditionals
+- modifying existing code before adding abstractions
+
+Avoid:
+
+- `any` unless justified
+- deeply nested control flow
+- duplicated logic
+- speculative abstractions

package/templates/adapters/gemini/README.md

@@ -0,0 +1,16 @@
+# Gemini Adapter
+
+Devflow does not install a Gemini-specific integration config in this step.
+
+Reason:
+
+- the universal source of truth already lives in `AGENTS.md`, `DEVFLOW.md`, `devflow/prompts/`, and `.devflow/workflows.yml`
+- this repository does not currently define a verified Gemini adapter contract to install automatically
+
+Use Devflow with Gemini by:
+
+1. Installing the core files
+2. Reusing the prompts in `devflow/prompts/` manually
+3. Pointing the model to `AGENTS.md`, `DEVFLOW.md`, and `.devflow/workflows.yml` when you want repo-specific workflow guidance
+
+When a stable Gemini integration format is verified, this directory can be upgraded from documentation to installable config.

package/templates/adapters/generic/README.md

@@ -0,0 +1,14 @@
+# Generic Adapter
+
+Use this adapter when your tool does not support native commands or rules.
+
+How to use Devflow in any chat or IDE:
+
+1. Start from `AGENTS.md` for the default engineering behavior
+2. Use `devflow/prompts/plan.txt` before writing code
+3. Use `devflow/prompts/build.txt` while implementing
+4. Use `devflow/prompts/tests.txt` after implementation
+5. Use `devflow/prompts/review.txt` for code review
+6. Use `devflow/prompts/verify.txt` before shipping
+
+This keeps the workflow portable without relying on tool-specific config.

package/templates/core/.devflow/workflows.yml

@@ -0,0 +1,21 @@
+review:
+  focus:
+    - bugs
+    - regressions
+    - missing_tests
+    - security
+  output:
+    format: findings_first
+    include_file_refs: true
+
+plan:
+  output:
+    include_files: true
+    include_risks: true
+
+verify:
+  checks:
+    - typecheck
+    - tests
+    - build
+    - edge_cases

package/templates/core/AGENTS.md

@@ -0,0 +1,44 @@
+# Devflow — AI Development Workflow
+
+You are a senior software engineer working on a production codebase.
+
+Full workflow reference: see `DEVFLOW.md` in this project.
+
+## Default workflow
+
+Before writing code always follow this order (PLAN → BUILD → TEST → REVIEW → VERIFY):
+
+1. Understand the problem
+2. Identify relevant files
+3. Propose a minimal implementation plan
+4. Implement the simplest working solution
+5. Verify correctness and edge cases
+
+## Engineering principles
+
+Prefer:
+
+- modifying existing code instead of creating new abstractions
+- small readable functions
+- explicit types
+- simple architecture
+
+Avoid:
+
+- unnecessary files
+- premature optimization
+- complex abstractions
+- duplicated logic
+
+## Verification checklist
+
+Before finishing any task verify:
+
+- the code compiles
+- tests pass
+- edge cases are handled
+- the solution is as simple as possible
+
+## When uncertain
+
+Ask questions instead of guessing.

package/templates/core/DEVFLOW.md

@@ -0,0 +1,138 @@
+# Devflow — Universal Workflow
+
+This file defines the five-phase development workflow. It applies regardless of which AI model or tool you use.
+
+---
+
+## The five phases
+
+```
+PLAN → BUILD → TEST → REVIEW → VERIFY
+```
+
+Always follow this order. Do not skip phases when working on non-trivial tasks.
+
+---
+
+## PLAN
+
+**When:** Before writing any code.
+
+**What the AI should produce:**
+- A summary of what needs to be built and why
+- The minimal set of files that will change
+- Functions, components, or types to create or modify
+- Tests that should exist when done
+- Edge cases and risks to address
+
+**Prompt (paste into any chat):**
+
+> Create a step-by-step implementation plan for: [describe your task]
+>
+> Include: what to build, which files change, what tests must pass, and potential edge cases.
+> Do not write code yet.
+
+---
+
+## BUILD
+
+**When:** After the plan is agreed.
+
+**What the AI should produce:**
+- The minimal working implementation that satisfies the plan
+- No gold-plating, no speculative abstractions
+- Code that compiles and passes existing tests
+
+**Principles:**
+- Modify existing code before creating new abstractions
+- Prefer explicit types, early returns, small functions
+- Keep diffs focused — one concern per change
+
+---
+
+## TEST
+
+**When:** After the implementation is in place.
+
+**What the AI should produce:**
+- Test cases covering the happy path and the edge cases identified in PLAN
+- Integration tests where they provide more value than unit tests
+- Minimal mocks — prefer real dependencies where feasible
+
+**Prompt (paste into any chat):**
+
+> Generate tests for the current implementation.
+>
+> Cover: happy path, edge cases from the plan, and any error states.
+> Prefer integration tests where practical. Use minimal mocks.
+
+---
+
+## REVIEW
+
+**When:** When the implementation and tests are complete.
+
+**What the AI should produce:**
+- Bugs or logic errors
+- Unhandled edge cases
+- Security issues (injection, unvalidated input, exposed secrets)
+- Duplicated logic that should be extracted
+- Unnecessary complexity that should be simplified
+- Performance issues that matter in production
+
+**Prompt (paste into any chat):**
+
+> Review this implementation as a senior engineer.
+>
+> Look for: bugs, edge cases, security issues, duplicated logic, unnecessary complexity.
+> Be specific. Suggest fixes.
+
+---
+
+## VERIFY
+
+**When:** Before marking the task as done.
+
+**Checklist (run through this before finishing):**
+
+- [ ] The code compiles / runs without errors
+- [ ] Tests pass
+- [ ] Edge cases from the PLAN phase are handled
+- [ ] No duplicated logic was introduced
+- [ ] The solution is as simple as it can be
+- [ ] No sensitive data is exposed (secrets, tokens, PII)
+
+**Prompt (paste into any chat):**
+
+> Verify this implementation against the original plan.
+>
+> Check: compilation, tests, edge cases, simplicity, security.
+> Flag anything that should be addressed before shipping.
+
+---
+
+## Quick reference
+
+| Phase | Trigger | Output |
+|-------|---------|--------|
+| PLAN | Before any code | Implementation plan + edge cases |
+| BUILD | Plan agreed | Minimal working implementation |
+| TEST | Implementation done | Test suite covering plan + edge cases |
+| REVIEW | Tests passing | List of issues with suggested fixes |
+| VERIFY | Before done | Checklist sign-off |
+
+---
+
+## Adapters
+
+Devflow keeps the workflow portable by separating the universal core from optional adapters.
+
+Current adapter status:
+
+| Harness | Integration |
+|---------|-------------|
+| Cursor | `/plan`, `/build`, `/tests`, `/review`, `/verify` slash commands |
+| Claude Code | `/plan`, `/build`, `/tests`, `/review`, `/verify` slash commands |
+| Codex CLI | Documentation-only adapter. See `.devflow/adapters/codex/README.md` |
+| Gemini CLI | Documentation-only adapter. See `.devflow/adapters/gemini/README.md` |
+| Any other | Use `.devflow/README.md` and copy prompts from `devflow/prompts/` |

package/templates/prompts/build.txt

@@ -0,0 +1,13 @@
+Implement the agreed plan for the following task:
+
+[Describe the task and include any accepted plan details here]
+
+Requirements:
+
+1. Make the smallest working change that satisfies the plan
+2. Modify existing code before adding new abstractions
+3. Keep functions small and explicit
+4. Preserve existing behavior outside the requested change
+5. Note any follow-up risks or tradeoffs if they remain
+
+Return the implementation and briefly explain what changed.

package/templates/prompts/plan.txt

@@ -0,0 +1,13 @@
+Create a step-by-step implementation plan for the following task:
+
+[Describe your task here]
+
+The plan must include:
+
+1. What needs to be built or changed
+2. Which files will be affected
+3. Functions, components, or types to create or modify
+4. Tests that should pass when done
+5. Edge cases and risks to address
+
+Do not write any code yet. Only the plan.

package/templates/prompts/review.txt

@@ -0,0 +1,14 @@
+Review the following implementation as a senior engineer.
+
+[Paste the code or describe what was implemented]
+
+Check for:
+
+- Bugs and logic errors
+- Unhandled edge cases
+- Security issues
+- Duplicated logic
+- Unnecessary complexity
+- Performance issues that matter in production
+
+Be specific. For each issue found, describe the problem and suggest a fix.

package/templates/prompts/tests.txt

@@ -0,0 +1,18 @@
+Generate tests for the following implementation:
+
+[Paste the code or describe what was implemented]
+
+Cover:
+
+- The happy path
+- Edge cases identified during planning
+- Error states and invalid input
+- Any boundary conditions
+
+Prefer:
+
+- Integration tests over unit tests where they provide more confidence
+- Realistic test data over artificial fixtures
+- Minimal mocking where feasible
+
+Provide the test code ready to run.

package/templates/prompts/verify.txt

@@ -0,0 +1,15 @@
+Verify this implementation against the original plan.
+
+[Paste the code or describe what was implemented and what it was supposed to do]
+
+Check each of the following and report the result:
+
+1. Does the code compile or run without errors?
+2. Do tests pass?
+3. Are edge cases from the plan handled?
+4. Is duplicated logic introduced?
+5. Could the solution be simpler without losing correctness?
+6. Is any sensitive data exposed?
+
+For each issue found, describe it clearly and suggest how to resolve it.
+If everything looks good, confirm it is ready to ship.