@esankhan3/code-search-mcp 1.0.6 → 1.1.1

package/dist/cli/index.js

@@ -1,20 +1,28 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { existsSync, rmSync } from "node:fs";
-import { join, resolve as resolvePath } from "node:path";
+import { constants as osConstants } from "node:os";
+import { dirname, join, resolve as resolvePath, basename } from "node:path";
 import {
   resolveCodeSearchConfig,
   parseCliFlags,
   printConfig,
-  toKnowledgeConfig
+  redactSecrets,
+  toKnowledgeConfig,
+  exportDataDir
 } from "../core/config.js";
+import { validateProjectName } from "../core/project-name.js";
 import {
   indexFromPath,
   KnowledgeIndexer,
+  getBlobStore,
   getKnowledgeBasePath,
   loadProfile
 } from "@esankhan3/anvil-knowledge-core";
-import { pickBackend, daemonSocketPath } from "../backends/index.js";
+import { pickBackend, daemonSocketPath, DaemonBackend } from "../backends/index.js";
+import { configureLogger, getComponentLogger } from "../observability/logger.js";
+const log = getComponentLogger("code-search");
+const FORMATS = /* @__PURE__ */ new Set(["text", "json", "jsonl"]);
 const HELP_TEXT = `code-search \u2014 multi-repo code intelligence
 
 USAGE:
@@ -26,9 +34,14 @@ COMMANDS:
   query <text>                     hybrid search; print top-K
   status                           show index + daemon health
   reset [--project <name>]         drop the project's index
-  daemon --workspace <path>        spawn the long-running daemon
-  serve [--port N] [--auth mode]   HTTP MCP server
-  mcp                              stdio MCP server (Claude Desktop)
+  daemon --workspace <path>        run the long-running daemon
+  serve [path] [--port N] [--auth mode]   HTTP MCP server
+  mcp [path]                       stdio MCP server over local repos (default: cwd)
+  mcp --remote <url>               stdio proxy to a remote code-search server
+
+INDEX OPTIONS:
+  --project <name>                 project namespace (default: path basename)
+  --force                          full re-index
 
 QUERY OPTIONS:
   --mode hybrid|vector|bm25        retrieval mode (default: hybrid)
@@ -36,6 +49,7 @@ QUERY OPTIONS:
   --repo <name>                    restrict to a repo (repeatable)
   --format text|json|jsonl         output format (default: text)
   --project <name>                 project namespace (default: cwd basename)
+  --no-daemon                      search in-process even if a daemon is running
 
 CONFIG:
   Every leaf in CodeSearchConfig is settable via --<dotted-path>.
@@ -44,6 +58,11 @@ CONFIG:
     --retrieval.max-chunks 20
     --no-indexing.auto-index
 `;
