kibi-cli 0.12.8 → 0.16.1

package/dist/public/impact/coverage-depth-quality.js

@@ -0,0 +1,179 @@
+function entitiesById(manifestResults) {
+    return new Map(manifestResults.map((result) => [result.entity.id, result.entity]));
+}
+function outgoingTargets(lookup) {
+    return lookup.result.relationships.flatMap((relationship) => {
+        if (relationship.type !== lookup.relationshipType)
+            return [];
+        const target = lookup.entities.get(relationship.to);
+        return target?.type === lookup.type ? [target] : [];
+    });
+}
+function incomingSources(lookup) {
+    return lookup.manifestResults.flatMap((result) => {
+        if (result.entity.type !== lookup.type)
+            return [];
+        return result.relationships.some((relationship) => relationship.type === lookup.relationshipType &&
+            relationship.to === lookup.targetId)
+            ? [result.entity]
+            : [];
+    });
+}
+function uniqueEntities(entities) {
+    return [
+        ...new Map(entities.map((entity) => [entity.id, entity])).values(),
+    ].toSorted((left, right) => left.id.localeCompare(right.id));
+}
+function testScope(test) {
+    if (test.verification_scope !== undefined)
+        return test.verification_scope;
+    if (test.tags?.some((tag) => tag.toLowerCase() === "e2e") === true) {
+        return "end_to_end";
+    }
+    return test.source.toLowerCase().includes("e2e") ? "end_to_end" : "unknown";
+}
+function passingTests(tests) {
+    return tests.filter((test) => test.status === "passing");
+}
+function classifyCoverageDepth(coverage) {
+    const allTests = uniqueEntities([
+        ...coverage.directTests,
+        ...coverage.scenarioTests,
+    ]);
+    const directPassingTests = passingTests(coverage.directTests);
+    if (directPassingTests.some((test) => testScope(test) === "end_to_end")) {
+        return "direct_passing_e2e";
+    }
+    if (directPassingTests.some((test) => testScope(test) === "integration")) {
+        return "direct_passing_integration";
+    }
+    const scenarioPassingTests = passingTests(coverage.scenarioTests);
+    if (scenarioPassingTests.some((test) => testScope(test) === "end_to_end")) {
+        return "scenario_passing_e2e";
+    }
+    if (scenarioPassingTests.some((test) => testScope(test) === "integration")) {
+        return "scenario_passing_integration";
+    }
+    const allPassingTests = passingTests(allTests);
+    if (allPassingTests.length > 0 &&
+        allPassingTests.every((test) => testScope(test) === "unit")) {
+        return "unit_only";
+    }
+    if (allTests.length > 0)
+        return "open_or_nonpassing_tests_only";
+    if (coverage.scenarioCount > 0)
+        return "scenario_only_no_test";
+    return "no_test_evidence";
+}
+function isReviewableCoverageDepth(coverageDepth) {
+    return (coverageDepth === "unit_only" ||
+        coverageDepth === "open_or_nonpassing_tests_only" ||
+        coverageDepth === "scenario_only_no_test" ||
+        coverageDepth === "no_test_evidence");
+}
+function uniqueStrings(values) {
+    return [...new Set(values)].toSorted((left, right) => left.localeCompare(right));
+}
+function coverageDepthSuggestion(coverageDepth) {
+    if (coverageDepth === "unit_only") {
+        return "Keep unit coverage where appropriate; add or link a passing end-to-end or scenario-backed test when this behavior warrants e2e confidence.";
+    }
+    return "Add or link passing tests, preferably end-to-end or scenario-backed when this behavior warrants e2e confidence.";
+}
+function createDiagnostic(coverage) {
+    const coverageDepth = classifyCoverageDepth(coverage);
+    if (!isReviewableCoverageDepth(coverageDepth))
+        return undefined;
+    const allTests = uniqueEntities([
+        ...coverage.directTests,
+        ...coverage.scenarioTests,
+    ]);
+    return {
+        id: "coverage_depth_review",
+        severity: "review",
+        blocking: false,
+        category: "coverage",
+        entityId: coverage.requirement.id,
+        source: coverage.requirement.source,
+        files: [coverage.requirement.source],
+        message: `Requirement ${coverage.requirement.id} (${coverage.requirement.title}) has ${coverageDepth} coverage depth and may need stronger behavior-level evidence.`,
+        suggestion: coverageDepthSuggestion(coverageDepth),
+        evidence: {
+            requirementId: coverage.requirement.id,
+            title: coverage.requirement.title,
+            source: coverage.requirement.source,
+            coverageDepth,
+            directTests: coverage.directTests.map((test) => test.id),
+            scenarioTests: coverage.scenarioTests.map((test) => test.id),
+            testStatuses: uniqueStrings(allTests.map((test) => test.status)),
+            verificationScopes: uniqueStrings(allTests.map(testScope)),
+        },
+    };
+}
+function coverageForRequirement(result, manifestResults, entities) {
+    const resultsById = new Map(manifestResults.map((manifestResult) => [
+        manifestResult.entity.id,
+        manifestResult,
+    ]));
+    const scenarios = outgoingTargets({
+        result,
+        relationshipType: "specified_by",
+        type: "scenario",
+        entities,
+    });
+    const directTests = uniqueEntities([
+        ...outgoingTargets({
+            result,
+            relationshipType: "verified_by",
+            type: "test",
+            entities,
+        }),
+        ...outgoingTargets({
+            result,
+            relationshipType: "covered_by",
+            type: "test",
+            entities,
+        }),
+        ...incomingSources({
+            manifestResults,
+            targetId: result.entity.id,
+            relationshipType: "validates",
+            type: "test",
+        }),
+    ]);
+    const scenarioTests = uniqueEntities(scenarios.flatMap((scenario) => {
+        const scenarioResult = resultsById.get(scenario.id);
+        return [
+            ...incomingSources({
+                manifestResults,
+                targetId: scenario.id,
+                relationshipType: "validates",
+                type: "test",
+            }),
+            ...(scenarioResult === undefined
+                ? []
+                : outgoingTargets({
+                    result: scenarioResult,
+                    relationshipType: "verified_by",
+                    type: "test",
+                    entities,
+                })),
+        ];
+    }));
+    return {
+        requirement: result.entity,
+        scenarioCount: scenarios.length,
+        directTests,
+        scenarioTests,
+    };
+}
+export function createCoverageDepthQualityDiagnostics(manifestResults) {
+    const entities = entitiesById(manifestResults);
+    return manifestResults
+        .filter((result) => result.entity.type === "req")
+        .flatMap((result) => {
+        const diagnostic = createDiagnostic(coverageForRequirement(result, manifestResults, entities));
+        return diagnostic === undefined ? [] : [diagnostic];
+    })
+        .toSorted((left, right) => (left.entityId ?? "").localeCompare(right.entityId ?? ""));
+}

