kibi-cli 0.12.7 → 0.14.0

package/dist/public/impact/manifest.js

@@ -0,0 +1,43 @@
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { extractFromManifest } from "../../extractors/manifest.js";
+import { loadConfig } from "../../utils/config.js";
+import { isTraceabilityRelationshipType } from "../symbol-granularity.js";
+import { normalizeSourceFile } from "./source-changes.js";
+function toTraceabilityRelationships(relationships) {
+    return relationships
+        .filter((relationship) => isTraceabilityRelationshipType(relationship.type))
+        .map((relationship) => ({ type: relationship.type, to: relationship.to }));
+}
+export function readImpactManifestResults(workspaceRoot) {
+    const config = loadConfig(workspaceRoot);
+    const symbolsPath = config.paths.symbols;
+    if (!symbolsPath)
+        return [];
+    const absolutePath = path.isAbsolute(symbolsPath)
+        ? symbolsPath
+        : path.resolve(workspaceRoot, symbolsPath);
+    if (!existsSync(absolutePath))
+        return [];
+    return extractFromManifest(absolutePath).map((result) => ({
+        entity: {
+            ...result.entity,
+            source: normalizeSourceFile(workspaceRoot, result.entity.source),
+        },
+        relationships: result.relationships,
+        ...(result.sourceFile !== undefined
+            ? { sourceFile: normalizeSourceFile(workspaceRoot, result.sourceFile) }
+            : {}),
+    }));
+}
+export function createImpactManifestLookup(manifestResults) {
+    const manifestLookup = new Map();
+    for (const result of manifestResults) {
+        const sourceFile = result.sourceFile ?? result.entity.source;
+        manifestLookup.set(`${sourceFile}:${result.entity.title}`, {
+            id: result.entity.id,
+            relationships: toTraceabilityRelationships(result.relationships),
+        });
+    }
+    return manifestLookup;
+}

package/dist/public/impact/requirement-quality.d.ts

@@ -0,0 +1,4 @@
+import type { KibiImpactDiagnostic } from "../../traceability/staged-diagnostics.js";
+import type { RequirementQualityDiagnosticsOptions } from "./types.js";
+export declare function createRequirementQualityDiagnostics(options: RequirementQualityDiagnosticsOptions): KibiImpactDiagnostic[];
+//# sourceMappingURL=requirement-quality.d.ts.map

package/dist/public/impact/requirement-quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/requirement-quality.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,YAAY,CAAC;AA+QvE,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,oCAAoC,GAC5C,oBAAoB,EAAE,CAMxB"}

package/dist/public/impact/requirement-quality.js

