@gitwhy-cli/whyspec 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gitwhy-cli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/gitwhy-cli/whyspec/main/assets/banner.png" alt="WhySpec — The Reasoning Layer" width="100%">
+</p>
+
+<p align="center">
+  <strong>Built by <a href="https://gitwhy.dev">GitWhy</a> with ❤️</strong>
+</p>
+
+<p align="center">
+  <a href="https://github.com/gitwhy-cli/whyspec/actions/workflows/ci.yml"><img src="https://github.com/gitwhy-cli/whyspec/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://github.com/gitwhy-cli/whyspec/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="license"></a>
+  <a href="https://discord.gg/2X5X5XeFyT"><img src="https://img.shields.io/badge/discord-join-5865F2?logo=discord&logoColor=white" alt="Discord"></a>
+</p>
+
+**Spec-driven development that captures reasoning.**
+
+A spec-driven context engineering framework for AI coding agents like Claude Code, Cursor, Copilot, and more.
+
+## Our Vision
+
+> Code tells you **what** was built. Tests tell you **how** it works. Only reasoning tells you **why** it exists.
+
+- **Plan before coding** — surface decisions upfront
+- **Capture after coding** — record what actually happened
+- **Track the delta** — see what changed and what surprised you
+
+In an era where AI writes most of the code, the human contribution isn't the syntax — it's the judgment. WhySpec preserves that judgment so it survives beyond the chat session that created it.
+
+## See it in action
+
+```
+You: /whyspec:plan add-jwt-auth
+AI:  Created .gitwhy/changes/add-jwt-auth/
+     ✓ intent.md  — why this change exists
+     ✓ design.md  — approach + 3 decisions to make
+     ✓ tasks.md   — verification-first checklist
+     Decision Bridge: 3 open questions to resolve.
+
+You: /whyspec:execute add-jwt-auth
+AI:  Implementing with full context...
+     ✓ 1. Add token verification middleware
+     ✓ 2. Create login endpoint with bcrypt
+     ✓ 3. Wire up protected routes
+     All tasks complete! 3 decisions resolved.
+
+You: /whyspec:capture add-jwt-auth
+AI:  Decision Bridge resolved:
+     ✓ Token storage: httpOnly cookie (XSS > CSRF)
+     ✓ Hashing: bcrypt (Node.js ecosystem)
+     ⚠ SURPRISE: Added 2FA (security review)
+     Saved to ctx_a1b2c3d4.md
+```
+
+## Install
+
+```bash
+npm install -g @gitwhy-cli/whyspec
+```
+
+## Quick Start
+
+```bash
+cd your-project
+whyspec init                        # Set up WhySpec
+# Then use /whyspec:plan in Claude Code, or /whyspec-plan in Cursor
+```
+
+That's it. WhySpec teaches your AI agent to plan before coding and capture reasoning after.
+
+## Docs
+
+→ [Getting Started](docs/getting-started.md): first steps<br>
+→ [Commands](docs/commands.md): slash commands & skills<br>
+→ [CLI](docs/cli.md): terminal reference<br>
+→ [Concepts](docs/concepts.md): Decision Bridge, context IDs, philosophy<br>
+→ [Supported Agents](docs/supported-tools.md): agent integrations & install paths<br>
+→ [Workflows](docs/workflows.md): common patterns<br>
+→ [GitWhy Integration](docs/gitwhy.md): SaaS platform & team sharing
+
+## Cross-Agent Support
+
+| AI Agent | Integration | How |
+|---------|------------|-----|
+| **Claude Code** | Native skills | `.claude/skills/whyspec-*/SKILL.md` |
+| **Cursor** | Slash commands | `.cursor/commands/whyspec-*.md` |
+| **GitHub Copilot** | Project instructions | `AGENTS.md` |
+| **Codex CLI** | Project instructions | `AGENTS.md` |
+| **Windsurf** | Project instructions | `AGENTS.md` |
+| **Cline** | Project instructions | `AGENTS.md` |
+| **Amazon Q** | Project instructions | `AGENTS.md` |
+| **RooCode** | Project instructions | `AGENTS.md` |
+
+Run `whyspec init` and select your tools. WhySpec generates the right config for each.
+
+## Works With
+
+WhySpec is complementary to existing AI coding tools. It fills the reasoning gap they leave open.
+
+| Tool | What it owns | WhySpec adds |
+|------|-------------|--------------|
+| **OpenSpec** | Planning before code | Reasoning capture *after* code |
+| **GSD** | Deep planning + execution | Decision Bridge: plan vs outcome tracking |
+| **gstack** | Sprint lifecycle (review, QA, ship) | Persistent WHY behind each change |
+
+WhySpec works **alongside** all three. Use them for planning and execution. Use WhySpec for reasoning.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, testing, and PR guidelines.
+
+## License
+
+[MIT](LICENSE) -- free forever. Go capture some reasoning.

