@kamkom/awb-mcp 0.0.1

package/.ai/backlog.md

@@ -0,0 +1,435 @@
+# AWB MCP — Product Backlog
+
+Stories and acceptance criteria derived from [.ai/prd.md](.ai/prd.md), grouped by milestone.
+
+---
+
+## v0.1 — MVP core
+
+### Story 1: MCP server runs in VS Code over stdio
+
+**User story**
+
+- As a developer using VS Code with an MCP-capable agent/chat client  
+- I want to run the AWB MCP server as a stdio-based server so that I can use its tools from my editor without extra infrastructure  
+
+**Acceptance criteria**
+
+- Given a Windows or macOS machine with Node.js and VS Code configured for MCP  
+- When I install the package (e.g. `npm i -g awb-mcp`) and add the server to my MCP settings with the command path  
+- Then the server starts over stdio, responds to MCP protocol messages, and exposes tools (e.g. list_tools returns AWB tools)  
+
+**Edge cases**
+
+- Linux: document as optional; no hard requirement to fix Linux-only issues in v0.1  
+- Invalid or missing `rootPath`: server returns clear error, does not crash  
+- Server receives malformed or unexpected JSON: responds with protocol error, does not exit ungracefully  
+
+**Technical considerations**
+
+- Use `@modelcontextprotocol/sdk` StdioServerTransport; single executable entrypoint (e.g. `awb-mcp` or `npx awb-mcp`)  
+- No network listener; stdio only  
+- Package `bin` in package.json so `awb-mcp` is on PATH after global install  
+
+**Design notes**
+
+- Keep VS Code MCP config minimal: only the command (e.g. `awb-mcp` or `npx awb-mcp`). No required env vars or args for basic use  
+
+---
+
+### Story 2: plan_bootstrap returns a deterministic plan with full contents and warnings
+
+**User story**
+
+- As a user in an agentic workflow  
+- I want to call `awb.plan_bootstrap` with a repo root and options so that I get a clear, deterministic plan of file operations (create/update/skip) with full file contents and warnings for existing files  
+
+**Acceptance criteria**
+
+- Given a valid `rootPath` (existing directory) and optional `options` (mode, includeReadmeProposal, overwritePolicy, files allowlist)  
+- When I call the tool `awb.plan_bootstrap` with those inputs  
+- Then I receive a response containing: a unique `planId`; an `operations[]` array with for each path: `path`, `action` (CREATE | UPDATE_MANAGED | SKIP), `content` when action is CREATE or UPDATE_MANAGED, `reason` (especially for SKIP), and `warnings[]`; optional `repoHints` and `readmeProposal` when requested  
+
+- Given a path that does not exist on disk  
+- When the plan is computed  
+- Then that path has action CREATE and includes full static template content  
+
+- Given a path that exists and has no AWB managed block and overwritePolicy is not "overwrite"  
+- When the plan is computed  
+- Then that path has action SKIP, a reason, and a warning that the file exists and is not being overwritten  
+
+**Edge cases**
+
+- `rootPath` is a file or non-existent: return clear error, no plan  
+- `files` allowlist: only those paths appear in operations; others are omitted  
+- Empty repo (no existing scaffold): all scaffold paths are CREATE  
+- overwritePolicy `"skip"`: existing files always SKIP (even if they contain a managed block). `"managed-only"`: SKIP unless file has AWB managed block (then UPDATE_MANAGED)  
+
+**Technical considerations**
+
+- planId: UUID or timestamp-based unique string; same inputs produce same plan content (deterministic)  
+- Read only: directory listing and file existence (and optionally small config files for hints). No writes in plan  
+- Input schema: validate rootPath (string), options optional with zod or equivalent  
+
+**Design notes**
+
+- Static mode default: all templates are prefilled content from server bundle. No LLM calls in server  
+
+---
+
+### Story 3: apply_bootstrap applies an approved plan with atomic writes and conflict handling
+
+**User story**
+
+- As a user who has reviewed a bootstrap plan  
+- I want to call `awb.apply_bootstrap` with the planId and operations so that only approved changes are written to disk using atomic writes and explicit conflict handling  
+
+**Acceptance criteria**
+
+- Given a valid `rootPath`, the `planId` from a prior `plan_bootstrap` call, and the same `operations[]` (or server-validated subset)  
+- When I call `awb.apply_bootstrap` without dryRun  
+- Then each CREATE/UPDATE_MANAGED operation is written to disk; each SKIP is not written; the response includes `results[]` with per-path `status` (WRITTEN | SKIPPED | FAILED) and `details`  
+
+- Given applyOptions.dryRun is true  
+- When I call `awb.apply_bootstrap`  
+- Then no files are modified and the response describes what would have been done (e.g. same result structure with WRITTEN/SKIPPED/FAILED as if applied)  
+
+- Given writeMode is "atomic" (default)  
+- When a file is written  
+- Then content is written to a temp file in the same directory and then renamed into place so that partial writes are not visible  
+
+**Edge cases**
+
+- planId or operations do not match a recent plan: server may validate and return FAILED for mismatches if failOnConflict is true  
+- Disk full or permission error: that path returns status FAILED with details; other paths still attempted where possible  
+- apply_bootstrap called with operations from a different rootPath: server validates and rejects or marks FAILED  
+
+**Technical considerations**
+
+- Atomic write: write to `*.tmp` (or similar) in same directory, fs.rename to final path  
+- Idempotency: applying the same plan twice with same overwrite policy should yield same outcome (second run no unexpected changes)  
+- applyOptions: dryRun, writeMode "atomic", failOnConflict (default true)  
+
+**Design notes**
+
+- Server does not re-read disk to “re-plan”; it applies the operations as given, enforcing overwrite policy per operation  
+
+---
+
+### Story 4: Overwrite and idempotency — SKIP by default, managed-block and explicit overwrite
+
+**User story**
+
+- As a user running bootstrap in a repo that may already have some files  
+- I want the server to never overwrite my content unless a file is under AWB management or I explicitly allow overwrite so that I do not lose work  
+
+**Acceptance criteria**
+
+- Given a target path where the file does not exist  
+- When the plan is computed and applied  
+- Then the action is CREATE and the file is created  
+
+- Given a target path where the file exists and does not contain the AWB managed block marker  
+- When overwritePolicy is "skip" or "managed-only" (default)  
+- Then the action is SKIP, reason and warnings are set, and the file is not modified on apply  
+
+- Given a target path where the file exists and contains the AWB managed block marker  
+- When overwritePolicy is "managed-only" (default)  
+- Then the action is UPDATE_MANAGED, content is the new managed block content, and on apply only the managed section is updated (or full file replace per implementation)  
+
+- Given the user passes overwrite: true for a specific file (or overwritePolicy "overwrite")  
+- When the plan is computed and applied  
+- Then that path can be CREATE/UPDATE and existing content may be replaced; user has explicitly opted in  
+
+**Edge cases**
+
+- Managed block marker missing or malformed: treat as unmanaged, SKIP unless overwrite  
+- Partial file (e.g. only start marker): define behavior (e.g. SKIP or treat as managed); document  
+
+**Technical considerations**
+
+- Define a single, documented AWB managed block format (e.g. `<!-- AWB MANAGED BEGIN -->` … `<!-- AWB MANAGED END -->` or similar)  
+- plan_bootstrap decides CREATE | UPDATE_MANAGED | SKIP per path based on existence and overwrite policy; apply_bootstrap enforces the same policy  
+
+**Design notes**
+
+- Safe-by-default: “plan first, then apply” with clear SKIP behavior and no blind overwrites  
+
+---
+
+### Story 5: Baseline scaffold — static templates for .github and AGENTS.md
+
+**User story**
+
+- As a user bootstrapping a repo for agentic workflows  
+- I want the server to generate a fixed set of high-quality, generic template files so that my repo has a standard structure for instructions, prompts, and agents without me creating them by hand  
+
+**Acceptance criteria**
+
+- Given a successful `plan_bootstrap` in static mode with no files allowlist (or allowlist including the baseline paths)  
+- When the plan is generated  
+- Then operations include the full baseline tree: `.github/copilot-instructions.md`, `.github/instructions/general.instructions.md`, `.github/instructions/testing.instructions.md`, `.github/prompts/readme.prompt.md`, `.github/prompts/onboarding.prompt.md`, `.github/prompts/change-summary.prompt.md`, `.github/agents/architect.agent.md`, `.github/agents/implementer.agent.md`, `.github/agents/reviewer.agent.md`, `AGENTS.md`  
+
+- Given the template content returned in the plan  
+- When I read it  
+- Then it is generic, high-signal, and safe: emphasizes “don’t guess,” “prefer repo scripts,” “write tests,” “avoid destructive commands”  
+- And placeholders (e.g. `{{packageManager}}`, `{{testCommand}}`) are minimal and optional; may be left as defaults in v0.1  
+
+**Edge cases**
+
+- `files` allowlist provided: only listed paths that belong to the baseline appear in operations  
+- Paths outside repo root (e.g. `..` in path): server rejects or normalizes  
+
+**Technical considerations**
+
+- Templates shipped as static files in the server package (e.g. in a `templates/` directory); no runtime fetch  
+- Use path.join(rootPath, ...) for all paths; normalize and reject paths not under rootPath  
+
+**Design notes**
+
+- Templates work for any repo/stack; no stack-specific logic required in v0.1  
+
+---
+
+### Story 6: Safety — no network, no shell, minimal reads, atomic writes
+
+**User story**
+
+- As a user running the AWB MCP server  
+- I want it to never perform network calls, shell execution, or broad filesystem reads so that I can trust it in sensitive or offline environments  
+
+**Acceptance criteria**
+
+- Given the server is running  
+- When any tool is invoked  
+- Then the server does not open outbound network connections or spawn shell/child processes  
+
+- Given plan_bootstrap or apply_bootstrap is called  
+- When the server needs to check files  
+- Then it only checks existence of target paths and, if needed, reads small config files (e.g. package.json) for hints; it does not read arbitrary or sensitive paths beyond what is documented  
+
+- Given apply_bootstrap writes a file  
+- When writeMode is atomic  
+- Then content is written to a temp file and then renamed; no partial content is visible at the final path on failure  
+
+- Given a file already exists and policy says SKIP  
+- When apply_bootstrap runs  
+- Then the user sees clear warnings in the plan and the apply result reflects SKIPPED with a reason  
+
+**Edge cases**
+
+- Symlinks: document whether we follow or reject; prefer not following symlinks outside rootPath  
+- Very long paths or huge files: avoid reading large files; existence check only where sufficient  
+
+**Technical considerations**
+
+- No require('child_process') or fetch/axios; no external HTTP  
+- Atomic write: temp file in same directory as target, then rename  
+- Explicit allowlist of files that may be read for hints (e.g. package.json, pyproject.toml) in v0.2  
+
+**Design notes**
+
+- Security section of PRD is non-negotiable for MVP; tests or checklist can enforce “no network, no shell”  
+
+---
+
+### Story 7: Early deployment and validation — works on other computers
+
+**User story**
+
+- As a maintainer or a user trying the package on a clean machine  
+- I want a clear packaging, install, and validation flow so that we can confirm the server runs on other computers (Windows and macOS) and works with VS Code MCP  
+
+**Acceptance criteria**
+
+- Given the project is built and published (e.g. to npm as `awb-mcp` or installed from tarball)  
+- When another user on a clean Windows or macOS machine runs `npm i -g awb-mcp` (or equivalent)  
+- Then the install completes and the `awb-mcp` (or documented) command is on PATH  
+
+- Given the server is installed globally  
+- When the user adds the server to VS Code MCP settings (e.g. in settings.json or Cursor MCP config) with only the command path  
+- Then VS Code/Cursor can start the server over stdio and list tools  
+
+- Given the server is running in VS Code  
+- When the user (or a script) invokes `awb.plan_bootstrap` with a valid repo root  
+- Then the tool returns a valid plan (planId, operations array, no crash)  
+
+- Given a release checklist exists (in repo or docs)  
+- When preparing a release  
+- Then the checklist includes: build, pack or publish, install on clean Windows, install on clean macOS, configure VS Code MCP, run smoke test (plan_bootstrap + optional apply_bootstrap in a temp dir)  
+
+**Edge cases**
+
+- Node version: document minimum (e.g. Node 18+); package.json engines optional  
+- npx vs global install: both documented; smoke test covers at least one  
+
+**Technical considerations**
+
+- package.json: `bin` entry for the executable; `main` or type module and entrypoint that runs the MCP server  
+- Build step that produces runnable code (e.g. tsc + node, or tsx in bin); ensure dependencies are bundled or declared so install is self-contained  
+- Optional: simple smoke script (e.g. node -e "call MCP list_tools") or doc that says “run plan_bootstrap from client”  
+
+**Design notes**
+
+- Early deployment is crucial: first milestone should include “works on another machine” validation; checklist prevents regressions  
+
+---
+
+## v0.2 — Repo hints and README proposal
+
+### Story 8: detect_repo_hints and placeholder fill
+
+**User story**
+
+- As a user with an existing repo (e.g. with package.json or pyproject.toml)  
+- I want the server to run lightweight heuristics to detect hints (e.g. package manager, test command) so that bootstrap templates can be filled with sensible defaults without deep stack detection  
+
+**Acceptance criteria**
+
+- Given a repo root that contains one or more of: package.json, lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml), pyproject.toml  
+- When `awb.detect_repo_hints` (or plan_bootstrap with hint detection) runs  
+- Then the result includes a small `repoHints` object with fields such as preferred package manager, test command placeholder, or similar; no heavy or framework-specific detection  
+
+- Given repoHints are available  
+- When plan_bootstrap returns template content  
+- Then optional placeholders (e.g. `{{packageManager}}`, `{{testCommand}}`) are replaced with hint values where possible; otherwise left as safe defaults  
+
+- Given a repo with no known config files  
+- When detect runs  
+- Then repoHints is empty or has defaults; no error  
+
+**Edge cases**
+
+- Multiple lockfiles: define precedence (e.g. pnpm > yarn > npm) and document  
+- Malformed package.json: do not throw; return partial or empty hints  
+- Must not become a “stack detection framework”: only a small, fixed set of heuristics  
+
+**Technical considerations**
+
+- detect_repo_hints: read only package.json, pyproject.toml, lockfile presence; no install or parse of dependencies  
+- Keep logic in one place; call from plan_bootstrap when options request hints  
+
+**Design notes**
+
+- v0.2 scope: minimal placeholders; avoid scope creep into full stack detection  
+
+---
+
+### Story 9: Optional README proposal (separate file or patch, no overwrite by default)
+
+**User story**
+
+- As a user who has an existing README.md  
+- I want the server to optionally suggest README content or a patch (e.g. README.agentic.md or a patch output) so that I can choose whether to integrate it without ever overwriting README.md by default  
+
+**Acceptance criteria**
+
+- Given plan_bootstrap is called with includeReadmeProposal: false (default)  
+- When the plan is returned  
+- Then no readmeProposal field or README-related write is included; README.md is never in operations as an overwrite  
+
+- Given plan_bootstrap is called with includeReadmeProposal: true  
+- When the plan is returned  
+- Then the response includes a readmeProposal (e.g. suggested content or a separate file path like README.agentic.md or a patch); README.md is still not in operations unless user explicitly opts in elsewhere  
+- And the client (LLM/user) decides whether to apply any README changes  
+
+- Given the server suggests README content  
+- When the suggestion is returned  
+- Then it is clearly a proposal (e.g. “suggested addition” or separate file); default behavior never modifies README.md  
+
+**Edge cases**
+
+- No README.md exists: readmeProposal can still suggest initial README content  
+- Very long README: server may suggest a patch or appendix only; avoid loading huge files unnecessarily  
+
+**Technical considerations**
+
+- readmeProposal: string content or { path, content } for a separate file; optional patch format  
+- If README.md is ever in operations, it is only when overwritePolicy or explicit overwrite is set and documented  
+
+**Design notes**
+
+- Narrow MVP: README handling is optional and safe-by-default; no automatic overwrite  
+
+---
+
+## v0.3 — Prompt mode and optional resources (if needed)
+
+### Story 10: Prompt mode — server returns prompts and skeletons, client LLM refines
+
+**User story**
+
+- As a user who wants AI-generated bootstrap content tailored to my repo  
+- I want the server to support a “prompt” mode where it returns prompts and minimal skeleton files so that my client LLM (e.g. Copilot) can refine content before I apply it, without the server calling any external LLM  
+
+**Acceptance criteria**
+
+- Given plan_bootstrap is called with mode: "prompt"  
+- When the plan is computed  
+- Then the server returns either (a) prompts plus minimal skeleton file content, or (b) static templates with a note that the client LLM may refine them before apply  
+- And the server does not call any third-party LLM API; any generation is done by the client using the user’s model  
+
+- Given the client has refined or generated content  
+- When the user calls apply_bootstrap with the modified plan/operations  
+- Then the server applies the provided content with the same overwrite and atomic-write rules as static mode  
+
+**Edge cases**
+
+- mode "prompt" with no client LLM: user can still apply skeletons as-is  
+- Mixed mode (some static, some prompt): v0.3 can define per-file or global; keep simple  
+
+**Technical considerations**
+
+- No fetch to OpenAI/Anthropic/etc. in server; prompts are strings returned to client  
+- Client is responsible for calling LLM and passing back refined content in the plan/operations  
+
+**Design notes**
+
+- MVP: prompt mode is optional; static mode remains default and primary  
+
+---
+
+### Story 11: Optional MCP prompts and resources for client workflows
+
+**User story**
+
+- As a user or client LLM  
+- I want to discover bootstrap-related prompts and read template resources via MCP so that I can run guided workflows (e.g. “bootstrap_agentic_repo”) or preview templates without calling tools  
+
+**Acceptance criteria**
+
+- Given the server supports optional Prompts  
+- When the client lists prompts  
+- Then at least one prompt is available (e.g. bootstrap_agentic_repo) that instructs the client to call plan_bootstrap, review output, then call apply_bootstrap  
+
+- Given the server supports optional Resources  
+- When the client requests a resource URI (e.g. awb://templates/copilot-instructions.md or awb://templates/AGENTS.md)  
+- Then the server returns read-only template content for that path  
+
+- Given tools already return full template content in plan_bootstrap  
+- When implementing resources  
+- Then resources are optional; same content can be exposed via tools only  
+
+**Edge cases**
+
+- Client does not support prompts/resources: server still works with tools only  
+- Unknown resource URI: return 404 or equivalent error  
+
+**Technical considerations**
+
+- MCP Prompts: register with the SDK; bootstrap_agentic_repo and optionally draft_readme_patch  
+- MCP Resources: register template URIs; resolve to static files from package  
+
+**Design notes**
+
+- v0.3 “only if needed”; if ship is faster without resources, tools-only is acceptable  
+
+---
+
+## Coverage and consistency
+
+- All PRD MVP goals and tool contracts (plan_bootstrap, apply_bootstrap, overwrite rules, baseline scaffold, safety, distribution) are covered by v0.1 stories.  
+- v0.2 covers detect_repo_hints and README proposal.  
+- v0.3 covers prompt mode and optional prompts/resources.  
+- Early deployment (Story 7) is part of v0.1 so that “works on other computers” is validated before or with the first usable release.  
+- Acceptance criteria are written in Given/When/Then form and are testable (manual or automated).  

package/.ai/prd.md

@@ -0,0 +1,215 @@
+# PRD — Agentic Bootstrap MCP Server (working name)
+
+## 1) Summary
+
+A minimal **MCP server** that helps bootstrap an “agentic-ready” repository by **creating a small set of standard files** (e.g., `.github/copilot-instructions.md`, prompts, agents, `AGENTS.md`). The server provides **static, high-quality starter templates** and (optionally) supports **prompt-driven generation** via the client’s LLM (e.g., VS Code Copilot). The goal is to ship quickly with a narrow scope.
+
+## 2) Goals
+
+**MVP goals**
+
+- Provide an MCP server usable from **VS Code** (Windows + macOS; Linux optional).
+- Generate and/or write a baseline file set that makes a repo immediately usable with agentic workflows.
+- Keep behavior **safe-by-default**: _plan first_, then apply changes with clear overwrite rules.
+- Templates can be:
+  - **Static** (prefilled content shipped with the server), and/or
+  - **Prompt-driven** (server supplies prompts; the client LLM produces content).
+
+**Non-goals (MVP)**
+
+- No remote downloads / resource pack syncing
+- No shell/git command execution “recipes”
+- No PR creation or GitHub integration
+- No deep stack detection or extensive customization packs
+- No background automation
+
+## 3) Target users & environment
+
+- Users working in **VS Code** with an MCP-capable agent/chat client.
+- Primary platforms: **Windows + macOS** (Linux optional).
+- Works in any repo/stack (templates are generic and useful everywhere).
+
+## 4) Product shape: MCP server capabilities
+
+The MCP server exposes **Tools**, optional **Prompts**, and optional **Resources**:
+
+### Tools (MVP)
+
+1. `awb.plan_bootstrap`
+
+- Purpose: compute a deterministic plan of file operations (create/update/skip).
+- Output includes full file contents (static templates), plus warnings when files already exist.
+
+2. `awb.apply_bootstrap`
+
+- Purpose: apply a previously returned plan to disk (atomic writes, idempotent behavior).
+- Server enforces overwrite policy; never blindly clobbers existing user content unless explicitly allowed.
+
+_(Optional but still “small”)_ 3) `awb.detect_repo_hints`
+
+- Purpose: very lightweight heuristics (presence of lockfiles, `package.json`, `pyproject.toml`, etc.) to fill small placeholders like “preferred package manager” in templates.
+- Must not turn into full “stack detection framework.”
+
+### Prompts (MVP, optional)
+
+- `bootstrap_agentic_repo`: a prompt that instructs the client LLM to call `plan_bootstrap`, review output, then call `apply_bootstrap`.
+- `draft_readme_patch`: optional prompt for the client LLM to propose a README patch based on existing README + repo hints.
+
+### Resources (MVP, optional)
+
+- Expose template files as MCP “resources” (read-only), e.g.:
+  - `awb://templates/copilot-instructions.md`
+  - `awb://templates/AGENTS.md`
+    This is optional if your tools already return templates.
+
+## 5) Baseline scaffold (MVP)
+
+The server supports generating the following tree:
+
+```
+.github/
+  copilot-instructions.md
+  instructions/
+    general.instructions.md
+    testing.instructions.md
+  prompts/
+    readme.prompt.md
+    onboarding.prompt.md
+    change-summary.prompt.md
+  agents/
+    architect.agent.md
+    implementer.agent.md
+    reviewer.agent.md
+AGENTS.md
+```
+
+### Template content strategy (MVP)
+
+- Templates are **generic**, high-signal, and safe:
+  - emphasize “don’t guess,” “prefer repo scripts,” “write tests,” “avoid destructive commands”
+
+- Keep placeholders minimal and optional (e.g., `{{packageManager}}`, `{{testCommand}}`) filled via `detect_repo_hints` or left as defaults.
+
+## 6) Generation modes
+
+### Mode A: Static templates (default)
+
+- `plan_bootstrap` returns prefilled content for all files.
+- Fast, deterministic, easiest to ship.
+
+### Mode B: Prompt-driven content (optional)
+
+- Server returns:
+  - either (a) prompts + minimal skeleton files, or
+  - (b) static templates that the client LLM is encouraged to refine before applying.
+
+- **Important:** In MVP, the MCP server itself does **not** call third-party LLM APIs.
+  - Any “LLM generation” happens in the **client** (e.g., Copilot), using the user’s configured model/provider.
+
+## 7) README handling (narrow MVP)
+
+- If `README.md` exists, the server **does not modify it** by default.
+- Optional flag to include a README suggestion:
+  - `plan_bootstrap` can return a _separate_ proposed patch (or a new `README.agentic.md`) rather than overwriting `README.md`.
+
+- The client (LLM/user) decides whether to apply README changes.
+
+## 8) Overwrite & idempotency rules (MVP)
+
+- If a target file **does not exist** → `CREATE`
+- If it **exists** → default `SKIP`, unless:
+  - file contains an **AWB managed block** marker, or
+  - user passes `overwrite: true` for that specific file
+
+## 9) Tool contracts (MVP)
+
+### 9.1 `awb.plan_bootstrap`
+
+**Input**
+
+- `rootPath`: string (repo/workspace root)
+- `options` (optional):
+  - `mode`: `"static"` | `"prompt"` (default `"static"`)
+  - `includeReadmeProposal`: boolean (default `false`)
+  - `overwritePolicy`: `"skip"` | `"managed-only"` | `"overwrite"` (default `"managed-only"`)
+  - `files`: optional allowlist of paths to generate (to keep scope minimal)
+
+**Output**
+
+- `planId`: string
+- `operations[]`:
+  - `path`
+  - `action`: `CREATE` | `UPDATE_MANAGED` | `SKIP`
+  - `content` (when CREATE/UPDATE_MANAGED)
+  - `reason` (especially for SKIP)
+  - `warnings[]` (e.g., “file exists; not overwriting”)
+
+- `repoHints` (optional): from detect logic
+- `readmeProposal` (optional): separate content/patch suggestion
+
+### 9.2 `awb.apply_bootstrap`
+
+**Input**
+
+- `rootPath`
+- `planId`
+- `operations[]` (echo back from plan; server can validate)
+- `applyOptions` (optional):
+  - `dryRun`: boolean
+  - `writeMode`: `"atomic"` (default)
+  - `failOnConflict`: boolean (default true)
+
+**Output**
+
+- `results[]`:
+  - `path`
+  - `status`: `WRITTEN` | `SKIPPED` | `FAILED`
+  - `details`
+
+## 10) Security & safety (MVP)
+
+- No network calls required.
+- No shell execution.
+- No reading sensitive files beyond what’s needed to check existence and optionally read small config files for hints (e.g., `package.json`).
+- Writes are atomic (temp file + rename).
+- Clear warnings when files exist.
+
+## 11) Distribution & deployment (ship-fast)
+
+### Packaging recommendation (fastest)
+
+- Implement in **Node + TypeScript** using the official MCP SDK.
+- Publish to npm as: `awb-mcp` (working name)
+- Provide a single executable entrypoint that starts the MCP server over stdio.
+
+### Install / run
+
+- `npm i -g awb-mcp`
+- Configure VS Code MCP settings to launch `awb-mcp` as a server (stdio).
+- Keep configuration minimal: just the command path.
+
+### Versioning
+
+- SemVer, but start `0.x` while iterating quickly.
+
+## 12) Success metrics (MVP)
+
+- Time-to-bootstrap: user can scaffold in < 1 minute.
+- Idempotency: second run produces zero unexpected changes.
+- Safety: no accidental overwrites; clear SKIP behavior.
+
+## 13) MVP milestones (tight)
+
+- **v0.1**
+  - MCP server runs in VS Code
+  - `plan_bootstrap` + `apply_bootstrap`
+  - static templates, managed-block support, atomic writes
+
+- **v0.2**
+  - optional `detect_repo_hints` + placeholder fill
+  - optional README proposal (separate file or patch output)
+
+- **v0.3 (only if needed)**
+  - “prompt mode” where server returns prompt(s) + skeletons (client LLM refines)
+
+---

