@massa-ai/core 1.2.1

package/dist/services/symbol/cycle-detection.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Cycle Detection — Iterative Tarjan Strongly Connected Components (SCC)
+ *
+ * Wave 5 FR-02 / N2 / AD-W5-001 / AD-W5-017.
+ *
+ * A pure, allocation-bounded SCC finder for the `cycles` aspect of the
+ * architecture map. Iterative (explicit heap-allocated work stack) instead of
+ * recursive to avoid the JS stack overflow that recursive Tarjan hits on deep
+ * CALL graphs — the canonical failure mode called out in AD-W5-001 and gated
+ * by the Wave-3 MLTS-022 RSS guard pattern.
+ *
+ * Output: SCCs of size >1, OR single-node SCCs that carry a self-loop. Both
+ * are "cycles" semantically — a function that calls itself closes a cycle of
+ * one node. The caller (architecture.ts) decorates each SCC with a stable id
+ * + intra-SCC edge count.
+ *
+ * Budget: when `edges.length > budget`, the input is truncated to the first
+ * `budget` edges and `truncated=true` is surfaced. The default budget (400k)
+ * matches the iterative Tarjan edge ceiling (AD-W5-017) so the detector never
+ * overflows the JS stack under the RSS guard.
+ *
+ * Determinism: node order inside each SCC, and SCC order in the result, are
+ * both deterministic (sorted lexicographically) so snapshot fingerprinting and
+ * tests are reproducible across runs.
+ */
+import type { CallEdge } from "./architecture.js";
+/**
+ * One strongly connected component, expressed as the sorted list of node ids
+ * (file paths when the input edges are file-level CALL edges). Sorted for
+ * deterministic snapshot fingerprinting.
+ */
+export interface SCC {
+    nodes: string[];
+}
+/**
+ * Result of {@link detectCycles}. `truncated=true` when the input exceeded the
+ * budget; callers surface this as `cycles_truncated` on the architecture map.
+ */
+export interface DetectCyclesResult {
+    sccs: SCC[];
+    truncated: boolean;
+}
+/**
+ * Default edge budget (AD-W5-017). Matches the ceiling analyzed for the
+ * iterative implementation under the Wave-3 MLTS-022 RSS guard (< 16 MiB
+ * resident set growth over baseline on a 500k-edge stress).
+ */
+export declare const DEFAULT_CYCLE_EDGE_BUDGET = 400000;
+/**
+ * Compute SCCs of a directed graph derived from `edges`. Returns SCCs of size
+ * >1 plus single-node SCCs with a self-loop.
+ *
+ * @param edges  Directed edges. Endpoints are opaque node ids (file paths for
+ *               the architecture use case). Self-edges `{from:x,to:x}` count
+ *               as a cycle of size 1.
+ * @param budget Hard cap on the number of edges processed. Edges beyond the
+ *               budget are dropped and `truncated=true` is returned. Defaults
+ *               to {@link DEFAULT_CYCLE_EDGE_BUDGET}.
+ */
+export declare function detectCycles(edges: ReadonlyArray<CallEdge>, budget?: number): DetectCyclesResult;
+//# sourceMappingURL=cycle-detection.d.ts.map

package/dist/services/symbol/cycle-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle-detection.d.ts","sourceRoot":"","sources":["../../../src/services/symbol/cycle-detection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAIlD;;;;GAIG;AACH,MAAM,WAAW,GAAG;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,SAAS,EAAE,OAAO,CAAC;CACpB;AAID;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAajD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,EAC9B,MAAM,GAAE,MAAkC,GACzC,kBAAkB,CAyIpB"}

package/dist/services/symbol/cycle-detection.js

