kibi-cli 0.12.8 → 0.16.1

package/bin/kibi

@@ -16,4 +16,6 @@
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
-import "../dist/cli.js";
+import { main } from "../dist/cli.js";
+
+await main();

package/dist/cli-command.d.ts

@@ -0,0 +1,5 @@
+export interface CommandResult {
+    readonly exitCode?: number;
+}
+export declare function withExitCode<TArgs extends unknown[]>(fn: (...args: TArgs) => Promise<CommandResult | undefined>): (...args: TArgs) => Promise<void>;
+//# sourceMappingURL=cli-command.d.ts.map

package/dist/cli-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-command.d.ts","sourceRoot":"","sources":["../src/cli-command.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAGD,wBAAgB,YAAY,CAAC,KAAK,SAAS,OAAO,EAAE,EAClD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,GACzD,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAOnC"}

package/dist/cli-command.js

@@ -0,0 +1,9 @@
+// implements REQ-kibi-operation-interface-parity
+export function withExitCode(fn) {
+    return async (...args) => {
+        const result = await fn(...args);
+        if (result?.exitCode !== undefined) {
+            process.exitCode = result.exitCode;
+        }
+    };
+}

package/dist/cli-errors.d.ts

@@ -0,0 +1,13 @@
+export declare class InputError extends Error {
+    readonly code: string;
+    readonly detail: string;
+    readonly exitCode = 2;
+    constructor(code: string, detail: string);
+}
+export declare class OperationError extends Error {
+    readonly code: string;
+    readonly detail: string;
+    readonly exitCode = 1;
+    constructor(code: string, detail: string);
+}
+//# sourceMappingURL=cli-errors.d.ts.map

package/dist/cli-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-errors.d.ts","sourceRoot":"","sources":["../src/cli-errors.ts"],"names":[],"mappings":"AACA,qBAAa,UAAW,SAAQ,KAAK;IAKjC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IAJzB,QAAQ,CAAC,QAAQ,KAAK;gBAGX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM;CAK1B;AAGD,qBAAa,cAAe,SAAQ,KAAK;IAKrC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IAJzB,QAAQ,CAAC,QAAQ,KAAK;gBAGX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM;CAK1B"}

package/dist/cli-errors.js

@@ -0,0 +1,26 @@
+// implements REQ-kibi-operation-interface-parity
+export class InputError extends Error {
+    code;
+    detail;
+    // implements REQ-kibi-operation-interface-parity
+    exitCode = 2;
+    constructor(code, detail) {
+        super(detail);
+        this.code = code;
+        this.detail = detail;
+        this.name = "InputError";
+    }
+}
+// implements REQ-kibi-operation-interface-parity
+export class OperationError extends Error {
+    code;
+    detail;
+    // implements REQ-kibi-operation-interface-parity
+    exitCode = 1;
+    constructor(code, detail) {
+        super(detail);
+        this.code = code;
+        this.detail = detail;
+        this.name = "OperationError";
+    }
+}

package/dist/cli-input.d.ts

@@ -0,0 +1,6 @@
+export type LoadInputOptions = {
+    readonly input?: string;
+    readonly cwd: string;
+};
+export declare function loadInput(options: LoadInputOptions): Promise<unknown>;
+//# sourceMappingURL=cli-input.d.ts.map

package/dist/cli-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-input.d.ts","sourceRoot":"","sources":["../src/cli-input.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB,CAAC;AA2CF,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAuB3E"}

package/dist/cli-input.js