package/dist/adapters/agents-md.d.ts

@@ -0,0 +1,13 @@
+import { GeneratedFile } from "./types.js";
+/**
+ * Generate AGENTS.md for AI tools that read project-root instruction files.
+ *
+ * Targets: GitHub Copilot, Windsurf, Cline, Amazon Q, RooCode, Codex CLI.
+ * Single comprehensive file with CLI-as-oracle pattern, example workflow,
+ * and Decision Bridge explanation.
+ *
+ * @param projectRoot - Optional project root prefix for paths (default: "")
+ * @returns Array of GeneratedFile objects (always 1 file)
+ */
+export declare function generateAgentsMd(projectRoot?: string): GeneratedFile[];
+//# sourceMappingURL=agents-md.d.ts.map

package/dist/adapters/agents-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-md.d.ts","sourceRoot":"","sources":["../../src/adapters/agents-md.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAGd,MAAM,YAAY,CAAC;AAsJpB;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,GAAE,MAAW,GACvB,aAAa,EAAE,CASjB"}

package/dist/adapters/agents-md.js

@@ -0,0 +1,165 @@
+import { WHYSPEC_COMMANDS, COMMAND_DESCRIPTIONS, } from "./types.js";
+/**
+ * Generate the AGENTS.md content.
+ *
+ * This single file is read by GitHub Copilot, Windsurf, Cline, Amazon Q,
+ * RooCode, Codex CLI, and other AI coding agents that look for project-root
+ * instruction files.
+ */
+function getAgentsMdContent() {
+    // Build the commands table
+    const commandRows = WHYSPEC_COMMANDS.map((cmd) => `| \`whyspec ${cmd} --json\` | ${COMMAND_DESCRIPTIONS[cmd]} |`).join("\n");
+    return `# WhySpec — The Reasoning Layer for AI Coding
+
+WhySpec captures WHY code was built the way it was, not just what was built or how to build it. It tracks how reasoning evolves from intent to outcome through the **Decision Bridge**: the plan PREDICTS decisions before coding, the capture RECORDS decisions after coding, and the delta reveals what was anticipated, what changed, and what was surprising.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+${commandRows}
+
+## How to Use WhySpec (CLI-as-Oracle Pattern)
+
+WhySpec follows the CLI-as-oracle pattern: call the CLI with \`--json\` and parse the structured response. The CLI handles path creation, validation, and project context. You handle content generation.
+
+### Calling the CLI
+
+Always use the \`--json\` flag when calling WhySpec commands:
+
+\`\`\`bash
+whyspec plan --json "add-jwt-auth"
+\`\`\`
+
+Example JSON response:
+
+\`\`\`json
+{
+  "path": ".gitwhy/changes/add-jwt-auth",
+  "templates": {
+    "intent": "## Why This Change Exists\\n...",
+    "design": "## Approach\\n...",
+    "tasks": "## Verification\\n..."
+  },
+  "context": { "project": "my-app", "branch": "feat/auth" }
+}
+\`\`\`
+
+Parse the response and use the returned paths and templates to create or read files.
+
+### Reading CLI Output
+
+\`\`\`bash
+# Get execution context (reads plan files)
+whyspec execute --json "add-jwt-auth"
+
+# Get capture template with linked commits
+whyspec capture --json "add-jwt-auth"
+
+# View full change story with Decision Bridge delta
+whyspec show --json "add-jwt-auth"
+
+# Search past decisions
+whyspec search --json "token expiry"
+
+# Create debug session with related contexts
+whyspec debug --json "login-fails-safari"
+\`\`\`
+
+## Example Workflow: Plan, Execute, Capture
+
+### Step 1: Plan (before coding)
+
+\`\`\`bash
+whyspec plan --json "add-jwt-auth"
+\`\`\`
+
+Ask the developer forcing questions, then create three files:
+- **intent.md** — Why this change exists, decisions to make, success criteria
+- **design.md** — Technical approach, trade-offs, questions to resolve
+- **tasks.md** — Verification criteria first, then implementation checklist
+
+The "Decisions to Make" section in design.md is the BEFORE side of the Decision Bridge:
+\`\`\`markdown
+## Decisions to Make
+- [ ] Token storage: cookie vs localStorage?
+- [ ] Hashing algorithm: bcrypt vs argon2?
+- [ ] Session model: JWT vs server-side?
+\`\`\`
+
+### Step 2: Execute (during coding)
+
+\`\`\`bash
+whyspec execute --json "add-jwt-auth"
+\`\`\`
+
+Read intent.md and design.md for context. Work through tasks.md, marking each task complete. Commit atomically per task.
+
+### Step 3: Capture (after coding)
+
+\`\`\`bash
+whyspec capture --json "add-jwt-auth"
+\`\`\`
+
+Record the reasoning behind what was built:
+- Map each "Decision to Make" → "Decision Made" with rationale
+- Capture surprises — decisions NOT in the original plan
+- Include rejected alternatives and trade-offs
+
+The AFTER side of the Decision Bridge:
+\`\`\`markdown
+## Decisions Made
+- [x] Token storage: httpOnly cookie — XSS protection outweighs CSRF complexity
+- [x] Hashing: bcrypt — Better library support in Node.js ecosystem
+- [x] JWT (stateless) — No session store needed for MVP
+SURPRISE: Added 2FA — Security review required it (not in original plan)
+\`\`\`
+
+## The Decision Bridge
+
+The Decision Bridge is WhySpec's core differentiator. It tracks how decisions evolve:
+
+| Phase | What it captures | File |
+|-------|-----------------|------|
+| **Before** (plan) | Decisions TO MAKE — questions, options, trade-offs | design.md |
+| **After** (capture) | Decisions MADE — choices, rationale, surprises | ctx_*.md |
+| **Delta** (show) | What changed — anticipated vs actual vs surprising | computed |
+
+Use \`whyspec show --json "<name>"\` to see the full Decision Bridge delta for any change.
+
+## Debugging with WhySpec
+
+WhySpec debug sessions follow the scientific method:
+
+1. **Symptoms** — Expected vs actual behavior
+2. **Past context search** — Check if anyone reasoned about this area before
+3. **Hypotheses** — 3+ falsifiable hypotheses
+4. **Investigation** — Test each hypothesis with evidence
+5. **Root cause** — Prove diagnosis before fixing (Iron Law: no fix without root cause)
+6. **Fix and capture** — Apply fix, then capture the debugging reasoning
+
+---
+
+*This file is read by GitHub Copilot, Windsurf, Cline, Amazon Q, RooCode, Codex CLI, and other AI coding agents that support project-level instruction files.*
+`;
+}
+/**
+ * Generate AGENTS.md for AI tools that read project-root instruction files.
+ *
+ * Targets: GitHub Copilot, Windsurf, Cline, Amazon Q, RooCode, Codex CLI.
+ * Single comprehensive file with CLI-as-oracle pattern, example workflow,
+ * and Decision Bridge explanation.
+ *
+ * @param projectRoot - Optional project root prefix for paths (default: "")
+ * @returns Array of GeneratedFile objects (always 1 file)
+ */
+export function generateAgentsMd(projectRoot = "") {
+    const prefix = projectRoot ? `${projectRoot}/` : "";
+    return [
+        {
+            path: `${prefix}AGENTS.md`,
+            content: getAgentsMdContent(),
+        },
+    ];
+}
+//# sourceMappingURL=agents-md.js.map