@@ -0,0 +1,182 @@
+/**
+ * Cycle Detection — Iterative Tarjan Strongly Connected Components (SCC)
+ *
+ * Wave 5 FR-02 / N2 / AD-W5-001 / AD-W5-017.
+ *
+ * A pure, allocation-bounded SCC finder for the `cycles` aspect of the
+ * architecture map. Iterative (explicit heap-allocated work stack) instead of
+ * recursive to avoid the JS stack overflow that recursive Tarjan hits on deep
+ * CALL graphs — the canonical failure mode called out in AD-W5-001 and gated
+ * by the Wave-3 MLTS-022 RSS guard pattern.
+ *
+ * Output: SCCs of size >1, OR single-node SCCs that carry a self-loop. Both
+ * are "cycles" semantically — a function that calls itself closes a cycle of
+ * one node. The caller (architecture.ts) decorates each SCC with a stable id
+ * + intra-SCC edge count.
+ *
+ * Budget: when `edges.length > budget`, the input is truncated to the first
+ * `budget` edges and `truncated=true` is surfaced. The default budget (400k)
+ * matches the iterative Tarjan edge ceiling (AD-W5-017) so the detector never
+ * overflows the JS stack under the RSS guard.
+ *
+ * Determinism: node order inside each SCC, and SCC order in the result, are
+ * both deterministic (sorted lexicographically) so snapshot fingerprinting and
+ * tests are reproducible across runs.
+ */
+// ─── Constants ───────────────────────────────────────────────────────────────
+/**
+ * Default edge budget (AD-W5-017). Matches the ceiling analyzed for the
+ * iterative implementation under the Wave-3 MLTS-022 RSS guard (< 16 MiB
+ * resident set growth over baseline on a 500k-edge stress).
+ */
+export const DEFAULT_CYCLE_EDGE_BUDGET = 400_000;
+/**
+ * Compute SCCs of a directed graph derived from `edges`. Returns SCCs of size
+ * >1 plus single-node SCCs with a self-loop.
+ *
+ * @param edges  Directed edges. Endpoints are opaque node ids (file paths for
+ *               the architecture use case). Self-edges `{from:x,to:x}` count
+ *               as a cycle of size 1.
+ * @param budget Hard cap on the number of edges processed. Edges beyond the
+ *               budget are dropped and `truncated=true` is returned. Defaults
+ *               to {@link DEFAULT_CYCLE_EDGE_BUDGET}.
+ */
+export function detectCycles(edges, budget = DEFAULT_CYCLE_EDGE_BUDGET) {
+    // Budget enforcement: drop trailing edges and flag truncation. We process
+    // the FIRST `budget` edges (preserve insertion order so the caller's
+    // ordering — e.g. sorted by from_file — is respected in the result).
+    let truncated = false;
+    let working = edges;
+    if (edges.length > budget) {
+        truncated = true;
+        working = edges.slice(0, budget);
+    }
+    if (working.length === 0)
+        return { sccs: [], truncated };
+    // ── Build adjacency + self-loop set ──────────────────────────────────────
+    // adj[v] = sorted unique successors of v. Self-loops are tracked separately
+    // so we can flag size-1 SCCs that close a cycle on themselves.
+    const adj = new Map();
+    const selfLoop = new Set();
+    const nodeSet = new Set();
+    for (const e of working) {
+        nodeSet.add(e.from);
+        nodeSet.add(e.to);
+        if (e.from === e.to) {
+            selfLoop.add(e.from);
+            continue;
+        }
+        let arr = adj.get(e.from);
+        if (!arr) {
+            arr = [];
+            adj.set(e.from, arr);
+        }
+        arr.push(e.to);
+    }
+    // Dedup successors per node so the iterative traversal does not re-queue
+    // the same successor twice from the same parent.
+    for (const [k, arr] of adj) {
+        if (arr.length <= 1)
+            continue;
+        const uniq = Array.from(new Set(arr));
+        if (uniq.length !== arr.length)
+            adj.set(k, uniq);
+    }
+    // ── Tarjan state ────────────────────────────────────────────────────────
+    let indexCounter = 0;
+    const indices = new Map();
+    const lowlink = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const sccs = [];
+    const work = [];
+    for (const start of nodeSet) {
+        if (indices.has(start))
+            continue;
+        work.push({ v: start, succ: adj.get(start) ?? EMPTY, pi: 0 });
+        while (work.length > 0) {
+            const frame = work[work.length - 1];
+            const { v, succ, pi } = frame;
+            if (pi === 0) {
+                // First visit: assign index + lowlink, push onto SCC stack.
+                indices.set(v, indexCounter);
+                lowlink.set(v, indexCounter);
+                indexCounter++;
+                stack.push(v);
+                onStack.add(v);
+            }
+            let recursed = false;
+            let i = pi;
+            while (i < succ.length) {
+                const w = succ[i];
+                const wIdx = indices.get(w);
+                if (wIdx === undefined) {
+                    // Successor not yet visited: recurse. Resume this frame at i+1
+                    // AFTER the child returns so its lowlink propagates here.
+                    frame.pi = i + 1;
+                    work.push({ v: w, succ: adj.get(w) ?? EMPTY, pi: 0 });
+                    recursed = true;
+                    break;
+                }
+                else if (onStack.has(w)) {
+                    // Back edge or cross edge to a node still on the stack: refine lowlink.
+                    const vl = lowlink.get(v);
+                    if (wIdx < vl)
+                        lowlink.set(v, wIdx);
+                }
+                i++;
+            }
+            if (recursed)
+                continue;
+            // Done processing all successors of v. If v is the root of an SCC,
+            // pop the stack into a new SCC.
+            const vIdx = indices.get(v);
+            const vLow = lowlink.get(v);
+            if (vLow === vIdx) {
+                const component = [];
+                for (;;) {
+                    const w = stack.pop();
+                    onStack.delete(w);
+                    component.push(w);
+                    if (w === v)
+                        break;
+                }
+                sccs.push(component);
+            }
+            // Propagate lowlink to parent (if any).
+            work.pop();
+            if (work.length > 0) {
+                const parent = work[work.length - 1];
+                const pl = lowlink.get(parent.v);
+                if (vLow < pl)
+                    lowlink.set(parent.v, vLow);
+            }
+        }
+    }
+    // ── Filter + sort for determinism ───────────────────────────────────────
+    // Keep SCCs of size >1, OR size-1 SCCs with a self-loop (a function that
+    // calls itself closes a cycle).
+    const cyclic = [];
+    for (const c of sccs) {
+        if (c.length > 1) {
+            c.sort();
+            cyclic.push(c);
+        }
+        else if (c.length === 1 && selfLoop.has(c[0])) {
+            cyclic.push(c);
+        }
+    }
+    // Sort SCCs by their first node so output is stable across run order.
+    cyclic.sort((a, b) => {
+        const n = Math.min(a.length, b.length);
+        for (let i = 0; i < n; i++) {
+            const d = a[i] < b[i] ? -1 : a[i] > b[i] ? 1 : 0;
+            if (d !== 0)
+                return d;
+        }
+        return a.length - b.length;
+    });
+    return { sccs: cyclic.map((nodes) => ({ nodes })), truncated };
+}
+const EMPTY = Object.freeze([]);
+//# sourceMappingURL=cycle-detection.js.map

