@shrkcrft/inspector 0.1.0-alpha.2

package/dist/impact-analysis.js

@@ -0,0 +1,697 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { scanImports, loadTsconfigPaths } from '@shrkcrft/boundaries';
+import { AreaKind, buildAreaMap } from "./area-map.js";
+import { rankAll } from "./task-ranker.js";
+import { loadOwnershipRules, impactFor } from "./ownership.js";
+export const IMPACT_ANALYSIS_SCHEMA = 'sharkcraft.impact-analysis/v2';
+export var ImpactRisk;
+(function (ImpactRisk) {
+    ImpactRisk["Low"] = "low";
+    ImpactRisk["Medium"] = "medium";
+    ImpactRisk["High"] = "high";
+    ImpactRisk["Critical"] = "critical";
+})(ImpactRisk || (ImpactRisk = {}));
+export var ImpactInputKind;
+(function (ImpactInputKind) {
+    ImpactInputKind["File"] = "file";
+    ImpactInputKind["Files"] = "files";
+    ImpactInputKind["Specifier"] = "specifier";
+    ImpactInputKind["Since"] = "since";
+    ImpactInputKind["Staged"] = "staged";
+    ImpactInputKind["Plan"] = "plan";
+    ImpactInputKind["Bundle"] = "bundle";
+    ImpactInputKind["Task"] = "task";
+    ImpactInputKind["Mixed"] = "mixed";
+    ImpactInputKind["Empty"] = "empty";
+})(ImpactInputKind || (ImpactInputKind = {}));
+const DEFAULT_MAX_DEPTH = 5;
+const DEFAULT_LIMIT = 200;
+function unique(xs) {
+    return [...new Set(xs)];
+}
+function inferInputKind(input) {
+    if (input.inputKind)
+        return input.inputKind;
+    if (input.specifier)
+        return ImpactInputKind.Specifier;
+    if (input.planTargets && input.planTargets.length > 0 && (!input.files || input.files.length === 0)) {
+        return ImpactInputKind.Plan;
+    }
+    if (input.files && input.files.length > 0)
+        return ImpactInputKind.Files;
+    if (input.task)
+        return ImpactInputKind.Task;
+    return ImpactInputKind.Empty;
+}
+function normalizeRel(projectRoot, p) {
+    if (!p)
+        return p;
+    if (nodePath.isAbsolute(p)) {
+        const rel = nodePath.relative(projectRoot, p);
+        return rel.split(nodePath.sep).join('/');
+    }
+    // Strip leading ./ noise.
+    return p.replace(/^\.\/?/, '').split(nodePath.sep).join('/');
+}
+function buildReverseGraph(projectRoot) {
+    let scan;
+    try {
+        scan = scanImports({ projectRoot });
+    }
+    catch {
+        return { importers: new Map(), edgeCount: 0, aliasMap: new Map() };
+    }
+    let aliasMap;
+    try {
+        aliasMap = loadTsconfigPaths(projectRoot).aliases;
+    }
+    catch {
+        aliasMap = new Map();
+    }
+    const importers = new Map();
+    for (const e of scan.edges) {
+        const targets = resolveTargets(projectRoot, e.from, e.importSpecifier, aliasMap);
+        for (const t of targets) {
+            const set = importers.get(t) ?? new Set();
+            set.add(e.from);
+            importers.set(t, set);
+        }
+    }
+    return { importers, edgeCount: scan.edges.length, aliasMap };
+}
+function resolveTargets(projectRoot, from, spec, aliasMap) {
+    const out = [];
+    if (spec.startsWith('.')) {
+        const dir = nodePath.posix.dirname(from);
+        const joined = nodePath.posix.normalize(nodePath.posix.join(dir, spec));
+        out.push(joined);
+        out.push(joined + '.ts');
+        out.push(joined + '.tsx');
+        out.push(joined + '/index.ts');
+        return out;
+    }
+    for (const [pattern, paths] of aliasMap.entries()) {
+        if (pattern.endsWith('*')) {
+            const prefix = pattern.slice(0, -1);
+            if (!spec.startsWith(prefix))
+                continue;
+            const rest = spec.slice(prefix.length);
+            for (const targetPattern of paths) {
+                const resolved = targetPattern.replace(/\*/g, rest);
+                out.push(resolved);
+                out.push(resolved + '.ts');
+                out.push(resolved + '.tsx');
+                out.push(resolved + '/index.ts');
+            }
+            continue;
+        }
+        if (pattern === spec) {
+            for (const t of paths) {
+                out.push(t);
+                out.push(t + '.ts');
+                out.push(t + '.tsx');
+                out.push(t + '/index.ts');
+            }
+        }
+    }
+    return out;
+}
+function matchTargetsBySpecifier(spec, aliasMap) {
+    // Returns possible files the specifier could resolve to, regardless of
+    // the importing file. Used by --specifier.
+    if (spec.startsWith('.'))
+        return [];
+    const out = [];
+    for (const [pattern, paths] of aliasMap.entries()) {
+        if (pattern.endsWith('*')) {
+            const prefix = pattern.slice(0, -1);
+            if (!spec.startsWith(prefix))
+                continue;
+            const rest = spec.slice(prefix.length);
+            for (const targetPattern of paths) {
+                const resolved = targetPattern.replace(/\*/g, rest);
+                out.push(resolved);
+                out.push(resolved + '.ts');
+                out.push(resolved + '/index.ts');
+            }
+        }
+        else if (pattern === spec) {
+            for (const t of paths) {
+                out.push(t);
+                out.push(t + '.ts');
+                out.push(t + '/index.ts');
+            }
+        }
+    }
+    return out;
+}
+function closeDependents(reverse, seeds, maxDepth) {
+    const direct = new Set();
+    const all = new Set();
+    const paths = [];
+    const visited = new Map();
+    // BFS from each seed.
+    for (const seed of seeds) {
+        const queue = [
+            { node: seed, depth: 0, via: [], root: seed },
+        ];
+        const seenLocal = new Set([seed]);
+        while (queue.length > 0) {
+            const cur = queue.shift();
+            const importers = reverse.importers.get(cur.node);
+            if (!importers)
+                continue;
+            for (const importer of importers) {
+                if (cur.depth === 0)
+                    direct.add(importer);
+                all.add(importer);
+                if (paths.length < 25 && cur.via.length < 4) {
+                    paths.push({
+                        from: importer,
+                        to: cur.root,
+                        via: [...cur.via, cur.node],
+                    });
+                }
+                const prevDepth = visited.get(importer);
+                if (prevDepth !== undefined && prevDepth <= cur.depth + 1)
+                    continue;
+                visited.set(importer, cur.depth + 1);
+                if (cur.depth + 1 >= maxDepth)
+                    continue;
+                if (seenLocal.has(importer))
+                    continue;
+                seenLocal.add(importer);
+                queue.push({
+                    node: importer,
+                    depth: cur.depth + 1,
+                    via: [...cur.via, cur.node],
+                    root: cur.root,
+                });
+            }
+        }
+    }
+    return { direct: [...direct].sort(), transitive: [...all].sort(), paths };
+}
+function detectWorkspaces(ctx) {
+    const pkgPath = nodePath.join(ctx.inspection.projectRoot, 'package.json');
+    if (!existsSync(pkgPath))
+        return [];
+    let workspaces = [];
+    try {
+        const json = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        if (Array.isArray(json.workspaces))
+            workspaces = [...json.workspaces];
+        else
+            workspaces =
+                json.workspaces?.packages?.slice() ??
+                    [];
+    }
+    catch {
+        return [];
+    }
+    const out = new Map();
+    for (const w of workspaces) {
+        const dir = w.replace(/\/\*?$/, '');
+        for (const f of ctx.files) {
+            if (!f.startsWith(dir + '/'))
+                continue;
+            const rest = f.slice(dir.length + 1);
+            const pkgName = rest.split('/')[0];
+            if (!pkgName)
+                continue;
+            const pkgFile = nodePath.join(ctx.inspection.projectRoot, dir, pkgName, 'package.json');
+            if (!existsSync(pkgFile))
+                continue;
+            const key = `${dir}/${pkgName}`;
+            const existing = out.get(key);
+            let name = pkgName;
+            try {
+                name =
+                    JSON.parse(readFileSync(pkgFile, 'utf8')).name ?? pkgName;
+            }
+            catch {
+                /* ignore */
+            }
+            if (existing) {
+                existing.fileCount += 1;
+            }
+            else {
+                out.set(key, { name, directory: key, fileCount: 1 });
+            }
+        }
+    }
+    return [...out.values()].sort((a, b) => b.fileCount - a.fileCount);
+}
+function affectedAreaSummary(ctx) {
+    const allTouched = unique([...ctx.files]);
+    const out = new Map();
+    for (const a of ctx.areaMap.areas) {
+        const hitCount = allTouched.filter((f) => a.paths.some((p) => f === p || f.startsWith(p + '/') || f.startsWith(p))).length;
+        if (hitCount > 0) {
+            out.set(a.id, { id: a.id, kind: a.kind, fileCount: hitCount });
+        }
+    }
+    return [...out.values()].sort((a, b) => b.fileCount - a.fileCount);
+}
+function boundaryRisks(ctx, affected) {
+    const risks = [];
+    const seen = new Set();
+    for (const a of affected) {
+        const area = ctx.areaMap.areas.find((x) => x.id === a.id);
+        if (!area)
+            continue;
+        for (const ruleId of area.boundaryRuleIds) {
+            const rule = ctx.inspection.boundaryRegistry.get(ruleId);
+            if (!rule)
+                continue;
+            const key = `${a.id}:${ruleId}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            risks.push({
+                ruleId,
+                reason: `Affects area ${a.id}; rule ${ruleId} guards that area.`,
+                severity: (rule.severity ?? 'warning'),
+            });
+        }
+    }
+    return risks;
+}
+function affectedTemplates(ctx) {
+    const out = [];
+    const seen = new Set();
+    for (const t of ctx.inspection.templateRegistry.list()) {
+        const tp = t.targetPath;
+        const path = typeof tp === 'string' ? tp : '';
+        if (!path)
+            continue;
+        if (ctx.files.some((f) => f.includes(path) || path.includes(f.split('/').pop() ?? ''))) {
+            if (seen.has(t.id))
+                continue;
+            seen.add(t.id);
+            out.push({ id: t.id, name: t.name });
+        }
+    }
+    return out;
+}
+function affectedPipelines(ctx) {
+    const out = [];
+    for (const p of ctx.inspection.pipelineRegistry.list()) {
+        const stepsString = JSON.stringify(p.steps ?? []).toLowerCase();
+        if (ctx.files.some((f) => stepsString.includes(f.toLowerCase()))) {
+            out.push({ id: p.id, title: p.title ?? p.id });
+        }
+    }
+    return out;
+}
+function affectedPresets(ctx) {
+    const out = [];
+    try {
+        const presets = ctx.inspection.presetRegistry.list();
+        for (const p of presets) {
+            if (!p.id)
+                continue;
+            const blob = JSON.stringify(p).toLowerCase();
+            if (ctx.files.some((f) => blob.includes(f.toLowerCase().split('/').pop() ?? ''))) {
+                out.push({ id: p.id, name: p.name ?? p.id });
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return out;
+}
+function affectedConstructs(ctx) {
+    // Constructs come from the project's construct registry (loaded at inspection time).
+    // We probe the inspection object for an optional `constructs` field.
+    const list = ctx.inspection.constructs;
+    if (!list)
+        return [];
+    const out = [];
+    const allTouched = new Set(ctx.files);
+    for (const c of list) {
+        const cf = c.files ?? [];
+        if (cf.some((f) => allTouched.has(f) || ctx.files.some((tf) => tf.startsWith(f) || f.startsWith(tf)))) {
+            out.push({ id: c.id, type: c.type, title: c.title });
+        }
+    }
+    return out;
+}
+function affectedPolicies(ctx, affected, boundary) {
+    // Lightweight: surface policies whose ids hint at boundaries / public-api / ownership
+    // when those domains are in play. The full policy run is a separate command.
+    const concerns = [];
+    const hasPublicApi = ctx.files.some((f) => f.includes('index.ts') || f.includes('plugin-api') || f.includes('public-api'));
+    const touchesPolicy = ctx.files.some((f) => f.includes('policy') || f.includes('policy-engine'));
+    if (boundary.length > 0) {
+        concerns.push({
+            policyId: 'policy.boundary-impact',
+            reason: 'Touches files governed by boundary rules; run `shrk policy run`.',
+            severity: 'warning',
+        });
+    }
+    if (hasPublicApi) {
+        concerns.push({
+            policyId: 'plugin-api.public-entrypoint',
+            reason: 'Touches a public entrypoint; downstream consumers may be affected.',
+            severity: 'warning',
+        });
+    }
+    if (touchesPolicy) {
+        concerns.push({
+            policyId: 'policy.engine',
+            reason: 'Modifies the policy engine itself; run policy tests with fixtures.',
+            severity: 'warning',
+        });
+    }
+    if (affected.some((a) => a.kind === AreaKind.Core || a.kind === AreaKind.Kernel)) {
+        concerns.push({
+            policyId: 'core.protected-area',
+            reason: 'Core / kernel area touched; requires elevated review.',
+            severity: 'error',
+        });
+    }
+    return concerns;
+}
+async function ownershipImpactFor(ctx) {
+    try {
+        const cfg = ctx.inspection.config;
+        const sources = cfg?.ownership?.sources;
+        const { rules } = await loadOwnershipRules(ctx.inspection.projectRoot, sources);
+        if (rules.length === 0)
+            return null;
+        return impactFor(ctx.files, rules);
+    }
+    catch {
+        return null;
+    }
+}
+function pathConventionsTouched(ctx) {
+    const out = new Set();
+    const list = ctx.inspection.pathService.list();
+    for (const p of list) {
+        const meta = (p.metadata ?? {});
+        const segment = (meta.path ?? p.id ?? '').replace(/\*+/g, '');
+        if (!segment)
+            continue;
+        if (ctx.files.some((f) => f.includes(segment)))
+            out.add(p.id);
+    }
+    return [...out].sort();
+}
+function classifyRisk(input) {
+    const reasons = [];
+    let score = 0;
+    if (input.directCount === 0 && input.transitiveCount === 0) {
+        reasons.push({ code: 'no-dependents', message: 'No dependents detected.' });
+    }
+    if (input.directCount > 5) {
+        score += 10;
+        reasons.push({
+            code: 'many-direct-dependents',
+            message: `${input.directCount} direct dependents.`,
+        });
+    }
+    else if (input.directCount > 0) {
+        score += 4;
+        reasons.push({
+            code: 'direct-dependents',
+            message: `${input.directCount} direct dependents.`,
+        });
+    }
+    if (input.transitiveCount > 25) {
+        score += 18;
+        reasons.push({
+            code: 'large-transitive-closure',
+            message: `${input.transitiveCount} transitive dependents.`,
+        });
+    }
+    else if (input.transitiveCount > 10) {
+        score += 10;
+    }
+    if (input.publicApi) {
+        score += 15;
+        reasons.push({
+            code: 'public-api',
+            message: 'Touches a public-API entry-point or re-export.',
+        });
+    }
+    if (input.hitsCore) {
+        score += 18;
+        reasons.push({
+            code: 'core-area',
+            message: 'Touches core / kernel area.',
+        });
+    }
+    if (input.boundaryCount > 0) {
+        score += 10;
+        reasons.push({
+            code: 'boundary-rules',
+            message: `${input.boundaryCount} boundary rule(s) potentially impacted.`,
+        });
+    }
+    if (input.packCount > 1) {
+        score += 6;
+        reasons.push({
+            code: 'cross-package',
+            message: `Spans ${input.packCount} workspace packages.`,
+        });
+    }
+    if (input.ownershipReview) {
+        score += 8;
+        reasons.push({
+            code: 'ownership-review',
+            message: 'Affects ownership-protected files; reviewer required.',
+        });
+    }
+    if (input.missingTests) {
+        score += 6;
+        reasons.push({
+            code: 'missing-tests',
+            message: 'Some target files have no co-located tests.',
+        });
+    }
+    if (input.hitsPolicy) {
+        score += 10;
+        reasons.push({
+            code: 'policy-impact',
+            message: 'Policy-engine surface or policy-governed area touched.',
+        });
+    }
+    if (input.hitsTemplates) {
+        score += 4;
+        reasons.push({
+            code: 'template-impact',
+            message: 'Templates / pipelines reference these paths.',
+        });
+    }
+    if (input.affectedAreaCount > 4) {
+        score += 6;
+        reasons.push({
+            code: 'spans-areas',
+            message: `Spans ${input.affectedAreaCount} repo areas.`,
+        });
+    }
+    let risk = ImpactRisk.Low;
+    if (score >= 35)
+        risk = ImpactRisk.Critical;
+    else if (score >= 22)
+        risk = ImpactRisk.High;
+    else if (score >= 10)
+        risk = ImpactRisk.Medium;
+    return { risk, reasons };
+}
+function findLikelyTests(projectRoot, files) {
+    const existing = new Set();
+    const missing = [];
+    for (const f of files) {
+        if (/\.(spec|test)\.[jt]sx?$/.test(f)) {
+            existing.add(f);
+            continue;
+        }
+        if (!/\.(ts|tsx|js|jsx)$/.test(f))
+            continue;
+        const candidates = [
+            f.replace(/\.(ts|tsx|js|jsx)$/, '.spec.$1'),
+            f.replace(/\.(ts|tsx|js|jsx)$/, '.test.$1'),
+            f.replace(/^src\//, 'tests/').replace(/\.(ts|tsx|js|jsx)$/, '.spec.$1'),
+            (() => {
+                const parsed = nodePath.parse(f);
+                return nodePath.join(parsed.dir, '__tests__', `${parsed.name}.test${parsed.ext}`);
+            })(),
+        ];
+        let anyExists = false;
+        for (const c of candidates) {
+            if (existsSync(nodePath.join(projectRoot, c))) {
+                existing.add(c);
+                anyExists = true;
+                break;
+            }
+        }
+        if (!anyExists)
+            missing.push(candidates[0]);
+    }
+    return { existing: [...existing].sort(), missing };
+}
+export async function analyzeImpact(inspection, input) {
+    const maxDepth = input.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    const inputKind = inferInputKind(input);
+    const areaMap = input.areaMap ?? buildAreaMap(inspection);
+    const explicitFiles = (input.files ?? []).map((f) => normalizeRel(inspection.projectRoot, f));
+    const planTargets = (input.planTargets ?? []).map((f) => normalizeRel(inspection.projectRoot, f));
+    const reverse = buildReverseGraph(inspection.projectRoot);
+    // Resolve specifier to a candidate file set, if applicable.
+    let specifierTargets = [];
+    if (input.specifier) {
+        specifierTargets = matchTargetsBySpecifier(input.specifier, reverse.aliasMap)
+            .filter((f) => existsSync(nodePath.join(inspection.projectRoot, f)))
+            .map((f) => normalizeRel(inspection.projectRoot, f));
+    }
+    const files = unique([...explicitFiles, ...planTargets, ...specifierTargets]);
+    const task = (input.task ?? '').trim() || files.join(' ') || (input.specifier ?? '');
+    const ctx = {
+        inspection,
+        files,
+        inputKind,
+        task,
+        ...(input.specifier ? { specifier: input.specifier } : {}),
+        maxDepth,
+        limit,
+        areaMap,
+    };
+    const { direct, transitive, paths } = closeDependents(reverse, files, maxDepth);
+    const directDependents = direct.slice(0, limit);
+    const transitiveDependents = transitive.slice(0, limit);
+    // Expand context with dependents for area / boundary / policy computation.
+    const expandedFiles = unique([...files, ...directDependents.slice(0, 50), ...transitiveDependents.slice(0, 50)]);
+    const expandedCtx = { ...ctx, files: expandedFiles };
+    const affectedAreas = affectedAreaSummary(expandedCtx);
+    const affectedPackages = detectWorkspaces(expandedCtx);
+    const pathConventions = pathConventionsTouched(expandedCtx);
+    const boundaryConcerns = boundaryRisks(expandedCtx, affectedAreas);
+    const policyConcerns = affectedPolicies(expandedCtx, affectedAreas, boundaryConcerns);
+    const ownership = await ownershipImpactFor(expandedCtx);
+    const templates = affectedTemplates(expandedCtx);
+    const pipelines = affectedPipelines(expandedCtx);
+    const presets = affectedPresets(expandedCtx);
+    const constructs = affectedConstructs(expandedCtx);
+    const { existing: likelyTests, missing: missingTests } = findLikelyTests(inspection.projectRoot, files);
+    // Per-target test suggestion (minimal commands).
+    const suggestedTestCommands = unique([
+        ...(likelyTests.length > 0 ? [`bun test ${likelyTests.slice(0, 6).join(' ')}`] : []),
+        'bun test',
+    ]);
+    const suggestedFullTestCommands = unique([
+        'bun test',
+        'bun x tsc -p tsconfig.base.json --noEmit',
+    ]);
+    const suggestedValidationCommands = unique([
+        'shrk check boundaries',
+        'shrk policy run',
+        'bun x tsc -p tsconfig.base.json --noEmit',
+        'bun test',
+    ]);
+    const suggestedReviewCommands = unique([
+        'shrk review packet --v3',
+        'shrk impact ' + files.slice(0, 3).join(','),
+        'shrk owners impact --files ' + files.slice(0, 3).join(','),
+    ]);
+    const ranking = rankAll(inspection, task || files.join(' '), 6);
+    const relatedRules = ranking.rules.slice(0, 5).map((r) => ({
+        id: r.item.id,
+        title: r.item.title,
+    }));
+    const relatedTemplates = ranking.templates.slice(0, 5).map((t) => ({
+        id: t.item.id,
+        name: t.item.name,
+    }));
+    const publicApi = files.some((f) => f.endsWith('/index.ts') ||
+        f.endsWith('main.ts') ||
+        f.includes('plugin-api/') ||
+        f.includes('public-api/'));
+    const hitsCore = affectedAreas.some((a) => a.kind === AreaKind.Core || a.kind === AreaKind.Kernel || a.kind === AreaKind.Common);
+    const hitsPolicy = files.some((f) => f.includes('policy') || f.includes('policy-engine'));
+    const hitsTemplates = templates.length > 0 || pipelines.length > 0;
+    const ownershipReview = (ownership?.requiredReviewFiles.length ?? 0) > 0;
+    const { risk, reasons: riskReasons } = classifyRisk({
+        directCount: direct.length,
+        transitiveCount: transitive.length,
+        boundaryCount: boundaryConcerns.length,
+        affectedAreaCount: affectedAreas.length,
+        publicApi,
+        packCount: affectedPackages.length,
+        ownershipReview,
+        missingTests: missingTests.length > 0,
+        hitsCore,
+        hitsPolicy,
+        hitsTemplates,
+    });
+    const truncations = [];
+    if (direct.length > limit) {
+        truncations.push({ list: 'directDependents', total: direct.length, shown: limit });
+    }
+    if (transitive.length > limit) {
+        truncations.push({
+            list: 'transitiveDependents',
+            total: transitive.length,
+            shown: limit,
+        });
+    }
+    if (paths.length > 25) {
+        truncations.push({ list: 'dependencyPathExamples', total: paths.length, shown: 25 });
+    }
+    const explanation = buildExplanation(risk, direct.length, transitive.length, boundaryConcerns.length, affectedAreas.length);
+    const diagnostics = [];
+    if (reverse.edgeCount === 0) {
+        diagnostics.push('Import-graph scan returned no edges — reverse closure unavailable.');
+    }
+    if (files.length === 0) {
+        diagnostics.push('No target files derived from input.');
+    }
+    const result = {
+        schema: IMPACT_ANALYSIS_SCHEMA,
+        task,
+        inputKind,
+        normalizedTargets: files,
+        affectedFiles: files,
+        directDependents,
+        transitiveDependents,
+        dependencyPathExamples: paths.slice(0, 25),
+        affectedAreas,
+        affectedPackages,
+        affectedPathConventions: pathConventions,
+        potentialBoundaryRisks: boundaryConcerns,
+        affectedPolicies: policyConcerns,
+        affectedOwnership: ownership,
+        affectedTemplates: templates,
+        affectedPipelines: pipelines,
+        affectedPresets: presets,
+        affectedConstructs: constructs,
+        likelyTests,
+        suggestedTestCommands,
+        suggestedFullTestCommands,
+        suggestedValidationCommands,
+        suggestedReviewCommands,
+        relatedRules,
+        relatedTemplates,
+        risk,
+        riskReasons,
+        explanation,
+        truncations,
+        diagnostics,
+    };
+    if (input.specifier) {
+        result.specifier = input.specifier;
+    }
+    return result;
+}
+function buildExplanation(risk, directCount, transitiveCount, boundaryCount, areaCount) {
+    return [
+        `Risk: ${risk}.`,
+        `${directCount} direct + ${transitiveCount} transitive dependent(s);`,
+        `${areaCount} area(s); ${boundaryCount} boundary rule(s).`,
+    ].join(' ');
+}