package/dist/adapters/agents-md.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-md.js","sourceRoot":"","sources":["../../src/adapters/agents-md.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,SAAS,kBAAkB;IACzB,2BAA2B;IAC3B,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CACtC,CAAC,GAAG,EAAE,EAAE,CAAC,eAAe,GAAG,eAAe,oBAAoB,CAAC,GAAG,CAAC,IAAI,CACxE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEb,OAAO;;;;;;;;EAQP,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4HZ,CAAC;AACF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,cAAsB,EAAE;IAExB,MAAM,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAEpD,OAAO;QACL;YACE,IAAI,EAAE,GAAG,MAAM,WAAW;YAC1B,OAAO,EAAE,kBAAkB,EAAE;SAC9B;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/claude-code.d.ts

@@ -0,0 +1,13 @@
+import { GeneratedFile } from "./types.js";
+/**
+ * Generate Claude Code skill files for all 6 WhySpec commands.
+ *
+ * Creates .claude/skills/whyspec-<command>/SKILL.md with:
+ * - YAML frontmatter (name, description)
+ * - Placeholder instructions showing the CLI-as-oracle pattern
+ *
+ * @param projectRoot - Optional project root prefix for paths (default: "")
+ * @returns Array of GeneratedFile objects
+ */
+export declare function generateClaudeCodeSkills(projectRoot?: string): GeneratedFile[];
+//# sourceMappingURL=claude-code.d.ts.map