package/dist/services/symbol/cycle-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle-detection.js","sourceRoot":"","sources":["../../../src/services/symbol/cycle-detection.ts"],"names":[],"mappings":"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"}

package/dist/services/symbol/definition-lookup.d.ts

@@ -0,0 +1,31 @@
+import type { DefinitionFqnResolution, SymbolDefinition, SymbolRepositoryPg } from "../../data/symbol/symbol-repository-pg.js";
+import type { SymbolIdentityResolution } from "@massa-ai/shared";
+export type DefinitionLookupResult = {
+    readonly status: "resolved";
+    readonly definition: SymbolDefinition;
+} | {
+    readonly status: "ambiguous";
+    readonly legacyFqn: string;
+    readonly candidates: Extract<DefinitionFqnResolution, {
+        ambiguous: true;
+    }>['candidates'];
+} | {
+    readonly status: "missing";
+    readonly query: string;
+} | {
+    readonly status: "bare";
+    readonly query: string;
+    readonly definitions: readonly SymbolDefinition[];
+};
+type LookupRepository = Pick<SymbolRepositoryPg, "resolveDefinitionFqn" | "findDefinitionsByName">;
+/** Stable public projection shared by HTTP and MCP transport surfaces. */
+export declare function toSymbolIdentityResolution(result: DefinitionLookupResult): SymbolIdentityResolution;
+/** One active-generation lookup contract shared by every graph consumer. */
+export declare class DefinitionLookupService {
+    private readonly repository;
+    constructor(repository?: () => LookupRepository);
+    lookup(projectId: string, query: string): Promise<DefinitionLookupResult>;
+}
+export declare const definitionLookupService: DefinitionLookupService;
+export {};
+//# sourceMappingURL=definition-lookup.d.ts.map

