aidp 0.1.0

data/templates/COMMON/TEMPLATES/ADR_TEMPLATE.md

@@ -0,0 +1,21 @@
+# ADR NNN: [Decision Title]
+
+Date: 2025-08-13
+Status: Proposed | Accepted | Superseded by NNN
+
+## Context
+
+- Forces, constraints, goals, NFRs, tradeoffs.
+
+## Decision
+
+- What we're choosing and why (tie directly to PRD/NFRs/Architecture).
+
+## Consequences
+
+- Positive/negative outcomes; risks; follow-ups; observability hooks;
+  cost/security implications.
+
+## Alternatives
+
+- Options considered; why not chosen; re-evaluation trigger(s).

data/templates/COMMON/TEMPLATES/DOMAIN_CHARTER.md

@@ -0,0 +1,27 @@
+# [Domain] Charter
+
+## Responsibilities (In-Scope)
+
+- Core domain capabilities owned by this bounded context.
+
+## Out of Scope
+
+- Clear exclusions to prevent scope creep.
+
+## Inputs & Outputs
+
+- APIs consumed/exposed (refs to contracts)
+- Events published/subscribed (refs to contracts)
+- Data ownership: authoritative stores and read models
+
+## Interfaces & Anti-Corruption
+
+- How external models are translated; adapters/ACLs; integration style (sync/async)
+
+## Quality Attributes Emphasis
+
+- Latency budgets, availability target, privacy/security, cost, operability
+
+## Review & Ownership
+
+- Reviewers, ownership rules, and escalation

data/templates/COMMON/TEMPLATES/EVENT_EXAMPLE.yaml

@@ -0,0 +1,16 @@
+# Example event contract (YAML)
+name: product.catalog.v1.ProductCreated
+version: v1
+schema:
+  id: string
+  name: string
+  price: number
+  currency: string
+metadata:
+  retention: 365d
+  pii: false
+compatibility:
+  strategy: backward-compatible
+  rules:
+    - fields are only added with defaults
+    - never change semantics of existing fields

data/templates/COMMON/TEMPLATES/MERMAID_C4.md

@@ -0,0 +1,46 @@
+# Mermaid C4 Diagram Template
+
+```mermaid
+flowchart LR
+  subgraph Users
+    U[Primary User]
+  end
+
+  subgraph Edge
+    FE[Client/UI]
+    API[API Gateway]
+  end
+
+  subgraph Services
+    Auth[Auth]
+    Profile[Profile]
+    Orders[Orders]
+    subgraph Catalog
+      Cat[Catalog]
+      Search[Search]
+    end
+  end
+
+  subgraph Data
+    UDB[(User DB)]
+    ODB[(Orders DB)]
+    IDX[(Search Index)]
+    CACHE[(Cache)]
+    BUS[[Event Bus]]
+  end
+
+  U --> FE --> API
+  API --> Auth
+  API --> Profile
+  API --> Orders
+  API --> Cat
+  API --> Search
+
+  Profile --> UDB
+  Orders --> ODB
+  Search --> IDX
+  Cat --> CACHE
+
+  Auth -- publishes --> BUS
+  Orders -- subscribes --> BUS
+```

data/templates/COMMON/TEMPLATES/OPENAPI_STUB.yaml

@@ -0,0 +1,11 @@
+openapi: 3.0.3
+info:
+  title: Sample API
+  version: 0.1.0
+paths:
+  /health:
+    get:
+      summary: Liveness probe
+      responses:
+        '200':
+          description: OK

data/templates/EXECUTE/00_PRD.md

