@shrkcrft/impact-engine 0.1.0-alpha.10

package/dist/engine/analyzer.d.ts

@@ -0,0 +1,29 @@
+import { type IGraphImpactAnalysis } from '../schema/impact-analysis.js';
+export type IGraphImpactInput = {
+    kind: 'files';
+    files: readonly string[];
+} | {
+    kind: 'symbol';
+    symbolId: string;
+} | {
+    kind: 'gitref';
+    ref: string;
+};
+export interface IAnalyzeOptions {
+    projectRoot: string;
+    /** Cap on each list. Default 200. */
+    limit?: number;
+    /** Cap on reverse-closure depth. Default 5. */
+    maxDepth?: number;
+}
+/**
+ * Compute a v3 graph-backed impact analysis.
+ *
+ * Failure modes are non-fatal:
+ *   - missing code graph → diagnostic + minimal payload
+ *   - missing bridge → no affectedRules/Paths/Templates; not an error
+ *   - input file unknown to the graph → kept in `normalizedTargets`
+ *     with a diagnostic, treated as zero-dependent
+ */
+export declare function analyzeGraphImpact(input: IGraphImpactInput, options: IAnalyzeOptions): IGraphImpactAnalysis;
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/engine/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../src/engine/analyzer.ts"],"names":[],"mappings":"AAYA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,8BAA8B,CAAC;AAGtC,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpC,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,eAAe,GACvB,oBAAoB,CA+OtB"}

package/dist/engine/analyzer.js

