@orquentra/codebuddy 0.0.0-stage → 2.4.0

package/dist/chunk-TI5TQD6D.js

@@ -0,0 +1,324 @@
+import {
+  readConfigFile,
+  writeAtomic
+} from "./chunk-K63EOA4B.js";
+
+// src/retrieval/zvec.ts
+import { execFile, spawn } from "child_process";
+import { mkdir, readFile, rm, stat } from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+var SUPPORTED = /^0\.2\.\d+$/;
+var DEFAULT_TIMEOUT_MS = 1500;
+var READY_CACHE_MS = 10 * 6e4;
+var NOT_READY_CACHE_MS = 3e4;
+var REFRESH_TIMEOUT_MS = 10 * 6e4;
+var DEFAULT_ZVEC_MODEL = "local/potion-code-16m-v2";
+var DOC_GLOBS = ["!**/*.md", "!**/*.mdx", "!docs/**"];
+var TEST_GLOBS = [
+  "!**/*.test.*",
+  "!**/*.spec.*",
+  "!**/__tests__/**",
+  "!**/test/**",
+  "!**/tests/**"
+];
+var ALWAYS_EXCLUDED_GLOBS = ["!evals/**", "!scripts/**", "!.codebuddy/**", "!**/fixtures/**"];
+function zvecExcludeGlobs(task) {
+  return [
+    .../\b(docs?|readme|documentation|markdown)\b/i.test(task) ? [] : DOC_GLOBS,
+    .../\b(tests?|spec)\b/i.test(task) ? [] : TEST_GLOBS,
+    ...ALWAYS_EXCLUDED_GLOBS
+  ];
+}
+var EXCLUDED_PREFIXES = [".codebuddy/cache/", ".zvec-grep/", ".git/", "node_modules/"];
+async function zvecCandidates(repositoryRoot, task, options = {}) {
+  const root = resolve(repositoryRoot);
+  const config = await zvecConfig(root);
+  if (!config.enabled) return none("disabled", "zvec-grep not enabled");
+  const run = (args) => runZg(config.binary, args, root, config.timeoutMs);
+  const cached = await readCachedReadiness(root, config.binary);
+  if (cached !== "ready") {
+    if (cached) return cached;
+    const readiness = await checkReadiness(run);
+    await markReadiness(root, config.binary, readiness);
+    if (readiness) return readiness;
+  }
+  const limit = Math.min(20, Math.max(1, Math.floor(options.limit ?? 10)));
+  const chunkLimit = limit * 8;
+  const globs = zvecExcludeGlobs(task);
+  const result = await run([
+    "query",
+    "--vector",
+    task,
+    "--mode",
+    "auto",
+    "--refresh",
+    "off",
+    "--limit",
+    String(chunkLimit),
+    ...globs.flatMap((glob) => ["-g", glob])
+  ]);
+  if (result.error) {
+    await resetZvecCache(root);
+    return fromError(result.error, "zvec-grep query");
+  }
+  const hits = parseHits(result.stdout).slice(0, chunkLimit);
+  if (hits.length === 0 && /\bzg index\b/.test(result.stdout)) {
+    const notReady = none("index-not-ready", NOT_READY);
+    await markReadiness(root, config.binary, notReady);
+    return notReady;
+  }
+  const indexedAt = await readIndexedAt(root);
+  const paths = [];
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  let stale = 0;
+  let changed = 0;
+  for (const hit of hits) {
+    const path = toRepoRelative(root, hit.path);
+    if (!path) continue;
+    if (seen.has(path)) {
+      if (paths.includes(path)) candidates.push({ ...hit, path });
+      continue;
+    }
+    if (paths.length >= limit) continue;
+    seen.add(path);
+    if (EXCLUDED_PREFIXES.some((prefix) => path.startsWith(prefix))) continue;
+    try {
+      const info = await stat(resolve(root, path));
+      if (!info.isFile()) continue;
+      if (indexedAt !== null && Math.max(info.mtimeMs, info.ctimeMs) > indexedAt) {
+        changed++;
+        continue;
+      }
+    } catch {
+      stale++;
+      continue;
+    }
+    paths.push(path);
+    candidates.push({ ...hit, path });
+  }
+  return {
+    status: "ok",
+    paths,
+    hits: candidates,
+    stale,
+    changed,
+    reason: `zvec-grep vector search: ${paths.length} file(s)` + (globs.length > 0 ? "; non-source paths excluded" : "") + (stale > 0 ? `, ${stale} stale hit(s) dropped` : "") + (changed > 0 ? `, ${changed} hit(s) changed since the zg index dropped` : "") + (indexedAt === null ? "; index age unknown, hits unverified (run `codebuddy zvec index`)" : "")
+  };
+}
+async function refreshZvecIndex(repositoryRoot, options = {}) {
+  const root = resolve(repositoryRoot);
+  const config = await zvecConfig(root);
+  if (!config.enabled) return { status: "disabled", reason: "zvec-grep not enabled" };
+  const readiness = await checkReadiness(
+    (args) => runZg(config.binary, args, root, config.timeoutMs)
+  );
+  if (readiness) return { status: readiness.status, reason: readiness.reason };
+  const startedAt = Date.now();
+  const result = await runZg(
+    config.binary,
+    ["index", root, "--mode", "auto"],
+    root,
+    REFRESH_TIMEOUT_MS,
+    options.signal
+  );
+  if (result.error) {
+    const failure = fromError(result.error, "zvec-grep refresh");
+    return { status: failure.status, reason: failure.reason };
+  }
+  await markIndexed(root, startedAt);
+  return { status: "ok", reason: "zvec-grep index refreshed" };
+}
+function parseHits(output) {
+  return [...output.matchAll(/^#(\d+) matchedBy=\S+ (.+?):(\d+)(?:-(\d+))?\s*$/gm)].flatMap((match) => {
+    const rank = Number(match[1]);
+    const startLine = Number(match[3]);
+    const endLine = Number(match[4] ?? match[3]);
+    if (startLine < 1 || endLine < startLine) return [];
+    return [
+      {
+        path: match[2],
+        rank,
+        startLine,
+        endLine,
+        source: "zvec",
+        freshness: "unverified"
+      }
+    ];
+  }).sort((left, right) => left.rank - right.rank);
+}
+async function resetZvecCache(repositoryRoot) {
+  await rm(readyPath(resolve(repositoryRoot)), { force: true });
+}
+async function zvecStatus(repositoryRoot) {
+  const root = resolve(repositoryRoot);
+  const config = await zvecConfig(root);
+  const run = (args) => runZg(config.binary, args, root, Math.max(config.timeoutMs, 5e3));
+  const version = await run(["version"]);
+  const found = version.error ? null : version.stdout.trim().split(/\s+/).pop() ?? null;
+  const supported = found !== null && SUPPORTED.test(found);
+  const readiness = supported ? await checkReadiness(run) : null;
+  const server = supported ? await run(["server", "status"]) : null;
+  return {
+    enabled: config.enabled,
+    binary: config.binary,
+    version: found,
+    supported,
+    indexReady: supported && readiness === null,
+    server: server === null || server.error ? "unknown" : /running|ready/i.test(server.stdout) ? "running" : "stopped",
+    reason: version.error ? fromError(version.error, "zvec-grep version check").reason : !supported ? `zvec-grep ${found ?? "unknown"} is not 0.2.x` : readiness?.reason ?? "ready"
+  };
+}
+async function buildZvecIndex(repositoryRoot, options = {}) {
+  const root = resolve(repositoryRoot);
+  const config = await zvecConfig(root);
+  const args = [
+    "index",
+    root,
+    "--embedding",
+    options.model ?? DEFAULT_ZVEC_MODEL,
+    "--mode",
+    "auto"
+  ];
+  if (options.rebuild) args.push("--rebuild");
+  const startedAt = Date.now();
+  const code = await new Promise((resolveRun, reject) => {
+    const child = spawn(config.binary, args, {
+      cwd: root,
+      stdio: options.quiet ? "ignore" : "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (exit) => resolveRun(exit ?? 1));
+  });
+  await resetZvecCache(root);
+  if (code === 0) await markIndexed(root, startedAt);
+  return code;
+}
+var NOT_READY = "zvec-grep index missing or not ready; run `codebuddy zvec index`";
+async function checkReadiness(run) {
+  const version = await run(["version"]);
+  if (version.error) return fromError(version.error, "zvec-grep version check");
+  const found = version.stdout.trim().split(/\s+/).pop() ?? "";
+  if (!SUPPORTED.test(found)) {
+    return none("unsupported-version", `zvec-grep ${found || "unknown"} is not 0.2.x`);
+  }
+  const ready = await run(["status", "--check-ready", "--mode", "auto"]);
+  if (!ready.error) return null;
+  return ready.error.code === "ETIMEDOUT" ? none("timeout", "zvec-grep status timed out") : none("index-not-ready", NOT_READY);
+}
+function readyPath(root) {
+  return join(root, ".codebuddy", "cache", "zvec-ready.json");
+}
+async function readCachedReadiness(root, binary) {
+  let cached;
+  try {
+    cached = JSON.parse(await readFile(readyPath(root), "utf8"));
+  } catch {
+    return null;
+  }
+  const checkedAt = Date.parse(cached.checkedAt ?? "");
+  const age = Date.now() - checkedAt;
+  if (cached.binary !== binary || !(age >= 0)) return null;
+  if (!cached.failure) return age <= READY_CACHE_MS ? "ready" : null;
+  if (age > NOT_READY_CACHE_MS) return null;
+  const workspace = await stat(join(root, ".zvec-grep")).catch(() => null);
+  if (workspace && workspace.mtimeMs > checkedAt) return null;
+  const { status, reason } = cached.failure;
+  return none(status, `${reason}; cached check from ${Math.round(age / 1e3)}s ago`);
+}
+async function markReadiness(root, binary, failure) {
+  try {
+    const path = readyPath(root);
+    await mkdir(dirname(path), { recursive: true, mode: 448 });
+    const record = {
+      binary,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...failure ? { failure: { status: failure.status, reason: failure.reason } } : {}
+    };
+    await writeAtomic(path, `${JSON.stringify(record)}
+`);
+  } catch {
+  }
+}
+function indexedPath(root) {
+  return join(root, ".codebuddy", "cache", "zvec-index.json");
+}
+async function readIndexedAt(root) {
+  try {
+    const parsed = JSON.parse(await readFile(indexedPath(root), "utf8"));
+    const at = Date.parse(parsed.indexedAt ?? "");
+    return Number.isFinite(at) ? at : null;
+  } catch {
+    return null;
+  }
+}
+async function markIndexed(root, at) {
+  try {
+    const path = indexedPath(root);
+    await mkdir(dirname(path), { recursive: true, mode: 448 });
+    await writeAtomic(path, `${JSON.stringify({ indexedAt: new Date(at).toISOString() })}
+`);
+  } catch {
+  }
+}
+async function zvecConfig(root) {
+  let file = {};
+  try {
+    file = await readConfigFile(root);
+  } catch {
+  }
+  const env = process.env.CODEBUDDY_ZVEC;
+  return {
+    enabled: env !== void 0 ? env === "1" || env === "true" : file.zvec?.enabled ?? false,
+    binary: file.zvec?.binary ?? "zg",
+    timeoutMs: file.zvec?.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  };
+}
+function runZg(binary, args, cwd, timeoutMs, signal) {
+  return new Promise((resolveRun) => {
+    execFile(
+      binary,
+      args,
+      {
+        cwd,
+        timeout: timeoutMs,
+        maxBuffer: 1024 * 1024,
+        killSignal: "SIGKILL",
+        ...signal ? { signal } : {}
+      },
+      (error, stdout) => {
+        if (error && error.killed) {
+          resolveRun({ stdout: "", error: Object.assign(error, { code: "ETIMEDOUT" }) });
+          return;
+        }
+        resolveRun({ stdout: String(stdout), error });
+      }
+    );
+  });
+}
+function fromError(error, what) {
+  if (error.code === "ENOENT") return none("not-installed", "zvec-grep (`zg`) not found on PATH");
+  if (error.code === "ETIMEDOUT") return none("timeout", `${what} timed out`);
+  return none("failed", `${what} failed`);
+}
+function none(status, reason) {
+  return { status, paths: [], hits: [], reason, stale: 0, changed: 0 };
+}
+function toRepoRelative(root, path) {
+  const absolute = isAbsolute(path) ? path : resolve(root, path);
+  const rel = relative(root, absolute);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return null;
+  return rel.split(sep).join("/");
+}
+
+export {
+  DEFAULT_ZVEC_MODEL,
+  zvecExcludeGlobs,
+  zvecCandidates,
+  refreshZvecIndex,
+  parseHits,
+  resetZvecCache,
+  zvecStatus,
+  buildZvecIndex
+};
+//# sourceMappingURL=chunk-TI5TQD6D.js.map

package/dist/chunk-TI5TQD6D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/retrieval/zvec.ts"],"sourcesContent":["import { execFile, spawn } from \"node:child_process\";\nimport { mkdir, readFile, rm, stat } from \"node:fs/promises\";\nimport { dirname, isAbsolute, join, relative, resolve, sep } from \"node:path\";\nimport { readConfigFile } from \"../core/config-file.js\";\nimport { writeAtomic } from \"../core/markdown-store-fs.js\";\n\n/**\n * Optional semantic candidate source backed by zvec-grep (`zg`), a local\n * code-search CLI. It only *suggests* files: hits are normalized to\n * repository-relative paths, checked against the working tree, and fused with\n * the keyword ranking by the caller. Risk, policy and incident evidence are\n * never derived from it.\n *\n * Off unless `.codebuddy/config.json` sets `zvec.enabled` (or\n * `CODEBUDDY_ZVEC=1`). It never builds an index implicitly: an unready index,\n * a missing or unsupported binary, a timeout, or unparseable output all return\n * no candidates plus a reason, and callers fall back to keyword ranking.\n *\n * Queries exclude non-source paths (docs, Markdown, evals, scripts, tests,\n * CodeBuddy's own state) unless the task asks about them: otherwise prose that\n * quotes a task, such as audits or eval prompts, outranks the code it describes.\n *\n * Benchmarked: vector-only queries beat zg's default hybrid route on code\n * tasks, so only `--vector` is used. Results are parsed from zg's agent\n * markdown (`#N matchedBy=… path:start-end`), as 0.2.x has no JSON output.\n *\n * Queries use `--mode auto`: a running `zg server` answers in ~200ms, otherwise\n * zg searches directly (~400ms). Auto mode never starts the daemon. The\n * version/readiness check (~400ms) is cached on disk for a few minutes so the\n * per-prompt hook process doesn't repeat it. A failed check (not installed,\n * index not ready, timeout) is cached too, but only for 30 s and only until the\n * workspace's `.zvec-grep/` changes, so an unready index costs one probe per\n * window instead of one per call while a fresh `zg index` is still picked up.\n *\n * Freshness: queries keep `--refresh off` so the prompt path never waits on\n * embedding. Instead `refreshZvecIndex` (run by project sync after index\n * passes, off the request path) and `codebuddy zvec index` record when the zg\n * index was last brought up to date, and hits whose file changed after that are\n * dropped rather than presented with their old meaning.\n */\n\n/** zvec-grep versions whose CLI and output format this adapter was tested against. */\nconst SUPPORTED = /^0\\.2\\.\\d+$/;\nconst DEFAULT_TIMEOUT_MS = 1_500;\nconst READY_CACHE_MS = 10 * 60_000;\n/** A failed readiness check is reused this long, so a fresh `zg index` is noticed quickly. */\nconst NOT_READY_CACHE_MS = 30_000;\n/** An incremental `zg index` runs in the background; only a runaway is killed. */\nconst REFRESH_TIMEOUT_MS = 10 * 60_000;\n/** Small, fast local model; indexes this repo in seconds. */\nexport const DEFAULT_ZVEC_MODEL = \"local/potion-code-16m-v2\";\nconst DOC_GLOBS = [\"!**/*.md\", \"!**/*.mdx\", \"!docs/**\"];\nconst TEST_GLOBS = [\n  \"!**/*.test.*\",\n  \"!**/*.spec.*\",\n  \"!**/__tests__/**\",\n  \"!**/test/**\",\n  \"!**/tests/**\",\n];\nconst ALWAYS_EXCLUDED_GLOBS = [\"!evals/**\", \"!scripts/**\", \"!.codebuddy/**\", \"!**/fixtures/**\"];\n\n/** zg `-g` exclusions for a task: docs and tests stay searchable when the task names them. */\nexport function zvecExcludeGlobs(task: string): string[] {\n  return [\n    ...(/\\b(docs?|readme|documentation|markdown)\\b/i.test(task) ? [] : DOC_GLOBS),\n    ...(/\\b(tests?|spec)\\b/i.test(task) ? [] : TEST_GLOBS),\n    ...ALWAYS_EXCLUDED_GLOBS,\n  ];\n}\n\nconst EXCLUDED_PREFIXES = [\".codebuddy/cache/\", \".zvec-grep/\", \".git/\", \"node_modules/\"];\n\nexport type ZvecStatus =\n  | \"ok\"\n  | \"disabled\"\n  | \"not-installed\"\n  | \"unsupported-version\"\n  | \"index-not-ready\"\n  | \"timeout\"\n  | \"failed\";\n\n/** zg provides no content hash: a valid range alone cannot prove index freshness. */\nexport type RetrievalHit = {\n  path: string;\n  startLine: number;\n  endLine: number;\n  rank: number;\n  /** `anchor`: a line the task itself names (path:line, stack frame, error string). */\n  source: \"zvec\" | \"anchor\";\n  freshness: \"unverified\";\n};\n\nexport type ZvecCandidates = {\n  status: ZvecStatus;\n  /** Repo-relative paths of existing files, best first. */\n  paths: string[];\n  /** Every chunk hit inside `paths`, in rank order (several per file). */\n  hits: RetrievalHit[];\n  reason: string;\n  /** Hits dropped because the file no longer exists (stale index). */\n  stale: number;\n  /** Hits dropped because the file changed after the zg index was refreshed. */\n  changed: number;\n};\n\nexport async function zvecCandidates(\n  repositoryRoot: string,\n  task: string,\n  options: { limit?: number } = {},\n): Promise<ZvecCandidates> {\n  const root = resolve(repositoryRoot);\n  const config = await zvecConfig(root);\n  if (!config.enabled) return none(\"disabled\", \"zvec-grep not enabled\");\n  const run = (args: string[]) => runZg(config.binary, args, root, config.timeoutMs);\n\n  const cached = await readCachedReadiness(root, config.binary);\n  if (cached !== \"ready\") {\n    if (cached) return cached;\n    const readiness = await checkReadiness(run);\n    await markReadiness(root, config.binary, readiness);\n    if (readiness) return readiness;\n  }\n\n  // zg ranks chunks, and one file can own many of them: oversample chunks so\n  // `limit` distinct files survive de-duplication.\n  const limit = Math.min(20, Math.max(1, Math.floor(options.limit ?? 10)));\n  const chunkLimit = limit * 8;\n  const globs = zvecExcludeGlobs(task);\n  const result = await run([\n    \"query\",\n    \"--vector\",\n    task,\n    \"--mode\",\n    \"auto\",\n    \"--refresh\",\n    \"off\",\n    \"--limit\",\n    String(chunkLimit),\n    ...globs.flatMap((glob) => [\"-g\", glob]),\n  ]);\n  if (result.error) {\n    await resetZvecCache(root);\n    return fromError(result.error, \"zvec-grep query\");\n  }\n\n  const hits = parseHits(result.stdout).slice(0, chunkLimit);\n  // With no index, zg answers with a \"run zg index\" hint instead of hits.\n  if (hits.length === 0 && /\\bzg index\\b/.test(result.stdout)) {\n    const notReady = none(\"index-not-ready\", NOT_READY);\n    await markReadiness(root, config.binary, notReady);\n    return notReady;\n  }\n  const indexedAt = await readIndexedAt(root);\n  const paths: string[] = [];\n  const candidates: RetrievalHit[] = [];\n  const seen = new Set<string>();\n  let stale = 0;\n  let changed = 0;\n  for (const hit of hits) {\n    const path = toRepoRelative(root, hit.path);\n    if (!path) continue;\n    // Later chunks of an accepted file keep their spans; a rejected file stays rejected.\n    if (seen.has(path)) {\n      if (paths.includes(path)) candidates.push({ ...hit, path });\n      continue;\n    }\n    if (paths.length >= limit) continue;\n    seen.add(path);\n    if (EXCLUDED_PREFIXES.some((prefix) => path.startsWith(prefix))) continue;\n    try {\n      const info = await stat(resolve(root, path));\n      if (!info.isFile()) continue;\n      // ctime too: a rename over the path keeps the old mtime.\n      if (indexedAt !== null && Math.max(info.mtimeMs, info.ctimeMs) > indexedAt) {\n        changed++;\n        continue;\n      }\n    } catch {\n      stale++;\n      continue;\n    }\n    paths.push(path);\n    candidates.push({ ...hit, path });\n  }\n  return {\n    status: \"ok\",\n    paths,\n    hits: candidates,\n    stale,\n    changed,\n    reason:\n      `zvec-grep vector search: ${paths.length} file(s)` +\n      (globs.length > 0 ? \"; non-source paths excluded\" : \"\") +\n      (stale > 0 ? `, ${stale} stale hit(s) dropped` : \"\") +\n      (changed > 0 ? `, ${changed} hit(s) changed since the zg index dropped` : \"\") +\n      (indexedAt === null\n        ? \"; index age unknown, hits unverified (run `codebuddy zvec index`)\"\n        : \"\"),\n  };\n}\n\nexport type ZvecRefresh = { status: ZvecStatus; reason: string };\n\n/**\n * Incrementally refresh an existing zg index (no `--rebuild`, no embedding\n * flag) and record when it started, which is the freshness bound applied to\n * later hits. Never builds a missing index and never starts a zg server; every\n * failure is returned as a status for the caller to log.\n */\nexport async function refreshZvecIndex(\n  repositoryRoot: string,\n  options: { signal?: AbortSignal } = {},\n): Promise<ZvecRefresh> {\n  const root = resolve(repositoryRoot);\n  const config = await zvecConfig(root);\n  if (!config.enabled) return { status: \"disabled\", reason: \"zvec-grep not enabled\" };\n  const readiness = await checkReadiness((args) =>\n    runZg(config.binary, args, root, config.timeoutMs),\n  );\n  if (readiness) return { status: readiness.status, reason: readiness.reason };\n  const startedAt = Date.now();\n  const result = await runZg(\n    config.binary,\n    [\"index\", root, \"--mode\", \"auto\"],\n    root,\n    REFRESH_TIMEOUT_MS,\n    options.signal,\n  );\n  if (result.error) {\n    const failure = fromError(result.error, \"zvec-grep refresh\");\n    return { status: failure.status, reason: failure.reason };\n  }\n  await markIndexed(root, startedAt);\n  return { status: \"ok\", reason: \"zvec-grep index refreshed\" };\n}\n\n/** Extract bounded, validated line ranges in retrieval rank order. */\nexport function parseHits(output: string): RetrievalHit[] {\n  return [...output.matchAll(/^#(\\d+) matchedBy=\\S+ (.+?):(\\d+)(?:-(\\d+))?\\s*$/gm)]\n    .flatMap((match) => {\n      const rank = Number(match[1]);\n      const startLine = Number(match[3]);\n      const endLine = Number(match[4] ?? match[3]);\n      if (startLine < 1 || endLine < startLine) return [];\n      return [\n        {\n          path: match[2] as string,\n          rank,\n          startLine,\n          endLine,\n          source: \"zvec\" as const,\n          freshness: \"unverified\" as const,\n        },\n      ];\n    })\n    .sort((left, right) => left.rank - right.rank);\n}\n\n/** Forget the cached readiness check, e.g. after `zg index` or a failed query. */\nexport async function resetZvecCache(repositoryRoot: string): Promise<void> {\n  await rm(readyPath(resolve(repositoryRoot)), { force: true });\n}\n\nexport type ZvecReport = {\n  enabled: boolean;\n  binary: string;\n  version: string | null;\n  supported: boolean;\n  indexReady: boolean;\n  server: \"running\" | \"stopped\" | \"unknown\";\n  reason: string;\n};\n\n/** Everything `codebuddy zvec status` shows. Read-only; never builds an index. */\nexport async function zvecStatus(repositoryRoot: string): Promise<ZvecReport> {\n  const root = resolve(repositoryRoot);\n  const config = await zvecConfig(root);\n  const run = (args: string[]) =>\n    runZg(config.binary, args, root, Math.max(config.timeoutMs, 5_000));\n  const version = await run([\"version\"]);\n  const found = version.error ? null : (version.stdout.trim().split(/\\s+/).pop() ?? null);\n  const supported = found !== null && SUPPORTED.test(found);\n  const readiness = supported ? await checkReadiness(run) : null;\n  const server = supported ? await run([\"server\", \"status\"]) : null;\n  return {\n    enabled: config.enabled,\n    binary: config.binary,\n    version: found,\n    supported,\n    indexReady: supported && readiness === null,\n    server:\n      server === null || server.error\n        ? \"unknown\"\n        : /running|ready/i.test(server.stdout)\n          ? \"running\"\n          : \"stopped\",\n    reason: version.error\n      ? fromError(version.error, \"zvec-grep version check\").reason\n      : !supported\n        ? `zvec-grep ${found ?? \"unknown\"} is not 0.2.x`\n        : (readiness?.reason ?? \"ready\"),\n  };\n}\n\n/**\n * Build or incrementally refresh the zg index for this repository, streaming\n * zg's progress. Explicit by design: CodeBuddy never indexes implicitly.\n */\nexport async function buildZvecIndex(\n  repositoryRoot: string,\n  options: {\n    model?: string;\n    rebuild?: boolean /** Discard zg's progress output. */;\n    quiet?: boolean;\n  } = {},\n): Promise<number> {\n  const root = resolve(repositoryRoot);\n  const config = await zvecConfig(root);\n  const args = [\n    \"index\",\n    root,\n    \"--embedding\",\n    options.model ?? DEFAULT_ZVEC_MODEL,\n    \"--mode\",\n    \"auto\",\n  ];\n  if (options.rebuild) args.push(\"--rebuild\");\n  const startedAt = Date.now();\n  const code = await new Promise<number>((resolveRun, reject) => {\n    const child = spawn(config.binary, args, {\n      cwd: root,\n      stdio: options.quiet ? \"ignore\" : \"inherit\",\n    });\n    child.on(\"error\", reject);\n    child.on(\"close\", (exit) => resolveRun(exit ?? 1));\n  });\n  await resetZvecCache(root);\n  if (code === 0) await markIndexed(root, startedAt);\n  return code;\n}\n\nconst NOT_READY = \"zvec-grep index missing or not ready; run `codebuddy zvec index`\";\n\n/** Version + index readiness. Returns null when ready, else the failure. */\nasync function checkReadiness(\n  run: (args: string[]) => Promise<RunResult>,\n): Promise<ZvecCandidates | null> {\n  const version = await run([\"version\"]);\n  if (version.error) return fromError(version.error, \"zvec-grep version check\");\n  const found = version.stdout.trim().split(/\\s+/).pop() ?? \"\";\n  if (!SUPPORTED.test(found)) {\n    return none(\"unsupported-version\", `zvec-grep ${found || \"unknown\"} is not 0.2.x`);\n  }\n  const ready = await run([\"status\", \"--check-ready\", \"--mode\", \"auto\"]);\n  if (!ready.error) return null;\n  return ready.error.code === \"ETIMEDOUT\"\n    ? none(\"timeout\", \"zvec-grep status timed out\")\n    : none(\"index-not-ready\", NOT_READY);\n}\n\nfunction readyPath(root: string): string {\n  return join(root, \".codebuddy\", \"cache\", \"zvec-ready.json\");\n}\n\ntype CachedReadiness = {\n  binary?: string;\n  checkedAt?: string;\n  /** Absent in caches written before failures were cached: those were always ready. */\n  failure?: { status: ZvecStatus; reason: string };\n};\n\n/**\n * \"ready\", a cached failure (reason marked as cached), or null when the check\n * must run. A failure is dropped once `.zvec-grep/` changed after it was\n * recorded, i.e. someone (re)built the index outside CodeBuddy.\n */\nasync function readCachedReadiness(\n  root: string,\n  binary: string,\n): Promise<\"ready\" | ZvecCandidates | null> {\n  let cached: CachedReadiness;\n  try {\n    cached = JSON.parse(await readFile(readyPath(root), \"utf8\")) as CachedReadiness;\n  } catch {\n    return null;\n  }\n  const checkedAt = Date.parse(cached.checkedAt ?? \"\");\n  const age = Date.now() - checkedAt;\n  if (cached.binary !== binary || !(age >= 0)) return null;\n  if (!cached.failure) return age <= READY_CACHE_MS ? \"ready\" : null;\n  if (age > NOT_READY_CACHE_MS) return null;\n  const workspace = await stat(join(root, \".zvec-grep\")).catch(() => null);\n  if (workspace && workspace.mtimeMs > checkedAt) return null;\n  const { status, reason } = cached.failure;\n  return none(status, `${reason}; cached check from ${Math.round(age / 1000)}s ago`);\n}\n\n/** Cache a readiness result: null = ready. */\nasync function markReadiness(\n  root: string,\n  binary: string,\n  failure: ZvecCandidates | null,\n): Promise<void> {\n  try {\n    const path = readyPath(root);\n    await mkdir(dirname(path), { recursive: true, mode: 0o700 });\n    const record: CachedReadiness = {\n      binary,\n      checkedAt: new Date().toISOString(),\n      ...(failure ? { failure: { status: failure.status, reason: failure.reason } } : {}),\n    };\n    await writeAtomic(path, `${JSON.stringify(record)}\\n`);\n  } catch {\n    // A read-only cache only costs a repeated readiness check.\n  }\n}\n\nfunction indexedPath(root: string): string {\n  return join(root, \".codebuddy\", \"cache\", \"zvec-index.json\");\n}\n\n/** When the zg index was last refreshed by CodeBuddy, or null if unknown. */\nasync function readIndexedAt(root: string): Promise<number | null> {\n  try {\n    const parsed = JSON.parse(await readFile(indexedPath(root), \"utf8\")) as { indexedAt?: string };\n    const at = Date.parse(parsed.indexedAt ?? \"\");\n    return Number.isFinite(at) ? at : null;\n  } catch {\n    return null;\n  }\n}\n\nasync function markIndexed(root: string, at: number): Promise<void> {\n  try {\n    const path = indexedPath(root);\n    await mkdir(dirname(path), { recursive: true, mode: 0o700 });\n    await writeAtomic(path, `${JSON.stringify({ indexedAt: new Date(at).toISOString() })}\\n`);\n  } catch {\n    // Without the record, later hits are reported as unverified, not trusted.\n  }\n}\n\nasync function zvecConfig(\n  root: string,\n): Promise<{ enabled: boolean; binary: string; timeoutMs: number }> {\n  let file: Awaited<ReturnType<typeof readConfigFile>> = {};\n  try {\n    file = await readConfigFile(root);\n  } catch {\n    // A broken config must not break context assembly; treat zvec as disabled.\n  }\n  const env = process.env.CODEBUDDY_ZVEC;\n  return {\n    enabled: env !== undefined ? env === \"1\" || env === \"true\" : (file.zvec?.enabled ?? false),\n    binary: file.zvec?.binary ?? \"zg\",\n    timeoutMs: file.zvec?.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n  };\n}\n\ntype RunResult = {\n  stdout: string;\n  error: (Error & { code?: string | number | null | undefined }) | null;\n};\n\nfunction runZg(\n  binary: string,\n  args: string[],\n  cwd: string,\n  timeoutMs: number,\n  signal?: AbortSignal,\n): Promise<RunResult> {\n  return new Promise((resolveRun) => {\n    execFile(\n      binary,\n      args,\n      {\n        cwd,\n        timeout: timeoutMs,\n        maxBuffer: 1024 * 1024,\n        killSignal: \"SIGKILL\",\n        ...(signal ? { signal } : {}),\n      },\n      (error, stdout) => {\n        if (error && (error as { killed?: boolean }).killed) {\n          resolveRun({ stdout: \"\", error: Object.assign(error, { code: \"ETIMEDOUT\" }) });\n          return;\n        }\n        resolveRun({ stdout: String(stdout), error });\n      },\n    );\n  });\n}\n\nfunction fromError(error: NonNullable<RunResult[\"error\"]>, what: string): ZvecCandidates {\n  if (error.code === \"ENOENT\") return none(\"not-installed\", \"zvec-grep (`zg`) not found on PATH\");\n  if (error.code === \"ETIMEDOUT\") return none(\"timeout\", `${what} timed out`);\n  return none(\"failed\", `${what} failed`);\n}\n\nfunction none(status: ZvecStatus, reason: string): ZvecCandidates {\n  return { status, paths: [], hits: [], reason, stale: 0, changed: 0 };\n}\n\nfunction toRepoRelative(root: string, path: string): string | null {\n  const absolute = isAbsolute(path) ? path : resolve(root, path);\n  const rel = relative(root, absolute);\n  if (rel === \"\" || rel === \"..\" || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return null;\n  return rel.split(sep).join(\"/\");\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WHZSVY2L.js

@@ -0,0 +1,144 @@
+import {
+  failSoft,
+  readHookInput,
+  writeStdout
+} from "./chunk-PYLH4MH5.js";
+import {
+  extractSymbolTable,
+  supportsSymbols
+} from "./chunk-PQK3GKZH.js";
+
+// src/hooks/pretool.ts
+import { open, stat } from "fs/promises";
+import { extname, isAbsolute, relative, resolve, sep } from "path";
+var TOOL_GUARD = {
+  readLines: 1e3,
+  readBytes: 8e4,
+  /** Symbols shorter than this are noise in an outline (one-line constants). */
+  outlineMinSymbolLines: 3,
+  /** Fewer top-level symbols than this: list class methods too. */
+  minTopLevelEntries: 10,
+  outlineEntries: 40,
+  blockLines: 100,
+  grepHeadLimit: 100
+};
+var SPECIAL_READ = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".bmp",
+  ".svg",
+  ".pdf",
+  ".ipynb"
+]);
+var MAX_GUARD_BYTES = 2e6;
+async function decidePreTool(input, env = process.env) {
+  if (env.CODEBUDDY_TOOL_GUARD === "0") return null;
+  const toolInput = input.tool_input ?? {};
+  if (input.tool_name === "Grep") return capGrep(toolInput);
+  if (input.tool_name === "Read") return guardRead(resolve(input.cwd ?? process.cwd()), toolInput);
+  return null;
+}
+function capGrep(toolInput) {
+  if (toolInput.output_mode !== "content" || toolInput.head_limit !== void 0) return null;
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      updatedInput: { ...toolInput, head_limit: TOOL_GUARD.grepHeadLimit }
+    }
+  };
+}
+async function guardRead(root, toolInput) {
+  if (toolInput.offset !== void 0 || toolInput.limit !== void 0) return null;
+  const filePath = toolInput.file_path;
+  if (typeof filePath !== "string" || !filePath) return null;
+  const absolute = isAbsolute(filePath) ? resolve(filePath) : resolve(root, filePath);
+  const rel = relative(root, absolute);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return null;
+  if (SPECIAL_READ.has(extname(absolute).toLowerCase())) return null;
+  let size;
+  try {
+    const info = await stat(absolute);
+    if (!info.isFile()) return null;
+    size = info.size;
+  } catch {
+    return null;
+  }
+  if (size > MAX_GUARD_BYTES) return null;
+  const text = await readText(absolute);
+  if (text === null) return null;
+  const lines = text.split(/\r?\n/);
+  if (lines.at(-1) === "") lines.pop();
+  if (lines.length <= TOOL_GUARD.readLines && size <= TOOL_GUARD.readBytes) return null;
+  const path = rel.replace(/\\/g, "/");
+  const outline = outlineOf(path, text, lines);
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: [
+        `CodeBuddy read guard: ${path} is ${lines.length} lines (~${Math.ceil(size / 4)} tokens), too large to read whole.`,
+        `Outline: ${outline.join("; ")}`,
+        "Read only the part you need with offset and limit (offset = first line, limit = line count).",
+        "To find specific text, use Grep with output_mode content and -n instead of reading the file.",
+        `To read the whole file anyway, call Read again with limit: ${lines.length}.`
+      ].join("\n")
+    }
+  };
+}
+async function readText(path) {
+  const handle = await open(path, "r");
+  try {
+    const content = await handle.readFile();
+    if (content.includes(0)) return null;
+    return content.toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+function outlineOf(path, text, lines) {
+  const cap = (entries) => entries.length > TOOL_GUARD.outlineEntries ? [
+    ...entries.slice(0, TOOL_GUARD.outlineEntries),
+    `\u2026 ${entries.length - TOOL_GUARD.outlineEntries} more`
+  ] : entries;
+  if (supportsSymbols(path)) {
+    const table = extractSymbolTable(text).filter(
+      (symbol) => symbol.endLine - symbol.startLine + 1 >= TOOL_GUARD.outlineMinSymbolLines
+    );
+    const topLevel = table.filter((symbol) => symbol.kind !== "method");
+    const symbols = topLevel.length >= TOOL_GUARD.minTopLevelEntries ? topLevel : table;
+    if (symbols.length > 0) {
+      const covered = Math.max(...symbols.map((symbol) => symbol.endLine));
+      return [
+        ...cap(symbols.map((s) => `${s.name} L${s.startLine}-${s.endLine}`)),
+        ...covered < lines.length ? [`not outlined L${covered + 1}-${lines.length}`] : []
+      ];
+    }
+  }
+  if (/\.mdx?$/i.test(path)) {
+    const headings = lines.flatMap(
+      (line, i) => /^#{1,4}\s+\S/.test(line) ? [`${line.trim().slice(0, 80)} L${i + 1}`] : []
+    );
+    if (headings.length > 0) return cap(headings);
+  }
+  const blocks = [];
+  for (let start = 1; start <= lines.length; start += TOOL_GUARD.blockLines) {
+    blocks.push(`L${start}-${Math.min(lines.length, start + TOOL_GUARD.blockLines - 1)}`);
+  }
+  return cap(blocks);
+}
+
+// src/hooks/pretool-command.ts
+async function runPreToolHookCommand() {
+  await failSoft(async () => {
+    const decision = await decidePreTool(await readHookInput());
+    if (decision) await writeStdout(JSON.stringify(decision));
+  });
+}
+
+export {
+  runPreToolHookCommand
+};
+//# sourceMappingURL=chunk-WHZSVY2L.js.map

package/dist/chunk-WHZSVY2L.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/pretool.ts","../src/hooks/pretool-command.ts"],"sourcesContent":["import { open, stat } from \"node:fs/promises\";\nimport { extname, isAbsolute, relative, resolve, sep } from \"node:path\";\nimport { extractSymbolTable, supportsSymbols } from \"../indexer/symbols.js\";\nimport type { HookInput } from \"./runtime.js\";\n\n/**\n * PreToolUse tool guard (Claude Code): cut tool output that would otherwise\n * stay in context for the rest of the session, without touching permissions.\n *\n * - Read of a large file with no range → denied with an outline (symbols or\n *   headings with line ranges) and how to read a range or the whole file.\n *   The model sees the deny reason; any Read with offset/limit passes.\n * - Grep in content mode with no head_limit → the same input plus a limit.\n *\n * Never emits `permissionDecision: \"allow\"`: Claude Code checks permissions on\n * the (possibly rewritten) input as usual. Verified on Claude Code 2.1.287.\n */\n/**\n * Only files whose full read is clearly expensive: below this, an agent that\n * re-reads the whole file after the outline (observed live) costs a turn for\n * nothing.\n */\nexport const TOOL_GUARD = {\n  readLines: 1_000,\n  readBytes: 80_000,\n  /** Symbols shorter than this are noise in an outline (one-line constants). */\n  outlineMinSymbolLines: 3,\n  /** Fewer top-level symbols than this: list class methods too. */\n  minTopLevelEntries: 10,\n  outlineEntries: 40,\n  blockLines: 100,\n  grepHeadLimit: 100,\n} as const;\n\n/** Read renders these itself (images, PDFs, notebooks); never guard them. */\nconst SPECIAL_READ = new Set([\n  \".png\",\n  \".jpg\",\n  \".jpeg\",\n  \".gif\",\n  \".webp\",\n  \".bmp\",\n  \".svg\",\n  \".pdf\",\n  \".ipynb\",\n]);\nconst MAX_GUARD_BYTES = 2_000_000;\n\nexport type PreToolDecision = {\n  hookSpecificOutput: {\n    hookEventName: \"PreToolUse\";\n    permissionDecision?: \"deny\";\n    permissionDecisionReason?: string;\n    updatedInput?: Record<string, unknown>;\n  };\n} | null;\n\nexport async function decidePreTool(\n  input: HookInput,\n  env: NodeJS.ProcessEnv = process.env,\n): Promise<PreToolDecision> {\n  if (env.CODEBUDDY_TOOL_GUARD === \"0\") return null;\n  const toolInput = input.tool_input ?? {};\n  if (input.tool_name === \"Grep\") return capGrep(toolInput);\n  if (input.tool_name === \"Read\") return guardRead(resolve(input.cwd ?? process.cwd()), toolInput);\n  return null;\n}\n\nfunction capGrep(toolInput: Record<string, unknown>): PreToolDecision {\n  if (toolInput.output_mode !== \"content\" || toolInput.head_limit !== undefined) return null;\n  return {\n    hookSpecificOutput: {\n      hookEventName: \"PreToolUse\",\n      updatedInput: { ...toolInput, head_limit: TOOL_GUARD.grepHeadLimit },\n    },\n  };\n}\n\nasync function guardRead(\n  root: string,\n  toolInput: Record<string, unknown>,\n): Promise<PreToolDecision> {\n  if (toolInput.offset !== undefined || toolInput.limit !== undefined) return null;\n  const filePath = toolInput.file_path;\n  if (typeof filePath !== \"string\" || !filePath) return null;\n  const absolute = isAbsolute(filePath) ? resolve(filePath) : resolve(root, filePath);\n  const rel = relative(root, absolute);\n  if (rel === \"\" || rel === \"..\" || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return null;\n  if (SPECIAL_READ.has(extname(absolute).toLowerCase())) return null;\n  let size: number;\n  try {\n    const info = await stat(absolute);\n    if (!info.isFile()) return null;\n    size = info.size;\n  } catch {\n    return null;\n  }\n  if (size > MAX_GUARD_BYTES) return null; // Read refuses huge files itself.\n  const text = await readText(absolute);\n  if (text === null) return null;\n  const lines = text.split(/\\r?\\n/);\n  if (lines.at(-1) === \"\") lines.pop();\n  if (lines.length <= TOOL_GUARD.readLines && size <= TOOL_GUARD.readBytes) return null;\n\n  const path = rel.replace(/\\\\/g, \"/\");\n  const outline = outlineOf(path, text, lines);\n  return {\n    hookSpecificOutput: {\n      hookEventName: \"PreToolUse\",\n      permissionDecision: \"deny\",\n      permissionDecisionReason: [\n        `CodeBuddy read guard: ${path} is ${lines.length} lines (~${Math.ceil(size / 4)} tokens), too large to read whole.`,\n        `Outline: ${outline.join(\"; \")}`,\n        \"Read only the part you need with offset and limit (offset = first line, limit = line count).\",\n        \"To find specific text, use Grep with output_mode content and -n instead of reading the file.\",\n        `To read the whole file anyway, call Read again with limit: ${lines.length}.`,\n      ].join(\"\\n\"),\n    },\n  };\n}\n\n/** Whole file as UTF-8 text, or null when it looks binary. */\nasync function readText(path: string): Promise<string | null> {\n  const handle = await open(path, \"r\");\n  try {\n    const content = await handle.readFile();\n    if (content.includes(0)) return null;\n    return content.toString(\"utf8\");\n  } finally {\n    await handle.close();\n  }\n}\n\nfunction outlineOf(path: string, text: string, lines: string[]): string[] {\n  const cap = (entries: string[]) =>\n    entries.length > TOOL_GUARD.outlineEntries\n      ? [\n          ...entries.slice(0, TOOL_GUARD.outlineEntries),\n          `… ${entries.length - TOOL_GUARD.outlineEntries} more`,\n        ]\n      : entries;\n  if (supportsSymbols(path)) {\n    const table = extractSymbolTable(text).filter(\n      (symbol) => symbol.endLine - symbol.startLine + 1 >= TOOL_GUARD.outlineMinSymbolLines,\n    );\n    const topLevel = table.filter((symbol) => symbol.kind !== \"method\");\n    // One big class says little on its own; then list its methods (`Class.method`).\n    const symbols = topLevel.length >= TOOL_GUARD.minTopLevelEntries ? topLevel : table;\n    if (symbols.length > 0) {\n      // The symbol table is capped, so say where the outline stops covering the file.\n      const covered = Math.max(...symbols.map((symbol) => symbol.endLine));\n      return [\n        ...cap(symbols.map((s) => `${s.name} L${s.startLine}-${s.endLine}`)),\n        ...(covered < lines.length ? [`not outlined L${covered + 1}-${lines.length}`] : []),\n      ];\n    }\n  }\n  if (/\\.mdx?$/i.test(path)) {\n    const headings = lines.flatMap((line, i) =>\n      /^#{1,4}\\s+\\S/.test(line) ? [`${line.trim().slice(0, 80)} L${i + 1}`] : [],\n    );\n    if (headings.length > 0) return cap(headings);\n  }\n  const blocks: string[] = [];\n  for (let start = 1; start <= lines.length; start += TOOL_GUARD.blockLines) {\n    blocks.push(`L${start}-${Math.min(lines.length, start + TOOL_GUARD.blockLines - 1)}`);\n  }\n  return cap(blocks);\n}\n","import { decidePreTool } from \"./pretool.js\";\nimport { failSoft, readHookInput, writeStdout } from \"./stdio.js\";\n\n/** `codebuddy hooks pretool`: runs on every Read/Grep, so it loads only its own module. */\nexport async function runPreToolHookCommand(): Promise<void> {\n  await failSoft(async () => {\n    const decision = await decidePreTool(await readHookInput());\n    if (decision) await writeStdout(JSON.stringify(decision));\n  });\n}\n"],"mappings":";;;;;;;;;;;AAAA,SAAS,MAAM,YAAY;AAC3B,SAAS,SAAS,YAAY,UAAU,SAAS,WAAW;AAqBrD,IAAM,aAAa;AAAA,EACxB,WAAW;AAAA,EACX,WAAW;AAAA;AAAA,EAEX,uBAAuB;AAAA;AAAA,EAEvB,oBAAoB;AAAA,EACpB,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,eAAe;AACjB;AAGA,IAAM,eAAe,oBAAI,IAAI;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AACD,IAAM,kBAAkB;AAWxB,eAAsB,cACpB,OACA,MAAyB,QAAQ,KACP;AAC1B,MAAI,IAAI,yBAAyB,IAAK,QAAO;AAC7C,QAAM,YAAY,MAAM,cAAc,CAAC;AACvC,MAAI,MAAM,cAAc,OAAQ,QAAO,QAAQ,SAAS;AACxD,MAAI,MAAM,cAAc,OAAQ,QAAO,UAAU,QAAQ,MAAM,OAAO,QAAQ,IAAI,CAAC,GAAG,SAAS;AAC/F,SAAO;AACT;AAEA,SAAS,QAAQ,WAAqD;AACpE,MAAI,UAAU,gBAAgB,aAAa,UAAU,eAAe,OAAW,QAAO;AACtF,SAAO;AAAA,IACL,oBAAoB;AAAA,MAClB,eAAe;AAAA,MACf,cAAc,EAAE,GAAG,WAAW,YAAY,WAAW,cAAc;AAAA,IACrE;AAAA,EACF;AACF;AAEA,eAAe,UACb,MACA,WAC0B;AAC1B,MAAI,UAAU,WAAW,UAAa,UAAU,UAAU,OAAW,QAAO;AAC5E,QAAM,WAAW,UAAU;AAC3B,MAAI,OAAO,aAAa,YAAY,CAAC,SAAU,QAAO;AACtD,QAAM,WAAW,WAAW,QAAQ,IAAI,QAAQ,QAAQ,IAAI,QAAQ,MAAM,QAAQ;AAClF,QAAM,MAAM,SAAS,MAAM,QAAQ;AACnC,MAAI,QAAQ,MAAM,QAAQ,QAAQ,IAAI,WAAW,KAAK,GAAG,EAAE,KAAK,WAAW,GAAG,EAAG,QAAO;AACxF,MAAI,aAAa,IAAI,QAAQ,QAAQ,EAAE,YAAY,CAAC,EAAG,QAAO;AAC9D,MAAI;AACJ,MAAI;AACF,UAAM,OAAO,MAAM,KAAK,QAAQ;AAChC,QAAI,CAAC,KAAK,OAAO,EAAG,QAAO;AAC3B,WAAO,KAAK;AAAA,EACd,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,OAAO,gBAAiB,QAAO;AACnC,QAAM,OAAO,MAAM,SAAS,QAAQ;AACpC,MAAI,SAAS,KAAM,QAAO;AAC1B,QAAM,QAAQ,KAAK,MAAM,OAAO;AAChC,MAAI,MAAM,GAAG,EAAE,MAAM,GAAI,OAAM,IAAI;AACnC,MAAI,MAAM,UAAU,WAAW,aAAa,QAAQ,WAAW,UAAW,QAAO;AAEjF,QAAM,OAAO,IAAI,QAAQ,OAAO,GAAG;AACnC,QAAM,UAAU,UAAU,MAAM,MAAM,KAAK;AAC3C,SAAO;AAAA,IACL,oBAAoB;AAAA,MAClB,eAAe;AAAA,MACf,oBAAoB;AAAA,MACpB,0BAA0B;AAAA,QACxB,yBAAyB,IAAI,OAAO,MAAM,MAAM,YAAY,KAAK,KAAK,OAAO,CAAC,CAAC;AAAA,QAC/E,YAAY,QAAQ,KAAK,IAAI,CAAC;AAAA,QAC9B;AAAA,QACA;AAAA,QACA,8DAA8D,MAAM,MAAM;AAAA,MAC5E,EAAE,KAAK,IAAI;AAAA,IACb;AAAA,EACF;AACF;AAGA,eAAe,SAAS,MAAsC;AAC5D,QAAM,SAAS,MAAM,KAAK,MAAM,GAAG;AACnC,MAAI;AACF,UAAM,UAAU,MAAM,OAAO,SAAS;AACtC,QAAI,QAAQ,SAAS,CAAC,EAAG,QAAO;AAChC,WAAO,QAAQ,SAAS,MAAM;AAAA,EAChC,UAAE;AACA,UAAM,OAAO,MAAM;AAAA,EACrB;AACF;AAEA,SAAS,UAAU,MAAc,MAAc,OAA2B;AACxE,QAAM,MAAM,CAAC,YACX,QAAQ,SAAS,WAAW,iBACxB;AAAA,IACE,GAAG,QAAQ,MAAM,GAAG,WAAW,cAAc;AAAA,IAC7C,UAAK,QAAQ,SAAS,WAAW,cAAc;AAAA,EACjD,IACA;AACN,MAAI,gBAAgB,IAAI,GAAG;AACzB,UAAM,QAAQ,mBAAmB,IAAI,EAAE;AAAA,MACrC,CAAC,WAAW,OAAO,UAAU,OAAO,YAAY,KAAK,WAAW;AAAA,IAClE;AACA,UAAM,WAAW,MAAM,OAAO,CAAC,WAAW,OAAO,SAAS,QAAQ;AAElE,UAAM,UAAU,SAAS,UAAU,WAAW,qBAAqB,WAAW;AAC9E,QAAI,QAAQ,SAAS,GAAG;AAEtB,YAAM,UAAU,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC,WAAW,OAAO,OAAO,CAAC;AACnE,aAAO;AAAA,QACL,GAAG,IAAI,QAAQ,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,KAAK,EAAE,SAAS,IAAI,EAAE,OAAO,EAAE,CAAC;AAAA,QACnE,GAAI,UAAU,MAAM,SAAS,CAAC,iBAAiB,UAAU,CAAC,IAAI,MAAM,MAAM,EAAE,IAAI,CAAC;AAAA,MACnF;AAAA,IACF;AAAA,EACF;AACA,MAAI,WAAW,KAAK,IAAI,GAAG;AACzB,UAAM,WAAW,MAAM;AAAA,MAAQ,CAAC,MAAM,MACpC,eAAe,KAAK,IAAI,IAAI,CAAC,GAAG,KAAK,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,EAAE,IAAI,CAAC;AAAA,IAC3E;AACA,QAAI,SAAS,SAAS,EAAG,QAAO,IAAI,QAAQ;AAAA,EAC9C;AACA,QAAM,SAAmB,CAAC;AAC1B,WAAS,QAAQ,GAAG,SAAS,MAAM,QAAQ,SAAS,WAAW,YAAY;AACzE,WAAO,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,MAAM,QAAQ,QAAQ,WAAW,aAAa,CAAC,CAAC,EAAE;AAAA,EACtF;AACA,SAAO,IAAI,MAAM;AACnB;;;ACpKA,eAAsB,wBAAuC;AAC3D,QAAM,SAAS,YAAY;AACzB,UAAM,WAAW,MAAM,cAAc,MAAM,cAAc,CAAC;AAC1D,QAAI,SAAU,OAAM,YAAY,KAAK,UAAU,QAAQ,CAAC;AAAA,EAC1D,CAAC;AACH;","names":[]}

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+var [command, subcommand] = process.argv.slice(2);
+if (command === "hooks" && subcommand === "lean") {
+  const { runLeanHookCommand } = await import("../lean-command-D6TZJEFX.js");
+  await runLeanHookCommand();
+} else if (command === "hooks" && subcommand === "pretool") {
+  const { runPreToolHookCommand } = await import("../pretool-command-MQQ2UNQM.js");
+  await runPreToolHookCommand();
+} else {
+  const { createCli } = await import("../main-ZZ3EQLYA.js");
+  await createCli().parseAsync();
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/index.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * Launcher. Hooks that fire on every prompt (lean) or every Read/Grep\n * (pretool) load only their own module; every other command loads the full CLI.\n */\nconst [command, subcommand] = process.argv.slice(2);\nif (command === \"hooks\" && subcommand === \"lean\") {\n  const { runLeanHookCommand } = await import(\"../hooks/lean-command.js\");\n  await runLeanHookCommand();\n} else if (command === \"hooks\" && subcommand === \"pretool\") {\n  const { runPreToolHookCommand } = await import(\"../hooks/pretool-command.js\");\n  await runPreToolHookCommand();\n} else {\n  const { createCli } = await import(\"./main.js\");\n  await createCli().parseAsync();\n}\n"],"mappings":";;;AAKA,IAAM,CAAC,SAAS,UAAU,IAAI,QAAQ,KAAK,MAAM,CAAC;AAClD,IAAI,YAAY,WAAW,eAAe,QAAQ;AAChD,QAAM,EAAE,mBAAmB,IAAI,MAAM,OAAO,6BAA0B;AACtE,QAAM,mBAAmB;AAC3B,WAAW,YAAY,WAAW,eAAe,WAAW;AAC1D,QAAM,EAAE,sBAAsB,IAAI,MAAM,OAAO,gCAA6B;AAC5E,QAAM,sBAAsB;AAC9B,OAAO;AACL,QAAM,EAAE,UAAU,IAAI,MAAM,OAAO,qBAAW;AAC9C,QAAM,UAAU,EAAE,WAAW;AAC/B;","names":[]}