@radix-ai/ai-memory 0.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,19 @@
+{
+  "name": "ai-memory",
+  "owner": {
+    "name": "radix-ai",
+    "url": "https://github.com/radix-ai/ai-memory"
+  },
+  "metadata": {
+    "description": "Persistent AI memory for any project. Multi-agent collaboration, RALPH loops, governance enforcement.",
+    "version": "0.1.0",
+    "pluginRoot": "plugins"
+  },
+  "plugins": [
+    {
+      "name": "ai-memory",
+      "source": "ai-memory",
+      "description": "Persistent project memory. Compound protocol, multi-agent claims, session sync. 5 skills, 2 agents, 2 rules, 12 MCP tools."
+    }
+  ]
+}

package/.cursor-plugin/marketplace.json

@@ -0,0 +1,19 @@
+{
+  "name": "ai-memory",
+  "owner": {
+    "name": "radix-ai",
+    "url": "https://github.com/radix-ai/ai-memory"
+  },
+  "metadata": {
+    "description": "Persistent AI memory for any project. Compound protocol, governance enforcement, MCP server.",
+    "version": "0.1.0",
+    "pluginRoot": "plugins"
+  },
+  "plugins": [
+    {
+      "name": "ai-memory",
+      "source": "ai-memory",
+      "description": "Persistent project memory with multi-agent collaboration. 5 skills, 2 agents, 2 rules, 12 MCP tools."
+    }
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Radix AI
+
+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,331 @@
+# ai-memory
+
+[![CI](https://github.com/radix-ai/ai-memory/actions/workflows/ci.yml/badge.svg)](https://github.com/radix-ai/ai-memory/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@radix-ai/ai-memory)](https://www.npmjs.com/package/@radix-ai/ai-memory)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Persistent AI memory for any project. Drop a `.ai/` directory into any codebase — Claude Code, Cursor, Windsurf, or any other AI tool reads it at session start and carries knowledge forward.
+
+```
+npm install @radix-ai/ai-memory
+npx @radix-ai/ai-memory init
+```
+
+---
+
+## The problem
+
+AI coding assistants forget everything between sessions. Decisions made last week, bugs already fixed, patterns that work — gone on every restart. You re-explain the stack, re-discover the same issues, watch the AI repeat the same mistakes.
+
+## What this does
+
+`ai-memory` gives any AI tool persistent memory by maintaining a structured `.ai/` directory in your project. The AI reads it at session start. A local MCP server gives it structured tools to search and write memory. A governance layer enforces project rules in code, not prompts.
+
+---
+
+## Install
+
+The install command sets up three things: **context loading** (the AI reads `.ai/` at session start), **MCP server** (structured memory tools), and **skills** (slash commands like `/mem-compound`).
+
+| Tool | Install | Skills |
+|---|---|---|
+| **Cursor** | `/add-plugin ai-memory` | `/mem-compound`, `/mem-session-close`, `/mem-validate`, `/mem-init` |
+| **Claude Code** | `/plugin install ai-memory` | Same slash commands via plugin |
+| **Windsurf** | `npx @radix-ai/ai-memory install --to windsurf` | Ask AI: "run the compound protocol" |
+| **VS Code + Cline** | `npx @radix-ai/ai-memory install --to cline` | Ask AI: "run the compound protocol" |
+| **VS Code + Copilot** | `npx @radix-ai/ai-memory install --to copilot` | Paste SKILL.md content into chat |
+| **Any other tool** | Paste bootstrap instruction into system prompt | Paste SKILL.md content |
+
+### CLI only
+```bash
+npx @radix-ai/ai-memory init            # scaffold .ai/
+npx @radix-ai/ai-memory install --to cursor  # install for your tool
+```
+
+---
+
+## Quick start
+
+`install` runs `init` automatically if `.ai/` is missing, so you can run either order.
+
+```bash
+# 1. Install for your tool (scaffolds .ai/ if needed)
+npx @radix-ai/ai-memory install --to cursor    # or claude-code, windsurf, cline, copilot
+
+# 2. Fill in what your project is
+# Edit .ai/IDENTITY.md and .ai/PROJECT_STATUS.md (project status)
+
+# 3. Restart your AI tool (or start a new chat)
+
+# 4. At the end of a session with real learning:
+/mem-compound
+```
+
+Or run `init` first to scaffold `.ai/` before installing.
+
+### Verify
+
+```bash
+npx @radix-ai/ai-memory verify
+```
+
+Checks: `.ai/` structure, bootstrap installed, MCP configured, harness validity, rule coverage, memory index populated.
+
+Or manually in a session: ask *"Call search_memory with query 'test'"* (confirms MCP). Then *"What does .ai/IDENTITY.md say?"* (confirms context loading).
+
+### Troubleshooting
+
+| Issue | What to do |
+|-------|------------|
+| `'ai-memory' is not recognized` | You're in the ai-memory dev repo. Run `npm run build` then `node dist/cli/index.js init` and `node dist/cli/index.js install --to cursor`. For published users, use `npx @radix-ai/ai-memory` — the package is pre-built. |
+| MCP tools not available | `install` scaffolds `.ai/` if missing. Restart Cursor (or start a new chat) after install. |
+| Cursor not picking up MCP | Cursor reads `.cursor/mcp.json`. The install writes it for Cursor. If you added manually, ensure the config is in `.cursor/mcp.json` (not `.mcp.json` at project root). |
+| `Cannot find module '.ai/mcp-launcher.cjs'` | Run `npx @radix-ai/ai-memory install --to cursor` first — it creates `.ai/` and the launcher. |
+| `'ai-memory' is not recognized` (Windows) | The launcher uses `cmd /c` on Windows. If it still fails, delete `.cursor/mcp.json` and run `install --to cursor` again to refresh the launcher. |
+
+---
+
+## What gets created
+
+```
+.ai/
+├── IDENTITY.md             — What this project is; constraints for the AI
+├── PROJECT_STATUS.md       — Current focus, open questions, what's working
+├── memory/
+│   ├── decisions.md        — Architectural decisions [P0/P1/P2 tagged]
+│   ├── patterns.md         — Reusable patterns and anti-patterns
+│   ├── debugging.md        — Non-obvious bugs with root cause and fix
+│   ├── improvements.md     — Incremental improvements over time
+│   └── memory-index.md     — Auto-generated priority index
+├── agents/                 — Agent methodology files
+├── skills/                 — Project domain knowledge
+├── toolbox/                — General tech knowledge
+├── rules/                  — Behavioral constraints
+├── sessions/
+│   ├── open-items.md       — Live registry of open tasks
+│   └── archive/
+│       └── thread-archive.md
+└── reference/
+    └── PROJECT.md          — Architecture (loaded on demand only)
+```
+
+Add governance, evals, docs schema, and ACP with `--full`:
+```bash
+npx @radix-ai/ai-memory init --full
+```
+Creates: `acp/`, `docs-schema.json`, `rules/doc-placement.md`, `agents/docs-manager.md`.
+
+---
+
+## Skills
+
+| Skill | When to use |
+|---|---|
+| `/mem-compound` | End of any session with real learning |
+| `/mem-session-close` | End of a short/exploratory session |
+| `/mem-init` | First-time project setup |
+| `/mem-validate` | Before a risky change (Full tier) |
+| `/mem-auto-review` | Automated PR review (Bugbot, CI, automations) |
+
+### Project-specific compound
+
+`/mem-compound` runs standard steps (scan, conflict check, update status, archive, sync) plus project-specific doc updates. The skill maps session work to domains (UI, Backend/API, AI/ML, Architecture, Backlog) and updates docs via `get_doc_path` and `validate_doc_placement`. Open items may be broad or categorical. Work done anywhere must be broken down into atomic tasks that fit RALPH loops and avoid conflicts when agents work in parallel. With `init --full`, `.ai/docs-schema.json` defines canonical paths and naming (SCREAMING_SNAKE by default).
+
+---
+
+## CLI
+
+```bash
+ai-memory init [--full] [--download-model]  # Scaffold .ai/. Use --download-model to pre-fetch hybrid search model (~23MB).
+ai-memory install --to <tool>    # Bootstrap for cursor, windsurf, cline, copilot, claude-code
+ai-memory mcp                    # Start MCP server (stdio)
+ai-memory mcp --http --port 3100 # Start MCP server (HTTP, for cloud agents)
+ai-memory validate               # Validate all .ai/ files
+ai-memory validate-docs          # Validate doc placement against .ai/docs-schema.json (staged or --paths)
+# Pre-commit: add `ai-memory validate-docs` to validate new docs before commit (e.g. via husky)
+ai-memory index                  # Regenerate memory-index.md from memory files
+ai-memory fmt                    # Auto-format YAML frontmatter
+ai-memory eval [--json]          # Memory health report
+ai-memory prune [--dry-run]      # Review stale entries
+ai-memory generate-harness       # Compile rule set from [P0] entries
+ai-memory verify [--json]        # Verify full installation chain (.ai/, bootstrap, MCP, harness)
+
+# Extensibility
+ai-memory agent create <name>    # Scaffold a new agent
+ai-memory skill create <name>    # Scaffold a new skill
+ai-memory rule create <name>     # Scaffold a new rule
+ai-memory eval add <name>        # Add a custom eval metric
+```
+
+---
+
+## Configuration
+
+| Env var | Default | Description |
+|---------|---------|-------------|
+| `AI_DIR` | `./.ai` | Path to the `.ai/` directory |
+| `AI_SEARCH` | `hybrid` | Search mode: `keyword` (TF only, no model), `semantic` (vector only), or `hybrid` (keyword + semantic + RRF). Use `keyword` for faster startup or constrained environments. |
+| `AI_SEARCH_WASM` | — | Set to `1` to prefer WASM backend (onnxruntime-web) over native. Use on Windows when onnxruntime-node fails. Slower but cross-platform. |
+| `AI_MODEL_PATH` | — | Local path to the embedding model for air-gapped/CI. When set, disables remote model downloads. Model must be in HuggingFace format under this path. |
+
+**Platform note:** Semantic/hybrid search uses onnxruntime-node on Linux/macOS. On Windows, onnxruntime-node may be unavailable; set `AI_SEARCH=keyword` for keyword-only, or `AI_SEARCH_WASM=1` to try WASM.
+
+---
+
+## Governance (Full tier)
+
+Tag decisions `[P0]` and add a `constraint_pattern` to enforce them in code:
+
+```markdown
+### [P0] No external auth libraries
+
+**Context:** ...
+**Decision:** Use the internal auth module only.
+
+\`\`\`yaml
+constraint_pattern:
+  type: ast
+  language: typescript
+  pattern: "import $_ from '$LIB'"
+  where:
+    LIB:
+      regex: "passport|jsonwebtoken|bcrypt"
+  path: "src/**/*.ts"
+\`\`\`
+```
+
+Then:
+```bash
+ai-memory generate-harness    # Compile .ai/temp/harness.json
+```
+
+`validate_context` in `/mem-compound` will hard-block any commit that violates a [P0] rule.
+
+### Harness features
+
+- **Path filtering:** Rules apply only to files matching `path` (minimatch glob). Example: `path: "src/**/*.ts"` skips `tests/`.
+- **AST constraints:** Use `where` to filter by meta-variable regex (e.g. path traversal checks).
+- **Deletion-aware regex:** Set `scope: "deletions"` to catch removal of protected content (e.g. `[P0]` markers).
+- **Stability Certificate:** On success, returns an audit log of rules checked; on failure, a detailed violation report.
+
+---
+
+## Multi-agent & iterative loops
+
+### RALPH loops (iterative self-improvement)
+
+PROJECT_STATUS.md is writable by default (`writable: true` in frontmatter). This means:
+1. Agent reads PROJECT_STATUS.md, picks a task, does work
+2. Agent updates PROJECT_STATUS.md with what it learned
+3. Agent exits (or session ends)
+4. Next iteration reads the updated PROJECT_STATUS.md
+5. Natural convergence through iteration
+
+This follows the [autoresearch](https://github.com/mutable-state-inc/autoresearch-at-home) pattern and the [Ralph Wiggum](https://ralph-wiggum.ai/) approach: **the plan file on disk is the shared state.**
+
+### Concurrent agents (cloud agents, worktrees, background tasks)
+
+`commit_memory` uses claim-based locking:
+- Before writing, the agent acquires a claim on the target path
+- If another agent holds an active claim (5-minute TTL), the write is rejected
+- Claims auto-expire, so crashed agents don't permanently lock files
+- Each write includes a `session_id` header for traceability
+
+This works in:
+- **Cursor Cloud Agents**: `.ai/` is in the git clone, MCP server starts per-agent
+- **Claude Code worktrees**: `.ai/` is copied to the worktree; run `/mem-compound` before exit to persist
+- **Claude Code sandbox**: MCP runs outside sandbox boundary — all memory tools work
+
+### Immutability model
+
+| File | Default | Control |
+|---|---|---|
+| `IDENTITY.md` | Immutable | Set `writable: true` in frontmatter to allow AI writes |
+| `PROJECT_STATUS.md` | Writable | Set `writable: false` in frontmatter to lock |
+| `toolbox/`, `acp/`, `rules/` | Always immutable | Structural — no override |
+| Everything else | Writable | Via `commit_memory` tool |
+
+---
+
+## MCP server
+
+The MCP server starts automatically via `.mcp.json`. Tools exposed:
+
+| Tool | What it does |
+|---|---|
+| `search_memory` | Hybrid search across `.ai/` (keyword + semantic + RRF). Params: `limit`, `include_deprecated` |
+| `get_memory` | Summary of a specific topic |
+| `commit_memory` | Write to `.ai/` with immutability + claim-based locking |
+| `get_open_items` | Return open-items.md |
+| `prune_memory` | Identify stale entries |
+| `get_repo_root` | Git repo root path (for path resolution when agent runs from subdir) |
+| `validate_context` | Check git diff against [P0] rules; returns Stability Certificate or violation report |
+| `validate_schema` | Validate memory entry frontmatter |
+| `generate_harness` | Compile `harness.json` from [P0] entries |
+| `get_evals` | Return latest eval report |
+| `claim_task` | Claim a task to prevent duplicate work across agents |
+| `publish_result` | Publish task result (success/failure) to archive |
+| `sync_memory` | Git commit `.ai/` changes (essential for ephemeral environments) |
+| `get_doc_path` | Resolve canonical path for a doc type (use before creating docs) |
+| `validate_doc_placement` | Validate doc path against `.ai/docs-schema.json` |
+| `list_doc_types` | List doc types with path and pattern |
+
+### HTTP transport (for cloud agents)
+
+```bash
+AI_MEMORY_AUTH_TOKEN=secret ai-memory mcp --http --port 3100
+```
+
+| Env var | Purpose |
+|---|---|
+| `AI_MEMORY_AUTH_TOKEN` | Bearer token for HTTP auth (optional, no auth when unset) |
+| `AI_MEMORY_CORS_ORIGINS` | Allowed origins, comma-separated (default: `*`) |
+
+### Context7 MCP (bundled)
+
+`.mcp.json` includes the [Context7](https://context7.com) MCP server for up-to-date docs (Cursor, Claude Code, Windsurf, etc.). Works without an API key; set `CONTEXT7_API_KEY` for higher rate limits.
+
+---
+
+## Evals
+
+```bash
+ai-memory eval
+```
+
+Reports: rule coverage, session cadence, frontmatter coverage, open items, deprecated ratio, memory depth, session count, memory freshness, hook coverage, skill discoverability, cloud readiness, automation readiness, integration coverage.
+
+Add custom metrics:
+```bash
+ai-memory eval add my-metric
+# Edit .ai/temp/custom-evals/my-metric.ts
+```
+
+---
+
+## ACP (Full tier)
+
+`.ai/acp/manifest.json` declares this agent's capabilities to ACP-aware orchestrators like [`acpx`](https://github.com/openclaw/acpx). The MCP server is the transport layer; ACP is the identity layer.
+
+---
+
+## Design
+
+- [Environment adaptation plan](docs/design/environment-adaptation-plan.md) — Spec-driven detection and injection for Cursor, VS Code, Claude Code, etc. (plan, not yet implemented)
+
+---
+
+## Related
+
+- [acpx](https://github.com/openclaw/acpx) — Headless CLI for Agent Communication Protocol
+- [Agent Communication Protocol](https://agentclientprotocol.com)
+- [compound-engineering-plugin](https://github.com/EveryInc/compound-engineering-plugin) — Plugin this system is modeled after
+- [lossless-claw](https://github.com/Martian-Engineering/lossless-claw) — Lossless context compaction (inspiration for session archive design)
+- [autoresearch-at-home](https://github.com/mutable-state-inc/autoresearch-at-home) — Multi-agent iterative research
+- [Ralph Wiggum](https://ralph-wiggum.ai/) — Iterative agent loops via plan file on disk
+
+---
+
+## License
+
+MIT

package/dist/cli/adapters.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tool adapter definitions for `ai-memory install --to <tool>`.
+ * Extracted from index.ts for maintainability.
+ */
+export declare const BOOTSTRAP_INSTRUCTION = "## ai-memory \u2014 Project Memory\n\nThis project has persistent AI memory in `.ai/`.\n\n- **IDENTITY.md** \u2014 project constraints and behavioral rules\n- **PROJECT_STATUS.md** \u2014 current focus, open questions, what to try next (writable)\n- **memory/** \u2014 decisions, patterns, debugging history\n- **skills/** \u2014 domain-specific patterns and session protocols\n\nUse `search_memory` (MCP) to find relevant context before starting a task.\nUse `commit_memory` to write new entries \u2014 never edit memory files directly.\nIf MCP is not connected, read `.ai/memory/memory-index.md` for a summary and write to `.ai/memory/` files directly.\n\n`.ai/` is the canonical memory for this project. Save all project learnings here, not in your tool's built-in memory (e.g. ~/.claude/, Cursor memory, etc.). Tool-native memory is for user preferences only.\n\nImmutable paths (do not write): IDENTITY.md, toolbox/, acp/, rules/.\n\nAt the end of a meaningful session, run /mem-compound to capture learnings.\n";
+/**
+ * Platform-agnostic MCP launcher. Detects OS at runtime and spawns correctly.
+ * - In ai-memory repo: run local dist directly (avoids npx entirely).
+ * - Windows: npx.cmd fails under spawn; npx-cli.js via node works.
+ * - macOS/Linux/BSD: npx works directly.
+ */
+export declare const MCP_LAUNCHER = "#!/usr/bin/env node\nconst { spawn } = require(\"child_process\");\nconst path = require(\"path\");\nconst fs = require(\"fs\");\nconst platform = process.platform;\nconst opts = { stdio: \"inherit\", env: process.env };\n\n// Prefer local build when in ai-memory repo (avoids npx on Windows)\nconst cwd = process.cwd();\nconst localCli = path.join(cwd, \"dist\", \"cli\", \"index.js\");\nconst localMcp = path.join(cwd, \"dist\", \"mcp-server\", \"index.js\");\n\nlet child;\nif (fs.existsSync(localCli)) {\n  child = spawn(\"node\", [localCli, \"mcp\"], opts);\n} else if (fs.existsSync(localMcp)) {\n  child = spawn(\"node\", [localMcp], opts);\n} else if (platform === \"win32\") {\n  const nodeDir = path.dirname(process.execPath);\n  const npxCli = path.join(nodeDir, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\");\n  if (fs.existsSync(npxCli)) {\n    child = spawn(\"node\", [npxCli, \"@radix-ai/ai-memory\", \"mcp\"], opts);\n  } else {\n    child = spawn(\"cmd\", [\"/c\", \"npx\", \"@radix-ai/ai-memory\", \"mcp\"], { ...opts, windowsHide: true });\n  }\n} else {\n  child = spawn(\"npx\", [\"@radix-ai/ai-memory\", \"mcp\"], opts);\n}\n\nchild.on(\"error\", (err) => {\n  console.error(\"[ai-memory-mcp] spawn failed:\", err.message);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  process.exit(code ?? (signal ? 1 : 0));\n});\n";
+/** MCP config path for the launcher (relative to project root). */
+export declare const MCP_LAUNCHER_PATH = ".ai/mcp-launcher.cjs";
+/** Single MCP config for all platforms. Uses launcher that detects OS at runtime. */
+export declare function getMCPJson(): string;
+/** Full skill content — written to .ai/skills/<name>/SKILL.md by install */
+export declare const CANONICAL_SKILLS: Record<string, string>;
+export declare const SESSION_START_HOOK = "#!/usr/bin/env node\n/**\n * ai-memory \u2014 Claude Code SessionStart hook\n * Injects minimal .ai/ context at session start (lazy loading).\n * Full context available via search_memory MCP tool.\n */\nconst { readFileSync, existsSync } = require(\"fs\");\nconst { join } = require(\"path\");\n\nconst aiDir = process.env.AI_DIR || join(process.cwd(), \".ai\");\n\nfunction safeRead(filePath, maxLines) {\n  try {\n    const content = readFileSync(filePath, \"utf-8\");\n    if (maxLines) return content.split(\"\\n\").slice(0, maxLines).join(\"\\n\");\n    return content;\n  } catch { return \"\"; }\n}\n\nif (!existsSync(aiDir)) process.exit(0);\n\nconst sections = [];\n\nconst identity = safeRead(join(aiDir, \"IDENTITY.md\"));\nif (identity) sections.push(identity.trim());\n\nconst status = safeRead(join(aiDir, \"PROJECT_STATUS.md\"));\nif (status) sections.push(status.trim());\n\nconst index = safeRead(join(aiDir, \"memory/memory-index.md\"));\nif (index && !index.includes(\"<!-- Index will be generated\")) {\n  sections.push(\"## Memory Index (priority-ranked)\\n\\n\" + index.trim());\n}\n\nif (sections.length === 0) process.exit(0);\n\nprocess.stdout.write(JSON.stringify({\n  type: \"context\",\n  content: sections.join(\"\\n\\n---\\n\\n\"),\n}));\n";
+export declare const PRE_COMPACT_HOOK = "#!/usr/bin/env node\nconst fs = require(\"fs\");\nconst path = require(\"path\");\nconst aiDir = process.env.AI_DIR || path.join(process.cwd(), \".ai\");\nif (!fs.existsSync(aiDir)) process.exit(0);\nconst tempDir = path.join(aiDir, \"temp\");\nfs.mkdirSync(tempDir, { recursive: true });\nconst dump = { timestamp: new Date().toISOString(), event: \"pre-compact\" };\nfor (const f of [\"PROJECT_STATUS.md\", \"memory/memory-index.md\", \"sessions/open-items.md\"]) {\n  const fp = path.join(aiDir, f);\n  if (fs.existsSync(fp)) dump[f] = fs.readFileSync(fp, \"utf-8\").slice(0, 2000);\n}\nfs.writeFileSync(path.join(tempDir, \"pre-compact-dump.json\"), JSON.stringify(dump, null, 2));\n";
+export declare const CLAUDE_HOOKS_CONFIG: string;
+export interface ToolAdapter {
+    dest: string;
+    content: string;
+    mcp: boolean;
+    /** MCP config path (default: .mcp.json). Cursor uses .cursor/mcp.json */
+    mcpPath?: string;
+    /** Additional files to write (path relative to project root → content) */
+    extraFiles?: Record<string, string>;
+}
+export declare const TOOL_ADAPTERS: Record<string, ToolAdapter>;
+//# sourceMappingURL=adapters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../src/cli/adapters.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,qBAAqB,6/BAkBjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,21CAoCxB,CAAC;AAEF,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AAExD,qFAAqF;AACrF,wBAAgB,UAAU,IAAI,MAAM,CAoBnC;AAQD,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAsJnD,CAAC;AAIF,eAAO,MAAM,kBAAkB,0vCAwC9B,CAAC;AAGF,eAAO,MAAM,gBAAgB,orBAa5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,QAiBrB,CAAC;AAIZ,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,OAAO,CAAC;IACb,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAiDrD,CAAC"}