@opencodehub/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,703 @@
+#!/usr/bin/env node
+/**
+ * `codehub` CLI entrypoint.
+ *
+ * Every subcommand is loaded lazily via `await import(...)` so that
+ * `codehub --help` (and `codehub <command> --help`) stays fast: no DuckDB
+ * native binding, no pipeline, no MCP SDK unless we are actually going to
+ * run that subcommand.
+ */
+import { cpus } from "node:os";
+import { Command } from "commander";
+const program = new Command()
+    .name("codehub")
+    .version("0.0.0")
+    .description("OpenCodeHub — code-graph indexer and MCP server for coding agents");
+program
+    .command("analyze [path]")
+    .description("Index a repository at [path] (default: current directory)")
+    .option("--force", "Ignore registry cache and re-run the pipeline")
+    .option("--embeddings", "Embed symbols and populate the DuckDB embeddings table")
+    .option("--embeddings-int8", "Use the int8 embedder variant (~23 MB) instead of fp32")
+    .option("--granularity <csv>", "Hierarchical embedding tiers to emit, comma-separated. Values: symbol, file, community. Default: symbol. Example: --granularity symbol,file,community")
+    .option("--embeddings-workers <n|auto>", 'Parallel ONNX embedder workers (each ~300 MB RSS on fp32). "auto" = os.cpus().length - 1, min 1. Default: "auto" when --embeddings is on (was 1 until 2026-04-27; single-threaded ONNX inference on a 100k-node repo took ~45 min, so CLI now opts into parallel by default). Pass --embeddings-workers 1 for the legacy in-process path.')
+    .option("--embeddings-batch-size <n>", "Chunks per embedBatch() call. Default 32. Set to 1 to restore the legacy one-node-per-call pattern.")
+    .option("--offline", "Assert no network access during analyze")
+    .option("--verbose", "Emit per-phase pipeline progress")
+    .option("--skip-agents-md", "Do not write the AGENTS.md / CLAUDE.md stanza")
+    .option("--sbom", "Emit .codehub/sbom.cyclonedx.json + .codehub/sbom.spdx.json from Dependency nodes")
+    .option("--coverage", "Overlay lcov/cobertura/jacoco/coverage.py report onto File nodes")
+    .option("--summaries", "Enable the summarize phase (default ON: structured Bedrock summaries per callable). Use --no-summaries to disable.")
+    .option("--no-summaries", "Disable the summarize phase entirely (equivalent to CODEHUB_BEDROCK_DISABLED=1).")
+    .option("--max-summaries <n|auto>", 'Cap on Bedrock summarize calls per run. "auto" (default) scales the cap to 10% of the SCIP-confirmed callable count (max 500).', "auto")
+    .option("--summary-model <id>", "Override the Bedrock model id used by the summarize phase (defaults to DEFAULT_MODEL_ID).")
+    .option("--skills", "After analyze, emit one SKILL.md per Community (symbolCount >= 5) under .codehub/skills/")
+    .option("--native-parser", "Opt into the native tree-sitter (N-API) runtime. Default is web-tree-sitter (WASM) for deterministic cross-platform behavior; pass --native-parser on Node 22 dev boxes where native parsing is measurably faster.")
+    .option("--strict-detectors", "Drop heuristic-only matches from the route / ORM detectors — emit edges only when the receiver's module origin was confirmed (DET-O-001)")
+    .option("--allow-build-scripts <list>", "Comma-separated opt-ins that enable build-script-driven indexers. Current value: `proleap` (JVM COBOL deep-parse). Unset → regex hot path only.")
+    .action(async (path, opts) => {
+    const mod = await import("./commands/analyze.js");
+    // `--native-parser` is honored by the parse worker via the
+    // `OCH_NATIVE_PARSER` env var; set it here before the worker pool
+    // spawns. WASM is the default runtime — native is opt-in.
+    if (opts["nativeParser"] === true) {
+        process.env["OCH_NATIVE_PARSER"] = "1";
+    }
+    // Pass the raw flag straight through to `runAnalyze`. The env
+    // kill-switch (`CODEHUB_BEDROCK_DISABLED=1`) is re-checked inside
+    // `runAnalyze` via `resolveSummariesEnabled` so tests that call
+    // `runAnalyze` directly honor the same truth table.
+    const summaries = opts["summaries"] === false ? false : undefined;
+    // --max-summaries accepts either a positive integer or the literal
+    // string "auto". Unknown strings fall back to "auto" so the CLI never
+    // refuses a run over flag syntax.
+    const rawMax = opts["maxSummaries"];
+    let maxSummariesPerRun;
+    if (rawMax === "auto" || rawMax === undefined) {
+        maxSummariesPerRun = "auto";
+    }
+    else if (typeof rawMax === "number" && Number.isFinite(rawMax)) {
+        maxSummariesPerRun = Math.max(0, Math.floor(rawMax));
+    }
+    else if (typeof rawMax === "string") {
+        const parsed = Number.parseInt(rawMax, 10);
+        maxSummariesPerRun = Number.isFinite(parsed) ? Math.max(0, parsed) : "auto";
+    }
+    else {
+        maxSummariesPerRun = "auto";
+    }
+    const granularity = parseGranularityCsv(opts["granularity"]);
+    const allowBuildScripts = parseAllowBuildScripts(opts["allowBuildScripts"]);
+    // When --embeddings is on and the user didn't pick a worker count, default
+    // to "auto" — single-threaded ONNX inference on 100k+ nodes takes ~45 min
+    // vs ~6–8 min with all cores busy. Power users can still pass
+    // `--embeddings-workers 1` for the legacy path.
+    const workersRaw = opts["embeddings"] === true && opts["embeddingsWorkers"] === undefined
+        ? "auto"
+        : opts["embeddingsWorkers"];
+    const embeddingsWorkers = parseWorkerCount(workersRaw);
+    const embeddingsBatchSize = parsePositiveInt(opts["embeddingsBatchSize"]);
+    await mod.runAnalyze(path ?? process.cwd(), {
+        force: opts["force"] === true,
+        embeddings: opts["embeddings"] === true,
+        embeddingsVariant: opts["embeddingsInt8"] === true ? "int8" : "fp32",
+        ...(granularity !== undefined ? { embeddingsGranularity: granularity } : {}),
+        ...(embeddingsWorkers !== undefined ? { embeddingsWorkers } : {}),
+        ...(embeddingsBatchSize !== undefined ? { embeddingsBatchSize } : {}),
+        offline: opts["offline"] === true,
+        verbose: opts["verbose"] === true,
+        skipAgentsMd: opts["skipAgentsMd"] === true,
+        sbom: opts["sbom"] === true,
+        coverage: opts["coverage"] === true,
+        ...(summaries === false ? { summaries } : {}),
+        maxSummariesPerRun,
+        ...(typeof opts["summaryModel"] === "string" ? { summaryModel: opts["summaryModel"] } : {}),
+        skills: opts["skills"] === true,
+        strictDetectors: opts["strictDetectors"] === true,
+        ...(allowBuildScripts !== undefined ? { allowBuildScripts } : {}),
+    });
+});
+program
+    .command("index [paths...]")
+    .description("Register an existing .codehub/ folder into the registry (no re-analysis). " +
+    "With no [paths], registers the current directory.")
+    .option("--force", "Stamp a minimal meta.json stub when .codehub/meta.json is missing")
+    .option("--allow-non-git", "Allow registering folders that are not git repositories")
+    .action(async (paths, opts) => {
+    const mod = await import("./commands/index-repo.js");
+    await mod.runIndexRepo(paths ?? [], {
+        force: opts["force"] === true,
+        allowNonGit: opts["allowNonGit"] === true,
+    });
+});
+program
+    .command("init [path]")
+    .description("Bootstrap a repo for OpenCodeHub — copies the Claude Code plugin assets into .claude/ (project-scope), writes .mcp.json, appends .codehub/ to .gitignore, seeds opencodehub.policy.yaml")
+    .option("--force", "Overwrite conflicting files under .claude/")
+    .option("--skip-mcp", "Skip writing .mcp.json")
+    .option("--skip-policy", "Skip seeding opencodehub.policy.yaml")
+    .action(async (path, opts) => {
+    const mod = await import("./commands/init.js");
+    const result = await mod.runInit({
+        ...(path !== undefined ? { repo: path } : {}),
+        force: opts["force"] === true,
+        skipMcp: opts["skipMcp"] === true,
+        skipPolicy: opts["skipPolicy"] === true,
+    });
+    // One-line recap so the user knows what changed.
+    const bits = [`${result.filesCopied} file(s) into .claude/`];
+    if (result.mcpResult)
+        bits.push(`.mcp.json (${result.mcpResult.action})`);
+    if (result.gitignoreUpdated)
+        bits.push(".gitignore updated");
+    if (result.policySeeded)
+        bits.push("opencodehub.policy.yaml seeded");
+    console.warn(`codehub init: ${bits.join(" · ")}`);
+    console.warn("Next: run 'codehub analyze' to build the graph, then restart Claude Code.");
+});
+program
+    .command("setup")
+    .description("Write MCP config entries for supported editors, download embedder weights, or install SCIP adapter binaries")
+    .option("--editors <list>", "Comma-separated editor ids (claude-code,cursor,codex,windsurf,opencode). Default: all")
+    .option("--force", "Overwrite an existing codehub entry without prompting; re-download weights")
+    .option("--undo", "Restore the most recent .bak next to each config")
+    .option("--embeddings", "Download gte-modernbert-base ONNX weights (SHA256-pinned)")
+    .option("--int8", "Use the int8 weight variant (~150 MB) instead of fp32 (~596 MB)")
+    .option("--model-dir <path>", "Override the target directory for embedder weights")
+    .option("--plugin", "Install the Claude Code plugin to ~/.claude/plugins/opencodehub/")
+    .option("--scip <tool>", "Install an external SCIP adapter binary (clang|ruby|dotnet|kotlin) or 'all'. SHA256-pinned; dotnet requires .NET SDK 8+ on PATH")
+    .option("--cobol-proleap", "Build the uwol/cobol-parser library from source (git clone + mvn install) and compile the bridge wrapper. Requires git, mvn, JDK 17+ on PATH. Installs under ~/.codehub/vendor/proleap/")
+    .action(async (opts) => {
+    const mod = await import("./commands/setup.js");
+    if (opts["plugin"] === true) {
+        await mod.runSetupPlugin({});
+        return;
+    }
+    if (opts["cobolProleap"] === true) {
+        await mod.runSetupCobolProleap({
+            force: opts["force"] === true,
+        });
+        return;
+    }
+    if (typeof opts["scip"] === "string") {
+        const tool = mod.parseScipFlag(opts["scip"]);
+        await mod.runSetupScip({
+            tool,
+            force: opts["force"] === true,
+        });
+        return;
+    }
+    if (opts["embeddings"] === true) {
+        const modelDir = typeof opts["modelDir"] === "string" ? opts["modelDir"] : undefined;
+        await mod.runSetupEmbeddings({
+            variant: opts["int8"] === true ? "int8" : "fp32",
+            ...(modelDir !== undefined ? { modelDir } : {}),
+            force: opts["force"] === true,
+        });
+        return;
+    }
+    const editors = typeof opts["editors"] === "string" ? parseEditors(opts["editors"]) : undefined;
+    await mod.runSetup({
+        ...(editors !== undefined ? { editors } : {}),
+        force: opts["force"] === true,
+        undo: opts["undo"] === true,
+    });
+});
+program
+    .command("mcp")
+    .description("Launch the codehub stdio MCP server")
+    .action(async () => {
+    const mod = await import("./commands/mcp.js");
+    await mod.runMcp();
+});
+program
+    .command("list")
+    .description("List all repos indexed on this machine")
+    .action(async () => {
+    const mod = await import("./commands/list.js");
+    await mod.runList();
+});
+program
+    .command("status [path]")
+    .description("Show index metadata for [path] (default: current directory)")
+    .action(async (path) => {
+    const mod = await import("./commands/status.js");
+    await mod.runStatus(path ?? process.cwd());
+});
+program
+    .command("clean [path]")
+    .description("Delete the index at [path]. --all deletes every registered index.")
+    .option("--all", "Delete every registered index")
+    .action(async (path, opts) => {
+    const mod = await import("./commands/clean.js");
+    await mod.runClean(path ?? process.cwd(), { all: opts["all"] === true });
+});
+program
+    .command("pack [path]")
+    .description("Produce a single-file LLM-ready snapshot of the repo via repomix (AST-compressed).")
+    .option("--style <style>", "Output style: xml|markdown|json|plain", "xml")
+    .option("--no-compress", "Disable tree-sitter AST compression (keeps full source)")
+    .option("--remove-comments", "Strip comments from the packed output")
+    .option("--out <path>", "Custom output path (default: <repo>/.codehub/pack/repo.<ext>)")
+    .action(async (path, opts) => {
+    const mod = await import("./commands/pack.js");
+    const style = opts["style"];
+    const result = await mod.runPack(path ?? process.cwd(), {
+        ...(style !== undefined ? { style } : {}),
+        compress: opts["compress"] !== false,
+        removeComments: opts["removeComments"] === true,
+        ...(typeof opts["out"] === "string" ? { outputPath: opts["out"] } : {}),
+    });
+    console.warn(`codehub pack: wrote ${result.bytes} bytes to ${result.outputPath} in ${result.durationMs}ms`);
+});
+program
+    .command("code-pack [path]")
+    .description("Produce the deterministic 9-item code-pack BOM (manifest + skeleton + file-tree + deps + " +
+    "ast-chunks + xrefs + findings + licenses + readme + optional embeddings.parquet) at " +
+    "<repo>/.codehub/packs/<packHash>/. Default engine is the new @opencodehub/pack BOM; " +
+    "--engine repomix opts into the legacy single-file snapshot (drop deferred to M7).")
+    .option("--budget <n>", "AST-chunker token budget (default 100000)", (v) => Number.parseInt(v, 10))
+    .option("--tokenizer <id>", 'Tokenizer pin "<vendor>:<name>@<pin>" (default openai:o200k_base@tiktoken-0.8.0)')
+    .option("--out-dir <dir>", "Override the .codehub/packs/<packHash>/ default output directory (the directory still " +
+    "contains the manifest + BOM bodies; supplying this flag lets you put the artifacts " +
+    "under a non-standard path, e.g. /tmp/my-pack)")
+    .option("--engine <engine>", "Engine: pack (default — 9-item BOM via @opencodehub/pack) or repomix (legacy single-file)", "pack")
+    .action(async (path, opts) => {
+    const mod = await import("./commands/code-pack.js");
+    const rawEngine = typeof opts["engine"] === "string" ? opts["engine"] : "pack";
+    const engine = rawEngine === "repomix" ? "repomix" : rawEngine === "pack" ? "pack" : "pack";
+    if (rawEngine !== engine && rawEngine !== "pack") {
+        throw new Error(`Unknown --engine value: "${rawEngine}". Expected one of: pack, repomix`);
+    }
+    const budget = typeof opts["budget"] === "number" && Number.isFinite(opts["budget"])
+        ? opts["budget"]
+        : undefined;
+    const result = await mod.runCodePack({
+        ...(path !== undefined ? { repo: path } : {}),
+        ...(budget !== undefined ? { budget } : {}),
+        ...(typeof opts["tokenizer"] === "string" ? { tokenizer: opts["tokenizer"] } : {}),
+        ...(typeof opts["outDir"] === "string" ? { outDir: opts["outDir"] } : {}),
+        engine,
+    });
+    if (result.engine === "pack") {
+        console.warn(`codehub code-pack: wrote ${result.bomItemCount} BOM items to ${result.outDir} ` +
+            `(packHash=${result.packHash.slice(0, 12)})`);
+    }
+    else {
+        console.warn(`codehub code-pack: wrote repomix snapshot to ${result.repomixOutputPath ?? result.outDir} ` +
+            `(packHash=${result.packHash.slice(0, 12)})`);
+    }
+});
+program
+    .command("query <text>")
+    .description("Direct hybrid search against a repo's graph")
+    .option("--limit <n>", "Max results", (v) => Number.parseInt(v, 10), 10)
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .option("--json", "Emit JSON on stdout")
+    .option("--content", "Attach full symbol source to each hit (capped at 2000 chars)")
+    .option("--context <text>", "What you are working on — prefixed to the query text to steer ranking")
+    .option("--goal <text>", "What you want to find — prefixed alongside --context to steer ranking")
+    .option("--max-symbols <n>", "Max symbols in process-grouped output (default 50)", (v) => Number.parseInt(v, 10))
+    .option("--bm25-only", "Skip the embedder probe and run BM25 search only")
+    .option("--rerank-top-k <n>", "RRF top-k passed to hybrid fusion (default 50)", (v) => Number.parseInt(v, 10))
+    .option("--zoom", "Enable coarse-to-fine retrieval (file tier → symbol tier). Requires an embedder and a hierarchical index (see `analyze --granularity symbol,file,community`).")
+    .option("--fanout <n>", "Files to shortlist at the coarse step when --zoom is on", (v) => Number.parseInt(v, 10))
+    .option("--granularity <tier>", "Restrict ANN to one hierarchical tier: symbol (default), file, or community")
+    .option("--force-backend-mismatch", "Bypass the embedder fingerprint check. Lets a query run when the persisted embedder model_id differs from the current one. Vectors may be stale.")
+    .action(async (text, opts) => {
+    const mod = await import("./commands/query.js");
+    const granularity = parseQueryGranularity(opts["granularity"]);
+    await mod.runQuery(text, {
+        limit: typeof opts["limit"] === "number" ? opts["limit"] : 10,
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        json: opts["json"] === true,
+        content: opts["content"] === true,
+        ...(typeof opts["context"] === "string" ? { context: opts["context"] } : {}),
+        ...(typeof opts["goal"] === "string" ? { goal: opts["goal"] } : {}),
+        ...(typeof opts["maxSymbols"] === "number" ? { maxSymbols: opts["maxSymbols"] } : {}),
+        bm25Only: opts["bm25Only"] === true,
+        ...(typeof opts["rerankTopK"] === "number" ? { rerankTopK: opts["rerankTopK"] } : {}),
+        zoom: opts["zoom"] === true,
+        ...(typeof opts["fanout"] === "number" ? { fanout: opts["fanout"] } : {}),
+        ...(granularity !== undefined ? { granularity } : {}),
+        forceBackendMismatch: opts["forceBackendMismatch"] === true,
+    });
+});
+program
+    .command("context <symbol>")
+    .description("360° view of a symbol (callers, callees, flows)")
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .option("--json", "Emit JSON on stdout")
+    .option("--target-uid <id>", "Exact node id from a prior result; bypasses name-based disambiguation")
+    .option("--file-path <hint>", "File path (or suffix) to disambiguate same-named symbols")
+    .option("--kind <kind>", "Kind filter (Function, Method, Class, Interface, …)")
+    .action(async (symbol, opts) => {
+    const mod = await import("./commands/context.js");
+    await mod.runContext(symbol, {
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        json: opts["json"] === true,
+        ...(typeof opts["targetUid"] === "string" ? { targetUid: opts["targetUid"] } : {}),
+        ...(typeof opts["filePath"] === "string" ? { filePath: opts["filePath"] } : {}),
+        ...(typeof opts["kind"] === "string" ? { kind: opts["kind"] } : {}),
+    });
+});
+program
+    .command("impact <symbol>")
+    .description("Blast-radius analysis for a symbol")
+    .option("--depth <n>", "Max traversal depth", (v) => Number.parseInt(v, 10), 3)
+    .option("--direction <dir>", "up | down | both", "both")
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .option("--json", "Emit JSON on stdout")
+    .option("--target-uid <id>", "Exact node id from a prior result; bypasses name-based disambiguation")
+    .option("--file-path <hint>", "File path (or suffix) to disambiguate same-named symbols")
+    .option("--kind <kind>", "Kind filter (Function, Method, Class, Interface, …)")
+    .action(async (symbol, opts) => {
+    const mod = await import("./commands/impact.js");
+    const directionRaw = typeof opts["direction"] === "string" ? opts["direction"] : "both";
+    const direction = directionRaw === "up" || directionRaw === "down" ? directionRaw : "both";
+    await mod.runImpact(symbol, {
+        depth: typeof opts["depth"] === "number" ? opts["depth"] : 3,
+        direction,
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        json: opts["json"] === true,
+        ...(typeof opts["targetUid"] === "string" ? { targetUid: opts["targetUid"] } : {}),
+        ...(typeof opts["filePath"] === "string" ? { filePath: opts["filePath"] } : {}),
+        ...(typeof opts["kind"] === "string" ? { kind: opts["kind"] } : {}),
+    });
+});
+program
+    .command("detect-changes")
+    .description("Map an uncommitted or committed diff onto affected graph symbols + processes. Useful in CI without launching the MCP server.")
+    .option("--scope <scope>", "unstaged | staged | all | compare  (default: all = working tree + index)", "all")
+    .option("--compare-ref <ref>", "Git ref to compare against (required when --scope=compare, e.g. origin/main)")
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .option("--json", "Emit JSON on stdout")
+    .option("--strict", "Exit 1 on MEDIUM+ risk (default: exit 1 only on HIGH / CRITICAL)")
+    .action(async (opts) => {
+    const mod = await import("./commands/detect-changes.js");
+    const rawScope = typeof opts["scope"] === "string" ? opts["scope"] : "all";
+    const scope = rawScope === "unstaged" || rawScope === "staged" || rawScope === "compare" ? rawScope : "all";
+    if (rawScope !== scope && rawScope !== "all") {
+        throw new Error(`Unknown --scope value: "${rawScope}". Expected one of: unstaged, staged, all, compare`);
+    }
+    await mod.runDetectChangesCmd({
+        scope,
+        ...(typeof opts["compareRef"] === "string" ? { compareRef: opts["compareRef"] } : {}),
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        json: opts["json"] === true,
+        strict: opts["strict"] === true,
+    });
+});
+program
+    .command("verdict")
+    .description("5-tier PR verdict (auto_merge|single_review|dual_review|expert_review|block)")
+    .option("--base <ref>", "Base git ref", "main")
+    .option("--head <ref>", "Head git ref", "HEAD")
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .option("--json", "Emit JSON on stdout instead of Markdown")
+    .action(async (opts) => {
+    const mod = await import("./commands/verdict.js");
+    await mod.runVerdict({
+        base: typeof opts["base"] === "string" ? opts["base"] : "main",
+        head: typeof opts["head"] === "string" ? opts["head"] : "HEAD",
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        json: opts["json"] === true,
+    });
+});
+// `codehub group ...` — cross-repo groups. We register placeholder
+// subcommands so `commander` routes the invocation correctly, and load the
+// real handler lazily on .action(). This keeps `codehub --help` snappy.
+{
+    const group = program.command("group").description("Manage named cross-repo groups");
+    group
+        .command("create <name> <repos...>")
+        .description("Create a group from registered repo names")
+        .option("--description <text>", "Short human-readable description")
+        .action(async (name, repos, opts) => {
+        const mod = await import("./commands/group.js");
+        await mod.runGroupCreate(name, repos, {
+            ...(typeof opts["description"] === "string" ? { description: opts["description"] } : {}),
+        });
+    });
+    group
+        .command("list")
+        .description("List all groups")
+        .action(async () => {
+        const mod = await import("./commands/group.js");
+        await mod.runGroupList();
+    });
+    group
+        .command("delete <name>")
+        .description("Delete a group")
+        .action(async (name) => {
+        const mod = await import("./commands/group.js");
+        await mod.runGroupDelete(name);
+    });
+    group
+        .command("status <name>")
+        .description("Per-repo index freshness within a group")
+        .action(async (name) => {
+        const mod = await import("./commands/group.js");
+        await mod.runGroupStatus(name);
+    });
+    group
+        .command("query <name> <text>")
+        .description("BM25 over every repo in the group, fused with RRF")
+        .option("--limit <n>", "Max results (default 20)", (v) => Number.parseInt(v, 10), 20)
+        .option("--json", "Emit JSON on stdout")
+        .action(async (name, text, opts) => {
+        const mod = await import("./commands/group.js");
+        await mod.runGroupQuery(name, text, {
+            limit: typeof opts["limit"] === "number" ? opts["limit"] : 20,
+            json: opts["json"] === true,
+        });
+    });
+    group
+        .command("sync <name>")
+        .description("Extract cross-repo HTTP / gRPC / topic contracts and write ~/.codehub/groups/<name>/contracts.json")
+        .option("--json", "Emit the written registry on stdout")
+        .action(async (name, opts) => {
+        const mod = await import("./commands/group.js");
+        await mod.runGroupSyncCmd(name, {
+            json: opts["json"] === true,
+        });
+    });
+}
+program
+    .command("ingest-sarif <sarifFile>")
+    .description("Ingest a SARIF 2.1.0 log into the graph as Finding nodes + FOUND_IN edges")
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .action(async (sarifFile, opts) => {
+    const mod = await import("./commands/ingest-sarif.js");
+    await mod.runIngestSarif(sarifFile, {
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+    });
+});
+program
+    .command("scan [path]")
+    .description("Run Priority-1 scanners and ingest findings into the graph")
+    .option("--scanners <list>", "Comma-separated scanner ids (overrides profile gating)")
+    .option("--with <list>", "Additional scanner ids to include (comma-separated)")
+    .option("--output <file>", "SARIF output path (default: <repo>/.codehub/scan.sarif)")
+    .option("--severity <list>", "Severity levels that fail the run (default: HIGH,CRITICAL)")
+    .option("--repo <name>", "Registered repo name (default: [path] or current directory)")
+    .option("--concurrency <n>", "Max parallel scanners", (v) => Number.parseInt(v, 10))
+    .option("--timeout <ms>", "Per-scanner timeout in ms", (v) => Number.parseInt(v, 10))
+    .action(async (path, opts) => {
+    const mod = await import("./commands/scan.js");
+    const scanners = typeof opts["scanners"] === "string" ? splitList(opts["scanners"]) : undefined;
+    const withScanners = typeof opts["with"] === "string" ? splitList(opts["with"]) : undefined;
+    const severity = typeof opts["severity"] === "string" ? splitList(opts["severity"]) : undefined;
+    const summary = await mod.runScan(path ?? process.cwd(), {
+        ...(scanners !== undefined ? { scanners } : {}),
+        ...(withScanners !== undefined ? { withScanners } : {}),
+        ...(severity !== undefined ? { severity } : {}),
+        ...(typeof opts["output"] === "string" ? { output: opts["output"] } : {}),
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        ...(typeof opts["concurrency"] === "number" ? { concurrency: opts["concurrency"] } : {}),
+        ...(typeof opts["timeout"] === "number" ? { timeoutMs: opts["timeout"] } : {}),
+    });
+    if (summary.exitCode !== 0) {
+        process.exitCode = summary.exitCode;
+    }
+});
+program
+    .command("doctor")
+    .description("Probe the local environment (node/pnpm/native bindings/scanners/registry) and print actionable hints")
+    .option("--skip-native", "Skip checks that require native bindings (duckdb / tree-sitter)")
+    .option("--repoRoot <path>", "Override the workspace root used as a fallback for native-binding resolution")
+    .action(async (opts) => {
+    const mod = await import("./commands/doctor.js");
+    await mod.runDoctor({
+        skipNative: opts["skipNative"] === true,
+        ...(typeof opts["repoRoot"] === "string" && opts["repoRoot"].length > 0
+            ? { repoRoot: opts["repoRoot"] }
+            : {}),
+    });
+});
+program
+    .command("bench")
+    .description("Run the acceptance gate suite (scripts/acceptance.sh) and render a pass/fail dashboard")
+    .option("--acceptance <path>", "Override the path to scripts/acceptance.sh")
+    .option("--silent", "Suppress the listr2 progress renderer (useful in CI)")
+    .action(async (opts) => {
+    const mod = await import("./commands/bench.js");
+    await mod.runBench({
+        ...(typeof opts["acceptance"] === "string" ? { acceptanceScript: opts["acceptance"] } : {}),
+        silent: opts["silent"] === true,
+    });
+});
+program
+    .command("wiki")
+    .description("Emit a Markdown wiki under --output (deterministic by default; --llm for LLM prose)")
+    .requiredOption("--output <dir>", "Target directory for rendered pages")
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .option("--json", "Emit a JSON summary on stdout")
+    .option("--offline", "Assert no network access (incompatible with --llm)")
+    .option("--llm", "Route top-ranked modules through @opencodehub/summarizer for narrative prose")
+    .option("--max-llm-calls <n>", "Cap on Bedrock summarizer calls when --llm is set. 0 (default) runs in dry-run mode", (v) => Number.parseInt(v, 10), 0)
+    .option("--llm-model <id>", "Override the Bedrock model id passed to the summarizer")
+    .action(async (opts) => {
+    const mod = await import("./commands/wiki.js");
+    const output = typeof opts["output"] === "string" ? opts["output"] : "";
+    if (output.length === 0) {
+        throw new Error("--output <dir> is required");
+    }
+    const maxLlmCallsRaw = opts["maxLlmCalls"];
+    const maxLlmCalls = typeof maxLlmCallsRaw === "number" && Number.isFinite(maxLlmCallsRaw)
+        ? Math.max(0, Math.floor(maxLlmCallsRaw))
+        : 0;
+    await mod.runWiki({
+        output,
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        json: opts["json"] === true,
+        offline: opts["offline"] === true,
+        llm: opts["llm"] === true,
+        maxLlmCalls,
+        ...(typeof opts["llmModel"] === "string" ? { llmModel: opts["llmModel"] } : {}),
+    });
+});
+program
+    .command("ci-init")
+    .description("Emit opinionated CI workflow files for GitHub Actions and/or GitLab CI")
+    .option("--platform <p>", "Target platform: github | gitlab | both (default: auto-detect)")
+    .option("--main-branch <b>", "Name of the main branch", "main")
+    .option("--repo <path>", "Repo root (default: current directory)")
+    .option("--force", "Overwrite existing workflow files")
+    .action(async (opts) => {
+    const mod = await import("./commands/ci-init.js");
+    const rawPlatform = typeof opts["platform"] === "string" ? opts["platform"] : undefined;
+    const platform = rawPlatform === "github" || rawPlatform === "gitlab" || rawPlatform === "both"
+        ? rawPlatform
+        : undefined;
+    if (rawPlatform !== undefined && platform === undefined) {
+        throw new Error(`Unknown --platform value: ${rawPlatform}. Expected one of: github, gitlab, both.`);
+    }
+    await mod.runCiInit({
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        ...(platform !== undefined ? { platform } : {}),
+        ...(typeof opts["mainBranch"] === "string" ? { mainBranch: opts["mainBranch"] } : {}),
+        force: opts["force"] === true,
+    });
+});
+program
+    .command("augment <pattern>")
+    .description("Fast-path BM25 enrichment for editor PreToolUse hooks — writes a compact context block to stderr")
+    .option("--limit <n>", "Max hits to enrich (default 5)", (v) => Number.parseInt(v, 10), 5)
+    .action(async (pattern, opts) => {
+    const mod = await import("./commands/augment.js");
+    await mod.runAugment(pattern, {
+        limit: typeof opts["limit"] === "number" ? opts["limit"] : 5,
+    });
+});
+program
+    .command("sql <query>")
+    .description("Run a read-only SQL query against the graph store")
+    .option("--repo <name>", "Registered repo name (default: current directory)")
+    .option("--timeout <ms>", "Per-query timeout in ms", (v) => Number.parseInt(v, 10), 5_000)
+    .option("--json", "Emit JSON on stdout")
+    .action(async (query, opts) => {
+    const mod = await import("./commands/sql.js");
+    await mod.runSql(query, {
+        ...(typeof opts["repo"] === "string" ? { repo: opts["repo"] } : {}),
+        timeoutMs: typeof opts["timeout"] === "number" ? opts["timeout"] : 5_000,
+        json: opts["json"] === true,
+    });
+});
+function splitList(raw) {
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+/**
+ * Parse the single-value `--granularity` flag used by `codehub query`.
+ * Accepts exactly one tier (symbol/file/community); rejects CSV lists.
+ */
+function parseQueryGranularity(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return undefined;
+    const trimmed = raw.trim();
+    if (trimmed === "symbol" || trimmed === "file" || trimmed === "community")
+        return trimmed;
+    throw new Error(`Unknown --granularity value: "${trimmed}". Expected one of: symbol, file, community`);
+}
+/**
+ * Parse a comma-separated `--granularity` value into the narrow set of
+ * hierarchical embedding tiers the ingestion phase accepts. Returns
+ * `undefined` when the flag was not supplied so callers can preserve the
+ * upstream default (`["symbol"]`). Unknown tokens throw so users see the
+ * typo rather than a silent fallback.
+ */
+function parseGranularityCsv(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return undefined;
+    const valid = new Set(["symbol", "file", "community"]);
+    const out = [];
+    const seen = new Set();
+    for (const token of splitList(raw)) {
+        if (!valid.has(token)) {
+            throw new Error(`Unknown granularity tier: "${token}". Expected one of: ${[...valid].join(", ")}`);
+        }
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        out.push(token);
+    }
+    return out;
+}
+/**
+ * Parse the `--allow-build-scripts` CSV flag for `codehub analyze`. Today
+ * the only recognized token is `proleap` (JVM COBOL deep-parse); unknown
+ * tokens throw so a typo surfaces immediately instead of silently leaving
+ * the build-script path disabled.
+ *
+ * Returns `undefined` when the flag is not supplied so the analyze pipeline
+ * preserves its own default ("regex hot path only, no JVM").
+ */
+function parseAllowBuildScripts(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return undefined;
+    const valid = new Set(["proleap"]);
+    const out = [];
+    const seen = new Set();
+    for (const token of splitList(raw)) {
+        if (!valid.has(token)) {
+            throw new Error(`Unknown --allow-build-scripts value: "${token}". Expected one of: ${[...valid].join(", ")}`);
+        }
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        out.push(token);
+    }
+    return out;
+}
+/**
+ * Parse `--embeddings-workers`. Accepts a positive integer or the literal
+ * "auto" (resolves to `os.cpus().length - 1`, floor 1). Returns undefined
+ * when the flag wasn't supplied so the pipeline picks its own default.
+ */
+function parseWorkerCount(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (raw === "auto") {
+        return Math.max(1, cpus().length - 1);
+    }
+    const parsed = typeof raw === "number" ? raw : Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        throw new Error(`--embeddings-workers must be a positive integer or "auto"; got "${String(raw)}"`);
+    }
+    return Math.floor(parsed);
+}
+/** Parse a positive integer CLI flag, returning undefined when omitted. */
+function parsePositiveInt(raw) {
+    if (raw === undefined)
+        return undefined;
+    const parsed = typeof raw === "number" ? raw : Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        throw new Error(`expected a positive integer; got "${String(raw)}"`);
+    }
+    return Math.floor(parsed);
+}
+function parseEditors(raw) {
+    const valid = new Set(["claude-code", "cursor", "codex", "windsurf", "opencode"]);
+    const out = [];
+    for (const token of raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)) {
+        if (valid.has(token)) {
+            out.push(token);
+        }
+        else {
+            throw new Error(`Unknown editor id: ${token}. Expected one of: ${[...valid].join(", ")}`);
+        }
+    }
+    return out;
+}
+program.parseAsync(process.argv).catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`codehub: ${message}`);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map