icopilot 2.2.0

package/CHANGELOG.md

@@ -0,0 +1,250 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.1.0] — 2026-06-28
+
+### Added — v2.1 Competitive Parity
+- **Image input** — vision model detection, base64 encoding, screenshot context (`src/context/image-input.ts`)
+- **Git undo** — AI commit tracking with `git reset --soft` and safety guards (`src/commands/git-undo-cmd.ts`)
+- **Web scraping** — `/web <url> [focus]` with HTML→markdown conversion (`src/commands/web-cmd.ts`)
+- **Lifecycle hooks** — 10 event types with preToolUse deny/modify via JSON stdin/stdout (`src/hooks/lifecycle.ts`)
+- **Diff-based editing** — SEARCH/REPLACE blocks with fuzzy matching and `/edit-format` (`src/tools/diff-edit.ts`)
+- **External editor** — `$VISUAL`/`$EDITOR` detection with `.md` temp files (`src/commands/editor-cmd.ts`)
+- **Reasoning control** — `/reasoning` and `/think-tokens` with API wiring (`src/commands/reasoning-cmd.ts`)
+- **Auto-lint & auto-test** — run linter/tests after AI edits with auto-fix loop (`src/tools/auto-check.ts`)
+- **Per-message mode switching** — `/ask`, `/code`, `/architect` per-turn prefixes (`src/commands/mode-prefix.ts`)
+- **Mid-session diff** — `/changes` with per-turn git snapshots (`src/commands/changes-cmd.ts`)
+- **Runtime settings** — `/settings KEY VALUE` with `~/.icopilotrc.json` persistence (`src/commands/settings-cmd.ts`)
+- **User feedback** — `/feedback` with offline storage and optional GitHub issue (`src/commands/feedback-cmd.ts`)
+- **Context visualization** — visual `/context` usage view + `/usage` alias (`src/commands/context-viz-cmd.ts`)
+- **Auto-memory** — AI self-learning with 28-day retention and `/memory auto` (`src/knowledge/auto-memory.ts`)
+- **Scheduled prompts** — `/every` and `/after` for recurring/delayed tasks (`src/commands/schedule-cmd.ts`)
+- **Read-only files** — `/read-only` with file protection (`src/commands/schedule-cmd.ts`)
+- **Clipboard operations** — `/paste`, `/copy-context`, `/run` with output injection (`src/commands/clipboard-cmd.ts`)
+
+### Fixed
+- Wiring issues: `/dead-code` handler, `--perf-trace` flag, completion deduplication, aggregator integration
+- Slash test assertion for `/copy-context` return shape
+
+## [2.0.0] — 2026-06-27
+
+### Added — v1.4 Multi-Agent Orchestration
+- Parallel agent runner with concurrent sub-agent execution
+- Agent result aggregation with merged multi-agent output
+- Custom agent definitions via `.icopilot/agents/*.yaml`
+- Agent routing with automatic delegation by query type
+- `run_in_terminal` tool for interactive PTY command execution
+- `list_directory` tool for structured directory listing
+- `search_symbols` tool for AST-aware symbol search
+- Tool retry logic with automatic retry on transient failures
+
+### Added — v1.5 Copilot Spaces & Teams
+- Project spaces with isolated context sandboxes per project/branch
+- Session handoff for exporting state to another developer
+- Shared team memory via `.icopilot/team-memory.md`
+- Smart file selection with model-driven relevant file picking
+- Git-aware context auto-including recently modified files
+- Dependency-aware context following imports to include related files
+- Context priority scoring with relevance-ranked sources
+
+### Added — v1.6 IDE-Grade Intelligence
+- Symbol index for project-wide function/class/type table
+- Cross-file navigation (go-to-definition, find-references)
+- Multi-file atomic edits reviewed holistically
+- Code generation with automatic test file creation
+- Live error watching with auto-suggested fixes
+- Stack trace analysis for AI-powered root cause diagnosis
+- Dead code detection identifying unused exports/functions
+
+### Added — v1.7 Workflow Automation
+- Workflow engine with `.icopilot/workflows/*.yaml` definitions
+- Built-in workflows (review-and-commit, test-fix-loop, release-prep)
+- GitHub Actions helper generating workflow YAML from natural language
+- Pre-commit hook with `/review` + `/security` before commit
+- File watch triggers running workflows on change
+- Release automation (version bump → changelog → tag → publish)
+
+### Added — v1.8 Knowledge & Learning
+- Project RAG with chunked document indexing and retrieval
+- `/doc` command for generating JSDoc/docstring
+- README generation from project analysis
+- Architecture diagram generation (mermaid from code)
+- Style learning adapting to user's coding patterns
+- Correction memory remembering user corrections
+- Project conventions learning and enforcement
+
+### Added — v1.9 Enterprise & Security
+- Role-based tool access restricting by user role
+- Audit logging with full trail of tool executions
+- Proxy support (HTTP/HTTPS/SOCKS5)
+- Air-gapped mode with local models (Ollama, vLLM)
+- Content filtering preventing PII in prompts
+- Retention policies with auto-delete after N days
+
+### Added — v2.0 The Complete Agentic OS
+- Goal-driven development (describe feature → implement end-to-end)
+- Self-healing builds (detect failure → diagnose → fix → retry)
+- TDD agent (write tests first, implement until green)
+- Multi-repo orchestration coordinating across repositories
+- Plugin marketplace (`icopilot install <plugin>`)
+- Custom model providers (any OpenAI-compatible endpoint)
+- IDE bridge for bidirectional VS Code / Neovim communication
+- API server mode exposing as HTTP API (`--serve`)
+- Container sandbox for Docker-based isolated execution
+- Cloud sessions for remote access from any terminal
+
+## [1.3.0] — 2026-06-27
+
+### Added — Agent Runtime & Extensibility
+- Agent system prompt framework with persona + tool binding
+- Background agent tasks with `&` suffix syntax
+- Agent memory (persistent knowledge across sessions)
+- Custom slash-command plugins via `.icopilot/plugins/`
+- Streaming tool output with real-time display
+- Tool composition (pipe output of one tool into another)
+- Multi-model routing (different models per task type)
+- Context-aware model switching
+- Agent self-reflection and correction loop
+- Conversation branching (fork conversation, explore alternatives)
+- Undo/redo for file edits
+- Checkpoint/restore for session state
+- Interactive conflict resolution for file edits
+- Rate-limit-aware request scheduling
+- Token-budget auto-split for long conversations
+- Project-wide semantic search
+
+## [Unreleased]
+
+## [2.2.0] - 2026-06-29
+
+
+### Added — v0.2 Quality & DX
+
+- **Tests** — Vitest suite covering `context/file-refs`, `session`, `tools/file-ops`,
+  `commands/slash`, and API retry smoke behavior (18 tests).
+- **Lint + Format** — ESLint (typescript-eslint) with Prettier integration; new
+  `npm run lint`, `lint:fix`, `format`, `format:check`, `typecheck`, `coverage`
+  scripts.
+- **CI** — GitHub Actions matrix for Node 18 / 20 / 22 on Ubuntu + Windows.
+- **Structured logging** — `src/logger.ts` with `--verbose` / `ICOPILOT_DEBUG=1` and
+  automatic redaction of `ghp_*`, `gho_*`, `Bearer …`, and `"token":"…"` patterns.
+- **Friendly errors** — classified messages for missing `GITHUB_TOKEN`, network
+  failures, 401/403 auth, and unknown models.
+- **Config file** — `~/.icopilotrc.json` merged with env vars and CLI flags (see
+  `docs/config.md`).
+- **Theming** — auto-detect `NO_COLOR`, `CI`, non-TTY; `--theme light|dark|none`
+  and `ICOPILOT_THEME=`.
+- **Windows polish** — prompt prefix falls back to ASCII outside Windows Terminal;
+  CI coverage for Windows.
+
+### Added — v0.3 Tooling & Agentic Power
+
+- **`apply_patch` tool** — model emits a unified diff; user picks hunks via an
+  interactive checkbox before any file is touched.
+- **Multi-file write transactions** — `proposeWriteBatch` shows a combined diff
+  preview and rolls back on partial failure.
+- **`grep` and `glob` read-only tools** — model can search the repo without
+  shelling out.
+- **`--sandbox`** opt-in mode restricts shell + write tools to the working
+  directory.
+- **Policy file** — `.icopilot/policy.json` / `~/.icopilot/policy.json` with
+  `allowShell`, `denyShell`, `allowWrite`, `denyWrite` patterns.
+- **Always-allow memory** — per-session "remember this command/path" to avoid
+  re-prompting for trusted operations.
+
+### Added — v0.4 Extensibility (MCP)
+
+- **MCP client** — minimal stdio JSON-RPC client (`src/mcp/client.ts`) with
+  LSP-style framing fallback and per-request timeout.
+- **MCP loader** — `~/.icopilot/mcp.json` + project-local `.mcp.json` discovered
+  and merged; project values win on conflict.
+- **Tool namespacing** — exposed MCP tools are surfaced as
+  `mcp__<server>__<tool>` to avoid collisions with built-ins.
+- See `docs/mcp.md`.
+
+### Added — v0.5 Sessions & Memory
+
+- **`/sessions`** — interactive picker to list and resume any saved session.
+- **`/export [md|json] [path]`** — write the current conversation as Markdown or
+  JSON.
+- **Per-project memory** — `.icopilot/memory.md` and `~/.icopilot/memory.md`
+  auto-injected into the system prompt.
+- **Rolling auto-summarize** — `Session.shouldAutoSummarize()` helper for hitting
+  the soft budget threshold.
+- See `docs/sessions.md`.
+
+### Added — v0.6 Git & Collaboration
+
+- **`/review`** — review staged changes; model surfaces bugs, security, perf.
+- **`/issue [title]`** — draft a GitHub issue from the current context; copies to
+  clipboard when available and offers `gh issue create`.
+- **`/branch <topic>`** — generate a conventional branch name and `git checkout
+  -b` after confirmation.
+
+### Changed
+
+- Tool registry now lazily loads MCP servers on first use and merges their tool
+  schemas with the built-ins.
+- File-write and shell tools enforce policy + sandbox before prompting the user.
+
+### Notes — deferred / exploratory
+
+The remaining `roadmap.md` items have shipped as **extension points** rather
+than full implementations — see `docs/future.md`:
+
+- Voice input — `SpeechProvider` interface (`src/extensions/voice.ts`)
+- Team mode — `TeamTransport` interface (`src/extensions/team.ts`)
+- Plugin marketplace — `PluginCatalog` interface and `LocalPluginCatalog`
+  default (`src/extensions/marketplace.ts`)
+
+Third-party packages can register real implementations without forking
+iCopilot.
+
+### Added — v0.7 Performance
+
+- Lazy `marked` / `marked-terminal` / `gpt-tokenizer` imports — they no longer
+  load until the first markdown render or token count.
+- `StreamSink` highlights fenced code blocks incrementally during streaming.
+- Worker-thread token counting for inputs ≥ 200 KB.
+- `npm run perf:cold-start` benchmark script; documented baselines in
+  `docs/performance.md`. The original `< 150 ms` cold-start goal was revised
+  to a measurable `< 800 ms` on Linux Node 20.
+
+### Added — v1.0 Release engineering
+
+- `docs/api.md` freezes the public surface with stability tiers.
+- `docs/index.md`, `docs/recipes.md` (14 recipes), `docs/release.md`.
+- `scripts/release.mjs` + `scripts/changelog.mjs` automate version bump,
+  changelog rotation, commit, and tag.
+- `.github/workflows/release.yml` publishes to npm with `--provenance` on tag
+  push and creates a GitHub Release from the changelog.
+- `tests/smoke/cli.smoke.test.ts` + `scripts/smoke.mjs` validate `--help`,
+  `--version`, and missing-token error paths.
+- LICENSE (MIT), `.npmignore`, and `package.json#files` allowlist.
+- Real SVG screenshots in README (`scripts/screenshots.mjs`).
+
+### Added — Beyond 1.0
+
+- Opt-in `--tui` mode (`src/modes/tui.ts`, no extra deps).
+- `/route get|set|list` multi-model routing with `cheap` / `balanced` /
+  `strong` / `fixed` profiles.
+- `/index build|status|search` workspace embeddings index using GitHub Models
+  embeddings.
+
+### Notes — deferred / exploratory
+
+The following items from `roadmap.md` are intentionally shipped as
+**extension points** rather than full reference implementations. Plug a real
+implementation in by registering against the interface — see
+`docs/future.md`:
+
+- Voice input — `SpeechProvider` (`src/extensions/voice.ts`)
+- Team mode over WebRTC — `TeamTransport` (`src/extensions/team.ts`)
+- Plugin marketplace — `PluginCatalog` (`src/extensions/marketplace.ts`)
+
+Cold-start: original `< 150 ms` goal revised to `< 800 ms` on Linux Node 20
+based on measured baselines (Windows median ≈ 2.1 s, Linux median ≈ 350 ms).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iCopilot contributors
+
+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,214 @@
+# iCopilot
+
+A terminal-native, agentic CLI assistant — fully replicating and enhancing
+the modern GitHub Copilot CLI experience, powered exclusively by the
+**GitHub Models API**.
+
+**Version 2.0** — The Complete Agentic OS.
+
+<p align="center">
+  <img src="./docs/screenshots/repl.svg" alt="iCopilot REPL with streaming response, shell proposal, and file write" width="820">
+</p>
+
+## Features
+
+### Core Experience
+- 🗣️  **Interactive REPL** with live, streaming markdown responses
+- 🧭  **Plan Mode** — produces step lists for review before any change
+- ⚡  **One-shot mode** — `icopilot -p "..."` for scripting / piping
+- 📎  **`@file` references** auto-inject file contents into context
+- 🛠️  **Agentic tools** — shell + file edits gated by `[Y/n]` confirmation
+- 🧠  **Token budget** tracker with auto-suggest `/compact`
+- 💾  **Session persistence** — resume via `/sessions`
+- 🪶  **Graceful SIGINT** — Ctrl-C aborts a stream, never the app
+- 🔁  **HTTP 429 backoff** with cooldown banners
+
+### Multi-Agent Orchestration (v1.4)
+- 🤖  **Parallel agent runner** — concurrent sub-agent execution with `&` syntax
+- 🧩  **Custom agent definitions** — `.icopilot/agents/*.yaml`
+- 🎯  **Agent routing** — automatic delegation by query type
+- 🔄  **Tool retry logic** — automatic retry on transient failures
+
+### Copilot Spaces & Teams (v1.5)
+- 📦  **Project spaces** — isolated context sandboxes per project/branch
+- 🤝  **Session handoff** — export state for another developer
+- 🧠  **Team memory** — shared `.icopilot/team-memory.md`
+- 📂  **Smart file selection** — model-driven relevant file picking
+- 🌿  **Git-aware context** — auto-include recently modified files
+
+### IDE-Grade Intelligence (v1.6)
+- 🔍  **Symbol index** — project-wide function/class/type table
+- 🧭  **Cross-file navigation** — go-to-definition, find-references
+- ✏️  **Multi-file atomic edits** — N-file changes reviewed holistically
+- 🧪  **Code generation with tests** — auto-generate test file for new modules
+- 👁️  **Live error watching** — monitor build output, auto-suggest fixes
+- 🕵️  **Stack trace analysis** — AI-powered root cause diagnosis
+
+### Workflow Automation (v1.7)
+- ⚙️  **Workflow engine** — `.icopilot/workflows/*.yaml` with conditionals and loops
+- 🚀  **GitHub Actions helper** — generate CI YAML from natural language
+- 🪝  **Pre-commit hook** — `/review` + `/security` before commit
+- 📁  **File watch triggers** — run workflow on file change
+- 📦  **Release automation** — version bump → changelog → tag → publish
+
+### Knowledge & Learning (v1.8)
+- 📚  **Project RAG** — chunk and index all docs for retrieval
+- 📝  **Doc generation** — JSDoc/docstring from code
+- 📖  **README generation** — scaffold from project analysis
+- 🏗️  **Architecture diagrams** — mermaid from code relationships
+- 🎨  **Style learning** — adapt to user's coding patterns
+- 💡  **Correction memory** — remember and apply user corrections
+- 📏  **Project conventions** — learn and enforce patterns
+
+### Enterprise & Security (v1.9)
+- 🔐  **Role-based access** — restrict tools by user role
+- 📋  **Audit logging** — full trail of all tool executions
+- 🌐  **Proxy support** — HTTP/HTTPS/SOCKS5
+- 🏠  **Air-gapped mode** — local models (Ollama, vLLM)
+- 🛡️  **Content filtering** — prevent PII in prompts
+- 🗑️  **Retention policies** — auto-delete after N days
+
+### The Complete Agentic OS (v2.0)
+- 🎯  **Goal-driven development** — describe feature → implement end-to-end
+- 🔧  **Self-healing builds** — detect failure → diagnose → fix → retry
+- 🧪  **TDD agent** — write tests first, implement until green
+- 🌐  **Multi-repo orchestration** — coordinate across repositories
+- 🏪  **Plugin marketplace** — `icopilot install <plugin>`
+- 🔌  **Custom model providers** — any OpenAI-compatible endpoint
+- 🖥️  **IDE bridge** — bidirectional VS Code / Neovim communication
+- 🌍  **API server mode** — expose as HTTP API (`--serve`)
+- 🐳  **Container sandbox** — Docker-based isolated execution
+- ☁️  **Cloud sessions** — run in cloud, access from any terminal
+
+### Slash Commands
+
+```
+/help /clear /model /cwd /diff /context /compact /sessions /export
+/commit /pr /review /issue /branch /plan /lint /test /security
+/agent /space /workflow /actions /release /doc /readme /diagram
+/rag /conventions /corrections /audit /proxy /provider /goal /heal
+/tdd /repo /serve /exit
+```
+
+## Install
+
+```bash
+npm install
+npm run build
+npm link        # exposes `icopilot` / `icli` globally
+```
+
+## Auth
+
+Set a GitHub PAT with `models:read`:
+
+```bash
+# bash / zsh
+export GITHUB_TOKEN=ghp_xxx...
+
+# PowerShell
+$env:GITHUB_TOKEN = "ghp_xxx..."
+```
+
+Optional:
+
+```bash
+ICOPILOT_MODEL=gpt-4o          # default model
+ICOPILOT_ENDPOINT=https://models.inference.ai.azure.com
+```
+
+## Usage
+
+```bash
+icopilot                                   # interactive REPL
+icopilot -p "Explain @src/index.ts"        # one-shot
+icopilot --model gpt-4o                    # pin model
+icopilot --plan                            # start in plan mode
+icopilot --sandbox                         # restrict tools to cwd
+icopilot --local                           # use local model (Ollama)
+icopilot --provider my-provider            # custom model provider
+icopilot --serve 3000                      # start as HTTP API server
+icopilot --verbose --log-level debug       # structured logs to stderr
+icopilot --theme light                     # light / dark / none
+```
+
+<p align="center">
+  <img src="./docs/screenshots/help.svg" alt="icopilot --help" width="820">
+</p>
+
+See [`docs/config.md`](./docs/config.md) for the full config-file format,
+[`docs/sessions.md`](./docs/sessions.md) for session/memory usage, and
+[`docs/mcp.md`](./docs/mcp.md) for MCP server integration.
+
+Inside the REPL:
+
+```
+> /help
+> /model gpt-4o-mini
+> Refactor @src/api/github-models.ts to add caching
+> /goal "Add user authentication"
+> /heal
+> /tdd "Create a rate limiter"
+> /review
+> /commit
+> /pr
+> /sessions
+> /export md
+> /exit
+```
+
+### When something goes wrong
+
+Errors are classified and re-rendered with actionable hints. For example,
+running without a token:
+
+<p align="center">
+  <img src="./docs/screenshots/missing-token.svg" alt="Friendly missing-token error" width="820">
+</p>
+
+### Version
+
+<p align="center">
+  <img src="./docs/screenshots/version.svg" alt="icopilot --version" width="520">
+</p>
+
+> **About the screenshots.** They are deterministic SVG renderings of the
+> actual binary's output (ANSI colors preserved). Regenerate them after any
+> UX change with `npm run screenshots`.
+
+## Architecture
+
+```
+src/
+├── index.ts              # entry / CLI flag parsing
+├── config.ts             # env + rc-file + runtime config
+├── logger.ts             # structured logging + secret redaction
+├── api/github-models.ts  # OpenAI-SDK client → GitHub Models
+├── session/              # history, persistence, multi-session, cloud sessions, handoff
+├── context/              # @file parser, /compact, project memory, smart files, git/dep context
+├── tools/                # shell, file ops, apply_patch, grep, glob, multi-edit, retry, policy
+├── mcp/                  # Model Context Protocol client + loader
+├── commands/             # slash dispatcher, git autopilot, 40+ commands
+├── agents/               # parallel runner, router, goal-driven, TDD, self-heal, multi-repo
+├── intelligence/         # symbol index, navigation, error watch, stack trace, dead code
+├── workflows/            # engine, file triggers, built-in workflows
+├── knowledge/            # RAG, style learner, corrections, conventions
+├── security/             # RBAC, audit, content filter, retention, proxy
+├── providers/            # custom model providers, local models
+├── plugins/              # marketplace, plugin loader
+├── server/               # HTTP API server mode
+├── bridge/               # IDE bridge (VS Code, Neovim)
+├── sandbox/              # container-based execution
+├── spaces/               # project spaces, space config
+├── hooks/                # precommit, git hooks
+├── ui/                   # streaming markdown render, theme, prompt
+└── modes/                # interactive / plan / oneshot
+```
+
+See [`roadmap.md`](./roadmap.md) for the version plan, [`TODO.md`](./TODO.md)
+for the implementation checklist, and [`CHANGELOG.md`](./CHANGELOG.md) for
+release notes.
+
+## License
+
+MIT