@@ -0,0 +1,54 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { InputError } from "./cli-errors.js";
+let stdinConsumed = false;
+async function readStdinOnce() {
+    if (stdinConsumed) {
+        throw new InputError("STDIN_ALREADY_READ", "Standard input can only be consumed once.");
+    }
+    stdinConsumed = true;
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function readInputText(options) {
+    if (options.input === undefined) {
+        throw new InputError("MISSING_INPUT", "The --input option is required.");
+    }
+    if (options.input === "-") {
+        return readStdinOnce();
+    }
+    const filePath = path.resolve(options.cwd, options.input);
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new InputError("INPUT_READ_FAILED", `Unable to read JSON input '${options.input}': ${error.message}`);
+        }
+        throw error;
+    }
+}
+// implements REQ-kibi-operation-interface-parity
+export async function loadInput(options) {
+    const text = await readInputText(options);
+    if (text.trim().length === 0) {
+        throw new InputError("EMPTY_INPUT", "JSON input is empty.");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new InputError("INVALID_JSON", `Invalid JSON input: ${error.message}`);
+        }
+        throw error;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new InputError("INVALID_INPUT_ROOT", "JSON input must be an object.");
+    }
+    return parsed;
+}

package/dist/cli-json-command.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+import { type OperationName } from "./public/operations/index.js";
+export type JsonInvocation = {
+    readonly operationName: OperationName;
+    readonly inputPath: string;
+    readonly command: Command;
+    readonly positionals?: readonly {
+        readonly name: string;
+        readonly value: string | undefined;
+    }[];
+};
+export declare function runJsonInvocation(invocation: JsonInvocation): Promise<void>;
+export declare function registerJsonOnlyCommands(program: Command): void;
+//# sourceMappingURL=cli-json-command.d.ts.map

package/dist/cli-json-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-json-command.d.ts","sourceRoot":"","sources":["../src/cli-json-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,OAAO,EACL,KAAK,aAAa,EAGnB,MAAM,8BAA8B,CAAC;AAItC,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS;QAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;KACpC,EAAE,CAAC;CACL,CAAC;AAyBF,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,cAAc,GACzB,OAAO,CAAC,IAAI,CAAC,CAiDf;AAaD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0B/D"}

package/dist/cli-json-command.js

@@ -0,0 +1,96 @@
+import { InputError } from "./cli-errors.js";
+import { loadInput } from "./cli-input.js";
+import { executeOperation as executeProtocolOperation } from "./cli-protocol.js";
+import { getSpec, listSpecs, } from "./public/operations/index.js";
+import { createCliRuntime } from "./runtime/cli-runtime.js";
+function writeInputError(error) {
+    process.stderr.write(`Error [${error.code}]: ${error.detail}\n`);
+    process.exitCode = error.exitCode;
+}
+function findInputConflicts(invocation) {
+    const optionConflicts = invocation.command.options.flatMap((option) => {
+        const name = option.attributeName();
+        if (name === "input" ||
+            invocation.command.getOptionValueSource(name) !== "cli") {
+            return [];
+        }
+        return option.long === undefined ? [] : [option.long];
+    });
+    const positionalConflicts = (invocation.positionals ?? [])
+        .filter(({ value }) => value !== undefined)
+        .map(({ name }) => name);
+    return [...positionalConflicts, ...optionConflicts];
+}
+// implements REQ-kibi-operation-interface-parity
+export async function runJsonInvocation(invocation) {
+    const conflicts = findInputConflicts(invocation);
+    if (conflicts.length > 0) {
+        writeInputError(new InputError("CONFLICTING_INPUT", `--input cannot be combined with: ${conflicts.join(", ")}`));
+        return;
+    }
+    let input;
+    try {
+        input = await loadInput({
+            input: invocation.inputPath,
+            cwd: process.cwd(),
+        });
+    }
+    catch (error) {
+        if (error instanceof InputError) {
+            writeInputError(error);
+            return;
+        }
+        throw error;
+    }
+    const workspaceRoot = process.cwd();
+    const spec = getSpec(invocation.operationName);
+    const runtime = createCliRuntime({ workspaceRoot });
+    const context = await runtime.open(spec, { workspaceRoot });
+    const result = await executeProtocolOperation(invocation.operationName, input, context);
+    if (result.exitCode === 0 && spec.effects.includes("kb-write")) {
+        await runtime.afterSuccess(spec, context);
+    }
+    await runtime.close(context, {
+        status: "success",
+        result,
+    });
+    if (result.stdout !== undefined) {
+        process.stdout.write(result.stdout);
+    }
+    if (result.stderr !== undefined) {
+        process.stderr.write(result.stderr);
+    }
+    process.exitCode = result.exitCode;
+}
+const INTEGRATED_OPERATIONS = new Set([
+    "kb_query",
+    "kb_search",
+    "kb_status",
+    "kb_find_gaps",
+    "kb_coverage",
+    "kb_graph",
+    "kb_check",
+]);
+// implements REQ-kibi-operation-interface-parity
+export function registerJsonOnlyCommands(program) {
+    for (const spec of listSpecs()) {
+        if (INTEGRATED_OPERATIONS.has(spec.name)) {
+            continue;
+        }
+        program
+            .command(spec.cliName.replaceAll(" ", "-"))
+            .description(spec.description)
+            .option("--input <path>", "JSON input file (use - for stdin)")
+            .action(async (options, command) => {
+            if (options.input === undefined) {
+                writeInputError(new InputError("MISSING_INPUT", "The --input option is required for this command."));
+                return;
+            }
+            await runJsonInvocation({
+                operationName: spec.name,
+                inputPath: options.input,
+                command,
+            });
+        });
+    }
+}

