@cleocode/adapters 2.0.0

package/dist/index.js

@@ -0,0 +1,1927 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/adapters/src/providers/claude-code/paths.js
+import { homedir } from "node:os";
+import { join } from "node:path";
+var ClaudeCodePathProvider;
+var init_paths = __esm({
+  "packages/adapters/src/providers/claude-code/paths.js"() {
+    "use strict";
+    ClaudeCodePathProvider = class {
+      getProviderDir() {
+        return process.env["CLAUDE_HOME"] ?? join(homedir(), ".claude");
+      }
+      getSettingsPath() {
+        return process.env["CLAUDE_SETTINGS"] ?? join(this.getProviderDir(), "settings.json");
+      }
+      getAgentInstallDir() {
+        return join(this.getProviderDir(), "agents");
+      }
+      getMemoryDbPath() {
+        return process.env["CLAUDE_MEM_DB"] ?? join(homedir(), ".claude-mem", "claude-mem.db");
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/context-monitor.js
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join2 } from "node:path";
+function getContextStatusFromPercentage(percentage) {
+  if (percentage >= THRESHOLDS.EMERGENCY)
+    return "emergency";
+  if (percentage >= THRESHOLDS.CRITICAL)
+    return "critical";
+  if (percentage >= THRESHOLDS.CAUTION)
+    return "caution";
+  if (percentage >= THRESHOLDS.WARNING)
+    return "warning";
+  return "ok";
+}
+var THRESHOLDS, ClaudeCodeContextMonitorProvider;
+var init_context_monitor = __esm({
+  "packages/adapters/src/providers/claude-code/context-monitor.js"() {
+    "use strict";
+    init_paths();
+    THRESHOLDS = {
+      WARNING: 50,
+      CAUTION: 70,
+      CRITICAL: 85,
+      EMERGENCY: 95
+    };
+    ClaudeCodeContextMonitorProvider = class {
+      pathProvider = new ClaudeCodePathProvider();
+      async processContextInput(input, cwd) {
+        const typed = input;
+        const contextSize = typed.context_window?.context_window_size ?? 2e5;
+        const usage = typed.context_window?.current_usage;
+        if (!usage)
+          return "-- no data";
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_tokens ?? 0;
+        const cacheCreate = usage.cache_creation_input_tokens ?? 0;
+        const totalTokens = inputTokens + outputTokens + cacheCreate;
+        const percentage = Math.floor(totalTokens * 100 / contextSize);
+        const status = getContextStatusFromPercentage(percentage);
+        const cleoDir = cwd ? join2(cwd, ".cleo") : ".cleo";
+        if (existsSync(cleoDir)) {
+          const stateDir = join2(cleoDir, "context-states");
+          const statePath = join2(stateDir, ".context-state.json");
+          const state = {
+            $schema: "https://cleo-dev.com/schemas/v1/context-state.schema.json",
+            version: "1.0.0",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+            staleAfterMs: 5e3,
+            contextWindow: {
+              maxTokens: contextSize,
+              currentTokens: totalTokens,
+              percentage,
+              breakdown: {
+                inputTokens,
+                outputTokens,
+                cacheCreationTokens: cacheCreate,
+                cacheReadTokens: usage.cache_read_input_tokens ?? 0
+              }
+            },
+            thresholds: {
+              warning: THRESHOLDS.WARNING,
+              caution: THRESHOLDS.CAUTION,
+              critical: THRESHOLDS.CRITICAL,
+              emergency: THRESHOLDS.EMERGENCY
+            },
+            status,
+            cleoSessionId: ""
+          };
+          try {
+            await mkdir(dirname(statePath), { recursive: true });
+            writeFileSync(statePath, JSON.stringify(state, null, 2));
+          } catch {
+          }
+        }
+        return `${percentage}% | ${totalTokens}/${contextSize}`;
+      }
+      checkStatuslineIntegration() {
+        const settingsPath = this.pathProvider.getSettingsPath();
+        if (!settingsPath || !existsSync(settingsPath))
+          return "no_settings";
+        try {
+          const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+          const statusLine = settings.statusLine;
+          if (!statusLine?.type)
+            return "not_configured";
+          if (statusLine.type !== "command")
+            return "custom_no_cleo";
+          const cmd = statusLine.command ?? "";
+          if (cmd.includes("context-monitor.sh") || cmd.includes("cleo-statusline") || cmd.includes(".context-state.json") || cmd.includes("context-states")) {
+            return "configured";
+          }
+          const scriptPath = cmd.startsWith("~") ? cmd.replace("~", homedir2()) : cmd;
+          if (existsSync(scriptPath)) {
+            try {
+              const content = readFileSync(scriptPath, "utf-8");
+              if (content.includes("context-state.json"))
+                return "configured";
+            } catch {
+            }
+          }
+          return "custom_no_cleo";
+        } catch {
+          return "no_settings";
+        }
+      }
+      getStatuslineConfig() {
+        return {
+          statusLine: {
+            type: "command",
+            command: join2(homedir2(), ".cleo", "lib", "session", "context-monitor.sh")
+          }
+        };
+      }
+      getSetupInstructions() {
+        const settingsPath = this.pathProvider.getSettingsPath() ?? "~/.claude/settings.json";
+        return [
+          "To enable context monitoring, add to your Claude Code settings:",
+          `File: ${settingsPath}`,
+          "",
+          JSON.stringify(this.getStatuslineConfig(), null, 2),
+          "",
+          "This enables real-time context window tracking in the CLI."
+        ].join("\n");
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/hooks.js
+var CLAUDE_CODE_EVENT_MAP, ClaudeCodeHookProvider;
+var init_hooks = __esm({
+  "packages/adapters/src/providers/claude-code/hooks.js"() {
+    "use strict";
+    CLAUDE_CODE_EVENT_MAP = {
+      SessionStart: "onSessionStart",
+      PostToolUse: "onToolComplete",
+      UserPromptSubmit: "onPromptSubmit",
+      Stop: "onSessionEnd"
+    };
+    ClaudeCodeHookProvider = class {
+      registered = false;
+      /**
+       * Map a Claude Code native event name to a CAAMP hook event name.
+       *
+       * @param providerEvent - Claude Code event name (e.g. "SessionStart", "PostToolUse")
+       * @returns CAAMP event name or null if unmapped
+       */
+      mapProviderEvent(providerEvent) {
+        return CLAUDE_CODE_EVENT_MAP[providerEvent] ?? null;
+      }
+      /**
+       * Register native hooks for a project.
+       *
+       * For Claude Code, hooks are registered via the plugin system
+       * (hooks.json descriptor), which is handled by the
+       * install provider. This method is a no-op since registration
+       * is managed through the plugin install lifecycle.
+       *
+       * @param _projectDir - Project directory (unused; hooks are global)
+       */
+      async registerNativeHooks(_projectDir) {
+        this.registered = true;
+      }
+      /**
+       * Unregister native hooks.
+       *
+       * For Claude Code, this is a no-op since hooks are managed through
+       * the plugin system. Unregistration happens via the install provider's
+       * uninstall method.
+       */
+      async unregisterNativeHooks() {
+        this.registered = false;
+      }
+      /**
+       * Check whether hooks have been registered via registerNativeHooks.
+       */
+      isRegistered() {
+        return this.registered;
+      }
+      /**
+       * Get the full event mapping for introspection/debugging.
+       */
+      getEventMap() {
+        return { ...CLAUDE_CODE_EVENT_MAP };
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/install.js
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+var INSTRUCTION_REFERENCES, MCP_SERVER_KEY, ClaudeCodeInstallProvider;
+var init_install = __esm({
+  "packages/adapters/src/providers/claude-code/install.js"() {
+    "use strict";
+    INSTRUCTION_REFERENCES = [
+      "@~/.cleo/templates/CLEO-INJECTION.md",
+      "@.cleo/memory-bridge.md"
+    ];
+    MCP_SERVER_KEY = "cleo";
+    ClaudeCodeInstallProvider = class {
+      installedProjectDir = null;
+      /**
+       * Install CLEO into a Claude Code project.
+       *
+       * @param options - Installation options including project directory and MCP server path
+       * @returns Result describing what was installed
+       */
+      async install(options) {
+        const { projectDir, mcpServerPath } = options;
+        const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let instructionFileUpdated = false;
+        let mcpRegistered = false;
+        const details = {};
+        if (mcpServerPath) {
+          mcpRegistered = this.registerMcpServer(projectDir, mcpServerPath);
+          if (mcpRegistered) {
+            details.mcpConfigPath = join3(projectDir, ".mcp.json");
+          }
+        }
+        instructionFileUpdated = this.updateInstructionFile(projectDir);
+        if (instructionFileUpdated) {
+          details.instructionFile = join3(projectDir, "CLAUDE.md");
+        }
+        const pluginResult = this.registerPlugin();
+        if (pluginResult) {
+          details.plugin = pluginResult;
+        }
+        this.installedProjectDir = projectDir;
+        return {
+          success: true,
+          installedAt,
+          instructionFileUpdated,
+          mcpRegistered,
+          details
+        };
+      }
+      /**
+       * Uninstall CLEO from the current Claude Code project.
+       *
+       * Removes the MCP server registration from .mcp.json.
+       * Does not remove CLAUDE.md references (they are harmless if CLEO is not present).
+       */
+      async uninstall() {
+        if (!this.installedProjectDir)
+          return;
+        const mcpPath = join3(this.installedProjectDir, ".mcp.json");
+        if (existsSync2(mcpPath)) {
+          try {
+            const raw = readFileSync2(mcpPath, "utf-8");
+            const config = JSON.parse(raw);
+            const mcpServers = config.mcpServers;
+            if (mcpServers && MCP_SERVER_KEY in mcpServers) {
+              delete mcpServers[MCP_SERVER_KEY];
+              writeFileSync2(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            }
+          } catch {
+          }
+        }
+        this.installedProjectDir = null;
+      }
+      /**
+       * Check whether CLEO is installed in the current environment.
+       *
+       * Checks for:
+       * 1. MCP server registered in .mcp.json
+       * 2. Plugin enabled in ~/.claude/settings.json
+       *
+       * Returns true if either condition is met (partial install counts).
+       */
+      async isInstalled() {
+        const settingsPath = join3(homedir3(), ".claude", "settings.json");
+        if (existsSync2(settingsPath)) {
+          try {
+            const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+            const plugins = settings.enabledPlugins;
+            if (plugins && plugins["cleo@cleocode"] === true) {
+              return true;
+            }
+          } catch {
+          }
+        }
+        const mcpPath = join3(process.cwd(), ".mcp.json");
+        if (existsSync2(mcpPath)) {
+          try {
+            const config = JSON.parse(readFileSync2(mcpPath, "utf-8"));
+            const mcpServers = config.mcpServers;
+            if (mcpServers && MCP_SERVER_KEY in mcpServers) {
+              return true;
+            }
+          } catch {
+          }
+        }
+        return false;
+      }
+      /**
+       * Ensure CLAUDE.md contains @-references to CLEO instruction files.
+       *
+       * Creates CLAUDE.md if it does not exist. Appends any missing references.
+       *
+       * @param projectDir - Project root directory
+       */
+      async ensureInstructionReferences(projectDir) {
+        this.updateInstructionFile(projectDir);
+      }
+      /**
+       * Register the CLEO MCP server in .mcp.json.
+       *
+       * @returns true if registration was performed or updated
+       */
+      registerMcpServer(projectDir, mcpServerPath) {
+        const mcpPath = join3(projectDir, ".mcp.json");
+        let config = {};
+        if (existsSync2(mcpPath)) {
+          try {
+            config = JSON.parse(readFileSync2(mcpPath, "utf-8"));
+          } catch {
+          }
+        }
+        if (!config.mcpServers || typeof config.mcpServers !== "object") {
+          config.mcpServers = {};
+        }
+        const mcpServers = config.mcpServers;
+        mcpServers[MCP_SERVER_KEY] = {
+          command: "node",
+          args: [mcpServerPath]
+        };
+        writeFileSync2(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        return true;
+      }
+      /**
+       * Update CLAUDE.md with CLEO @-references.
+       *
+       * @returns true if the file was created or modified
+       */
+      updateInstructionFile(projectDir) {
+        const claudeMdPath = join3(projectDir, "CLAUDE.md");
+        let content = "";
+        let existed = false;
+        if (existsSync2(claudeMdPath)) {
+          content = readFileSync2(claudeMdPath, "utf-8");
+          existed = true;
+        }
+        const missingRefs = INSTRUCTION_REFERENCES.filter((ref) => !content.includes(ref));
+        if (missingRefs.length === 0) {
+          return false;
+        }
+        const refsBlock = missingRefs.join("\n");
+        if (existed) {
+          const separator = content.endsWith("\n") ? "" : "\n";
+          content = content + separator + refsBlock + "\n";
+        } else {
+          content = refsBlock + "\n";
+        }
+        writeFileSync2(claudeMdPath, content, "utf-8");
+        return true;
+      }
+      /**
+       * Register the CLEO brain plugin in ~/.claude/settings.json.
+       *
+       * @returns Description of what was registered, or null if no change needed
+       */
+      registerPlugin() {
+        const home = homedir3();
+        const settingsPath = join3(home, ".claude", "settings.json");
+        let settings = {};
+        if (existsSync2(settingsPath)) {
+          try {
+            settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+          } catch {
+          }
+        }
+        const enabledPlugins = settings.enabledPlugins ?? {};
+        const pluginKey = "cleo@cleocode";
+        if (enabledPlugins[pluginKey] === true) {
+          return null;
+        }
+        if (enabledPlugins["claude-mem@thedotmack"] === true) {
+          enabledPlugins["claude-mem@thedotmack"] = false;
+        }
+        enabledPlugins[pluginKey] = true;
+        settings.enabledPlugins = enabledPlugins;
+        mkdirSync(join3(home, ".claude"), { recursive: true });
+        writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+        return `Enabled ${pluginKey} in ~/.claude/settings.json`;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/spawn.js
+import { exec, spawn as nodeSpawn } from "node:child_process";
+import { unlink, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+var execAsync, ClaudeCodeSpawnProvider;
+var init_spawn = __esm({
+  "packages/adapters/src/providers/claude-code/spawn.js"() {
+    "use strict";
+    execAsync = promisify(exec);
+    ClaudeCodeSpawnProvider = class {
+      /** Map of instance IDs to tracked process info. */
+      processMap = /* @__PURE__ */ new Map();
+      /**
+       * Check if the Claude CLI is available in PATH.
+       *
+       * @returns true if `claude` is found via `which`
+       */
+      async canSpawn() {
+        try {
+          await execAsync("which claude");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Spawn a subagent via Claude CLI.
+       *
+       * Writes the prompt to a temporary file and spawns a detached Claude
+       * process. The process runs independently of the parent.
+       *
+       * @param context - Spawn context with taskId, prompt, and options
+       * @returns Spawn result with instance ID and status
+       */
+      async spawn(context) {
+        const instanceId = `claude-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = (/* @__PURE__ */ new Date()).toISOString();
+        let tmpFile;
+        try {
+          tmpFile = `/tmp/claude-spawn-${instanceId}.txt`;
+          await writeFile(tmpFile, context.prompt, "utf-8");
+          const args = ["--allow-insecure", "--no-upgrade-check", tmpFile];
+          const spawnOpts = {
+            detached: true,
+            stdio: "ignore"
+          };
+          if (context.workingDirectory) {
+            spawnOpts.cwd = context.workingDirectory;
+          }
+          const child = nodeSpawn("claude", args, spawnOpts);
+          child.unref();
+          if (child.pid) {
+            this.processMap.set(instanceId, {
+              pid: child.pid,
+              taskId: context.taskId,
+              startTime
+            });
+          }
+          const capturedTmpFile = tmpFile;
+          child.on("exit", async () => {
+            this.processMap.delete(instanceId);
+            try {
+              await unlink(capturedTmpFile);
+            } catch {
+            }
+          });
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "claude-code",
+            status: "running",
+            startTime
+          };
+        } catch (error) {
+          if (tmpFile) {
+            try {
+              await unlink(tmpFile);
+            } catch {
+            }
+          }
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "claude-code",
+            status: "failed",
+            startTime,
+            endTime: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      }
+      /**
+       * List currently running Claude subagent processes.
+       *
+       * Checks each tracked process via kill(pid, 0) to verify it is still alive.
+       * Dead processes are automatically cleaned from the tracking map.
+       *
+       * @returns Array of spawn results for running processes
+       */
+      async listRunning() {
+        const running = [];
+        for (const [instanceId, tracked] of this.processMap.entries()) {
+          try {
+            process.kill(tracked.pid, 0);
+            running.push({
+              instanceId,
+              taskId: tracked.taskId,
+              providerId: "claude-code",
+              status: "running",
+              startTime: tracked.startTime
+            });
+          } catch {
+            this.processMap.delete(instanceId);
+          }
+        }
+        return running;
+      }
+      /**
+       * Terminate a running spawn by instance ID.
+       *
+       * Sends SIGTERM to the tracked process. If the process is not found
+       * or has already exited, this is a no-op.
+       *
+       * @param instanceId - ID of the spawn instance to terminate
+       */
+      async terminate(instanceId) {
+        const tracked = this.processMap.get(instanceId);
+        if (!tracked)
+          return;
+        try {
+          process.kill(tracked.pid, "SIGTERM");
+        } catch {
+        }
+        this.processMap.delete(instanceId);
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/task-sync.js
+import { readFile, rm, stat } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function parseTaskId(content) {
+  const match = content.match(/^\[T(\d+)\]/);
+  return match ? `T${match[1]}` : null;
+}
+function stripPrefixes(content) {
+  return content.replace(/^\[T\d+\]\s*/, "").replace(/^\[!\]\s*/, "").replace(/^\[BLOCKED\]\s*/, "");
+}
+function mapStatus(twStatus) {
+  switch (twStatus) {
+    case "completed":
+      return "completed";
+    case "in_progress":
+      return "active";
+    case "pending":
+      return "pending";
+    default:
+      return "pending";
+  }
+}
+function getTodoWriteFilePath(projectDir) {
+  return join4(projectDir, ".cleo", "sync", "todowrite-state.json");
+}
+var ClaudeCodeTaskSyncProvider;
+var init_task_sync = __esm({
+  "packages/adapters/src/providers/claude-code/task-sync.js"() {
+    "use strict";
+    ClaudeCodeTaskSyncProvider = class {
+      customFilePath;
+      constructor(options) {
+        this.customFilePath = options?.filePath;
+      }
+      async getExternalTasks(projectDir) {
+        const filePath = this.customFilePath ?? getTodoWriteFilePath(projectDir);
+        try {
+          await stat(filePath);
+        } catch {
+          return [];
+        }
+        const raw = await readFile(filePath, "utf-8");
+        let state;
+        try {
+          state = JSON.parse(raw);
+        } catch {
+          return [];
+        }
+        if (!state.todos || !Array.isArray(state.todos)) {
+          return [];
+        }
+        const tasks = [];
+        let syntheticIndex = 0;
+        for (const item of state.todos) {
+          const cleoTaskId = parseTaskId(item.content);
+          const title = cleoTaskId ? stripPrefixes(item.content).trim() : item.content.trim();
+          if (!title)
+            continue;
+          tasks.push({
+            externalId: cleoTaskId ?? `tw-new-${syntheticIndex++}`,
+            cleoTaskId,
+            title,
+            status: mapStatus(item.status),
+            providerMeta: {
+              source: "todowrite",
+              activeForm: item.activeForm,
+              rawContent: item.content
+            }
+          });
+        }
+        return tasks;
+      }
+      async cleanup(projectDir) {
+        const filePath = this.customFilePath ?? getTodoWriteFilePath(projectDir);
+        try {
+          await rm(filePath);
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/transport.js
+var ClaudeCodeTransportProvider;
+var init_transport = __esm({
+  "packages/adapters/src/providers/claude-code/transport.js"() {
+    "use strict";
+    ClaudeCodeTransportProvider = class {
+      transportName = "claude-code";
+      createTransport() {
+        return null;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/adapter.js
+import { exec as exec2 } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { promisify as promisify2 } from "node:util";
+var execAsync2, ClaudeCodeAdapter;
+var init_adapter = __esm({
+  "packages/adapters/src/providers/claude-code/adapter.js"() {
+    "use strict";
+    init_context_monitor();
+    init_hooks();
+    init_install();
+    init_paths();
+    init_spawn();
+    init_task_sync();
+    init_transport();
+    execAsync2 = promisify2(exec2);
+    ClaudeCodeAdapter = class {
+      id = "claude-code";
+      name = "Claude Code";
+      version = "1.0.0";
+      capabilities = {
+        supportsHooks: true,
+        supportedHookEvents: [
+          "onSessionStart",
+          "onSessionEnd",
+          "onToolStart",
+          "onToolComplete",
+          "onError"
+        ],
+        supportsSpawn: true,
+        supportsInstall: true,
+        supportsMcp: true,
+        supportsInstructionFiles: true,
+        instructionFilePattern: "CLAUDE.md",
+        supportsContextMonitor: true,
+        supportsStatusline: true,
+        supportsProviderPaths: true,
+        supportsTransport: true,
+        supportsTaskSync: true
+      };
+      hooks;
+      spawn;
+      install;
+      paths;
+      contextMonitor;
+      transport;
+      taskSync;
+      projectDir = null;
+      initialized = false;
+      constructor() {
+        this.hooks = new ClaudeCodeHookProvider();
+        this.spawn = new ClaudeCodeSpawnProvider();
+        this.install = new ClaudeCodeInstallProvider();
+        this.paths = new ClaudeCodePathProvider();
+        this.contextMonitor = new ClaudeCodeContextMonitorProvider();
+        this.transport = new ClaudeCodeTransportProvider();
+        this.taskSync = new ClaudeCodeTaskSyncProvider();
+      }
+      /**
+       * Initialize the adapter for a given project directory.
+       *
+       * Validates the environment by checking for the Claude CLI
+       * and Claude Code configuration directory.
+       *
+       * @param projectDir - Root directory of the project
+       */
+      async initialize(projectDir) {
+        this.projectDir = projectDir;
+        this.initialized = true;
+      }
+      /**
+       * Dispose the adapter and clean up resources.
+       *
+       * Unregisters hooks and releases any tracked state.
+       */
+      async dispose() {
+        if (this.hooks.isRegistered()) {
+          await this.hooks.unregisterNativeHooks();
+        }
+        this.initialized = false;
+        this.projectDir = null;
+      }
+      /**
+       * Run a health check to verify Claude Code is accessible.
+       *
+       * Checks:
+       * 1. Adapter has been initialized
+       * 2. Claude CLI is available in PATH
+       * 3. ~/.claude/ configuration directory exists
+       *
+       * @returns Health status with details about each check
+       */
+      async healthCheck() {
+        const details = {};
+        if (!this.initialized) {
+          return {
+            healthy: false,
+            provider: this.id,
+            details: { error: "Adapter not initialized" }
+          };
+        }
+        let cliAvailable = false;
+        try {
+          const { stdout } = await execAsync2("which claude");
+          cliAvailable = stdout.trim().length > 0;
+          details.cliPath = stdout.trim();
+        } catch {
+          details.cliAvailable = false;
+        }
+        const claudeConfigDir = join5(homedir4(), ".claude");
+        const configExists = existsSync3(claudeConfigDir);
+        details.configDirExists = configExists;
+        const entrypointSet = process.env.CLAUDE_CODE_ENTRYPOINT !== void 0;
+        details.entrypointEnvSet = entrypointSet;
+        const healthy = cliAvailable;
+        details.cliAvailable = cliAvailable;
+        return {
+          healthy,
+          provider: this.id,
+          details
+        };
+      }
+      /**
+       * Check whether the adapter has been initialized.
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the project directory this adapter was initialized with.
+       */
+      getProjectDir() {
+        return this.projectDir;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/statusline.js
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join6 } from "node:path";
+function getClaudeSettingsPath() {
+  return process.env["CLAUDE_SETTINGS"] ?? join6(process.env["CLAUDE_HOME"] ?? join6(homedir5(), ".claude"), "settings.json");
+}
+function checkStatuslineIntegration() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!existsSync4(settingsPath))
+    return "no_settings";
+  try {
+    const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+    const statusLine = settings.statusLine;
+    if (!statusLine?.type)
+      return "not_configured";
+    if (statusLine.type !== "command")
+      return "custom_no_cleo";
+    const cmd = statusLine.command ?? "";
+    if (cmd.includes("context-monitor.sh") || cmd.includes("cleo-statusline") || cmd.includes(".context-state.json") || cmd.includes("context-states")) {
+      return "configured";
+    }
+    const scriptPath = cmd.startsWith("~") ? cmd.replace("~", homedir5()) : cmd;
+    if (existsSync4(scriptPath)) {
+      try {
+        const content = readFileSync3(scriptPath, "utf-8");
+        if (content.includes("context-state.json"))
+          return "configured";
+      } catch {
+      }
+    }
+    return "custom_no_cleo";
+  } catch {
+    return "no_settings";
+  }
+}
+function getStatuslineConfig(cleoHome) {
+  return {
+    statusLine: {
+      type: "command",
+      command: join6(cleoHome, "lib", "session", "context-monitor.sh")
+    }
+  };
+}
+function getSetupInstructions(cleoHome) {
+  const settingsPath = getClaudeSettingsPath();
+  return [
+    "To enable context monitoring, add to your Claude Code settings:",
+    `File: ${settingsPath}`,
+    "",
+    JSON.stringify(getStatuslineConfig(cleoHome), null, 2),
+    "",
+    "This enables real-time context window tracking in the CLI."
+  ].join("\n");
+}
+var init_statusline = __esm({
+  "packages/adapters/src/providers/claude-code/statusline.js"() {
+    "use strict";
+  }
+});
+
+// packages/adapters/src/providers/claude-code/index.js
+var claude_code_exports = {};
+__export(claude_code_exports, {
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  ClaudeCodeContextMonitorProvider: () => ClaudeCodeContextMonitorProvider,
+  ClaudeCodeHookProvider: () => ClaudeCodeHookProvider,
+  ClaudeCodeInstallProvider: () => ClaudeCodeInstallProvider,
+  ClaudeCodePathProvider: () => ClaudeCodePathProvider,
+  ClaudeCodeSpawnProvider: () => ClaudeCodeSpawnProvider,
+  ClaudeCodeTransportProvider: () => ClaudeCodeTransportProvider,
+  checkStatuslineIntegration: () => checkStatuslineIntegration,
+  createAdapter: () => createAdapter,
+  default: () => claude_code_default,
+  getSetupInstructions: () => getSetupInstructions,
+  getStatuslineConfig: () => getStatuslineConfig
+});
+function createAdapter() {
+  return new ClaudeCodeAdapter();
+}
+var claude_code_default;
+var init_claude_code = __esm({
+  "packages/adapters/src/providers/claude-code/index.js"() {
+    "use strict";
+    init_adapter();
+    init_adapter();
+    init_context_monitor();
+    init_hooks();
+    init_install();
+    init_paths();
+    init_spawn();
+    init_transport();
+    init_statusline();
+    claude_code_default = ClaudeCodeAdapter;
+  }
+});
+
+// packages/adapters/src/providers/opencode/hooks.js
+var OPENCODE_EVENT_MAP, OpenCodeHookProvider;
+var init_hooks2 = __esm({
+  "packages/adapters/src/providers/opencode/hooks.js"() {
+    "use strict";
+    OPENCODE_EVENT_MAP = {
+      "session.start": "onSessionStart",
+      "session.end": "onSessionEnd",
+      "tool.start": "onToolStart",
+      "tool.complete": "onToolComplete",
+      "error": "onError",
+      "prompt.submit": "onPromptSubmit"
+    };
+    OpenCodeHookProvider = class {
+      registered = false;
+      /**
+       * Map an OpenCode native event name to a CAAMP hook event name.
+       *
+       * @param providerEvent - OpenCode event name (e.g. "session.start", "tool.complete")
+       * @returns CAAMP event name or null if unmapped
+       */
+      mapProviderEvent(providerEvent) {
+        return OPENCODE_EVENT_MAP[providerEvent] ?? null;
+      }
+      /**
+       * Register native hooks for a project.
+       *
+       * For OpenCode, hooks are registered via the config system
+       * (.opencode/config.json), which is handled by the install provider.
+       * This method marks hooks as registered without performing
+       * filesystem operations.
+       *
+       * @param _projectDir - Project directory (unused; config manages registration)
+       */
+      async registerNativeHooks(_projectDir) {
+        this.registered = true;
+      }
+      /**
+       * Unregister native hooks.
+       *
+       * For OpenCode, this is a no-op since hooks are managed through
+       * the config system. Unregistration happens via the install
+       * provider's uninstall method.
+       */
+      async unregisterNativeHooks() {
+        this.registered = false;
+      }
+      /**
+       * Check whether hooks have been registered via registerNativeHooks.
+       */
+      isRegistered() {
+        return this.registered;
+      }
+      /**
+       * Get the full event mapping for introspection/debugging.
+       */
+      getEventMap() {
+        return { ...OPENCODE_EVENT_MAP };
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/install.js
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join7 } from "node:path";
+var INSTRUCTION_REFERENCES2, MCP_SERVER_KEY2, OpenCodeInstallProvider;
+var init_install2 = __esm({
+  "packages/adapters/src/providers/opencode/install.js"() {
+    "use strict";
+    INSTRUCTION_REFERENCES2 = [
+      "@~/.cleo/templates/CLEO-INJECTION.md",
+      "@.cleo/memory-bridge.md"
+    ];
+    MCP_SERVER_KEY2 = "cleo";
+    OpenCodeInstallProvider = class {
+      installedProjectDir = null;
+      /**
+       * Install CLEO into an OpenCode project.
+       *
+       * @param options - Installation options including project directory and MCP server path
+       * @returns Result describing what was installed
+       */
+      async install(options) {
+        const { projectDir, mcpServerPath } = options;
+        const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let instructionFileUpdated = false;
+        let mcpRegistered = false;
+        const details = {};
+        if (mcpServerPath) {
+          mcpRegistered = this.registerMcpServer(projectDir, mcpServerPath);
+          if (mcpRegistered) {
+            details.mcpConfigPath = join7(projectDir, ".opencode", "config.json");
+          }
+        }
+        instructionFileUpdated = this.updateInstructionFile(projectDir);
+        if (instructionFileUpdated) {
+          details.instructionFile = join7(projectDir, "AGENTS.md");
+        }
+        this.installedProjectDir = projectDir;
+        return {
+          success: true,
+          installedAt,
+          instructionFileUpdated,
+          mcpRegistered,
+          details
+        };
+      }
+      /**
+       * Uninstall CLEO from the current OpenCode project.
+       *
+       * Removes the MCP server registration from .opencode/config.json.
+       * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+       */
+      async uninstall() {
+        if (!this.installedProjectDir)
+          return;
+        const configPath = join7(this.installedProjectDir, ".opencode", "config.json");
+        if (existsSync5(configPath)) {
+          try {
+            const raw = readFileSync4(configPath, "utf-8");
+            const config = JSON.parse(raw);
+            const mcpServers = config.mcpServers;
+            if (mcpServers && MCP_SERVER_KEY2 in mcpServers) {
+              delete mcpServers[MCP_SERVER_KEY2];
+              writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            }
+          } catch {
+          }
+        }
+        this.installedProjectDir = null;
+      }
+      /**
+       * Check whether CLEO is installed in the current environment.
+       *
+       * Checks for MCP server registered in .opencode/config.json.
+       * Returns true if the CLEO MCP server entry is found.
+       */
+      async isInstalled() {
+        const configPath = join7(process.cwd(), ".opencode", "config.json");
+        if (existsSync5(configPath)) {
+          try {
+            const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+            const mcpServers = config.mcpServers;
+            if (mcpServers && MCP_SERVER_KEY2 in mcpServers) {
+              return true;
+            }
+          } catch {
+          }
+        }
+        return false;
+      }
+      /**
+       * Ensure AGENTS.md contains @-references to CLEO instruction files.
+       *
+       * Creates AGENTS.md if it does not exist. Appends any missing references.
+       *
+       * @param projectDir - Project root directory
+       */
+      async ensureInstructionReferences(projectDir) {
+        this.updateInstructionFile(projectDir);
+      }
+      /**
+       * Register the CLEO MCP server in .opencode/config.json.
+       *
+       * OpenCode stores its MCP server configuration in .opencode/config.json
+       * under the mcpServers key.
+       *
+       * @returns true if registration was performed or updated
+       */
+      registerMcpServer(projectDir, mcpServerPath) {
+        const openCodeDir = join7(projectDir, ".opencode");
+        const configPath = join7(openCodeDir, "config.json");
+        let config = {};
+        mkdirSync2(openCodeDir, { recursive: true });
+        if (existsSync5(configPath)) {
+          try {
+            config = JSON.parse(readFileSync4(configPath, "utf-8"));
+          } catch {
+          }
+        }
+        if (!config.mcpServers || typeof config.mcpServers !== "object") {
+          config.mcpServers = {};
+        }
+        const mcpServers = config.mcpServers;
+        mcpServers[MCP_SERVER_KEY2] = {
+          command: "node",
+          args: [mcpServerPath]
+        };
+        writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        return true;
+      }
+      /**
+       * Update AGENTS.md with CLEO @-references.
+       *
+       * @returns true if the file was created or modified
+       */
+      updateInstructionFile(projectDir) {
+        const agentsMdPath = join7(projectDir, "AGENTS.md");
+        let content = "";
+        let existed = false;
+        if (existsSync5(agentsMdPath)) {
+          content = readFileSync4(agentsMdPath, "utf-8");
+          existed = true;
+        }
+        const missingRefs = INSTRUCTION_REFERENCES2.filter((ref) => !content.includes(ref));
+        if (missingRefs.length === 0) {
+          return false;
+        }
+        const refsBlock = missingRefs.join("\n");
+        if (existed) {
+          const separator = content.endsWith("\n") ? "" : "\n";
+          content = content + separator + refsBlock + "\n";
+        } else {
+          content = refsBlock + "\n";
+        }
+        writeFileSync3(agentsMdPath, content, "utf-8");
+        return true;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/spawn.js
+import { exec as exec3, spawn as nodeSpawn2 } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+function buildOpenCodeAgentMarkdown(description, instructions) {
+  const normalizedDesc = description.replace(/\s+/g, " ").trim();
+  return [
+    "---",
+    `description: ${JSON.stringify(normalizedDesc)}`,
+    "mode: subagent",
+    "hidden: true",
+    "---",
+    "",
+    instructions.trim(),
+    ""
+  ].join("\n");
+}
+async function ensureSubagentDefinition(workingDirectory) {
+  const agentDir = join8(workingDirectory, ".opencode", "agent");
+  const agentPath = join8(agentDir, `${OPENCODE_SUBAGENT_NAME}.md`);
+  const description = "CLEO task executor with protocol compliance.";
+  const instructions = [
+    "# CLEO Subagent",
+    "",
+    "You are a CLEO subagent executing a delegated task.",
+    "Follow the CLEO protocol and complete the assigned work.",
+    "",
+    "@~/.cleo/templates/CLEO-INJECTION.md"
+  ].join("\n");
+  const content = buildOpenCodeAgentMarkdown(description, instructions);
+  await mkdir2(agentDir, { recursive: true });
+  let existing = null;
+  try {
+    existing = await readFile2(agentPath, "utf-8");
+  } catch {
+    existing = null;
+  }
+  if (existing !== content) {
+    await writeFile2(agentPath, content, "utf-8");
+  }
+  return OPENCODE_SUBAGENT_NAME;
+}
+var execAsync3, OPENCODE_SUBAGENT_NAME, OPENCODE_FALLBACK_AGENT, OpenCodeSpawnProvider;
+var init_spawn2 = __esm({
+  "packages/adapters/src/providers/opencode/spawn.js"() {
+    "use strict";
+    execAsync3 = promisify3(exec3);
+    OPENCODE_SUBAGENT_NAME = "cleo-subagent";
+    OPENCODE_FALLBACK_AGENT = "general";
+    OpenCodeSpawnProvider = class {
+      /** Map of instance IDs to tracked process info. */
+      processMap = /* @__PURE__ */ new Map();
+      /**
+       * Check if the OpenCode CLI is available in PATH.
+       *
+       * @returns true if `opencode` is found via `which`
+       */
+      async canSpawn() {
+        try {
+          await execAsync3("which opencode");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Spawn a subagent via OpenCode CLI.
+       *
+       * Ensures the CLEO subagent definition exists in the project's
+       * .opencode/agent/ directory, then spawns a detached OpenCode
+       * process. The process runs independently of the parent.
+       *
+       * @param context - Spawn context with taskId, prompt, and options
+       * @returns Spawn result with instance ID and status
+       */
+      async spawn(context) {
+        const instanceId = `opencode-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = (/* @__PURE__ */ new Date()).toISOString();
+        const workingDirectory = context.workingDirectory ?? process.cwd();
+        try {
+          let agentName;
+          try {
+            agentName = await ensureSubagentDefinition(workingDirectory);
+          } catch {
+            agentName = OPENCODE_FALLBACK_AGENT;
+          }
+          const child = nodeSpawn2("opencode", [
+            "run",
+            "--format",
+            "json",
+            "--agent",
+            agentName,
+            "--title",
+            `CLEO ${context.taskId}`,
+            context.prompt
+          ], {
+            cwd: workingDirectory,
+            detached: true,
+            stdio: "ignore"
+          });
+          child.unref();
+          if (child.pid) {
+            this.processMap.set(instanceId, {
+              pid: child.pid,
+              taskId: context.taskId,
+              startTime
+            });
+          }
+          child.on("exit", () => {
+            this.processMap.delete(instanceId);
+          });
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "opencode",
+            status: "running",
+            startTime
+          };
+        } catch {
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "opencode",
+            status: "failed",
+            startTime,
+            endTime: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      }
+      /**
+       * List currently running OpenCode subagent processes.
+       *
+       * Checks each tracked process via kill(pid, 0) to verify it is still alive.
+       * Dead processes are automatically cleaned from the tracking map.
+       *
+       * @returns Array of spawn results for running processes
+       */
+      async listRunning() {
+        const running = [];
+        for (const [instanceId, tracked] of this.processMap.entries()) {
+          try {
+            process.kill(tracked.pid, 0);
+            running.push({
+              instanceId,
+              taskId: tracked.taskId,
+              providerId: "opencode",
+              status: "running",
+              startTime: tracked.startTime
+            });
+          } catch {
+            this.processMap.delete(instanceId);
+          }
+        }
+        return running;
+      }
+      /**
+       * Terminate a running spawn by instance ID.
+       *
+       * Sends SIGTERM to the tracked process. If the process is not found
+       * or has already exited, this is a no-op.
+       *
+       * @param instanceId - ID of the spawn instance to terminate
+       */
+      async terminate(instanceId) {
+        const tracked = this.processMap.get(instanceId);
+        if (!tracked)
+          return;
+        try {
+          process.kill(tracked.pid, "SIGTERM");
+        } catch {
+        }
+        this.processMap.delete(instanceId);
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/adapter.js
+import { exec as exec4 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join9 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+var execAsync4, OpenCodeAdapter;
+var init_adapter2 = __esm({
+  "packages/adapters/src/providers/opencode/adapter.js"() {
+    "use strict";
+    init_hooks2();
+    init_install2();
+    init_spawn2();
+    execAsync4 = promisify4(exec4);
+    OpenCodeAdapter = class {
+      id = "opencode";
+      name = "OpenCode";
+      version = "1.0.0";
+      capabilities = {
+        supportsHooks: true,
+        supportedHookEvents: [
+          "onSessionStart",
+          "onSessionEnd",
+          "onToolStart",
+          "onToolComplete",
+          "onError",
+          "onPromptSubmit"
+        ],
+        supportsSpawn: true,
+        supportsInstall: true,
+        supportsMcp: true,
+        supportsInstructionFiles: true,
+        instructionFilePattern: "AGENTS.md",
+        supportsContextMonitor: false,
+        supportsStatusline: false,
+        supportsProviderPaths: true,
+        supportsTransport: false,
+        supportsTaskSync: false
+      };
+      hooks;
+      spawn;
+      install;
+      projectDir = null;
+      initialized = false;
+      constructor() {
+        this.hooks = new OpenCodeHookProvider();
+        this.spawn = new OpenCodeSpawnProvider();
+        this.install = new OpenCodeInstallProvider();
+      }
+      /**
+       * Initialize the adapter for a given project directory.
+       *
+       * Validates the environment by checking for the OpenCode CLI
+       * and OpenCode configuration directory.
+       *
+       * @param projectDir - Root directory of the project
+       */
+      async initialize(projectDir) {
+        this.projectDir = projectDir;
+        this.initialized = true;
+      }
+      /**
+       * Dispose the adapter and clean up resources.
+       *
+       * Unregisters hooks and releases any tracked state.
+       */
+      async dispose() {
+        if (this.hooks.isRegistered()) {
+          await this.hooks.unregisterNativeHooks();
+        }
+        this.initialized = false;
+        this.projectDir = null;
+      }
+      /**
+       * Run a health check to verify OpenCode is accessible.
+       *
+       * Checks:
+       * 1. Adapter has been initialized
+       * 2. OpenCode CLI is available in PATH
+       * 3. .opencode/ configuration directory exists in the project
+       *
+       * @returns Health status with details about each check
+       */
+      async healthCheck() {
+        const details = {};
+        if (!this.initialized) {
+          return {
+            healthy: false,
+            provider: this.id,
+            details: { error: "Adapter not initialized" }
+          };
+        }
+        let cliAvailable = false;
+        try {
+          const { stdout } = await execAsync4("which opencode");
+          cliAvailable = stdout.trim().length > 0;
+          details.cliPath = stdout.trim();
+        } catch {
+          details.cliAvailable = false;
+        }
+        if (this.projectDir) {
+          const openCodeConfigDir = join9(this.projectDir, ".opencode");
+          const configExists = existsSync6(openCodeConfigDir);
+          details.configDirExists = configExists;
+        }
+        const versionEnvSet = process.env.OPENCODE_VERSION !== void 0;
+        details.versionEnvSet = versionEnvSet;
+        const healthy = cliAvailable;
+        details.cliAvailable = cliAvailable;
+        return {
+          healthy,
+          provider: this.id,
+          details
+        };
+      }
+      /**
+       * Check whether the adapter has been initialized.
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the project directory this adapter was initialized with.
+       */
+      getProjectDir() {
+        return this.projectDir;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/index.js
+var opencode_exports = {};
+__export(opencode_exports, {
+  OpenCodeAdapter: () => OpenCodeAdapter,
+  OpenCodeHookProvider: () => OpenCodeHookProvider,
+  OpenCodeInstallProvider: () => OpenCodeInstallProvider,
+  OpenCodeSpawnProvider: () => OpenCodeSpawnProvider,
+  createAdapter: () => createAdapter2,
+  default: () => opencode_default
+});
+function createAdapter2() {
+  return new OpenCodeAdapter();
+}
+var opencode_default;
+var init_opencode = __esm({
+  "packages/adapters/src/providers/opencode/index.js"() {
+    "use strict";
+    init_adapter2();
+    init_adapter2();
+    init_hooks2();
+    init_spawn2();
+    init_install2();
+    opencode_default = OpenCodeAdapter;
+  }
+});
+
+// packages/adapters/src/providers/cursor/hooks.js
+var CursorHookProvider;
+var init_hooks3 = __esm({
+  "packages/adapters/src/providers/cursor/hooks.js"() {
+    "use strict";
+    CursorHookProvider = class {
+      registered = false;
+      /**
+       * Map a provider event name to a CAAMP hook event name.
+       *
+       * Always returns null since Cursor does not emit hook events.
+       *
+       * @param _providerEvent - Ignored; Cursor has no hook events
+       * @returns null (no mapping available)
+       */
+      mapProviderEvent(_providerEvent) {
+        return null;
+      }
+      /**
+       * Register native hooks for a project.
+       *
+       * No-op for Cursor since it has no hook system.
+       *
+       * @param _projectDir - Ignored
+       */
+      async registerNativeHooks(_projectDir) {
+        this.registered = true;
+      }
+      /**
+       * Unregister native hooks.
+       *
+       * No-op for Cursor since it has no hook system.
+       */
+      async unregisterNativeHooks() {
+        this.registered = false;
+      }
+      /**
+       * Check whether hooks have been registered.
+       */
+      isRegistered() {
+        return this.registered;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/cursor/install.js
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join10 } from "node:path";
+var INSTRUCTION_REFERENCES3, MCP_SERVER_KEY3, CursorInstallProvider;
+var init_install3 = __esm({
+  "packages/adapters/src/providers/cursor/install.js"() {
+    "use strict";
+    INSTRUCTION_REFERENCES3 = [
+      "@~/.cleo/templates/CLEO-INJECTION.md",
+      "@.cleo/memory-bridge.md"
+    ];
+    MCP_SERVER_KEY3 = "cleo";
+    CursorInstallProvider = class {
+      installedProjectDir = null;
+      /**
+       * Install CLEO into a Cursor project.
+       *
+       * @param options - Installation options including project directory and MCP server path
+       * @returns Result describing what was installed
+       */
+      async install(options) {
+        const { projectDir, mcpServerPath } = options;
+        const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let instructionFileUpdated = false;
+        let mcpRegistered = false;
+        const details = {};
+        if (mcpServerPath) {
+          mcpRegistered = this.registerMcpServer(projectDir, mcpServerPath);
+          if (mcpRegistered) {
+            details.mcpConfigPath = join10(projectDir, ".cursor", "mcp.json");
+          }
+        }
+        instructionFileUpdated = this.updateInstructionFiles(projectDir);
+        if (instructionFileUpdated) {
+          details.instructionFiles = this.getUpdatedFileList(projectDir);
+        }
+        this.installedProjectDir = projectDir;
+        return {
+          success: true,
+          installedAt,
+          instructionFileUpdated,
+          mcpRegistered,
+          details
+        };
+      }
+      /**
+       * Uninstall CLEO from the current Cursor project.
+       *
+       * Removes the MCP server registration from .cursor/mcp.json.
+       * Does not remove instruction file references (they are harmless if CLEO is not present).
+       */
+      async uninstall() {
+        if (!this.installedProjectDir)
+          return;
+        const mcpPath = join10(this.installedProjectDir, ".cursor", "mcp.json");
+        if (existsSync7(mcpPath)) {
+          try {
+            const raw = readFileSync5(mcpPath, "utf-8");
+            const config = JSON.parse(raw);
+            const mcpServers = config.mcpServers;
+            if (mcpServers && MCP_SERVER_KEY3 in mcpServers) {
+              delete mcpServers[MCP_SERVER_KEY3];
+              writeFileSync4(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            }
+          } catch {
+          }
+        }
+        this.installedProjectDir = null;
+      }
+      /**
+       * Check whether CLEO is installed in the current environment.
+       *
+       * Checks for MCP server registered in .cursor/mcp.json.
+       */
+      async isInstalled() {
+        const mcpPath = join10(process.cwd(), ".cursor", "mcp.json");
+        if (existsSync7(mcpPath)) {
+          try {
+            const config = JSON.parse(readFileSync5(mcpPath, "utf-8"));
+            const mcpServers = config.mcpServers;
+            if (mcpServers && MCP_SERVER_KEY3 in mcpServers) {
+              return true;
+            }
+          } catch {
+          }
+        }
+        return false;
+      }
+      /**
+       * Ensure instruction files contain @-references to CLEO.
+       *
+       * Updates .cursorrules (legacy) and creates .cursor/rules/cleo.mdc (modern).
+       *
+       * @param projectDir - Project root directory
+       */
+      async ensureInstructionReferences(projectDir) {
+        this.updateInstructionFiles(projectDir);
+      }
+      /**
+       * Register the CLEO MCP server in .cursor/mcp.json.
+       *
+       * Cursor stores MCP server configuration in .cursor/mcp.json
+       * under the mcpServers key.
+       *
+       * @returns true if registration was performed or updated
+       */
+      registerMcpServer(projectDir, mcpServerPath) {
+        const cursorDir = join10(projectDir, ".cursor");
+        const mcpPath = join10(cursorDir, "mcp.json");
+        let config = {};
+        mkdirSync3(cursorDir, { recursive: true });
+        if (existsSync7(mcpPath)) {
+          try {
+            config = JSON.parse(readFileSync5(mcpPath, "utf-8"));
+          } catch {
+          }
+        }
+        if (!config.mcpServers || typeof config.mcpServers !== "object") {
+          config.mcpServers = {};
+        }
+        const mcpServers = config.mcpServers;
+        mcpServers[MCP_SERVER_KEY3] = {
+          command: "node",
+          args: [mcpServerPath]
+        };
+        writeFileSync4(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        return true;
+      }
+      /**
+       * Update instruction files with CLEO @-references.
+       *
+       * Handles both legacy (.cursorrules) and modern (.cursor/rules/cleo.mdc) formats.
+       *
+       * @returns true if any file was created or modified
+       */
+      updateInstructionFiles(projectDir) {
+        let updated = false;
+        if (this.updateLegacyRules(projectDir)) {
+          updated = true;
+        }
+        if (this.updateModernRules(projectDir)) {
+          updated = true;
+        }
+        return updated;
+      }
+      /**
+       * Update legacy .cursorrules file with @-references.
+       * Only modifies the file if it already exists (does not create it).
+       *
+       * @returns true if the file was modified
+       */
+      updateLegacyRules(projectDir) {
+        const rulesPath = join10(projectDir, ".cursorrules");
+        if (!existsSync7(rulesPath)) {
+          return false;
+        }
+        let content = readFileSync5(rulesPath, "utf-8");
+        const missingRefs = INSTRUCTION_REFERENCES3.filter((ref) => !content.includes(ref));
+        if (missingRefs.length === 0) {
+          return false;
+        }
+        const separator = content.endsWith("\n") ? "" : "\n";
+        content = content + separator + missingRefs.join("\n") + "\n";
+        writeFileSync4(rulesPath, content, "utf-8");
+        return true;
+      }
+      /**
+       * Create or update .cursor/rules/cleo.mdc with CLEO references.
+       *
+       * MDC (Markdown Component) format is Cursor's modern rule file format.
+       * Each .mdc file in .cursor/rules/ is loaded as a rule set.
+       *
+       * @returns true if the file was created or modified
+       */
+      updateModernRules(projectDir) {
+        const rulesDir = join10(projectDir, ".cursor", "rules");
+        const mdcPath = join10(rulesDir, "cleo.mdc");
+        const expectedContent = [
+          "---",
+          "description: CLEO task management protocol references",
+          'globs: "**/*"',
+          "alwaysApply: true",
+          "---",
+          "",
+          ...INSTRUCTION_REFERENCES3,
+          ""
+        ].join("\n");
+        if (existsSync7(mdcPath)) {
+          const existing = readFileSync5(mdcPath, "utf-8");
+          if (existing === expectedContent) {
+            return false;
+          }
+        }
+        mkdirSync3(rulesDir, { recursive: true });
+        writeFileSync4(mdcPath, expectedContent, "utf-8");
+        return true;
+      }
+      /**
+       * Get list of instruction files that were updated.
+       */
+      getUpdatedFileList(projectDir) {
+        const files = [];
+        if (existsSync7(join10(projectDir, ".cursorrules"))) {
+          files.push(join10(projectDir, ".cursorrules"));
+        }
+        files.push(join10(projectDir, ".cursor", "rules", "cleo.mdc"));
+        return files;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/cursor/adapter.js
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join11 } from "node:path";
+var CursorAdapter;
+var init_adapter3 = __esm({
+  "packages/adapters/src/providers/cursor/adapter.js"() {
+    "use strict";
+    init_hooks3();
+    init_install3();
+    CursorAdapter = class {
+      id = "cursor";
+      name = "Cursor";
+      version = "1.0.0";
+      capabilities = {
+        supportsHooks: false,
+        supportedHookEvents: [],
+        supportsSpawn: false,
+        supportsInstall: true,
+        supportsMcp: true,
+        supportsInstructionFiles: true,
+        instructionFilePattern: ".cursor/rules/*.mdc",
+        supportsContextMonitor: false,
+        supportsStatusline: false,
+        supportsProviderPaths: true,
+        supportsTransport: false,
+        supportsTaskSync: false
+      };
+      hooks;
+      install;
+      projectDir = null;
+      initialized = false;
+      constructor() {
+        this.hooks = new CursorHookProvider();
+        this.install = new CursorInstallProvider();
+      }
+      /**
+       * Initialize the adapter for a given project directory.
+       *
+       * @param projectDir - Root directory of the project
+       */
+      async initialize(projectDir) {
+        this.projectDir = projectDir;
+        this.initialized = true;
+      }
+      /**
+       * Dispose the adapter and clean up resources.
+       */
+      async dispose() {
+        if (this.hooks.isRegistered()) {
+          await this.hooks.unregisterNativeHooks();
+        }
+        this.initialized = false;
+        this.projectDir = null;
+      }
+      /**
+       * Run a health check to verify Cursor is accessible.
+       *
+       * Checks:
+       * 1. Adapter has been initialized
+       * 2. .cursor/ configuration directory exists in the project
+       * 3. CURSOR_EDITOR env var is set
+       *
+       * @returns Health status with details about each check
+       */
+      async healthCheck() {
+        const details = {};
+        if (!this.initialized) {
+          return {
+            healthy: false,
+            provider: this.id,
+            details: { error: "Adapter not initialized" }
+          };
+        }
+        let configExists = false;
+        if (this.projectDir) {
+          const cursorConfigDir = join11(this.projectDir, ".cursor");
+          configExists = existsSync8(cursorConfigDir);
+          details.configDirExists = configExists;
+        }
+        const editorEnvSet = process.env.CURSOR_EDITOR !== void 0;
+        details.editorEnvSet = editorEnvSet;
+        if (this.projectDir) {
+          const legacyRulesExist = existsSync8(join11(this.projectDir, ".cursorrules"));
+          details.legacyRulesExist = legacyRulesExist;
+        }
+        const healthy = configExists || editorEnvSet;
+        details.detected = healthy;
+        return {
+          healthy,
+          provider: this.id,
+          details
+        };
+      }
+      /**
+       * Check whether the adapter has been initialized.
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the project directory this adapter was initialized with.
+       */
+      getProjectDir() {
+        return this.projectDir;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/cursor/index.js
+var cursor_exports = {};
+__export(cursor_exports, {
+  CursorAdapter: () => CursorAdapter,
+  CursorHookProvider: () => CursorHookProvider,
+  CursorInstallProvider: () => CursorInstallProvider,
+  createAdapter: () => createAdapter3,
+  default: () => cursor_default
+});
+function createAdapter3() {
+  return new CursorAdapter();
+}
+var cursor_default;
+var init_cursor = __esm({
+  "packages/adapters/src/providers/cursor/index.js"() {
+    "use strict";
+    init_adapter3();
+    init_adapter3();
+    init_hooks3();
+    init_install3();
+    cursor_default = CursorAdapter;
+  }
+});
+
+// packages/adapters/src/registry.js
+import { readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname2, join as join12, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var PROVIDER_IDS = ["claude-code", "opencode", "cursor"];
+function getProviderManifests() {
+  const manifests = [];
+  const baseDir = resolve(dirname2(fileURLToPath(import.meta.url)), "providers");
+  for (const providerId of PROVIDER_IDS) {
+    try {
+      const manifestPath = join12(baseDir, providerId, "manifest.json");
+      const raw = readFileSync6(manifestPath, "utf-8");
+      manifests.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return manifests;
+}
+async function discoverProviders() {
+  const providers = /* @__PURE__ */ new Map();
+  providers.set("claude-code", async () => {
+    const { ClaudeCodeAdapter: ClaudeCodeAdapter2 } = await Promise.resolve().then(() => (init_claude_code(), claude_code_exports));
+    return new ClaudeCodeAdapter2();
+  });
+  providers.set("opencode", async () => {
+    const { OpenCodeAdapter: OpenCodeAdapter2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
+    return new OpenCodeAdapter2();
+  });
+  providers.set("cursor", async () => {
+    const { CursorAdapter: CursorAdapter2 } = await Promise.resolve().then(() => (init_cursor(), cursor_exports));
+    return new CursorAdapter2();
+  });
+  return providers;
+}
+
+// packages/adapters/src/index.ts
+init_claude_code();
+init_claude_code();
+init_claude_code();
+init_claude_code();
+init_claude_code();
+init_claude_code();
+init_claude_code();
+init_claude_code();
+init_opencode();
+init_opencode();
+init_opencode();
+init_opencode();
+init_cursor();
+init_cursor();
+init_cursor();
+init_claude_code();
+init_opencode();
+init_cursor();
+export {
+  ClaudeCodeAdapter,
+  ClaudeCodeContextMonitorProvider,
+  ClaudeCodeHookProvider,
+  ClaudeCodeInstallProvider,
+  ClaudeCodePathProvider,
+  ClaudeCodeSpawnProvider,
+  ClaudeCodeTransportProvider,
+  CursorAdapter,
+  CursorHookProvider,
+  CursorInstallProvider,
+  OpenCodeAdapter,
+  OpenCodeHookProvider,
+  OpenCodeInstallProvider,
+  OpenCodeSpawnProvider,
+  checkStatuslineIntegration,
+  createAdapter as createClaudeCodeAdapter,
+  createAdapter3 as createCursorAdapter,
+  createAdapter2 as createOpenCodeAdapter,
+  discoverProviders,
+  getProviderManifests,
+  getSetupInstructions,
+  getStatuslineConfig
+};
+//# sourceMappingURL=index.js.map