package/dist/public/impact/diagnostics.d.ts

@@ -0,0 +1,7 @@
+import type { KibiImpactDiagnostic } from "../../traceability/staged-diagnostics.js";
+import type { QualityDiagnostic, SemanticReviewDiagnosticsOptions, SymbolGranularityDiagnosticsOptions } from "./types.js";
+export declare function createSymbolGranularityDiagnostics(options: SymbolGranularityDiagnosticsOptions): KibiImpactDiagnostic[];
+export declare function createSemanticReviewDiagnostics(options: SemanticReviewDiagnosticsOptions): KibiImpactDiagnostic[];
+export declare function hasBlockingImpactDiagnostics(diagnostics: readonly KibiImpactDiagnostic[]): boolean;
+export declare function hasBlockingQualityDiagnostics(diagnostics: readonly QualityDiagnostic[]): boolean;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/public/impact/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/public/impact/diagnostics.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAWrF,OAAO,KAAK,EACV,iBAAiB,EACjB,gCAAgC,EAChC,mCAAmC,EACpC,MAAM,YAAY,CAAC;AA2FpB,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,mCAAmC,GAC3C,oBAAoB,EAAE,CA+CxB;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,oBAAoB,EAAE,CAsBxB;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,SAAS,oBAAoB,EAAE,GAC3C,OAAO,CAET;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,SAAS,iBAAiB,EAAE,GACxC,OAAO,CAIT"}

package/dist/public/impact/diagnostics.js