package/dist/cli-protocol.d.ts

@@ -0,0 +1,12 @@
+import { type DiagnosticTelemetry } from "./cli-validate.js";
+import type { OperationContext } from "./public/operations/index.js";
+export type CliContext = OperationContext & {
+    readonly diagnosticTelemetry?: DiagnosticTelemetry;
+};
+export type CliProtocolResult = {
+    readonly exitCode: number;
+    readonly stdout?: string;
+    readonly stderr?: string;
+};
+export declare function executeOperation(catalogName: string, input: unknown, context: CliContext): Promise<CliProtocolResult>;
+//# sourceMappingURL=cli-protocol.d.ts.map

package/dist/cli-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-protocol.d.ts","sourceRoot":"","sources":["../src/cli-protocol.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGrE,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG;IAC1C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CACpD,CAAC;AAGF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAUF,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAoC5B"}

package/dist/cli-protocol.js

@@ -0,0 +1,37 @@
+import { InputError, OperationError } from "./cli-errors.js";
+import { prepareOperationInput, } from "./cli-validate.js";
+import { listSpecs } from "./public/operations/index.js";
+function errorResult(error) {
+    return {
+        exitCode: error.exitCode,
+        stderr: `Error [${error.code}]: ${error.detail}\n`,
+    };
+}
+// implements REQ-kibi-operation-interface-parity
+export async function executeOperation(catalogName, input, context) {
+    const spec = listSpecs().find(({ name }) => name === catalogName);
+    if (spec === undefined) {
+        return errorResult(new InputError("UNKNOWN_OPERATION", `Unknown operation '${catalogName}'.`));
+    }
+    const prepared = prepareOperationInput(input, spec.businessInputSchema);
+    if (!prepared.valid) {
+        return errorResult(new InputError("VALIDATION_FAILED", prepared.errors.join("; ")));
+    }
+    try {
+        const executionContext = prepared.telemetry
+            ? { ...context, diagnosticTelemetry: prepared.telemetry }
+            : context;
+        const result = await spec.execute(prepared.businessInput, executionContext);
+        const output = result.structuredContent ?? result;
+        return { exitCode: 0, stdout: `${JSON.stringify(output)}\n` };
+    }
+    catch (error) {
+        if (error instanceof InputError || error instanceof OperationError) {
+            return errorResult(error);
+        }
+        if (error instanceof Error) {
+            return errorResult(new OperationError("OPERATION_FAILED", error.message));
+        }
+        return errorResult(new OperationError("OPERATION_FAILED", "Operation failed unexpectedly."));
+    }
+}