+function usageError(msg) {
+  process.stderr.write(`code-search: ${msg}
+`);
+  process.exit(2);
+}
 async function main() {
   const argv = process.argv.slice(2);
   if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
@@ -51,8 +70,7 @@ async function main() {
     process.exit(0);
   }
   if (argv[0] === "--print-config") {
-    const { patch } = parseCliFlags(argv.slice(1));
-    const cfg = resolveCodeSearchConfig({ cli: patch });
+    const { cfg } = parseCommand("--print-config", argv.slice(1), {}, process.cwd());
     process.stdout.write(printConfig(cfg) + "\n");
     process.exit(0);
   }
@@ -79,68 +97,100 @@ ${HELP_TEXT}`);
       process.exit(2);
   }
 }
-function takeFlag(rest, name) {
-  const idx = rest.indexOf(name);
-  if (idx < 0) return void 0;
-  return rest[idx + 1];
+function parseCommand(cmd, argv, spec, workspaceDir) {
+  const { patch, rest, unknown } = parseCliFlags(argv);
+  if (unknown.length) usageError(`${cmd}: unknown flag(s): ${unknown.join(", ")}`);
+  const values = /* @__PURE__ */ new Map();
+  const bools = /* @__PURE__ */ new Set();
+  const positionals = [];
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--help" || a === "-h") {
+      process.stdout.write(HELP_TEXT);
+      process.exit(0);
+    }
+    if (spec.values?.includes(a)) {
+      const v = rest[i + 1];
+      if (v === void 0 || v.startsWith("--")) usageError(`${cmd}: ${a} needs a value`);
+      values.set(a, [...values.get(a) ?? [], v]);
+      i++;
+    } else if (spec.bools?.includes(a)) {
+      bools.add(a);
+    } else if (a.startsWith("-") && a.length > 1 && Number.isNaN(Number(a))) {
+      usageError(`${cmd}: unknown flag ${a}`);
+    } else {
+      positionals.push(a);
+    }
+  }
+  if (spec.maxPositionals !== void 0 && positionals.length > spec.maxPositionals) {
+    usageError(`${cmd}: unexpected argument(s): ${positionals.slice(spec.maxPositionals).join(" ")}`);
+  }
+  const cfg = resolveCodeSearchConfig({ cli: patch, workspaceDir: workspaceDir ?? positionals[0] ?? process.cwd() });
+  configureLogger({ structured: cfg.telemetry.structuredLogs });
+  return { cfg, values, bools, positionals };
 }
-function projectFromPath(p) {
-  return resolvePath(p).split("/").filter(Boolean).pop() || "project";
+function flag(p, name) {
+  const v = p.values.get(name);
+  return v?.[v.length - 1];
+}
+function projectArg(p, fallbackDir) {
+  const name = flag(p, "--project") ?? basename(resolvePath(fallbackDir));
+  try {
+    return validateProjectName(name);
+  } catch (err) {
+    usageError(err.message);
+  }
 }
 async function cmdIndex(rest) {
-  const { patch, rest: positional } = parseCliFlags(rest);
-  const path = positional.find((a) => !a.startsWith("--")) ?? process.cwd();
-  const cfg = resolveCodeSearchConfig({ cli: patch, workspaceDir: path });
-  const project = takeFlag(positional, "--project") ?? projectFromPath(path);
-  const force = positional.includes("--force");
-  process.stderr.write(`[code-search] indexing ${path} as project "${project}"...
-`);
-  const stats = await indexFromPath(project, resolvePath(path), {
-    force,
-    config: toKnowledgeConfig(cfg),
-    onProgress: (m) => process.stderr.write(`[code-search] ${m}
-`)
+  const p = parseCommand("index", rest, { values: ["--project"], bools: ["--force"], maxPositionals: 1 });
+  const path = resolvePath(p.positionals[0] ?? process.cwd());
+  exportDataDir(p.cfg);
+  const project = projectArg(p, path);
+  const knowledge = toKnowledgeConfig(p.cfg);
+  log.info(`indexing ${path} as project "${project}"...`);
+  const stats = await indexFromPath(project, path, {
+    force: p.bools.has("--force"),
+    config: knowledge,
+    onProgress: (m) => log.info(m)
   });
+  const rollup = await new KnowledgeIndexer().getStats(project, knowledge);
   process.stdout.write(JSON.stringify({
     project,
     chunks: stats.totalChunks,
     repos: stats.repos.length,
-    crossRepoEdges: stats.crossRepoEdges,
+    crossRepoEdges: rollup.crossRepoEdges,
     durationMs: stats.indexDurationMs
   }, null, 2) + "\n");
 }
 const VALID_MODES = /* @__PURE__ */ new Set(["hybrid", "vector", "bm25"]);
 async function cmdQuery(rest) {
-  const { patch, rest: positional } = parseCliFlags(rest);
-  const queryText = positional.find((a) => !a.startsWith("--") && !a.startsWith("-"));
-  if (!queryText) {
-    process.stderr.write("code-search query: missing <text>\n");
-    process.exit(2);
-  }
-  const rawMode = takeFlag(positional, "--mode") ?? "hybrid";
+  const p = parseCommand("query", rest, {
+    values: ["--project", "--mode", "--top-k", "--format", "--repo"],
+    bools: ["--no-daemon"]
+  }, process.cwd());
+  const queryText = p.positionals.join(" ");
+  if (!queryText) usageError("query: missing <text>");
+  const rawMode = flag(p, "--mode") ?? "hybrid";
   if (!VALID_MODES.has(rawMode)) {
-    process.stderr.write(
-      `code-search query: invalid --mode "${rawMode}". Valid modes: ${[...VALID_MODES].join(", ")}.
-`
-    );
-    process.exit(2);
+    usageError(`query: invalid --mode "${rawMode}". Valid modes: ${[...VALID_MODES].join(", ")}.`);
   }
   const mode = rawMode;
-  const topK = parseInt(takeFlag(positional, "--top-k") ?? "10", 10);
-  const repos = positional.reduce((acc, a, i) => {
-    if (a === "--repo" && positional[i + 1]) acc.push(positional[i + 1]);
-    return acc;
-  }, []);
-  const format = takeFlag(positional, "--format") ?? "text";
-  const project = takeFlag(positional, "--project") ?? projectFromPath(process.cwd());
-  const cfg = resolveCodeSearchConfig({ cli: patch });
-  const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
+  const rawTopK = flag(p, "--top-k") ?? "10";
+  if (!/^\d+$/.test(rawTopK) || parseInt(rawTopK, 10) < 1) {
+    usageError(`query: invalid --top-k "${rawTopK}" (a positive integer).`);
+  }
+  const topK = parseInt(rawTopK, 10);
+  const format = flag(p, "--format") ?? "text";
+  if (!FORMATS.has(format)) usageError(`query: invalid --format "${format}". Valid formats: ${[...FORMATS].join(", ")}.`);
+  const repos = p.values.get("--repo") ?? [];
+  exportDataDir(p.cfg);
+  const project = projectArg(p, process.cwd());
   const backend = await pickBackend({
     project,
     workspaceDir: process.cwd(),
-    knowledge: toKnowledgeConfig(cfg),
-    preferDaemon: !cfg.daemon.disabled,
-    socketPath
+    knowledge: toKnowledgeConfig(p.cfg),
+    preferDaemon: !p.cfg.daemon.disabled && !p.bools.has("--no-daemon"),
+    socketPath: daemonSocketPath(p.cfg.storage.dataDir, project)
   });
   const result = await backend.search(queryText, {
     mode,
@@ -174,37 +224,44 @@ function printSearchResult(result, format) {
   }
 }
 async function cmdStatus(rest) {
-  const { patch } = parseCliFlags(rest);
-  const cfg = resolveCodeSearchConfig({ cli: patch });
-  const project = takeFlag(rest, "--project") ?? projectFromPath(process.cwd());
-  const indexer = new KnowledgeIndexer();
-  const stats = await indexer.getStats(project);
-  const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
-  const profilesAvailable = await Promise.all(
-    stats.repos.map(async (r) => ({ name: r.name, hasProfile: !!await loadProfile(project, r.name) }))
-  );
+  const p = parseCommand("status", rest, { values: ["--project"], maxPositionals: 0 }, process.cwd());
+  exportDataDir(p.cfg);
+  const project = projectArg(p, process.cwd());
+  const knowledge = toKnowledgeConfig(p.cfg);
+  const socketPath = daemonSocketPath(p.cfg.storage.dataDir, project);
+  const daemonAlive = await new DaemonBackend({ project, workspaceDir: null, knowledge, preferDaemon: true, socketPath }).ping();
+  const blobs = getBlobStore(project, knowledge);
+  const indexed = await blobs.exists("index_stats.json") || await blobs.exists("lancedb");
+  const stats = indexed ? await new KnowledgeIndexer().getStats(project, knowledge) : null;
+  const profilesAvailable = stats ? await Promise.all(stats.repos.map(async (r) => ({ name: r.name, hasProfile: !!await loadProfile(project, r.name, knowledge) }))) : [];
   process.stdout.write(JSON.stringify({
     project,
-    dataDir: cfg.storage.dataDir,
+    dataDir: p.cfg.storage.dataDir,
+    ...p.cfg.storage.backends ? { storageBackends: redactSecrets(p.cfg.storage.backends) } : { kbPath: getKnowledgeBasePath(project) },
+    indexed,
     daemonSocket: socketPath,
-    daemonAlive: existsSync(socketPath),
-    totalChunks: stats.totalChunks,
-    embeddingProvider: stats.embeddingProvider,
-    lastIndexedAt: stats.lastIndexed || null,
-    repos: stats.repos,
+    daemonAlive,
+    totalChunks: stats?.totalChunks ?? 0,
+    embeddingProvider: stats?.embeddingProvider ?? null,
+    lastIndexedAt: stats?.lastIndexed || null,
+    repos: stats?.repos ?? [],
     profilesAvailable
   }, null, 2) + "\n");
 }
 async function cmdReset(rest) {
-  const project = takeFlag(rest, "--project") ?? projectFromPath(process.cwd());
-  const basePath = getKnowledgeBasePath(project);
+  const p = parseCommand("reset", rest, { values: ["--project"], maxPositionals: 0 }, process.cwd());
+  exportDataDir(p.cfg);
+  const project = projectArg(p, process.cwd());
+  const dataDir = p.cfg.storage.dataDir;
+  const basePath = resolvePath(getKnowledgeBasePath(project));
+  if (dirname(basePath) !== dataDir) {
+    usageError(`reset: refusing to remove ${basePath} \u2014 not a project directory inside ${dataDir}`);
+  }
   if (existsSync(basePath)) {
     rmSync(basePath, { recursive: true, force: true });
-    process.stderr.write(`[code-search] removed ${basePath}
-`);
+    log.info(`removed ${basePath}`);
   } else {
-    process.stderr.write(`[code-search] nothing to remove at ${basePath}
-`);
+    log.info(`nothing to remove at ${basePath}`);
   }
 }
 async function cmdDaemon(rest) {
@@ -214,18 +271,28 @@ async function cmdDaemon(rest) {
     stdio: "inherit",
     detached: false
   });
-  child.on("exit", (code) => process.exit(code ?? 0));
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(sig, () => {
+      try {
+        child.kill(sig);
+      } catch {
+      }
+    });
+  }
+  child.on("exit", (code, signal) => {
+    process.exit(code ?? 128 + (signal ? osConstants.signals[signal] ?? 0 : 0));
+  });
 }
 async function cmdServe(rest) {
   process.argv = [process.argv[0], process.argv[1], "--serve", ...rest];
   await import("../index.js");
 }
 async function cmdMcp(rest) {
-  process.argv = [process.argv[0], process.argv[1], ...rest];
+  const remote = rest.includes("--remote") || rest.some((a) => /^https?:\/\//.test(a));
+  process.argv = [process.argv[0], process.argv[1], ...remote ? [] : ["--local"], ...rest];
   await import("../index.js");
 }
 main().catch((err) => {
-  process.stderr.write(`code-search fatal: ${err instanceof Error ? err.stack : err}
-`);
+  log.error(`fatal: ${err instanceof Error ? err.stack : err}`);
   process.exit(1);
 });

package/dist/core/config.js

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { homedir, tmpdir } from "node:os";
+import { Logger } from "../observability/logger.js";
 function defaultDataDir() {
-  return process.env.CODE_SEARCH_DATA_DIR ?? join(homedir(), ".code-search", "index");
+  return process.env.CODE_SEARCH_DATA_DIR ?? join(process.env.ANVIL_HOME || join(homedir(), ".anvil"), "knowledge-base");
 }
 const DEFAULTS = {
   server: {
@@ -59,7 +60,6 @@ const DEFAULTS = {
     recordQueries: false
   },
   daemon: {
-    autoSpawn: false,
     disabled: false
   }
 };
@@ -159,14 +159,16 @@ function parseHeaders(s) {
   }
   return Object.keys(out).length ? out : void 0;
 }
-function parseReindexMs(raw) {
-  if (!raw || raw === "0" || raw === "none") return 0;
-  const m = raw.match(/^(\d+)(m|h)$/);
-  if (!m) {
-    const n = parseInt(raw, 10);
-    return Number.isFinite(n) ? n : 0;
+function parseReindexInterval(raw) {
+  if (raw === void 0 || raw === null || raw === "" || raw === 0 || raw === "0" || raw === "none") return 0;
+  const s = String(raw).trim();
+  const unit = s.match(/^(\d+)(m|h)$/);
+  if (unit) return parseInt(unit[1], 10) * (unit[2] === "h" ? 36e5 : 6e4);
+  if (/^\d+$/.test(s)) {
+    const ms = parseInt(s, 10);
+    return ms >= 6e4 ? ms : null;
   }
-  return m[2] === "h" ? parseInt(m[1], 10) * 60 * 6e4 : parseInt(m[1], 10) * 6e4;
+  return null;
 }
 function envStorageBackends(env) {
   const blobBackend = env("STORAGE_BLOB_BACKEND");
@@ -220,7 +222,7 @@ function envLayer() {
     server: {
       transport,
       port: port ? parseInt(port, 10) : void 0,
-      host: env("HOST") ?? (authMode === "none" || !authMode ? void 0 : "0.0.0.0")
+      host: env("HOST")
     },
     auth: {
       mode: authMode,
@@ -253,7 +255,8 @@ function envLayer() {
     },
     indexing: {
       autoIndex: env("AUTO_INDEX") !== void 0 ? env("AUTO_INDEX") !== "false" && env("AUTO_INDEX") !== "0" : void 0,
-      reindexIntervalMs: env("REINDEX_INTERVAL") !== void 0 ? parseReindexMs(env("REINDEX_INTERVAL")) : void 0,
+      // Raw string; normalised (and validated) by the resolver for every layer.
+      reindexIntervalMs: env("REINDEX_INTERVAL"),
       chunking: {
         maxTokens: chunkMaxTokens ? parseInt(chunkMaxTokens, 10) : void 0
       },
@@ -278,7 +281,6 @@ function envLayer() {
       recordQueries: env("TELEMETRY_RECORD_QUERIES") === "1" || env("TELEMETRY_RECORD_QUERIES") === "true" ? true : void 0
     },
     daemon: {
-      autoSpawn: env("DAEMON_AUTO_SPAWN") === "1" || env("DAEMON_AUTO_SPAWN") === "true" ? true : void 0,
       disabled: env("DAEMON_DISABLED") === "1" || env("DAEMON_DISABLED") === "true" ? true : void 0
     }
   };
@@ -296,30 +298,64 @@ const RESERVED_FLAGS = /* @__PURE__ */ new Set([
   "--force",
   "--workspace",
   "--no-daemon",
-  "--auto-spawn-daemon",
-  "--config",
   "--format",
   "--top-k",
   "--mode",
-  "--repo",
-  "--language"
+  "--repo"
 ]);
+const ROOT_ALIASES = {
+  "--port": ["server", "port"],
+  "--host": ["server", "host"],
+  "--transport": ["server", "transport"],
+  "--auth": ["auth", "mode"]
+};
+const OPTIONAL_LEAVES = [
+  "auth.jwtSecret",
+  "embedding.model",
+  "embedding.apiKey",
+  "embedding.baseUrl",
+  "embedding.ollamaHost",
+  "reranker.model",
+  "reranker.apiKey",
+  "reranker.baseUrl",
+  "reranker.timeoutMs",
+  "llm.apiKey",
+  "llm.baseUrl",
+  "github.token",
+  "telemetry.otelEndpoint"
+];
+const OPEN_SUBTREES = ["storage.backends.", "telemetry.otelHeaders."];
+function leafPaths(obj, prefix, out) {
+  for (const [k, v] of Object.entries(obj)) {
+    if (isPlainObject(v)) leafPaths(v, `${prefix}${k}.`, out);
+    else out.add(`${prefix}${k}`);
+  }
+  return out;
+}
+const KNOWN_LEAVES = leafPaths(DEFAULTS, "", new Set(OPTIONAL_LEAVES));
+function isKnownPath(path) {
+  return KNOWN_LEAVES.has(path) || OPEN_SUBTREES.some((p) => path.startsWith(p));
+}
 function parseCliFlags(argv) {
   const patch = {};
   const rest = [];
+  const unknown = [];
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (!arg.startsWith("--") || RESERVED_FLAGS.has(arg)) {
       rest.push(arg);
       continue;
     }
-    let key = arg.slice(2);
+    let path = ROOT_ALIASES[arg];
     let negate = false;
-    if (key.startsWith("no-")) {
-      negate = true;
-      key = key.slice(3);
+    if (!path) {
+      let key = arg.slice(2);
+      if (key.startsWith("no-")) {
+        negate = true;
+        key = key.slice(3);
+      }
+      path = key.split(".").map((seg) => seg.replace(/-([a-z])/g, (_, c) => c.toUpperCase()));
     }
-    const path = key.split(".").map((seg) => seg.replace(/-([a-z])/g, (_, c) => c.toUpperCase()));
     let val;
     if (negate) {
       val = false;
@@ -328,9 +364,13 @@ function parseCliFlags(argv) {
     } else {
       val = true;
     }
+    if (!isKnownPath(path.join("."))) {
+      unknown.push(arg);
+      continue;
+    }
     setDeep(patch, path, val);
   }
-  return { patch, rest };
+  return { patch, rest, unknown };
 }
 function setDeep(obj, path, value) {
   let cur = obj;
@@ -347,10 +387,33 @@ function resolveCodeSearchConfig(opts = {}) {
   const yaml2 = opts.workspaceDir ? loadYamlFile(join(opts.workspaceDir, ".code-search.yaml")) ?? {} : {};
   const env = envLayer();
   const cli = opts.cli ?? {};
-  const cfg = deepMerge(DEFAULTS, yaml1, yaml2, env, cli);
+  const layers = [yaml1, yaml2, env, cli];
+  const cfg = deepMerge(
+    structuredClone(DEFAULTS),
+    ...layers
+  );
+  if (cfg.auth.mode !== "none" && !layers.some((l) => l.server?.host !== void 0)) {
+    cfg.server.host = "0.0.0.0";
+  }
+  const rawInterval = cfg.indexing.reindexIntervalMs;
+  const intervalMs = parseReindexInterval(rawInterval);
+  if (intervalMs === null) {
+    warnOnce(cfg, `[code-search] invalid reindex interval ${JSON.stringify(String(rawInterval))} (use 30m, 1h, \u2026 \u2014 at least one minute \u2014 or 0); auto-reindex disabled`);
+  }
+  cfg.indexing.reindexIntervalMs = intervalMs ?? 0;
+  cfg.storage.dataDir = resolve(cfg.storage.dataDir);
   bridgeLegacyEnvVars(cfg);
   return cfg;
 }
+const warned = /* @__PURE__ */ new Set();
+function warnOnce(cfg, msg) {
+  if (warned.has(msg)) return;
+  warned.add(msg);
+  new Logger({ structured: cfg.telemetry.structuredLogs }).warn(msg);
+}
+function exportDataDir(cfg) {
+  process.env.CODE_SEARCH_DATA_DIR = cfg.storage.dataDir;
+}
 function bridgeLegacyEnvVars(cfg) {
   process.env.ANVIL_LLM_MODE ??= process.env.CODE_SEARCH_LLM_MODE ?? cfg.llm.mode;
   process.env.ANVIL_LLM_PROVIDER ??= process.env.CODE_SEARCH_LLM_PROVIDER ?? cfg.llm.provider;
@@ -362,7 +425,7 @@ function bridgeLegacyEnvVars(cfg) {
 function toKnowledgeConfig(c) {
   return {
     embedding: { ...c.embedding },
-    chunking: { ...c.indexing.chunking },
+    chunking: { ...c.indexing.chunking, ignorePatterns: c.indexing.ignorePatterns },
     retrieval: {
       maxChunks: c.retrieval.maxChunks,
       maxTokens: c.retrieval.maxTokens,
@@ -373,23 +436,29 @@ function toKnowledgeConfig(c) {
     ...c.storage.backends ? { storage: c.storage.backends } : {}
   };
 }
-const SECRET_KEYS = /* @__PURE__ */ new Set([
-  "apiKey",
-  "jwtSecret",
-  "token",
-  "githubToken"
-]);
+const SECRET_KEY = /pass(word)?|secret|token|authorization|api[-_]?keys?|credential/i;
+const URI_USERINFO = /([a-z][a-z0-9+.-]*:\/\/)([^/\s@]+)@/gi;
+function redactString(v) {
+  return `***redacted (${v.length} chars)`;
+}
 function redactSecrets(value, parentKey = "") {
+  if (typeof value === "string") {
+    return value.replace(URI_USERINFO, (_m, scheme, info) => {
+      const colon = info.indexOf(":");
+      return `${scheme}${colon >= 0 ? info.slice(0, colon + 1) : ""}***@`;
+    });
+  }
   if (Array.isArray(value)) {
     return value.map((v) => redactSecrets(v, parentKey));
   }
   if (isPlainObject(value)) {
     const out = {};
     for (const [k, v] of Object.entries(value)) {
-      if (SECRET_KEYS.has(k) && typeof v === "string" && v.length > 0) {
-        out[k] = `***redacted (${v.length} chars)`;
-      } else if (k === "apiKeys" && Array.isArray(v)) {
-        out[k] = v.map((s) => `***redacted (${s.length} chars)`);
+      const secret = SECRET_KEY.test(k) || parentKey === "otelHeaders";
+      if (secret && typeof v === "string" && v.length > 0) {
+        out[k] = redactString(v);
+      } else if (secret && Array.isArray(v)) {
+        out[k] = v.map((s) => typeof s === "string" ? redactString(s) : redactSecrets(s, k));
       } else {
         out[k] = redactSecrets(v, k);
       }
@@ -403,7 +472,9 @@ function printConfig(c) {
 }
 export {
   DEFAULTS,
+  exportDataDir,
   parseCliFlags,
+  parseReindexInterval,
   printConfig,
   redactSecrets,
   resolveCodeSearchConfig,

package/dist/core/env-config.js

@@ -1,13 +1,12 @@
 import { execSync as _execSync } from "node:child_process";
 import {
   resolveCodeSearchConfig,
-  parseCliFlags,
   toKnowledgeConfig
 } from "./config.js";
 import { normalizeRerankerConfig } from "@esankhan3/anvil-knowledge-core";
 let _config = null;
 function resolveLlmMode(explicit, apiKey, claudeBin) {
-  if (explicit && explicit !== "none") {
+  if (explicit === "cli" || explicit === "api" || explicit === "none") {
     if (explicit === "api" && !apiKey) {
       console.error(
         `[code-search-mcp] WARNING: LLM_MODE=api but no API key found. Set CODE_SEARCH_LLM_API_KEY or ANTHROPIC_API_KEY. Falling back to LLM_MODE=none.`
@@ -32,10 +31,9 @@ function resolvedKnowledgeConfig() {
 }
 function loadServerConfig(opts) {
   if (_config) return _config;
-  const cli = opts?.argv ? parseCliFlags(opts.argv).patch : void 0;
-  const c = resolveCodeSearchConfig({ cli, workspaceDir: opts?.workspaceDir });
+  const c = resolveCodeSearchConfig({ cli: opts?.cli, workspaceDir: opts?.workspaceDir });
   const rerankerStruct = normalizeRerankerConfig(c.reranker);
-  const llmMode = resolveLlmMode(c.llm.mode, c.llm.apiKey, c.llm.claudeBin);
+  const llmMode = resolveLlmMode(process.env.ANVIL_LLM_MODE ?? c.llm.mode, c.llm.apiKey, c.llm.claudeBin);
   _config = {
     port: c.server.port,
     host: c.server.host,

package/dist/core/project-name.js

@@ -0,0 +1,12 @@
+const RESERVED = /* @__PURE__ */ new Set(["daemon", "projects"]);
+function validateProjectName(name) {
+  if (!name || name === "." || name === ".." || /[/\\\0]/.test(name) || RESERVED.has(name)) {
+    throw new Error(
+      `Invalid project name ${JSON.stringify(name)}: a project name must be a single path segment (no "/" or "\\", not "." or "..") and not one of the reserved names: ${[...RESERVED].join(", ")}.`
+    );
+  }
+  return name;
+}
+export {
+  validateProjectName
+};

package/dist/core/version.js

@@ -0,0 +1,5 @@
+import { readFileSync } from "node:fs";
+const PACKAGE_VERSION = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8")).version;
+export {
+  PACKAGE_VERSION
+};