@@ -0,0 +1,126 @@
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+import { extractSymbolsFromStagedFile, } from "../../traceability/symbol-extract.js";
+import { getBehavioralSymbolNames, getNonBehavioralSymbolNames, isAllowedGranularityReason, isTraceabilityRelationshipType, } from "../symbol-granularity.js";
+function isNarrowerSymbol(manifestSymbolName, candidate, sourceSymbols) {
+    if (candidate.name === manifestSymbolName)
+        return false;
+    if (candidate.name.startsWith(`${manifestSymbolName}.`))
+        return true;
+    return !sourceSymbols.some((symbol) => symbol.name === manifestSymbolName);
+}
+function hasTraceabilityRelationship(result) {
+    return result.relationships.some((relationship) => isTraceabilityRelationshipType(relationship.type));
+}
+function hasValidGranularityReason(result) {
+    return isAllowedGranularityReason(result.entity.granularity_reason);
+}
+function readSourceSymbols(sourceFile, sourceContentByFile, workspaceRoot) {
+    const stagedContent = sourceContentByFile?.get(sourceFile);
+    if (stagedContent !== undefined) {
+        return extractSymbolsFromStagedFile({
+            path: sourceFile,
+            status: "M",
+            hunkRanges: [{ start: 1, end: Number.MAX_SAFE_INTEGER }],
+            content: stagedContent,
+        });
+    }
+    const absolutePath = path.isAbsolute(sourceFile)
+        ? sourceFile
+        : path.resolve(workspaceRoot, sourceFile);
+    if (!existsSync(absolutePath))
+        return [];
+    return extractSymbolsFromStagedFile({
+        path: sourceFile,
+        status: "M",
+        hunkRanges: [{ start: 1, end: Number.MAX_SAFE_INTEGER }],
+        content: readFileSync(absolutePath, "utf8"),
+    });
+}
+function getGranularSymbolsForSourceFile(sourceFile, options) {
+    const sourceSymbols = readSourceSymbols(sourceFile, options.sourceContentByFile, options.workspaceRoot ?? process.cwd());
+    const changedSymbols = options.symbolsByFile.get(sourceFile);
+    return {
+        candidateSymbols: changedSymbols ?? sourceSymbols,
+        sourceSymbols: sourceSymbols.length > 0 ? sourceSymbols : (changedSymbols ?? []),
+    };
+}
+function formatRelationshipTargets(symbol) {
+    const targets = [
+        ...new Set((symbol.relationships ?? [])
+            .filter((relationship) => isTraceabilityRelationshipType(relationship.type))
+            .map((relationship) => relationship.to)),
+    ].sort();
+    return targets.length > 0 ? targets.join(", ") : "linked requirements/tests";
+}
+function isChangedBehavioralReviewCandidate(symbol) {
+    if (symbol.role !== "behavioral")
+        return false;
+    if (symbol.kind === "class")
+        return false;
+    return symbol.hunkRanges.length > 0;
+}
+export function createSymbolGranularityDiagnostics(options) {
+    const diagnostics = [];
+    for (const result of options.manifestResults) {
+        if (options.activeEntityIds !== undefined &&
+            !options.activeEntityIds.has(result.entity.id)) {
+            continue;
+        }
+        if (!result.sourceFile)
+            continue;
+        if (!hasTraceabilityRelationship(result))
+            continue;
+        if (hasValidGranularityReason(result))
+            continue;
+        const { candidateSymbols, sourceSymbols } = getGranularSymbolsForSourceFile(result.sourceFile, options);
+        const narrowerSymbols = candidateSymbols.filter((symbol) => isNarrowerSymbol(result.entity.title, symbol, sourceSymbols));
+        if (narrowerSymbols.length === 0)
+            continue;
+        const behavioralNames = getBehavioralSymbolNames(narrowerSymbols);
+        if (behavioralNames.length === 0)
+            continue;
+        const nonBehavioralNames = getNonBehavioralSymbolNames(narrowerSymbols);
+        const ignoredSymbolsSuggestion = nonBehavioralNames.length > 0
+            ? ` Non-behavioral symbols ignored for this decision: ${nonBehavioralNames.join(", ")}.`
+            : "";
+        diagnostics.push({
+            id: "symbol_granularity_violation",
+            severity: "error",
+            blocking: true,
+            category: "symbol",
+            files: [result.entity.source, result.sourceFile],
+            docs: ["docs/symbol-traceability-taxonomy.md"],
+            message: `Symbol ${result.entity.id} links ${result.sourceFile} coarsely while granular symbols are available (behavioral only): ${behavioralNames.join(", ")}`,
+            suggestion: `Move ownership/coverage/test relationships to the narrow behavioral symbol, add a manifest behavioral anchor, or add granularity_reason with config-artifact, module-level-behavior, extractor-miss, or legacy-link when the coarse symbol is intentional.${ignoredSymbolsSuggestion}`,
+        });
+    }
+    return diagnostics;
+}
+export function createSemanticReviewDiagnostics(options) {
+    const diagnostics = [];
+    for (const symbols of options.symbolsByFile.values()) {
+        for (const symbol of symbols) {
+            if (!isChangedBehavioralReviewCandidate(symbol))
+                continue;
+            const linkedTargets = formatRelationshipTargets(symbol);
+            diagnostics.push({
+                id: "symbol_semantic_review_needed",
+                severity: "warning",
+                blocking: false,
+                category: "symbol",
+                files: [symbol.location.file],
+                docs: ["docs/symbol-traceability-taxonomy.md"],
+                message: `Changed behavioral symbol ${symbol.name} needs semantic review against linked Kibi coverage: ${linkedTargets}`,
+                suggestion: `Use kb_search and kb_query for ${symbol.location.file}, then verify that ${linkedTargets} actually describe and test the changed behavior or UI copy. Update Kibi links or requirements/tests while the edit context is fresh.`,
+            });
+        }
+    }
+    return diagnostics;
+}
+export function hasBlockingImpactDiagnostics(diagnostics) {
+    return hasBlockingQualityDiagnostics(diagnostics);
+}
+export function hasBlockingQualityDiagnostics(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.blocking || diagnostic.severity === "error");
+}

