ai-devkit 0.4.0 → 0.4.2

package/templates/commands/review-requirements.toml

@@ -0,0 +1,11 @@
+description='''Review the requirements documentation for a feature to ensure
+completeness and alignment with project standards.'''
+prompt='''Please review `docs/ai/requirements/feature-{name}.md` and the project-level template `docs/ai/requirements/README.md` to ensure structure and content alignment. Summarize:
+- Core problem statement and affected users
+- Goals, non-goals, and success criteria
+- Primary user stories & critical flows
+- Constraints, assumptions, open questions
+- Any missing sections or deviations from the template
+
+Identify gaps or contradictions and suggest clarifications.
+'''

package/templates/commands/update-planning.toml

@@ -0,0 +1,63 @@
+description='''Assist in updating planning documentation to reflect current
+implementation progress for a feature.'''
+prompt='''# Planning Update Assistant
+
+Please help me reconcile the current implementation progress with our planning documentation.
+
+## Step 1: Gather Context
+Ask me for:
+- Feature/branch name and brief status
+- Tasks completed since last update
+- Any new tasks discovered
+- Current blockers or risks
+- Relevant planning docs (e.g., `docs/ai/planning/feature-{name}.md`)
+
+## Step 2: Review Planning Doc
+If a planning doc exists:
+- Summarize existing milestones and task breakdowns
+- Note expected sequencing and dependencies
+- Identify outstanding tasks in the plan
+
+## Step 3: Reconcile Progress
+For each planned task:
+- Mark status (done / in progress / blocked / not started)
+- Note actual work completed vs. planned scope
+- Record blockers or changes in approach
+- Identify tasks that were skipped or added
+
+## Step 4: Update Task List
+Help me produce an updated checklist such as:
+```
+### Current Status: [Feature Name]
+
+#### Done
+- [x] Task A - short note on completion or link to commit/pr
+- [x] Task B
+
+#### In Progress
+- [ ] Task C - waiting on [dependency]
+
+#### Blocked
+- [ ] Task D - blocked by [issue/owner]
+
+#### Newly Discovered Work
+- [ ] Task E - reason discovered
+- [ ] Task F - due by [date]
+```
+
+## Step 5: Next Steps & Priorities
+- Suggest the next 2-3 actionable tasks
+- Highlight risky areas needing attention
+- Recommend coordination (design changes, stakeholder sync, etc.)
+- List documentation updates needed
+
+## Step 6: Summary for Planning Doc
+Prepare a summary paragraph to copy into the planning doc, covering:
+- Current state and progress
+- Major risks/blockers
+- Upcoming focus items
+- Any changes to scope or timeline
+
+---
+Let me know when you're ready to begin the planning update.
+'''

package/templates/commands/writing-test.toml

@@ -0,0 +1,46 @@
+description='''Add tests for a new feature'''
+prompt='''Review `docs/ai/testing/feature-{name}.md` and ensure it mirrors the base template before writing tests.
+
+## Step 1: Gather Context
+Ask me for:
+- Feature name and branch
+- Summary of what changed (link to design & requirements docs)
+- Target environment (backend, frontend, full-stack)
+- Existing automated test suites (unit, integration, E2E)
+- Any flaky or slow tests to avoid
+
+## Step 2: Analyze Testing Template
+- Identify required sections from `docs/ai/testing/feature-{name}.md` (unit, integration, manual verification, coverage targets)
+- Confirm success criteria and edge cases from requirements & design docs
+- Note any mocks/stubs or fixtures already available
+
+## Step 3: Unit Tests (Aim for 100% coverage)
+For each module/function:
+1. List behavior scenarios (happy path, edge cases, error handling)
+2. Generate concrete test cases with assertions and inputs
+3. Reference existing utilities/mocks to accelerate implementation
+4. Provide pseudocode or actual test snippets
+5. Highlight potential missing branches preventing full coverage
+
+## Step 4: Integration Tests
+1. Identify critical flows that span multiple components/services
+2. Define setup/teardown steps (databases, APIs, queues)
+3. Outline test cases validating interaction boundaries, data contracts, and failure modes
+4. Suggest instrumentation/logging to debug failures
+
+## Step 5: Coverage Strategy
+- Recommend tooling commands (e.g., `npm run test -- --coverage`)
+- Call out files/functions that still need coverage and why
+- Suggest additional tests if coverage <100%
+
+## Step 6: Manual & Exploratory Testing
+- Propose manual test checklist covering UX, accessibility, and error handling
+- Identify exploratory scenarios or chaos/failure injection tests if relevant
+
+## Step 7: Update Documentation & TODOs
+- Summarize which tests were added or still missing
+- Update `docs/ai/testing/feature-{name}.md` sections with links to test files and results
+- Flag follow-up tasks for deferred tests (with owners/dates)
+
+Let me know when you have the latest code changes ready; we'll write tests together until we hit 100% coverage.
+'''