package/dist/cli-register-foundation.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerFoundationCommands(program: Command): void;
+//# sourceMappingURL=cli-register-foundation.d.ts.map

package/dist/cli-register-foundation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-register-foundation.d.ts","sourceRoot":"","sources":["../src/cli-register-foundation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYzC,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiHjE"}

package/dist/cli-register-foundation.js

@@ -0,0 +1,90 @@
+import { withExitCode } from "./cli-command.js";
+import { runJsonInvocation } from "./cli-json-command.js";
+import { initCommand } from "./commands/init.js";
+import { migrateCommand } from "./commands/migrate.js";
+import { queryCommand } from "./commands/query.js";
+import { searchCommand } from "./commands/search.js";
+import { statusCommand } from "./commands/status.js";
+import { syncCommand } from "./commands/sync.js";
+import { getSpec } from "./public/operations/index.js";
+// implements REQ-kibi-operation-interface-parity
+export function registerFoundationCommands(program) {
+    program
+        .command("init")
+        .description("Initialize .kb/ directory")
+        .option("--no-hooks", "Do not install git hooks (hooks installed by default)")
+        .action(withExitCode(async (options) => initCommand(options)));
+    program
+        .command("migrate")
+        .description("Migrate .kb/config.json to the latest schema version")
+        .option("--dry-run", "Preview migration changes without writing files")
+        .option("--yes", "Apply migration changes without prompting")
+        .action(withExitCode(async (options) => migrateCommand(options)));
+    program
+        .command("sync")
+        .description("Sync entities from documents")
+        .option("--validate-only", "Perform validation without mutations")
+        .option("--refresh-symbol-coordinates", "Refresh generated symbol coordinates")
+        .option("--rebuild", "Rebuild branch snapshot from scratch (discards current KB)")
+        .action(withExitCode(async (options) => syncCommand(options)));
+    program
+        .command("query [type]")
+        .alias("kb-query")
+        .description(getSpec("kb_query").description)
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--id <id>", "Query specific entity by ID")
+        .option("--tag <tag>", "Filter by tag")
+        .option("--source <path>", "Filter by source file path (substring match)")
+        .option("--relationships <id>", "Get relationships from entity")
+        .option("--format <format>", "Output format: json|table", "json")
+        .option("--limit <n>", "Limit results", "100")
+        .option("--offset <n>", "Skip results", "0")
+        .action(withExitCode(async (type, options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_query",
+                inputPath: options.input,
+                command,
+                positionals: [{ name: "type", value: type }],
+            });
+            return undefined;
+        }
+        return queryCommand(type, options);
+    }));
+    program
+        .command("search [query]")
+        .description(getSpec("kb_search").description)
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--type <type>", "Filter by entity type")
+        .option("--format <format>", "Output format: json|table", "table")
+        .option("--limit <n>", "Limit results", "20")
+        .option("--offset <n>", "Skip results", "0")
+        .action(async (query, options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_search",
+                inputPath: options.input,
+                command,
+                positionals: [{ name: "query", value: query }],
+            });
+            return;
+        }
+        await searchCommand(query, options);
+    });
+    program
+        .command("status")
+        .description(getSpec("kb_status").description)
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--format <format>", "Output format: json|table", "table")
+        .action(async (options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_status",
+                inputPath: options.input,
+                command,
+            });
+            return;
+        }
+        await statusCommand(options);
+    });
+}

package/dist/cli-register-maintenance.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerMaintenanceCommands(program: Command): void;
+//# sourceMappingURL=cli-register-maintenance.d.ts.map

package/dist/cli-register-maintenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-register-maintenance.d.ts","sourceRoot":"","sources":["../src/cli-register-maintenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoClE"}

package/dist/cli-register-maintenance.js