package/dist/services/symbol/definition-lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-lookup.d.ts","sourceRoot":"","sources":["../../../src/services/symbol/definition-lookup.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,uBAAuB,EACvB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,2CAA2C,CAAC;AAEnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAEjE,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAA;CAAE,GACtE;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,uBAAuB,EAAE;QAAE,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC,YAAY,CAAC,CAAA;CAAE,GACtJ;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAAE,CAAC;AAE3G,KAAK,gBAAgB,GAAG,IAAI,CAAC,kBAAkB,EAAE,sBAAsB,GAAG,uBAAuB,CAAC,CAAC;AAEnG,0EAA0E;AAC1E,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,sBAAsB,GAC7B,wBAAwB,CAe1B;AAED,4EAA4E;AAC5E,qBAAa,uBAAuB;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,GAAE,MAAM,gBAAsC;IAE/E,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;CAsBhF;AAED,eAAO,MAAM,uBAAuB,yBAAgC,CAAC"}

package/dist/services/symbol/definition-lookup.js

@@ -0,0 +1,53 @@
+import { getSymbolRepository } from "../../data/symbol/symbol-repository-factory.js";
+import { parseStructuralFqn } from "../structural/fqn-codec.js";
+/** Stable public projection shared by HTTP and MCP transport surfaces. */
+export function toSymbolIdentityResolution(result) {
+    switch (result.status) {
+        case "resolved":
+            return Object.freeze({ status: "resolved", fqn: result.definition.id });
+        case "ambiguous":
+            return Object.freeze({
+                status: "ambiguous",
+                legacyFqn: result.legacyFqn,
+                candidates: result.candidates,
+            });
+        case "missing":
+            return Object.freeze({ status: "missing", query: result.query });
+        case "bare":
+            return Object.freeze({ status: "bare", query: result.query });
+    }
+}
+/** One active-generation lookup contract shared by every graph consumer. */
+export class DefinitionLookupService {
+    repository;
+    constructor(repository = getSymbolRepository) {
+        this.repository = repository;
+    }
+    async lookup(projectId, query) {
+        const repo = this.repository();
+        if (query.indexOf("#") <= 0) {
+            const definitions = await repo.findDefinitionsByName(projectId, query);
+            return definitions.length > 0
+                ? Object.freeze({ status: "bare", query, definitions: Object.freeze(definitions) })
+                : Object.freeze({ status: "missing", query });
+        }
+        try {
+            parseStructuralFqn(query);
+        }
+        catch {
+            return Object.freeze({ status: "missing", query });
+        }
+        const result = await repo.resolveDefinitionFqn(projectId, query);
+        if (result.found)
+            return Object.freeze({ status: "resolved", definition: result.definition });
+        if (result.ambiguous)
+            return Object.freeze({
+                status: "ambiguous",
+                legacyFqn: result.legacyFqn,
+                candidates: result.candidates,
+            });
+        return Object.freeze({ status: "missing", query });
+    }
+}
+export const definitionLookupService = new DefinitionLookupService();
+//# sourceMappingURL=definition-lookup.js.map