package/dist/public/impact/diff-meaning.d.ts

@@ -0,0 +1,2 @@
+export declare function hasMeaningfulSourceDiff(diffText: string): boolean;
+//# sourceMappingURL=diff-meaning.d.ts.map

package/dist/public/impact/diff-meaning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-meaning.d.ts","sourceRoot":"","sources":["../../../src/public/impact/diff-meaning.ts"],"names":[],"mappings":"AAyGA,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAejE"}

package/dist/public/impact/diff-meaning.js

@@ -0,0 +1,101 @@
+function normalizeDiffContent(line) {
+    let normalized = "";
+    let quote = null;
+    let escaped = false;
+    for (const character of line.slice(1)) {
+        if (quote !== null) {
+            normalized += character;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (character === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === '"' || character === "'" || character === "`") {
+            quote = character;
+            normalized += character;
+            continue;
+        }
+        if (!/\s/.test(character))
+            normalized += character;
+    }
+    return normalized;
+}
+function removeSyntacticTrailingCommas(content) {
+    let normalized = "";
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const character = content[index];
+        if (character === undefined)
+            continue;
+        if (quote !== null) {
+            normalized += character;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (character === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === '"' || character === "'" || character === "`") {
+            quote = character;
+            normalized += character;
+            continue;
+        }
+        const nextCharacter = content[index + 1];
+        if (character === "," &&
+            (nextCharacter === ")" || nextCharacter === "]" || nextCharacter === "}")) {
+            continue;
+        }
+        normalized += character;
+    }
+    return normalized;
+}
+function hasMeaningfulDiffHunk(diffLines) {
+    let removedContent = "";
+    let addedContent = "";
+    for (const line of diffLines) {
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            removedContent += normalizeDiffContent(line);
+            continue;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            addedContent += normalizeDiffContent(line);
+        }
+    }
+    const normalizedRemovedContent = removeSyntacticTrailingCommas(removedContent);
+    const normalizedAddedContent = removeSyntacticTrailingCommas(addedContent);
+    if (normalizedRemovedContent.length === 0 &&
+        normalizedAddedContent.length === 0) {
+        return false;
+    }
+    return normalizedRemovedContent !== normalizedAddedContent;
+}
+// implements REQ-cli-staged-impact-enforcement
+export function hasMeaningfulSourceDiff(diffText) {
+    const hunkLines = [];
+    for (const line of diffText.split(/\r?\n/)) {
+        if (line.startsWith("@@")) {
+            if (hasMeaningfulDiffHunk(hunkLines))
+                return true;
+            hunkLines.length = 0;
+            continue;
+        }
+        if (hunkLines.length > 0 || line.startsWith("+") || line.startsWith("-")) {
+            hunkLines.push(line);
+        }
+    }
+    return hasMeaningfulDiffHunk(hunkLines);
+}

package/dist/public/impact/full-kb-quality.d.ts

