@orquentra/codebuddy 2.6.2 → 2.8.0

package/dist/chunk-J4T6HHI4.js

@@ -0,0 +1,1444 @@
+import {
+  CLIENT_ADAPTERS,
+  CLIENT_IDS,
+  MODE_LABELS,
+  sharedRulesReaders,
+  supportedModes
+} from "./chunk-W7GAXL6C.js";
+import {
+  indexRepository
+} from "./chunk-ITQO632W.js";
+import {
+  resolveNamespaceFrom
+} from "./chunk-KNR2P2UY.js";
+import {
+  writeAtomic
+} from "./chunk-CG5B3LYG.js";
+
+// src/clients/install.ts
+import { access as access2 } from "fs/promises";
+import { join as join9, resolve as resolve7 } from "path";
+
+// src/hooks/hermes-plugin.ts
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2, join, resolve } from "path";
+
+// src/hooks/managed-plugin.ts
+import { mkdir, readFile, rm, rmdir } from "fs/promises";
+import { dirname } from "path";
+async function read(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function managedPluginInstalled(plugin3) {
+  for (const file of plugin3.files) {
+    if (!(await read(file.path))?.startsWith(plugin3.marker)) return false;
+  }
+  return true;
+}
+async function setManagedPlugin(plugin3, enabled) {
+  const current = await Promise.all(plugin3.files.map((file) => read(file.path)));
+  const foreign = plugin3.files.find((_, i) => {
+    const text = current[i];
+    return text != null && !text.startsWith(plugin3.marker);
+  });
+  if (foreign) {
+    if (!enabled) return false;
+    throw new Error(
+      `${foreign.path} exists and is not managed by CodeBuddy; move it aside and re-run.`
+    );
+  }
+  let changed = false;
+  for (const [i, file] of plugin3.files.entries()) {
+    if (enabled && current[i] !== file.content) {
+      await mkdir(dirname(file.path), { recursive: true });
+      await writeAtomic(file.path, file.content, { mode: 420 });
+      changed = true;
+    } else if (!enabled && current[i] != null) {
+      await rm(file.path, { force: true });
+      changed = true;
+    }
+  }
+  if (!enabled && changed) {
+    for (const dir of plugin3.dirs) await rmdir(dir).catch(() => {
+    });
+  }
+  return changed;
+}
+
+// src/hooks/hermes-plugin.ts
+var HERMES_PLUGIN_MARKER = "# codebuddy-managed: hermes-plugin";
+var HERMES_PLUGIN_MANIFEST = `${HERMES_PLUGIN_MARKER} v1
+name: codebuddy
+version: 1.0.0
+kind: standalone
+description: CodeBuddy recall and capture bridge (codebuddy clients install hermes --mode hooks).
+provides_hooks:
+  - pre_llm_call
+  - post_tool_call
+  - post_llm_call
+  - on_session_end
+`;
+var HERMES_LEAN_MANIFEST = `${HERMES_PLUGIN_MARKER} v1 lean
+name: codebuddy
+version: 1.0.0
+kind: standalone
+description: CodeBuddy lean bridge (codebuddy clients install hermes --mode lean).
+provides_hooks:
+  - pre_llm_call
+`;
+var HERMES_HOOK_FN = `def _hook(command, payload):
+    """Run one fail-soft CodeBuddy hook; its stdout, or "" on any failure."""
+    try:
+        done = subprocess.run(
+            ["codebuddy", "hooks", command],
+            input=json.dumps({"cwd": ROOT, **payload}),
+            capture_output=True,
+            text=True,
+            timeout=TIMEOUT_S[command],
+            cwd=ROOT,
+        )
+    except Exception:
+        return ""
+    return done.stdout if done.returncode == 0 else ""
+
+
+`;
+function renderHermesPlugin(variant) {
+  return variant === "lean" ? `${HERMES_PLUGIN_MARKER} v1 lean
+# Generated by "codebuddy clients install hermes --mode lean"; removed by
+# "codebuddy clients uninstall hermes". Local edits are overwritten.
+"""CodeBuddy lean bridge: forwards each prompt to "codebuddy hooks lean"."""
+
+import json
+import subprocess
+from pathlib import Path
+
+# <root>/.hermes/plugins/codebuddy/__init__.py
+ROOT = str(Path(__file__).absolute().parents[3])
+TIMEOUT_S = {"lean": 2}
+
+
+${HERMES_HOOK_FN}def _pre_llm_call(session_id="", user_message="", **_):
+    if not isinstance(user_message, str) or not user_message.strip():
+        return None
+    payload = {
+        "session_id": session_id,
+        "hook_event_name": "pre_llm_call",
+        "ephemeral_context": True,
+        "prompt": user_message,
+    }
+    block = _hook("lean", payload).strip()
+    return {"context": block} if block else None
+
+
+def register(ctx):
+    ctx.register_hook("pre_llm_call", _pre_llm_call)
+` : `${HERMES_PLUGIN_MARKER} v1
+# Generated by "codebuddy clients install hermes --mode hooks"; removed by
+# "codebuddy clients uninstall hermes". Local edits are overwritten.
+"""CodeBuddy lifecycle bridge: forwards Hermes hooks to "codebuddy hooks <command>"."""
+
+import json
+import subprocess
+import threading
+from pathlib import Path
+
+# <root>/.hermes/plugins/codebuddy/__init__.py
+ROOT = str(Path(__file__).absolute().parents[3])
+EDIT_TOOLS = {"write_file", "patch"}
+TIMEOUT_S = {"context": 20, "stage": 10, "capture": 60}
+_lock = threading.Lock()
+_turns = {}
+
+
+${HERMES_HOOK_FN}def _turn(turn_id, session_id):
+    # Compression can rotate the session id mid-turn; a turn keeps its first id.
+    with _lock:
+        return _turns.setdefault(
+            turn_id or session_id, {"session": session_id, "text": "", "commands": []}
+        )
+
+
+def _pre_llm_call(session_id="", turn_id="", user_message="", **_):
+    _turn(turn_id, session_id)
+    payload = {"session_id": session_id, "hook_event_name": "pre_llm_call", "ephemeral_context": True}
+    if isinstance(user_message, str) and user_message.strip():
+        payload["prompt"] = user_message
+    block = _hook("context", payload).strip()
+    return {"context": block} if block else None
+
+
+def _post_tool_call(tool_name="", args=None, result=None, session_id="", turn_id="", **_):
+    turn = _turn(turn_id, session_id)
+    args = args if isinstance(args, dict) else {}
+    if tool_name in EDIT_TOOLS:
+        # Paths only: write_file content never needs to cross the pipe.
+        tool_input = {k: args[k] for k in ("path", "mode", "patch") if k in args}
+        _hook("stage", {
+            "session_id": turn["session"],
+            "hook_event_name": "post_tool_call",
+            "tool_name": tool_name,
+            "tool_input": tool_input,
+        })
+    elif tool_name == "terminal" and isinstance(args.get("command"), str):
+        exit_code = None
+        if not args.get("background"):  # a background process has not finished
+            try:
+                exit_code = json.loads(result).get("exit_code")
+            except Exception:
+                pass
+        turn["commands"].append({
+            "command": args["command"],
+            "exit_code": exit_code if type(exit_code) is int else None,
+        })
+
+
+def _post_llm_call(session_id="", turn_id="", assistant_response="", **_):
+    if isinstance(assistant_response, str) and assistant_response.strip():
+        _turn(turn_id, session_id)["text"] = assistant_response
+
+
+def _on_session_end(session_id="", turn_id="", **_):
+    with _lock:
+        turn = _turns.pop(turn_id or session_id, None)
+    turn = turn or {"session": session_id, "text": "", "commands": []}
+    payload = {"session_id": turn["session"], "hook_event_name": "on_session_end"}
+    if turn["text"]:
+        payload["last_assistant_message"] = turn["text"]
+    if turn["commands"]:
+        payload["shell_commands"] = turn["commands"][-20:]
+    _hook("capture", payload)
+
+
+def register(ctx):
+    ctx.register_hook("pre_llm_call", _pre_llm_call)
+    ctx.register_hook("post_tool_call", _post_tool_call)
+    ctx.register_hook("post_llm_call", _post_llm_call)
+    ctx.register_hook("on_session_end", _on_session_end)
+`;
+}
+var HERMES_PLUGIN_SOURCE = renderHermesPlugin("full");
+function hermesPluginDir(repositoryRoot) {
+  return join(resolve(repositoryRoot), ".hermes", "plugins", "codebuddy");
+}
+function plugin(repositoryRoot, variant = "full") {
+  const dir = hermesPluginDir(repositoryRoot);
+  return {
+    marker: HERMES_PLUGIN_MARKER,
+    files: [
+      {
+        path: join(dir, "plugin.yaml"),
+        content: variant === "lean" ? HERMES_LEAN_MANIFEST : HERMES_PLUGIN_MANIFEST
+      },
+      { path: join(dir, "__init__.py"), content: renderHermesPlugin(variant) }
+    ],
+    dirs: [dir, dirname2(dir), dirname2(dirname2(dir))]
+  };
+}
+function hermesPluginInstalled(repositoryRoot) {
+  return managedPluginInstalled(plugin(repositoryRoot));
+}
+function setHermesPlugin(repositoryRoot, enabled, variant = "full") {
+  return setManagedPlugin(plugin(repositoryRoot, variant), enabled);
+}
+async function hermesPluginVariant(repositoryRoot) {
+  if (!await hermesPluginInstalled(repositoryRoot)) return null;
+  const source = await readFile2(join(hermesPluginDir(repositoryRoot), "__init__.py"), "utf8");
+  return source.startsWith(`${HERMES_PLUGIN_MARKER} v1 lean`) ? "lean" : "full";
+}
+
+// src/hooks/opencode-plugin.ts
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname3, join as join2, resolve as resolve2 } from "path";
+var OPENCODE_PLUGIN_MARKER = "// codebuddy-managed: opencode-plugin";
+var OPENCODE_RUNTIME = `const ID_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+let lastMs = 0;
+let counter = 0;
+
+/** Run one fail-soft CodeBuddy hook; resolves to its stdout, "" on any failure. */
+function hook(command, payload) {
+  return new Promise((done) => {
+    let out = "";
+    let child;
+    try {
+      child = spawn("codebuddy", ["hooks", command], {
+        cwd: payload.cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+        // npm installs a codebuddy.cmd shim on Windows, which spawn only runs through a shell.
+        shell: process.platform === "win32",
+      });
+    } catch {
+      done("");
+      return;
+    }
+    const timer = setTimeout(() => child.kill(), TIMEOUT_MS[command]);
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      done("");
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      done(code === 0 ? out : "");
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify(payload));
+  });
+}
+
+/** An ascending OpenCode part id (prt_ + 48-bit time/counter hex + 14 base62). */
+function partId() {
+  const now = Date.now();
+  if (now !== lastMs) {
+    lastMs = now;
+    counter = 0;
+  }
+  counter += 1;
+  const time = (BigInt(now) * 4096n + BigInt(counter)) & 0xffffffffffffn;
+  let random = "";
+  for (const byte of crypto.getRandomValues(new Uint8Array(14))) random += ID_CHARS[byte % 62];
+  return "prt_" + time.toString(16).padStart(12, "0") + random;
+}
+
+`;
+function renderOpencodePlugin(variant) {
+  return variant === "lean" ? `${OPENCODE_PLUGIN_MARKER} v1 lean
+// Generated by \`codebuddy clients install opencode --mode lean\`; removed by
+// \`codebuddy clients uninstall opencode\`. Local edits are overwritten.
+import { spawn } from "node:child_process";
+
+const TIMEOUT_MS = { lean: 2000, reset: 10000 };
+${OPENCODE_RUNTIME}/** @type {import("@opencode-ai/plugin").Plugin} */
+export const CodeBuddyPlugin = async ({ directory }) => {
+  const base = (sessionID, event) => ({ session_id: sessionID, cwd: directory, hook_event_name: event });
+
+  return {
+    "chat.message": async (input, output) => {
+      const prompt = output.parts
+        .flatMap((part) => (part.type === "text" && !part.synthetic ? [part.text] : []))
+        .join("\\n")
+        .trim();
+      if (!prompt) return;
+      const block = (await hook("lean", { ...base(input.sessionID, "chat.message"), prompt })).trim();
+      if (!block) return;
+      output.parts.push({
+        id: partId(),
+        sessionID: input.sessionID,
+        messageID: output.message.id,
+        type: "text",
+        text: block,
+        synthetic: true,
+      });
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.compacted") {
+        await hook("reset", { ...base(event.properties.sessionID, "session.compacted"), source: "compact" });
+      }
+    },
+  };
+};
+` : `${OPENCODE_PLUGIN_MARKER} v1
+// Generated by \`codebuddy clients install opencode --mode hooks\`; removed by
+// \`codebuddy clients uninstall opencode\`. Local edits are overwritten.
+import { spawn } from "node:child_process";
+
+const EDIT_TOOLS = new Set(["edit", "write", "patch", "apply_patch"]);
+const TIMEOUT_MS = { context: 20000, stage: 10000, capture: 60000, reset: 10000 };
+${OPENCODE_RUNTIME}/** @type {import("@opencode-ai/plugin").Plugin} */
+export const CodeBuddyPlugin = async ({ directory }) => {
+  /** @type {Map<string, { text: string, commands: Array<{ command: string, exit_code: number | null }> }>} */
+  const turns = new Map();
+  const turn = (sessionID) => {
+    if (!turns.has(sessionID)) turns.set(sessionID, { text: "", commands: [] });
+    return turns.get(sessionID);
+  };
+  const base = (sessionID, event) => ({ session_id: sessionID, cwd: directory, hook_event_name: event });
+
+  return {
+    "chat.message": async (input, output) => {
+      turns.delete(input.sessionID);
+      const prompt = output.parts
+        .flatMap((part) => (part.type === "text" && !part.synthetic ? [part.text] : []))
+        .join("\\n")
+        .trim();
+      const block = (
+        await hook("context", { ...base(input.sessionID, "chat.message"), ...(prompt ? { prompt } : {}) })
+      ).trim();
+      if (!block) return;
+      output.parts.push({
+        id: partId(),
+        sessionID: input.sessionID,
+        messageID: output.message.id,
+        type: "text",
+        text: block,
+        synthetic: true,
+      });
+    },
+    "tool.execute.after": async (input, output) => {
+      if (EDIT_TOOLS.has(input.tool)) {
+        await hook("stage", {
+          ...base(input.sessionID, "tool.execute.after"),
+          tool_name: input.tool,
+          tool_input: input.args,
+        });
+      } else if (input.tool === "bash" && typeof input.args?.command === "string") {
+        const exit = output.metadata?.exit;
+        turn(input.sessionID).commands.push({
+          command: input.args.command,
+          exit_code: typeof exit === "number" ? exit : null,
+        });
+      }
+    },
+    "experimental.text.complete": async (input, output) => {
+      if (output.text.trim()) turn(input.sessionID).text = output.text;
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.idle") {
+        const sessionID = event.properties.sessionID;
+        const current = turns.get(sessionID);
+        turns.delete(sessionID);
+        await hook("capture", {
+          ...base(sessionID, "session.idle"),
+          ...(current?.text ? { last_assistant_message: current.text } : {}),
+          ...(current?.commands.length ? { shell_commands: current.commands.slice(-20) } : {}),
+        });
+      } else if (event.type === "session.compacted") {
+        await hook("reset", { ...base(event.properties.sessionID, "session.compacted"), source: "compact" });
+      }
+    },
+  };
+};
+`;
+}
+var OPENCODE_PLUGIN_SOURCE = renderOpencodePlugin("full");
+function opencodePluginPath(repositoryRoot) {
+  return join2(resolve2(repositoryRoot), ".opencode", "plugins", "codebuddy.js");
+}
+function plugin2(repositoryRoot, variant = "full") {
+  const path = opencodePluginPath(repositoryRoot);
+  return {
+    marker: OPENCODE_PLUGIN_MARKER,
+    files: [{ path, content: renderOpencodePlugin(variant) }],
+    dirs: [dirname3(path), dirname3(dirname3(path))]
+  };
+}
+function opencodePluginInstalled(repositoryRoot) {
+  return managedPluginInstalled(plugin2(repositoryRoot));
+}
+function setOpencodePlugin(repositoryRoot, enabled, variant = "full") {
+  return setManagedPlugin(plugin2(repositoryRoot, variant), enabled);
+}
+async function opencodePluginVariant(repositoryRoot) {
+  if (!await opencodePluginInstalled(repositoryRoot)) return null;
+  const source = await readFile3(opencodePluginPath(repositoryRoot), "utf8");
+  return source.startsWith(`${OPENCODE_PLUGIN_MARKER} v1 lean`) ? "lean" : "full";
+}
+
+// src/hooks/settings.ts
+import { mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
+import { dirname as dirname4, join as join3, resolve as resolve3 } from "path";
+var HOOK_COMMAND_PREFIX = "codebuddy hooks";
+var TOOL_GUARD_DEF = {
+  event: "PreToolUse",
+  matcher: "Read|Grep|Bash",
+  command: `${HOOK_COMMAND_PREFIX} pretool`
+};
+var HOOK_DEFS = [
+  { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} context` },
+  {
+    event: "PostToolUse",
+    matcher: "Edit|Write|MultiEdit",
+    command: `${HOOK_COMMAND_PREFIX} stage`
+  },
+  { event: "Stop", command: `${HOOK_COMMAND_PREFIX} capture` },
+  // After compaction or /clear the model no longer holds earlier context, so
+  // capsules the session ledger marked as sent must be sent again.
+  { event: "SessionStart", matcher: "compact|clear", command: `${HOOK_COMMAND_PREFIX} reset` },
+  TOOL_GUARD_DEF
+];
+var LEAN_HOOK_DEFS = [
+  { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} lean` },
+  { event: "SessionStart", matcher: "compact|clear", command: `${HOOK_COMMAND_PREFIX} reset` },
+  TOOL_GUARD_DEF
+];
+function claudeSettingsPath(repositoryRoot = process.cwd()) {
+  return join3(resolve3(repositoryRoot), ".claude", "settings.json");
+}
+function upsertHooks(settings, variant = "full") {
+  const defs = variant === "lean" ? LEAN_HOOK_DEFS : HOOK_DEFS;
+  const wanted = new Set(defs.map((def) => def.command));
+  const next = { ...settings, hooks: { ...settings.hooks ?? {} } };
+  const hooks = next.hooks;
+  let changed = false;
+  for (const event of Object.keys(hooks)) {
+    const groups = [];
+    for (const group of hooks[event] ?? []) {
+      const kept = (group.hooks ?? []).filter(
+        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX) || wanted.has(hook.command)
+      );
+      if (kept.length !== (group.hooks ?? []).length) changed = true;
+      if (kept.length > 0) groups.push({ ...group, hooks: kept });
+    }
+    if (groups.length > 0) hooks[event] = groups;
+    else delete hooks[event];
+  }
+  for (const def of defs) {
+    const groups = [...hooks[def.event] ?? []];
+    const existingIndex = groups.findIndex(
+      (group) => group.hooks?.some((hook) => hook.command === def.command)
+    );
+    if (existingIndex === -1) {
+      groups.push({
+        ...def.matcher ? { matcher: def.matcher } : {},
+        hooks: [{ type: "command", command: def.command }]
+      });
+      changed = true;
+    } else {
+      const existing = groups[existingIndex];
+      if (existing && (def.matcher ?? void 0) !== (existing.matcher ?? void 0)) {
+        const { matcher: _oldMatcher, ...rest } = existing;
+        groups[existingIndex] = def.matcher ? { ...rest, matcher: def.matcher } : rest;
+        changed = true;
+      }
+    }
+    hooks[def.event] = groups;
+  }
+  return { settings: next, changed };
+}
+function removeHooks(settings) {
+  if (!settings.hooks) return { settings, changed: false };
+  const next = { ...settings, hooks: { ...settings.hooks } };
+  const hooks = next.hooks;
+  let changed = false;
+  for (const event of Object.keys(hooks)) {
+    const keptGroups = [];
+    for (const group of hooks[event] ?? []) {
+      const keptHooks = (group.hooks ?? []).filter(
+        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX)
+      );
+      if (keptHooks.length !== (group.hooks ?? []).length) changed = true;
+      if (keptHooks.length === 0) continue;
+      keptGroups.push({ ...group, hooks: keptHooks });
+    }
+    if (keptGroups.length === 0) delete hooks[event];
+    else hooks[event] = keptGroups;
+  }
+  return { settings: next, changed };
+}
+function hooksInstalled(settings) {
+  const hooks = settings.hooks ?? {};
+  return Object.values(hooks).some(
+    (groups) => groups.some((group) => group.hooks?.some((h) => h.command?.startsWith(HOOK_COMMAND_PREFIX)))
+  );
+}
+function hooksVariant(settings) {
+  if (!hooksInstalled(settings)) return null;
+  const leanCommand = `${HOOK_COMMAND_PREFIX} lean`;
+  const lean = Object.values(settings.hooks ?? {}).some(
+    (groups) => groups.some((group) => group.hooks?.some((hook) => hook.command === leanCommand))
+  );
+  return lean ? "lean" : "full";
+}
+async function readSettings(path) {
+  try {
+    return JSON.parse(await readFile4(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+async function writeSettings(path, settings) {
+  await mkdir2(dirname4(path), { recursive: true });
+  await writeAtomic(path, `${JSON.stringify(settings, null, 2)}
+`, { mode: 420 });
+}
+
+// src/hooks/install.ts
+var SURFACES = {
+  "claude-settings": {
+    path: claudeSettingsPath,
+    installed: async (root) => hooksInstalled(await readSettings(claudeSettingsPath(root))),
+    variant: async (root) => hooksVariant(await readSettings(claudeSettingsPath(root))),
+    set: async (root, enabled, variant) => {
+      const path = claudeSettingsPath(root);
+      const current = await readSettings(path);
+      const { settings, changed } = enabled ? upsertHooks(current, variant) : removeHooks(current);
+      if (changed) await writeSettings(path, settings);
+      return changed;
+    }
+  },
+  "opencode-plugin": {
+    path: opencodePluginPath,
+    installed: opencodePluginInstalled,
+    variant: opencodePluginVariant,
+    set: setOpencodePlugin
+  },
+  "hermes-plugin": {
+    path: hermesPluginDir,
+    installed: hermesPluginInstalled,
+    variant: hermesPluginVariant,
+    set: setHermesPlugin
+  }
+};
+async function setClientHooks(root, client, enabled, variant = "full") {
+  const surface = CLIENT_ADAPTERS[client].hooks;
+  if (!surface) return null;
+  const { path, set } = SURFACES[surface];
+  return { target: path(root), changed: await set(root, enabled, variant) };
+}
+async function clientHooksVariant(root, client) {
+  const surface = CLIENT_ADAPTERS[client].hooks;
+  if (!surface) return void 0;
+  return SURFACES[surface].variant(root);
+}
+async function clientHooksInstalled(root, client) {
+  const surface = CLIENT_ADAPTERS[client].hooks;
+  return surface ? SURFACES[surface].installed(root) : null;
+}
+async function hookedRulesSiblings(root, client) {
+  const file = CLIENT_ADAPTERS[client].rulesFile;
+  const hooked = [];
+  for (const id of CLIENT_IDS) {
+    if (id !== client && CLIENT_ADAPTERS[id].rulesFile === file && await clientHooksInstalled(root, id))
+      hooked.push(id);
+  }
+  return hooked;
+}
+async function rulesFileHooked(root, client) {
+  return await clientHooksInstalled(root, client) === true || (await hookedRulesSiblings(root, client)).length > 0;
+}
+
+// src/integrations/project-mcp.ts
+import { access, mkdir as mkdir3, readFile as readFile5, rm as rm2 } from "fs/promises";
+import { dirname as dirname5, join as join4, resolve as resolve4 } from "path";
+async function writeProjectMcpConfig(options) {
+  const path = join4(options.repositoryRoot, ".mcp.json");
+  const current = await readProjectMcpConfig(path);
+  current.mcpServers ??= {};
+  current.mcpServers[`codebuddy-${options.namespace}`] = codebuddyMcpServer(
+    options.repositoryRoot,
+    options.namespace
+  );
+  if (options.graphify) {
+    current.mcpServers.graphify = {
+      command: "python",
+      args: [
+        "-m",
+        "graphify.serve",
+        resolve4(options.repositoryRoot, options.graphPath ?? "graphify-out/graph.json")
+      ],
+      env: { CODEBUDDY_PROJECT_ROOT: options.repositoryRoot }
+    };
+  } else if (current.mcpServers.graphify) {
+    delete current.mcpServers.graphify;
+  }
+  await writeAtomic(path, `${JSON.stringify(current, null, 2)}
+`, { mode: 420 });
+  return { path, servers: Object.keys(current.mcpServers).sort() };
+}
+var OPENCODE_SCHEMA = "https://opencode.ai/config.json";
+function codebuddyMcpServer(repositoryRoot, namespace) {
+  return {
+    command: "codebuddy",
+    args: ["serve"],
+    env: {
+      CODEBUDDY_PROJECT_ROOT: repositoryRoot,
+      CODEBUDDY_NAMESPACE: namespace,
+      CODEBUDDY_TOOL_PROFILE: "core"
+    }
+  };
+}
+async function projectMcpPath(root, file, format) {
+  const path = join4(root, file);
+  if (format !== "opencode" || await exists(path)) return path;
+  return await exists(`${path}c`) ? `${path}c` : path;
+}
+async function exists(path) {
+  return access(path).then(
+    () => true,
+    () => false
+  );
+}
+function formatEntry(format, server) {
+  if (format === "mcpServers") return server;
+  return {
+    type: "local",
+    command: [server.command, ...server.args],
+    ...server.env ? { environment: server.env } : {},
+    enabled: true
+  };
+}
+function serversKey(format) {
+  return format === "opencode" ? "mcp" : "mcpServers";
+}
+async function upsertMcpServer(path, format, name, server) {
+  const existed = await exists(path);
+  const { config, comments } = await readConfig(path);
+  const key = serversKey(format);
+  const servers2 = { ...config[key] ?? {} };
+  const entry = formatEntry(format, server);
+  if (JSON.stringify(servers2[name]) === JSON.stringify(entry)) return "unchanged";
+  if (comments) return "manual";
+  servers2[name] = entry;
+  const next = format === "opencode" && !existed ? { $schema: OPENCODE_SCHEMA, ...config, [key]: servers2 } : { ...config, [key]: servers2 };
+  await mkdir3(dirname5(path), { recursive: true });
+  await writeAtomic(path, `${JSON.stringify(next, null, 2)}
+`, { mode: 420 });
+  return existed ? "updated" : "created";
+}
+async function removeMcpServer(path, format, name) {
+  const { config, comments } = await readConfig(path);
+  const key = serversKey(format);
+  const servers2 = { ...config[key] ?? {} };
+  if (!(name in servers2)) return "unchanged";
+  if (comments) return "manual";
+  delete servers2[name];
+  const next = { ...config, [key]: servers2 };
+  const leftover = Object.keys(next).filter((k) => k !== key && k !== "$schema");
+  if (Object.keys(servers2).length === 0 && leftover.length === 0) await rm2(path, { force: true });
+  else await writeAtomic(path, `${JSON.stringify(next, null, 2)}
+`, { mode: 420 });
+  return "removed";
+}
+async function hasMcpServer(path, format, name) {
+  const { config } = await readConfig(path);
+  return name in (config[serversKey(format)] ?? {});
+}
+function parseJsonc(raw) {
+  let comments = false;
+  const json = raw.replace(/"(?:[^"\\]|\\.)*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (match) => {
+    if (match.startsWith('"')) return match;
+    comments = true;
+    return " ";
+  }).replace(/"(?:[^"\\]|\\.)*"|,(\s*[}\]])/g, (match, tail) => tail ?? match);
+  return { value: JSON.parse(json), comments };
+}
+async function readConfig(path) {
+  try {
+    const { value, comments } = parseJsonc(await readFile5(path, "utf8"));
+    const config = value && typeof value === "object" ? value : {};
+    return { config, comments };
+  } catch (error) {
+    if (error.code === "ENOENT") return { config: {}, comments: false };
+    throw new Error(`Could not read ${path}: ${error.message}`);
+  }
+}
+async function readProjectMcpConfig(path) {
+  return (await readConfig(path)).config;
+}
+
+// src/templates/install.ts
+import { readFile as readFile6, rm as rm3 } from "fs/promises";
+import { join as join5, resolve as resolve5 } from "path";
+
+// src/templates/workflow.ts
+var WORKFLOW_CLIENTS = CLIENT_IDS;
+var INTRO = [
+  "You have CodeBuddy available as a local, MCP-backed project-context engine.",
+  "Use it to work like a careful senior engineer, not to dump broad context.",
+  ""
+];
+var START_AGENT = [
+  "## At the start of a substantive coding turn",
+  "",
+  "1. When project context is needed, call `context_pack` with the user's task and a token budget (start",
+  "   with 4000). It automatically finds relevant files and returns bounded symbols,",
+  "   plan, policy, incidents, risks, architecture neighbours, and team facts.",
+  "   Reuse evidence already present. For a clearly identified small edit, read the",
+  "   needed source directly; fetch context for unknown dependencies or project constraints.",
+  "   Read missing function bodies before editing. If safety evidence was omitted,",
+  "   narrow the targets or increase the budget before proceeding.",
+  "2. Use `context_bootstrap` only when you need broad project orientation beyond",
+  "   the task pack. Use `context_before_edit` when you already have exact paths",
+  "   or a plan and need a narrower follow-up.",
+  "3. Prior work from earlier chats arrives as `handoffs` with freshness",
+  "   (`changedSince`, `missing`); re-check those files before relying on it.",
+  "4. On repeated context calls in one conversation, pass a stable `sessionId` and",
+  "   the previous response's `delivery.deliveryId` as `ack`. Unchanged sections",
+  "   are then omitted and listed in `delivery.unchanged`. If earlier output is no",
+  "   longer in your context (e.g. after compaction), pass `full: true`.",
+  ""
+];
+var START_HOOKS = [
+  "## At the start of a substantive coding turn",
+  "",
+  "CodeBuddy hooks inject a `CodeBuddy project context (auto-recalled)` block into",
+  "each prompt: project, plan, policies, facts, incidents, handoffs, current",
+  "changes, and risk. Agents without CodeBuddy hooks (no such block in the prompt)",
+  "follow the agent-driven flow: `context_pack` first, `context_after_turn` last.",
+  "",
+  "1. Start from the injected block; do not call `context_bootstrap` for orientation",
+  "   it already covers. Its `task files` are CodeBuddy's best match; when it names",
+  "   none, call `context_pack` with the task before searching the repository yourself.",
+  "2. Read ranges, not whole files: `Read` with offset/limit, or `sed -n 'A,Bp'`.",
+  "   Large files read whole (`Read` without a range, `cat`, `less`) are denied with an",
+  "   outline of their symbols and line ranges; read the range you need from it.",
+  "3. Call `context_pack` (or `context_before_edit` with exact paths) when the",
+  "   task needs symbols, neighbours, or file-level evidence the block lacks. Pass the",
+  "   block's `session` value as `sessionId` and the previous `delivery.deliveryId`",
+  "   as `ack` so unchanged sections are not resent.",
+  "4. Prior work from earlier chats arrives as handoffs with freshness; re-check",
+  "   those files before relying on it.",
+  ""
+];
+var MIDDLE = [
+  "## While implementing",
+  "",
+  "- Prefer the smallest sufficient set of edits; preserve existing behavior.",
+  "- Honor risk warnings and policy rules for the files you touch; call out risk",
+  "  before editing sensitive areas.",
+  "- Do not re-request broad context if the task pack already suffices.",
+  "",
+  "## Before finalizing",
+  "",
+  "- Consider calling `code_suggestions` (with `paths`, `planId`, or `useGit`) for",
+  "  read-only, evidence-backed quality findings; resolve high-severity ones.",
+  "- Run the smallest relevant verification (tests, lint, typecheck) and fix",
+  "  failures before presenting completion.",
+  ""
+];
+var AFTER_AGENT = [
+  "## After a meaningful turn",
+  "",
+  "- Call `context_after_turn` with a concise `summary`, the `changedFiles`, and a",
+  "  `planId` if one is active, plus `verification` (commands run and results)",
+  "  so the turn's worklog handoff records it. CodeBuddy auto-saves confident facts, decisions,",
+  "  and incidents, queues uncertain or sensitive items for review, and drops",
+  "  chatter. Never paste secrets, tokens, or credentials into the summary.",
+  ""
+];
+var AFTER_HOOKS = [
+  "## After a meaningful turn",
+  "",
+  "- Do not call `context_after_turn`: the turn-end hook captures the turn once, from",
+  "  the real change set and the verification commands you ran. A second capture",
+  "  would record a divergent worklog entry.",
+  "- Never paste secrets, tokens, or credentials into your final message; it is the",
+  "  capture summary.",
+  ""
+];
+var TAIL = [
+  "## If a tool or service is unavailable (degraded mode)",
+  "",
+  "- A CodeBuddy MCP tool errors or is missing: proceed using the repository",
+  "  itself as the source of truth; do not block on it.",
+  "- Postgres is unreachable: the file-based tools (context, plan, risk, map,",
+  "  suggest) still work; recall and embeddings may be degraded \u2014 say so instead",
+  "  of inventing remembered facts.",
+  "- Retrieval returns no context: read the relevant files directly rather than",
+  "  guessing; the working tree is authoritative.",
+  "",
+  "## Never",
+  "",
+  "- Invent behavior the codebase does not support.",
+  "- Ignore failing tests or lint.",
+  "- Make speculative, wide changes without evidence.",
+  "- Save low-confidence project memory as a durable fact."
+];
+function renderBody(mode) {
+  return [
+    ...INTRO,
+    ...mode === "hooks" ? START_HOOKS : START_AGENT,
+    ...MIDDLE,
+    ...mode === "hooks" ? AFTER_HOOKS : AFTER_AGENT,
+    ...TAIL
+  ].join("\n");
+}
+function rulesReaders(file) {
+  return CLIENT_IDS.filter((id) => CLIENT_ADAPTERS[id].rulesFile === file).map((id) => CLIENT_ADAPTERS[id].name).join(", ");
+}
+function renderWorkflowTemplate(client, mode = "agent") {
+  const file = CLIENT_ADAPTERS[client].rulesFile;
+  return [
+    `# CodeBuddy workflow (${rulesReaders(file)})`,
+    "",
+    "This section is managed by CodeBuddy (`codebuddy clients install <client> --mode <mode>`)",
+    `and lives in \`${file}\`. Edit outside the managed markers to customize.`,
+    `Automation mode: \`${mode}\` (${MODE_LABELS[mode]}).`,
+    "",
+    renderBody(mode)
+  ].join("\n");
+}
+function parseWorkflowMode(block) {
+  return block.match(/Automation mode: `(hooks|agent)`/)?.[1] === "hooks" ? "hooks" : "agent";
+}
+function defaultRulesFile(client) {
+  return CLIENT_ADAPTERS[client].rulesFile;
+}
+function clientDisplayName(client) {
+  return CLIENT_ADAPTERS[client].name;
+}
+
+// src/templates/install.ts
+var START_MARKER = "<!-- codebuddy:workflow:start -->";
+var END_MARKER = "<!-- codebuddy:workflow:end -->";
+function renderManagedBlock(client, mode = "agent") {
+  return `${START_MARKER}
+${renderWorkflowTemplate(client, mode)}
+${END_MARKER}
+`;
+}
+async function installWorkflowRules(options) {
+  const projectRoot = resolve5(options.projectRoot ?? process.cwd());
+  const path = options.targetPath ?? join5(projectRoot, defaultRulesFile(options.client));
+  const existing = await readIfPresent(path);
+  const mode = options.mode ?? await defaultRulesMode(options.client, projectRoot);
+  if (options.onlyIfManaged && (existing === null || !hasManagedBlock(existing))) {
+    return { path, client: options.client, action: "unchanged" };
+  }
+  if (mode === "mcp-only") {
+    const content2 = existing === null ? null : removeBlock(existing);
+    if (content2 === null || content2 === existing) {
+      return { path, client: options.client, action: "unchanged" };
+    }
+    if (content2.trim() === "") await rm3(path, { force: true });
+    else await writeAtomic(path, content2, { mode: 420 });
+    return { path, client: options.client, action: "removed" };
+  }
+  const { content, action } = upsertBlock(existing, renderManagedBlock(options.client, mode));
+  if (action === "unchanged") return { path, client: options.client, action };
+  await writeAtomic(path, content, { mode: 420 });
+  return { path, client: options.client, action };
+}
+function upsertBlock(existing, block) {
+  if (existing === null) return { content: block, action: "created" };
+  const start = existing.indexOf(START_MARKER);
+  const end = existing.indexOf(END_MARKER);
+  if (start !== -1 && end !== -1 && end > start) {
+    const before = existing.slice(0, start);
+    const after = existing.slice(end + END_MARKER.length).replace(/^\n/, "");
+    const replaced = `${before}${block}${after}`;
+    return { content: replaced, action: replaced === existing ? "unchanged" : "updated" };
+  }
+  const separator = existing.length === 0 || existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+  return { content: `${existing}${separator}${block}`, action: "added" };
+}
+async function defaultRulesMode(client, projectRoot = process.cwd()) {
+  return await rulesFileHooked(projectRoot, client) ? "hooks" : "agent";
+}
+async function readManagedMode(path) {
+  const existing = await readIfPresent(path);
+  if (existing === null || !hasManagedBlock(existing)) return null;
+  return parseWorkflowMode(existing.slice(existing.indexOf(START_MARKER)));
+}
+function hasManagedBlock(content) {
+  const start = content.indexOf(START_MARKER);
+  return start !== -1 && content.indexOf(END_MARKER) > start;
+}
+function removeBlock(existing) {
+  if (!hasManagedBlock(existing)) return existing;
+  const start = existing.indexOf(START_MARKER);
+  const end = existing.indexOf(END_MARKER) + END_MARKER.length;
+  const before = existing.slice(0, start).replace(/\n\n$/, "\n");
+  const after = existing.slice(end).replace(/^\n/, "");
+  return `${before}${after}`;
+}
+async function readIfPresent(path) {
+  try {
+    return await readFile6(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+// src/cli/commands/codex.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir5, readFile as readFile8 } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname7, join as join7 } from "path";
+
+// src/cli/commands/claude-desktop.ts
+import { existsSync } from "fs";
+import { mkdir as mkdir4, readFile as readFile7 } from "fs/promises";
+import { dirname as dirname6, join as join6, resolve as resolve6 } from "path";
+import { fileURLToPath } from "url";
+function claudeDesktopConfigPath(home = process.env.HOME ?? "") {
+  if (process.platform === "darwin") {
+    return join6(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (process.platform === "win32") {
+    return join6(process.env.APPDATA ?? home, "Claude", "claude_desktop_config.json");
+  }
+  return join6(home, ".config", "Claude", "claude_desktop_config.json");
+}
+async function readClaudeConfig(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(await readFile7(path, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Failed to parse Claude Desktop config at ${path}: ${error.message}`
+    );
+  }
+}
+async function writeClaudeConfig(path, config) {
+  await mkdir4(dirname6(path), { recursive: true });
+  await writeAtomic(path, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function resolveCliEntrypoint() {
+  const fromArgv = process.argv[1];
+  if (fromArgv && existsSync(fromArgv)) return fromArgv;
+  const here = dirname6(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve6(here, "index.js"),
+    // bundled: here = dist/cli/
+    resolve6(here, "..", "cli", "index.js"),
+    // source: here = src/cli/commands/
+    resolve6(here, "..", "index.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return fromArgv ?? candidates[0] ?? "";
+}
+function buildEntry(options) {
+  const env = {
+    CODEBUDDY_NAMESPACE: options.namespace,
+    CODEBUDDY_PROJECT_ROOT: resolve6(options.projectRoot ?? process.cwd())
+  };
+  if (options.hfToken) env.HF_TOKEN = options.hfToken;
+  if (options.groqApiKey) env.GROQ_API_KEY = options.groqApiKey;
+  if (options.databaseUrl) env.DATABASE_URL = options.databaseUrl;
+  return {
+    // Absolute: Claude Desktop is a GUI app and does not inherit the shell's
+    // PATH (nvm, Homebrew), so a bare "node" may not resolve or may be another
+    // version. Re-run `codebuddy claude install` after switching Node.
+    command: process.execPath,
+    args: [resolveCliEntrypoint(), "serve"],
+    env
+  };
+}
+async function installClaudeEntry(options) {
+  const path = claudeDesktopConfigPath();
+  const config = await readClaudeConfig(path);
+  config.mcpServers ??= {};
+  const serverKey = options.serverName ?? `codebuddy-${options.namespace}`;
+  const existed = config.mcpServers[serverKey] !== void 0;
+  config.mcpServers[serverKey] = buildEntry(options);
+  await writeClaudeConfig(path, config);
+  return { path, serverKey, created: !existed };
+}
+async function removeClaudeEntry(serverKey) {
+  const path = claudeDesktopConfigPath();
+  const config = await readClaudeConfig(path);
+  if (!config.mcpServers || !(serverKey in config.mcpServers)) {
+    return { removed: false, path };
+  }
+  delete config.mcpServers[serverKey];
+  await writeClaudeConfig(path, config);
+  return { removed: true, path };
+}
+async function listClaudeEntries() {
+  const path = claudeDesktopConfigPath();
+  const config = await readClaudeConfig(path);
+  const entries = Object.entries(config.mcpServers ?? {}).filter(([key]) => key === "codebuddy" || key.startsWith("codebuddy-")).map(([key, entry]) => ({
+    key,
+    namespace: entry.env?.CODEBUDDY_NAMESPACE ?? null,
+    databaseUrl: entry.env?.DATABASE_URL ?? null
+  }));
+  return { path, entries };
+}
+
+// src/cli/commands/codex.ts
+function codexConfigPath(home = homedir()) {
+  return join7(home, ".codex", "config.toml");
+}
+async function readCodexConfig(path) {
+  if (!existsSync2(path)) return "";
+  return readFile8(path, "utf8");
+}
+async function writeCodexConfig(path, content) {
+  await mkdir5(dirname7(path), { recursive: true });
+  await writeAtomic(path, content, { mode: 384 });
+}
+async function installCodexEntry(options) {
+  const path = codexConfigPath();
+  const serverKey = options.serverName ?? `codebuddy-${options.namespace}`;
+  const current = await readCodexConfig(path);
+  const existed = hasServerBlock(current, serverKey);
+  const entry = buildEntry(options);
+  if (options.toolProfile)
+    entry.env = { ...entry.env, CODEBUDDY_TOOL_PROFILE: options.toolProfile };
+  const next = upsertServerBlock(current, serverKey, entry);
+  if (next !== current) await writeCodexConfig(path, next);
+  return { path, serverKey, created: !existed, changed: next !== current };
+}
+async function removeCodexEntry(serverKey) {
+  const path = codexConfigPath();
+  const current = await readCodexConfig(path);
+  const next = removeServerBlock(current, serverKey);
+  const removed = next !== current;
+  const trimmed = next.trimEnd();
+  if (removed) await writeCodexConfig(path, trimmed ? `${trimmed}
+` : "");
+  return { removed, path };
+}
+async function listCodexEntries() {
+  const path = codexConfigPath();
+  const config = await readCodexConfig(path);
+  const entries = Array.from(config.matchAll(/^\[mcp_servers\."([^"]+)"\]\s*$/gm)).flatMap((match) => match[1] ? [match[1]] : []).filter((key) => key === "codebuddy" || key.startsWith("codebuddy-")).map((key) => {
+    const block = getServerBlock(config, key);
+    return {
+      key,
+      namespace: readEnvValue(block, "CODEBUDDY_NAMESPACE"),
+      databaseUrl: readEnvValue(block, "DATABASE_URL")
+    };
+  });
+  return { path, entries };
+}
+function upsertServerBlock(config, serverKey, entry) {
+  const trimmed = removeServerBlock(config, serverKey).trimEnd();
+  const block = formatServerBlock(serverKey, entry);
+  return `${trimmed}${trimmed ? "\n\n" : ""}${block}
+`;
+}
+function removeServerBlock(config, serverKey) {
+  const escaped = escapeRegExp(serverKey);
+  const end = String.raw`(?![\s\S])`;
+  const sectionPattern = String.raw`^\[mcp_servers\."${escaped}"\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})`;
+  const envPattern = String.raw`^\[mcp_servers\."${escaped}"\.env\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})`;
+  return config.replace(new RegExp(sectionPattern, "gm"), "").replace(new RegExp(envPattern, "gm"), "");
+}
+function getServerBlock(config, serverKey) {
+  const escaped = escapeRegExp(serverKey);
+  const end = String.raw`(?![\s\S])`;
+  const pattern = String.raw`^\[mcp_servers\."${escaped}"\][\s\S]*?(?=^\[mcp_servers\."${escaped}"\.env\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})|^\[[^\]]+\]\s*$|${end})`;
+  const server = config.match(new RegExp(pattern, "m"))?.[0] ?? "";
+  const env = config.match(
+    new RegExp(
+      String.raw`^\[mcp_servers\."${escaped}"\.env\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})`,
+      "m"
+    )
+  )?.[0] ?? "";
+  return `${server}
+${env}`;
+}
+function hasServerBlock(config, serverKey) {
+  return new RegExp(String.raw`^\[mcp_servers\."${escapeRegExp(serverKey)}"\]\s*$`, "m").test(
+    config
+  );
+}
+function formatServerBlock(serverKey, entry) {
+  const lines = [
+    `[mcp_servers.${tomlKey(serverKey)}]`,
+    `command = ${tomlString(entry.command)}`,
+    `args = ${tomlArray(entry.args)}`
+  ];
+  if (entry.env && Object.keys(entry.env).length > 0) {
+    lines.push("", `[mcp_servers.${tomlKey(serverKey)}.env]`);
+    for (const [key, value] of Object.entries(entry.env).sort(
+      ([left], [right]) => left.localeCompare(right)
+    )) {
+      lines.push(`${key} = ${tomlString(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function readEnvValue(block, key) {
+  return block.match(new RegExp(`^${escapeRegExp(key)}\\s*=\\s*"([^"]*)"`, "m"))?.[1] ?? null;
+}
+function tomlKey(key) {
+  return `"${key.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tomlArray(values) {
+  return `[${values.map(tomlString).join(", ")}]`;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/integrations/hermes-config.ts
+import { mkdir as mkdir6, readFile as readFile9 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname8, join as join8 } from "path";
+import { isDeepStrictEqual } from "util";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function hermesConfigPath(home = homedir2()) {
+  return join8(process.env.HERMES_HOME ?? join8(home, ".hermes"), "config.yaml");
+}
+async function readRaw(path) {
+  try {
+    return await readFile9(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+function parseConfig(raw) {
+  try {
+    const value = parseYaml(raw) ?? {};
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function servers(config) {
+  const value = config.mcp_servers;
+  return value && typeof value === "object" ? value : {};
+}
+var isItem = (line) => line.trim() !== "" && !line.trim().startsWith("#");
+var indentOf = (line) => line.length - line.trimStart().length;
+function editMcpServers(raw, name, entry) {
+  const lines = raw.split("\n");
+  const header = lines.findIndex((line) => /^mcp_servers:\s*(#.*)?$/.test(line));
+  const render = (indent2) => stringifyYaml({ [name]: entry }).trimEnd().split("\n").map((line) => `${" ".repeat(indent2)}${line}`);
+  if (header === -1) {
+    if (entry === null) return raw;
+    const body = raw === "" || raw.endsWith("\n") ? raw : `${raw}
+`;
+    return `${body}mcp_servers:
+${render(2).join("\n")}
+`;
+  }
+  let end = header + 1;
+  while (end < lines.length && !/^\S/.test(lines[end] ?? "")) end++;
+  const block = Array.from({ length: end - header - 1 }, (_, i) => header + 1 + i);
+  const items = block.filter((i) => isItem(lines[i] ?? ""));
+  const indent = items.length > 0 ? indentOf(lines[items[0]] ?? "") : 2;
+  const quoted = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const keyLine = new RegExp(`^ {${indent}}(?:${quoted}|"${quoted}"|'${quoted}'):\\s*(#.*)?$`);
+  const start = items.find((i) => keyLine.test(lines[i] ?? ""));
+  if (start === void 0) {
+    if (entry === null) return raw;
+    const at = (items.at(-1) ?? header) + 1;
+    lines.splice(at, 0, ...render(indent));
+    return lines.join("\n");
+  }
+  const next = block.find(
+    (i) => i > start && (lines[i] ?? "").trim() !== "" && indentOf(lines[i] ?? "") <= indent
+  );
+  let stop = next ?? end;
+  while (stop > start + 1 && (lines[stop - 1] ?? "").trim() === "") stop--;
+  lines.splice(start, stop - start, ...entry === null ? [] : render(indent));
+  if (entry === null && items.length > 0 && items.every((i) => i >= start && i < stop)) {
+    lines.splice(header, 1);
+  }
+  return lines.join("\n");
+}
+async function setHermesMcpServer(path, name, entry) {
+  const raw = await readRaw(path);
+  const before = parseConfig(raw);
+  if (!before) return "manual";
+  const current = servers(before)[name];
+  if (entry === null ? current === void 0 : isDeepStrictEqual(current, entry)) {
+    return "unchanged";
+  }
+  const nextServers = { ...servers(before) };
+  if (entry === null) delete nextServers[name];
+  else nextServers[name] = entry;
+  const { mcp_servers: _, ...rest } = before;
+  const expected = Object.keys(nextServers).length > 0 ? { ...rest, mcp_servers: nextServers } : rest;
+  const next = editMcpServers(raw, name, entry);
+  if (!isDeepStrictEqual(parseConfig(next), expected)) return "manual";
+  await mkdir6(dirname8(path), { recursive: true });
+  await writeAtomic(path, next, { mode: 384 });
+  return entry === null ? "removed" : current === void 0 ? "created" : "updated";
+}
+async function readHermesConfig(path) {
+  return parseConfig(await readRaw(path));
+}
+async function hasHermesMcpServer(path, name) {
+  const config = await readHermesConfig(path);
+  return config !== null && name in servers(config);
+}
+
+// src/clients/global-mcp.ts
+function globalMcpPath(target) {
+  return target === "codex" ? codexConfigPath() : hermesConfigPath();
+}
+async function setGlobalMcp(target, options) {
+  const { name, root, namespace, enabled } = options;
+  if (target === "hermes") {
+    return setHermesMcpServer(
+      hermesConfigPath(),
+      name,
+      enabled ? codebuddyMcpServer(root, namespace) : null
+    );
+  }
+  if (!enabled) return (await removeCodexEntry(name)).removed ? "removed" : "unchanged";
+  const result = await installCodexEntry({
+    namespace,
+    projectRoot: root,
+    serverName: name,
+    toolProfile: "core"
+  });
+  return result.created ? "created" : result.changed ? "updated" : "unchanged";
+}
+async function hasGlobalMcp(target, name) {
+  if (target === "hermes") return hasHermesMcpServer(hermesConfigPath(), name);
+  return (await listCodexEntries()).entries.some((entry) => entry.key === name);
+}
+
+// src/clients/install.ts
+async function installClient(options) {
+  const adapter = CLIENT_ADAPTERS[options.client];
+  if (!supportedModes(adapter).includes(options.mode)) {
+    throw new Error(
+      `${adapter.name} does not support ${MODE_LABELS[options.mode]} mode: ${adapter.gap ?? "no lifecycle hooks"}.`
+    );
+  }
+  return apply(options, options.mode, options.mode !== "lean");
+}
+async function ensureIndex(root) {
+  const target = join9(root, ".codebuddy", "cache", "index.json");
+  const existed = await access2(target).then(
+    () => true,
+    () => false
+  );
+  if (!existed) await indexRepository({ repositoryRoot: root });
+  return { surface: "index", target, action: existed ? "unchanged" : "built" };
+}
+async function uninstallClient(options) {
+  return apply(options, "mcp-only", false);
+}
+async function apply(options, mode, keepMcp) {
+  const root = resolve7(options.projectRoot ?? process.cwd());
+  const adapter = CLIENT_ADAPTERS[options.client];
+  const steps = [];
+  const notes = [];
+  const namespace = options.namespace ?? await resolveNamespaceFrom(root);
+  const name = `codebuddy-${namespace}`;
+  const shared = sharedRulesReaders(options.client);
+  const liveSiblings = mode === "mcp-only" || mode === "lean" ? await installedWithMcp(root, shared, namespace) : [];
+  if (liveSiblings.length > 0) {
+    const path = join9(root, adapter.rulesFile);
+    steps.push({ surface: "rules", target: path, action: "kept" });
+    notes.push(
+      `Kept the CodeBuddy block in ${adapter.rulesFile}: still used by ${liveSiblings.map((id) => CLIENT_ADAPTERS[id].name).join(", ")}.`
+    );
+  } else {
+    const hooked = mode === "agent" ? await hookedRulesSiblings(root, options.client) : [];
+    const rules = await installWorkflowRules({
+      client: options.client,
+      projectRoot: root,
+      // Lean sends no rules: the block would cost tokens every turn and shadow AGENTS.md.
+      mode: mode === "lean" ? "mcp-only" : hooked.length > 0 ? "hooks" : mode
+    });
+    steps.push({ surface: "rules", target: rules.path, action: rules.action });
+    if (hooked.length > 0) {
+      notes.push(
+        `Kept ${adapter.rulesFile} hook-driven: ${hooked.map((id) => CLIENT_ADAPTERS[id].name).join(", ")} hooks are installed; agents without hooks follow its agent-driven fallback.`
+      );
+    }
+  }
+  if (shared.length > 0) {
+    notes.push(
+      `${adapter.rulesFile} is also read by ${shared.map((id) => CLIENT_ADAPTERS[id].name).join(", ")}.`
+    );
+  }
+  const hooks = await setHooks(
+    root,
+    mode === "hooks" || mode === "lean",
+    options.client,
+    mode === "lean" ? "lean" : "full"
+  );
+  if (hooks) steps.push(hooks);
+  if (mode === "lean") steps.push(await ensureIndex(root));
+  if ("file" in adapter.mcp) {
+    const path = await projectMcpPath(root, adapter.mcp.file, adapter.mcp.format);
+    const action = keepMcp ? await upsertMcpServer(path, adapter.mcp.format, name, codebuddyMcpServer(root, namespace)) : await removeMcpServer(path, adapter.mcp.format, name);
+    steps.push({ surface: "mcp", target: path, action });
+    if (action === "manual") {
+      notes.push(
+        `${path} has comments CodeBuddy will not rewrite; ${keepMcp ? "add" : "remove"} the "${name}" entry under "mcp" by hand${keepMcp ? `: ${JSON.stringify(formatEntry(adapter.mcp.format, codebuddyMcpServer(root, namespace)))}` : ""}.`
+      );
+    }
+  } else if (options.global) {
+    const target = globalMcpPath(adapter.mcp.global);
+    const action = await setGlobalMcp(adapter.mcp.global, {
+      name,
+      root,
+      namespace,
+      enabled: keepMcp
+    });
+    steps.push({ surface: "mcp", target, action });
+    if (action === "manual") {
+      notes.push(
+        `${target} is not a YAML map CodeBuddy can edit safely; ${keepMcp ? "add" : "remove"} the "${name}" entry under mcp_servers by hand.`
+      );
+    }
+  } else {
+    notes.push(
+      `MCP config is global; ${keepMcp ? "add" : "remove"} it with --global, or: ${adapter.mcp.manual}.`
+    );
+  }
+  if (adapter.note && mode !== "mcp-only") notes.push(`${adapter.name}: ${adapter.note}.`);
+  return { client: options.client, steps, notes };
+}
+async function installedWithMcp(root, clients, namespace) {
+  const live = [];
+  for (const id of clients) {
+    if ((await detectClient(id, root, namespace)).mcp) live.push(id);
+  }
+  return live;
+}
+async function setHooks(root, enabled, client = "claude", variant = "full") {
+  const result = await setClientHooks(root, client, enabled, variant);
+  if (!result) return null;
+  const action = result.changed ? enabled ? "installed" : "removed" : "unchanged";
+  return { surface: "hooks", target: result.target, action };
+}
+async function detectClient(client, projectRoot = process.cwd(), namespace) {
+  const root = resolve7(projectRoot);
+  const adapter = CLIENT_ADAPTERS[client];
+  const rulesMode = await readManagedMode(join9(root, adapter.rulesFile));
+  const hooks = await clientHooksInstalled(root, client);
+  const name = `codebuddy-${namespace ?? await resolveNamespaceFrom(root)}`;
+  const mcp = "file" in adapter.mcp ? await hasMcpServer(
+    await projectMcpPath(root, adapter.mcp.file, adapter.mcp.format),
+    adapter.mcp.format,
+    name
+  ) : await hasGlobalMcp(adapter.mcp.global, name).catch(() => false);
+  const warnings = [];
+  if (hooks && rulesMode === "agent") {
+    warnings.push(
+      `hooks are installed but ${adapter.rulesFile} is agent-driven: retrieval and capture run twice. Run \`codebuddy clients install ${client} --mode hooks\`.`
+    );
+  }
+  if (rulesMode === "hooks" && hooks === false) {
+    warnings.push(
+      `${adapter.rulesFile} is hook-driven but hooks are not installed: turns are not captured.`
+    );
+  }
+  const effectiveRules = hooks === null && rulesMode === "hooks" ? "agent" : rulesMode;
+  const mode = hooks ? await clientHooksVariant(root, client) === "lean" ? "lean" : "hooks" : effectiveRules ?? (mcp ? "mcp-only" : "none");
+  return { client, mode, rulesMode, hooks, mcp, warnings };
+}
+
+export {
+  hermesPluginInstalled,
+  clientHooksInstalled,
+  writeProjectMcpConfig,
+  WORKFLOW_CLIENTS,
+  renderWorkflowTemplate,
+  clientDisplayName,
+  renderManagedBlock,
+  installWorkflowRules,
+  defaultRulesMode,
+  installClaudeEntry,
+  removeClaudeEntry,
+  listClaudeEntries,
+  installCodexEntry,
+  removeCodexEntry,
+  listCodexEntries,
+  hermesConfigPath,
+  readHermesConfig,
+  installClient,
+  uninstallClient,
+  setHooks,
+  detectClient
+};
+//# sourceMappingURL=chunk-J4T6HHI4.js.map