package/dist/services/symbol/definition-lookup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-lookup.js","sourceRoot":"","sources":["../../../src/services/symbol/definition-lookup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AAMrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAWhE,0EAA0E;AAC1E,MAAM,UAAU,0BAA0B,CACxC,MAA8B;IAE9B,QAAQ,MAAM,CAAC,MAAM,EAAE,CAAC;QACtB,KAAK,UAAU;YACb,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1E,KAAK,WAAW;YACd,OAAO,MAAM,CAAC,MAAM,CAAC;gBACnB,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;aAC9B,CAAC,CAAC;QACL,KAAK,SAAS;YACZ,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;QACnE,KAAK,MAAM;YACT,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAClE,CAAC;AACH,CAAC;AAED,4EAA4E;AAC5E,MAAM,OAAO,uBAAuB;IACL;IAA7B,YAA6B,aAAqC,mBAAmB;QAAxD,eAAU,GAAV,UAAU,CAA8C;IAAG,CAAC;IAEzF,KAAK,CAAC,MAAM,CAAC,SAAiB,EAAE,KAAa;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YACvE,OAAO,WAAW,CAAC,MAAM,GAAG,CAAC;gBAC3B,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;gBACnF,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,IAAI,CAAC;YACH,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,MAAM,MAAM,GAA4B,MAAM,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC1F,IAAI,MAAM,CAAC,KAAK;YAAE,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;QAC9F,IAAI,MAAM,CAAC,SAAS;YAAE,OAAO,MAAM,CAAC,MAAM,CAAC;gBACzC,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;aAC9B,CAAC,CAAC;QACH,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;IACrD,CAAC;CACF;AAED,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,uBAAuB,EAAE,CAAC"}