@@ -0,0 +1,10 @@
+import type { PrologProcess } from "../../prolog.js";
+import type { QualityDiagnostic } from "./types.js";
+type FullKbQualityDiagnosticsOptions = {
+    readonly prolog: Pick<PrologProcess, "query">;
+    readonly hardViolationEntityIds?: ReadonlySet<string>;
+    readonly maxDiagnostics?: number;
+};
+export declare function collectFullKbQualityDiagnostics(options: FullKbQualityDiagnosticsOptions): Promise<readonly QualityDiagnostic[]>;
+export {};
+//# sourceMappingURL=full-kb-quality.d.ts.map

package/dist/public/impact/full-kb-quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAqBpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC9C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AA0KF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAmBvC"}

package/dist/public/impact/full-kb-quality.js

@@ -0,0 +1,191 @@
+import { parseEntityFromList, parseListOfLists, parseTriples, } from "../../prolog/codec.js";
+import { createCoverageDepthQualityDiagnostics } from "./coverage-depth-quality.js";
+import { createRequirementQualityDiagnostics } from "./requirement-quality.js";
+import { createSymbolQualityDiagnostics } from "./symbol-quality.js";
+const RELATIONSHIP_TYPES = [
+    "depends_on",
+    "executable_for",
+    "specified_by",
+    "verified_by",
+    "validates",
+    "implements",
+    "covered_by",
+    "constrained_by",
+    "constrains",
+    "requires_property",
+    "requires_predicate",
+    "guards",
+    "publishes",
+    "consumes",
+    "supersedes",
+    "relates_to",
+];
+function stringField(entity, key) {
+    const value = entity[key];
+    return typeof value === "string" ? value : "";
+}
+function optionalStringField(entity, key) {
+    const value = entity[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function optionalNumberField(entity, key) {
+    const value = entity[key];
+    return typeof value === "number" ? value : undefined;
+}
+function optionalStringArrayField(entity, key) {
+    const value = entity[key];
+    if (!Array.isArray(value))
+        return undefined;
+    return value.map((item) => String(item));
+}
+function toExtractedEntity(entity) {
+    const extracted = {
+        id: stringField(entity, "id"),
+        type: stringField(entity, "type"),
+        title: stringField(entity, "title"),
+        status: stringField(entity, "status"),
+        created_at: stringField(entity, "created_at"),
+        updated_at: stringField(entity, "updated_at"),
+        source: stringField(entity, "source"),
+    };
+    const tags = optionalStringArrayField(entity, "tags");
+    if (tags !== undefined)
+        extracted.tags = tags;
+    const owner = optionalStringField(entity, "owner");
+    if (owner !== undefined)
+        extracted.owner = owner;
+    const priority = optionalStringField(entity, "priority");
+    if (priority !== undefined)
+        extracted.priority = priority;
+    const severity = optionalStringField(entity, "severity");
+    if (severity !== undefined)
+        extracted.severity = severity;
+    const textRef = optionalStringField(entity, "text_ref");
+    if (textRef !== undefined)
+        extracted.text_ref = textRef;
+    const logicClaims = optionalStringArrayField(entity, "logic_claims");
+    if (logicClaims !== undefined)
+        extracted.logic_claims = logicClaims;
+    const granularityReason = optionalStringField(entity, "granularity_reason");
+    if (granularityReason !== undefined) {
+        extracted.granularity_reason = granularityReason;
+    }
+    const symbolKind = optionalStringField(entity, "symbol_kind");
+    if (symbolKind !== undefined)
+        extracted.symbol_kind = symbolKind;
+    const symbolRole = optionalStringField(entity, "symbol_role");
+    if (symbolRole !== undefined)
+        extracted.symbol_role = symbolRole;
+    const verificationScope = optionalStringField(entity, "verification_scope");
+    if (verificationScope === "unit" ||
+        verificationScope === "integration" ||
+        verificationScope === "end_to_end") {
+        extracted.verification_scope = verificationScope;
+    }
+    const sourceLine = optionalNumberField(entity, "sourceLine");
+    if (sourceLine !== undefined)
+        extracted.sourceLine = sourceLine;
+    const sourceColumn = optionalNumberField(entity, "sourceColumn");
+    if (sourceColumn !== undefined)
+        extracted.sourceColumn = sourceColumn;
+    const sourceEndLine = optionalNumberField(entity, "sourceEndLine");
+    if (sourceEndLine !== undefined)
+        extracted.sourceEndLine = sourceEndLine;
+    const sourceEndColumn = optionalNumberField(entity, "sourceEndColumn");
+    if (sourceEndColumn !== undefined)
+        extracted.sourceEndColumn = sourceEndColumn;
+    const factKind = optionalStringField(entity, "fact_kind");
+    if (factKind === "subject" ||
+        factKind === "property_value" ||
+        factKind === "observation" ||
+        factKind === "meta" ||
+        factKind === "predicate_schema" ||
+        factKind === "predicate") {
+        extracted.fact_kind = factKind;
+    }
+    const claimKey = optionalStringField(entity, "claim_key");
+    if (claimKey !== undefined)
+        extracted.claim_key = claimKey;
+    const claimText = optionalStringField(entity, "claim_text");
+    if (claimText !== undefined)
+        extracted.claim_text = claimText;
+    const predicateName = optionalStringField(entity, "predicate_name");
+    if (predicateName !== undefined)
+        extracted.predicate_name = predicateName;
+    const predicateNamespace = optionalStringField(entity, "predicate_namespace");
+    if (predicateNamespace !== undefined) {
+        extracted.predicate_namespace = predicateNamespace;
+    }
+    const predicateArity = optionalNumberField(entity, "predicate_arity");
+    if (predicateArity !== undefined)
+        extracted.predicate_arity = predicateArity;
+    for (const field of [
+        "argument_names",
+        "argument_types",
+        "argument_descriptions",
+        "aliases",
+        "examples",
+        "predicate_args",
+    ]) {
+        const values = optionalStringArrayField(entity, field);
+        if (values !== undefined)
+            extracted[field] = values;
+    }
+    return extracted;
+}
+function sourceFileFor(entity) {
+    return (optionalStringField(entity, "sourceFile") ??
+        optionalStringField(entity, "source_file"));
+}
+async function loadKbExtractionResults(prolog) {
+    const entityResult = await prolog.query("findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)");
+    const entities = entityResult.bindings.Results
+        ? parseListOfLists(entityResult.bindings.Results).map(parseEntityFromList)
+        : [];
+    const relationships = new Map();
+    for (const relationshipType of RELATIONSHIP_TYPES) {
+        const relResult = await prolog.query(`findall([From,To,'${relationshipType}'], kb_relationship(${relationshipType}, From, To), Rels)`);
+        const rows = relResult.bindings.Rels
+            ? parseTriples(relResult.bindings.Rels)
+            : [];
+        for (const [from, to, type] of rows) {
+            const current = relationships.get(from) ?? [];
+            current.push({ from, to, type });
+            relationships.set(from, current);
+        }
+    }
+    return entities.map((entity) => {
+        const result = {
+            entity: toExtractedEntity(entity),
+            relationships: relationships.get(stringField(entity, "id")) ?? [],
+        };
+        const sourceFile = sourceFileFor(entity);
+        if (sourceFile !== undefined) {
+            result.sourceFile = sourceFile;
+        }
+        return result;
+    });
+}
+function capDiagnostics(diagnostics, maxDiagnostics) {
+    return maxDiagnostics !== undefined && maxDiagnostics >= 0
+        ? diagnostics.slice(0, maxDiagnostics)
+        : diagnostics;
+}
+export async function collectFullKbQualityDiagnostics(options) {
+    const manifestResults = await loadKbExtractionResults(options.prolog);
+    const coverageDepthDiagnostics = createCoverageDepthQualityDiagnostics(manifestResults);
+    const diagnostics = [
+        ...createRequirementQualityDiagnostics({
+            manifestResults,
+            ...(options.hardViolationEntityIds !== undefined
+                ? { hardViolationEntityIds: options.hardViolationEntityIds }
+                : {}),
+        }),
+        ...coverageDepthDiagnostics,
+        ...createSymbolQualityDiagnostics({
+            manifestResults,
+            symbolsByFile: new Map(),
+        }),
+    ];
+    return capDiagnostics(diagnostics, options.maxDiagnostics);
+}

package/dist/public/impact/manifest.d.ts

@@ -0,0 +1,5 @@
+import type { ExtractionResult } from "../../extractors/markdown.js";
+import type { ManifestLookup } from "../../traceability/symbol-extract.js";
+export declare function readImpactManifestResults(workspaceRoot: string): readonly ExtractionResult[];
+export declare function createImpactManifestLookup(manifestResults: readonly ExtractionResult[]): ManifestLookup;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/public/impact/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/public/impact/manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAc3E,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,GACpB,SAAS,gBAAgB,EAAE,CAoB7B;AAED,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,SAAS,gBAAgB,EAAE,GAC3C,cAAc,CAYhB"}