@@ -0,0 +1,36 @@
+# AI Scaffold Product Requirements Document (PRD) Generator
+
+You are a product strategist. Produce a **concise, complete PRD**.
+
+## Important Instructions
+
+- If you need additional information to create a complete PRD, create a file called `PRD_QUESTIONS.md` with specific questions for the user.
+- If `PRD_QUESTIONS.md` already exists, read the existing questions and answers to understand the user's responses.
+- Otherwise, proceed to create the complete PRD document.
+- Only ask for clarifications at this PRD step. For subsequent steps, proceed with available information.
+
+## Input
+
+- A high-level prompt/idea provided by the user.
+
+## Process
+
+- Derive goals, scope, success metrics, personas, user stories (Given/When/Then),
+  constraints, risks, and out-of-scope.
+- Keep it implementation-agnostic; do not pick frameworks/languages yet.
+- Prefer measurable outcomes and acceptance criteria mapped to user stories.
+
+## Output (Markdown → write to docs/PRD.md)
+
+- Goal & Non-Goals
+- Personas & Primary Use Cases
+- User Stories (Given/When/Then)
+- Constraints & Assumptions
+- Success Metrics (leading/lagging)
+- Out of Scope
+- Risks & Mitigations
+- Open Questions (for the PRD gate)
+
+## Regeneration Policy
+
+If re-run, append under `## Regenerated on <date>` rather than overwrite user edits.

data/templates/EXECUTE/01_NFRS.md