@@ -0,0 +1,366 @@
+import { execSync } from 'node:child_process';
+import { EdgeKind, GraphQueryApi, GraphStore, NodeKind, } from '@shrkcrft/graph';
+import { BridgeStore, RuleGraphQueryApi, } from '@shrkcrft/rule-graph';
+import { GRAPH_IMPACT_SCHEMA, } from "../schema/impact-analysis.js";
+import { classifyRisk } from "./risk-score.js";
+/**
+ * Compute a v3 graph-backed impact analysis.
+ *
+ * Failure modes are non-fatal:
+ *   - missing code graph → diagnostic + minimal payload
+ *   - missing bridge → no affectedRules/Paths/Templates; not an error
+ *   - input file unknown to the graph → kept in `normalizedTargets`
+ *     with a diagnostic, treated as zero-dependent
+ */
+export function analyzeGraphImpact(input, options) {
+    const limit = options.limit ?? 200;
+    const maxDepth = Math.max(1, Math.min(10, options.maxDepth ?? 5));
+    const graphStore = new GraphStore(options.projectRoot);
+    const diagnostics = [];
+    if (!graphStore.exists()) {
+        return missingGraphPayload(input, ['code-graph store missing — run `shrk graph index`']);
+    }
+    const api = GraphQueryApi.fromStore(options.projectRoot);
+    let bridgeApi;
+    const bridgeStore = new BridgeStore(options.projectRoot);
+    if (bridgeStore.exists()) {
+        bridgeApi = RuleGraphQueryApi.fromStores(options.projectRoot);
+    }
+    else {
+        diagnostics.push("bridge store missing — `shrk rule-graph index` for affectedRules/Templates");
+    }
+    // Resolve input → target node ids.
+    const targets = [];
+    const normalizedTargets = [];
+    const addFileTarget = (relPath) => {
+        const file = api.findFile(relPath);
+        if (file) {
+            targets.push({ nodeId: file.id, path: file.path, isSymbol: false });
+            normalizedTargets.push(file.id);
+        }
+        else {
+            diagnostics.push(`file not in graph: ${relPath}`);
+            normalizedTargets.push(`file:${relPath}`);
+        }
+    };
+    if (input.kind === 'files') {
+        for (const f of input.files)
+            addFileTarget(f);
+    }
+    else if (input.kind === 'symbol') {
+        let symNode;
+        if (input.symbolId.startsWith('symbol:')) {
+            symNode = api.neighbours(input.symbolId)?.node;
+        }
+        else {
+            const matches = api.findSymbol(input.symbolId, { exact: true, limit: 5 });
+            symNode = matches.find((s) => (s.data?.['isExported'] ?? false) === true) ?? matches[0];
+        }
+        if (symNode) {
+            targets.push({ nodeId: symNode.id, path: symNode.path, isSymbol: true });
+            normalizedTargets.push(symNode.id);
+        }
+        else {
+            diagnostics.push(`symbol not in graph: ${input.symbolId}`);
+            normalizedTargets.push(`symbol:${input.symbolId}`);
+        }
+    }
+    else {
+        const files = changedFilesSince(options.projectRoot, input.ref);
+        if (files.length === 0)
+            diagnostics.push(`no files changed since ${input.ref}`);
+        for (const f of files)
+            addFileTarget(f);
+    }
+    // Reverse closure over imports-file edges.
+    const truncations = {};
+    const reachable = new Set();
+    for (const t of targets)
+        reachable.add(t.nodeId);
+    const directIds = new Set();
+    {
+        let frontier = [...reachable];
+        let depth = 1;
+        while (depth <= maxDepth && frontier.length > 0) {
+            const next = [];
+            let truncated = false;
+            for (const id of frontier) {
+                for (const imp of api.importersOf(id)) {
+                    if (reachable.has(imp.id))
+                        continue;
+                    reachable.add(imp.id);
+                    next.push(imp.id);
+                    if (depth === 1)
+                        directIds.add(imp.id);
+                    if (reachable.size - targets.length >= limit) {
+                        truncated = true;
+                        break;
+                    }
+                }
+                if (truncated)
+                    break;
+            }
+            if (truncated) {
+                truncations['dependents'] = (truncations['dependents'] ?? 0) + 1;
+                break;
+            }
+            frontier = next;
+            depth += 1;
+        }
+    }
+    const direct = [...directIds]
+        .map((id) => toRef(api, id))
+        .filter((r) => r !== undefined);
+    const transitive = [];
+    for (const id of reachable) {
+        if (id === targets.find((t) => t.nodeId === id)?.nodeId)
+            continue;
+        if (directIds.has(id))
+            continue;
+        if (targets.some((t) => t.nodeId === id))
+            continue;
+        const ref = toRef(api, id);
+        if (ref)
+            transitive.push(ref);
+        if (transitive.length >= limit) {
+            truncations['transitive'] = (truncations['transitive'] ?? 0) + 1;
+            break;
+        }
+    }
+    // Symbols declared by target files.
+    const affectedSymbols = [];
+    const callerSet = new Set();
+    for (const t of targets) {
+        if (t.isSymbol) {
+            affectedSymbols.push(toRefForce(api, t.nodeId));
+            for (const c of api.referencesOf(t.nodeId))
+                callerSet.add(c.id);
+        }
+        else {
+            for (const sym of api.symbolsIn(t.nodeId)) {
+                affectedSymbols.push(toRefForce(api, sym.id));
+                for (const c of api.referencesOf(sym.id))
+                    callerSet.add(c.id);
+            }
+        }
+    }
+    const affectedCallerFiles = [...callerSet]
+        .map((id) => toRef(api, id))
+        .filter((r) => r !== undefined)
+        .slice(0, limit);
+    // Affected packages.
+    const packagesSet = new Set();
+    for (const id of reachable) {
+        const pkg = packageOf(api, id);
+        if (pkg)
+            packagesSet.add(pkg);
+    }
+    const affectedPackages = [...packagesSet].sort();
+    // Rule-graph bridge: rules / paths / templates touching any affected file.
+    const affectedRules = [];
+    const affectedPaths = [];
+    const affectedTemplates = [];
+    if (bridgeApi) {
+        const seenRule = new Set();
+        const seenPath = new Set();
+        const seenTpl = new Set();
+        for (const id of reachable) {
+            const node = api.neighbours(id)?.node;
+            if (!node?.path)
+                continue;
+            const f = bridgeApi.forFile(node.path);
+            if (!f)
+                continue;
+            for (const h of f.rules) {
+                if (seenRule.has(h.target.id))
+                    continue;
+                seenRule.add(h.target.id);
+                affectedRules.push({
+                    id: h.target.id,
+                    label: h.target.label,
+                    severity: h.edge.data?.['severity'] ?? undefined,
+                });
+            }
+            for (const h of f.paths) {
+                if (seenPath.has(h.target.id))
+                    continue;
+                seenPath.add(h.target.id);
+                affectedPaths.push({ id: h.target.id, label: h.target.label });
+            }
+            for (const h of f.templates) {
+                if (seenTpl.has(h.target.id))
+                    continue;
+                seenTpl.add(h.target.id);
+                affectedTemplates.push({ id: h.target.id, label: h.target.label });
+            }
+        }
+    }
+    // Likely tests: reachable files tagged `test`.
+    const likelyTests = [];
+    for (const id of reachable) {
+        const node = api.neighbours(id)?.node;
+        if (!node)
+            continue;
+        if (!(node.tags ?? []).includes('test'))
+            continue;
+        const ref = toRef(api, id);
+        if (ref)
+            likelyTests.push(ref);
+        if (likelyTests.length >= limit) {
+            truncations['likelyTests'] = (truncations['likelyTests'] ?? 0) + 1;
+            break;
+        }
+    }
+    // publicApiTouched: any target is an index file or declares an exported symbol.
+    let publicApiTouched = false;
+    for (const t of targets) {
+        if (t.path && (/\/index\.ts$/.test(t.path) || /^index\.ts$/.test(t.path) || t.path.endsWith('.d.ts'))) {
+            publicApiTouched = true;
+            break;
+        }
+        if (t.isSymbol) {
+            const node = api.neighbours(t.nodeId)?.node;
+            if (node && (node.data?.['isExported'] ?? false) === true) {
+                publicApiTouched = true;
+                break;
+            }
+        }
+        else {
+            const syms = api.symbolsIn(t.nodeId);
+            if (syms.some((s) => (s.data?.['isExported'] ?? false) === true)) {
+                publicApiTouched = true;
+                break;
+            }
+        }
+    }
+    // Risk + validation scope.
+    const { risk, reasons } = classifyRisk({
+        directCount: direct.length,
+        transitiveCount: transitive.length,
+        packagesTouched: affectedPackages.length,
+        rulesTouched: affectedRules.length,
+        templatesTouched: affectedTemplates.length,
+        publicApiTouched,
+        callerFilesCount: affectedCallerFiles.length,
+    });
+    const validationScope = deriveValidationScope({
+        risk,
+        affectedRules: affectedRules.length,
+        affectedTemplates: affectedTemplates.length,
+        likelyTests: likelyTests.length,
+        affectedPackages,
+    });
+    return {
+        schema: GRAPH_IMPACT_SCHEMA,
+        inputKind: input.kind,
+        normalizedTargets,
+        directDependents: direct,
+        transitiveDependents: transitive,
+        affectedSymbols,
+        affectedCallerFiles,
+        affectedPackages,
+        affectedRules,
+        affectedPaths,
+        affectedTemplates,
+        likelyTests,
+        publicApiTouched,
+        risk,
+        riskReasons: reasons,
+        validationScope,
+        truncations,
+        diagnostics,
+    };
+}
+function toRef(api, id) {
+    const node = api.neighbours(id)?.node;
+    if (!node)
+        return undefined;
+    return toRefFromNode(node);
+}
+function toRefForce(api, id) {
+    const ref = toRef(api, id);
+    return ref ?? { id, kind: 'unknown', label: id };
+}
+function toRefFromNode(node) {
+    return {
+        id: node.id,
+        kind: node.kind,
+        label: node.label,
+        ...(node.path ? { path: node.path } : {}),
+        ...(node.line ? { line: node.line } : {}),
+    };
+}
+function packageOf(api, id) {
+    // A file → package via BelongsToPackage edge.
+    const neighbours = api.neighbours(id);
+    if (!neighbours)
+        return undefined;
+    for (const edge of neighbours.out) {
+        if (edge.edge.kind === EdgeKind.BelongsToPackage) {
+            const target = edge.target;
+            if ('kind' in target && target.kind === NodeKind.Package)
+                return target.label;
+        }
+    }
+    // Symbol → owning file → package.
+    if (id.startsWith('symbol:')) {
+        const filePath = id.slice('symbol:'.length).split('#')[0];
+        if (filePath) {
+            const fileId = `file:${filePath}`;
+            return packageOf(api, fileId);
+        }
+    }
+    return undefined;
+}
+function deriveValidationScope(input) {
+    const out = [];
+    if (input.affectedRules > 0)
+        out.push('shrk check boundaries');
+    if (input.affectedTemplates > 0)
+        out.push('shrk drift --json');
+    if (input.likelyTests > 0)
+        out.push('bun test');
+    if (input.risk === 'high' || input.risk === 'critical') {
+        out.push('shrk doctor');
+        out.push('bun x tsc -p tsconfig.base.json --noEmit');
+    }
+    return out;
+}
+function missingGraphPayload(input, diagnostics) {
+    return {
+        schema: GRAPH_IMPACT_SCHEMA,
+        inputKind: input.kind,
+        normalizedTargets: [],
+        directDependents: [],
+        transitiveDependents: [],
+        affectedSymbols: [],
+        affectedCallerFiles: [],
+        affectedPackages: [],
+        affectedRules: [],
+        affectedPaths: [],
+        affectedTemplates: [],
+        likelyTests: [],
+        publicApiTouched: false,
+        risk: 'low',
+        riskReasons: [],
+        validationScope: [],
+        truncations: {},
+        diagnostics,
+    };
+}
+function changedFilesSince(projectRoot, ref) {
+    try {
+        const raw = execSync(`git diff --name-only ${ref}`, {
+            cwd: projectRoot,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return raw
+            .split('\n')
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/engine/risk-score.d.ts

@@ -0,0 +1,30 @@
+import type { IGraphImpactAnalysis, RiskLevel } from '../schema/impact-analysis.js';
+interface IRiskInputs {
+    directCount: number;
+    transitiveCount: number;
+    packagesTouched: number;
+    rulesTouched: number;
+    templatesTouched: number;
+    publicApiTouched: boolean;
+    callerFilesCount: number;
+}
+/**
+ * Deterministic, heuristic risk score. Weights chosen to match the
+ * v2 inspector's qualitative behavior (small change → low, big graph
+ * spread or public-API touch → high+) without depending on the
+ * inspector's exact internal scoring.
+ *
+ * The thresholds are tuned for the SharkCraft monorepo and similar
+ * mid-size TS workspaces. They will need re-tuning when applied to
+ * very large or very small codebases — surface that as a future
+ * configuration knob if needed.
+ */
+export declare function classifyRisk(input: IRiskInputs): {
+    risk: RiskLevel;
+    reasons: readonly string[];
+};
+/** Re-export so callers can read the (partial) inputs back for tests. */
+export type { IRiskInputs };
+/** Defensive constructor used by analyzer tests. */
+export declare function emptyImpactAnalysis(): Partial<IGraphImpactAnalysis>;
+//# sourceMappingURL=risk-score.d.ts.map

package/dist/engine/risk-score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"risk-score.d.ts","sourceRoot":"","sources":["../../src/engine/risk-score.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEpF,UAAU,WAAW;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CA2ChG;AAED,yEAAyE;AACzE,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,oDAAoD;AACpD,wBAAgB,mBAAmB,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAOnE"}

package/dist/engine/risk-score.js

@@ -0,0 +1,66 @@
+/**
+ * Deterministic, heuristic risk score. Weights chosen to match the
+ * v2 inspector's qualitative behavior (small change → low, big graph
+ * spread or public-API touch → high+) without depending on the
+ * inspector's exact internal scoring.
+ *
+ * The thresholds are tuned for the SharkCraft monorepo and similar
+ * mid-size TS workspaces. They will need re-tuning when applied to
+ * very large or very small codebases — surface that as a future
+ * configuration knob if needed.
+ */
+export function classifyRisk(input) {
+    let score = 0;
+    const reasons = [];
+    if (input.directCount >= 5) {
+        score += 2;
+        reasons.push(`${input.directCount} direct dependents`);
+    }
+    else if (input.directCount > 0) {
+        score += 1;
+        reasons.push(`${input.directCount} direct dependents`);
+    }
+    if (input.transitiveCount >= 50) {
+        score += 3;
+        reasons.push(`${input.transitiveCount} transitive dependents`);
+    }
+    else if (input.transitiveCount >= 10) {
+        score += 2;
+        reasons.push(`${input.transitiveCount} transitive dependents`);
+    }
+    if (input.packagesTouched >= 5) {
+        score += 2;
+        reasons.push(`${input.packagesTouched} workspace packages spanned`);
+    }
+    else if (input.packagesTouched >= 2) {
+        score += 1;
+        reasons.push(`${input.packagesTouched} workspace packages spanned`);
+    }
+    if (input.rulesTouched > 0) {
+        score += 1;
+        reasons.push(`${input.rulesTouched} boundary rule(s) apply`);
+    }
+    if (input.templatesTouched > 0) {
+        score += 1;
+        reasons.push(`covered by ${input.templatesTouched} template(s) — verify drift`);
+    }
+    if (input.publicApiTouched) {
+        score += 2;
+        reasons.push('public API surface touched');
+    }
+    if (input.callerFilesCount >= 10) {
+        score += 1;
+        reasons.push(`${input.callerFilesCount} caller files`);
+    }
+    const risk = score >= 8 ? 'critical' : score >= 5 ? 'high' : score >= 2 ? 'medium' : 'low';
+    return { risk, reasons };
+}
+/** Defensive constructor used by analyzer tests. */
+export function emptyImpactAnalysis() {
+    return {
+        risk: 'low',
+        riskReasons: [],
+        truncations: {},
+        diagnostics: [],
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './schema/impact-analysis.js';
+export * from './engine/analyzer.js';
+export * from './engine/risk-score.js';
+export * from './runner/impact-report-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./schema/impact-analysis.js";
+export * from "./engine/analyzer.js";
+export * from "./engine/risk-score.js";
+export * from "./runner/impact-report-store.js";

package/dist/runner/impact-report-store.d.ts

@@ -0,0 +1,59 @@
+import type { IGraphImpactAnalysis } from '../schema/impact-analysis.js';
+export declare const IMPACT_RUN_SCHEMA: "sharkcraft.impact-run/v1";
+/**
+ * Compact, doctor-friendly snapshot of the most recent `shrk impact`
+ * run. The full v3 payload can carry hundreds of `IAffectedNodeRef`
+ * entries — we keep counts + a representative `inputSummary` so the
+ * dashboard / doctor can answer "what was the last analysis" without
+ * loading every dependent.
+ */
+export interface IImpactRunReport {
+    schema: typeof IMPACT_RUN_SCHEMA;
+    generatedAt: string;
+    inputKind: 'files' | 'symbol' | 'gitref';
+    /** Short, human-readable summary of the request (file list, ref, …). */
+    inputSummary: string;
+    risk: 'low' | 'medium' | 'high' | 'critical';
+    directDependentCount: number;
+    transitiveDependentCount: number;
+    affectedPackageCount: number;
+    affectedSymbolCount: number;
+    affectedCallerFileCount: number;
+    affectedRuleCount: number;
+    affectedTemplateCount: number;
+    likelyTestCount: number;
+    publicApiTouched: boolean;
+    riskReasons: readonly string[];
+    validationScope: readonly string[];
+    diagnostics: readonly string[];
+}
+export declare class ImpactReportStore {
+    private readonly projectRoot;
+    readonly absPath: string;
+    readonly baselinePath: string;
+    constructor(projectRoot: string);
+    exists(): boolean;
+    baselineExists(): boolean;
+    read(): IImpactRunReport | undefined;
+    write(report: IImpactRunReport): void;
+    readBaseline(): IImpactRunReport | undefined;
+    writeBaseline(report: IImpactRunReport): void;
+    clearBaseline(): boolean;
+}
+export interface IImpactDelta {
+    /** last.dependents (direct + transitive) − baseline.dependents. */
+    dependentDelta: number;
+    /** last.packageCount − baseline.packageCount. */
+    packageDelta: number;
+    /** Risk drift summary, e.g. "low → high". */
+    riskDrift?: string;
+    /** Is `last` strictly worse than baseline along any axis? */
+    worsened: boolean;
+}
+export declare function diffImpactReports(baseline: IImpactRunReport, last: IImpactRunReport): IImpactDelta;
+/**
+ * Build a compact `IImpactRunReport` from the full v3 payload + the
+ * request summary string. Pure; callers persist via `ImpactReportStore`.
+ */
+export declare function snapshotImpactAnalysis(analysis: IGraphImpactAnalysis, inputSummary: string): IImpactRunReport;
+//# sourceMappingURL=impact-report-store.d.ts.map

package/dist/runner/impact-report-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-report-store.d.ts","sourceRoot":"","sources":["../../src/runner/impact-report-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,eAAO,MAAM,iBAAiB,EAAG,0BAAmC,CAAC;AAIrE;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,iBAAiB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACzC,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IAC7C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wBAAwB,EAAE,MAAM,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,qBAAa,iBAAiB;IAIhB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAHxC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,YAAY,EAAE,MAAM,CAAC;gBAER,WAAW,EAAE,MAAM;IAKhD,MAAM,IAAI,OAAO;IAIjB,cAAc,IAAI,OAAO;IAIzB,IAAI,IAAI,gBAAgB,GAAG,SAAS;IAWpC,KAAK,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAKrC,YAAY,IAAI,gBAAgB,GAAG,SAAS;IAW5C,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAK7C,aAAa,IAAI,OAAO;CAKzB;AAED,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,cAAc,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,gBAAgB,GACrB,YAAY,CAcd;AAeD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,oBAAoB,EAC9B,YAAY,EAAE,MAAM,GACnB,gBAAgB,CAoBlB"}

package/dist/runner/impact-report-store.js

@@ -0,0 +1,113 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+export const IMPACT_RUN_SCHEMA = 'sharkcraft.impact-run/v1';
+const REPORT_REL = '.sharkcraft/impact/last.json';
+const BASELINE_REL = '.sharkcraft/impact/baseline.json';
+export class ImpactReportStore {
+    projectRoot;
+    absPath;
+    baselinePath;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.absPath = nodePath.join(projectRoot, REPORT_REL);
+        this.baselinePath = nodePath.join(projectRoot, BASELINE_REL);
+    }
+    exists() {
+        return existsSync(this.absPath);
+    }
+    baselineExists() {
+        return existsSync(this.baselinePath);
+    }
+    read() {
+        if (!this.exists())
+            return undefined;
+        try {
+            const raw = JSON.parse(readFileSync(this.absPath, 'utf8'));
+            if (raw.schema !== IMPACT_RUN_SCHEMA)
+                return undefined;
+            return raw;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    write(report) {
+        mkdirSync(nodePath.dirname(this.absPath), { recursive: true });
+        writeFileSync(this.absPath, JSON.stringify(report, null, 2), 'utf8');
+    }
+    readBaseline() {
+        if (!this.baselineExists())
+            return undefined;
+        try {
+            const raw = JSON.parse(readFileSync(this.baselinePath, 'utf8'));
+            if (raw.schema !== IMPACT_RUN_SCHEMA)
+                return undefined;
+            return raw;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    writeBaseline(report) {
+        mkdirSync(nodePath.dirname(this.baselinePath), { recursive: true });
+        writeFileSync(this.baselinePath, JSON.stringify(report, null, 2), 'utf8');
+    }
+    clearBaseline() {
+        if (!this.baselineExists())
+            return false;
+        rmSync(this.baselinePath);
+        return true;
+    }
+}
+export function diffImpactReports(baseline, last) {
+    const baseDeps = baseline.directDependentCount + baseline.transitiveDependentCount;
+    const lastDeps = last.directDependentCount + last.transitiveDependentCount;
+    const baseRiskIdx = riskRank(baseline.risk);
+    const lastRiskIdx = riskRank(last.risk);
+    const riskWorsened = lastRiskIdx > baseRiskIdx;
+    const dependentWorsened = lastDeps > baseDeps;
+    const packageWorsened = last.affectedPackageCount > baseline.affectedPackageCount;
+    return {
+        dependentDelta: lastDeps - baseDeps,
+        packageDelta: last.affectedPackageCount - baseline.affectedPackageCount,
+        ...(baseline.risk !== last.risk ? { riskDrift: `${baseline.risk} → ${last.risk}` } : {}),
+        worsened: riskWorsened || dependentWorsened || packageWorsened,
+    };
+}
+function riskRank(r) {
+    switch (r) {
+        case 'low':
+            return 0;
+        case 'medium':
+            return 1;
+        case 'high':
+            return 2;
+        case 'critical':
+            return 3;
+    }
+}
+/**
+ * Build a compact `IImpactRunReport` from the full v3 payload + the
+ * request summary string. Pure; callers persist via `ImpactReportStore`.
+ */
+export function snapshotImpactAnalysis(analysis, inputSummary) {
+    return {
+        schema: IMPACT_RUN_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        inputKind: analysis.inputKind,
+        inputSummary,
+        risk: analysis.risk,
+        directDependentCount: analysis.directDependents.length,
+        transitiveDependentCount: analysis.transitiveDependents.length,
+        affectedPackageCount: analysis.affectedPackages.length,
+        affectedSymbolCount: analysis.affectedSymbols.length,
+        affectedCallerFileCount: analysis.affectedCallerFiles.length,
+        affectedRuleCount: analysis.affectedRules.length,
+        affectedTemplateCount: analysis.affectedTemplates.length,
+        likelyTestCount: analysis.likelyTests.length,
+        publicApiTouched: analysis.publicApiTouched,
+        riskReasons: [...analysis.riskReasons],
+        validationScope: [...analysis.validationScope],
+        diagnostics: [...analysis.diagnostics],
+    };
+}

package/dist/schema/impact-analysis.d.ts

@@ -0,0 +1,73 @@
+/**
+ * v3 impact-analysis payload. Built from the persistent code graph and
+ * (when available) the rule-graph bridge. Intentionally compatible with
+ * the existing v2 payload's *core shape* (input kind, normalised
+ * targets, dependent files, packages, tests) while adding:
+ *
+ *   - affectedSymbols / affectedCallerFiles — Wave 3 symbol edges.
+ *   - affectedRules / affectedTemplates / affectedPaths — rule-graph bridge.
+ *   - publicApiTouched — true if any normalised target is an index
+ *     entrypoint or declares an exported symbol.
+ *   - validationScope — exact `shrk …` commands to run.
+ */
+export declare const GRAPH_IMPACT_SCHEMA: "sharkcraft.graph-impact-analysis/v3";
+export type GraphImpactSchemaVersion = typeof GRAPH_IMPACT_SCHEMA;
+export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
+export interface IAffectedNodeRef {
+    /** Stable graph node id, e.g. `file:packages/foo/src/bar.ts`. */
+    id: string;
+    /** Project-relative path for File / Symbol nodes. */
+    path?: string;
+    /** Display label (symbol name, file basename, …). */
+    label: string;
+    /** Kind tag, e.g. 'file' | 'symbol' | 'package'. */
+    kind: string;
+    /** 1-based line number for symbols. */
+    line?: number;
+}
+export interface IAffectedAssetRef {
+    /** Bridge node id, e.g. `boundary:core.is-base-layer`. */
+    id: string;
+    /** Display label. */
+    label: string;
+    /** Optional severity / data carried over from the bridge edge. */
+    severity?: string;
+}
+export interface IGraphImpactAnalysis {
+    schema: GraphImpactSchemaVersion;
+    /** What kind of input the report was built from. */
+    inputKind: 'files' | 'symbol' | 'gitref';
+    /** Original normalised targets (file paths or `symbol:` ids). */
+    normalizedTargets: readonly string[];
+    /** Files importing a target directly (1-hop). */
+    directDependents: readonly IAffectedNodeRef[];
+    /** Files reachable via repeated reverse-import walk (capped). */
+    transitiveDependents: readonly IAffectedNodeRef[];
+    /** Symbols *declared by* the targets. */
+    affectedSymbols: readonly IAffectedNodeRef[];
+    /** Files that call/reference any affected symbol. */
+    affectedCallerFiles: readonly IAffectedNodeRef[];
+    /** Workspace packages touched (union of target packages + dependents). */
+    affectedPackages: readonly string[];
+    /** Rules (boundary) that apply to a target or dependent file. */
+    affectedRules: readonly IAffectedAssetRef[];
+    /** Path conventions matching a target or dependent file. */
+    affectedPaths: readonly IAffectedAssetRef[];
+    /** Templates whose output covers a target or dependent file. */
+    affectedTemplates: readonly IAffectedAssetRef[];
+    /** Likely tests for the targets / dependents (tag=test + dependent). */
+    likelyTests: readonly IAffectedNodeRef[];
+    /** True if any normalised target is an `index.ts` or declares exports. */
+    publicApiTouched: boolean;
+    /** Risk classification. */
+    risk: RiskLevel;
+    /** Human-readable reasons that contributed to the risk score. */
+    riskReasons: readonly string[];
+    /** Exact CLI commands to run before / after merging the change. */
+    validationScope: readonly string[];
+    /** Capped-list counters (when lists were truncated). */
+    truncations: Readonly<Record<string, number>>;
+    /** Free-form diagnostics (missing index, stale graph, etc.). */
+    diagnostics: readonly string[];
+}
+//# sourceMappingURL=impact-analysis.d.ts.map

package/dist/schema/impact-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-analysis.d.ts","sourceRoot":"","sources":["../../src/schema/impact-analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAG,qCAA8C,CAAC;AAElF,MAAM,MAAM,wBAAwB,GAAG,OAAO,mBAAmB,CAAC;AAElE,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAE/D,MAAM,WAAW,gBAAgB;IAC/B,iEAAiE;IACjE,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,EAAE,EAAE,MAAM,CAAC;IACX,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,wBAAwB,CAAC;IACjC,oDAAoD;IACpD,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACzC,iEAAiE;IACjE,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,iDAAiD;IACjD,gBAAgB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,iEAAiE;IACjE,oBAAoB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,yCAAyC;IACzC,eAAe,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC7C,qDAAqD;IACrD,mBAAmB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACjD,0EAA0E;IAC1E,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,iEAAiE;IACjE,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC5C,4DAA4D;IAC5D,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC5C,gEAAgE;IAChE,iBAAiB,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,wEAAwE;IACxE,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACzC,0EAA0E;IAC1E,gBAAgB,EAAE,OAAO,CAAC;IAC1B,2BAA2B;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,iEAAiE;IACjE,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,mEAAmE;IACnE,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,wDAAwD;IACxD,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,gEAAgE;IAChE,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC"}

package/dist/schema/impact-analysis.js

@@ -0,0 +1,13 @@
+/**
+ * v3 impact-analysis payload. Built from the persistent code graph and
+ * (when available) the rule-graph bridge. Intentionally compatible with
+ * the existing v2 payload's *core shape* (input kind, normalised
+ * targets, dependent files, packages, tests) while adding:
+ *
+ *   - affectedSymbols / affectedCallerFiles — Wave 3 symbol edges.
+ *   - affectedRules / affectedTemplates / affectedPaths — rule-graph bridge.
+ *   - publicApiTouched — true if any normalised target is an index
+ *     entrypoint or declares an exported symbol.
+ *   - validationScope — exact `shrk …` commands to run.
+ */
+export const GRAPH_IMPACT_SCHEMA = 'sharkcraft.graph-impact-analysis/v3';

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@shrkcrft/impact-engine",
+  "version": "0.1.0-alpha.10",
+  "description": "SharkCraft impact engine: graph-backed change analysis. Combines code graph + rule-graph + symbol-reference edges into a v3 impact payload (affected files, symbols, rules, templates, tests, risk).",
+  "license": "MIT",
+  "author": "SharkCraft contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sharkcraft/sharkcraft.git",
+    "directory": "packages/impact-engine"
+  },
+  "homepage": "https://github.com/sharkcraft/sharkcraft",
+  "bugs": {
+    "url": "https://github.com/sharkcraft/sharkcraft/issues"
+  },
+  "keywords": [
+    "sharkcraft",
+    "impact-engine",
+    "graph",
+    "code-intelligence",
+    "blast-radius"
+  ],
+  "engines": {
+    "bun": ">=1.1.0",
+    "node": ">=18"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@shrkcrft/core": "^0.1.0-alpha.10",
+    "@shrkcrft/graph": "^0.1.0-alpha.10",
+    "@shrkcrft/rule-graph": "^0.1.0-alpha.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}