package/templates/env/base.md

@@ -0,0 +1,51 @@
+# AI DevKit Rules
+
+## Project Context
+This project uses ai-devkit for structured AI-assisted development. Phase documentation is located in `docs/ai/`.
+
+## Documentation Structure
+- `docs/ai/requirements/` - Problem understanding and requirements
+- `docs/ai/design/` - System architecture and design decisions (include mermaid diagrams)
+- `docs/ai/planning/` - Task breakdown and project planning
+- `docs/ai/implementation/` - Implementation guides and notes
+- `docs/ai/testing/` - Testing strategy and test cases
+- `docs/ai/deployment/` - Deployment and infrastructure docs
+- `docs/ai/monitoring/` - Monitoring and observability setup
+
+## Code Style & Standards
+- Follow the project's established code style and conventions
+- Write clear, self-documenting code with meaningful variable names
+- Add comments for complex logic or non-obvious decisions
+
+## Development Workflow
+- Review phase documentation in `docs/ai/` before implementing features
+- Keep requirements, design, and implementation docs updated as the project evolves
+- Reference the planning doc for task breakdown and priorities
+- Copy the testing template (`docs/ai/testing/README.md`) before creating feature-specific testing docs
+
+## AI Interaction Guidelines
+- When implementing features, first check relevant phase documentation
+- For new features, start with requirements clarification
+- Update phase docs when significant changes or decisions are made
+
+## Testing & Quality
+- Write tests alongside implementation
+- Follow the testing strategy defined in `docs/ai/testing/`
+- Use `/writing-test` to generate unit and integration tests targeting 100% coverage
+- Ensure code passes all tests before considering it complete
+
+## Documentation
+- Update phase documentation when requirements or design changes
+- Keep inline code comments focused and relevant
+- Document architectural decisions and their rationale
+- Use mermaid diagrams for any architectural or data-flow visuals (update existing diagrams if needed)
+- Record test coverage results and outstanding gaps in `docs/ai/testing/`
+
+## Key Commands
+When working on this project, you can run commands to:
+- Understand project requirements and goals (`review-requirements`)
+- Review architectural decisions (`review-design`)
+- Plan and execute tasks (`execute-plan`)
+- Verify implementation against design (`check-implementation`)
+- Suggest missing tests (`suggest-tests`)
+- Perform structured code reviews (`code-review`)

package/web/content/pages/vision.md

@@ -11,6 +11,8 @@ AI DevKit exists to bridge the gap between AI-assisted development and structure
 
 ## Our Purpose
 
+It inherits the idea from [The New Engineering Workflow](https://ownthecraftbook.com/chapters/9-the-new-engineering-workflow/) in [AI changes the Tools, you still own the Craft](https://ownthecraftbook.com/): empowering engineers to integrate AI effectively into a structured, test-driven, and craftsmanship-focused development process.
+
 We believe that AI coding assistants are most powerful when they work within a well-defined engineering framework where documentation is clear, plans are systematic, and architecture is intentional.
 
 AI DevKit provides the scaffolding for that structure. It helps engineers reduce the back-and-forth of prompting, keep context in sync, and share memory between themselves and their AI tools.