docmind-mcp 0.3.0

package/dist/cli.js

@@ -0,0 +1,943 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+function defaultConfig(defaultRoot = "") {
+  return {
+    defaultRoot,
+    sirchmunkUrl: "http://127.0.0.1:8584",
+    researchTimeoutSec: 120,
+    searchTimeoutSec: 30
+  };
+}
+async function loadConfig() {
+  for (const file of [CONFIG_FILE, LEGACY_CONFIG_FILE]) {
+    try {
+      const raw = await readFile(file, "utf-8");
+      const parsed = JSON.parse(raw);
+      return { ...defaultConfig(), ...parsed };
+    } catch {
+      continue;
+    }
+  }
+  return defaultConfig();
+}
+async function saveConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return CONFIG_FILE;
+}
+function resolveRoot(config, rootArg) {
+  const root = rootArg ?? process.env.DOCMIND_ROOT ?? process.env.DIGMUNK_ROOT ?? config.defaultRoot;
+  if (!root) {
+    throw new Error(
+      "No knowledge root configured. Run `docmind init`, or pass a `root` argument / DOCMIND_ROOT env."
+    );
+  }
+  return resolve(root);
+}
+var CONFIG_DIR, CONFIG_FILE, LEGACY_CONFIG_FILE;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    CONFIG_DIR = join(homedir(), ".docmind");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+    LEGACY_CONFIG_FILE = join(homedir(), ".digmunk", "config.json");
+  }
+});
+
+// src/installer.ts
+var installer_exports = {};
+__export(installer_exports, {
+  runInstall: () => runInstall
+});
+import { readFile as readFile2, writeFile as writeFile2, copyFile as copyFile2, access } from "node:fs/promises";
+import { execFile as execFile2 } from "node:child_process";
+import { homedir as homedir4 } from "node:os";
+import { join as join4, dirname } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+function mcpServerEntry(root) {
+  return { command: ["docmind-mcp"], env: { DOCMIND_ROOT: root } };
+}
+async function which(cmd) {
+  return new Promise((resolve3) => {
+    execFile2("which", [cmd], (err) => resolve3(!err));
+  });
+}
+async function installOpencode(root) {
+  const candidates = [
+    join4(homedir4(), ".config", "opencode", "opencode.json"),
+    join4(homedir4(), ".config", "opencode", "opencode.jsonc")
+  ];
+  const configPath = candidates.find((p) => existsSync3(p));
+  if (!configPath) {
+    return {
+      target: "opencode",
+      ok: false,
+      detail: "global config not found",
+      manualHint: `Add to ~/.config/opencode/opencode.json:
+${JSON.stringify({ mcp: { docmind: { type: "local", ...mcpServerEntry(root) } } }, null, 2)}`
+    };
+  }
+  const raw = await readFile2(configPath, "utf-8");
+  const jsonText = configPath.endsWith(".jsonc") ? raw.replace(/\/\/.*$/gm, "") : raw;
+  const config = JSON.parse(jsonText);
+  config.mcp = config.mcp ?? {};
+  config.mcp.docmind = { type: "local", ...mcpServerEntry(root) };
+  await copyFile2(configPath, `${configPath}.bak`);
+  await writeFile2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return { target: "opencode", ok: true, detail: `registered in ${configPath} (backup: .bak)` };
+}
+async function installClaudeCode(root) {
+  if (await which("claude")) {
+    const result = await new Promise((resolve3) => {
+      execFile2(
+        "claude",
+        ["mcp", "add", "--scope", "user", "docmind", "--", "docmind-mcp"],
+        { env: { ...process.env, DOCMIND_ROOT: root }, timeout: 3e4 },
+        (err, stdout2, stderr) => {
+          if (err) resolve3({ ok: false, detail: `claude mcp add failed: ${(stderr || err.message).slice(0, 200)}` });
+          else resolve3({ ok: true, detail: `claude mcp add succeeded: ${(stdout2 || "done").trim().slice(0, 120)}` });
+        }
+      );
+    });
+    if (result.ok) return { target: "claude-code", ...result };
+  }
+  return {
+    target: "claude-code",
+    ok: false,
+    detail: "claude CLI unavailable",
+    manualHint: `Add to ~/.claude.json mcpServers:
+  "docmind": {"command": "docmind-mcp", "env": {"DOCMIND_ROOT": "${root}"}}`
+  };
+}
+async function installCodex(root) {
+  const configPath = join4(homedir4(), ".codex", "config.toml");
+  const section = `
+[mcp_servers.docmind]
+command = "docmind-mcp"
+env = { "DOCMIND_ROOT" = "${root}" }
+`;
+  if (existsSync3(configPath)) {
+    const raw = await readFile2(configPath, "utf-8");
+    if (raw.includes("[mcp_servers.docmind]")) {
+      return { target: "codex", ok: true, detail: "already registered in ~/.codex/config.toml" };
+    }
+    await copyFile2(configPath, `${configPath}.bak`);
+    await writeFile2(configPath, raw.replace(/\n*$/, "\n") + section, "utf-8");
+    return { target: "codex", ok: true, detail: `registered in ${configPath} (backup: .bak)` };
+  }
+  await import("node:fs/promises").then((m) => m.mkdir(dirname(configPath), { recursive: true }));
+  await writeFile2(configPath, section.trimStart(), "utf-8");
+  return { target: "codex", ok: true, detail: `created ${configPath}` };
+}
+function genericInstructions(root) {
+  const entry = mcpServerEntry(root);
+  return {
+    target: "generic",
+    ok: true,
+    detail: `Register this MCP stdio server in your agent config:
+${JSON.stringify({ docmind: entry }, null, 2)}`
+  };
+}
+async function runInstall(target, rootOverride) {
+  const config = await loadConfig();
+  const root = rootOverride ?? config.defaultRoot;
+  if (!root) {
+    return [{ target: target ?? "all", ok: false, detail: "no knowledge root configured \u2014 run `docmind init` first" }];
+  }
+  const targets = target ? [target] : ["opencode", "claude-code", "codex"];
+  const results = [];
+  for (const t of targets) {
+    switch (t) {
+      case "opencode":
+        results.push(await installOpencode(root));
+        break;
+      case "claude-code":
+        results.push(await installClaudeCode(root));
+        break;
+      case "codex":
+        results.push(await installCodex(root));
+        break;
+      case "generic":
+      case "manual":
+        results.push(genericInstructions(root));
+        break;
+      default:
+        results.push({
+          target: t,
+          ok: false,
+          detail: `unknown target "${t}" (supported: opencode, claude-code, codex, generic)`
+        });
+    }
+  }
+  return results;
+}
+var init_installer = __esm({
+  "src/installer.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/lock.ts
+function serialized(fn) {
+  const next = chain.then(fn, fn);
+  chain = next.catch(() => void 0);
+  return next;
+}
+var chain;
+var init_lock = __esm({
+  "src/lock.ts"() {
+    "use strict";
+    chain = Promise.resolve();
+  }
+});
+
+// src/zg.ts
+var zg_exports = {};
+__export(zg_exports, {
+  parseZgOutput: () => parseZgOutput,
+  readHitFile: () => readHitFile,
+  zgIndex: () => zgIndex,
+  zgRg: () => zgRg,
+  zgSearch: () => zgSearch,
+  zgStatus: () => zgStatus
+});
+import { spawn as spawn2 } from "node:child_process";
+import { readFile as readFile3 } from "node:fs/promises";
+function runZg(root, args, timeoutSec) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn2("zg", [...args, "--no-color"], {
+      cwd: root,
+      env: { ...process.env, NO_COLOR: "1" }
+    });
+    let stdout2 = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`zg timed out after ${timeoutSec}s`));
+    }, timeoutSec * 1e3);
+    child.stdout.on("data", (d) => stdout2 += d);
+    child.stderr.on("data", (d) => stderr += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(new Error(`zg spawn failed: ${e.message}. Is zvec-grep installed?`));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve3({ code: code ?? 1, stdout: stdout2, stderr });
+    });
+  });
+}
+function parseZgOutput(output, query) {
+  const hits = [];
+  const groups = [];
+  let current = null;
+  for (const rawLine of output.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    const group = line.match(/^Q\d+\s+\[(\w+)\]:\s(.*)$/);
+    if (group) {
+      groups.push(group[2]);
+      continue;
+    }
+    const total = line.match(/^hits:\s(\d+)$/);
+    if (total) continue;
+    if (line.startsWith("query groups") || line.trim() === "") continue;
+    const header = line.match(HIT_HEADER);
+    if (header) {
+      current = {
+        rank: Number(header[1]),
+        matchedBy: header[2],
+        file: header[3],
+        lineStart: Number(header[4]),
+        lineEnd: Number(header[5]),
+        snippets: []
+      };
+      hits.push(current);
+      continue;
+    }
+    if (!current) continue;
+    const meta = line.match(META_LINE);
+    if (meta) {
+      if (meta[1] === "heading") current.heading = meta[2];
+      if (meta[1] === "scope") current.scope = meta[2];
+      continue;
+    }
+    const content = line.match(CONTENT_LINE);
+    if (content) {
+      current.snippets.push({ line: Number(content[1]), text: content[2] });
+    }
+  }
+  hits.sort((a, b) => a.rank - b.rank);
+  return { query, groups, hits, raw: output };
+}
+async function zgSearch(root, query, opts = {}) {
+  return serialized(async () => {
+    const { limit, timeoutSec = 30 } = opts;
+    const args = ["query", query];
+    if (limit) args.push("--limit", String(limit));
+    const { code, stdout: stdout2, stderr } = await runZg(root, args, timeoutSec);
+    if (code !== 0 && !stdout2.trim()) {
+      throw new Error(`zg query failed (exit ${code}): ${stderr.trim() || "no output"}`);
+    }
+    return parseZgOutput(stdout2, query);
+  });
+}
+async function zgRg(root, pattern, opts = {}) {
+  return serialized(async () => {
+    const { timeoutSec = 30 } = opts;
+    const { code, stdout: stdout2, stderr } = await runZg(
+      root,
+      ["query", "--rg", "-F", "--", pattern, "."],
+      timeoutSec
+    );
+    if (code !== 0 && !stdout2.trim()) {
+      throw new Error(`zg rg failed (exit ${code}): ${stderr.trim() || "no output"}`);
+    }
+    return stdout2;
+  });
+}
+async function zgIndex(root, timeoutSec = 120) {
+  return serialized(async () => {
+    const { code, stdout: stdout2, stderr } = await runZg(root, ["index", "--hidden"], timeoutSec);
+    if (code !== 0) throw new Error(`zg index failed (exit ${code}): ${stderr.trim()}`);
+    return stdout2.trim();
+  });
+}
+async function zgStatus(root) {
+  const { stdout: stdout2, stderr } = await runZg(root, ["status", "--check-ready"], 15).catch((e) => ({
+    code: 1,
+    stdout: "",
+    stderr: String(e.message)
+  }));
+  return { ready: /is ready/.test(stdout2), detail: (stdout2 + stderr).trim() };
+}
+async function readHitFile(root, hit) {
+  return readFile3(`${root}/${hit.file}`, "utf-8");
+}
+var HIT_HEADER, META_LINE, CONTENT_LINE;
+var init_zg = __esm({
+  "src/zg.ts"() {
+    "use strict";
+    init_lock();
+    HIT_HEADER = /^#(\d+)\s+matchedBy=(\S+)\s+(.+?):(\d+)-(\d+)\s*$/;
+    META_LINE = /^(heading|heading_level|scope):\s(.*)$/;
+    CONTENT_LINE = /^(\d+)\t(.*)$/;
+  }
+});
+
+// src/wizard.ts
+init_config();
+import { mkdir as mkdir2 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+import { stdin, stdout } from "node:process";
+
+// src/daemon.ts
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var PID_FILE = join2(homedir2(), ".docmind", "sirchmunk.pid");
+async function fetchStatus(url, timeoutMs = 4e3) {
+  try {
+    const res = await fetch(`${url}/api/v1/search/status`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return { reachable: false, body: null };
+    return { reachable: true, body: await res.json() };
+  } catch {
+    return { reachable: false, body: null };
+  }
+}
+function readManagedPid() {
+  try {
+    const pid = Number(readFileSync(PID_FILE, "utf-8").trim());
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return null;
+  }
+}
+async function serveState(url) {
+  const { reachable, body } = await fetchStatus(url);
+  const data = body?.data ?? {};
+  return {
+    reachable,
+    llmConfigured: Boolean(data.llm_configured),
+    model: data.llm_model ?? null,
+    status: data.status ?? (reachable ? "unknown" : "unreachable"),
+    pid: readManagedPid() ?? void 0,
+    managed: readManagedPid() !== null
+  };
+}
+async function serveUp(url, waitTimeoutSec = 120) {
+  const existing = await serveState(url);
+  if (existing.reachable) return { started: false, state: existing };
+  const dir = join2(homedir2(), ".docmind");
+  writeFileSync(PID_FILE, "", "utf-8");
+  const logFile = join2(dir, "sirchmunk-serve.log");
+  const out = existsSync(logFile) ? "a" : "w";
+  const { openSync } = await import("node:fs");
+  const logFd = openSync(logFile, out);
+  const child = spawn("sirchmunk", ["serve"], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.unref();
+  writeFileSync(PID_FILE, String(child.pid), "utf-8");
+  const deadline = Date.now() + waitTimeoutSec * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    const state = await serveState(url);
+    if (state.reachable) return { started: true, state };
+  }
+  return { started: true, state: await serveState(url) };
+}
+async function serveDown(url) {
+  const pid = readManagedPid();
+  if (pid === null) {
+    const state = await serveState(url);
+    return {
+      stopped: false,
+      detail: state.reachable ? `sirchmunk serve is running but was not started by docmind (kill its process manually: pid unknown).` : "sirchmunk serve is not running."
+    };
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    await new Promise((r) => setTimeout(r, 1500));
+    try {
+      process.kill(pid, 0);
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  } catch (e) {
+    return { stopped: false, detail: `failed to stop pid ${pid}: ${e.message}` };
+  }
+  try {
+    unlinkSync(PID_FILE);
+  } catch {
+  }
+  return { stopped: true, detail: `stopped sirchmunk serve (pid ${pid}).` };
+}
+
+// src/deps.ts
+import { execFile } from "node:child_process";
+import { createWriteStream, existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { chmod as chmodAsync, copyFile, mkdir as mkdirAsync } from "node:fs/promises";
+import { homedir as homedir3, platform, arch } from "node:os";
+import { join as join3 } from "node:path";
+import { pipeline } from "node:stream/promises";
+function run(cmd, args, timeoutMs = 12e4) {
+  return new Promise((resolve3, reject) => {
+    execFile(cmd, args, { timeout: timeoutMs, encoding: "utf-8" }, (err, stdout2, stderr) => {
+      if (err && typeof err.code !== "number") return reject(err);
+      resolve3({ code: err?.code ?? 0, stdout: stdout2, stderr });
+    });
+  });
+}
+async function checkZg() {
+  try {
+    const { stdout: stdout2 } = await run("zg", ["--version"]);
+    return { name: "zvec-grep (zg)", ok: true, detail: stdout2.trim() };
+  } catch {
+    return {
+      name: "zvec-grep (zg)",
+      ok: false,
+      detail: "not found",
+      fixHint: "npm install -g @zvec/zvec-grep"
+    };
+  }
+}
+async function checkRipgrep() {
+  try {
+    const { stdout: stdout2 } = await run("rg", ["--version"]);
+    return { name: "ripgrep (rg)", ok: true, detail: stdout2.split("\n")[0].trim() };
+  } catch {
+    return { name: "ripgrep (rg)", ok: false, detail: "not found", fixHint: "apt install ripgrep / brew install ripgrep" };
+  }
+}
+async function checkRga() {
+  try {
+    const { stdout: stdout2 } = await run("rga", ["--version"]);
+    return { name: "ripgrep-all (rga)", ok: true, detail: stdout2.split("\n")[0].trim() };
+  } catch {
+    return {
+      name: "ripgrep-all (rga)",
+      ok: false,
+      detail: "not found (sirchmunk auto-install hits GitHub rate limits)",
+      fixHint: "docmind init will install it from a pinned release URL"
+    };
+  }
+}
+async function checkSirchmunk() {
+  try {
+    const { stdout: stdout2 } = await run("sirchmunk", ["version"]);
+    return { name: "sirchmunk", ok: true, detail: stdout2.trim() };
+  } catch {
+    return {
+      name: "sirchmunk",
+      ok: false,
+      detail: "not found",
+      fixHint: "pip install torch (CPU) first, then pip install 'sirchmunk[mcp]'"
+    };
+  }
+}
+async function checkTorch() {
+  try {
+    const { stdout: stdout2 } = await run("python3", ["-c", "import torch; print(torch.__version__)"]);
+    const v = stdout2.trim();
+    return { name: "pytorch", ok: true, detail: v.includes("cpu") ? `${v} (CPU)` : v };
+  } catch {
+    return { name: "pytorch", ok: false, detail: "not installed", fixHint: "pip install torch --index-url https://download.pytorch.org/whl/cpu" };
+  }
+}
+async function checkSirchmunkEnv() {
+  const envFile = join3(homedir3(), ".sirchmunk", ".env");
+  if (!existsSync2(envFile)) {
+    return { name: "sirchmunk LLM config", ok: false, detail: "~/.sirchmunk/.env missing", fixHint: "docmind init will create it" };
+  }
+  const content = await import("node:fs/promises").then((m) => m.readFile(envFile, "utf-8"));
+  const hasKey = /LLM_API_KEY\s*=\s*\S+/.test(content);
+  const model = content.match(/LLM_MODEL_NAME\s*=\s*(\S+)/)?.[1];
+  const baseUrl = content.match(/LLM_BASE_URL\s*=\s*(\S+)/)?.[1];
+  if (baseUrl && !/^https?:\/\/.+/.test(baseUrl)) {
+    return {
+      name: "sirchmunk LLM config",
+      ok: false,
+      detail: `LLM_BASE_URL is invalid ("${baseUrl}") \u2014 research will fail with connection errors`,
+      fixHint: `edit ~/.sirchmunk/.env, set LLM_BASE_URL=https://<provider>/v1, then re-run \`docmind up\``
+    };
+  }
+  return {
+    name: "sirchmunk LLM config",
+    ok: hasKey,
+    detail: hasKey ? `key present${model ? `, model: ${model}` : ""}` : "LLM_API_KEY not set in ~/.sirchmunk/.env"
+  };
+}
+async function installZg() {
+  const { code, stderr } = await run("npm", ["install", "-g", "@zvec/zvec-grep"], 6e5);
+  if (code !== 0) throw new Error(`npm install -g @zvec/zvec-grep failed: ${stderr.slice(0, 300)}`);
+}
+async function installTorchCpu() {
+  const { code, stderr } = await run(
+    "pip",
+    ["install", "--break-system-packages", "torch", "--index-url", "https://download.pytorch.org/whl/cpu"],
+    18e5
+  );
+  if (code !== 0) throw new Error(`CPU torch install failed: ${stderr.slice(0, 300)}`);
+}
+async function installSirchmunk() {
+  const { code, stderr } = await run("pip", ["install", "--break-system-packages", "sirchmunk[mcp]"], 12e5);
+  if (code !== 0) throw new Error(`pip install sirchmunk[mcp] failed: ${stderr.slice(0, 300)}`);
+}
+var RGA_VERSION = "v1.0.0-alpha.5";
+var RGA_ASSET = `ripgrep_all-${RGA_VERSION}-x86_64-unknown-linux-musl.tar.gz`;
+var RGA_URL = `https://github.com/phiresky/ripgrep-all/releases/download/${RGA_VERSION}/${RGA_ASSET}`;
+async function installRga() {
+  if (platform() !== "linux" || arch() !== "x64") {
+    throw new Error(`Automatic rga install supports linux/x64 only. On this platform, install ripgrep-all manually.`);
+  }
+  const tmpDir = "/tmp/opencode/docmind-rga";
+  const tarball = join3(tmpDir, RGA_ASSET);
+  await mkdirAsync(tmpDir, { recursive: true });
+  const res = await fetch(RGA_URL, { redirect: "follow" });
+  if (!res.ok || !res.body) {
+    throw new Error(`rga download failed (HTTP ${res.status}) from ${RGA_URL}`);
+  }
+  await pipeline(res.body, createWriteStream(tarball));
+  const extractDir = join3(tmpDir, "out");
+  await mkdirAsync(extractDir, { recursive: true });
+  await new Promise((resolve3, reject) => {
+    execFile("tar", ["xzf", tarball, "-C", extractDir], (err) => err ? reject(err) : resolve3());
+  });
+  const binDir = "/usr/local/bin";
+  for (const bin of ["rga", "rga-preproc"]) {
+    const src = join3(extractDir, `ripgrep_all-${RGA_VERSION}-x86_64-unknown-linux-musl`, bin);
+    const dest = join3(binDir, bin);
+    await copyFile(src, dest);
+    await chmodAsync(dest, 493);
+  }
+}
+function writeSirchmunkEnv(llm) {
+  if (!/^https?:\/\/.+/.test(llm.baseUrl)) {
+    throw new Error(`Invalid LLM base URL "${llm.baseUrl}" \u2014 expected an http(s) URL like https://api.example.com/v1`);
+  }
+  const dir = join3(homedir3(), ".sirchmunk");
+  mkdirSync(dir, { recursive: true });
+  const envFile = join3(dir, ".env");
+  const content = [
+    "# Written by `docmind init`",
+    `LLM_API_KEY=${llm.key}`,
+    `LLM_BASE_URL=${llm.baseUrl}`,
+    `LLM_MODEL_NAME=${llm.model}`,
+    ""
+  ].join("\n");
+  writeFileSync2(envFile, content, "utf-8");
+  return envFile;
+}
+
+// src/wizard.ts
+var LineReader = class {
+  buf = "";
+  lines = [];
+  eof = false;
+  waiter = null;
+  constructor() {
+    stdin.setEncoding("utf-8");
+    stdin.on("data", (chunk) => {
+      this.buf += chunk;
+      let idx;
+      while ((idx = this.buf.indexOf("\n")) >= 0) {
+        const line = this.buf.slice(0, idx).replace(/\r$/, "");
+        this.buf = this.buf.slice(idx + 1);
+        if (this.waiter) {
+          const w = this.waiter;
+          this.waiter = null;
+          w(line);
+        } else {
+          this.lines.push(line);
+        }
+      }
+    });
+    stdin.on("end", () => {
+      this.eof = true;
+      if (this.waiter) {
+        const w = this.waiter;
+        this.waiter = null;
+        w(null);
+      }
+    });
+    stdin.on("error", () => {
+      this.eof = true;
+    });
+  }
+  next(fallback) {
+    if (this.lines.length > 0) return Promise.resolve(this.lines.shift());
+    if (this.eof) return Promise.resolve(fallback);
+    return new Promise((resolve3) => {
+      this.waiter = (line) => resolve3(line ?? fallback);
+    });
+  }
+};
+function parseLlmText(text) {
+  const out = {};
+  const keyMatch = text.match(/(?:api[_-]?key|key)\s*[=:：]\s*([A-Za-z0-9_\-]{16,})/i) ?? text.match(/\b(sk-[A-Za-z0-9_\-]{16,})\b/);
+  if (keyMatch) out.key = keyMatch[1];
+  const urlMatch = text.match(/https?:\/\/[^\s,，;；'"()（）]+/i);
+  if (urlMatch) {
+    out.baseUrl = urlMatch[0].replace(/[.。,，]+$/, "");
+    if (!/\/v\d+$/.test(out.baseUrl)) out.baseUrl = `${out.baseUrl.replace(/\/+$/, "")}/v1`;
+  }
+  const modelMatch = text.match(/model(?:\s*name)?(?:\s*\([^)]*\))?\s*[=:：]\s*([\w.\-/]+)/i) ?? text.match(/(?:模型名(?:称)?|模型)\s*[=:：（(]\s*([\w.\-/]+)/);
+  if (modelMatch) out.model = modelMatch[1];
+  return out;
+}
+async function ask(reader, question, fallback) {
+  const suffix = fallback ? ` [${fallback}]` : "";
+  stdout.write(`${question}${suffix}: `);
+  const answer = (await reader.next(fallback ?? "")).trim();
+  return answer || fallback || "";
+}
+async function confirm(reader, question, defaultYes = true) {
+  stdout.write(`${question} ${defaultYes ? "[Y/n]" : "[y/N]"}: `);
+  const answer = (await reader.next(defaultYes ? "y" : "n")).trim().toLowerCase();
+  if (!answer) return defaultYes;
+  return answer === "y" || answer === "yes";
+}
+async function step(name, fn) {
+  stdout.write(`  installing ${name} ... `);
+  try {
+    await fn();
+    stdout.write("done\n");
+  } catch (e) {
+    stdout.write("FAILED\n");
+    throw new Error(`${name}: ${e.message}`);
+  }
+}
+async function runInit() {
+  const reader = new LineReader();
+  try {
+    console.log("docmind init \u2014 set up your local Deep Research knowledge base\n");
+    console.log("Step 1/4  Checking dependencies...");
+    const checks = await Promise.all([checkZg(), checkRipgrep(), checkRga(), checkTorch(), checkSirchmunk()]);
+    const missing = [];
+    for (const c of checks) {
+      console.log(`  ${c.ok ? "ok " : "MISS"}  ${c.name}: ${c.detail}`);
+      if (!c.ok) missing.push(c);
+    }
+    if (missing.length > 0) {
+      const proceed = await confirm(reader, `Install ${missing.length} missing component(s) now?`, true);
+      if (!proceed) {
+        console.log("\nInstall manually later, then re-run `docmind init`:");
+        for (const c of missing) console.log(`  - ${c.name}: ${c.fixHint}`);
+        return;
+      }
+      const wantRg = checks.find((c) => c.name.includes("ripgrep (rg)"));
+      if (!wantRg.ok) {
+        console.log("\nripgrep is missing. Install it with your system package manager first:");
+        console.log("  apt install ripgrep   /   brew install ripgrep\n");
+        return;
+      }
+      if (checks.find((c) => c.name === "zvec-grep (zg)")?.ok === false) {
+        await step("zvec-grep (npm, ~1 min)", installZg);
+      }
+      if (checks.find((c) => c.name === "pytorch")?.ok === false) {
+        await step("pytorch CPU (~200MB download)", installTorchCpu);
+      }
+      if (checks.find((c) => c.name === "ripgrep-all (rga)")?.ok === false) {
+        await step("ripgrep-all (pinned release, ~6MB)", installRga);
+      }
+      if (checks.find((c) => c.name === "sirchmunk")?.ok === false) {
+        await step("sirchmunk[mcp] (pip)", installSirchmunk);
+      }
+    }
+    console.log("");
+    console.log("Step 2/4  Knowledge base folder");
+    const suggestedRoot = join5(homedir5(), "docmind-docs");
+    const rootInput = await ask(reader, "Folder to use as your knowledge base", suggestedRoot);
+    const root = resolve2(rootInput);
+    await mkdir2(root, { recursive: true });
+    console.log(`  knowledge base: ${root}`);
+    console.log("\nStep 3/4  LLM for research mode");
+    console.log("  Paste your key/url/model in any format, e.g.:");
+    console.log('    "key=sk-xxx Base url=https://api.example.com/v1 Model name=your-model"');
+    const llmText = await ask(reader, "LLM credentials (or press Enter to skip research mode)");
+    const parsed = parseLlmText(llmText);
+    let llm = null;
+    if (parsed.key) {
+      const key = parsed.key;
+      const baseUrl = await ask(reader, "LLM base URL", parsed.baseUrl ?? "https://api.openai.com/v1");
+      const model = await ask(reader, "LLM model name", parsed.model ?? "gpt-4o-mini");
+      llm = { key, baseUrl, model };
+      const envFile = writeSirchmunkEnv(llm);
+      console.log(`  written: ${envFile} (model: ${model})`);
+    } else {
+      console.log("  skipped \u2014 research mode will degrade to fast search until configured.");
+      console.log("  Run `docmind init` again anytime to add it.");
+    }
+    console.log("\nStep 4/4  Starting the research engine");
+    const { started, state } = await serveUp("http://127.0.0.1:8584");
+    console.log(`  ${started ? "started" : "already running"} sirchmunk serve \u2014 status: ${state.status}, llm: ${state.llmConfigured ? state.model : "not configured"}`);
+    if (!state.reachable) {
+      console.log("  note: sirchmunk may still be loading models in the background. Check `docmind doctor` in a minute.");
+    }
+    await saveConfig({ ...defaultConfig(root), sirchmunkUrl: "http://127.0.0.1:8584" });
+    console.log(`  config written: ~/.docmind/config.json`);
+    console.log("\nNext: connect your agent \u2014");
+    console.log("  docmind install                 (auto-detect installed agents)");
+    console.log("  docmind install --target opencode / claude-code / codex");
+    console.log("  docmind doctor                  (verify everything)");
+    const doInstall = await confirm(reader, "\nRun agent integration now?", true);
+    if (doInstall) {
+      const target = await ask(reader, "Agent (opencode / claude-code / codex / generic)", "auto");
+      const { runInstall: runInstall2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+      await runInstall2(target === "auto" ? void 0 : target, root);
+    }
+  } finally {
+  }
+}
+async function ensureIndexed(root) {
+  if (!existsSync4(join5(root, ".zvec-grep"))) {
+    console.log(`Building initial index for ${root} ...`);
+    const { execFile: execFile3 } = await import("node:child_process");
+    await new Promise((res, rej) => {
+      execFile3("zg", ["index", "--hidden"], { cwd: root, timeout: 6e5 }, (err) => err ? rej(err) : res());
+    });
+    console.log("Index ready.");
+  }
+}
+
+// src/doctor.ts
+init_config();
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+async function zgIndexStatus(root) {
+  if (!existsSync5(join6(root, ".zvec-grep"))) {
+    return { name: "knowledge index", ok: false, detail: `no index in ${root} (built on first write/search attempt)` };
+  }
+  return { name: "knowledge index", ok: true, detail: `indexed (${join6(root, ".zvec-grep")})` };
+}
+async function rootCheck() {
+  const config = await loadConfig();
+  const root = process.env.DOCMIND_ROOT ?? config.defaultRoot;
+  if (!root) {
+    return {
+      check: { name: "knowledge root", ok: false, detail: "not configured (run `docmind init`)" },
+      root: null
+    };
+  }
+  const exists = existsSync5(root);
+  return {
+    check: { name: "knowledge root", ok: exists, detail: exists ? root : `${root} (missing)` },
+    root
+  };
+}
+async function runDoctor() {
+  const lines = [];
+  let allOk = true;
+  const { check: rootCheckResult, root } = await rootCheck();
+  const checks = [
+    rootCheckResult,
+    await checkZg(),
+    await checkRipgrep(),
+    await checkRga(),
+    await checkTorch().then((c) => ({ ...c, name: "pytorch (optional, speeds first research)" })),
+    await checkSirchmunk(),
+    await checkSirchmunkEnv()
+  ];
+  if (root) checks.push(await zgIndexStatus(root));
+  const config = await loadConfig();
+  const state = await serveState(config.sirchmunkUrl);
+  checks.push({
+    name: "sirchmunk serve",
+    ok: state.reachable,
+    detail: state.reachable ? `status: ${state.status}, llm: ${state.llmConfigured ? state.model : "NOT configured"}, url: ${config.sirchmunkUrl}${state.managed ? `, managed pid ${state.pid}` : " (external process)"}` : `unreachable at ${config.sirchmunkUrl} \u2014 run \`docmind up\``
+  });
+  if (state.reachable && !state.llmConfigured) {
+    checks.push({
+      name: "research mode",
+      ok: false,
+      detail: "no LLM key \u2014 research will degrade to fast search. Re-run `docmind init`."
+    });
+  }
+  for (const c of checks) {
+    if (!c.ok) allOk = false;
+    lines.push(`${c.ok ? "[ok]" : "[!!]"} ${c.name}: ${c.detail}`);
+    if (!c.ok && c.fixHint) lines.push(`     fix: ${c.fixHint}`);
+  }
+  lines.push("");
+  lines.push(
+    allOk ? "All systems operational. Your agent can use docmind's search / research / remember tools." : "Some components need attention (see [!!] items above)."
+  );
+  return { ok: allOk, lines };
+}
+
+// src/cli.ts
+init_installer();
+init_config();
+init_zg();
+var HELP = `docmind \u2014 local Deep Research knowledge base for coding agents
+
+Usage:
+  docmind init                       Interactive setup: deps, LLM key, service, agent config
+  docmind up                         Start the sirchmunk research engine in the background
+  docmind down                       Stop the docmind-managed sirchmunk serve
+  docmind status                     Show whether the research engine is reachable
+  docmind doctor                     Full health check of the whole chain
+  docmind install [--target T]       Register the MCP server in an agent
+                                     targets: opencode, claude-code, codex, generic
+  docmind search <query> [--root D]  Quick terminal search (free, no LLM)
+  docmind index [--root D]           (Re)build the search index for a knowledge folder
+  docmind-mcp                        MCP stdio server (this is what agents run)
+
+Config lives in ~/.docmind/config.json; LLM key in ~/.sirchmunk/.env.
+`;
+function rootFlag(args) {
+  const i = args.indexOf("--root");
+  return i >= 0 ? args[i + 1] : void 0;
+}
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+  switch (cmd) {
+    case "init":
+      await runInit();
+      break;
+    case "up": {
+      const config = await loadConfig();
+      const { started, state } = await serveUp(config.sirchmunkUrl);
+      console.log(
+        started ? `sirchmunk serve started (pid ${state.pid}). status: ${state.status}, llm: ${state.llmConfigured ? state.model : "not configured"}` : `already running \u2014 status: ${state.status}, llm: ${state.llmConfigured ? state.model : "not configured"}`
+      );
+      break;
+    }
+    case "down": {
+      const config = await loadConfig();
+      const { stopped, detail } = await serveDown(config.sirchmunkUrl);
+      console.log(stopped ? detail : `note: ${detail}`);
+      break;
+    }
+    case "status": {
+      const config = await loadConfig();
+      const state = await serveState(config.sirchmunkUrl);
+      console.log(
+        state.reachable ? `sirchmunk: ${state.status} | llm: ${state.llmConfigured ? state.model : "not configured"} | ${config.sirchmunkUrl}${state.managed ? ` | managed pid ${state.pid}` : ""}` : `sirchmunk unreachable at ${config.sirchmunkUrl} \u2014 run \`docmind up\``
+      );
+      break;
+    }
+    case "doctor": {
+      const report = await runDoctor();
+      console.log(report.lines.join("\n"));
+      process.exitCode = report.ok ? 0 : 1;
+      break;
+    }
+    case "install": {
+      const targetIdx = args.indexOf("--target");
+      const target = targetIdx >= 0 ? args[targetIdx + 1] : void 0;
+      const results = await runInstall(target);
+      for (const r of results) {
+        console.log(`[${r.ok ? "ok" : "!!"}] ${r.target}: ${r.detail}`);
+        if (r.manualHint) console.log(`    manual setup:
+${r.manualHint}`);
+      }
+      break;
+    }
+    case "search": {
+      const query = args.find((a) => !a.startsWith("--"));
+      if (!query) {
+        console.error("Usage: docmind search <query> [--root D]");
+        process.exitCode = 1;
+        break;
+      }
+      const config = await loadConfig();
+      const root = resolveRoot(config, rootFlag(args));
+      await ensureIndexed(root);
+      const result = await zgSearch(root, query);
+      if (result.hits.length === 0) {
+        console.log(`No hits for "${query}".`);
+        break;
+      }
+      for (const hit of result.hits) {
+        console.log(`#${hit.rank} ${hit.file}:${hit.lineStart}-${hit.lineEnd} [${hit.matchedBy}]${hit.heading ? ` \u2014 ${hit.heading}` : ""}`);
+        for (const s of hit.snippets.slice(0, 2)) console.log(`      L${s.line}: ${s.text.trim().slice(0, 160)}`);
+      }
+      break;
+    }
+    case "index": {
+      const config = await loadConfig();
+      const root = resolveRoot(config, rootFlag(args));
+      await ensureIndexed(root);
+      const { zgIndex: zgIndex2 } = await Promise.resolve().then(() => (init_zg(), zg_exports));
+      console.log(await zgIndex2(root));
+      break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      console.log(HELP);
+      break;
+    default:
+      console.error(`Unknown command: ${cmd}
+`);
+      console.log(HELP);
+      process.exitCode = 1;
+  }
+}
+main().catch((e) => {
+  console.error(`docmind: ${e.message}`);
+  process.exitCode = 1;
+});