package/.cursor/commands/implement-us.md

@@ -0,0 +1,24 @@
+You are an implementation-focused coding agent working in this repo.
+
+## Source of truth
+
+Use `@.ai/backlog.md` as the authoritative spec. Do not re-ask for requirements that are already in the story.
+
+## Task
+
+Implement Story [N] from `@.ai/backlog.md`. Use subagent to gather info about user story.
+
+## Operating rules
+
+- First, open `@.ai/backlog.md`, locate Story [N], and copy its Acceptance Criteria into a checklist.
+- Treat “Edge Cases”, “Technical Considerations”, “Design Notes”, and “Feature context” as hard constraints.
+- Safe by default. Avoid destructive actions unless the story explicitly requires them.
+- Don’t guess: inspect existing code/scripts/config before choosing an approach. If something is unclear, state assumptions explicitly and proceed with the most conservative option.
+
+- Find the correct integration points in the current codebase (minimize new architecture).
+- Implement the smallest end-to-end change that satisfies all Acceptance Criteria and Edge Cases.
+- Add/update tests as appropriate; run relevant build/lint/test commands.
+
+## Done means
+
+- Provide a final summary mapping: each Acceptance Criterion → where/how it’s satisfied.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,128 @@
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import z from "zod";
+// Process-level safety: avoid ungraceful exit on uncaught errors (e.g. malformed JSON)
+// SDK transport already catches parse errors; these handlers are a last resort.
+process.on("uncaughtException", (err) => {
+    console.error("[awb-mcp] uncaughtException:", err?.message ?? err);
+    process.exitCode = 1;
+    setTimeout(() => process.exit(1), 100);
+});
+process.on("unhandledRejection", (reason, promise) => {
+    console.error("[awb-mcp] unhandledRejection:", reason);
+    process.exitCode = 1;
+    setTimeout(() => process.exit(1), 100);
+});
+const server = new McpServer({
+    name: "awb-mcp",
+    version: "0.0.1",
+    description: "AWB MCP Server — bootstrap agentic-ready repos via MCP",
+});
+function validateRootPath(rootPath) {
+    if (rootPath === undefined || rootPath === null) {
+        return { ok: false, error: "rootPath is required and must be a non-empty string." };
+    }
+    if (typeof rootPath !== "string") {
+        return { ok: false, error: "rootPath must be a string." };
+    }
+    const trimmed = rootPath.trim();
+    if (trimmed === "") {
+        return { ok: false, error: "rootPath cannot be empty." };
+    }
+    let resolved;
+    try {
+        resolved = path.resolve(trimmed);
+    }
+    catch {
+        return { ok: false, error: `rootPath could not be resolved: ${trimmed}` };
+    }
+    if (!fs.existsSync(resolved)) {
+        return { ok: false, error: `rootPath does not exist: ${resolved}` };
+    }
+    try {
+        const stat = fs.statSync(resolved);
+        if (!stat.isDirectory()) {
+            return { ok: false, error: `rootPath is not a directory: ${resolved}` };
+        }
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { ok: false, error: `rootPath could not be read: ${msg}` };
+    }
+    return { ok: true, resolved };
+}
+function errorContent(text) {
+    return { content: [{ type: "text", text }] };
+}
+const PlanBootstrapInputSchema = z.object({
+    rootPath: z.string().min(1, "rootPath is required"),
+});
+const ApplyBootstrapInputSchema = z.object({
+    rootPath: z.string().min(1, "rootPath is required"),
+    planId: z.string(),
+    operations: z.array(z.unknown()).optional(),
+});
+server.registerTool("awb.plan_bootstrap", {
+    title: "Plan Bootstrap",
+    description: "Compute a deterministic plan of file operations (create/update/skip) for bootstrapping an agentic-ready repo. Full implementation in Story 2.",
+    inputSchema: PlanBootstrapInputSchema,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    const parsed = PlanBootstrapInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return errorContent(`Invalid input: ${parsed.error.message}`);
+    }
+    const { rootPath } = parsed.data;
+    const validation = validateRootPath(rootPath);
+    if (!validation.ok) {
+        return errorContent(`Error: ${validation.error}`);
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `plan_bootstrap stub: rootPath validated (${validation.resolved}). Full plan generation is implemented in Story 2.`,
+            },
+        ],
+    };
+});
+server.registerTool("awb.apply_bootstrap", {
+    title: "Apply Bootstrap",
+    description: "Apply a previously returned bootstrap plan to disk (atomic writes). Full implementation in Story 3.",
+    inputSchema: ApplyBootstrapInputSchema,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    const parsed = ApplyBootstrapInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return errorContent(`Invalid input: ${parsed.error.message}`);
+    }
+    const { rootPath } = parsed.data;
+    const validation = validateRootPath(rootPath);
+    if (!validation.ok) {
+        return errorContent(`Error: ${validation.error}`);
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `apply_bootstrap stub: rootPath validated (${validation.resolved}). No files written. Full apply is implemented in Story 3.`,
+            },
+        ],
+    };
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@kamkom/awb-mcp",
+  "version": "0.0.1",
+  "description": "AWB MCP Server — bootstrap agentic-ready repos via MCP",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "awb-mcp": "dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "npx tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "tsx": "^4.19.2",
+    "typescript": "^5.8.2",
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.2",
+    "tsx": "^4.19.2",
+    "@types/node": "^22.13.10"
+  }
+}

