wingfoil 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roberto Pompermaier
+
+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,334 @@
+# WingFoil
+
+**A structured harness for deterministic AI-assisted software development.**
+
+WingFoil solves a critical problem: as your software project grows, AI agents lose consistency and control. Context gets
+scattered, conventions drift, and decisions made in one session don't carry forward to the next.
+
+WingFoil centralizes your project's **memory, DNA, and directives** in a structured, git-backed format — giving both
+humans and AI agents a shared source of truth.
+
+---
+
+## The Problem
+
+When using AI agents to write software, you face growing friction:
+
+- **Context collapse:** Large context windows and full codebase scans become expensive and noisy
+- **Convention drift:** Agents don't respect established patterns unless you re-explain them every session
+- **Decision scatter:** Architectural decisions, patterns, and constraints live in Slack, old docs, or nowhere
+- **Governance gaps:** No way to enforce rules consistently across human developers and AI agents
+
+The larger the project, the worse the signal-to-noise ratio.
+
+---
+
+## The Solution
+
+WingFoil provides a **structured, authoritative interface** to your project:
+
+- **Project Memory** — Git-backed storage for decisions, artifacts, and domain knowledge
+- **Project DNA** — Structural map of modules, tech stack, and conventions
+- **Project Directives** — Role-based rules that both humans and agents respect
+- **Workflow State Management** — Unified tracking and communication of project flow, progress, and blockers
+- **Interaction Layer** — CLI for humans, MCP for agents
+
+This keeps everything synchronized and deterministic.
+
+---
+
+## Who It's For
+
+**Alex, the Solo Developer**  
+Every new AI session forces you to re-explain context. WingFoil loads relevant info in seconds — no more context loss
+between sessions.
+
+**Sam, the Code Reviewer**  
+You're starting with AI for code review but aren't confident enough for full development yet. WingFoil lets you enforce
+quality standards and gradually expand AI usage as you gain confidence.
+
+**Jordan, the Team Developer**  
+You don't know what conventions your tech lead has defined, and agents ignore team rules. WingFoil keeps everyone
+aligned on directives, decisions, and project state without constant manual updates.
+
+**Morgan, the Tech Lead**  
+You need agents to follow the team's rules automatically, not invent new ones. WingFoil encodes governance once; it
+auto-loads for every agent. It also keeps the whole team synchronized on progress and blockers.
+
+**Casey, the Manager**  
+You need visibility into decisions and methodology. WingFoil provides an audit trail, queryable knowledge base, and
+real-time tracking of project state.
+
+---
+
+## Key Features
+
+### Five Pillars — status in 0.2.1
+
+- ✓ **Project Memory** — Git-backed documents (tasks, ADRs, decision-logs, bugs, specs…) with per-type
+  state machines, approval gates and an audit trail (**shipped**: create, search, submit, approve,
+  reject, deprecate, history)
+- ✓ **Project DNA** — Structured config: modules, tech stack, team & roles, resource paths
+  (**shipped**: show, set, add, update, remove)
+- ✓ **Project Directives** — Role-scoped rules: six built-in templates installed by `init`, your own
+  custom directives, role assignments (**shipped in 0.2.1**)
+- ✓ **Interaction Layer** — CLI for humans and agents; MCP server for agents with read-only Resources
+  and one Prompt per role (**shipped**)
+- **Workflow State Management** — workflows are declared and listable today; the engine that starts
+  and tracks them is planned for 0.3
+
+### CLI at a glance
+
+| Area | Commands |
+|---|---|
+| Setup | `wingfoil init [--template Scrum\|Kanban]` · `wingfoil mcp` |
+| DNA | `wingfoil dna show [section]` · `dna set <path> --value <v>` · `dna add` · `dna update` · `dna remove` · `wingfoil paths [category]` |
+| Memory | `wingfoil memory add --type <t> --title <t>` · `submit <id>` · `approve <id> --reason <r>` · `reject <id> --reason <r>` · `deprecate <id>` · `history <id>` · `search [keyword]` |
+| Directives | `wingfoil directive create --name <n>` · `directive assign --directive <n> --role <r>` · `directive remove <n>` · `wingfoil directives list [--role <r>]` |
+| Workflow | `wingfoil workflow list` |
+
+Every command accepts `--format console|json|yaml` and ends with exit code `0` (success), `1` (refused)
+or `2` (bad command line). Full details: **[CLI reference](docs/cli-reference.md)**.
+
+### For AI Agents
+
+- ✓ **MCP server** (`wingfoil mcp`, stdio) — DNA, Memory and workflows as read-only Resources, plus a
+  `<role>-session` Prompt per role that embeds the role's directives
+- ✓ **Read-only by construction** — the MCP surface has no Tools; changes go through the CLI, and
+  approvals belong to a human holding the `approver` role
+- ✓ **[`docs/agents.md`](docs/agents.md)** — the same knowledge as a document an agent can read from a
+  link: what WingFoil is, the rules to follow, the CLI equivalent of every MCP Resource and Prompt
+
+---
+
+## Getting Started
+
+### Installation
+
+```bash
+npm install -g wingfoil
+```
+
+This installs the `wingfoil` binary (**Node.js 22.12+** required). Verify it:
+
+```bash
+wingfoil --version
+```
+
+### Quick Start
+
+Run this from the root of a **git repository** with a git identity configured
+(`git config user.name` / `user.email`).
+
+**1. Initialize WingFoil** — scaffolds `.wingfoil/` (DNA, Memory schema and templates, directives,
+workflows) and commits it:
+
+```bash
+$ wingfoil init --template Scrum
+```
+
+**2. Name the project and register yourself as the approver** — approvals need a team member holding
+the `approver` role, with your git email:
+
+```console
+$ wingfoil dna set project.name --value "My Project"
+{
+  "key": "project.name",
+  "value": "My Project"
+}
+$ wingfoil dna add team.members --value "Ada Lovelace" --entry-email ada@example.com --entry-roles approver,developer
+{
+  "key": "team.members",
+  "value": "Ada Lovelace"
+}
+```
+
+**3. Create a task, write it, submit it:**
+
+```console
+$ wingfoil memory add --type task --title "My first task"
+{
+  "id": "task-001-my-first-task",
+  "path": "docs/memory/task/task-001-my-first-task.md"
+}
+$ wingfoil memory submit task-001-my-first-task
+{
+  "id": "task-001-my-first-task",
+  "path": "docs/memory/task/task-001-my-first-task.md",
+  "from": "draft",
+  "to": "pending"
+}
+```
+
+(Write the task's body in the file before submitting — the submit commit records it.)
+
+**4. Approve it** — the commit records who approved and why:
+
+```console
+$ wingfoil memory approve task-001-my-first-task --reason "Scope is clear."
+{
+  "id": "task-001-my-first-task",
+  "path": "docs/memory/task/task-001-my-first-task.md",
+  "from": "pending",
+  "to": "approved"
+}
+$ git log -1 --format=%B
+wf(task): approve task-001-my-first-task [pending → approved]
+
+Approver: Ada Lovelace <ada@example.com> (approver)
+Reason: Scope is clear.
+```
+
+**5. Connect your AI agent** — for Claude Code, add `.mcp.json` at the repository root:
+
+```json
+{ "mcpServers": { "wingfoil": { "command": "wingfoil", "args": ["mcp"] } } }
+```
+
+### Documentation
+
+| Document | For |
+|---|---|
+| **[User guide](docs/user-guide.md)** | Step by step: install, configure DNA / Memory / Directives, daily use, agents, CI |
+| **[CLI reference](docs/cli-reference.md)** | Every command: arguments, output, exit codes, the commit it writes |
+| **[Examples](docs/examples/)** | Runnable, self-checking scripts for the main scenarios |
+| **[Guide for AI agents](docs/agents.md)** | What an agent needs to operate in a WingFoil project |
+| **[Changelog](CHANGELOG.md)** | What changed in each release |
+
+---
+
+## Value Proposition
+
+**For** developers and teams already using AI agents  
+**WingFoil** makes the development process **deterministic**  
+**By** centralizing memory, conventions, and directives — keeping them synchronized across all actors
+
+### Success Metric: Determinism Index
+
+Two independent development runs from the same specs + WingFoil config using different AI agents should produce
+substantially equivalent software, with all team members and agents maintaining shared understanding of project workflow
+state, progress, and alignment.
+
+---
+
+## What Comes Later
+
+**0.3 — Project Workflow:** the workflow engine (`workflow start|next|status|show|end`…), approval
+routing by role, agent execution with directives and Memory context auto-loaded, reference workflow
+templates, notifications when an approval is required.
+
+**0.4 — Interaction Layer + Polish** · **1.0 — MVP complete**, all five pillars integrated.
+
+Later, based on early adopter feedback: semantic search, IDE integrations beyond MCP, notification
+routing (email, Slack), multi-project management.
+
+---
+
+## Release Roadmap
+
+WingFoil is built one pillar per release until all five are integrated in 1.0.
+
+| Release | Focus | Status |
+|---|---|---|
+| Lean Inception · Requirements | Product vision, USM · BDD · SARD · backlog | ✓ Complete |
+| **0.1** | Project Memory + DNA | ✓ Released (not published to npm) |
+| **0.2** | + Project Directives, Memory approvals, DNA editing, MCP role Prompts | 🔄 Being released |
+| **0.3** | + Project Workflow | Planned |
+| **0.4** | + Interaction Layer polish | Planned |
+| **1.0** | MVP complete | Planned |
+
+**Dogfooding:** WingFoil's own development is managed with WingFoil — its configuration lives under
+`docs/self/`.
+
+---
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────┐
+│  Humans (CLI)        Agents (MCP Client)        │
+├─────────────────────────────────────────────────┤
+│           WingFoil Harness                      │
+│  ┌─────────────────────────────────────────┐    │
+│  │ Memory | DNA | Directives | Workflow    │    │
+│  └─────────────────────────────────────────┘    │
+├─────────────────────────────────────────────────┤
+│         Git Repository                          │
+│  (versioning, audit trail, state history)       │
+└─────────────────────────────────────────────────┘
+```
+
+- **CLI**: Humans (and agents) use `wingfoil` commands to manage Memory, DNA and Directives, and to read Workflows
+- **MCP Server**: Agents connect via Model Context Protocol to query Memory/DNA, receive Directives, and view Workflow
+  definitions
+- **Git Backend**: All changes (memory, decisions, workflow state) are versioned and auditable
+- **Read-Only MCP**: The MCP surface is read-only; state changes go through the CLI, and approvals belong to a
+  human holding the `approver` role
+- **Workflow Synchronization** *(0.3)*: All team members and agents stay aligned on current progress and blockers
+
+---
+
+## Project Documentation
+
+Before implementation, the product is fully specified through a **traceable documentation pipeline** under `docs/`,
+taking the Lean Inception vision down to an implementation-ready backlog (the *specification downcast*):
+
+```
+docs/
+├── 01_vision/         Lean Inception — product brief, vision, personas, 8 journeys, features, sequencer, MVP canvas
+├── 02_requirements/   Specification downcast:
+│   ├── 01_user_story_map/   User Story Map (Jeff Patton) — journey backbone + prioritized stories, incl. edge cases
+│   ├── 02_bdd/              BDD suite (Gojko Adzic) — Gherkin scenarios per feature (happy + error/edge paths)
+│   └── 03_sard/             System & Architecture Requirements (Volere) — NFRs with measurable Fit Criteria
+└── 03_backlog/        Operational backlog — schema-validated JSON work items, partitioned by release wave
+```
+
+**Traceability chain.** Every item links back through the layers:
+`Backlog task → SARD requirement / BDD scenario → User Story → Journey → Vision feature`.
+
+**MVP scope at a glance:**
+
+| Layer          | Artifact                                                    | Count    |
+|----------------|-------------------------------------------------------------|----------|
+| Vision         | User journeys                                               | 8        |
+| Vision         | MVP features (5 pillars + notifications)                    | 63       |
+| User Story Map | Journey files · edge-case / interruption stories            | 7 · 14   |
+| BDD            | Gherkin feature files / scenarios                           | 63 / 190 |
+| SARD           | Architecture & NFR requirements (measurable Fit Criteria)   | 43       |
+| Backlog        | Implementation-ready tasks (63 user stories + 43 technical) | 106      |
+
+All artifacts are scheduled across 5 release waves (v0.1 → v1.0), sequenced by risk in
+`docs/01_vision/07_sequencer.md`.
+
+---
+
+## License
+
+MIT — open source and free to use.
+
+---
+
+## Contributing
+
+Early feedback is welcome. Please open issues on GitHub to share:
+
+- Use cases and pain points
+- Feature requests
+- Bug reports
+
+See **[`COLLABORATION.md`](COLLABORATION.md)** — how to contribute through Memory artifacts
+(Bug / Decision-Log / ADR / Tech-Spec) instead of code, with credit for the AI-generated work
+derived from your contribution.
+
+---
+
+## Questions?
+
+- **GitHub Issues:** Bug reports, feature requests
+- **Documentation:** Start from the [user guide](docs/user-guide.md); WingFoil's own specifications (vision, USM · BDD ·
+  SARD, backlog) are under [`docs/`](docs/)
+- **Community:** Join discussions (links coming soon)
+
+---
+
+**WingFoil: Making AI-assisted development deterministic, not chaotic.**

package/dist/cli/error.d.ts

@@ -0,0 +1,11 @@
+import type { OutputFormat } from './output';
+/**
+ * Write an error to stderr in the consistent spec-005 §3 format for the active `--format`: a
+ * `{error, hint?}` object for `json`/`yaml`, or `error: <reason>` (+ optional `hint:` line) for
+ * `console`. Writes only; the caller terminates via {@link exitWith}.
+ */
+export declare function emitError(reason: string, opts: {
+    format: OutputFormat;
+    hint?: string;
+}): void;
+//# sourceMappingURL=error.d.ts.map

package/dist/cli/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/cli/error.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAS7F"}

package/dist/cli/error.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitError = emitError;
+/**
+ * The consistent error format (spec-005-cli-command-contract §3, REQ-INT-08). Written verbatim
+ * from the spec's own code listing so `src/cli` and the spec cannot drift.
+ */
+const js_yaml_1 = require("js-yaml");
+/**
+ * Write an error to stderr in the consistent spec-005 §3 format for the active `--format`: a
+ * `{error, hint?}` object for `json`/`yaml`, or `error: <reason>` (+ optional `hint:` line) for
+ * `console`. Writes only; the caller terminates via {@link exitWith}.
+ */
+function emitError(reason, opts) {
+    if (opts.format === 'json') {
+        process.stderr.write(JSON.stringify({ error: reason, ...(opts.hint ? { hint: opts.hint } : {}) }) + '\n');
+    }
+    else if (opts.format === 'yaml') {
+        process.stderr.write((0, js_yaml_1.dump)({ error: reason, ...(opts.hint ? { hint: opts.hint } : {}) }));
+    }
+    else {
+        process.stderr.write(`error: ${reason}\n`);
+        if (opts.hint)
+            process.stderr.write(`hint: ${opts.hint}\n`);
+    }
+}
+//# sourceMappingURL=error.js.map

package/dist/cli/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../src/cli/error.ts"],"names":[],"mappings":";;AAaA,8BASC;AAtBD;;;GAGG;AACH,qCAA2C;AAI3C;;;;GAIG;AACH,SAAgB,SAAS,CAAC,MAAc,EAAE,IAA6C;IACrF,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;QAC3B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;IAC5G,CAAC;SAAM,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;QAClC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAA,cAAQ,EAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/F,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,MAAM,IAAI,CAAC,CAAC;QAC3C,IAAI,IAAI,CAAC,IAAI;YAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;IAC9D,CAAC;AACH,CAAC"}

package/dist/cli/exit.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The exit-code contract (spec-005-cli-command-contract §1, REQ-INT-04). Every `wingfoil`
+ * invocation terminates through this single function, so the `0`/`1`/`2` mapping can never be
+ * bypassed by an uncaught code path elsewhere in `src/cli`.
+ *
+ * This module owns only the *mechanism* (the single `process.exit`). The exit-code *selection* —
+ * which outcome maps to which code — lives in `src/core` (`exitCodeForError`/`exitCodeForResult`),
+ * shared with the MCP surface per REQ-SYS-05 (task-012); `ExitCode` is re-exported from there so the
+ * CLI never redeclares the contract's shape.
+ */
+import type { ExitCode } from '../core';
+export type { ExitCode };
+/**
+ * The single process-exit mechanism for the CLI (spec-005 §1, REQ-INT-04): optionally write
+ * `message` to stderr, then `process.exit(code)`. Every invocation terminates through here so the
+ * `0`/`1`/`2` contract cannot be bypassed. Returns `never`.
+ */
+export declare function exitWith(code: ExitCode, message?: string): never;
+//# sourceMappingURL=exit.d.ts.map

package/dist/cli/exit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.d.ts","sourceRoot":"","sources":["../../src/cli/exit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,YAAY,EAAE,QAAQ,EAAE,CAAC;AAEzB;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAGhE"}

package/dist/cli/exit.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exitWith = exitWith;
+/**
+ * The single process-exit mechanism for the CLI (spec-005 §1, REQ-INT-04): optionally write
+ * `message` to stderr, then `process.exit(code)`. Every invocation terminates through here so the
+ * `0`/`1`/`2` contract cannot be bypassed. Returns `never`.
+ */
+function exitWith(code, message) {
+    if (message)
+        process.stderr.write(message + '\n');
+    process.exit(code);
+}
+//# sourceMappingURL=exit.js.map

package/dist/cli/exit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.js","sourceRoot":"","sources":["../../src/cli/exit.ts"],"names":[],"mappings":";;AAmBA,4BAGC;AARD;;;;GAIG;AACH,SAAgB,QAAQ,CAAC,IAAc,EAAE,OAAgB;IACvD,IAAI,OAAO;QAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IAClD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrB,CAAC"}

package/dist/cli/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `cli` module — human interface (Commander.js + chalk); the `wingfoil` command surface.
+ *
+ * task-006-dual-interface-shared-core adds the thin adapter (spec-006 §2): `buildCliCommands`
+ * (`./registrar.ts`) derives one `wingfoil <noun> <verb>` command descriptor per operation from a
+ * `CoreModule[]` registry (`src/core/index.ts`'s `CORE_MODULES`), with no business logic beyond
+ * parse-format / call-core / render-result / exit. `buildProgram` (`./program.ts`) wires that model
+ * onto a real `commander` `Command` tree — see that file's module doc for why `commander` (ESM-only
+ * as of v15) is imported dynamically rather than statically, and why that wiring is not itself
+ * exercised by an automated test in this task. A runnable `bin` entry point (calling
+ * `buildProgram(CORE_MODULES, ...)` against `process.argv` and installing it as the `wingfoil`
+ * executable) is left to a later task — this task's scope is the registrar mechanism and its test
+ * coverage, not a shippable CLI binary (see task-006 Execution Notes).
+ */
+export declare const MODULE_NAME: "cli";
+export { buildCliCommands, listRegisteredCliCommands } from './registrar';
+export type { BuildCommandsOptions, CliCommand } from './registrar';
+export { buildProgram } from './program';
+export { exitWith } from './exit';
+export type { ExitCode } from './exit';
+export { isValidFormat, renderSuccess } from './output';
+export type { OutputFormat } from './output';
+export { emitError } from './error';
+export { runInit, createReadlinePrompt } from './init-command';
+export type { InitCliOptions, InitCliDeps } from './init-command';
+export { runMcp } from './mcp-command';
+export type { McpCliDeps } from './mcp-command';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,EAAG,KAAc,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,YAAY,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACxD,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMcp = exports.createReadlinePrompt = exports.runInit = exports.emitError = exports.renderSuccess = exports.isValidFormat = exports.exitWith = exports.buildProgram = exports.listRegisteredCliCommands = exports.buildCliCommands = exports.MODULE_NAME = void 0;
+/**
+ * `cli` module — human interface (Commander.js + chalk); the `wingfoil` command surface.
+ *
+ * task-006-dual-interface-shared-core adds the thin adapter (spec-006 §2): `buildCliCommands`
+ * (`./registrar.ts`) derives one `wingfoil <noun> <verb>` command descriptor per operation from a
+ * `CoreModule[]` registry (`src/core/index.ts`'s `CORE_MODULES`), with no business logic beyond
+ * parse-format / call-core / render-result / exit. `buildProgram` (`./program.ts`) wires that model
+ * onto a real `commander` `Command` tree — see that file's module doc for why `commander` (ESM-only
+ * as of v15) is imported dynamically rather than statically, and why that wiring is not itself
+ * exercised by an automated test in this task. A runnable `bin` entry point (calling
+ * `buildProgram(CORE_MODULES, ...)` against `process.argv` and installing it as the `wingfoil`
+ * executable) is left to a later task — this task's scope is the registrar mechanism and its test
+ * coverage, not a shippable CLI binary (see task-006 Execution Notes).
+ */
+exports.MODULE_NAME = 'cli';
+var registrar_1 = require("./registrar");
+Object.defineProperty(exports, "buildCliCommands", { enumerable: true, get: function () { return registrar_1.buildCliCommands; } });
+Object.defineProperty(exports, "listRegisteredCliCommands", { enumerable: true, get: function () { return registrar_1.listRegisteredCliCommands; } });
+var program_1 = require("./program");
+Object.defineProperty(exports, "buildProgram", { enumerable: true, get: function () { return program_1.buildProgram; } });
+var exit_1 = require("./exit");
+Object.defineProperty(exports, "exitWith", { enumerable: true, get: function () { return exit_1.exitWith; } });
+var output_1 = require("./output");
+Object.defineProperty(exports, "isValidFormat", { enumerable: true, get: function () { return output_1.isValidFormat; } });
+Object.defineProperty(exports, "renderSuccess", { enumerable: true, get: function () { return output_1.renderSuccess; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "emitError", { enumerable: true, get: function () { return error_1.emitError; } });
+var init_command_1 = require("./init-command");
+Object.defineProperty(exports, "runInit", { enumerable: true, get: function () { return init_command_1.runInit; } });
+Object.defineProperty(exports, "createReadlinePrompt", { enumerable: true, get: function () { return init_command_1.createReadlinePrompt; } });
+var mcp_command_1 = require("./mcp-command");
+Object.defineProperty(exports, "runMcp", { enumerable: true, get: function () { return mcp_command_1.runMcp; } });
+//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;GAaG;AACU,QAAA,WAAW,GAAG,KAAc,CAAC;AAE1C,yCAA0E;AAAjE,6GAAA,gBAAgB,OAAA;AAAE,sHAAA,yBAAyB,OAAA;AAEpD,qCAAyC;AAAhC,uGAAA,YAAY,OAAA;AACrB,+BAAkC;AAAzB,gGAAA,QAAQ,OAAA;AAEjB,mCAAwD;AAA/C,uGAAA,aAAa,OAAA;AAAE,uGAAA,aAAa,OAAA;AAErC,iCAAoC;AAA3B,kGAAA,SAAS,OAAA;AAClB,+CAA+D;AAAtD,uGAAA,OAAO,OAAA;AAAE,oHAAA,oBAAoB,OAAA;AAEtC,6CAAuC;AAA9B,qGAAA,MAAM,OAAA"}

package/dist/cli/init-command.d.ts

@@ -0,0 +1,34 @@
+import { type InitProjectValue } from '../core';
+import type { CoreResult } from '../core/types';
+/** The parsed flag surface `runInit` acts on (global `--format`/`--interactive` + local `--template`). */
+export interface InitCliOptions {
+    /** `--template <name>` value, or `undefined` when the flag was omitted. */
+    readonly template?: string;
+    /** The negatable global `--interactive` (default `true`; `false` when `--no-interactive` was passed). */
+    readonly interactive: boolean;
+    /** The global `--format` value, still unvalidated (validated here, per registrar's contract). */
+    readonly format: string;
+}
+/** Injected, side-effecting dependencies — the seam that keeps `runInit` fully unit-testable. */
+export interface InitCliDeps {
+    /** The resolved project (git) root the layout is written under. */
+    readonly root: string;
+    /** Whether stdout is a TTY (drives the spec-008 §4 prompt-vs-fail decision). */
+    readonly isTTY: boolean;
+    /** Ask the user one question and resolve their (raw) answer — injected so no real TTY is needed. */
+    readonly prompt: (question: string) => Promise<string>;
+    /** The core init flow; defaults to {@link initWingfoilProject} (overridden in tests). */
+    readonly init?: (root: string, template: string) => CoreResult<InitProjectValue>;
+}
+/**
+ * Execute `wingfoil init`. Terminates through the single spec-005 §1 exit path (`exitWith`) exactly
+ * once: `2` on any usage error (invalid `--format`, unknown/omitted-required `--template`), otherwise
+ * the code the core `CoreResult` maps to (`0` success / `1` already-initialized or other logic error).
+ */
+export declare function runInit(options: InitCliOptions, deps: InitCliDeps): Promise<void>;
+/**
+ * A real readline-backed wizard prompt (used by ./program.ts's `init` command; not unit-tested — the
+ * same seam as `commander` wiring). Reads one line from stdin, resolves it, and closes the interface.
+ */
+export declare function createReadlinePrompt(): (question: string) => Promise<string>;
+//# sourceMappingURL=init-command.d.ts.map

package/dist/cli/init-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-command.d.ts","sourceRoot":"","sources":["../../src/cli/init-command.ts"],"names":[],"mappings":"AAeA,OAAO,EAA0C,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACxF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAWhD,0GAA0G;AAC1G,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,yGAAyG;IACzG,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,iGAAiG;IACjG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,iGAAiG;AACjG,MAAM,WAAW,WAAW;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,oGAAoG;IACpG,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD,yFAAyF;IACzF,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,UAAU,CAAC,gBAAgB,CAAC,CAAC;CAClF;AA2CD;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBvF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAS5E"}