kibi-cli 2.38.0 → 2.40.0

package/dist/operations/proof/explain.js

@@ -148,13 +148,218 @@ export function projectRequirementExplain(proof) {
                 }),
             }
             : {}),
+        ...refutationFields(proof, stages),
         ...claimFields(proof),
         scenarios,
+        ...negativePathField(stages.negativePath),
+        ...dimensionField(stages.dimension),
+        ...casesField(stages.cases),
         tests,
         productionSymbols: explanations.filter((item) => !structuralIds.has(item.symbolId)),
         structuralSymbols: explanations.filter((item) => structuralIds.has(item.symbolId)),
     };
 }
+// implements REQ-kibi-happy-path-gap
+function negativePathField(stage) {
+    if (stage === undefined)
+        return {};
+    const record = asRecord(stage);
+    const suggestions = Array.isArray(record.suggestedNegatives)
+        ? record.suggestedNegatives.map((item) => {
+            const entry = asRecord(item);
+            return {
+                claimKey: asString(entry.claimKey),
+                factId: asString(entry.factId),
+                assumption: asRecord(entry.assumption),
+            };
+        })
+        : [];
+    return {
+        negativePath: {
+            status: asString(record.status),
+            negativeScenarios: asStringArray(record.negativeScenarios),
+            claims: asStringArray(record.claims),
+            suggestedNegatives: suggestions,
+            ...waiverField(record.waiver),
+        },
+    };
+}
+function waiverField(raw) {
+    const waiver = asRecord(raw);
+    const reason = asString(waiver.reason);
+    const approvedBy = asString(waiver.approvedBy);
+    return reason === ""
+        ? {}
+        : { waiver: { reason, ...(approvedBy === "" ? {} : { approvedBy }) } };
+}
+// implements REQ-kibi-dimension-gap
+function dimensionField(stage) {
+    if (stage === undefined)
+        return {};
+    const record = asRecord(stage);
+    const claims = (raw) => Array.isArray(raw)
+        ? raw.map((item) => {
+            const entry = asRecord(item);
+            return {
+                claimKey: asString(entry.claimKey),
+                claimText: asString(entry.claimText),
+                quantifier: asString(entry.quantifier),
+                factIds: asStringArray(entry.factIds),
+                rewrites: asStringArray(entry.rewrites),
+                ...waiverField(entry.waiver),
+            };
+        })
+        : [];
+    return {
+        dimension: {
+            status: asString(record.status),
+            claims: claims(record.claims),
+            waivedClaims: claims(record.waivedClaims),
+        },
+    };
+}
+// implements REQ-kibi-case-coverage
+function casesField(stage) {
+    if (stage === undefined)
+        return {};
+    const record = asRecord(stage);
+    const cases = Array.isArray(record.cases)
+        ? record.cases.map((item) => {
+            const entry = asRecord(item);
+            return {
+                caseId: asString(entry.caseId),
+                claimKey: asString(entry.claimKey),
+                factId: asString(entry.factId),
+                generator: asString(entry.generator),
+                constraint: asString(entry.constraint),
+                predicted: asString(entry.predicted),
+                coverage: asString(entry.coverage),
+                scenarios: asStringArray(entry.scenarios),
+                assumption: asRecord(entry.assumption),
+                ...waiverField(entry.waiver),
+            };
+        })
+        : [];
+    const summary = asRecord(record.summary);
+    return {
+        cases: {
+            status: asString(record.status),
+            cases,
+            summary: Object.fromEntries(Object.entries(summary).filter((entry) => typeof entry[1] === "number")),
+            limitReached: record.limitReached === true,
+        },
+    };
+}
+function renderCases(view) {
+    const cases = view.cases;
+    if (cases === undefined || cases.cases.length === 0)
+        return [];
+    const summary = cases.summary;
+    const lines = [
+        "",
+        `Edge cases: ${cases.status} (${summary.covered ?? 0} covered, ${summary.uncovered ?? 0} uncovered, ${summary.unspecified ?? 0} unspecified, ${summary.waived ?? 0} waived)`,
+    ];
+    for (const row of cases.cases) {
+        const where = row.coverage === "covered" ? ` by ${row.scenarios.join(", ")}` : "";
+        lines.push(`  ${row.caseId} ${row.factId} ${row.constraint} -> ${row.predicted}: ${row.coverage}${where}`);
+        if (row.coverage === "uncovered" && row.predicted === "rejection")
+            lines.push(`    add a scenario that assumes ${JSON.stringify(row.assumption)} and expects rejection`);
+        if (row.waiver !== undefined && row.waiver.approvedBy === undefined)
+            lines.push(`    waiver awaiting approval (set case_waiver_approved_by to the person who accepts it, in this pull request): ${row.waiver.reason}`);
+    }
+    if (cases.limitReached)
+        lines.push("  (some facts have more cases than the per-fact limit of 12)");
+    return lines;
+}
+const DIMENSION_REWRITES = {
+    bound: "an integer property with the bound (lte, gte or eq)",
+    rule: "a rule over a variable (every X with P must Q)",
+    count: "an integer count of what varies",
+    set: "a set fact over the members",
+};
+function renderDimension(view) {
+    const dimension = view.dimension;
+    if (dimension === undefined || dimension.status === "not_required")
+        return [];
+    const lines = ["", `Quantified claims: ${dimension.status}`];
+    for (const claim of dimension.claims) {
+        lines.push(`  ${claim.claimKey} (${claim.factIds.join(", ")}): "${claim.quantifier.replaceAll("_", " ")}" is grounded on a boolean: ${claim.claimText}`);
+        const rewrites = claim.rewrites
+            .map((rewrite) => DIMENSION_REWRITES[rewrite] ?? rewrite)
+            .join("; or ");
+        if (rewrites !== "")
+            lines.push(`    ground it on ${rewrites}`);
+        if (claim.waiver !== undefined)
+            lines.push(`    waiver awaiting approval (set dimension_waiver_approved_by to the person who accepts it, in this pull request): ${claim.waiver.reason}`);
+    }
+    for (const claim of dimension.waivedClaims) {
+        lines.push(`  ${claim.claimKey} waived by ${claim.waiver?.approvedBy ?? ""}: ${claim.waiver?.reason ?? ""}`);
+    }
+    return lines;
+}
+function renderNegativePath(view) {
+    const negative = view.negativePath;
+    if (negative === undefined || negative.status === "not_required")
+        return [];
+    const lines = ["", `Failure side: ${negative.status}`];
+    if (negative.waiver !== undefined) {
+        lines.push(negative.waiver.approvedBy === undefined
+            ? `  waiver awaiting approval (set failure_side_waiver_approved_by to the person who accepts it, in this pull request): ${negative.waiver.reason}`
+            : `  waived by ${negative.waiver.approvedBy}: ${negative.waiver.reason}`);
+    }
+    for (const scenarioId of negative.negativeScenarios) {
+        lines.push(`  ${scenarioId} expects rejection or error`);
+    }
+    for (const suggestion of negative.suggestedNegatives) {
+        lines.push(`  ${suggestion.claimKey} (${suggestion.factId}): assume ${JSON.stringify(suggestion.assumption)} and expect rejection`);
+    }
+    return lines;
+}
+// implements REQ-kibi-claim-bound-proofs
+function refutationFields(proof, stages) {
+    const refutations = Array.isArray(proof.claimBindingRejections)
+        ? proof.claimBindingRejections.map((row) => {
+            const entry = asRecord(row);
+            return {
+                test: asString(entry.test),
+                claimKey: asString(entry.claimKey),
+                reason: asString(entry.reason),
+            };
+        })
+        : [];
+    const missing = asStringArray(asRecord(stages.sourceCoordinates).missingSymbols);
+    return {
+        ...(refutations.length > 0 ? { refutations } : {}),
+        ...(missing.length > 0 ? { missingCoordinateSymbols: missing } : {}),
+    };
+}
+/** Why each gap keeps a requirement from being tested end to end. */
+const GAP_REASONS = {
+    missing_passing_e2e: "no scenario-backed test has a passing end-to-end receipt (a test whose verification_scope is not end_to_end does not count)",
+    missing_proof_receipt: "a scenario-backed test has no proof receipt yet",
+    stale_proof_receipt: "a proof receipt is older than the current code",
+    failed_proof_receipt: "a proof receipt records a failed run",
+    invalid_proof_receipt: "a proof receipt cannot be checked",
+    proof_contract_mismatch: "a proof receipt was recorded for an older proof contract",
+    missing_production_symbol: "no production symbol implements the requirement",
+    missing_production_symbol_coverage: "a production symbol is not covered by a qualifying end-to-end test (a test whose verification_scope is not end_to_end does not qualify)",
+    missing_executable_test_symbol: "a scenario test has no test code linked executable_for",
+    missing_scenario: "the requirement has no scenario",
+    missing_scenario_test: "a scenario has no test",
+    happy_path_only: "no scenario exercises the failure side",
+    uncovered_case: "an edge case of the claim has no scenario",
+};
+/** One plain clause per gap, naming what it is about where Kibi knows. */
+// implements REQ-kibi-claim-bound-proofs
+export function gapReason(gap, view) {
+    if (gap === "missing_symbol_coordinates") {
+        const symbols = view.missingCoordinateSymbols ?? [];
+        const named = symbols.length > 0 ? `${symbols.slice(0, 3).join(", ")} ` : "a symbol ";
+        return `${gap}: ${named}${symbols.length > 1 ? "have" : "has"} no source coordinates, so Kibi cannot tie the proof to its code (kibi sync --refresh-symbol-coordinates places ${symbols.length > 1 ? "them" : "it"}; kibi check says why a symbol cannot be placed)`;
+    }
+    const reason = GAP_REASONS[gap];
+    return reason ? `${gap}: ${reason}` : gap;
+}
 function claimFields(proof) {
     const summary = asRecord(proof.claimSummary);
     const count = (key) => typeof summary[key] === "number" ? summary[key] : 0;
@@ -185,6 +390,9 @@ function claimFields(proof) {
                         ...(typeof entry.blocker === "string"
                             ? { blocker: entry.blocker }
                             : {}),
+                        ...(typeof entry.notProved === "string"
+                            ? { notProved: entry.notProved }
+                            : {}),
                         bindings: (Array.isArray(entry.bindings)
                             ? entry.bindings
                             : []).map((raw) => {
@@ -205,6 +413,19 @@ function claimFields(proof) {
             : {}),
     };
 }
+/** Gaps a refuted claim leaves that a derived proof would have covered. */
+const CERTIFIED_GAPS = new Set(["happy_path_only", "uncovered_case"]);
+// implements REQ-kibi-claim-bound-proofs
+function renderRefutations(view) {
+    const refutations = view.refutations ?? [];
+    if (refutations.length === 0)
+        return [];
+    const lines = refutations.map((row) => `refuted: ${row.test} refutes ${row.claimKey}: ${row.reason}. The code breaks the claim, so it is not proved; fix the code (or, with the person who owns the rule, the requirement) and run kibi prove`);
+    const covered = view.proofGaps.filter((gap) => CERTIFIED_GAPS.has(gap));
+    if (covered.length > 0)
+        lines.push(`  ${covered.join(" and ")} ${covered.length > 1 ? "follow" : "follows"} from the refutation: a proof that derives the claim covers its failure side and edge cases, a refuted one covers none`);
+    return lines;
+}
 function renderClaims(view) {
     if (view.claims === undefined)
         return [];
@@ -223,6 +444,9 @@ function renderClaims(view) {
             : `  ${claim.claimKey} not applicable (${claim.status})`);
         for (const binding of claim.bindings)
             lines.push(`    ${binding.test} ${binding.kind}: ${binding.binding}${binding.binding === "derived" ? ` (${binding.scope})` : ""}${binding.reason ? `: ${binding.reason}` : ""}`);
+        // implements REQ-kibi-claim-bound-proofs
+        if (claim.notProved === "requirement_not_tested")
+            lines.push(`    not proved: the certificate derives the claim, but a claim is proved only once the requirement is tested end to end, and it is not (proofStatus ${view.proofStatus})${view.proofGaps.length > 0 ? `: ${view.proofGaps.map((gap) => gapReason(gap, view)).join("; ")}` : ""}`);
     }
     return lines;
 }
@@ -258,6 +482,7 @@ function renderRequirementExplain(view) {
             ? []
             : [`evidenceLevel: ${view.evidenceLevel}`]),
         ...(view.certificateRejections ?? []).map((row) => `certificate rejected for ${row.test}: ${row.reason}`),
+        ...renderRefutations(view),
         ...renderClaims(view),
         "",
         "Scenarios",
@@ -267,6 +492,9 @@ function renderRequirementExplain(view) {
     for (const scenario of view.scenarios) {
         lines.push(`  ${scenario.id} -> ${scenario.tests.join(", ") || "(no tests)"}`);
     }
+    lines.push(...renderNegativePath(view));
+    lines.push(...renderDimension(view));
+    lines.push(...renderCases(view));
     lines.push("");
     for (const test of view.tests) {
         lines.push(`TEST ${test.testId}`);

package/dist/operations/proof/ingest-proof.d.ts

@@ -24,6 +24,8 @@ export type IngestProofTestResult = Readonly<{
     evidenceLevel?: string;
     /** Why the test's certificate did not re-check, for a certificate kind. */
     certificateRejection?: string;
+    /** The receipt's verification scope (unit, integration or end_to_end). */
+    scope?: string;
 }>;
 export type IngestProofResult = Readonly<{
     artifactDigest: string;

package/dist/operations/proof/ingest-proof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ingest-proof.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/ingest-proof.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AAOjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAkBjF,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,YAAY,EAGlB,MAAM,+BAA+B,CAAC;AAoBvC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5C,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC1B,4EAA4E;IAC5E,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC,CAAC;AAGH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC3C,CAAC,CAAC;AAEH,KAAK,iBAAiB,GAAG;IACvB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,iBAAiB,CAAC;CACtC,CAAC;AA8nBF,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,CAAC,CAuC5B"}
+{"version":3,"file":"ingest-proof.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/ingest-proof.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AAOjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAkBjF,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,YAAY,EAGlB,MAAM,+BAA+B,CAAC;AAoBvC,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5C,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC1B,4EAA4E;IAC5E,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAGH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC3C,CAAC,CAAC;AAEH,KAAK,iBAAiB,GAAG;IACvB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,iBAAiB,CAAC;CACtC,CAAC;AA+nBF,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,CAAC,CAuC5B"}

package/dist/operations/proof/ingest-proof.js

@@ -328,6 +328,7 @@ async function executeIngestProofUnlocked(args, context, lifecycle) {
             ...(typeof entry.receipt.certificate_rejection === "string"
                 ? { certificateRejection: entry.receipt.certificate_rejection }
                 : {}),
+            scope: entry.receipt.scope,
         },
     ]));
     const pendingCommits = [];

package/dist/operations/proof/java-package-shadow.d.ts

@@ -0,0 +1,14 @@
+interface Row {
+    readonly line: number;
+    readonly text: string;
+}
+/** Java source with comments, string, char and text-block contents removed. */
+export declare function javaCode(text: string): string;
+/**
+ * A filter for one read: keeps every row, except a marked row whose
+ * declaration the project's files rule out. Directory scans are shared by
+ * the files of the read.
+ */
+export declare function createShadowRowFilter(workspaceRoot: string): (file: string, rows: readonly Row[]) => Row[];
+export {};
+//# sourceMappingURL=java-package-shadow.d.ts.map

package/dist/operations/proof/java-package-shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"java-package-shadow.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/java-package-shadow.ts"],"names":[],"mappings":"AAoDA,UAAU,GAAG;IACX,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAgBD,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA8B7C;AAmND;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,EAAE,KAAK,GAAG,EAAE,CAgG1G"}