@@ -0,0 +1,216 @@
+const CURRENT_REQUIREMENT_STATUSES = new Set([
+    "open",
+    "in_progress",
+    "active",
+    "accepted",
+]);
+const TEST_LIKE_REQUIREMENT_STATUSES = new Set([
+    "passing",
+    "failing",
+    "skipped",
+    "pending",
+]);
+const STRICT_RELATIONSHIP_TYPES = new Set([
+    "constrains",
+    "requires_property",
+    "requires_predicate",
+]);
+const BROAD_REQUIREMENT_THRESHOLDS = {
+    implementingSymbols: 8,
+    scenarios: 6,
+    tests: 8,
+    dependentRequirements: 5,
+};
+const NORMATIVE_INDICATOR_PATTERNS = [
+    ["must", /\bmust\b/i],
+    ["only", /\bonly\b/i],
+    ["never", /\bnever\b/i],
+    ["limit", /\blimits?\b/i],
+    ["minimum", /\bminimum\b/i],
+    ["maximum", /\bmaximum\b/i],
+    ["at least", /\bat\s+least\b/i],
+    ["at most", /\bat\s+most\b/i],
+];
+function isRequirement(result) {
+    return result.entity.type === "req";
+}
+function isCurrentRequirement(result) {
+    return (isRequirement(result) &&
+        CURRENT_REQUIREMENT_STATUSES.has(result.entity.status));
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort();
+}
+function entityTypeById(results) {
+    const types = new Map();
+    for (const result of results) {
+        types.set(result.entity.id, result.entity.type);
+    }
+    return types;
+}
+function targetHasType(targetId, type, typesByEntityId) {
+    const targetType = typesByEntityId.get(targetId);
+    return targetType === undefined || targetType === type;
+}
+function collectFanout(requirementId, results, typesByEntityId) {
+    const implementingSymbolIds = [];
+    const scenarioIds = [];
+    const testIds = [];
+    const dependentRequirementIds = [];
+    for (const result of results) {
+        for (const relationship of result.relationships) {
+            if (relationship.type === "implements" &&
+                relationship.to === requirementId) {
+                implementingSymbolIds.push(result.entity.id);
+            }
+            if (result.entity.id === requirementId &&
+                relationship.type === "specified_by" &&
+                targetHasType(relationship.to, "scenario", typesByEntityId)) {
+                scenarioIds.push(relationship.to);
+            }
+            if (result.entity.id === requirementId &&
+                (relationship.type === "verified_by" ||
+                    relationship.type === "covered_by") &&
+                targetHasType(relationship.to, "test", typesByEntityId)) {
+                testIds.push(relationship.to);
+            }
+            if (relationship.type === "depends_on") {
+                if (result.entity.id === requirementId &&
+                    targetHasType(relationship.to, "req", typesByEntityId)) {
+                    dependentRequirementIds.push(relationship.to);
+                }
+                if (relationship.to === requirementId && result.entity.type === "req") {
+                    dependentRequirementIds.push(result.entity.id);
+                }
+            }
+        }
+    }
+    return {
+        implementingSymbolIds: sortedUnique(implementingSymbolIds),
+        scenarioIds: sortedUnique(scenarioIds),
+        testIds: sortedUnique(testIds),
+        dependentRequirementIds: sortedUnique(dependentRequirementIds),
+    };
+}
+function exceedsBroadThreshold(fanout) {
+    return (fanout.implementingSymbolIds.length >
+        BROAD_REQUIREMENT_THRESHOLDS.implementingSymbols ||
+        fanout.scenarioIds.length > BROAD_REQUIREMENT_THRESHOLDS.scenarios ||
+        fanout.testIds.length > BROAD_REQUIREMENT_THRESHOLDS.tests ||
+        fanout.dependentRequirementIds.length >
+            BROAD_REQUIREMENT_THRESHOLDS.dependentRequirements);
+}
+function isUmbrellaRequirement(result) {
+    const tags = result.entity.tags ?? [];
+    return tags.some((tag) => tag === "umbrella" || tag === "epic");
+}
+function createBroadRequirementDiagnostics(results) {
+    const typesByEntityId = entityTypeById(results);
+    return results.flatMap((result) => {
+        if (!isCurrentRequirement(result))
+            return [];
+        const fanout = collectFanout(result.entity.id, results, typesByEntityId);
+        if (!exceedsBroadThreshold(fanout))
+            return [];
+        if (isUmbrellaRequirement(result))
+            return [];
+        return [
+            {
+                id: "broad_requirement_review",
+                severity: "review",
+                blocking: false,
+                category: "requirement",
+                entityId: result.entity.id,
+                source: result.entity.source,
+                files: [result.entity.source],
+                docs: ["docs/entity-schema.md"],
+                message: `Requirement ${result.entity.id} has broad fanout that exceeds requirement review thresholds.`,
+                suggestion: "Split this into smaller behavioral requirements, or keep an explicit umbrella/epic tag when broad ownership is intentional.",
+                evidence: {
+                    implementingSymbolIds: fanout.implementingSymbolIds,
+                    implementingSymbolCount: fanout.implementingSymbolIds.length,
+                    implementingSymbolThreshold: BROAD_REQUIREMENT_THRESHOLDS.implementingSymbols,
+                    scenarioIds: fanout.scenarioIds,
+                    scenarioCount: fanout.scenarioIds.length,
+                    scenarioThreshold: BROAD_REQUIREMENT_THRESHOLDS.scenarios,
+                    testIds: fanout.testIds,
+                    testCount: fanout.testIds.length,
+                    testThreshold: BROAD_REQUIREMENT_THRESHOLDS.tests,
+                    dependentRequirementIds: fanout.dependentRequirementIds,
+                    dependentRequirementCount: fanout.dependentRequirementIds.length,
+                    dependentRequirementThreshold: BROAD_REQUIREMENT_THRESHOLDS.dependentRequirements,
+                },
+            },
+        ];
+    });
+}
+function createRequirementStatusDiagnostics(results) {
+    return results.flatMap((result) => {
+        if (!isRequirement(result))
+            return [];
+        if (!TEST_LIKE_REQUIREMENT_STATUSES.has(result.entity.status))
+            return [];
+        return [
+            {
+                id: "requirement_status_review",
+                severity: "review",
+                blocking: false,
+                category: "status",
+                entityId: result.entity.id,
+                source: result.entity.source,
+                files: [result.entity.source],
+                docs: ["docs/entity-schema.md"],
+                message: `Requirement ${result.entity.id} uses test-like status ${result.entity.status}.`,
+                suggestion: "Use requirement lifecycle statuses such as open, in_progress, active, accepted, closed, deprecated, or superseded; keep passing/failing statuses on test entities.",
+                evidence: { status: result.entity.status },
+            },
+        ];
+    });
+}
+function strictRelationshipTypes(result) {
+    return sortedUnique(result.relationships
+        .filter((relationship) => STRICT_RELATIONSHIP_TYPES.has(relationship.type))
+        .map((relationship) => relationship.type));
+}
+function matchedNormativeIndicators(text) {
+    return NORMATIVE_INDICATOR_PATTERNS.filter((entry) => entry[1].test(text)).map((entry) => entry[0]);
+}
+function createStrictFactModelingDiagnostics(options) {
+    return options.manifestResults.flatMap((result) => {
+        if (!isCurrentRequirement(result))
+            return [];
+        if (options.hardViolationEntityIds?.has(result.entity.id))
+            return [];
+        const relationshipTypes = strictRelationshipTypes(result);
+        if (relationshipTypes.length > 0)
+            return [];
+        const indicators = matchedNormativeIndicators(result.entity.title);
+        if (indicators.length === 0)
+            return [];
+        return [
+            {
+                id: "strict_fact_modeling_review",
+                severity: "review",
+                blocking: false,
+                category: "fact",
+                entityId: result.entity.id,
+                source: result.entity.source,
+                files: [result.entity.source],
+                docs: ["docs/modeling-cheatsheet.md", "docs/error-reference.md"],
+                message: `Requirement ${result.entity.id} contains normative prose but has no strict fact or predicate relationship.`,
+                suggestion: "Use kb_model_requirement for strict property facts, or kb_suggest_predicates when the claim fits a predicate schema.",
+                evidence: {
+                    matchedIndicators: indicators,
+                    strictRelationshipTypes: relationshipTypes,
+                },
+            },
+        ];
+    });
+}
+export function createRequirementQualityDiagnostics(options) {
+    return [
+        ...createBroadRequirementDiagnostics(options.manifestResults),
+        ...createRequirementStatusDiagnostics(options.manifestResults),
+        ...createStrictFactModelingDiagnostics(options),
+    ];
+}

