@esankhan3/code-search-mcp 0.0.2 → 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,231 @@
+#!/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 {
+  resolveCodeSearchConfig,
+  parseCliFlags,
+  printConfig,
+  toKnowledgeConfig
+} from "../core/config.js";
+import {
+  indexFromPath,
+  KnowledgeIndexer,
+  getKnowledgeBasePath,
+  loadProfile
+} from "@esankhan3/anvil-knowledge-core";
+import { pickBackend, daemonSocketPath } from "../backends/index.js";
+const HELP_TEXT = `code-search \u2014 multi-repo code intelligence
+
+USAGE:
+  code-search <command> [options]
+  code-search --print-config       print resolved configuration (secrets redacted)
+
+COMMANDS:
+  index [path]                     index a directory (default: cwd)
+  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)
+
+QUERY OPTIONS:
+  --mode hybrid|vector|bm25        retrieval mode (default: hybrid)
+  --top-k N                        max results (default: 10)
+  --repo <name>                    restrict to a repo (repeatable)
+  --format text|json|jsonl         output format (default: text)
+  --project <name>                 project namespace (default: cwd basename)
+
+CONFIG:
+  Every leaf in CodeSearchConfig is settable via --<dotted-path>.
+  Examples:
+    --embedding.provider codestral
+    --retrieval.max-chunks 20
+    --no-indexing.auto-index
+`;
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(HELP_TEXT);
+    process.exit(0);
+  }
+  if (argv[0] === "--print-config") {
+    const { patch } = parseCliFlags(argv.slice(1));
+    const cfg = resolveCodeSearchConfig({ cli: patch });
+    process.stdout.write(printConfig(cfg) + "\n");
+    process.exit(0);
+  }
+  const sub = argv[0];
+  const rest = argv.slice(1);
+  switch (sub) {
+    case "index":
+      return await cmdIndex(rest);
+    case "query":
+      return await cmdQuery(rest);
+    case "status":
+      return await cmdStatus(rest);
+    case "reset":
+      return await cmdReset(rest);
+    case "daemon":
+      return await cmdDaemon(rest);
+    case "serve":
+      return await cmdServe(rest);
+    case "mcp":
+      return await cmdMcp(rest);
+    default:
+      process.stderr.write(`unknown subcommand: ${sub}
+${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 projectFromPath(p) {
+  return resolvePath(p).split("/").filter(Boolean).pop() || "project";
+}
+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}
+`)
+  });
+  process.stdout.write(JSON.stringify({
+    project,
+    chunks: stats.totalChunks,
+    repos: stats.repos.length,
+    crossRepoEdges: stats.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";
+  if (!VALID_MODES.has(rawMode)) {
+    process.stderr.write(
+      `code-search query: invalid --mode "${rawMode}". Valid modes: ${[...VALID_MODES].join(", ")}.
+`
+    );
+    process.exit(2);
+  }
+  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 backend = await pickBackend({
+    project,
+    workspaceDir: process.cwd(),
+    knowledge: toKnowledgeConfig(cfg),
+    preferDaemon: !cfg.daemon.disabled,
+    socketPath
+  });
+  const result = await backend.search(queryText, {
+    mode,
+    maxResults: topK,
+    repos: repos.length ? repos : void 0
+  });
+  await backend.close();
+  printSearchResult(result, format);
+}
+function printSearchResult(result, format) {
+  if (format === "json") {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    return;
+  }
+  if (format === "jsonl") {
+    for (const c of result.chunks) process.stdout.write(JSON.stringify(c) + "\n");
+    return;
+  }
+  if (result.chunks.length === 0) {
+    process.stdout.write(`No results for "${result.query}"
+`);
+    return;
+  }
+  let i = 0;
+  for (const c of result.chunks) {
+    i++;
+    process.stdout.write(
+      `### ${i}. ${c.repoName}/${c.filePath}:${c.startLine}-${c.endLine} (score: ${c.score.toFixed(3)}, source: ${c.source})
+\`\`\`` + c.language + "\n" + c.content + "\n```\n\n"
+    );
+  }
+}
+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);
+  process.stdout.write(JSON.stringify({
+    project,
+    dataDir: cfg.storage.dataDir,
+    daemonSocket: socketPath,
+    daemonAlive: existsSync(socketPath),
+    totalChunks: stats.totalChunks,
+    embeddingProvider: stats.embeddingProvider,
+    lastIndexedAt: stats.lastIndexed || null,
+    repos: stats.repos,
+    profilesAvailable: stats.repos.map((r) => ({
+      name: r.name,
+      hasProfile: !!loadProfile(project, r.name)
+    }))
+  }, null, 2) + "\n");
+}
+async function cmdReset(rest) {
+  const project = takeFlag(rest, "--project") ?? projectFromPath(process.cwd());
+  const basePath = getKnowledgeBasePath(project);
+  if (existsSync(basePath)) {
+    rmSync(basePath, { recursive: true, force: true });
+    process.stderr.write(`[code-search] removed ${basePath}
+`);
+  } else {
+    process.stderr.write(`[code-search] nothing to remove at ${basePath}
+`);
+  }
+}
+async function cmdDaemon(rest) {
+  const here = new URL(import.meta.url);
+  const daemonEntry = join(new URL("..", here).pathname, "daemon", "index.js");
+  const child = spawn(process.execPath, [daemonEntry, ...rest], {
+    stdio: "inherit",
+    detached: false
+  });
+  child.on("exit", (code) => process.exit(code ?? 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];
+  await import("../index.js");
+}
+main().catch((err) => {
+  process.stderr.write(`code-search fatal: ${err instanceof Error ? err.stack : err}
+`);
+  process.exit(1);
+});

package/dist/core/config.js

@@ -1,59 +1,372 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-const DEFAULT_CONFIG = {
-  embedding: { provider: "auto", dimensions: 1024 },
-  chunking: { maxTokens: 500, contextEnrichment: "structural" },
+function defaultDataDir() {
+  return process.env.CODE_SEARCH_DATA_DIR ?? join(homedir(), ".code-search", "index");
+}
+const DEFAULTS = {
+  server: {
+    transport: "stdio",
+    port: 3100,
+    host: "127.0.0.1"
+  },
+  auth: {
+    mode: "none",
+    apiKeys: [],
+    jwtSecret: void 0,
+    jwtIssuer: "code-search-mcp",
+    rateLimitPerMinute: 100
+  },
+  storage: {
+    dataDir: defaultDataDir()
+  },
+  embedding: {
+    provider: "auto",
+    dimensions: 1024
+  },
+  reranker: {
+    provider: "ollama"
+  },
   retrieval: {
-    maxChunks: 20,
+    maxChunks: 8,
     maxTokens: 12e3,
-    hybridWeights: { vector: 0.5, bm25: 0.3, graph: 0.2 },
-    reranker: "ollama"
+    hybridWeights: { vector: 0.5, bm25: 0.3, graph: 0.2 }
   },
-  autoIndex: true
+  indexing: {
+    autoIndex: true,
+    reindexIntervalMs: 0,
+    chunking: { maxTokens: 500, contextEnrichment: "structural" },
+    respectGitignore: true,
+    debounceMs: 500,
+    ignorePatterns: ["node_modules", ".git", "dist", "build", ".next", "__pycache__", ".venv", "vendor", "target"]
+  },
+  llm: {
+    mode: "none",
+    provider: "anthropic",
+    model: "sonnet",
+    apiKey: void 0,
+    baseUrl: void 0,
+    claudeBin: "claude"
+  },
+  github: {
+    token: void 0
+  },
+  telemetry: {
+    otelEndpoint: void 0,
+    otelHeaders: void 0,
+    metricsEnabled: false,
+    structuredLogs: false,
+    recordQueries: false
+  },
+  daemon: {
+    autoSpawn: false,
+    disabled: false
+  }
 };
-function loadKnowledgeConfig(project) {
-  const anvilHome = process.env.ANVIL_HOME || join(homedir(), ".anvil");
-  const paths = [
-    join(anvilHome, "projects", project, "factory.yaml"),
-    join(anvilHome, "projects", project, "project.yaml")
-  ];
-  for (const p of paths) {
-    if (!existsSync(p)) continue;
-    try {
-      const raw = readFileSync(p, "utf-8");
-      return parseKnowledgeSection(raw);
-    } catch {
-    }
-  }
-  return { ...DEFAULT_CONFIG };
-}
-function parseKnowledgeSection(yaml) {
-  const config = { ...DEFAULT_CONFIG };
-  const providerMatch = yaml.match(/^\s{4}provider:\s+(\S+)/m);
-  if (providerMatch) {
-    config.embedding = { ...config.embedding, provider: providerMatch[1] };
-  }
-  const modelMatch = yaml.match(/^\s{4}model:\s+(\S+)/m);
-  if (modelMatch) config.embedding.model = modelMatch[1];
-  const dimMatch = yaml.match(/^\s{4}dimensions:\s+(\d+)/m);
-  if (dimMatch) config.embedding.dimensions = parseInt(dimMatch[1], 10);
-  const chunkMatch = yaml.match(/^\s{4}max_tokens:\s+(\d+)/m);
-  if (chunkMatch) config.chunking.maxTokens = parseInt(chunkMatch[1], 10);
-  const enrichMatch = yaml.match(/^\s{4}context_enrichment:\s+(\S+)/m);
-  if (enrichMatch) config.chunking.contextEnrichment = enrichMatch[1];
-  const autoMatch = yaml.match(/^\s{2}auto_index:\s+(true|false)/m);
-  if (autoMatch) config.autoIndex = autoMatch[1] === "true";
-  return config;
-}
-function getKnowledgeBasePath(project) {
-  const dataDir = process.env.CODE_SEARCH_DATA_DIR;
-  if (dataDir) return join(dataDir, project);
-  const anvilHome = process.env.ANVIL_HOME || join(homedir(), ".anvil");
-  return join(anvilHome, "knowledge-base", project);
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(base, ...patches) {
+  const out = { ...base };
+  for (const p of patches) {
+    if (!p) continue;
+    for (const [k, v] of Object.entries(p)) {
+      if (v === void 0) continue;
+      if (isPlainObject(v) && isPlainObject(out[k])) {
+        out[k] = deepMerge(out[k], v);
+      } else {
+        out[k] = v;
+      }
+    }
+  }
+  return out;
+}
+function parseYaml(src) {
+  const lines = src.split(/\r?\n/);
+  const root = {};
+  const stack = [{ obj: root, indent: -1 }];
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/#.*$/, "").replace(/\s+$/, "");
+    if (!line.trim()) continue;
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+    const colon = trimmed.indexOf(":");
+    if (colon < 0) continue;
+    const key = trimmed.slice(0, colon).trim();
+    const valRaw = trimmed.slice(colon + 1).trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) stack.pop();
+    const parent = stack[stack.length - 1].obj;
+    if (!valRaw) {
+      const child = {};
+      parent[key] = child;
+      stack.push({ obj: child, indent });
+      continue;
+    }
+    parent[key] = coerce(valRaw);
+  }
+  return root;
+}
+function coerce(raw) {
+  let v = raw;
+  if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+    return v.slice(1, -1);
+  }
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v === "null" || v === "~") return null;
+  if (/^-?\d+$/.test(v)) return parseInt(v, 10);
+  if (/^-?\d+\.\d+$/.test(v)) return parseFloat(v);
+  if (v.startsWith("[") && v.endsWith("]")) {
+    return v.slice(1, -1).split(",").map((s) => coerce(s.trim()));
+  }
+  if (v.startsWith("{") && v.endsWith("}")) {
+    const o = {};
+    for (const part of v.slice(1, -1).split(",")) {
+      const [k, x] = part.split(":");
+      if (k && x !== void 0) o[k.trim()] = coerce(x.trim());
+    }
+    return o;
+  }
+  if (v.startsWith("~")) return v.replace(/^~/, homedir());
+  return v;
+}
+function snakeToCamel(obj) {
+  if (Array.isArray(obj)) return obj.map(snakeToCamel);
+  if (!isPlainObject(obj)) return obj;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const camel = k.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+    out[camel] = snakeToCamel(v);
+  }
+  return out;
+}
+function loadYamlFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const src = readFileSync(path, "utf-8");
+    const raw = parseYaml(src);
+    return snakeToCamel(raw);
+  } catch {
+    return null;
+  }
+}
+function parseHeaders(s) {
+  if (!s) return void 0;
+  const out = {};
+  for (const pair of s.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) out[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+  }
+  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;
+  }
+  return m[2] === "h" ? parseInt(m[1], 10) * 60 * 6e4 : parseInt(m[1], 10) * 6e4;
+}
+function envLayer() {
+  const env = (k) => process.env[`CODE_SEARCH_${k}`];
+  const authMode = env("AUTH_MODE");
+  const transport = env("TRANSPORT");
+  const port = env("PORT");
+  const rateLimit = env("RATE_LIMIT_PER_MINUTE");
+  const maxChunks = env("RETRIEVAL_MAX_CHUNKS");
+  const maxTokens = env("RETRIEVAL_MAX_TOKENS");
+  const chunkMaxTokens = env("CHUNKING_MAX_TOKENS");
+  const debounce = env("INDEXING_DEBOUNCE_MS");
+  const embedDims = env("EMBEDDING_DIMENSIONS");
+  return {
+    server: {
+      transport,
+      port: port ? parseInt(port, 10) : void 0,
+      host: env("HOST") ?? (authMode === "none" || !authMode ? void 0 : "0.0.0.0")
+    },
+    auth: {
+      mode: authMode,
+      apiKeys: env("AUTH_API_KEYS")?.split(",").map((s) => s.trim()).filter(Boolean),
+      jwtSecret: env("AUTH_JWT_SECRET"),
+      jwtIssuer: env("AUTH_JWT_ISSUER"),
+      rateLimitPerMinute: rateLimit ? parseInt(rateLimit, 10) : void 0
+    },
+    storage: {
+      dataDir: env("DATA_DIR")
+    },
+    embedding: {
+      provider: env("EMBEDDING_PROVIDER"),
+      model: env("EMBEDDING_MODEL"),
+      dimensions: embedDims ? parseInt(embedDims, 10) : void 0,
+      apiKey: env("EMBEDDING_API_KEY"),
+      baseUrl: env("EMBEDDING_BASE_URL"),
+      ollamaHost: env("OLLAMA_HOST") ?? process.env.OLLAMA_HOST
+    },
+    reranker: {
+      provider: env("RERANKER_PROVIDER"),
+      model: env("RERANKER_MODEL"),
+      apiKey: env("RERANKER_API_KEY"),
+      baseUrl: env("RERANKER_BASE_URL")
+    },
+    retrieval: {
+      maxChunks: maxChunks ? parseInt(maxChunks, 10) : void 0,
+      maxTokens: maxTokens ? parseInt(maxTokens, 10) : void 0
+    },
+    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,
+      chunking: {
+        maxTokens: chunkMaxTokens ? parseInt(chunkMaxTokens, 10) : void 0
+      },
+      debounceMs: debounce ? parseInt(debounce, 10) : void 0
+    },
+    llm: {
+      mode: env("LLM_MODE"),
+      provider: env("LLM_PROVIDER"),
+      model: env("LLM_MODEL"),
+      apiKey: env("LLM_API_KEY") ?? process.env.ANTHROPIC_API_KEY ?? process.env.OPENAI_API_KEY,
+      baseUrl: env("LLM_BASE_URL"),
+      claudeBin: env("CLAUDE_BIN") ?? process.env.CLAUDE_BIN
+    },
+    github: {
+      token: env("GITHUB_TOKEN") ?? process.env.GITHUB_TOKEN
+    },
+    telemetry: {
+      otelEndpoint: env("OTEL_ENDPOINT") ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+      otelHeaders: parseHeaders(env("OTEL_HEADERS") ?? process.env.OTEL_EXPORTER_OTLP_HEADERS),
+      metricsEnabled: env("METRICS_ENABLED") === "1" || env("METRICS_ENABLED") === "true" ? true : void 0,
+      structuredLogs: env("STRUCTURED_LOGS") === "1" || env("STRUCTURED_LOGS") === "true" ? true : void 0,
+      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
+    }
+  };
+}
+const RESERVED_FLAGS = /* @__PURE__ */ new Set([
+  "--local",
+  "--remote",
+  "--serve",
+  "--help",
+  "-h",
+  "--print-config",
+  "--api-key",
+  "--project",
+  "--token",
+  "--force",
+  "--workspace",
+  "--no-daemon",
+  "--auto-spawn-daemon",
+  "--config",
+  "--format",
+  "--top-k",
+  "--mode",
+  "--repo",
+  "--language"
+]);
+function parseCliFlags(argv) {
+  const patch = {};
+  const rest = [];
+  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 negate = false;
+    if (key.startsWith("no-")) {
+      negate = true;
+      key = key.slice(3);
+    }
+    const path = key.split(".").map((seg) => seg.replace(/-([a-z])/g, (_, c) => c.toUpperCase()));
+    let val;
+    if (negate) {
+      val = false;
+    } else if (argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) {
+      val = coerce(argv[++i]);
+    } else {
+      val = true;
+    }
+    setDeep(patch, path, val);
+  }
+  return { patch, rest };
+}
+function setDeep(obj, path, value) {
+  let cur = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    const k = path[i];
+    if (!isPlainObject(cur[k])) cur[k] = {};
+    cur = cur[k];
+  }
+  cur[path[path.length - 1]] = value;
+}
+function resolveCodeSearchConfig(opts = {}) {
+  const globalConfigPath = opts.configPath ?? join(homedir(), ".code-search", "config.yaml");
+  const yaml1 = loadYamlFile(globalConfigPath) ?? {};
+  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);
+  bridgeLegacyEnvVars(cfg);
+  return cfg;
+}
+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;
+  process.env.ANVIL_LLM_MODEL ??= process.env.CODE_SEARCH_LLM_MODEL ?? cfg.llm.model;
+  if (cfg.llm.apiKey) process.env.ANVIL_LLM_API_KEY ??= cfg.llm.apiKey;
+  if (cfg.llm.baseUrl) process.env.ANVIL_LLM_BASE_URL ??= cfg.llm.baseUrl;
+  if (cfg.llm.claudeBin) process.env.ANVIL_CLAUDE_BIN ??= cfg.llm.claudeBin;
+}
+function toKnowledgeConfig(c) {
+  return {
+    embedding: { ...c.embedding },
+    chunking: { ...c.indexing.chunking },
+    retrieval: {
+      maxChunks: c.retrieval.maxChunks,
+      maxTokens: c.retrieval.maxTokens,
+      hybridWeights: { ...c.retrieval.hybridWeights },
+      reranker: { ...c.reranker }
+    },
+    autoIndex: c.indexing.autoIndex
+  };
+}
+const SECRET_KEYS = /* @__PURE__ */ new Set([
+  "apiKey",
+  "jwtSecret",
+  "token",
+  "githubToken"
+]);
+function redactSecrets(value, parentKey = "") {
+  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)`);
+      } else {
+        out[k] = redactSecrets(v, k);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function printConfig(c) {
+  return JSON.stringify(redactSecrets(c), null, 2);
 }
 export {
-  DEFAULT_CONFIG,
-  getKnowledgeBasePath,
-  loadKnowledgeConfig
+  DEFAULTS,
+  parseCliFlags,
+  printConfig,
+  redactSecrets,
+  resolveCodeSearchConfig,
+  toKnowledgeConfig
 };