package/dist/services/symbol/git-ref-validation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shell-arg validation for git refs (`base_branch` / `since`).
+ *
+ * `defaultDiffRunner` uses `execFileSync("git", [...])`, which already
+ * prevents shell injection (no `sh -c`). This guard prevents the git CLI's
+ * own arg-injection surface — e.g. `base_branch = "--upload-pack=evil"` —
+ * from being passed to git as an option-flag instead of a revision.
+ *
+ * Spec AC 10 (N8): reject values starting with `--` or containing
+ * `\r`, `\n`, `;`, `|`, `&`, `$`, `<`, `>`, `(`, `)`, `{`, `}`, or `\`.
+ * The accepted pattern is `/^[A-Za-z0-9._\/+-]+$/` (covers branch names,
+ * tags, SHAs, ISO dates, and `origin/main`-style refs).
+ */
+/**
+ * Validate a git ref param before it reaches `execFileSync("git", [...])`.
+ *
+ * Empty string is ALLOWED here — the caller (`defaultDiffRunner`) treats an
+ * empty `base_branch` as "fall back to `main`", so we do not reject it at
+ * the validation layer. Non-empty values must match the accepted pattern
+ * and must not start with `--` (git arg-injection).
+ *
+ * @throws ToolError("Invalid <paramName> value: <value>. Valid pattern: ...")
+ *   when `value` starts with `--` or fails the accepted pattern.
+ */
+export declare function validateGitRef(paramName: string, value: string): void;
+//# sourceMappingURL=git-ref-validation.d.ts.map

package/dist/services/symbol/git-ref-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-ref-validation.d.ts","sourceRoot":"","sources":["../../../src/services/symbol/git-ref-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAOrE"}

package/dist/services/symbol/git-ref-validation.js

@@ -0,0 +1,34 @@
+/**
+ * Shell-arg validation for git refs (`base_branch` / `since`).
+ *
+ * `defaultDiffRunner` uses `execFileSync("git", [...])`, which already
+ * prevents shell injection (no `sh -c`). This guard prevents the git CLI's
+ * own arg-injection surface — e.g. `base_branch = "--upload-pack=evil"` —
+ * from being passed to git as an option-flag instead of a revision.
+ *
+ * Spec AC 10 (N8): reject values starting with `--` or containing
+ * `\r`, `\n`, `;`, `|`, `&`, `$`, `<`, `>`, `(`, `)`, `{`, `}`, or `\`.
+ * The accepted pattern is `/^[A-Za-z0-9._\/+-]+$/` (covers branch names,
+ * tags, SHAs, ISO dates, and `origin/main`-style refs).
+ */
+import { ToolError } from "../../tools/enum-validation.js";
+const GIT_REF_PATTERN = /^[A-Za-z0-9._\/+-]+$/;
+/**
+ * Validate a git ref param before it reaches `execFileSync("git", [...])`.
+ *
+ * Empty string is ALLOWED here — the caller (`defaultDiffRunner`) treats an
+ * empty `base_branch` as "fall back to `main`", so we do not reject it at
+ * the validation layer. Non-empty values must match the accepted pattern
+ * and must not start with `--` (git arg-injection).
+ *
+ * @throws ToolError("Invalid <paramName> value: <value>. Valid pattern: ...")
+ *   when `value` starts with `--` or fails the accepted pattern.
+ */
+export function validateGitRef(paramName, value) {
+    if (value === "")
+        return; // caller handles empty → default "main"
+    if (value.startsWith("--") || !GIT_REF_PATTERN.test(value)) {
+        throw new ToolError(`Invalid ${paramName} value: ${value}. Valid pattern: alphanumeric, -, /, ., _, +.`);
+    }
+}
+//# sourceMappingURL=git-ref-validation.js.map

package/dist/services/symbol/git-ref-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-ref-validation.js","sourceRoot":"","sources":["../../../src/services/symbol/git-ref-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAE3D,MAAM,eAAe,GAAG,sBAAsB,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,SAAiB,EAAE,KAAa;IAC7D,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,CAAC,wCAAwC;IAClE,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3D,MAAM,IAAI,SAAS,CACjB,WAAW,SAAS,WAAW,KAAK,+CAA+C,CACpF,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/services/symbol/impact-analysis.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Impact Analysis Service (Phase 4 D3)
+ *
+ * Given a git diff scope (unstaged / staged / committed-vs-base), compute the
+ * set of symbols whose callers or dependents are affected by the change, and
+ * rank them by a risk score derived from PageRank centrality (blast radius)
+ * and graph distance (closer = riskier).
+ *
+ * Approach (ported-and-rewritten from codebase-memory-mcp's `detect_changes`
+ * concept; that reference only mapped files→symbols — the reverse-traversal
+ * and risk scoring here are fresh):
+ *
+ *   1. Run a SCOPED `git diff --name-only` to get changed files (never the
+ *      whole repo; the diff runner is injectable for tests).
+ *   2. Map each changed file → symbols defined there (listDefinitions).
+ *   3. REVERSE-traverse the dependency graph to find impacted consumers:
+ *        - File level: who imports the changed file? (symbol_imports reverse)
+ *        - Symbol level: who references the changed symbols? (get_references)
+ *      These two are the reliable CROSS-FILE signals. Typed CALL edges (D1)
+ *      are same-file only, so they are a secondary refinement, not the spine.
+ *   4. Propagate impact by `depth` over the reverse file-import graph.
+ *   5. Score each impacted symbol: risk = centralityWeight + proximityWeight
+ *      (centrality of the impacted file; closer hops weigh more).
+ *   6. Sort descending, cap the result count.
+ *
+ * Cost is bounded by MAX_DEPTH, MAX_IMPACTED, and a visited set so a patho-
+ * logical fan-out cannot exhaust memory/time.
+ */
+import { getSymbolRepository } from "../../data/symbol/symbol-repository-factory.js";
+export type ImpactScope = "unstaged" | "staged" | "committed" | "all";
+/**
+ * Result shape of the diff runner (N7). `paths` is the deduped set of changed
+ * files (tracked + untracked, minus secret-like untracked files). `untrackedFiltered`
+ * counts how many untracked paths were excluded by the secrets denylist so
+ * the response can surface it (`untracked_filtered`).
+ */
+export interface DiffRunnerResult {
+    paths: string[];
+    untrackedFiltered: number;
+}
+export interface ImpactAnalysisOptions {
+    projectId: string;
+    /** Absolute path to the project working tree (where `git` runs). */
+    projectPath: string;
+    /** What diff to analyze. */
+    scope: ImpactScope;
+    /** For committed scope: diff against this branch (default "main"). */
+    baseBranch?: string;
+    /** For committed scope: commits since this date/ref (e.g. "2026-07-01" or a SHA). */
+    since?: string;
+    /** How far to propagate impact through the reverse import graph. Default 2. */
+    depth?: number;
+    /** Optional filter — only consider these changed paths (relative). */
+    paths?: string[];
+    /** Injectable diff runner (tests pass a stub; production runs real git). */
+    diffRunner?: (projectPath: string, scope: ImpactScope, baseBranch?: string, since?: string) => DiffRunnerResult;
+    /**
+     * Injectable symbol repository (tests pass an instrumented stub; production
+     * resolves the singleton via {@link getSymbolRepository}). Using this seam
+     * instead of `mock.module` on the factory avoids a process-wide mock that
+     * leaks into concurrently-run sibling suites (which then crash the ETL
+     * pipeline with "clearProject is not a function" on the real repo).
+     */
+    repoOverride?: ReturnType<typeof getSymbolRepository>;
+    /**
+     * Wall-clock budget (ms) for the reverse-BFS. If exceeded, the traversal
+     * aborts with `truncated=true` and the impacted set collected so far.
+     * Additive to MAX_DEPTH / MAX_IMPACTED / MAX_DEF_QUERIES. Default 5s.
+     * Injectable clock is for deterministic tests.
+     */
+    deadlineMs?: number;
+    /** Injectable clock (defaults to Date.now) for deterministic deadline tests. */
+    now?: () => number;
+}
+export interface ChangedFile {
+    /** Relative path inside the project (matches symbol_definitions.file_path). */
+    path: string;
+    /** Symbols defined in this file. */
+    symbols: {
+        fqn: string;
+        name: string;
+        kind: string;
+        line: number;
+    }[];
+}
+export interface ImpactedSymbol {
+    /** The impacted consumer symbol (a caller/dependent of the changed code). */
+    fqn: string;
+    name: string;
+    file: string;
+    line: number;
+    /** Hop distance from the nearest changed file (0 = directly imports it). */
+    depth: number;
+    /** PageRank centrality of the impacted symbol's file (0–1). */
+    centrality: number;
+    /** Computed risk score (higher = riskier). Sorted descending. */
+    risk: number;
+    /** Human-readable reason this symbol is impacted. */
+    reason: string;
+    /** Which changed file/symbol reaches it. */
+    via: {
+        changedFile: string;
+        changedSymbol?: string;
+        edge: "import" | "reference";
+    };
+}
+export interface ImpactAnalysisResult {
+    projectId: string;
+    scope: ImpactScope;
+    baseBranch?: string;
+    since?: string;
+    depth: number;
+    changedFiles: ChangedFile[];
+    impacted: ImpactedSymbol[];
+    truncated: boolean;
+    /** Number of untracked new files excluded from the diff because they
+     * matched the secrets denylist (e.g. `.env*`, `*.key`, `*.pem`). Surfaced
+     * so agents can see that a secret was deliberately filtered (N7 AC 9a). */
+    untrackedFiltered: number;
+    /**
+     * N4: pre-clamp total of unique impacted FQNs (the count we would have
+     * returned if MAX_IMPACTED did not apply). `impacted_shown = impacted.length`
+     * and `impacted_omitted = impacted_total - impacted_shown` are derivable
+     * on the same code path as the displayed list.
+     */
+    impacted_total: number;
+    impacted_shown: number;
+    impacted_omitted: number;
+    /**
+     * Wave 5 FR-03 / N41: quotient rollup of impacted files by 2-segment path
+     * prefix. Cap DEFAULT_MODULE_CAP prefixes; overflow folds into `(other)`.
+     * Same emitter as impacted_total/shown/omitted so the counts are consistent.
+     * Undefined when there are no impacted files (backward-compat).
+     */
+    impacted_modules?: {
+        prefix: string;
+        count: number;
+    }[];
+    /** Diagnostic when git produced no output (e.g. clean tree). */
+    note?: string;
+}
+export declare class ImpactAnalysisService {
+    private static instance;
+    private constructor();
+    static getInstance(): ImpactAnalysisService;
+    /**
+     * Run the impact analysis. See {@link ImpactAnalysisOptions}.
+     */
+    analyze(opts: ImpactAnalysisOptions): Promise<ImpactAnalysisResult>;
+    /** All file paths indexed for the project (relative). */
+    private allIndexedFiles;
+    /** Definitions in a single file (kind kept for filtering). */
+    private listDefinitionsByFile;
+    /**
+     * Reverse import graph: importerOf(file) = list of importer file paths for
+     * every file that imports `file` (i.e. symbol_imports where to_file === file).
+     * Built once from allImportEdges (client-side reverse; PG repo lacks
+     * findImporters). PostgreSQL allImportEdges returns a minimal {from_file,to_file}
+     * row (no specifier); PG returns full SymbolImport — we coerce to the minimal
+     * shape so both backends unify.
+     */
+    private buildReverseImportGraph;
+    /** PageRank centrality map (file → score). */
+    private getCentralityMap;
+}
+/**
+ * Group impacted files by their 2-segment path prefix (`path/to/file.ts` →
+ * `path/to`). Cap at `moduleCap` prefixes (highest count first); fold the
+ * overflow into an `(other)` entry. Files with no `/` use the full path as
+ * their prefix. The rollup runs over the FULL pre-clamp impacted set so it
+ * reflects the total blast radius, not the truncated view.
+ *
+ * Pure (no I/O); exported for B2/B3 consumption + unit testing.
+ */
+export declare function computeImpactedModules(impacted: ImpactedSymbol[], moduleCap?: number): {
+    prefix: string;
+    count: number;
+}[];
+/**
+ * Run a SCOPED `git diff --name-only` in `projectPath`. Returns relative paths.
+ * Scope:
+ *   - unstaged:  `git diff --name-only` (+ untracked new files)
+ *   - staged:    `git diff --name-only --cached` (+ untracked new files)
+ *   - committed: `git diff --name-only <base>...HEAD` (single-source; no untracked)
+ *   - all:       committed + unstaged + untracked new files, deduped
+ *
+ * `scope=unstaged` (default) and `scope=staged` BREAKINGLY now include
+ * untracked new files (`git ls-files --others --exclude-standard`), matching
+ * the cbm invariant: untracked new files are invisible to `git diff` but are
+ * semantically part of the working-tree change. `scope=committed` stays
+ * single-source (committed-only) for callers that want the old behavior.
+ *
+ * Secret-like untracked paths (`.env*`, `*.key`, `*.pem`, `secrets.*`, etc.)
+ * are excluded and counted in `untrackedFiltered` (N7 AC 9a). Dedup is via
+ * `Set<string>`.
+ *
+ * `baseBranch`/`since` are validated against git arg-injection (N8) before any
+ * `execFileSync` call.
+ *
+ * Never invoked on the whole repo by the tool — the scope is always bounded.
+ * Throws on git failure so the tool can surface a clean error.
+ */
+export declare function defaultDiffRunner(projectPath: string, scope: ImpactScope, baseBranch?: string, since?: string): DiffRunnerResult;
+export declare const impactAnalysisService: ImpactAnalysisService;
+//# sourceMappingURL=impact-analysis.d.ts.map

package/dist/services/symbol/impact-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-analysis.d.ts","sourceRoot":"","sources":["../../../src/services/symbol/impact-analysis.ts"],"names":[],"mappings":"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"}