package/dist/public/impact/source-changes.d.ts

@@ -0,0 +1,5 @@
+import type { ChangedFileImpactOptions, SourceChange } from "./types.js";
+export declare function normalizeSourceFile(workspaceRoot: string, sourceFile: string): string;
+export declare function uniqueSorted(values: Iterable<string>): string[];
+export declare function collectSourceChanges(options: ChangedFileImpactOptions): SourceChange[];
+//# sourceMappingURL=source-changes.d.ts.map

package/dist/public/impact/source-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-changes.d.ts","sourceRoot":"","sources":["../../../src/public/impact/source-changes.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAiBzE,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,GACjB,MAAM,CAKR;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAE/D;AA6HD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,wBAAwB,GAChC,YAAY,EAAE,CAchB"}

package/dist/public/impact/source-changes.js

@@ -0,0 +1,129 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+import { getStagedFiles, parseHunksFromDiff, } from "../../traceability/git-staged.js";
+import { hasMeaningfulSourceDiff } from "./diff-meaning.js";
+const SOURCE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mts",
+    ".cts",
+    ".mjs",
+    ".cjs",
+]);
+function isSupportedSourcePath(filePath) {
+    return SOURCE_EXTENSIONS.has(path.extname(filePath));
+}
+export function normalizeSourceFile(workspaceRoot, sourceFile) {
+    const relativePath = path.isAbsolute(sourceFile)
+        ? path.relative(workspaceRoot, sourceFile)
+        : sourceFile;
+    return relativePath.split(path.sep).join("/");
+}
+export function uniqueSorted(values) {
+    return [...new Set(values)].sort();
+}
+function escapeGitPath(filePath) {
+    return filePath.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function runGit(workspaceRoot, command) {
+    return execSync(command, { cwd: workspaceRoot, encoding: "utf8" });
+}
+function readWorkingTreeSource(workspaceRoot, sourceFile) {
+    const absolutePath = path.resolve(workspaceRoot, sourceFile);
+    if (!existsSync(absolutePath))
+        return null;
+    return readFileSync(absolutePath, "utf8");
+}
+function fullFileHunk(content) {
+    return [{ start: 1, end: Math.max(1, content.split(/\r?\n/).length) }];
+}
+function getWorkingTreeDiffSourceFiles(workspaceRoot) {
+    try {
+        return uniqueSorted(runGit(workspaceRoot, "git diff --name-only --diff-filter=ACMR")
+            .split(/\r?\n/)
+            .map((filePath) => normalizeSourceFile(workspaceRoot, filePath.trim()))
+            .filter((filePath) => filePath.length > 0)
+            .filter(isSupportedSourcePath));
+    }
+    catch {
+        return [];
+    }
+}
+function getWorkingTreeHunks(workspaceRoot, sourceFile) {
+    try {
+        const diffText = runGit(workspaceRoot, `git diff -U0 -- "${escapeGitPath(sourceFile)}"`);
+        return parseHunksFromDiff(diffText);
+    }
+    catch {
+        return [];
+    }
+}
+function getStagedSourceChanges(workspaceRoot, sourceFileFilter) {
+    const stagedFiles = getStagedFiles((command, options) => execSync(command, { ...options, cwd: workspaceRoot }));
+    return stagedFiles
+        .filter((file) => isSupportedSourcePath(file.path))
+        .filter((file) => sourceFileFilter.size === 0 || sourceFileFilter.has(file.path))
+        .flatMap((file) => {
+        if (file.content === undefined || file.hunkRanges.length === 0)
+            return [];
+        if (file.diffText !== undefined &&
+            !hasMeaningfulSourceDiff(file.diffText)) {
+            return [];
+        }
+        return [
+            {
+                file: file.path,
+                status: file.status,
+                hunkRanges: file.hunkRanges,
+                content: file.content,
+            },
+        ];
+    });
+}
+function getWorkingTreeSourceChanges(workspaceRoot, sourceFileFilter) {
+    const sourceFiles = sourceFileFilter.size > 0
+        ? [...sourceFileFilter]
+        : getWorkingTreeDiffSourceFiles(workspaceRoot);
+    return sourceFiles.flatMap((sourceFile) => {
+        const content = readWorkingTreeSource(workspaceRoot, sourceFile);
+        if (content === null)
+            return [];
+        const diffText = runGit(workspaceRoot, `git diff -U0 -- "${escapeGitPath(sourceFile)}"`);
+        if (!hasMeaningfulSourceDiff(diffText))
+            return [];
+        const hunkRanges = getWorkingTreeHunks(workspaceRoot, sourceFile);
+        if (hunkRanges.length === 0)
+            return [];
+        return [{ file: sourceFile, status: "M", hunkRanges, content }];
+    });
+}
+function getExplicitSourceChanges(workspaceRoot, sourceFileFilter) {
+    return [...sourceFileFilter].flatMap((sourceFile) => {
+        const content = readWorkingTreeSource(workspaceRoot, sourceFile);
+        if (content === null)
+            return [];
+        return [
+            {
+                file: sourceFile,
+                status: "M",
+                hunkRanges: fullFileHunk(content),
+                content,
+            },
+        ];
+    });
+}
+export function collectSourceChanges(options) {
+    const workspaceRoot = path.resolve(options.workspaceRoot);
+    const sourceFileFilter = new Set((options.sourceFiles ?? [])
+        .map((sourceFile) => normalizeSourceFile(workspaceRoot, sourceFile))
+        .filter(isSupportedSourcePath));
+    if (options.staged)
+        return getStagedSourceChanges(workspaceRoot, sourceFileFilter);
+    if (options.includeWorkingTreeDiff) {
+        return getWorkingTreeSourceChanges(workspaceRoot, sourceFileFilter);
+    }
+    return getExplicitSourceChanges(workspaceRoot, sourceFileFilter);
+}

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

@@ -0,0 +1,6 @@
+import type { ExtractionResult } from "../../extractors/markdown.js";
+import type { ImpactExtractedSymbol, ImpactLinkedEntity, SymbolsByFile } from "./types.js";
+export declare function formatExtractedSymbols(symbolsByFile: SymbolsByFile): ImpactExtractedSymbol[];
+export declare function collectLinkedEntities(symbolsByFile: SymbolsByFile, manifestResults: readonly ExtractionResult[], activeSourceFiles: ReadonlySet<string>): ImpactLinkedEntity[];
+export declare function buildNextActions(sourceFiles: readonly string[]): string[];
+//# sourceMappingURL=summaries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"summaries.d.ts","sourceRoot":"","sources":["../../../src/public/impact/summaries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAIrE,OAAO,KAAK,EACV,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,EACd,MAAM,YAAY,CAAC;AAYpB,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,aAAa,GAC3B,qBAAqB,EAAE,CAazB;AAED,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,SAAS,gBAAgB,EAAE,EAC5C,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,GACrC,kBAAkB,EAAE,CA4CtB;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAYzE"}

package/dist/public/impact/summaries.js

@@ -0,0 +1,68 @@
+import { isTraceabilityRelationshipType } from "../symbol-granularity.js";
+import { uniqueSorted } from "./source-changes.js";
+function linkedEntityIdsFor(symbol) {
+    return uniqueSorted((symbol.relationships ?? [])
+        .filter((relationship) => isTraceabilityRelationshipType(relationship.type))
+        .map((relationship) => relationship.to));
+}
+export function formatExtractedSymbols(symbolsByFile) {
+    return [...symbolsByFile.values()]
+        .flatMap((symbols) => [...symbols])
+        .map((symbol) => ({
+        id: symbol.id,
+        name: symbol.name,
+        kind: symbol.kind,
+        role: symbol.role,
+        location: symbol.location,
+        hunkRanges: symbol.hunkRanges,
+        linkedEntityIds: linkedEntityIdsFor(symbol),
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+export function collectLinkedEntities(symbolsByFile, manifestResults, activeSourceFiles) {
+    const linkedEntities = new Map();
+    const add = (entity) => {
+        linkedEntities.set(`${entity.sourceSymbolId}:${entity.relationshipType}:${entity.id}`, entity);
+    };
+    for (const symbols of symbolsByFile.values()) {
+        for (const symbol of symbols) {
+            for (const relationship of symbol.relationships ?? []) {
+                if (!isTraceabilityRelationshipType(relationship.type))
+                    continue;
+                add({
+                    id: relationship.to,
+                    relationshipType: relationship.type,
+                    sourceSymbolId: symbol.id,
+                    sourceSymbolName: symbol.name,
+                });
+            }
+        }
+    }
+    for (const result of manifestResults) {
+        if (result.sourceFile === undefined ||
+            !activeSourceFiles.has(result.sourceFile)) {
+            continue;
+        }
+        for (const relationship of result.relationships) {
+            if (!isTraceabilityRelationshipType(relationship.type))
+                continue;
+            add({
+                id: relationship.to,
+                relationshipType: relationship.type,
+                sourceSymbolId: result.entity.id,
+                sourceSymbolName: result.entity.title,
+            });
+        }
+    }
+    return [...linkedEntities.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+export function buildNextActions(sourceFiles) {
+    if (sourceFiles.length === 0)
+        return [];
+    return [
+        `kb_search({ query: "${sourceFiles.join(" ")}" }) to discover requirements/tests that may describe the changed behavior.`,
+        ...sourceFiles.map((sourceFile) => `kb_query({ sourceFile: "${sourceFile}" }) to inspect exact source-linked Kibi entities before deciding whether requirements/tests need updates.`),
+        "Update narrower symbols, requirements, tests, or strict facts when diagnostics show broad or stale modeling.",
+        "rerun kb_check with the same sourceFiles/impact options after Kibi updates.",
+    ];
+}

package/dist/public/impact/symbol-quality-model.d.ts

@@ -0,0 +1,21 @@
+import type { ExtractionResult } from "../../extractors/markdown.js";
+import type { ExtractedSymbol } from "../../traceability/symbol-extract.js";
+import { type SymbolKind, type SymbolRole } from "../symbol-granularity.js";
+import type { SymbolQualityDiagnosticsOptions } from "./types.js";
+export type SymbolMetadata = {
+    readonly result: ExtractionResult;
+    readonly id: string;
+    readonly title: string;
+    readonly sourceFile: string;
+    readonly source: string;
+    readonly kind: SymbolKind | "component" | "service" | "module" | "config";
+    readonly role: SymbolRole;
+    readonly requirementTargetIds: readonly string[];
+    readonly coordinateKey: string | null;
+};
+export declare const AGGREGATE_KINDS: ReadonlySet<string>;
+export declare function collectSymbols(options: SymbolQualityDiagnosticsOptions): readonly SymbolMetadata[];
+export declare function isModuleOrConfig(symbol: SymbolMetadata): boolean;
+export declare function narrowerManifestSymbols(symbol: SymbolMetadata, symbols: readonly SymbolMetadata[]): readonly SymbolMetadata[];
+export declare function narrowerExtractedSymbols(symbol: SymbolMetadata, symbolsByFile: ReadonlyMap<string, readonly ExtractedSymbol[]>): readonly ExtractedSymbol[];
+//# sourceMappingURL=symbol-quality-model.d.ts.map

package/dist/public/impact/symbol-quality-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-quality-model.d.ts","sourceRoot":"","sources":["../../../src/public/impact/symbol-quality-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAC;AAElE,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1E,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAK9C,CAAC;AAyFH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,+BAA+B,GACvC,SAAS,cAAc,EAAE,CAyB3B;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAEhE;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,SAAS,cAAc,EAAE,GACjC,SAAS,cAAc,EAAE,CAO3B;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,cAAc,EACtB,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC,GAC7D,SAAS,eAAe,EAAE,CAO5B"}

package/dist/public/impact/symbol-quality-model.js

@@ -0,0 +1,116 @@
+import { getSymbolRole, } from "../symbol-granularity.js";
+export const AGGREGATE_KINDS = new Set([
+    "class",
+    "component",
+    "service",
+    "module",
+]);
+function isActiveSymbol(result) {
+    return result.entity.type === "symbol" && result.entity.status === "active";
+}
+function getRequirementTargets(result) {
+    return [
+        ...new Set(result.relationships
+            .filter((relationship) => relationship.type === "implements" &&
+            relationship.to.startsWith("REQ-"))
+            .map((relationship) => relationship.to)),
+    ].sort();
+}
+function inferKind(result) {
+    const explicitKind = result.entity.symbol_kind;
+    if (explicitKind === "component" ||
+        explicitKind === "service" ||
+        explicitKind === "module" ||
+        explicitKind === "config") {
+        return explicitKind;
+    }
+    if (explicitKind === "function" ||
+        explicitKind === "class" ||
+        explicitKind === "method" ||
+        explicitKind === "property" ||
+        explicitKind === "accessor" ||
+        explicitKind === "interface" ||
+        explicitKind === "type" ||
+        explicitKind === "variable" ||
+        explicitKind === "enum" ||
+        explicitKind === "unknown") {
+        return explicitKind;
+    }
+    if (result.entity.title.endsWith("Component"))
+        return "component";
+    if (result.entity.title.endsWith("Service"))
+        return "service";
+    if (result.entity.title.endsWith("Module"))
+        return "module";
+    if (result.entity.title.endsWith("Config"))
+        return "config";
+    if (result.entity.title.includes("."))
+        return "method";
+    return "unknown";
+}
+function inferRole(result, kind) {
+    const explicitRole = result.entity.symbol_role;
+    if (explicitRole === "behavioral" ||
+        explicitRole === "structural" ||
+        explicitRole === "type-shape" ||
+        explicitRole === "config" ||
+        explicitRole === "module" ||
+        explicitRole === "unknown") {
+        return explicitRole;
+    }
+    if (kind === "component" || kind === "service")
+        return "behavioral";
+    if (kind === "module")
+        return "module";
+    if (kind === "config")
+        return "config";
+    return getSymbolRole({ name: result.entity.title, kind });
+}
+function getCoordinateKey(result) {
+    const { sourceLine, sourceColumn, sourceEndLine, sourceEndColumn } = result.entity;
+    if (sourceLine === undefined ||
+        sourceColumn === undefined ||
+        sourceEndLine === undefined ||
+        sourceEndColumn === undefined) {
+        return null;
+    }
+    return `${sourceLine}:${sourceColumn}:${sourceEndLine}:${sourceEndColumn}`;
+}
+export function collectSymbols(options) {
+    return options.manifestResults
+        .filter((result) => options.activeEntityIds === undefined
+        ? isActiveSymbol(result)
+        : isActiveSymbol(result) &&
+            options.activeEntityIds.has(result.entity.id))
+        .flatMap((result) => {
+        if (result.sourceFile === undefined)
+            return [];
+        const kind = inferKind(result);
+        return [
+            {
+                result,
+                id: result.entity.id,
+                title: result.entity.title,
+                sourceFile: result.sourceFile,
+                source: result.entity.source,
+                kind,
+                role: inferRole(result, kind),
+                requirementTargetIds: getRequirementTargets(result),
+                coordinateKey: getCoordinateKey(result),
+            },
+        ];
+    });
+}
+export function isModuleOrConfig(symbol) {
+    return symbol.role === "module" || symbol.role === "config";
+}
+export function narrowerManifestSymbols(symbol, symbols) {
+    return symbols.filter((candidate) => candidate.id !== symbol.id &&
+        candidate.sourceFile === symbol.sourceFile &&
+        candidate.title.startsWith(`${symbol.title}.`));
+}
+export function narrowerExtractedSymbols(symbol, symbolsByFile) {
+    return (symbolsByFile.get(symbol.sourceFile) ?? []).filter((candidate) => candidate.name !== symbol.title &&
+        candidate.name.startsWith(`${symbol.title}.`) &&
+        candidate.role === "behavioral");
+}

package/dist/public/impact/symbol-quality.d.ts

@@ -0,0 +1,4 @@
+import type { KibiImpactDiagnostic } from "../../traceability/staged-diagnostics.js";
+import type { SymbolQualityDiagnosticsOptions } from "./types.js";
+export declare function createSymbolQualityDiagnostics(options: SymbolQualityDiagnosticsOptions): KibiImpactDiagnostic[];
+//# sourceMappingURL=symbol-quality.d.ts.map

package/dist/public/impact/symbol-quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/symbol-quality.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAUrF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAC;AA0LlE,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,+BAA+B,GACvC,oBAAoB,EAAE,CAOxB"}