@@ -0,0 +1,36 @@
+import { withExitCode } from "./cli-command.js";
+import { branchEnsureCommand } from "./commands/branch.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { gcCommand } from "./commands/gc.js";
+import { usageMetricsCommand } from "./commands/usage-metrics.js";
+// implements REQ-kibi-operation-interface-parity
+export function registerMaintenanceCommands(program) {
+    program
+        .command("gc")
+        .description("Garbage collect stale branch KBs")
+        .option("--dry-run", "Preview without deleting (default)", true)
+        .option("--force", "Actually delete stale branches")
+        .action(async (options) => {
+        await gcCommand({ dryRun: !options.force, force: options.force });
+    });
+    program
+        .command("doctor")
+        .description("Diagnose KB setup and configuration")
+        .action(withExitCode(async () => doctorCommand()));
+    program
+        .command("usage-metrics")
+        .description("Report usage and quality metrics from .kb/usage.log")
+        .option("--format <format>", "Output format: json|table", "table")
+        .option("--limit <n>", "Limit top zero-result source files", "10")
+        .action(withExitCode(async (options) => usageMetricsCommand(options)));
+    program
+        .command("branch")
+        .description("Manage branch KBs")
+        .argument("<action>", "Action: ensure")
+        .option("--from <branch>", "Source branch to copy KB from")
+        .action(async (action, options) => {
+        if (action === "ensure") {
+            await branchEnsureCommand(options);
+        }
+    });
+}

package/dist/cli-register-reporting.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerReportingCommands(program: Command): void;
+//# sourceMappingURL=cli-register-reporting.d.ts.map

package/dist/cli-register-reporting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-register-reporting.d.ts","sourceRoot":"","sources":["../src/cli-register-reporting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUzC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuHhE"}

package/dist/cli-register-reporting.js

@@ -0,0 +1,101 @@
+import { withExitCode } from "./cli-command.js";
+import { runJsonInvocation } from "./cli-json-command.js";
+import { checkCommand } from "./commands/check.js";
+import { coverageCommand } from "./commands/coverage.js";
+import { gapsCommand } from "./commands/gaps.js";
+import { graphCommand } from "./commands/graph.js";
+import { getSpec } from "./public/operations/index.js";
+// implements REQ-kibi-operation-interface-parity
+export function registerReportingCommands(program) {
+    program
+        .command("find-gaps [type]")
+        .alias("gaps")
+        .description(getSpec("kb_find_gaps").description)
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--missing-rel <rels>", "Comma-separated missing relationship filters")
+        .option("--present-rel <rels>", "Comma-separated present relationship filters")
+        .option("--tag <tags>", "Comma-separated tag filter")
+        .option("--source <path>", "Source file substring filter")
+        .option("--limit <n>", "Limit results", "100")
+        .option("--offset <n>", "Skip results", "0")
+        .option("--format <format>", "Output format: json|table", "table")
+        .action(async (type, options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_find_gaps",
+                inputPath: options.input,
+                command,
+                positionals: [{ name: "type", value: type }],
+            });
+            return;
+        }
+        await gapsCommand(type, options);
+    });
+    program
+        .command("coverage")
+        .description(getSpec("kb_coverage").description)
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--by <group>", "Coverage mode: req|symbol|type", "req")
+        .option("--tag <tags>", "Comma-separated tag filter")
+        .option("--include-passing", "Include passing rows", false)
+        .option("--no-include-transitive", "Disable transitive symbol coverage")
+        .option("--limit <n>", "Limit results", "100")
+        .option("--offset <n>", "Skip results", "0")
+        .option("--format <format>", "Output format: json|table", "table")
+        .action(async (options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_coverage",
+                inputPath: options.input,
+                command,
+            });
+            return;
+        }
+        await coverageCommand(options);
+    });
+    program
+        .command("graph")
+        .description(getSpec("kb_graph").description)
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--from <ids>", "Comma-separated seed IDs")
+        .option("--relationships <rels>", "Comma-separated relationship filter")
+        .option("--direction <direction>", "Direction: outgoing|incoming|both", "outgoing")
+        .option("--depth <n>", "Traversal depth", "1")
+        .option("--entity-types <types>", "Comma-separated entity type filter")
+        .option("--max-nodes <n>", "Maximum node count", "200")
+        .option("--max-edges <n>", "Maximum edge count", "500")
+        .option("--format <format>", "Output format: json|table", "table")
+        .action(async (options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_graph",
+                inputPath: options.input,
+                command,
+            });
+            return;
+        }
+        await graphCommand(options);
+    });
+    program
+        .command("check")
+        .description(getSpec("kb_check").description)
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--fix", "Suggest fixes for violations")
+        .option("--kb-path <dir>", "Path to KB directory (overrides branch resolution)")
+        .option("--rules <csv>", "Comma-separated allowlist of rule names to run")
+        .option("--staged", "Run check only against staged changes (experimental)")
+        .option("--min-links <n>", "Minimum number of links required for symbol coverage", "1")
+        .option("--dry-run", "Do not modify files; only print what would happen")
+        .option("--format <format>", "Output format: text|json", "text")
+        .action(withExitCode(async (options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_check",
+                inputPath: options.input,
+                command,
+            });
+            return undefined;
+        }
+        return checkCommand(options);
+    }));
+}