package/src/index.ts

@@ -0,0 +1,142 @@
+import process from "node:process";
+import fs from "node:fs";
+import path from "node:path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import z from "zod";
+
+// Process-level safety: avoid ungraceful exit on uncaught errors (e.g. malformed JSON)
+// SDK transport already catches parse errors; these handlers are a last resort.
+process.on("uncaughtException", (err) => {
+  console.error("[awb-mcp] uncaughtException:", err?.message ?? err);
+  process.exitCode = 1;
+  setTimeout(() => process.exit(1), 100);
+});
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("[awb-mcp] unhandledRejection:", reason);
+  process.exitCode = 1;
+  setTimeout(() => process.exit(1), 100);
+});
+
+const server = new McpServer({
+  name: "awb-mcp",
+  version: "0.0.1",
+  description: "AWB MCP Server — bootstrap agentic-ready repos via MCP",
+});
+
+function validateRootPath(rootPath: unknown): { ok: true; resolved: string } | { ok: false; error: string } {
+  if (rootPath === undefined || rootPath === null) {
+    return { ok: false, error: "rootPath is required and must be a non-empty string." };
+  }
+  if (typeof rootPath !== "string") {
+    return { ok: false, error: "rootPath must be a string." };
+  }
+  const trimmed = rootPath.trim();
+  if (trimmed === "") {
+    return { ok: false, error: "rootPath cannot be empty." };
+  }
+  let resolved: string;
+  try {
+    resolved = path.resolve(trimmed);
+  } catch {
+    return { ok: false, error: `rootPath could not be resolved: ${trimmed}` };
+  }
+  if (!fs.existsSync(resolved)) {
+    return { ok: false, error: `rootPath does not exist: ${resolved}` };
+  }
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) {
+      return { ok: false, error: `rootPath is not a directory: ${resolved}` };
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: `rootPath could not be read: ${msg}` };
+  }
+  return { ok: true, resolved };
+}
+
+function errorContent(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+const PlanBootstrapInputSchema = z.object({
+  rootPath: z.string().min(1, "rootPath is required"),
+});
+
+const ApplyBootstrapInputSchema = z.object({
+  rootPath: z.string().min(1, "rootPath is required"),
+  planId: z.string(),
+  operations: z.array(z.unknown()).optional(),
+});
+
+server.registerTool(
+  "awb.plan_bootstrap",
+  {
+    title: "Plan Bootstrap",
+    description: "Compute a deterministic plan of file operations (create/update/skip) for bootstrapping an agentic-ready repo. Full implementation in Story 2.",
+    inputSchema: PlanBootstrapInputSchema,
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  async (args) => {
+    const parsed = PlanBootstrapInputSchema.safeParse(args);
+    if (!parsed.success) {
+      return errorContent(`Invalid input: ${parsed.error.message}`);
+    }
+    const { rootPath } = parsed.data;
+    const validation = validateRootPath(rootPath);
+    if (!validation.ok) {
+      return errorContent(`Error: ${validation.error}`);
+    }
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `plan_bootstrap stub: rootPath validated (${validation.resolved}). Full plan generation is implemented in Story 2.`,
+        },
+      ],
+    };
+  },
+);
+
+server.registerTool(
+  "awb.apply_bootstrap",
+  {
+    title: "Apply Bootstrap",
+    description: "Apply a previously returned bootstrap plan to disk (atomic writes). Full implementation in Story 3.",
+    inputSchema: ApplyBootstrapInputSchema,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  async (args) => {
+    const parsed = ApplyBootstrapInputSchema.safeParse(args);
+    if (!parsed.success) {
+      return errorContent(`Invalid input: ${parsed.error.message}`);
+    }
+    const { rootPath } = parsed.data;
+    const validation = validateRootPath(rootPath);
+    if (!validation.ok) {
+      return errorContent(`Error: ${validation.error}`);
+    }
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `apply_bootstrap stub: rootPath validated (${validation.resolved}). No files written. Full apply is implemented in Story 3.`,
+        },
+      ],
+    };
+  },
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}