package/dist/adapters/claude-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../src/adapters/claude-code.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAId,MAAM,YAAY,CAAC;AAyLpB;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,GAAE,MAAW,GACvB,aAAa,EAAE,CAmBjB"}

package/dist/adapters/claude-code.js

@@ -0,0 +1,206 @@
+import { WHYSPEC_COMMANDS, COMMAND_DESCRIPTIONS, } from "./types.js";
+/**
+ * Generate the placeholder instructions for each WhySpec command skill.
+ * These are filled with real content by Agent 5 (skill authoring).
+ * The placeholders show the CLI-as-oracle pattern so the skill is functional
+ * even before Agent 5 enriches it.
+ */
+function getSkillInstructions(command) {
+    switch (command) {
+        case "plan":
+            return `# WhySpec Plan
+
+Use this skill when the developer wants to plan a change before coding.
+
+## Workflow
+
+1. Ask the developer 2-3 forcing questions:
+   - "What problem does this solve?"
+   - "What constraints exist?"
+   - "How will you know it works?"
+
+2. Call the CLI to create the change folder:
+   \`\`\`bash
+   whyspec plan --json "<change-name>"
+   \`\`\`
+
+3. Parse the JSON response to get the folder path and templates.
+
+4. Create three files in the change folder:
+   - **intent.md** — Why this change exists, decisions to make, constraints, success criteria
+   - **design.md** — Technical approach, trade-off matrix, architecture, questions to resolve
+   - **tasks.md** — Verification criteria (defined FIRST), then implementation checklist
+
+5. The "Decisions to Make" section in design.md is the BEFORE side of the Decision Bridge.
+   These will be resolved by /whyspec:capture after implementation.
+
+## Important
+- Always call the CLI first — it handles path creation and validation.
+- Capture COMPLETE reasoning, not abbreviated summaries.
+- Every decision-to-make should be a checkbox: \`- [ ] Token storage: cookie vs localStorage?\``;
+        case "execute":
+            return `# WhySpec Execute
+
+Use this skill when the developer wants to implement a planned change.
+
+## Workflow
+
+1. Call the CLI to get the execution context:
+   \`\`\`bash
+   whyspec execute --json "<change-name>"
+   \`\`\`
+
+2. Parse the JSON response to get intent, design, tasks, and progress.
+
+3. Read intent.md and design.md for WHY context — understand the goal before coding.
+
+4. Work through tasks.md sequentially:
+   - Show progress: "Working on task 3/7: <description>"
+   - Implement the code changes
+   - Mark each task complete: \`- [ ]\` → \`- [x]\` in tasks.md
+   - Commit atomically (one commit per task or logical unit)
+
+5. On completion, prompt: "Ready to capture reasoning? Run /whyspec:capture"
+
+## Important
+- Use intent.md as context while implementing — it contains the WHY.
+- Track deviations from the plan — surprises are valuable for capture.
+- Do not skip tasks or mark them done without implementing.`;
+        case "capture":
+            return `# WhySpec Capture
+
+Use this skill when the developer wants to save reasoning after coding.
+
+## Workflow
+
+1. Call the CLI to get the capture template and metadata:
+   \`\`\`bash
+   whyspec capture --json "<change-name>"
+   \`\`\`
+
+2. Parse the JSON response to get the template, linked commits, and files changed.
+
+3. Read intent.md and design.md from the change folder.
+
+4. Create a ctx_<id>.md file in the change folder using the GitWhy SaaS XML format:
+   - Map each "Decision to Make" from design.md → "Decisions Made" with rationale
+   - Map each "Question to Resolve" → resolved answer
+   - Capture "Surprises" — decisions NOT in the plan
+   - Include story, rejected alternatives, trade-offs, verification, risks
+
+5. This completes the Decision Bridge: plan PREDICTED decisions, capture RECORDS them.
+
+## Important
+- The context file uses \`<context>\` XML tags (GitWhy SaaS format).
+- Include ALL decisions, not just the ones from the plan.
+- Surprises (unplanned decisions) are the most valuable part of the capture.`;
+        case "show":
+            return `# WhySpec Show
+
+Use this skill when the developer wants to view the full story of a change.
+
+## Workflow
+
+1. Call the CLI to get the full change data:
+   \`\`\`bash
+   whyspec show --json "<change-name>"
+   \`\`\`
+
+2. Parse the JSON response containing intent, design, tasks, context, and Decision Bridge delta.
+
+3. Display the change story in sections:
+   - **Intent** — WHY (from intent.md)
+   - **Design** — HOW (from design.md)
+   - **Tasks** — WHAT (from tasks.md with completion status)
+   - **Context** — REASONING (from ctx_<id>.md)
+   - **Decision Bridge Delta** — Decisions to Make vs Decisions Made, highlighting changes and surprises
+
+## Important
+- The Decision Bridge delta is the unique value — always show it.
+- If context hasn't been captured yet, show intent + design + tasks and suggest running /whyspec:capture.`;
+        case "search":
+            return `# WhySpec Search
+
+Use this skill when the developer wants to find past decisions and reasoning.
+
+## Workflow
+
+1. Call the CLI to search across all changes:
+   \`\`\`bash
+   whyspec search --json "<query>"
+   \`\`\`
+
+2. Parse the JSON response containing scored results with snippets.
+
+3. Display results ranked by relevance:
+   - Title matches score highest (100 points)
+   - Reasoning/decision matches score next (30 points)
+   - File path matches score lower (20 points)
+
+4. For each result, show: title, change name, score, and a relevant snippet.
+
+## Important
+- Search covers both active changes and archived ones.
+- Search also finds intent.md and design.md — not just captured contexts.
+- Use this before starting new work: "Has anyone reasoned about this area before?"`;
+        case "debug":
+            return `# WhySpec Debug
+
+Use this skill when the developer is investigating a bug.
+
+## Workflow
+
+1. Call the CLI to create a debug session:
+   \`\`\`bash
+   whyspec debug --json "<bug-description>"
+   \`\`\`
+
+2. Parse the JSON response to get the debug folder path and related past contexts.
+
+3. Follow the scientific method:
+   - **Symptoms** — Expected vs actual behavior, error messages, reproduction steps
+   - **Related contexts** — Search past decisions in this area (from CLI response)
+   - **Hypotheses** — Form 3+ falsifiable hypotheses with "what would prove this wrong?"
+   - **Investigation** — Test each hypothesis with evidence gathering
+   - **Root cause** — Prove the diagnosis BEFORE proposing a fix (Iron Law)
+   - **Fix** — Apply the fix and verify
+   - **Prevention** — How to prevent this class of bug in the future
+
+4. Create debug.md with the full investigation trail.
+
+5. Auto-prompt: "Ready to capture debug reasoning? Run /whyspec:capture"
+
+## Important
+- No fix without root cause — this is the Iron Law.
+- Check related past contexts BEFORE forming hypotheses — past decisions inform better hypotheses.
+- The debug.md persists across sessions so investigation survives context resets.`;
+    }
+}
+/**
+ * Generate Claude Code skill files for all 6 WhySpec commands.
+ *
+ * Creates .claude/skills/whyspec-<command>/SKILL.md with:
+ * - YAML frontmatter (name, description)
+ * - Placeholder instructions showing the CLI-as-oracle pattern
+ *
+ * @param projectRoot - Optional project root prefix for paths (default: "")
+ * @returns Array of GeneratedFile objects
+ */
+export function generateClaudeCodeSkills(projectRoot = "") {
+    const prefix = projectRoot ? `${projectRoot}/` : "";
+    return WHYSPEC_COMMANDS.map((command) => {
+        const frontmatter = [
+            "---",
+            `name: whyspec-${command}`,
+            `description: ${COMMAND_DESCRIPTIONS[command]}`,
+            "---",
+        ].join("\n");
+        const instructions = getSkillInstructions(command);
+        const content = `${frontmatter}\n\n${instructions}\n`;
+        return {
+            path: `${prefix}.claude/skills/whyspec-${command}/SKILL.md`,
+            content,
+        };
+    });
+}
+//# sourceMappingURL=claude-code.js.map

