kibi-cli 0.19.0 → 2.0.0

package/dist/cli-register-proof.js

@@ -0,0 +1,103 @@
+import { withExitCode } from "./cli-command.js";
+// implements REQ-kibi-proof-evidence-protocol
+export function registerProofCommand(program) {
+    program
+        .command("prove")
+        .description("Run the configured proof producers and ingest valid kibi.proof-run.v1 evidence")
+        .option("--test <id>", "Prove a single test entity")
+        .option("--requirement <id>", "Prove every proof-bearing test behind a requirement")
+        .option("--integration <ids>", "Prove only tests bound to these integrations (comma-separated)")
+        .option("--integration-except <ids>", "With --all (or another selector), skip tests bound to these integrations (comma-separated)")
+        .option("--all", "Prove every proof-bearing test in the knowledge base")
+        .action(withExitCode(async (options) => {
+        const mode = [
+            options.test ? "test" : undefined,
+            options.requirement ? "requirement" : undefined,
+            options.integration ? "integration" : undefined,
+            options.all ? "all" : undefined,
+        ].filter(Boolean).length;
+        if (mode > 1)
+            throw new Error("prove: choose exactly one selector: --test, --requirement, --integration, or --all");
+        if (options.integrationExcept && mode === 0)
+            throw new Error("prove: --integration-except requires a selector such as --all");
+        return await (await import("./commands/prove.js")).proveCommand({
+            ...(options.test === undefined ? {} : { testId: options.test }),
+            ...(options.requirement === undefined
+                ? {}
+                : { requirement: options.requirement }),
+            ...(options.integration === undefined
+                ? {}
+                : { integration: options.integration }),
+            ...(options.integrationExcept === undefined
+                ? {}
+                : { integrationExcept: options.integrationExcept }),
+            all: mode === 0,
+        });
+    }));
+    const proof = program
+        .command("proof")
+        .description("Inspect proof integration and maintain proof evidence");
+    proof
+        .command("inspect")
+        .description("Detect test infrastructure and recommend the strongest available proof integration")
+        .option("--json", "Emit structured JSON", false)
+        .action(withExitCode(async (options) => {
+        const result = await (await import("./proof/inspect.js")).inspectProofEnvironment(process.cwd());
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            return undefined;
+        }
+        process.stdout.write(renderInspection(result));
+        return undefined;
+    }));
+    proof
+        .command("prune")
+        .description("Shrink each test's proof_receipts history to its newest entries (re-proving the same snapshot appends duplicates; prune removes the superseded ones)")
+        .option("--test <id>", "Prune a single test entity")
+        .option("--keep <n>", "Number of newest receipts to keep per test (default 1)", "1")
+        .action(withExitCode(async (options) => {
+        return await (await import("./commands/proof-prune.js")).proofPruneCommand({
+            ...(options.test === undefined ? {} : { test: options.test }),
+            ...(options.keep === undefined ? {} : { keep: options.keep }),
+        });
+    }));
+    proof
+        .command("migrate-legacy")
+        .description("Remove legacy verification_receipts blocks from test documents that already carry a proof_contract")
+        .option("--test <id>", "Migrate a single test entity")
+        .action(withExitCode(async (options) => {
+        return await (await import("./commands/proof-migrate-legacy.js")).proofMigrateLegacyCommand({
+            ...(options.test === undefined ? {} : { test: options.test }),
+        });
+    }));
+}
+function renderInspection(result) {
+    const inspection = result;
+    const lines = ["Proof environment", ""];
+    if (inspection.languages.length > 0)
+        lines.push(`Languages: ${inspection.languages.join(", ")}`);
+    if (inspection.buildSystems.length > 0)
+        lines.push(`Build systems: ${inspection.buildSystems.join(", ")}`);
+    lines.push("");
+    lines.push("Detected runners:");
+    if (inspection.detectedRunners.length === 0) {
+        lines.push("  (none detected)");
+    }
+    else {
+        for (const runner of inspection.detectedRunners)
+            lines.push(`  ✓ ${runner}`);
+    }
+    if (inspection.ciWorkflows.length > 0)
+        lines.push(`CI workflows: ${inspection.ciWorkflows.join(", ")}`);
+    lines.push("");
+    lines.push(`Current integration: ${inspection.currentIntegration ?? "none"}`);
+    lines.push("");
+    lines.push(`Recommendation: ${inspection.recommendation}`);
+    if (inspection.missing.length > 0) {
+        lines.push("");
+        lines.push("Missing:");
+        for (const entry of inspection.missing)
+            lines.push(`  - ${entry}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

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

@@ -1 +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;AAYzC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgJhE"}
+{"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;AAYzC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAyKhE"}

package/dist/cli-register-reporting.js

@@ -30,6 +30,16 @@ export function registerReportingCommands(program) {
         }
         await (await import("./commands/gaps.js")).gapsCommand(type, options);
     });
+    program
+        .command("report")
+        .description("Generate a self-contained HTML requirement-health report for local viewing or CI publishing")
+        .option("--output <path>", "HTML file or directory (directories receive index.html)", "kibi-report")
+        .option("--open", "Open the generated report in the default browser", false)
+        .option("--tag <tags>", "Comma-separated tag filter")
+        .option("--limit <n>", "Maximum complete requirement rows (1-100000)", "10000")
+        .action(async (options) => {
+        await (await import("./commands/report.js")).reportCommand(options);
+    });
     program
         .command("coverage")
         .description(getCliOperationMetadata("kb_coverage").description)
@@ -37,6 +47,7 @@ export function registerReportingCommands(program) {
         .option("--by <group>", "Coverage mode: req|symbol|type", "req")
         .option("--tag <tags>", "Comma-separated tag filter")
         .option("--include-passing", "Include passing rows", false)
+        .option("--status <statuses>", "Comma-separated requirement proof-status filter (proven, missing, unresolved, not_applicable); implies include-passing")
         .option("--no-include-transitive", "Disable transitive symbol coverage")
         .option("--limit <n>", "Limit results", "100")
         .option("--offset <n>", "Skip results", "0")

package/dist/cli.d.ts

@@ -1,5 +1,9 @@
 import { Command } from "commander";
 export type { CommandResult } from "./cli-command.js";
+export declare function packageVersion(value: unknown): string;
+export declare function isCliEntrypoint(argv1: string | undefined, moduleUrl: string): boolean;
+export declare function exitCodeFromCliFailure(error: unknown): number;
 export declare function buildProgram(): Command;
 export declare function main(): Promise<never>;
+export declare function runCliIfEntrypoint(isEntrypoint?: boolean, start?: typeof main): Promise<void>;
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAmBtD,wBAAgB,YAAY,IAAI,OAAO,CAgBtC;AAGD,wBAAsB,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,CAgB3C"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMtD,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAUrD;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,SAAS,EAAE,MAAM,GAChB,OAAO,CAIT;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAI7D;AAGD,wBAAgB,YAAY,IAAI,OAAO,CAiBtC;AAGD,wBAAsB,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,CAc3C;AAED,wBAAsB,kBAAkB,CACtC,YAAY,UAAoD,EAChE,KAAK,cAAO,GACX,OAAO,CAAC,IAAI,CAAC,CAGf"}

package/dist/cli.js

@@ -23,10 +23,11 @@ import { Command } from "commander";
 import { registerFoundationCommands } from "./cli-register-foundation.js";
 import { registerJsonOnlyCommands } from "./cli-register-json.js";
 import { registerMaintenanceCommands } from "./cli-register-maintenance.js";
+import { registerProofCommand } from "./cli-register-proof.js";
 import { registerReportingCommands } from "./cli-register-reporting.js";
 import { registerSkillsCommands } from "./cli-register-skills.js";
 const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-function packageVersion(value) {
+export function packageVersion(value) {
     if (value !== null &&
         typeof value === "object" &&
         "version" in value &&
@@ -35,6 +36,14 @@ function packageVersion(value) {
     }
     return "0.1.0";
 }
+export function isCliEntrypoint(argv1, moduleUrl) {
+    return (argv1 !== undefined && moduleUrl === pathToFileURL(resolve(argv1)).href);
+}
+export function exitCodeFromCliFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    return 1;
+}
 // implements REQ-kibi-operation-interface-parity
 export function buildProgram() {
     const program = new Command()
@@ -46,6 +55,7 @@ export function buildProgram() {
     registerReportingCommands(program);
     registerMaintenanceCommands(program);
     registerSkillsCommands(program);
+    registerProofCommand(program);
     registerJsonOnlyCommands(program);
     return program;
 }
@@ -57,15 +67,14 @@ export async function main() {
         exitCode = process.exitCode ?? 0;
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(message);
-        exitCode = 1;
+        exitCode = exitCodeFromCliFailure(error);
     }
     await Promise.all([process.stdout, process.stderr].map((stream) => stream.writableNeedDrain ? once(stream, "drain") : Promise.resolve()));
     process.exit(exitCode);
 }
-const entryPath = process.argv[1];
-if (entryPath !== undefined &&
-    import.meta.url === pathToFileURL(resolve(entryPath)).href) {
-    void main();
+export async function runCliIfEntrypoint(isEntrypoint = isCliEntrypoint(process.argv[1], import.meta.url), start = main) {
+    if (!isEntrypoint)
+        return;
+    await start();
 }
+void runCliIfEntrypoint();

package/dist/commands/aggregated-checks.d.ts

@@ -6,7 +6,6 @@ import type { Violation } from "./check.js";
  * faster than running individual checks with multiple round-trips.
  * @param prolog - The Prolog process
  * @param rulesAllowlist - Set of rule names to run (null = all)
- * @param requireAdr - Whether to require ADR constraints for symbol-traceability
  */
-export declare function runAggregatedChecks(prolog: Pick<PrologProcess, "query">, rulesAllowlist: Set<string> | null, requireAdr?: boolean): Promise<Violation[]>;
+export declare function runAggregatedChecks(prolog: Pick<PrologProcess, "query">, rulesAllowlist: Set<string> | null): Promise<Violation[]>;
 //# sourceMappingURL=aggregated-checks.d.ts.map

package/dist/commands/aggregated-checks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregated-checks.d.ts","sourceRoot":"","sources":["../../src/commands/aggregated-checks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,cAAc,CAAC;AAEnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAW5C;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,EACpC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,EAClC,UAAU,UAAQ,GACjB,OAAO,CAAC,SAAS,EAAE,CAAC,CAwDtB"}
+{"version":3,"file":"aggregated-checks.d.ts","sourceRoot":"","sources":["../../src/commands/aggregated-checks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,cAAc,CAAC;AAEnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAW5C;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,EACpC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CA8DtB"}

package/dist/commands/aggregated-checks.js

@@ -1,26 +1,31 @@
 import path from "node:path";
 import { resolveKbPlPath } from "../prolog.js";
-import { escapeAtom } from "../prolog/codec.js";
+import { escapeAtom, toPrologAtom } from "../prolog/codec.js";
 /**
  * Run all checks using the aggregated Prolog predicates.
  * This makes a single Prolog call and parses JSON output, significantly
  * faster than running individual checks with multiple round-trips.
  * @param prolog - The Prolog process
  * @param rulesAllowlist - Set of rule names to run (null = all)
- * @param requireAdr - Whether to require ADR constraints for symbol-traceability
  */
-export async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr = false) {
+export async function runAggregatedChecks(prolog, rulesAllowlist) {
     // implements REQ-003
     const violations = [];
     const checksPlPath = path.join(path.dirname(resolveKbPlPath()), "checks.pl");
     const checksPlPathEscaped = escapeAtom(checksPlPath);
-    // Use check_all_json_with_options if available, otherwise fall back to check_all_json
-    const requireAdrStr = requireAdr ? "true" : "false";
-    const query = `(use_module('${checksPlPathEscaped}'), 
-    (   predicate_property(checks:check_all_json_with_options(_, _), _)
-    ->  call(checks:check_all_json_with_options(JsonString, ${requireAdrStr}))
+    const fallbackQuery = `(   predicate_property(checks:check_all_json_with_options(_, _), _)
+    ->  call(checks:check_all_json_with_options(JsonString, false))
     ;   call(checks:check_all_json(JsonString))
-    ))`;
+    )`;
+    const checksQuery = rulesAllowlist
+        ? `(   predicate_property(checks:check_selected_json(_, _), _)
+      ->  call(checks:check_selected_json([${[...rulesAllowlist]
+            .map(toPrologAtom)
+            .join(",")}], JsonString))
+      ;   ${fallbackQuery}
+      )`
+        : fallbackQuery;
+    const query = `(use_module('${checksPlPathEscaped}'), ${checksQuery})`;
     const result = await prolog.query(query);
     if (!result.success) {
         throw new Error(`Aggregated checks query failed: ${result.error || "Unknown error"}`);

package/dist/commands/branch.d.ts

@@ -1,6 +1,43 @@
 export interface BranchEnsureOptions {
     from?: string;
+    workspaceRoot?: string;
 }
+export interface BranchMigrateOptions {
+    from?: string;
+    to?: string;
+    apply?: boolean;
+    /** Hash-bound preview approval required for every mutating migration. */
+    approvalHash?: string;
+    recoverJournal?: string;
+    workspaceRoot?: string;
+}
+export interface BranchRecoverOptions {
+    apply?: boolean;
+    workspaceRoot?: string;
+}
+export interface BranchRestoreOptions {
+    branch?: string;
+    apply?: boolean;
+    workspaceRoot?: string;
+}
+/** Legacy migration changes storage format for one exact branch identity. */
+export declare function isSupportedLegacyBranchMigration(from: string, to: string): boolean;
+export declare function branchMigrationApprovalHash(from: string, to: string, sourcePath: string, targetPath: string): string;
+export declare function completeBranchJournalPaths(paths: readonly string[]): [string, string, string, string];
 export declare function branchEnsureCommand(options?: BranchEnsureOptions): Promise<void>;
+/**
+ * Move a legacy branch-named KB into the exact active Git branch namespace.
+ * Preview is the default; --apply is required because this changes tracked
+ * workspace state.
+ */
+export declare function branchMigrateCommand(options?: BranchMigrateOptions): Promise<void>;
+/**
+ * Rebuild an unreadable exact branch store from the current authored sources.
+ * The existing bytes are moved to a Kibi-owned recovery directory only after a
+ * clean staging store has been created successfully.
+ */
+export declare function branchRecoverCommand(options?: BranchRecoverOptions): Promise<void>;
+/** Restore the newest quarantined store for an exact branch identity. */
+export declare function branchRestoreCommand(options?: BranchRestoreOptions): Promise<void>;
 export default branchEnsureCommand;
 //# sourceMappingURL=branch.d.ts.map

package/dist/commands/branch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/commands/branch.ts"],"names":[],"mappings":"AA2BA,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAmDD,wBAAsB,mBAAmB,CACvC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/commands/branch.ts"],"names":[],"mappings":"AA4CA,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,6EAA6E;AAC7E,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,OAAO,CAET;AAuBD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CAeR;AAwBD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAMlC;AAwFD,wBAAsB,mBAAmB,CACvC,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CA2Kf;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAyFf;AAED,yEAAyE;AACzE,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAkDf;AAED,eAAe,mBAAmB,CAAC"}