@dotcontext/cli 0.8.2 → 0.9.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 AI Coders
+Copyright (c) 2024 AI Coders Academy
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -6,29 +6,91 @@
 
 > **Formerly `@ai-coders/context`.** Renamed to avoid confusion with Context7 and other "context" tools in the AI space. The `.context/` directory standard is unchanged. See [Migration Guide](#migration-from-ai-coderscontext).
 
-**The Ultimate MCP for AI Agent Orchestration, Context Engineering, and Spec-Driven Development.**
-Context engineering for AI now is stupidly simple.
+**Dotcontext is a harness engineering runtime for AI-assisted software delivery.**
 
-Stop letting LLMs run on autopilot. PREVC is a universal process that improves AI output through 5 simple steps: **Planning, Review, Execution, Validation, and Confirmation**. Context-oriented. Spec-driven. No guesswork.
+It gives coding agents a real operating environment instead of a loose prompt and a pile of conventions. Dotcontext combines shared project context, workflow structure, policies, sensors, task contracts, replayable execution history, and MCP access into one system.
 
-## The Problem
+The point is not just to "give the model more context". The point is to make agent execution legible, constrained, reusable, and auditable.
 
-Every AI coding tool invented its own way to organize context:
+## What Dotcontext Is
 
+Dotcontext is three things at once:
+
+- a `.context/` convention for durable project knowledge
+- a harness runtime that governs how agents execute work
+- a CLI and MCP surface that expose that runtime to humans and AI tools
+
+PREVC remains the default execution model for structured work: **Planning, Review, Execution, Validation, and Confirmation**.
+
+## Why Dotcontext Exists
+
+Most agent workflows break down for the same reasons:
+
+- project knowledge is scattered across tool-specific formats
+- execution rules live in prompts instead of in runtime controls
+- agents can change code without producing evidence
+- there is no durable record of why an agent did what it did
+- teams cannot reuse the same operating model across Claude, Cursor, Codex, Copilot, and others
+
+Dotcontext exists to solve that layer, not just the prompt layer.
+
+## Architecture
+
+Dotcontext is now organized around an explicit harness runtime:
+
+```text
+cli -> harness <- mcp
 ```
-.cursor/rules/          # Cursor
-.claude/                # Claude Code
-.windsurf/rules/        # Windsurf
-.github/agents/         # Copilot
-.cline/                 # Cline
-.agent/rules/           # Google Antigravity
-.trae/rules/            # Trae AI
-AGENTS.md               # Codex
-```
 
-Using multiple tools? Enjoy duplicating your rules, agents, and documentation across 8 different formats. Context fragmentation is real.
+- `@dotcontext/cli` is the operator-facing surface
+- `dotcontext/harness` is the reusable runtime and domain layer
+- `dotcontext/mcp` is the MCP transport adapter
+
+The main architecture reference, with Mermaid diagrams for runtime flow, boundaries, and packaging, lives in [ARCHITECTURE.md](./ARCHITECTURE.md).
+
+## Problems It Solves
+
+### 1. Context Fragmentation
+
+Every AI coding tool now has a primary surface plus older compatibility paths that still show up in the wild. Dotcontext keeps track of both so teams can write against the current surface without losing legacy imports.
+
+| Tool | Primary surface | Legacy / compatibility surface |
+| --- | --- | --- |
+| Cursor | `.cursor/rules/*.mdc`, `AGENTS.md`-scoped instructions | `.cursorrules`, `.cursor/rules/*.md` |
+| Claude Code | `CLAUDE.md`, `.claude/agents`, `.claude/skills` | older memory-style files under `.claude/` |
+| GitHub Copilot | `.github/copilot-instructions.md`, `.github/instructions/*.instructions.md`, `.github/agents/*.agent.md`, `.github/skills` | `.github/copilot/*` and `.github/.copilot/*` |
+| Windsurf | `AGENTS.md`, `.windsurf/rules`, `.windsurf/skills` | `.windsurfrules`, older `.windsurf/` rule files |
+| Gemini | `GEMINI.md`, `.gemini/commands`, `.gemini/settings.json`, `.gemini/skills` | older `.gemini/` config layouts |
+| Codex | `AGENTS.md`, `.codex/skills`, `.codex/config.toml` | `.codex/instructions.md` |
+| Google Antigravity | `.agents/rules`, `.agents/workflows` | older `.agent/` layouts |
+| Trae AI | `.trae/rules`, `.trae/agents` | older `.trae/` rule files |
+
+Using multiple tools means duplicating rules, playbooks, and documentation across incompatible formats.
+
+### 2. Weak Runtime Control
+
+Most agent setups still rely on:
+
+- a long agent file
+- a few MCP tools
+- best-effort conventions
+
+That is not enough for production-grade behavior. You need runtime controls such as policies, sensors, contracts, and backpressure.
+
+### 3. No Durable Execution Model
+
+Without sessions, traces, artifacts, and replay:
+
+- agents cannot hand off work cleanly
+- failures are hard to cluster and learn from
+- workflow gates are hard to enforce
+- evaluation becomes anecdotal instead of operational
 
-## The Solution
+## What Dotcontext Does
+
+Dotcontext consolidates those concerns into one operating model.
+
+### Shared Context
 
 One `.context/` directory. Works everywhere.
 
@@ -43,11 +105,54 @@ One `.context/` directory. Works everywhere.
 Export to any tool.
 **Write once. Use anywhere. No boilerplate.**
 
+### Harness Runtime
+
+The runtime adds execution controls on top of the shared context:
+
+- durable sessions, traces, artifacts, and checkpoints
+- sensors and backpressure
+- task contracts and handoffs
+- policy enforcement
+- replay and failure dataset generation
+
+### Multi-Surface Access
+
+The same runtime is exposed through:
+
+- `@dotcontext/cli` for operator workflows
+- `dotcontext/mcp` for AI tools
+- `dotcontext/harness` as the reusable domain/runtime boundary
+
+## How The Harness Works
+
+At runtime, both the CLI and the MCP server delegate to the same harness services. The harness is responsible for:
+
+- durable sessions, traces, artifacts, and checkpoints
+- sensors and backpressure
+- task contracts and handoffs
+- policy enforcement
+- replay generation
+- failure dataset clustering
+
+```mermaid
+flowchart LR
+    CLI["CLI"] --> H["Harness Runtime"]
+    MCP["MCP Server"] --> H
+
+    H --> S["Sessions + State"]
+    H --> Q["Sensors + Backpressure"]
+    H --> T["Task Contracts + Handoffs"]
+    H --> P["Policy Engine"]
+    H --> R["Replay + Datasets"]
+```
+
+For the full system view, see [ARCHITECTURE.md](./ARCHITECTURE.md).
+
 > **Using GitHub Copilot, Cursor, Claude, or another AI tool?**
-> Just run `npx @dotcontext/cli mcp:install` — no API key needed!
+> Just run `npx @dotcontext/mcp install` — no API key needed!
 >
 > **Usando GitHub Copilot, Cursor, Claude ou outra ferramenta de IA?**
-> Execute `npx @dotcontext/cli mcp:install` — sem necessidade de API key!
+> Execute `npx @dotcontext/mcp install` — sem necessidade de API key!
 
 > **Note / Nota**
 > Standalone CLI generation is no longer supported. Use MCP-enabled AI tools to create, fill, or refresh context.
@@ -59,7 +164,7 @@ Export to any tool.
 
 #### English
 
-1. Run `npx @dotcontext/cli mcp:install`
+1. Run `npx @dotcontext/mcp install`
 2. Prompt your AI agent: `init the context`
 3. Then: `plan [YOUR TASK] using dotcontext`
 4. After planned: `start the workflow`
@@ -68,237 +173,229 @@ Export to any tool.
 
 #### Português
 
-1. Execute `npx @dotcontext/cli mcp:install`
+1. Execute `npx @dotcontext/mcp install`
 2. Diga ao seu agente de IA: `init the context`
 3. Depois: `plan [SUA TAREFA] using dotcontext`
 4. Após o planejamento: `start the workflow`
 
 **Sem necessidade de API key.** Sua ferramenta de IA fornece o LLM.
 
-### Path 2: Standalone CLI — workflow, sync, imports, and MCP setup
+### Path 2: Standalone CLI — sync, imports, and admin tools
 
 #### English
 
-1. Run `npx @dotcontext/cli`
-2. Use the interactive CLI for workflow, sync, reverse sync, and MCP setup
+1. Run `npx -y @dotcontext/cli@latest`
+2. Use the interactive CLI for sync, reverse sync, hidden admin tools, and MCP setup
 3. When you need context creation or AI-generated content, use your MCP-connected AI tool
 
 #### Português
 
-1. Execute `npx @dotcontext/cli`
-2. Use a CLI interativa para workflow, sincronização, reverse sync e configuração MCP
+1. Execute `npx -y @dotcontext/cli@latest`
+2. Use a CLI interativa para sincronização, reverse sync, ferramentas administrativas ocultas e configuração MCP
 3. Quando precisar criar contexto ou gerar conteúdo com IA, use sua ferramenta conectada via MCP
 
 ## MCP Server Setup
 
 This package includes an MCP (Model Context Protocol) server that provides AI coding assistants with powerful tools to analyze and document your codebase.
 
-### Quick Installation (v0.7.0+)
+### Recommended Installation
 
-Use the MCP Install command to automatically configure the MCP server:
+Use the installer. It is the source of truth for supported tools and config formats:
 
 ```bash
-npx @dotcontext/cli mcp:install
+npx @dotcontext/mcp install
 ```
 
-This interactive command:
+If you already have the MCP package installed globally, `dotcontext-mcp install` works too. The legacy `dotcontext mcp:install` CLI flow still works as a compatibility path.
+
+The installer:
 - Detects installed AI tools on your system
-- Configures dotcontext MCP server in each tool
+- Opens the interactive tool picker when you run `install` in a terminal without a tool id
+- Configures the `dotcontext` MCP server in each tool
 - Supports global (home directory) and local (project directory) installation
-- Merges with existing MCP configurations without overwriting
-- Includes dry-run mode to preview changes
-- Works with Claude Code, Cursor, Windsurf, Codex, Continue.dev, and more
-
-### Manual Configuration
-
-Alternatively, manually configure for your preferred tool.
-
-### Antigravity
-
-#### 1. Access Raw Config
-
-The visual interface only shows official partners, but the manual editing mode allows any local or remote executable.
-
-1. Open the **Agent** panel (usually in the sidebar or `Ctrl+L`).
-2. Click the options menu (three dots `...`) or the settings icon.
-3. Select **Manage MCP Servers**.
-4. At the top of this screen, look for a discreet button or link named **"View raw config"** or **"Edit JSON"**.
+- Falls back to `all` detected tools in non-interactive runs without a tool id
+- Merges with existing MCP configurations without overwriting unrelated servers
+- Includes `--dry-run` and `--verbose` modes
+- Writes the config shape required by each supported client
 
-> **Note:** If you cannot find the button in the UI, you can navigate directly through the file explorer and look for `.idx/mcp.json` or `mcp_config.json` in your workspace root.
+Examples:
 
-#### 2. Add Custom Server
+```bash
+# Interactive install for detected tools
+npx @dotcontext/mcp install
 
-You will see a JSON file. You must add a new entry inside the `"mcpServers"` object.
+# Install for a specific tool
+npx @dotcontext/mcp install codex
 
-Here is the template to add a server (example using `npx` for a Node.js server or a local executable):
+# Install in the current project instead of your home directory
+npx @dotcontext/mcp install cursor --local
 
-```json
-{
-  "mcpServers": {
-    "dotcontext": {
-      "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
-    }
-  }
-}
+# Preview without writing files
+npx @dotcontext/mcp install claude --dry-run --verbose
 ```
 
-#### 3. Restart the Connection
+### Supported MCP Install Targets
+
+`install` currently supports these tool ids:
+
+| Tool ID | Tool | Config Shape |
+| --- | --- | --- |
+| `claude` | Claude Code | `mcpServers` JSON |
+| `cursor` | Cursor AI | `mcpServers` JSON with `type: "stdio"` |
+| `windsurf` | Windsurf | `mcpServers` JSON |
+| `continue` | Continue.dev | standalone `.continue/mcpServers/dotcontext.json` |
+| `claude-desktop` | Claude Desktop | `mcpServers` JSON |
+| `vscode` | VS Code (GitHub Copilot) | `servers` JSON |
+| `roo` | Roo Code | `mcpServers` JSON |
+| `amazonq` | Amazon Q Developer CLI | `mcpServers` JSON |
+| `gemini-cli` | Gemini CLI | `mcpServers` JSON |
+| `codex` | Codex CLI | TOML `[mcp_servers.dotcontext]` |
+| `kiro` | Kiro | `mcpServers` JSON |
+| `zed` | Zed Editor | `context_servers` JSON |
+| `jetbrains` | JetBrains IDEs | `servers` array |
+| `trae` | Trae AI | `mcpServers` JSON |
+| `kilo` | Kilo Code | `mcp` JSON |
+| `copilot-cli` | GitHub Copilot CLI | `mcpServers` JSON |
 
-After saving the `mcp.json` file:
-
-1. Return to the **"Manage MCP Servers"** panel.
-2. Click the **Refresh** button or restart the Antigravity environment (*Reload Window*).
-3. The new server should appear in the list with a status indicator (usually a green light if connected successfully).
+### Manual Configuration
 
-### Claude Code (CLI)
+Use manual configuration only when you cannot use `@dotcontext/mcp install`. The exact file format depends on the client.
 
-Add the MCP server using the Claude CLI:
+Dotcontext writes this command into client configs:
 
-```bash
-claude mcp add dotcontext -- npx @dotcontext/cli mcp
+```text
+command: npx
+args: ["-y", "@dotcontext/mcp@latest"]
 ```
 
-Or configure manually in `~/.claude.json`:
+#### Standard `mcpServers` JSON
+
+Used by tools such as Claude Code, Windsurf, Claude Desktop, Roo Code, Amazon Q Developer CLI, Gemini CLI, Trae AI, and GitHub Copilot CLI.
 
 ```json
 {
   "mcpServers": {
     "dotcontext": {
       "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
+      "args": ["-y", "@dotcontext/mcp@latest"]
     }
   }
 }
 ```
 
-### Claude Desktop
+#### Cursor
 
-Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):
+Cursor expects `type: "stdio"`:
 
 ```json
 {
   "mcpServers": {
     "dotcontext": {
+      "type": "stdio",
       "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
+      "args": ["-y", "@dotcontext/mcp@latest"]
     }
   }
 }
 ```
 
-### Cursor AI
+#### Continue.dev
 
-Create `.cursor/mcp.json` in your project root:
+Continue uses a standalone per-server file:
 
 ```json
 {
-  "mcpServers": {
-    "dotcontext": {
-      "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
-    }
-  }
+  "command": "npx",
+  "args": ["-y", "@dotcontext/mcp@latest"],
+  "env": {}
 }
 ```
 
-### Windsurf
+#### VS Code (GitHub Copilot)
 
-Add to your Windsurf MCP config (`~/.codeium/windsurf/mcp_config.json`):
+VS Code uses `servers` instead of `mcpServers`:
 
 ```json
 {
-  "mcpServers": {
+  "servers": {
     "dotcontext": {
+      "type": "stdio",
       "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
+      "args": ["-y", "@dotcontext/mcp@latest"]
     }
   }
 }
 ```
 
-### Zed Editor
+#### Zed
 
-Add to your Zed settings (`~/.config/zed/settings.json`):
+Zed uses `context_servers`:
 
 ```json
 {
   "context_servers": {
     "dotcontext": {
-      "command": {
-        "path": "npx",
-        "args": ["@dotcontext/cli", "mcp"]
-      }
+      "command": "npx",
+      "args": ["-y", "@dotcontext/mcp@latest"],
+      "env": {}
     }
   }
 }
 ```
 
-### Cline (VS Code Extension)
+#### JetBrains IDEs
 
-Configure in Cline settings (VS Code → Settings → Cline → MCP Servers):
+JetBrains uses a `servers` array:
 
 ```json
 {
-  "mcpServers": {
-    "dotcontext": {
+  "servers": [
+    {
+      "name": "dotcontext",
       "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
+      "args": ["-y", "@dotcontext/mcp@latest"],
+      "env": {}
     }
-  }
+  ]
 }
 ```
 
-### Codex CLI
+#### Kilo Code
 
-Add to your Codex CLI config (`~/.codex/config.toml`):
-
-```toml
-[mcp_servers.dotcontext]
-command = "npx"
-args = ["--yes", "@dotcontext/cli@latest", "mcp"]
-```
-
-### Google Antigravity
-
-Add to your Antigravity MCP config (`~/.gemini/mcp_config.json`):
+Kilo uses `mcp.dotcontext` with a command array:
 
 ```json
 {
-  "mcpServers": {
+  "mcp": {
     "dotcontext": {
-      "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
+      "type": "local",
+      "command": ["npx", "-y", "@dotcontext/mcp@latest"],
+      "enabled": true
     }
   }
 }
 ```
 
-### Trae AI
+#### Codex CLI
 
-Add to your Trae AI MCP config (Settings > MCP Servers):
+Codex uses TOML:
 
-```json
-{
-  "mcpServers": {
-    "dotcontext": {
-      "command": "npx",
-      "args": ["@dotcontext/cli", "mcp"]
-    }
-  }
-}
+```toml
+[mcp_servers.dotcontext]
+command = "npx"
+args = ["-y", "@dotcontext/mcp@latest"]
 ```
 
 ### Local Development
 
-For local development, point directly to the built distribution:
+For local development, point directly to the dedicated MCP binary after `npm run build`:
 
 ```json
 {
   "mcpServers": {
     "dotcontext-dev": {
       "command": "node",
-      "args": ["/path/to/dotcontext-cli/dist/index.js", "mcp"]
+      "args": ["/absolute/path/to/this-repo/dist/mcp/bin.js"]
     }
   }
 }
@@ -435,7 +532,7 @@ The system automatically detects project scale and adjusts the workflow:
 
 - Node.js 20+
 
-**Context creation, AI generation, and refresh are MCP-only.** Use `npx dotcontext mcp:install` and let your AI tool use its own LLM.
+**Context creation, AI generation, and refresh are MCP-only.** Use `npx @dotcontext/mcp install` and let your AI tool use its own LLM.
 
 ### Available MCP Tools
 
@@ -446,12 +543,16 @@ Once configured, your AI assistant will have access to 9 gateway tools with acti
 | Gateway | Description | Actions |
 |---------|-------------|---------|
 | **explore** | File and code exploration | `read`, `list`, `analyze`, `search`, `getStructure` |
-| **context** | Context scaffolding and semantic context | `check`, `init`, `fill`, `fillSingle`, `listToFill`, `getMap`, `buildSemantic`, `scaffoldPlan` |
+| **context** | Context scaffolding, semantic context, and optional Q&A/flow helpers | `check`, `bootstrapStatus`, `init`, `fill`, `fillSingle`, `listToFill`, `getMap`, `buildSemantic`, `scaffoldPlan`, `searchQA`, `generateQA`, `getFlow`, `detectPatterns` |
 | **plan** | Plan management and execution tracking | `link`, `getLinked`, `getDetails`, `getForPhase`, `updatePhase`, `recordDecision`, `updateStep`, `getStatus`, `syncMarkdown`, `commitPhase` |
 | **agent** | Agent orchestration and discovery | `discover`, `getInfo`, `orchestrate`, `getSequence`, `getDocs`, `getPhaseDocs`, `listTypes` |
 | **skill** | Skill management for on-demand expertise | `list`, `getContent`, `getForPhase`, `scaffold`, `export`, `fill` |
 | **sync** | Import/export synchronization with AI tools | `exportRules`, `exportDocs`, `exportAgents`, `exportContext`, `exportSkills`, `reverseSync`, `importDocs`, `importAgents`, `importSkills` |
 
+`context init` also bootstraps `.context/harness/sensors.json`. While that catalog is still in bootstrap form, `context listToFill`/`fill` can return it so the AI can customize project-specific quality sensors.
+
+`searchQA` ranks generated `.context/docs/qa/*.md` helper docs by keyword match. It is a lightweight shortcut, not embedding-based semantic retrieval, and `generateQA` is opt-in.
+
 #### Dedicated Workflow Tools
 
 | Tool | Description |
@@ -489,8 +590,8 @@ Skills are task-specific procedures that AI agents activate when needed:
 | `security-audit` | Security review checklist | R, V |
 
 ```bash
-npx dotcontext skill list   # List available skills
-npx dotcontext skill export # Export to AI tools
+npx -y @dotcontext/cli@latest admin skill list   # List available skills
+npx -y @dotcontext/cli@latest admin skill export # Export to AI tools
 ```
 
 Use MCP tools from your AI assistant to scaffold, fill, or refresh skills and other context files.
@@ -528,7 +629,7 @@ The previous name `@ai-coders/context` caused frequent confusion with **Context7
 | Before | After |
 |--------|-------|
 | `npm install @ai-coders/context` | `npm install @dotcontext/cli` |
-| `npx @ai-coders/context` | `npx dotcontext` |
+| `npx @ai-coders/context` | `npx -y @dotcontext/cli@latest` |
 | CLI command: `ai-context` | CLI command: `dotcontext` |
 | MCP server name: `"ai-context"` | MCP server name: `"dotcontext"` |
 | Env var: `AI_CONTEXT_LANG` | Env var: `DOTCONTEXT_LANG` |
@@ -551,9 +652,9 @@ The previous name `@ai-coders/context` caused frequent confusion with **Context7
 
 2. **Update MCP configurations** -- re-run the installer:
    ```bash
-   npx dotcontext mcp:install
+   npx @dotcontext/mcp install
    ```
-   Or manually replace `"ai-context"` with `"dotcontext"` and `"@ai-coders/context"` with `"@dotcontext/cli"` in your MCP JSON configs.
+   Or manually replace `"ai-context"` with `"dotcontext"` and `"@ai-coders/context"` with `"@dotcontext/mcp"` in your MCP JSON configs.
 
 3. **Update shell aliases** -- replace `ai-context` with `dotcontext` in your `.bashrc`, `.zshrc`, or equivalent.
 

package/dist/cli/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CLI boundary exports.
+ *
+ * This module defines the operator-facing surface that is expected to
+ * become the future `dotcontext/cli` package. Keep domain/runtime logic
+ * out of this boundary whenever possible.
+ */
+export { MCPInstallService, buildMcpInstallToolChoices, resolveMcpInstallToolSelection, type MCPInstallServiceDependencies, type MCPInstallOptions, type MCPInstallResult, type MCPInstallation, type MCPInstallToolChoice, type MCPInstallToolPrompt, type ResolveMcpInstallToolSelectionOptions, StateDetector, type ProjectState, type StateDetectionResult, type StateDetectorOptions, } from '../services/cli';
+export { SyncService } from '../services/sync/syncService';
+export { ImportRulesService, ImportAgentsService } from '../services/import';
+export { ExportRulesService } from '../services/export';
+export { ReportService } from '../services/report';
+export { QuickSyncService, type QuickSyncOptions } from '../services/quickSync';
+export { ReverseQuickSyncService, type MergeStrategy } from '../services/reverseSync';
+//# 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;;;;;;GAMG;AAEH,OAAO,EACL,iBAAiB,EACjB,0BAA0B,EAC1B,8BAA8B,EAC9B,KAAK,6BAA6B,EAClC,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,qCAAqC,EAC1C,aAAa,EACb,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * CLI boundary exports.
+ *
+ * This module defines the operator-facing surface that is expected to
+ * become the future `dotcontext/cli` package. Keep domain/runtime logic
+ * out of this boundary whenever possible.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReverseQuickSyncService = exports.QuickSyncService = exports.ReportService = exports.ExportRulesService = exports.ImportAgentsService = exports.ImportRulesService = exports.SyncService = exports.StateDetector = exports.resolveMcpInstallToolSelection = exports.buildMcpInstallToolChoices = exports.MCPInstallService = void 0;
+var cli_1 = require("../services/cli");
+Object.defineProperty(exports, "MCPInstallService", { enumerable: true, get: function () { return cli_1.MCPInstallService; } });
+Object.defineProperty(exports, "buildMcpInstallToolChoices", { enumerable: true, get: function () { return cli_1.buildMcpInstallToolChoices; } });
+Object.defineProperty(exports, "resolveMcpInstallToolSelection", { enumerable: true, get: function () { return cli_1.resolveMcpInstallToolSelection; } });
+Object.defineProperty(exports, "StateDetector", { enumerable: true, get: function () { return cli_1.StateDetector; } });
+var syncService_1 = require("../services/sync/syncService");
+Object.defineProperty(exports, "SyncService", { enumerable: true, get: function () { return syncService_1.SyncService; } });
+var import_1 = require("../services/import");
+Object.defineProperty(exports, "ImportRulesService", { enumerable: true, get: function () { return import_1.ImportRulesService; } });
+Object.defineProperty(exports, "ImportAgentsService", { enumerable: true, get: function () { return import_1.ImportAgentsService; } });
+var export_1 = require("../services/export");
+Object.defineProperty(exports, "ExportRulesService", { enumerable: true, get: function () { return export_1.ExportRulesService; } });
+var report_1 = require("../services/report");
+Object.defineProperty(exports, "ReportService", { enumerable: true, get: function () { return report_1.ReportService; } });
+var quickSync_1 = require("../services/quickSync");
+Object.defineProperty(exports, "QuickSyncService", { enumerable: true, get: function () { return quickSync_1.QuickSyncService; } });
+var reverseSync_1 = require("../services/reverseSync");
+Object.defineProperty(exports, "ReverseQuickSyncService", { enumerable: true, get: function () { return reverseSync_1.ReverseQuickSyncService; } });
+//# 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;;;;;;GAMG;;;AAEH,uCAeyB;AAdvB,wGAAA,iBAAiB,OAAA;AACjB,iHAAA,0BAA0B,OAAA;AAC1B,qHAAA,8BAA8B,OAAA;AAQ9B,oGAAA,aAAa,OAAA;AAMf,4DAA2D;AAAlD,0GAAA,WAAW,OAAA;AACpB,6CAA6E;AAApE,4GAAA,kBAAkB,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAChD,6CAAwD;AAA/C,4GAAA,kBAAkB,OAAA;AAC3B,6CAAmD;AAA1C,uGAAA,aAAa,OAAA;AACtB,mDAAgF;AAAvE,6GAAA,gBAAgB,OAAA;AACzB,uDAAsF;AAA7E,sHAAA,uBAAuB,OAAA"}