package/dist/adapters/claude-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.js","sourceRoot":"","sources":["../../src/adapters/claude-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAChB,oBAAoB,GAErB,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,OAAuB;IACnD,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,MAAM;YACT,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gGA6BmF,CAAC;QAE7F,KAAK,SAAS;YACZ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;4DA0B+C,CAAC;QAEzD,KAAK,SAAS;YACZ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;6EA0BgE,CAAC;QAE1E,KAAK,MAAM;YACT,OAAO;;;;;;;;;;;;;;;;;;;;;;0GAsB6F,CAAC;QAEvG,KAAK,QAAQ;YACX,OAAO;;;;;;;;;;;;;;;;;;;;;;;mFAuBsE,CAAC;QAEhF,KAAK,OAAO;YACV,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kFA6BqE,CAAC;IACjF,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CACtC,cAAsB,EAAE;IAExB,MAAM,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAEpD,OAAO,gBAAgB,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QACtC,MAAM,WAAW,GAAG;YAClB,KAAK;YACL,iBAAiB,OAAO,EAAE;YAC1B,gBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;YAC/C,KAAK;SACN,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEb,MAAM,YAAY,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;QACnD,MAAM,OAAO,GAAG,GAAG,WAAW,OAAO,YAAY,IAAI,CAAC;QAEtD,OAAO;YACL,IAAI,EAAE,GAAG,MAAM,0BAA0B,OAAO,WAAW;YAC3D,OAAO;SACR,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/adapters/cursor.d.ts

@@ -0,0 +1,12 @@
+import { GeneratedFile } from "./types.js";
+/**
+ * Generate Cursor custom slash command files for all 6 WhySpec commands.
+ *
+ * Creates .cursor/commands/whyspec-<command>.md files — plain markdown
+ * that Cursor discovers automatically as slash commands.
+ *
+ * @param projectRoot - Optional project root prefix for paths (default: "")
+ * @returns Array of GeneratedFile objects
+ */
+export declare function generateCursorCommands(projectRoot?: string): GeneratedFile[];
+//# sourceMappingURL=cursor.d.ts.map

package/dist/adapters/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/adapters/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAId,MAAM,YAAY,CAAC;AAkNpB;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,GAAE,MAAW,GACvB,aAAa,EAAE,CAOjB"}