package/dist/cli-register-skills.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerSkillsCommands(program: Command): void;
+//# sourceMappingURL=cli-register-skills.d.ts.map

package/dist/cli-register-skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-register-skills.d.ts","sourceRoot":"","sources":["../src/cli-register-skills.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoF7D"}

package/dist/cli-register-skills.js

@@ -0,0 +1,71 @@
+import { withExitCode } from "./cli-command.js";
+import { runJsonInvocation } from "./cli-json-command.js";
+import { skillsListCommand, skillsLoadCommand, skillsReadCommand, skillsValidateCommand, } from "./commands/skills.js";
+// implements REQ-kibi-operation-interface-parity
+export function registerSkillsCommands(program) {
+    const skillsProgram = program
+        .command("skills")
+        .description("Manage bundled markdown skills");
+    skillsProgram
+        .command("list")
+        .description("List bundled markdown skills")
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--format <format>", "Output format: json|table", "table")
+        .action(async (options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_skills_list",
+                inputPath: options.input,
+                command,
+            });
+            return;
+        }
+        await skillsListCommand(options);
+    });
+    skillsProgram
+        .command("load")
+        .description("Load a bundled markdown skill")
+        .argument("[id]", "Bundled skill ID")
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--format <format>", "Output format: json|markdown", "markdown")
+        .action(async (id, options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_skills_load",
+                inputPath: options.input,
+                command,
+                positionals: [{ name: "id", value: id }],
+            });
+            return;
+        }
+        await skillsLoadCommand(id ?? "", options);
+    });
+    skillsProgram
+        .command("read")
+        .description("Read a declared bundled skill resource")
+        .argument("[id]", "Bundled skill ID")
+        .argument("[resource]", "Declared resource path")
+        .option("--input <path>", "JSON input file (use - for stdin)")
+        .option("--format <format>", "Output format: text|json", "text")
+        .action(async (id, resource, options, command) => {
+        if (options.input !== undefined) {
+            await runJsonInvocation({
+                operationName: "kb_skills_read",
+                inputPath: options.input,
+                command,
+                positionals: [
+                    { name: "id", value: id },
+                    { name: "resource", value: resource },
+                ],
+            });
+            return;
+        }
+        await skillsReadCommand(id ?? "", resource ?? "", options);
+    });
+    skillsProgram
+        .command("validate")
+        .description("Validate a bundled markdown skill path")
+        .argument("<path>", "Skill bundle directory or SKILL.md path")
+        .option("--format <format>", "Output format: json|table", "table")
+        .action(withExitCode(async (pathLike, options) => skillsValidateCommand(pathLike, options)));
+}