@codemap-ai/cli 0.1.0

package/dist/chunk-KWYP3ADN.js

@@ -0,0 +1,1742 @@
+import{createRequire as __cmr}from"node:module";import{fileURLToPath as __f2p}from"node:url";import{dirname as __dn}from"node:path";var require=__cmr(import.meta.url);var __filename=__f2p(import.meta.url);var __dirname=__dn(__filename);
+import {
+  MASTRA_DISABLED_TOOLS,
+  ensureLocalIndexWithSummary,
+  getMastraMcpStatusSummary,
+  getWorkspaceStatusLines,
+  listMastraThreadMessages,
+  listMastraThreads,
+  readWorkspacePath,
+  removeMcpServerEntry,
+  require_dist,
+  saveMcpServerEntry
+} from "./chunk-FFFJKKKM.js";
+import {
+  __toESM,
+  clearGlobalAuthConfig,
+  createCodeMapClient,
+  loadConfig,
+  startMcpLogin,
+  tryOpenLoginBrowser,
+  waitForLoginAuthorization
+} from "./chunk-AXGGL47C.js";
+
+// src/cli-agent/core/convention-synthesizer.ts
+import { readFile, writeFile, mkdir, stat, readdir } from "fs/promises";
+import { createHash } from "crypto";
+import { spawnSync } from "child_process";
+import path from "path";
+var CONVENTION_SOURCES = [
+  { label: "Claude Code", paths: ["CLAUDE.md", ".claude/CLAUDE.md"] },
+  { label: "Codex", paths: [".codex/codemap-agent-pack.md", ".codex/config.toml", ".codex/agents/*.toml"] },
+  { label: "Cursor", paths: [".cursorrules", ".cursor/rules/*.mdc"] },
+  { label: "Windsurf", paths: [".windsurfrules"] },
+  { label: "GitHub Copilot", paths: [".github/copilot-instructions.md"] },
+  { label: "Cline", paths: [".clinerules"] },
+  { label: "OpenAI Codex", paths: ["AGENTS.md"] },
+  { label: "General", paths: ["CONVENTIONS.md"] }
+];
+var RULE_SOURCES = [
+  { label: "Claude Code rules", paths: [".claude/rules/*.md"] }
+];
+var SKILL_DIRS = [".claude/skills", ".codex/skills"];
+function getWorkspaceRoot() {
+  const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8", cwd: process.cwd() });
+  return r.stdout?.trim() || process.cwd();
+}
+function dotCodemap() {
+  return path.join(getWorkspaceRoot(), ".codemap");
+}
+function cachePaths() {
+  const dir = dotCodemap();
+  return {
+    conventions: { md: path.join(dir, "synthesized-conventions.md"), meta: path.join(dir, "conventions-meta.json") },
+    rules: { md: path.join(dir, "synthesized-rules.md"), meta: path.join(dir, "rules-meta.json") },
+    skills: { md: path.join(dir, "synthesized-skills.md"), meta: path.join(dir, "skills-meta.json") }
+  };
+}
+async function readConfig(root) {
+  try {
+    return JSON.parse(await readFile(path.join(root, ".codemap", "agent-context.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function expandGlob(root, pattern) {
+  if (!pattern.includes("*")) {
+    try {
+      await stat(path.join(root, pattern));
+      return [pattern];
+    } catch {
+      return [];
+    }
+  }
+  const parts = pattern.split("/");
+  const starIdx = parts.findIndex((p) => p.includes("*"));
+  const parentDir = parts.slice(0, starIdx).join("/") || ".";
+  const starPart = parts[starIdx];
+  const rest = parts.slice(starIdx + 1).join("/");
+  let entries;
+  try {
+    entries = await readdir(path.join(root, parentDir));
+  } catch {
+    return [];
+  }
+  const results = [];
+  if (starPart === "*" && rest) {
+    for (const e of entries) {
+      const c = [parentDir === "." ? "" : parentDir, e, rest].filter(Boolean).join("/");
+      try {
+        await stat(path.join(root, c));
+        results.push(c);
+      } catch {
+      }
+    }
+  } else {
+    const ext = path.extname(rest || starPart).replace("*", "");
+    for (const e of entries) {
+      if (!ext || e.endsWith(ext))
+        results.push([parentDir === "." ? "" : parentDir, e].filter(Boolean).join("/"));
+    }
+  }
+  return results;
+}
+async function scanSources(root, sources) {
+  const results = [];
+  for (const { label, paths } of sources) {
+    for (const pattern of paths) {
+      for (const rel of await expandGlob(root, pattern)) {
+        try {
+          const content = await readFile(path.join(root, rel), "utf8");
+          if (content.trim()) results.push({ label, filePath: rel, content });
+        } catch {
+        }
+      }
+    }
+  }
+  return results;
+}
+async function scanSkills(root) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const dir of SKILL_DIRS) {
+    let entries;
+    try {
+      entries = await readdir(path.join(root, dir));
+    } catch {
+      continue;
+    }
+    for (const skillName of entries) {
+      const rel = `${dir}/${skillName}/SKILL.md`;
+      if (seen.has(skillName)) continue;
+      try {
+        const content = await readFile(path.join(root, rel), "utf8");
+        if (content.trim()) seen.set(skillName, { label: `Skill: ${skillName}`, filePath: rel, content });
+      } catch {
+      }
+    }
+  }
+  return [...seen.values()];
+}
+function hashFiles(files) {
+  const h = createHash("sha256");
+  for (const f of files) h.update(f.filePath).update(f.content);
+  return h.digest("hex").slice(0, 16);
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+async function loadCache(paths, hash) {
+  try {
+    const [content, metaRaw] = await Promise.all([readFile(paths.md, "utf8"), readFile(paths.meta, "utf8")]);
+    const meta = JSON.parse(metaRaw);
+    if (meta.hash === hash && content.trim()) return content;
+  } catch {
+  }
+  return null;
+}
+async function saveCache(paths, content, hash, files) {
+  const meta = { hash, scannedFiles: files.map((f) => f.filePath), tokenCount: estimateTokens(content), synthesizedAt: Date.now() };
+  await mkdir(dotCodemap(), { recursive: true });
+  await Promise.all([writeFile(paths.md, content, "utf8"), writeFile(paths.meta, JSON.stringify(meta, null, 2), "utf8")]);
+}
+async function stream(provider, model, prompt, userContent) {
+  let result = "";
+  for await (const chunk of provider.stream({
+    model,
+    messages: [{ role: "user", content: `${prompt}
+
+${userContent}` }]
+  })) {
+    if (chunk.text) result += chunk.text;
+  }
+  return result.trim();
+}
+function buildInput(files) {
+  return files.map((f) => `=== ${f.label}: ${f.filePath} ===
+${f.content}`).join("\n\n");
+}
+var CONVENTIONS_PROMPT = `You are synthesizing project configuration and convention files from multiple AI agent configs into a unified project guide.
+
+Instructions:
+- Merge overlapping content, keep the most specific version
+- Remove exact duplicates
+- Keep: architecture, tech stack, coding style, naming conventions, commands, UI routes, design system
+- Skip: rule lists and skill workflows (those are handled separately)
+- Organize by topic with ## headers
+- Output clean markdown
+
+Output ONLY the unified guide. No preamble.`;
+var RULES_PROMPT = `You are synthesizing project rule files into a unified rule set.
+
+Instructions:
+- Merge rules from all files
+- Remove EXACT duplicate rules only \u2014 preserve all unique rules fully intact
+- Do NOT compress, summarize, or shorten any rule
+- Organize by topic with ## headers
+- Output clean markdown
+
+Output ONLY the unified rules. No preamble.`;
+var SKILLS_PROMPT = `You are synthesizing project workflow skill files into a unified skills guide.
+
+Instructions:
+- Each skill has a name and step-by-step process
+- If multiple files describe the same skill, keep the most complete version
+- Keep ALL step-by-step processes fully intact \u2014 do NOT compress or summarize
+- Organize skills with ## headers (one per skill)
+- Output clean markdown
+
+Output ONLY the unified skills guide. No preamble.`;
+async function runPipeline(root, files, paths, prompt, provider, model, maxTokens, forceRefresh) {
+  if (files.length === 0) return null;
+  const hash = hashFiles(files);
+  if (!forceRefresh) {
+    const cached = await loadCache(paths, hash);
+    if (cached) return cached;
+  }
+  const content = await stream(provider, model, prompt, buildInput(files));
+  if (!content) return null;
+  let final = content;
+  if (maxTokens) {
+    const est = estimateTokens(content);
+    if (est > maxTokens) {
+      final = content.slice(0, maxTokens * 4).trimEnd() + `
+
+_[Truncated \u2014 increase \`conventionMaxTokens\` in .codemap/agent-context.json]_`;
+    }
+  }
+  await saveCache(paths, final, hash, files).catch(() => {
+  });
+  return final;
+}
+async function loadOrSynthesizeAll(provider, model, forceRefresh = false) {
+  const root = getWorkspaceRoot();
+  const config = await readConfig(root);
+  const maxTokens = config.conventionMaxTokens ?? null;
+  const cp = cachePaths();
+  const [conventionFiles, ruleFiles, skillFiles] = await Promise.all([
+    scanSources(root, CONVENTION_SOURCES),
+    scanSources(root, RULE_SOURCES),
+    scanSkills(root)
+  ]);
+  if (conventionFiles.length === 0 && ruleFiles.length === 0 && skillFiles.length === 0) return null;
+  const [conventions, rules, skills] = await Promise.all([
+    runPipeline(root, conventionFiles, cp.conventions, CONVENTIONS_PROMPT, provider, model, maxTokens, forceRefresh),
+    runPipeline(root, ruleFiles, cp.rules, RULES_PROMPT, provider, model, null, forceRefresh),
+    runPipeline(root, skillFiles, cp.skills, SKILLS_PROMPT, provider, model, null, forceRefresh)
+  ]);
+  const fromCache = !forceRefresh;
+  return { conventions, rules, skills, fromCache };
+}
+async function refreshAll(provider, model) {
+  return loadOrSynthesizeAll(provider, model, true);
+}
+async function getCachedContext() {
+  const cp = cachePaths();
+  const [conventions, rules, skills] = await Promise.all([
+    readFile(cp.conventions.md, "utf8").then((s) => s.trim() || null).catch(() => null),
+    readFile(cp.rules.md, "utf8").then((s) => s.trim() || null).catch(() => null),
+    readFile(cp.skills.md, "utf8").then((s) => s.trim() || null).catch(() => null)
+  ]);
+  return { conventions, rules, skills };
+}
+
+// src/cli-agent/chat/slash-commands/shell.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function runShell(command) {
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: process.cwd(),
+      maxBuffer: 10 * 1024 * 1024,
+      shell: process.env.SHELL || "/bin/sh"
+    });
+    return `${stdout}${stderr}`;
+  } catch (err) {
+    const output = err;
+    return `${output.stdout ?? ""}${output.stderr ?? ""}`;
+  }
+}
+
+// src/cli-agent/chat/slash-commands/sessions.ts
+function stringifyToolResult(result) {
+  return typeof result === "string" ? result : JSON.stringify(result ?? "");
+}
+function attachToolResult(messages, part, timestamp) {
+  const resultText = stringifyToolResult(part.result);
+  const content = part.isError ? `[ERROR] ${resultText}` : resultText;
+  const toolResult = {
+    name: part.name,
+    content,
+    fullContent: content,
+    success: !part.isError
+  };
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (!msg) continue;
+    if (msg.role === "user" || msg.role === "assistant" || msg.role === "system") break;
+    if (msg.role === "tool_call" && (msg.toolCallId === part.id || !msg.toolCallId && msg.name === part.name)) {
+      messages[i] = {
+        ...msg,
+        toolCallId: msg.toolCallId ?? part.id,
+        toolResults: [...msg.toolResults ?? [], toolResult],
+        expandedContent: content,
+        content: msg.content.endsWith(" \u2713") || msg.content.endsWith(" \u2717") ? msg.content : `${msg.content}${part.isError ? " \u2717" : " \u2713"}`
+      };
+      return;
+    }
+  }
+  messages.push({
+    role: "tool_call",
+    name: part.name,
+    toolCallId: part.id,
+    content: `Call ${part.name}${part.isError ? " \u2717" : " \u2713"}`,
+    toolResults: [toolResult],
+    expandedContent: content,
+    timestamp
+  });
+}
+function formatAge(date) {
+  const diff = Date.now() - date.getTime();
+  const m = Math.floor(diff / 6e4);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+function getThreadTokenUsage(t) {
+  const metaUsage = t.metadata?.tokenUsage;
+  if (metaUsage?.totalTokens) return metaUsage;
+  return t.tokenUsage;
+}
+function formatThread(t, current) {
+  const usage = getThreadTokenUsage(t);
+  const tok = usage?.totalTokens ? ` \xB7 ${Math.round(usage.totalTokens / 1e3)}k tok` : "";
+  const title = t.title ?? t.id.slice(0, 8);
+  const bullet = current ? " \u25CF" : "";
+  return `\`${t.id.slice(0, 8)}\`${bullet} ${title}${tok}  ${formatAge(t.updatedAt)}`;
+}
+function extractText(content) {
+  return content.filter((p) => p.type === "text").map((p) => p.text).join(" ");
+}
+function extractTaskContent(raw) {
+  const match = raw.match(/<task>\n([\s\S]*?)\n<\/task>/);
+  return match?.[1]?.trim() ?? raw.trim();
+}
+function mapHarnessMessagesToUI(messages) {
+  const result = [];
+  for (const msg of messages) {
+    const ts = msg.createdAt.getTime();
+    if (msg.role === "user") {
+      const raw = extractText(msg.content);
+      result.push({ role: "user", content: extractTaskContent(raw), timestamp: ts });
+    } else if (msg.role === "assistant") {
+      let textParts = "";
+      for (const part of msg.content) {
+        if (part.type === "text") {
+          textParts += part.text;
+        } else if (part.type === "tool_call") {
+          const p = part;
+          if (textParts.trim()) {
+            result.push({ role: "assistant", content: textParts.trim(), timestamp: ts });
+            textParts = "";
+          }
+          result.push({ role: "tool_call", name: p.name, toolCallId: p.id, content: `Call ${p.name}`, timestamp: ts });
+        } else if (part.type === "tool_result") {
+          attachToolResult(result, part, ts);
+        }
+      }
+      if (textParts.trim()) {
+        result.push({ role: "assistant", content: textParts.trim(), timestamp: ts });
+      }
+    } else if (msg.role === "system") {
+      const text = extractText(msg.content);
+      if (text) result.push({ role: "system", content: text, timestamp: ts });
+    }
+  }
+  return result;
+}
+var sessionsCommand = {
+  name: "sessions",
+  description: "List or load Mastra chat threads. Usage: /sessions [new|load <thread-id>]",
+  execute: async (args, ctx) => {
+    const append = (content) => ctx.setMessages((prev) => [...prev, { role: "system", content, timestamp: Date.now() }]);
+    const [sub, ...rest] = args.trim().split(/\s+/);
+    if (sub === "new") {
+      ctx.newSession?.();
+      append("Started a new session.");
+      return;
+    }
+    if (sub === "load" && rest[0]) {
+      const prefix = rest[0];
+      const threads2 = await listMastraThreads();
+      const target = threads2.find((t) => t.id.startsWith(prefix));
+      if (!target) {
+        append(`No thread matching \`${prefix}\`. Run /sessions to list.`);
+        return;
+      }
+      await ctx.loadThreadById?.(target.id);
+      return;
+    }
+    const threads = await listMastraThreads();
+    if (threads.length === 0) {
+      append("No saved threads yet.");
+      return;
+    }
+    const currentId = ctx.getMastraThreadId?.() ?? null;
+    const lines = ["**Recent threads** (newest first):", ""];
+    [...threads].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 10).forEach((t) => lines.push(formatThread(t, t.id === currentId)));
+    lines.push("", "_/sessions new \xB7 /sessions load <thread-id>_");
+    append(lines.join("\n"));
+  }
+};
+async function loadThreadIntoUI(threadId, setMessages, appendMessage) {
+  const harnessMessages = await listMastraThreadMessages(threadId, 200);
+  if (harnessMessages.length === 0) {
+    appendMessage({ role: "system", content: "Thread is empty." });
+    return;
+  }
+  const uiMessages = mapHarnessMessagesToUI(harnessMessages);
+  setMessages([
+    ...uiMessages,
+    { role: "system", content: `_Thread loaded \xB7 ${uiMessages.filter((m) => m.role === "user").length} turns_`, timestamp: Date.now() }
+  ]);
+}
+
+// src/cli-agent/chat/slash-commands/help.ts
+var helpCommand = {
+  name: "help",
+  description: "Show this help",
+  execute: (_args, ctx) => {
+    const lines = (ctx.getCommandList?.() ?? []).map(
+      (c) => `/${c.name.padEnd(18)} ${c.description}`
+    );
+    lines.push("", "@mention           Type @ to autocomplete file paths");
+    ctx.setMessages((prev) => [
+      ...prev,
+      { role: "system", content: lines.join("\n") }
+    ]);
+  }
+};
+
+// src/cli-agent/chat/slash-commands/clear.ts
+var clearCommand = {
+  name: "clear",
+  description: "Clear screen and start a new session (old session preserved in /sessions)",
+  execute: (_args, ctx) => {
+    ctx.newSession?.();
+  }
+};
+
+// src/cli-agent/chat/slash-commands/exit.ts
+var exitCommand = {
+  name: "exit",
+  description: "Exit chat",
+  execute: (_args, ctx) => {
+    ctx.exit();
+  }
+};
+
+// src/cli-agent/chat/slash-commands/status.ts
+var statusCommand = {
+  name: "status",
+  description: "Show model, session, and workspace status",
+  execute: async (_args, ctx) => {
+    const workspaceStatus = await getWorkspaceStatusLines();
+    ctx.setMessages((prev) => [
+      ...prev,
+      {
+        role: "system",
+        content: [
+          `Model:   ${ctx.currentModel}`,
+          `History: ${ctx.getMessages().length} messages`,
+          ctx.availableModels?.length ? `Gateway: ${ctx.availableModels.length} models available` : "Gateway: not available",
+          ctx.getSessionTokens() > 0 ? `Tokens:  ${ctx.getSessionTokens().toLocaleString()} total (thread)` : "",
+          "",
+          ...workspaceStatus
+        ].filter((l, i, arr) => l !== "" || arr[i - 1] !== "").join("\n")
+      }
+    ]);
+  }
+};
+
+// src/cli-agent/chat/slash-commands/models.ts
+var modelsCommand = {
+  name: "models",
+  description: "Switch the active model",
+  execute: (_args, ctx) => {
+    if (!ctx.availableModels || ctx.availableModels.length === 0) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: "No gateway models available." }
+      ]);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/tool-categories.ts
+var TOOL_CATEGORIES = {
+  // ── Local-only ───────────────────────────────────────────────────────────
+  refresh_local_index: "local",
+  diff: "local",
+  get_current_workspace_info: "local",
+  web_search: "local",
+  web_fetch: "local",
+  // ── Local index + optional cloud enhancement ─────────────────────────────
+  explore_task: "local",
+  search_codebase: "local",
+  get_file: "local",
+  find_related_files: "local",
+  symbol: "local",
+  rename_symbol: "local",
+  move_symbols: "local",
+  // ── Auth required, no project needed ─────────────────────────────────────
+  check_auth_status: "auth",
+  login: "auth",
+  logout: "auth",
+  get_project: "auth",
+  list_projects: "auth",
+  link_project: "auth",
+  manage_git_connection: "auth",
+  list_repositories: "auth",
+  // ── Cloud project required ────────────────────────────────────────────────
+  create_project: "cloud",
+  reimport: "cloud",
+  get_project_insights: "cloud",
+  get_project_map: "cloud"
+};
+
+// src/cli-agent/chat/slash-commands/tools.ts
+var BOLD = "\x1B[1m";
+var RESET = "\x1B[0m";
+var C_GRAY = "\x1B[38;2;107;114;128m";
+var C_CYAN = `${BOLD}\x1B[38;2;0;229;255m`;
+var C_GREEN = "\x1B[38;2;34;197;94m";
+var C_YELLOW = "\x1B[38;2;250;204;21m";
+var C_MAGENTA = "\x1B[38;2;217;119;214m";
+var SECTION = {
+  local: { label: "LOCAL", color: C_GREEN, note: "works offline, no auth" },
+  auth: { label: "AUTH", color: C_YELLOW, note: "login required" },
+  cloud: { label: "CLOUD", color: C_CYAN, note: "login + linked project" }
+};
+var EXTERNAL_SECTION = { label: "EXTERNAL", color: C_MAGENTA, note: "from user MCP servers" };
+var toolsCommand = {
+  name: "tools",
+  description: "List available MCP tools grouped by category",
+  execute: async (_args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const allTools = await ctx.toolClient.listAllowedTools();
+      const disabledSet = new Set(MASTRA_DISABLED_TOOLS.map((n) => n.replace(/^codemap_/, "")));
+      const tools = allTools.filter((t) => !disabledSet.has(t.name));
+      const disabledTools = allTools.filter((t) => disabledSet.has(t.name));
+      const nameW = Math.min(32, Math.max(6, ...allTools.map((t) => t.name.length)));
+      const descW = 58;
+      const grouped = { local: [], auth: [], cloud: [] };
+      for (const t of tools) {
+        const cat = TOOL_CATEGORIES[t.name] ?? "cloud";
+        grouped[cat].push(t);
+      }
+      const mastraStatus = await getMastraMcpStatusSummary();
+      const externalTools = [];
+      if (mastraStatus?.statuses) {
+        for (const server of mastraStatus.statuses) {
+          if (server.toolNames.length === 0) continue;
+          if (server.name === "codemap") continue;
+          const serverTools = server.toolNames.map((name) => ({ name }));
+          externalTools.push({ server: server.name, tools: serverTools });
+        }
+      }
+      const lines = [
+        `${BOLD}Available tools${RESET}  ${C_GRAY}${tools.length} MCP active, ${disabledTools.length} disabled${RESET}`,
+        ""
+      ];
+      for (const cat of ["local", "auth", "cloud"]) {
+        const group = grouped[cat];
+        if (group.length === 0) continue;
+        const { label, color, note } = SECTION[cat];
+        lines.push("");
+        lines.push(
+          `${color}${BOLD}${label}${RESET}  ${C_GRAY}${note}  \xB7  ${group.length} tools${RESET}`
+        );
+        lines.push(`${C_GRAY}${"\u2500".repeat(nameW + descW + 4)}${RESET}`);
+        for (const t of group) {
+          const name = t.name.padEnd(nameW).slice(0, nameW);
+          const raw = (t.description ?? "").replace(/\n.*/s, "").trim();
+          const desc = raw.length > descW ? raw.slice(0, descW - 1) + "\u2026" : raw;
+          lines.push(`${color}${name}${RESET}  ${C_GRAY}${desc}${RESET}`);
+        }
+        lines.push("");
+      }
+      if (externalTools.length > 0) {
+        const { label, color, note } = EXTERNAL_SECTION;
+        const totalExternal = externalTools.reduce((sum, e) => sum + e.tools.length, 0);
+        lines.push("");
+        lines.push(
+          `${color}${BOLD}${label}${RESET}  ${C_GRAY}${note}  \xB7  ${totalExternal} tools from ${externalTools.length} server(s)${RESET}`
+        );
+        lines.push(`${C_GRAY}${"\u2500".repeat(nameW + descW + 4)}${RESET}`);
+        for (const { server, tools: serverTools } of externalTools) {
+          lines.push(`${C_GRAY}${" ".repeat(nameW + 2)}${color}[${server}]${RESET}`);
+          for (const t of serverTools) {
+            const name = t.name.padEnd(nameW).slice(0, nameW);
+            lines.push(`${color}${name}${RESET}`);
+          }
+        }
+        lines.push("");
+      }
+      if (disabledTools.length > 0) {
+        lines.push("");
+        lines.push(
+          `${C_GRAY}${BOLD}DISABLED${RESET}  ${C_GRAY}handled by CLI /commands or internal  \xB7  ${disabledTools.length} tools${RESET}`
+        );
+        lines.push(`${C_GRAY}${"\u2500".repeat(nameW + descW + 4)}${RESET}`);
+        for (const t of disabledTools) {
+          const name = t.name.padEnd(nameW).slice(0, nameW);
+          const raw = (t.description ?? "").replace(/\n.*/s, "").trim();
+          const desc = raw.length > descW ? raw.slice(0, descW - 1) + "\u2026" : raw;
+          lines.push(`${C_GRAY}${name}  ${desc}${RESET}`);
+        }
+        lines.push("");
+      }
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: lines.join("\n") }
+      ]);
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: `Error listing tools: ${err}` }
+      ]);
+    }
+    ctx.setBusy(false);
+  }
+};
+
+// src/cli-agent/chat/slash-commands/diff.ts
+var diffCommand = {
+  name: "diff",
+  description: "Show working diff",
+  execute: async (_args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const result = await ctx.toolClient.callTool("diff", {
+        mode: "working",
+        include_patch: false,
+        include_untracked: true
+      });
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: result.content }
+      ]);
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: `Error: ${err}` }
+      ]);
+    }
+    ctx.setBusy(false);
+  }
+};
+
+// src/cli-agent/chat/slash-commands/history.ts
+var historyCommand = {
+  name: "history",
+  description: "Show conversation stats",
+  execute: (_args, ctx) => {
+    const msgs = ctx.getMessages();
+    const turns = msgs.filter((m) => m.role === "user").length;
+    ctx.setMessages((prev) => [
+      ...prev,
+      {
+        role: "system",
+        content: `Conversation: ${turns} user turns, ${msgs.length} total messages`
+      }
+    ]);
+  }
+};
+
+// src/cli-agent/chat/slash-commands/debug.ts
+var debugCommand = {
+  name: "debug",
+  description: "Toggle stream debug logging to JSONL file",
+  execute: (args, ctx) => {
+    const set = (on) => {
+      ctx.setDebug(on);
+      const logLine = ctx.debugLogFile ? `
+Log file: ${ctx.debugLogFile}` : "\nLog file will be created on next message.";
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Debug mode: ${on ? "ON" : "OFF"}${on ? logLine : ""}`
+        }
+      ]);
+    };
+    if (args === "on") return set(true);
+    if (args === "off") return set(false);
+    set(!ctx.debug);
+  }
+};
+
+// src/cli-agent/chat/slash-commands/mcp.ts
+var mcpCommand = {
+  name: "mcp",
+  description: "Manage MCP servers: list, add, remove",
+  execute: async (args, ctx) => {
+    const parts = args.trim().split(/\s+/);
+    const sub = parts[0];
+    if (!sub) {
+      return showStatus(ctx);
+    }
+    if (sub === "add") {
+      const name = parts[1];
+      const command = parts[2];
+      if (!name || !command) {
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: "Usage: /mcp add <name> <command> [args...]" }
+        ]);
+        return;
+      }
+      const cmdArgs = parts.slice(3);
+      const config = { command, args: cmdArgs.length > 0 ? cmdArgs : void 0 };
+      const workspaceRoot = await readWorkspacePath();
+      await saveMcpServerEntry(workspaceRoot, name, config);
+      ctx.toolClient.addExtraServer(name, config);
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Added MCP server "${name}" \u2192 ${command} ${cmdArgs.join(" ")}
+Connecting\u2026`
+        }
+      ]);
+      ctx.setBusy(true);
+      try {
+        await ctx.reinitHarness?.();
+      } catch (err) {
+        ctx.setBusy(false);
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.toolClient.removeExtraServer(name);
+        await removeMcpServerEntry(workspaceRoot, name).catch(() => {
+        });
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: `Failed to initialize harness: ${msg.split("\n")[0]}` }
+        ]);
+        return;
+      }
+      const summary = await getMastraMcpStatusSummary();
+      ctx.setBusy(false);
+      const serverStatus = summary?.statuses.find((s) => s.name === name);
+      const skipped = summary?.skipped.find((s) => s.name === name);
+      if (!serverStatus?.connected || skipped) {
+        const errMsg = serverStatus?.error ?? skipped?.reason ?? "unknown error";
+        const isNotFound = errMsg.includes("ENOENT") || errMsg.includes("not found");
+        const hint = isNotFound ? `
+
+Tip: "${command}" was not found on PATH. Try using npx:
+  /mcp add ${name} npx ${[command, ...cmdArgs].join(" ")}` : "";
+        ctx.toolClient.removeExtraServer(name);
+        await removeMcpServerEntry(workspaceRoot, name).catch(() => {
+        });
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: `Failed to connect MCP server "${name}": ${errMsg.split("\n")[0]}${hint}` }
+        ]);
+        ctx.reinitHarness?.().catch(() => {
+        });
+      } else {
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: `MCP server "${name}" connected (${serverStatus.toolCount} tools).` }
+        ]);
+      }
+      return;
+    }
+    if (sub === "remove") {
+      const name = parts[1];
+      if (!name) {
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: "Usage: /mcp remove <name>" }
+        ]);
+        return;
+      }
+      if (name === "codemap") {
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: "Cannot remove the default codemap server." }
+        ]);
+        return;
+      }
+      const workspaceRoot = await readWorkspacePath();
+      const removed = await removeMcpServerEntry(workspaceRoot, name);
+      if (!removed) {
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: `MCP server "${name}" not found in config.` }
+        ]);
+        return;
+      }
+      ctx.toolClient.removeExtraServer(name);
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: `Removed MCP server "${name}". Reconnecting\u2026` }
+      ]);
+      ctx.setBusy(true);
+      await ctx.reinitHarness?.();
+      ctx.setBusy(false);
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: `Harness reinitialized without "${name}".` }
+      ]);
+      return;
+    }
+    ctx.setMessages((prev) => [
+      ...prev,
+      {
+        role: "system",
+        content: "Unknown subcommand. Usage:\n/mcp \u2014 list servers\n/mcp add <name> <command> [args...]\n/mcp remove <name>"
+      }
+    ]);
+  }
+};
+async function showStatus(ctx) {
+  const summary = await getMastraMcpStatusSummary();
+  const lines = ["MCP Servers:", ""];
+  if (!summary) {
+    lines.push("  Mastra harness is not initialized yet.");
+    lines.push("  Send a chat message first, then run /mcp again.");
+    lines.push("");
+    lines.push("Add external servers: /mcp add <name> <command> [args...]");
+    lines.push("Or configure in .codemap/mcp.json \u2192 mcpServers");
+    ctx.setMessages((prev) => [
+      ...prev,
+      { role: "system", content: lines.join("\n") }
+    ]);
+    return;
+  }
+  const { statuses, skipped } = summary;
+  if (!summary.hasServers) {
+    lines.push("  No MCP servers configured in Mastra.");
+  }
+  for (const s of statuses) {
+    const icon = s.connected ? "\u25CF" : s.connecting ? "\u25D0" : "\u2717";
+    const state = s.connected ? `connected via ${s.transport}` : s.connecting ? `connecting via ${s.transport}` : `error: ${s.error ?? "unknown"}`;
+    const toolCount = s.toolCount > 0 ? ` (${s.toolCount} tools)` : "";
+    const toolNames = s.toolNames.length > 0 ? `
+      ${s.toolNames.slice(0, 8).join(", ")}${s.toolNames.length > 8 ? ", \u2026" : ""}` : "";
+    lines.push(`  ${icon} ${s.name} \u2014 ${state}${toolCount}${toolNames}`);
+  }
+  for (const s of skipped) {
+    lines.push(`  - ${s.name} \u2014 skipped: ${s.reason}`);
+  }
+  if (summary.hasServers && statuses.length === 0 && skipped.length === 0) {
+    lines.push("  Mastra MCP manager has configured servers, but no runtime status yet.");
+    lines.push("  Try sending one chat message or restart the chat if this persists.");
+  }
+  if (statuses.length + skipped.length <= 1) {
+    lines.push("");
+    lines.push("Add external servers: /mcp add <name> <command> [args...]");
+    lines.push("Or configure in .codemap/mcp.json \u2192 mcpServers");
+  }
+  ctx.setMessages((prev) => [
+    ...prev,
+    { role: "system", content: lines.join("\n") }
+  ]);
+}
+
+// src/cli-agent/chat/slash-commands/git-commit.ts
+var COMMIT_MSG_PROMPT = `You are a git commit message generator. Given a diff, write a concise commit message.
+
+Rules:
+- First line: max 72 chars, imperative mood ("Add feature" not "Added feature")
+- No period at end of subject line
+- If needed, blank line then bullet points explaining WHY (not what the diff shows)
+- Output ONLY the commit message, nothing else`;
+var REVIEW_PROMPT = `You are a senior code reviewer. Analyze this git diff for issues.
+
+Focus on:
+- Security: hardcoded secrets, SQL injection, XSS, unsafe eval, missing auth checks
+- Bugs: logic errors, null/undefined risks, race conditions, off-by-one
+- Performance: N+1 queries, unnecessary re-renders, memory leaks
+- Best practices: error handling, type safety, naming
+
+Output format (strict JSON array, nothing else):
+[{"severity":"critical|high|medium|low","category":"security|bugs|performance|style","message":"short description","file":"path","line":42}]
+
+If no issues found, return: []
+
+Diff:`;
+function parseReviewResponse(text) {
+  const jsonMatch = /\[[\s\S]*\]/.exec(text);
+  if (!jsonMatch) return [];
+  try {
+    return JSON.parse(jsonMatch[0]);
+  } catch {
+    return [];
+  }
+}
+function formatReviewResult(issues) {
+  if (issues.length === 0) return "\u2705 Code review passed \u2014 no issues found";
+  const critical = issues.filter((i) => i.severity === "critical");
+  const high = issues.filter((i) => i.severity === "high");
+  const medium = issues.filter((i) => i.severity === "medium");
+  const low = issues.filter((i) => i.severity === "low");
+  const lines = ["\u26A0\uFE0F **Code Review:**\n"];
+  if (critical.length > 0) {
+    lines.push(`\u{1F534} **Critical (${critical.length}):**`);
+    for (const issue of critical) {
+      const loc = issue.file ? ` \`${issue.file}:${issue.line ?? ""}\`` : "";
+      lines.push(`   - ${issue.message}${loc}`);
+    }
+  }
+  if (high.length > 0) {
+    lines.push(`\u{1F7E0} **High (${high.length}):**`);
+    for (const issue of high) {
+      const loc = issue.file ? ` \`${issue.file}:${issue.line ?? ""}\`` : "";
+      lines.push(`   - ${issue.message}${loc}`);
+    }
+  }
+  if (medium.length > 0) {
+    lines.push(`\u{1F7E1} **Medium (${medium.length}):**`);
+    for (const issue of medium.slice(0, 3)) {
+      const loc = issue.file ? ` \`${issue.file}:${issue.line ?? ""}\`` : "";
+      lines.push(`   - ${issue.message}${loc}`);
+    }
+  }
+  if (low.length > 0) {
+    lines.push(`\u26AA **Low (${low.length}):**`);
+    for (const issue of low.slice(0, 3)) {
+      const loc = issue.file ? ` \`${issue.file}:${issue.line ?? ""}\`` : "";
+      lines.push(`   - ${issue.message}${loc}`);
+    }
+  }
+  return lines.join("\n");
+}
+var gitCommitCommand = {
+  name: "commit",
+  description: "AI-generated commit message [--review: run code review first] [--confirm: force commit despite review issues]",
+  execute: async (args, ctx) => {
+    ctx.setBusy(true);
+    ctx.startSubprocess("git commit");
+    const append = (content) => ctx.setMessages((prev) => [...prev, { role: "system", content }]);
+    const shouldReview = args.includes("--review");
+    const forceConfirm = args.includes("--confirm");
+    const cleanArgs = args.replace("--review", "").replace("--confirm", "").trim();
+    let committed = false;
+    try {
+      const manualMsg = cleanArgs;
+      if (manualMsg) {
+        ctx.logSubprocess("Committing with provided message\u2026");
+        const output = await runShell(`git add -A && git commit -m ${JSON.stringify(manualMsg)}`);
+        committed = true;
+        append(output || "Committed.");
+        return;
+      }
+      ctx.logSubprocess("Checking status\u2026");
+      const status = await runShell("git status --short");
+      if (!status.trim()) {
+        append("Nothing to commit \u2014 working tree clean.");
+        return;
+      }
+      ctx.logSubprocess("Reading diff\u2026");
+      const diffOutput = await runShell("git diff HEAD --stat && echo '---' && git diff HEAD -- . ':(exclude)package-lock.json' ':(exclude)*.lock'");
+      const diff = diffOutput.slice(0, 6e3);
+      let reviewIssues = [];
+      if (shouldReview) {
+        ctx.logSubprocess("AI reviewing diff\u2026");
+        let reviewResponse = "";
+        for await (const chunk of ctx.provider.stream({
+          model: ctx.currentModel,
+          messages: [{ role: "user", content: `${REVIEW_PROMPT}
+
+${diff}` }]
+        })) {
+          if (chunk.text) reviewResponse += chunk.text;
+        }
+        reviewIssues = parseReviewResponse(reviewResponse);
+        if (reviewIssues.length > 0) {
+          ctx.logSubprocess(`Found ${reviewIssues.length} issue(s)`);
+          const reviewResult = formatReviewResult(reviewIssues);
+          append(reviewResult);
+          const hasBlockingIssues = reviewIssues.some(
+            (i) => i.severity === "critical" || i.severity === "high"
+          );
+          if (hasBlockingIssues && !forceConfirm) {
+            append(
+              "\n\u274C **Commit blocked** \u2014 critical/high issues found.\nFix issues and run `/commit --review` again, or use `/commit --confirm` to force commit."
+            );
+            return;
+          }
+        } else {
+          ctx.logSubprocess("No issues found");
+        }
+      }
+      ctx.logSubprocess("Generating commit message\u2026");
+      let commitMsg = "";
+      for await (const chunk of ctx.provider.stream({
+        model: ctx.currentModel,
+        messages: [{
+          role: "user",
+          content: `${COMMIT_MSG_PROMPT}
+
+Diff:
+${diff}`
+        }]
+      })) {
+        if (chunk.text) commitMsg += chunk.text;
+      }
+      commitMsg = commitMsg.trim();
+      if (!commitMsg) {
+        append("Failed to generate commit message. Use `/commit <message>` instead.");
+        return;
+      }
+      ctx.logSubprocess(`\u2192 ${commitMsg.split("\n")[0]}`);
+      const commitOutput = await runShell(`git add -A && git commit -m ${JSON.stringify(commitMsg)}`);
+      committed = true;
+      let resultMsg = `\`\`\`
+${commitMsg}
+\`\`\`
+${commitOutput}
+
+_Undo: \`git reset --soft HEAD~1\`_`;
+      if (shouldReview) {
+        if (reviewIssues.length > 0) {
+          resultMsg += forceConfirm ? `
+
+\u26A0\uFE0F Force committed with --confirm (${reviewIssues.length} review issue(s))` : `
+
+\u26A0\uFE0F Committed with ${reviewIssues.length} review issue(s)`;
+        } else {
+          resultMsg += "\n\n\u2705 Code review passed \u2014 no issues found";
+        }
+      }
+      append(resultMsg);
+    } catch (err) {
+      append(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      if (committed) {
+        ctx.logSubprocess("Refreshing local/cloud commit status\u2026");
+        await ctx.refreshWorkspaceCommits?.();
+      }
+      ctx.endSubprocess();
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/git-push.ts
+var gitPushCommand = {
+  name: "push",
+  description: "Push current branch to remote (sets upstream if needed)",
+  execute: async (_args, ctx) => {
+    ctx.setBusy(true);
+    ctx.startSubprocess("git push");
+    const append = (content) => ctx.setMessages((prev) => [...prev, { role: "system", content }]);
+    try {
+      ctx.logSubprocess("Reading branch\u2026");
+      const branchOutput = await runShell("git rev-parse --abbrev-ref HEAD");
+      const branch = branchOutput.trim();
+      if (!branch || branch === "HEAD") {
+        append("Not on a branch \u2014 cannot push.");
+        return;
+      }
+      ctx.logSubprocess(`Pushing \`${branch}\`\u2026`);
+      const pushOutput = await runShell(`git push 2>&1 || git push -u origin ${branch} 2>&1`);
+      const output = pushOutput.trim();
+      if (output) ctx.logSubprocess(output.split("\n").at(-1) ?? output);
+      ctx.logSubprocess("Refreshing local/cloud commit status\u2026");
+      await ctx.refreshWorkspaceCommits?.();
+      append(output || `Pushed \`${branch}\`.`);
+    } catch (err) {
+      append(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      ctx.endSubprocess();
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/git-pr.ts
+var PR_PROMPT = `You are a pull request description writer. Given commits and a diff summary, write a PR title and description.
+
+Output format (exactly):
+TITLE: <title under 70 chars>
+
+## Summary
+- <bullet>
+- <bullet>
+
+## Changes
+- <key file or area changed>
+
+## Test plan
+- <what to verify>
+
+Rules:
+- Output ONLY the title and body in this exact format, nothing else
+- Title: imperative mood, under 70 chars
+- Be concise \u2014 8-12 lines total`;
+var gitPrCommand = {
+  name: "pr",
+  description: "Create a pull request with AI-generated title and description",
+  execute: async (args, ctx) => {
+    ctx.setBusy(true);
+    ctx.startSubprocess("gh pr create");
+    const append = (content) => ctx.setMessages((prev) => [...prev, { role: "system", content }]);
+    try {
+      ctx.logSubprocess("Checking gh CLI\u2026");
+      const ghCheck = await runShell("which gh 2>&1");
+      if (!ghCheck.trim().startsWith("/")) {
+        append("`gh` CLI not found. Install it from https://cli.github.com then run `/pr` again.");
+        return;
+      }
+      ctx.logSubprocess("Reading commits\u2026");
+      const baseOutput = await runShell("git remote show origin 2>/dev/null | grep 'HEAD branch' | awk '{print $NF}' || echo 'main'");
+      const base = baseOutput.trim() || "main";
+      const logOutput = await runShell(`git log ${base}..HEAD --oneline 2>/dev/null | head -30`);
+      if (!logOutput.trim()) {
+        append(`No commits ahead of \`${base}\`. Nothing to PR.`);
+        return;
+      }
+      const diffStat = await runShell(`git diff ${base}..HEAD --stat 2>/dev/null | tail -20`);
+      const context = `Commits:
+${logOutput}
+
+Changed files:
+${diffStat}`;
+      const extra = args.trim() ? `
+Extra context: ${args}` : "";
+      ctx.logSubprocess("Generating PR description\u2026");
+      let raw = "";
+      const vanillaModel = ctx.availableModels?.find((m) => m.startsWith("cc/") || m.startsWith("kr/")) ?? ctx.currentModel;
+      for await (const chunk of ctx.provider.stream({
+        model: vanillaModel,
+        messages: [{
+          role: "user",
+          content: `${PR_PROMPT}
+
+${context}${extra}`
+        }]
+      })) {
+        if (chunk.text) raw += chunk.text;
+      }
+      raw = raw.trim();
+      const titleMatch = raw.match(/^TITLE:\s*(.+)/m);
+      const title = titleMatch?.[1]?.trim() ?? "Update";
+      const body = raw.replace(/^TITLE:.*\n?/m, "").trim();
+      if (!title) {
+        append("Failed to generate PR description.");
+        return;
+      }
+      ctx.logSubprocess(`\u2192 ${title}`);
+      ctx.logSubprocess("Creating PR\u2026");
+      const prOutput = await runShell(`gh pr create --base ${base} --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} 2>&1`);
+      const prUrl = prOutput.match(/https:\/\/github\.com\/\S+/)?.[0] ?? "";
+      if (prUrl) ctx.logSubprocess(prUrl);
+      append(`**PR created**
+
+**${title}**
+
+${body}
+
+---
+${prOutput}`);
+    } catch (err) {
+      append(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      ctx.endSubprocess();
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/conventions.ts
+var conventionsCommand = {
+  name: "conventions",
+  description: "Show synthesized conventions/rules/skills. Use 'refresh' to re-synthesize.",
+  execute: async (args, ctx) => {
+    const append = (content) => ctx.setMessages((prev) => [...prev, { role: "system", content }]);
+    const sub = args.trim().toLowerCase();
+    const model = ctx.currentModel;
+    if (sub === "refresh") {
+      ctx.setBusy(true);
+      append("Re-synthesizing conventions, rules and skills in parallel\u2026");
+      try {
+        const result = await refreshAll(ctx.provider, model);
+        if (!result) {
+          append("No convention/rule/skill files found in workspace.");
+        } else {
+          const parts = [];
+          if (result.conventions) parts.push(`### Conventions
+${result.conventions}`);
+          if (result.rules) parts.push(`### Rules
+${result.rules}`);
+          if (result.skills) parts.push(`### Skills
+${result.skills}`);
+          append(`**Refreshed** (3 synthesis runs in parallel)
+
+${parts.join("\n\n---\n\n")}`);
+        }
+      } catch (err) {
+        append(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      ctx.setBusy(false);
+      return;
+    }
+    ctx.setBusy(true);
+    try {
+      let cached = await getCachedContext();
+      const hasCache = cached.conventions || cached.rules || cached.skills;
+      if (!hasCache) {
+        append("No cache found. Synthesizing now (running 3 streams in parallel)\u2026");
+        const result = await loadOrSynthesizeAll(ctx.provider, model);
+        if (!result) {
+          append("No convention/rule/skill files found in workspace.");
+          ctx.setBusy(false);
+          return;
+        }
+        cached = result;
+      }
+      const parts = [];
+      if (cached.conventions) parts.push(`### Conventions
+${cached.conventions}`);
+      if (cached.rules) parts.push(`### Rules
+${cached.rules}`);
+      if (cached.skills) parts.push(`### Skills & Workflows
+${cached.skills}`);
+      append(`**Project context** (3 synthesized files)
+
+${parts.join("\n\n---\n\n")}
+
+---
+_/conventions refresh \u2014 re-synthesize from source files_`);
+    } catch (err) {
+      append(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    ctx.setBusy(false);
+  }
+};
+
+// src/cli-agent/chat/ui/pi-tui/clipboard.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function copyToClipboard(text) {
+  try {
+    if (process.platform === "darwin") {
+      return spawnSync2("pbcopy", { input: text, encoding: "utf8" }).status === 0;
+    }
+    if (process.platform === "linux") {
+      if (spawnSync2("xclip", ["-selection", "clipboard"], { input: text, encoding: "utf8" }).status === 0) return true;
+      if (spawnSync2("xsel", ["--clipboard", "--input"], { input: text, encoding: "utf8" }).status === 0) return true;
+      if (spawnSync2("wl-copy", [], { input: text, encoding: "utf8" }).status === 0) return true;
+    }
+    if (process.platform === "win32") {
+      return spawnSync2("clip", { input: text, encoding: "utf8" }).status === 0;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/cli-agent/chat/slash-commands/copy-cmd.ts
+var copyCommand = {
+  name: "copy",
+  description: "Copy last assistant response to clipboard",
+  execute: (_args, ctx) => {
+    const msgs = ctx.getMessages?.() ?? [];
+    const last = [...msgs].reverse().find((m) => m.role === "assistant" && m.content?.trim());
+    if (!last) {
+      ctx.appendMessage({ role: "system", content: "Nothing to copy \u2014 no assistant response found." });
+      return;
+    }
+    const ok = copyToClipboard(last.content);
+    ctx.appendMessage({
+      role: "system",
+      content: ok ? `Copied to clipboard (${last.content.length.toLocaleString()} chars).` : "Copy failed \u2014 pbcopy/xclip/xsel not available."
+    });
+  }
+};
+
+// src/cli-agent/chat/slash-commands/login.ts
+var loginCommand = {
+  name: "login",
+  description: "Log in to CodeMap (opens browser for authorization)",
+  execute: async (_args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const config = await loadConfig();
+      if (config.apiToken) {
+        const lines2 = ["Already logged in."];
+        if (config.user?.email) lines2.push(`Account: ${config.user.email}`);
+        if (config.user?.name) lines2.push(`Name:    ${config.user.name}`);
+        lines2.push(`API:     ${config.apiUrl}`);
+        lines2.push(`
+Use /logout first if you want to log in with a different account.`);
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: lines2.join("\n") }
+        ]);
+        return;
+      }
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: "Starting CodeMap login..." }
+      ]);
+      const client = createCodeMapClient(config);
+      const startResponse = await startMcpLogin(client);
+      const openedBrowser = await tryOpenLoginBrowser(startResponse.authorizeUrl);
+      const urlMsg = openedBrowser ? "Browser opened for CodeMap authorization.\nWaiting for you to approve access..." : `Open this URL to log in:
+${startResponse.authorizeUrl}
+
+Waiting for authorization...`;
+      ctx.setMessages((prev) => [...prev, { role: "system", content: urlMsg }]);
+      const result = await waitForLoginAuthorization(config, startResponse);
+      const lines = ["Logged in successfully."];
+      if (result.user?.email) lines.push(`Account: ${result.user.email}`);
+      if (result.user?.name) lines.push(`Name:    ${result.user.name}`);
+      lines.push(`API:     ${result.apiUrl || config.apiUrl}`);
+      ctx.setMessages((prev) => [...prev, { role: "system", content: lines.join("\n") }]);
+      await ctx.reinitHarness?.();
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Login failed: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]);
+    } finally {
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/logout.ts
+var logoutCommand = {
+  name: "logout",
+  description: "Log out of CodeMap and clear stored credentials",
+  execute: async (_args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const config = await loadConfig();
+      if (!config.apiToken) {
+        ctx.setMessages((prev) => [
+          ...prev,
+          { role: "system", content: "Not logged in." }
+        ]);
+        return;
+      }
+      const client = createCodeMapClient(config);
+      await client.request("/settings/api-keys/revoke-current", {
+        method: "POST",
+        authRequired: true
+      }).catch(() => {
+      });
+      await clearGlobalAuthConfig(config);
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: "Logged out. API key revoked and credentials cleared." }
+      ]);
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Logout error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]);
+    } finally {
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/projects.ts
+var VALID_STATUSES = /* @__PURE__ */ new Set(["draft", "importing", "ready", "failed", "archived"]);
+var projectsCommand = {
+  name: "projects",
+  description: "List CodeMap cloud projects. Usage: /projects [--status <status>]",
+  execute: async (args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const toolArgs = {};
+      const statusIdx = parts.indexOf("--status");
+      if (statusIdx >= 0 && parts[statusIdx + 1]) {
+        const status = parts[statusIdx + 1];
+        if (!VALID_STATUSES.has(status)) {
+          ctx.setMessages((prev) => [
+            ...prev,
+            {
+              role: "system",
+              content: `Invalid status "${status}". Valid: draft, importing, ready, failed, archived`
+            }
+          ]);
+          return;
+        }
+        toolArgs.status = status;
+      }
+      const result = await ctx.toolClient.callTool("list_projects", toolArgs);
+      ctx.setMessages((prev) => [...prev, { role: "system", content: result.content }]);
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]);
+    } finally {
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/link.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var linkCommand = {
+  name: "link",
+  description: "Link this workspace to a CodeMap project. Usage: /link [<project-id>] [--confirm] [--update-repo]",
+  execute: async (args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const toolArgs = {};
+      for (const part of parts) {
+        if (UUID_RE.test(part)) toolArgs.project_id = part;
+        else if (part === "--confirm") toolArgs.confirm = true;
+        else if (part === "--update-repo") toolArgs.update_repo = true;
+      }
+      const result = await ctx.toolClient.callTool("link_project", toolArgs);
+      ctx.setMessages((prev) => [...prev, { role: "system", content: result.content }]);
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]);
+    } finally {
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/create.ts
+var createCommand = {
+  name: "create",
+  description: "Create a CodeMap project from this workspace. Usage: /create [--upload] [github <url>] [gitlab <url> [--token <tok>]]",
+  execute: async (args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      let toolName = "create_project";
+      const toolArgs = {};
+      if ((parts[0] === "github" || parts[0] === "gitlab") && parts[1]) {
+        toolArgs.repository_url = parts[1];
+        const tokenIdx = parts.indexOf("--token");
+        if (tokenIdx >= 0 && parts[tokenIdx + 1]) {
+          toolArgs.access_token = parts[tokenIdx + 1];
+        }
+      } else if (parts.includes("--upload")) {
+        toolArgs.upload_confirmed = true;
+      }
+      const result = await ctx.toolClient.callTool(toolName, toolArgs);
+      ctx.setMessages((prev) => [...prev, { role: "system", content: result.content }]);
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]);
+    } finally {
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/import.ts
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var importCommand = {
+  name: "import",
+  description: "Trigger a CodeMap reimport and wait for it to finish. Usage: /import [<project-id>]",
+  execute: async (args, ctx) => {
+    ctx.setBusy(true);
+    try {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const toolArgs = {};
+      const uuid = parts.find((p) => UUID_RE2.test(p));
+      if (uuid) toolArgs.project_id = uuid;
+      ctx.setMessages((prev) => [
+        ...prev,
+        { role: "system", content: "Triggering reimport..." }
+      ]);
+      const MAX_POLLS = 12;
+      let result = await ctx.toolClient.callTool("reimport", {
+        ...toolArgs,
+        action: "trigger_and_wait"
+      });
+      for (let i = 0; i < MAX_POLLS; i++) {
+        if (result.isError) break;
+        const text = result.content ?? "";
+        if (!text.includes("still in progress") && !text.includes("timedOut")) break;
+        result = await ctx.toolClient.callTool("reimport", {
+          ...toolArgs,
+          action: "wait"
+        });
+      }
+      ctx.setMessages((prev) => [...prev, { role: "system", content: result.content }]);
+    } catch (err) {
+      ctx.setMessages((prev) => [
+        ...prev,
+        {
+          role: "system",
+          content: `Error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]);
+    } finally {
+      ctx.setBusy(false);
+    }
+  }
+};
+
+// src/cli-agent/chat/slash-commands/index.ts
+var commands = [
+  helpCommand,
+  statusCommand,
+  loginCommand,
+  logoutCommand,
+  projectsCommand,
+  linkCommand,
+  createCommand,
+  importCommand,
+  modelsCommand,
+  toolsCommand,
+  diffCommand,
+  gitCommitCommand,
+  gitPushCommand,
+  gitPrCommand,
+  sessionsCommand,
+  conventionsCommand,
+  copyCommand,
+  clearCommand,
+  historyCommand,
+  debugCommand,
+  mcpCommand,
+  exitCommand
+];
+function getCommandList() {
+  return commands;
+}
+function executeCommand(text, ctx) {
+  const [cmd] = text.split(/\s+/);
+  const command = commands.find((c) => `/${c.name}` === cmd);
+  if (!command) return false;
+  command.execute(text.slice(cmd.length).trim(), ctx);
+  return true;
+}
+
+// src/cli-agent/core/file-search.ts
+var import_code_index = __toESM(require_dist(), 1);
+import path2 from "path";
+var cachedWorkspaceFiles = null;
+var workspaceFilesPromise = null;
+async function warmupFileSearch() {
+  await searchIndexedFiles("").catch(() => {
+  });
+}
+async function searchIndexedFiles(query) {
+  const normalized = query.trim();
+  debugFileSearch("start", { query: normalized });
+  const localResults = await searchLocalIndex(normalized);
+  debugFileSearch("local results", { count: localResults.length });
+  if (localResults.length > 0) return localResults;
+  const workspaceResults = await searchWorkspaceFiles(normalized);
+  debugFileSearch("workspace results", { count: workspaceResults.length });
+  return workspaceResults;
+}
+var cachedLocalStore = null;
+async function searchLocalIndex(query) {
+  try {
+    if (!cachedLocalStore) {
+      const { store: store2 } = await ensureLocalIndexWithSummary();
+      cachedLocalStore = store2;
+      debugFileSearch("local index opened", { dbPath: store2.dbPath });
+    }
+    const store = cachedLocalStore;
+    const pathMatches = rankFiles(
+      store.listFiles(5e3).filter((file) => isSelectablePath(file.path)),
+      query
+    ).map((file) => ({
+      path: file.path,
+      label: file.path,
+      hint: formatHint(file.language, file.parseStatus, "local index")
+    }));
+    if (!query || pathMatches.length > 0) return pathMatches;
+    const searchMatches = uniqueByPath(
+      store.search(query, null).files.filter((file) => isSelectablePath(file.path)).slice(0, 50).map((file) => ({
+        path: file.path,
+        label: file.path,
+        hint: formatHint(file.language, void 0, "local index")
+      }))
+    );
+    debugFileSearch("local full-text results", { count: searchMatches.length });
+    return searchMatches;
+  } catch (error) {
+    debugFileSearch("local failed", error);
+    cachedLocalStore = null;
+    return [];
+  }
+}
+async function searchWorkspaceFiles(query) {
+  try {
+    if (!cachedWorkspaceFiles) {
+      if (!workspaceFilesPromise) {
+        workspaceFilesPromise = (async () => {
+          const workspacePath = await readWorkspacePath();
+          debugFileSearch("workspace scan", { workspacePath });
+          return (0, import_code_index.collectWorkspaceFiles)(workspacePath);
+        })();
+      }
+      cachedWorkspaceFiles = await workspaceFilesPromise;
+    }
+    return rankFiles(
+      cachedWorkspaceFiles.filter(
+        (file) => file.isText && isSelectablePath(file.path)
+      ),
+      query
+    ).map((file) => ({
+      path: file.path,
+      label: file.path,
+      hint: formatHint(file.language, file.parseStatus, "workspace")
+    }));
+  } catch (error) {
+    debugFileSearch("workspace failed", error);
+    cachedWorkspaceFiles = null;
+    workspaceFilesPromise = null;
+    return [];
+  }
+}
+function rankFiles(files, query) {
+  return files.map((file) => ({
+    file,
+    score: scorePath(file.path, query)
+  })).filter((item) => !query || item.score < Number.MAX_SAFE_INTEGER).sort(
+    (left, right) => left.score - right.score || left.file.path.localeCompare(right.file.path)
+  ).slice(0, 50).map((item) => item.file);
+}
+function uniqueByPath(items) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (seen.has(item.path)) return false;
+    seen.add(item.path);
+    return true;
+  });
+}
+function scorePath(filePath, query) {
+  if (!query) return sourcePreferencePenalty(filePath);
+  const normalizedPath = filePath.toLowerCase();
+  const normalizedName = path2.posix.basename(normalizedPath);
+  const normalizedQuery = query.toLowerCase();
+  const queryTokens = splitTerms(normalizedQuery);
+  const basePenalty = sourcePreferencePenalty(filePath);
+  if (normalizedName === normalizedQuery) return basePenalty;
+  if (stripExtension(normalizedName) === normalizedQuery)
+    return basePenalty + 1;
+  if (normalizedName.includes(normalizedQuery)) return basePenalty + 10;
+  if (normalizedPath.includes(normalizedQuery)) return basePenalty + 20;
+  if (queryTokens.length > 0 && queryTokens.every((term) => normalizedPath.includes(term))) {
+    return basePenalty + 30;
+  }
+  if (isSubsequence(normalizedQuery, normalizedPath)) return basePenalty + 45;
+  return Number.MAX_SAFE_INTEGER;
+}
+function sourcePreferencePenalty(filePath) {
+  const lower = filePath.toLowerCase();
+  let score = 0;
+  if (/\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|php|dart|css|scss|md|json)$/.test(
+    lower
+  )) {
+    score -= 5;
+  }
+  if (lower.includes("/src/") || lower.startsWith("src/")) score -= 4;
+  if (lower.includes("/features/") || lower.includes("/lib/")) score -= 2;
+  if (lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/coverage/"))
+    score += 50;
+  if (lower.includes("/node_modules/") || lower.includes("/.next/"))
+    score += 100;
+  if (lower.includes("/.pnpm-store/")) score += 100;
+  if (lower.startsWith(".") || lower.includes("/.")) score += 20;
+  return score;
+}
+function isSelectablePath(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".ds_store")) return false;
+  if (lower.includes("/node_modules/") || lower.includes("/.git/"))
+    return false;
+  if (lower.includes(".pnpm-store/")) return false;
+  if (lower.includes(".codemap-storage/")) return false;
+  if (lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/coverage/"))
+    return false;
+  return true;
+}
+function splitTerms(query) {
+  return query.split(/[\s\-_/.,:]+/).map((term) => term.trim()).filter((term) => term.length > 0);
+}
+function stripExtension(name) {
+  return name.replace(/\.[^.]+$/, "");
+}
+function isSubsequence(query, value) {
+  let queryIndex = 0;
+  for (const char of value) {
+    if (char === query[queryIndex]) queryIndex += 1;
+    if (queryIndex === query.length) return true;
+  }
+  return false;
+}
+function formatHint(language, parseStatus, source) {
+  return [language, parseStatus, source].filter(Boolean).join(" \xB7 ");
+}
+function debugFileSearch(message, details) {
+  if (process.env.CODEMAP_DEBUG_FILE_SEARCH !== "1") return;
+  const suffix = details === void 0 ? "" : ` ${details instanceof Error ? details.stack ?? details.message : JSON.stringify(details)}`;
+  process.stderr.write(`[codemap:file-search] ${message}${suffix}
+`);
+}
+
+export {
+  loadOrSynthesizeAll,
+  getCachedContext,
+  runShell,
+  loadThreadIntoUI,
+  getCommandList,
+  executeCommand,
+  warmupFileSearch,
+  searchIndexedFiles
+};