package/bin/icopilot.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// iCopilot entrypoint — delegates to the compiled ESM bundle.
+import('../dist/index.js').catch((err) => {
+  console.error('\x1b[31m[icopilot] fatal:\x1b[0m', err?.stack || err);
+  process.exit(1);
+});

package/dist/acp/router.js

@@ -0,0 +1,123 @@
+import { TOOL_SCHEMAS, dispatchTool } from '../tools/registry.js';
+import { JSON_RPC_ERROR_CODES, createJsonRpcError, createJsonRpcResponse, isValidMethodName, parseMethodNamespace, validateJsonRpcRequest, } from './schema.js';
+const VERSION = '2.2.0';
+export class AcpRouter {
+    version;
+    onLog;
+    constructor(options) {
+        this.version = options?.version ?? VERSION;
+        this.onLog = options?.onLog ?? (() => { });
+    }
+    async handle(request) {
+        const validation = validateJsonRpcRequest(request);
+        if (!validation.valid) {
+            this.onLog('warn', 'Invalid JSON-RPC request', validation.error);
+            return createJsonRpcError(JSON_RPC_ERROR_CODES.INVALID_REQUEST, validation.error ?? 'Invalid request');
+        }
+        const req = request;
+        if (!isValidMethodName(req.method)) {
+            this.onLog('warn', 'Invalid method name', { method: req.method });
+            return createJsonRpcError(JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND, 'Invalid method name', undefined, req.id);
+        }
+        this.onLog('debug', 'ACP request', { method: req.method, id: req.id });
+        try {
+            const { namespace, action } = parseMethodNamespace(req.method);
+            switch (namespace) {
+                case 'tools':
+                    return await this.handleToolsMethod(action, req);
+                case 'tool':
+                    return await this.handleToolMethod(action, req);
+                case 'capabilities':
+                    return await this.handleCapabilitiesMethod(action, req);
+                default:
+                    this.onLog('warn', 'Unknown method namespace', { namespace, method: req.method });
+                    return createJsonRpcError(JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND, `Unknown method: ${req.method}`, undefined, req.id);
+            }
+        }
+        catch (error) {
+            this.onLog('error', 'Error handling ACP request', {
+                method: req.method,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return createJsonRpcError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, error instanceof Error ? error.message : 'Internal server error', undefined, req.id);
+        }
+    }
+    async handleToolsMethod(action, req) {
+        if (action === 'list') {
+            const tools = this.getAvailableTools();
+            this.onLog('debug', 'Listed tools', { count: tools.length });
+            return createJsonRpcResponse(tools, req.id);
+        }
+        this.onLog('warn', 'Unknown tools method', { action });
+        return createJsonRpcError(JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND, `Unknown method: tools/${action}`, undefined, req.id);
+    }
+    async handleToolMethod(action, req) {
+        if (action === 'call') {
+            return await this.callTool(req);
+        }
+        this.onLog('warn', 'Unknown tool method', { action });
+        return createJsonRpcError(JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND, `Unknown method: tool/${action}`, undefined, req.id);
+    }
+    async handleCapabilitiesMethod(action, req) {
+        if (action === 'get') {
+            const capabilities = this.getCapabilities();
+            this.onLog('debug', 'Retrieved capabilities', {
+                version: capabilities.version,
+                methods: capabilities.supportedMethods.length,
+            });
+            return createJsonRpcResponse(capabilities, req.id);
+        }
+        this.onLog('warn', 'Unknown capabilities method', { action });
+        return createJsonRpcError(JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND, `Unknown method: capabilities/${action}`, undefined, req.id);
+    }
+    getAvailableTools() {
+        return TOOL_SCHEMAS.filter((tool) => tool.type === 'function').map((tool) => {
+            const func = tool.function;
+            return {
+                name: func.name,
+                description: func.description,
+                inputSchema: {
+                    type: 'object',
+                    properties: func.parameters?.properties ?? {},
+                    required: func.parameters?.required ?? [],
+                },
+            };
+        });
+    }
+    async callTool(req) {
+        const params = req.params;
+        if (!params || typeof params !== 'object') {
+            this.onLog('warn', 'Invalid tool call params', { id: req.id });
+            return createJsonRpcError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, 'params must be an object with toolName and args', undefined, req.id);
+        }
+        const toolName = params.toolName;
+        const toolArgs = params.args;
+        if (typeof toolName !== 'string' || !toolName) {
+            this.onLog('warn', 'Missing or invalid toolName', { id: req.id });
+            return createJsonRpcError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, 'toolName must be a non-empty string', undefined, req.id);
+        }
+        if (!toolArgs || typeof toolArgs !== 'object') {
+            this.onLog('warn', 'Missing or invalid tool args', { toolName, id: req.id });
+            return createJsonRpcError(JSON_RPC_ERROR_CODES.INVALID_PARAMS, 'args must be an object', undefined, req.id);
+        }
+        this.onLog('debug', 'Calling tool', { toolName, id: req.id });
+        try {
+            const result = await dispatchTool(toolName, toolArgs);
+            this.onLog('debug', 'Tool call succeeded', { toolName });
+            return createJsonRpcResponse({ toolName, result }, req.id);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.onLog('warn', 'Tool call failed', { toolName, error: errorMsg });
+            return createJsonRpcError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Tool execution failed: ${errorMsg}`, { toolName, error: errorMsg }, req.id);
+        }
+    }
+    getCapabilities() {
+        return {
+            version: this.version,
+            protocolVersion: '1.0',
+            supportedMethods: ['tools/list', 'tool/call', 'capabilities/get'],
+            name: 'iCopilot ACP Server',
+        };
+    }
+}

package/dist/acp/schema.js

@@ -0,0 +1,53 @@
+export const JSON_RPC_ERROR_CODES = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    SERVER_ERROR_START: -32099,
+    SERVER_ERROR_END: -32000,
+    NOT_AUTHORIZED: -32001,
+};
+export function validateJsonRpcRequest(data) {
+    if (typeof data !== 'object' || data === null) {
+        return { valid: false, error: 'Request must be an object' };
+    }
+    const req = data;
+    if (req.jsonrpc !== '2.0') {
+        return { valid: false, error: 'jsonrpc must be "2.0"' };
+    }
+    if (typeof req.method !== 'string' || !req.method) {
+        return { valid: false, error: 'method must be a non-empty string' };
+    }
+    if (req.id !== undefined &&
+        typeof req.id !== 'string' &&
+        typeof req.id !== 'number' &&
+        req.id !== null) {
+        return { valid: false, error: 'id must be a string, number, or null' };
+    }
+    return { valid: true };
+}
+export function createJsonRpcResponse(result, id) {
+    return {
+        jsonrpc: '2.0',
+        result,
+        id,
+    };
+}
+export function createJsonRpcError(code, message, data, id) {
+    return {
+        jsonrpc: '2.0',
+        error: { code, message, data },
+        id,
+    };
+}
+export function isValidMethodName(method) {
+    return /^[a-zA-Z0-9_/-]+$/.test(method) && method.length > 0 && method.length <= 128;
+}
+export function parseMethodNamespace(method) {
+    const parts = method.split('/');
+    if (parts.length === 2) {
+        return { namespace: parts[0], action: parts[1] };
+    }
+    return { namespace: '', action: method };
+}