@@ -0,0 +1,27 @@
+# AI Scaffold Non-Functional Requirements (NFRs) Generator
+
+You are a systems/product engineer focusing on **quality attributes** that shape
+architecture.
+
+## Inputs
+
+- `docs/PRD.md`
+
+## Process
+
+- Distill NFRs: availability, latency budgets, throughput, durability, security,
+  privacy, compliance, accessibility, observability, maintainability, portability,
+  cost.
+- Convert ambiguous statements into specific, testable targets (e.g.,
+  "p95 < 300ms @ 100 RPS").
+
+## Output (Markdown → write to docs/NFRs.md)
+
+- Quality Attributes & Measurable Targets
+- Constraints derived from NFRs
+- Key Tradeoffs & Risks
+- Validation Approach (how we'll test each NFR)
+
+## Regeneration Policy
+
+Append under `## Regenerated on <date>` if re-run.

data/templates/EXECUTE/02A_ARCH_GATE_QUESTIONS.md

@@ -0,0 +1,13 @@
+# Architecture Gate — Questions to Ask (Only at this step)
+
+Ask concisely; collect answers and append them under **Design Inputs** in
+`Architecture.md`.
+
+1. Target stack preferences (languages, frameworks, package managers)?
+2. Deployment model (k8s/serverless/VMs); cloud/provider; primary data stores &
+   search choices?
+3. Scale & SLOs (expected RPS, p95 latency, availability, cost ceilings)?
+4. Data sensitivity/compliance (e.g., PII, HIPAA/PCI/GDPR/CCPA)?
+5. Repo strategy (mono-repo vs multi-repo; separate contracts repo)?
+6. Agent runtime (model(s), vector store, allowed tools, code execution limits)?
+7. Human review points (which gates require human approval vs auto-merge on green)?

data/templates/EXECUTE/02_ARCHITECTURE.md

@@ -0,0 +1,42 @@
+# AI Scaffold Architecture Generator
+
+You are a software architect. Propose an architecture with **clean bounded contexts**
+and **hexagonal structure**.
+
+## Important Instructions
+
+- If you need additional information to create a complete architecture, create a file called `ARCH_QUESTIONS.md` with specific questions for the user (see `02A_ARCH_GATE_QUESTIONS.md` for suggested questions).
+- If `ARCH_QUESTIONS.md` already exists, read the existing questions and answers to understand the user's responses.
+- Otherwise, proceed to create the complete architecture document.
+- Only ask for clarifications at this Architecture step. For subsequent steps, proceed with available information.
+
+## Inputs
+
+- `docs/PRD.md`
+- `docs/NFRs.md`
+
+## Process
+
+- Analyze domain to identify bounded contexts; choose integration styles
+  (sync/async, events, queues).
+- Design **Context → Container → Component** (C4-ish) and produce a **Mermaid**
+  diagram.
+- Ensure domain separation with anti-corruption layers.
+- Suggest **3-5 ADRs** that capture key decisions to formalize next.
+
+## Output (to disk)
+
+1. `docs/Architecture.md` including:
+   - Context, Container, Component overviews
+   - Domain boundaries and ownership
+   - Integration points and data flow
+   - Design Inputs (answers to architecture gate questions)
+   - Architecture risks and mitigations
+2. `docs/architecture.mmd` containing a Mermaid diagram (see
+   `COMMON/TEMPLATES/MERMAID_C4.md` for style).
+3. `docs/adr/` suggestions list in `Architecture.md` under **Decisions to
+   Formalize (ADRs)**.
+
+## Regeneration Policy
+
+Append under `## Regenerated on <date>` if re-run.

data/templates/EXECUTE/03_ADR_FACTORY.md

@@ -0,0 +1,22 @@
+# AI Scaffold Architecture Decision Records (ADRs) Factory
+
+You are the ADR scribe. For each proposed decision, create an ADR using the standard
+format.
+
+## Inputs
+
+- `docs/Architecture.md` (the **Decisions to Formalize (ADRs)** list)
+- `COMMON/TEMPLATES/ADR_TEMPLATE.md`
+
+## Process
+
+- One ADR per decision; assign sequential numbers (starting at 001). Keep
+  **Proposed** unless approved.
+
+## Output (files in `docs/adr/`)
+
+- `docs/adr/NNN-<slug>.md` using the template, including date `2025-08-13`
+
+## Regeneration Policy
+
+- Do not overwrite accepted ADRs. Create a new ADR that **supersedes** if needed.

data/templates/EXECUTE/04_DOMAIN_DECOMPOSITION.md

@@ -0,0 +1,24 @@
+# AI Scaffold Domain Decomposition
+
+You are a domain modeler. Define bounded contexts and their charters.
+
+## Inputs
+
+- `docs/PRD.md`, `docs/NFRs.md`, `docs/Architecture.md`
+
+## Process
+
+- Identify domains/contexts. For each, write a **Domain Charter** using
+  `COMMON/TEMPLATES/DOMAIN_CHARTER.md`.
+- Include cross-cutting contexts (Security/Privacy, Data/Schema, Test, Docs,
+  SRE/Observability).
+
+## Output
+
+- `docs/DomainCharters/<Context>.md` per context
+- Update `docs/Architecture.md` with a table mapping contexts → ownership →
+  interfaces.
+
+## Regeneration Policy
+
+Append new/changed contexts; keep previous charters.

data/templates/EXECUTE/05_CONTRACTS.md

@@ -0,0 +1,27 @@
+# AI Scaffold Contracts Generator
+
+You are a contracts-first engineer.
+
+## Inputs
+
+- `docs/DomainCharters/*`
+- `docs/Architecture.md`
+
+## Process
+
+- Define **API contracts** (OpenAPI/GraphQL), **event contracts** (YAML), and
+  **schemas/migrations**.
+- Document versioning, compatibility rules, deprecation policy, and
+  consumer-driven tests.
+
+## Output
+
+- `contracts/api/*.yaml|.graphql`
+- `contracts/events/*.yaml`
+- `contracts/schema/*`
+- A `contracts/README.md` explaining versioning and compatibility guarantees.
+
+## Regeneration Policy
+
+Maintain backward compatibility and version bump rules. Never silently break
+consumers.

data/templates/EXECUTE/06_THREAT_MODEL.md

@@ -0,0 +1,23 @@
+# AI Scaffold Threat Model Generator
+
+You are a security & privacy engineer.
+
+## Inputs
+
+- `docs/PRD.md`, `docs/NFRs.md`, `docs/Architecture.md`, `contracts/*`
+
+## Process
+
+- Perform **STRIDE** (threats) and **LINDDUN** (privacy) passes.
+- Create a **data classification** and **PII flow** with retention policies and
+  DPAs where appropriate.
+- Identify mitigations and owners.
+
+## Output
+
+- `docs/ThreatModel.md`
+- `docs/DataMap.md` (classification, flows, retention)
+
+## Regeneration Policy
+
+Track risks with IDs; updates append notes and status changes.

data/templates/EXECUTE/07_TEST_PLAN.md

@@ -0,0 +1,24 @@
+# AI Scaffold Test Plan Generator
+
+You are a test strategist.
+
+## Inputs
+
+- `docs/PRD.md`, `docs/NFRs.md`, `contracts/*`, `docs/Architecture.md`
+
+## Process
+
+- Derive acceptance tests from user stories.
+- Define the **test pyramid** (unit, contract, component, e2e) and
+  **property-based** tests for core logic.
+- Establish coverage & mutation-testing thresholds.
+- Follow Sandi Metz's rules for unit testing.
+
+## Output
+
+- `docs/TestPlan.md`
+- `golden/` fixtures directory plan
+
+## Regeneration Policy
+
+Append; do not remove prior test cases unless superseded and noted.

data/templates/EXECUTE/08_TASKS.md

@@ -0,0 +1,29 @@
+# AI Scaffold Task Planner
+
+You are a planner.
+
+## Important Instructions
+
+- If you need additional information to create a complete task plan, create a file called `TASKS_QUESTIONS.md` with specific questions for the user.
+- If `TASKS_QUESTIONS.md` already exists, read the existing questions and answers to understand the user's responses.
+- Otherwise, proceed to create the complete task plan.
+- Only ask for clarifications at this Tasks step. For subsequent steps, proceed with available information.
+
+## Inputs
+
+- `docs/DomainCharters/*`, `contracts/*`, `docs/TestPlan.md`
+
+## Process
+
+- Break work into tasks **per domain** and **per cross-cutting** area.
+- Include Definition of Done (DoD), dependencies, and reviewer role.
+
+## Output
+
+- `tasks/domains/<context>.yaml`
+- `tasks/crosscutting/<area>.yaml`
+- `tasks/backlog.yaml` as a merge of all tasks with ordering hints
+
+## Regeneration Policy
+
+Append new tasks; mark deprecated tasks with status.

data/templates/EXECUTE/09_SCAFFOLDING_DEVEX.md

@@ -0,0 +1,25 @@
+# AI Scaffold DevEx Generator
+
+You are a developer experience engineer.
+
+## Inputs
+
+- `docs/DomainCharters/*`, `contracts/*`
+
+## Process
+
+- Propose **language-agnostic** repository layouts for each context (service/lib)
+  using ports/adapters.
+- Provide local dev environment hints (docker-compose/devcontainer) without
+  choosing specific stacks unless already decided via ADRs.
+- Add lint/format/type-check suggestions generically (e.g., "use the
+  ecosystem-standard tools for chosen language").
+
+## Output
+
+- `docs/ScaffoldingGuide.md` with practical structures and examples for multiple
+  common stacks (JS/TS, Ruby on Rails, Go, Java, etc.)
+
+## Regeneration Policy
+
+Keep alternatives side-by-side; tie recommendations to ADRs when present.

data/templates/EXECUTE/10_IMPLEMENTATION_AGENT.md

@@ -0,0 +1,30 @@
+# AI Scaffold Implementation Guide Generator
+
+You are a senior engineer writing **implementation guidance** for domain agents.
+
+## Important Instructions
+
+- If you need additional information to create a complete implementation guide, create a file called `IMPL_QUESTIONS.md` with specific questions for the user.
+- If `IMPL_QUESTIONS.md` already exists, read the existing questions and answers to understand the user's responses.
+- Otherwise, proceed to create the complete implementation guide.
+- Only ask for clarifications at this Implementation step. For subsequent steps, proceed with available information.
+
+## Inputs
+
+- `contracts/*`, `docs/DomainCharters/*`, `docs/TestPlan.md`
+
+## Process
+
+- For each task, suggest patterns and structure using **SOLID**, **GoF**, **DDD**,
+  and **hexagonal architecture**.
+- Emphasize **composition-first**, domain events, and clean interfaces.
+- Require "Design by Contract" (pre/postconditions) for public functions where
+  idiomatic.
+
+## Output
+
+- `docs/ImplementationGuide.md` with examples and a pattern-to-use-case matrix.
+
+## Regeneration Policy
+
+Append new examples; keep prior guidance.

data/templates/EXECUTE/11_STATIC_ANALYSIS.md

@@ -0,0 +1,22 @@
+# AI Scaffold Static Analysis Generator
+
+You are a security/compliance engineer.
+
+## Inputs
+
+- Repository source as it evolves.
+
+## Process
+
+- Specify linters/formatters/type-checkers per language family.
+- Add SAST, dependency risk scanning, license compliance, SBOM generation, secret
+  scanning.
+
+## Output
+
+- `docs/StaticAnalysis.md` including minimal commands for common ecosystems and
+  policy gates (fail thresholds).
+
+## Regeneration Policy
+
+Keep policy changes auditable.

data/templates/EXECUTE/12_OBSERVABILITY_SLOS.md

@@ -0,0 +1,21 @@
+# AI Scaffold Observability Generator
+
+You are an SRE.
+
+## Inputs
+
+- `docs/NFRs.md`, `docs/Architecture.md`
+
+## Process
+
+- Define SLOs, SLIs; model RED/USE metrics; tracing.
+- Propose dashboards, alert rules tied to SLOs, health checks, readiness probes.
+- Draft runbooks for common incidents.
+
+## Output
+
+- `docs/Observability.md` and `observability/` folder structure suggestion
+
+## Regeneration Policy
+
+Append; keep changes traceable.

data/templates/EXECUTE/13_DELIVERY_ROLLOUT.md

@@ -0,0 +1,21 @@
+# AI Scaffold Delivery Plan Generator
+
+You are a release engineer.
+
+## Inputs
+
+- `docs/Architecture.md`, `docs/TestPlan.md`
+
+## Process
+
+- Plan infra-as-code, environments, feature flags, canary, automated rollback,
+  schema migration sequencing (expand → migrate → contract).
+- Include change risk assessment and release checklists.
+
+## Output
+
+- `docs/DeliveryPlan.md`
+
+## Regeneration Policy
+
+Append versions of the rollout plan as the system matures.

data/templates/EXECUTE/14_DOCS_PORTAL.md

@@ -0,0 +1,23 @@
+# AI Scaffold Documentation Portal Generator
+
+You are a docs lead.
+
+## Inputs
+
+- All prior artifacts.
+
+## Process
+
+- Propose a docs portal (MkDocs/Docusaurus/Sphinx/etc.) without enforcing a
+  specific tool.
+- Organize how-tos, reference, concepts, ADR index, API/event docs, architecture
+  map.
+- Use the Diataxis framework for planning and organizing docs.
+
+## Output
+
+- `docs/DocsPortalPlan.md`
+
+## Regeneration Policy
+
+Append new sections; preserve existing IA decisions unless superseded by ADRs.

data/templates/EXECUTE/15_POST_RELEASE.md

@@ -0,0 +1,25 @@
+# AI Scaffold Post-Release Analysis Generator
+
+You are a product/ops analyst setting up the feedback loop.
+
+## Inputs
+
+- Telemetry, cost data, error budgets, UX analytics
+
+## Process
+
+- Compare outcomes vs PRD/NFRs; decide iterate/optimize/deprecate; plan A/B tests
+  if relevant.
+
+## Output
+
+- `docs/PostReleaseReport.md` template with sections:
+  - Outcomes vs Targets
+  - Reliability & Cost Review
+  - Top Incidents & Fix/Follow-ups
+  - User Feedback & UX Findings
+  - Next Iteration Plan
+
+## Regeneration Policy
+
+Version and timestamp each report.