@neurcode-ai/cli 0.10.0 → 0.12.0

package/dist/governance/intent/drift-detector.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Architectural Drift Detector — deterministic, bounded, explainable.
+ *
+ * Given an intent graph (declared architecture) and a diff (proposed change),
+ * the detector answers: *did this change introduce a dependency edge that
+ * violates the declared architecture?*
+ *
+ * Algorithm (entirely deterministic):
+ *   1. Classify each diff-file into a layer using `firstMatchingGlob` over the
+ *      contract's `layers[].glob`. First match wins. Files with no matching
+ *      layer are "unclassified" and surface as soft findings (not violations).
+ *   2. Extract import edges from added lines via `extractImportEdgesFromDiff`.
+ *   3. For each edge, resolve the *target layer*:
+ *        a. Relative specifiers (`./`, `../`) → resolve to a project-relative
+ *           path, then classify by glob.
+ *        b. Workspace-package specifiers (`@scope/name`) → mapped to the
+ *           package's layer via a module entry, when available.
+ *        c. Bare specifiers (`react`, `lodash`) → marked as `external`.
+ *      External imports are not subject to layer rules in Phase 1.
+ *   4. For each (fromLayer, toLayer) pair where both are known:
+ *        - If the pair appears in `forbiddenEdges` → produce a BLOCK violation.
+ *        - If `allowedEdges` is non-empty and the pair is not in it →
+ *          produce a WARN violation (`undeclared_edge`).
+ *
+ * Determinism: same diff + same contract = same `DriftReport` byte-for-byte.
+ * Output keys are emitted in stable order; arrays are sorted by `fromFile,line,specifier`.
+ *
+ * Intelligence classification: DETERMINISTIC.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDriftDetection = runDriftDetection;
+exports.intentGraphIsEnforceable = intentGraphIsEnforceable;
+const path_1 = require("path");
+const import_graph_1 = require("./import-graph");
+const glob_match_1 = require("./glob-match");
+const intent_graph_1 = require("./intent-graph");
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Run drift detection. Returns a stable, typed report.
+ *
+ * Behaviour edge-cases:
+ *   - Empty graph → empty report, `driftDetected: false`. Zero cost.
+ *   - Graph has layers but no edges → classification runs, no violations emitted.
+ *     Useful for "observe before enforce" rollouts.
+ *   - File-of-file with no matching layer → file surfaces in `unclassifiedFiles`,
+ *     but its imports are skipped (we cannot evaluate a rule on an unknown layer).
+ */
+function runDriftDetection(input) {
+    const { graph, diffFiles } = input;
+    const enforce = input.enforce ?? false;
+    if ((0, intent_graph_1.isEmptyIntentGraph)(graph)) {
+        return emptyReport(graph.fingerprint);
+    }
+    // 1. Classify diff files.
+    const classifiedFiles = [];
+    const fileLayerMap = new Map();
+    const unclassified = [];
+    for (const f of diffFiles) {
+        const classification = classifyFile(f.path, graph);
+        classifiedFiles.push(classification);
+        if (classification.layer) {
+            fileLayerMap.set(f.path, classification.layer);
+        }
+        else {
+            unclassified.push(f.path);
+        }
+    }
+    // 2. Extract imports.
+    const allEdges = (0, import_graph_1.extractImportEdgesFromDiff)(diffFiles);
+    const byFile = (0, import_graph_1.groupImportEdgesByFile)(allEdges);
+    // 3. Evaluate edges.
+    const violations = [];
+    const external = [];
+    const layersTouched = new Set();
+    const forbiddenEdgesViolated = new Set();
+    let importsAnalyzed = 0;
+    for (const [file, edges] of byFile) {
+        const fromLayer = fileLayerMap.get(file);
+        if (!fromLayer) {
+            // We already recorded the file as unclassified; nothing to evaluate.
+            continue;
+        }
+        layersTouched.add(fromLayer);
+        for (const edge of edges) {
+            importsAnalyzed += 1;
+            const resolution = resolveImportTarget(edge, graph, file);
+            if (resolution.kind === 'external') {
+                external.push({ file, specifier: edge.specifier, line: edge.line });
+                continue;
+            }
+            if (resolution.kind === 'unresolved') {
+                // Internal-looking specifier we could not pin to a layer. Skip silently
+                // in Phase 1 — surface upgrades come in Phase 2 (semantic diff).
+                continue;
+            }
+            const toLayer = resolution.layer;
+            layersTouched.add(toLayer);
+            // Forbidden edge check
+            const forbidden = graph.forbiddenEdges.find((e) => e.from === fromLayer && e.to === toLayer);
+            if (forbidden) {
+                const rule = `forbidden: ${fromLayer} → ${toLayer}`;
+                forbiddenEdgesViolated.add(rule);
+                violations.push({
+                    kind: 'forbidden_edge',
+                    severity: enforce ? 'block' : 'warn',
+                    file,
+                    line: edge.line,
+                    fromLayer,
+                    toLayer,
+                    specifier: edge.specifier,
+                    reason: forbidden.reason ??
+                        `Layer "${fromLayer}" must not import from layer "${toLayer}".`,
+                    evidence: {
+                        rawStatement: edge.rawStatement,
+                        contractRule: rule,
+                    },
+                });
+                continue;
+            }
+            // Undeclared edge check (only when allowedEdges is non-empty)
+            if (graph.allowedEdges.length > 0) {
+                const allowed = graph.allowedEdges.some((e) => e.from === fromLayer && e.to === toLayer);
+                if (!allowed && fromLayer !== toLayer) {
+                    violations.push({
+                        kind: 'undeclared_edge',
+                        severity: 'warn',
+                        file,
+                        line: edge.line,
+                        fromLayer,
+                        toLayer,
+                        specifier: edge.specifier,
+                        reason: `Edge ${fromLayer} → ${toLayer} is not in the contract's allowedEdges. ` +
+                            `Either add it to the contract or refactor the dependency.`,
+                        evidence: {
+                            rawStatement: edge.rawStatement,
+                            contractRule: `not-in-allowed: ${fromLayer} → ${toLayer}`,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    // Sort for determinism
+    violations.sort(sortByFileLineSpecifier);
+    const blockCount = violations.filter((v) => v.severity === 'block').length;
+    const warnCount = violations.filter((v) => v.severity === 'warn').length;
+    return {
+        schemaVersion: 1,
+        driftDetected: violations.length > 0,
+        violations,
+        classifiedFiles,
+        unclassifiedFiles: unclassified.slice().sort(),
+        externalImports: external,
+        summary: {
+            filesAnalyzed: diffFiles.length,
+            importsAnalyzed,
+            violationCount: violations.length,
+            blockCount,
+            warnCount,
+            layersTouched: [...layersTouched].sort(),
+            forbiddenEdgesViolated: [...forbiddenEdgesViolated].sort(),
+        },
+        contractFingerprint: graph.fingerprint,
+        intelligenceClassification: 'deterministic',
+    };
+}
+// Marker for use when enforcement is disabled and we want to short-circuit
+function intentGraphIsEnforceable(graph) {
+    return (0, intent_graph_1.intentGraphHasEnforcement)(graph);
+}
+// ── Internal — classification ────────────────────────────────────────────────
+function classifyFile(path, graph) {
+    for (const layer of graph.layers) {
+        const matched = (0, glob_match_1.firstMatchingGlob)(layer.glob, path);
+        if (matched) {
+            return { path, layer: layer.id, matchedGlob: matched };
+        }
+    }
+    return { path, layer: null, matchedGlob: null };
+}
+function resolveImportTarget(edge, graph, sourceFile) {
+    const spec = edge.specifier;
+    // Relative specifiers: resolve against the source file's directory.
+    if (spec.startsWith('./') || spec.startsWith('../') || spec.startsWith('/')) {
+        const resolved = resolveRelativeSpecifier(sourceFile, spec);
+        if (!resolved)
+            return { kind: 'unresolved' };
+        const layer = classifyPathToLayer(resolved, graph.layers);
+        if (layer)
+            return { kind: 'classified', layer };
+        return { kind: 'unresolved' };
+    }
+    // Bare specifier — external dependency, not a layer.
+    // Includes `@scope/pkg` since we don't have a workspace-package → layer
+    // map in Phase 1. Workspace-package layer mapping is a Phase 2 enhancement.
+    return { kind: 'external' };
+}
+/**
+ * Resolve a relative specifier (e.g. `../service/auth`) against a source file
+ * (e.g. `src/commands/login.ts`) to a project-relative path (e.g.
+ * `src/service/auth`). Extension is not appended — the layer globs are expected
+ * to be flexible enough to match either form, but we additionally try common
+ * extensions for a best-effort hit.
+ */
+function resolveRelativeSpecifier(sourceFile, specifier) {
+    try {
+        const sourceDir = (0, path_1.dirname)((0, glob_match_1.normalizePathForGlob)(sourceFile));
+        const joined = path_1.posix.normalize(path_1.posix.join(sourceDir, specifier));
+        return joined;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Classify a resolved path into a layer. Tries the bare path first, then
+ * common extensions, then path-with-/index appended. This handles the most
+ * common ESM/CJS resolution shapes without doing real filesystem lookups
+ * (which would be non-deterministic and slow).
+ */
+function classifyPathToLayer(resolvedPath, layers) {
+    const candidates = [
+        resolvedPath,
+        `${resolvedPath}.ts`,
+        `${resolvedPath}.tsx`,
+        `${resolvedPath}.js`,
+        `${resolvedPath}.jsx`,
+        `${resolvedPath}.py`,
+        `${resolvedPath}/index.ts`,
+        `${resolvedPath}/index.js`,
+        `${resolvedPath}/__init__.py`,
+    ];
+    for (const layer of layers) {
+        for (const candidate of candidates) {
+            if ((0, glob_match_1.firstMatchingGlob)(layer.glob, candidate)) {
+                return layer.id;
+            }
+        }
+    }
+    return null;
+}
+// ── Internal — sorting ───────────────────────────────────────────────────────
+function sortByFileLineSpecifier(a, b) {
+    if (a.file !== b.file)
+        return a.file < b.file ? -1 : 1;
+    if (a.line !== b.line)
+        return a.line - b.line;
+    if (a.specifier !== b.specifier)
+        return a.specifier < b.specifier ? -1 : 1;
+    return 0;
+}
+// ── Empty result ─────────────────────────────────────────────────────────────
+function emptyReport(fingerprint) {
+    return {
+        schemaVersion: 1,
+        driftDetected: false,
+        violations: [],
+        classifiedFiles: [],
+        unclassifiedFiles: [],
+        externalImports: [],
+        summary: {
+            filesAnalyzed: 0,
+            importsAnalyzed: 0,
+            violationCount: 0,
+            blockCount: 0,
+            warnCount: 0,
+            layersTouched: [],
+            forbiddenEdgesViolated: [],
+        },
+        contractFingerprint: fingerprint,
+        intelligenceClassification: 'deterministic',
+    };
+}
+//# sourceMappingURL=drift-detector.js.map

package/dist/governance/intent/drift-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drift-detector.js","sourceRoot":"","sources":["../../../src/governance/intent/drift-detector.ts"],"names":[],"mappings":"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"}

package/dist/governance/intent/glob-match.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Bounded deterministic glob matcher for intent governance.
+ *
+ * Why a local implementation:
+ *   - Zero filesystem access. Pattern-vs-string only.
+ *   - Replay determinism: identical (pattern, path) → identical boolean, forever.
+ *   - No dependency on `glob`, `minimatch`, or `micromatch` (which have version drift,
+ *     locale-sensitive behaviour, and historical bugs around `**` semantics).
+ *
+ * Supported syntax (intentionally minimal):
+ *   `**`  — match any number of path segments (including zero)
+ *   `*`   — match any sequence of chars except `/`
+ *   `?`   — match exactly one char except `/`
+ *   Literal characters match themselves. No brace expansion, no character classes,
+ *   no negation (negation is expressed at the contract layer, not the glob layer).
+ *
+ * Paths are normalised to forward slashes before matching. Leading `./` is stripped.
+ *
+ * Intelligence classification: DETERMINISTIC.
+ */
+/** Normalise a file path for matching: forward slashes, no leading `./`. */
+export declare function normalizePathForGlob(path: string): string;
+/**
+ * Compile a glob into a deterministic RegExp.
+ * The regex is anchored: it matches the full path, not a substring.
+ */
+export declare function compileGlob(pattern: string): RegExp;
+/**
+ * Test whether `path` matches `pattern`. Both are normalised before comparison.
+ * Pure function — same inputs always produce the same output.
+ */
+export declare function matchesGlob(pattern: string, path: string): boolean;
+/**
+ * Return true if `path` matches any pattern in `patterns`.
+ * Useful for layer membership checks where multiple globs are OR'd together.
+ */
+export declare function matchesAnyGlob(patterns: ReadonlyArray<string>, path: string): boolean;
+/**
+ * Return the first pattern in `patterns` that matches `path`, or `null` if none match.
+ * Order matters — caller is responsible for arranging patterns in priority order.
+ */
+export declare function firstMatchingGlob(patterns: ReadonlyArray<string>, path: string): string | null;
+//# sourceMappingURL=glob-match.d.ts.map

package/dist/governance/intent/glob-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-match.d.ts","sourceRoot":"","sources":["../../../src/governance/intent/glob-match.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAwCnD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAElE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMrF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAC/B,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,IAAI,CAMf"}

package/dist/governance/intent/glob-match.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Bounded deterministic glob matcher for intent governance.
+ *
+ * Why a local implementation:
+ *   - Zero filesystem access. Pattern-vs-string only.
+ *   - Replay determinism: identical (pattern, path) → identical boolean, forever.
+ *   - No dependency on `glob`, `minimatch`, or `micromatch` (which have version drift,
+ *     locale-sensitive behaviour, and historical bugs around `**` semantics).
+ *
+ * Supported syntax (intentionally minimal):
+ *   `**`  — match any number of path segments (including zero)
+ *   `*`   — match any sequence of chars except `/`
+ *   `?`   — match exactly one char except `/`
+ *   Literal characters match themselves. No brace expansion, no character classes,
+ *   no negation (negation is expressed at the contract layer, not the glob layer).
+ *
+ * Paths are normalised to forward slashes before matching. Leading `./` is stripped.
+ *
+ * Intelligence classification: DETERMINISTIC.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePathForGlob = normalizePathForGlob;
+exports.compileGlob = compileGlob;
+exports.matchesGlob = matchesGlob;
+exports.matchesAnyGlob = matchesAnyGlob;
+exports.firstMatchingGlob = firstMatchingGlob;
+const ESCAPE_RE = /[.+^${}()|[\]\\]/g;
+/** Normalise a file path for matching: forward slashes, no leading `./`. */
+function normalizePathForGlob(path) {
+    let p = path.replace(/\\/g, '/');
+    if (p.startsWith('./'))
+        p = p.slice(2);
+    return p;
+}
+/**
+ * Compile a glob into a deterministic RegExp.
+ * The regex is anchored: it matches the full path, not a substring.
+ */
+function compileGlob(pattern) {
+    const normalized = normalizePathForGlob(pattern);
+    let i = 0;
+    let out = '^';
+    while (i < normalized.length) {
+        const c = normalized[i];
+        // `**` — any number of segments (zero or more)
+        if (c === '*' && normalized[i + 1] === '*') {
+            // `**/` or `/**` collapses to "anything (including empty)" without trailing slash artifacts
+            if (normalized[i + 2] === '/') {
+                out += '(?:.*/)?';
+                i += 3;
+                continue;
+            }
+            out += '.*';
+            i += 2;
+            continue;
+        }
+        // `*` — any chars except `/`
+        if (c === '*') {
+            out += '[^/]*';
+            i += 1;
+            continue;
+        }
+        // `?` — one char except `/`
+        if (c === '?') {
+            out += '[^/]';
+            i += 1;
+            continue;
+        }
+        // literal
+        out += c.replace(ESCAPE_RE, '\\$&');
+        i += 1;
+    }
+    out += '$';
+    return new RegExp(out);
+}
+/**
+ * Test whether `path` matches `pattern`. Both are normalised before comparison.
+ * Pure function — same inputs always produce the same output.
+ */
+function matchesGlob(pattern, path) {
+    return compileGlob(pattern).test(normalizePathForGlob(path));
+}
+/**
+ * Return true if `path` matches any pattern in `patterns`.
+ * Useful for layer membership checks where multiple globs are OR'd together.
+ */
+function matchesAnyGlob(patterns, path) {
+    const normalised = normalizePathForGlob(path);
+    for (const pattern of patterns) {
+        if (compileGlob(pattern).test(normalised))
+            return true;
+    }
+    return false;
+}
+/**
+ * Return the first pattern in `patterns` that matches `path`, or `null` if none match.
+ * Order matters — caller is responsible for arranging patterns in priority order.
+ */
+function firstMatchingGlob(patterns, path) {
+    const normalised = normalizePathForGlob(path);
+    for (const pattern of patterns) {
+        if (compileGlob(pattern).test(normalised))
+            return pattern;
+    }
+    return null;
+}
+//# sourceMappingURL=glob-match.js.map

package/dist/governance/intent/glob-match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-match.js","sourceRoot":"","sources":["../../../src/governance/intent/glob-match.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;AAKH,oDAIC;AAMD,kCAwCC;AAMD,kCAEC;AAMD,wCAMC;AAMD,8CASC;AAxFD,MAAM,SAAS,GAAG,mBAAmB,CAAC;AAEtC,4EAA4E;AAC5E,SAAgB,oBAAoB,CAAC,IAAY;IAC/C,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACjC,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACvC,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;GAGG;AACH,SAAgB,WAAW,CAAC,OAAe;IACzC,MAAM,UAAU,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACjD,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,GAAG,GAAG,GAAG,CAAC;IACd,OAAO,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAExB,+CAA+C;QAC/C,IAAI,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YAC3C,4FAA4F;YAC5F,IAAI,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;gBAC9B,GAAG,IAAI,UAAU,CAAC;gBAClB,CAAC,IAAI,CAAC,CAAC;gBACP,SAAS;YACX,CAAC;YACD,GAAG,IAAI,IAAI,CAAC;YACZ,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACX,CAAC;QAED,6BAA6B;QAC7B,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YACd,GAAG,IAAI,OAAO,CAAC;YACf,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACX,CAAC;QAED,4BAA4B;QAC5B,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YACd,GAAG,IAAI,MAAM,CAAC;YACd,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACX,CAAC;QAED,UAAU;QACV,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACpC,CAAC,IAAI,CAAC,CAAC;IACT,CAAC;IACD,GAAG,IAAI,GAAG,CAAC;IACX,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;;GAGG;AACH,SAAgB,WAAW,CAAC,OAAe,EAAE,IAAY;IACvD,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,SAAgB,cAAc,CAAC,QAA+B,EAAE,IAAY;IAC1E,MAAM,UAAU,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC9C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,OAAO,IAAI,CAAC;IACzD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAgB,iBAAiB,CAC/B,QAA+B,EAC/B,IAAY;IAEZ,MAAM,UAAU,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC9C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,OAAO,OAAO,CAAC;IAC5D,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/governance/intent/import-graph.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Import Graph Extraction — bounded, deterministic, diff-scoped.
+ *
+ * Extracts import edges (file → imported specifier) from the **added** lines of
+ * a parsed diff. This is intentionally narrow:
+ *
+ *   - **Bounded scope**: only files in the diff, only added lines.
+ *     We never re-parse the entire project. This keeps drift detection fast
+ *     and proportional to the size of the change, not the size of the codebase.
+ *
+ *   - **Regex-based parsing**: not AST. For governance signals on imports
+ *     specifically, ECMAScript `import`/`require` statements are unambiguous
+ *     enough that regex matches what an AST would catch. False positives in
+ *     pathological edge cases (e.g. import strings inside template literals)
+ *     are acceptable — drift findings are advisory in Phase 1.
+ *
+ *   - **TS/JS/Python first**: matchers for ESM imports, CJS requires, and
+ *     Python `from X import` / `import X`. Other languages can be added as
+ *     additional matcher entries.
+ *
+ * Intelligence classification: DETERMINISTIC.
+ */
+import type { DiffFile } from '@neurcode-ai/diff-parser';
+/**
+ * One extracted import edge: a file imports a specifier on a specific line.
+ *
+ * `specifier` is the literal string from the source (e.g. `"./auth/login"`,
+ * `"@neurcode-ai/diff-parser"`, `"sqlalchemy.orm"`). Resolution to a layer is
+ * the next phase's job — this module produces raw, faithful edges.
+ */
+export interface ImportEdge {
+    /** Source file (project-relative). */
+    fromFile: string;
+    /** Raw imported specifier. */
+    specifier: string;
+    /** 1-based line number (best-effort, from the diff hunk). */
+    line: number;
+    /** Original matched text — used in drift reports as evidence. */
+    rawStatement: string;
+    /** Which matcher produced this edge. Aids debuggability. */
+    matcherId: string;
+}
+/**
+ * Extract all import edges from the added lines of the diff.
+ *
+ * Pure function — same `diffFiles` produces the same `ImportEdge[]` every time,
+ * with deterministic ordering (files in input order; lines in hunk order;
+ * matchers in declaration order).
+ */
+export declare function extractImportEdgesFromDiff(diffFiles: DiffFile[]): ImportEdge[];
+/**
+ * Group edges by source file. Used by the drift detector to iterate
+ * file-by-file when classifying layers.
+ */
+export declare function groupImportEdgesByFile(edges: ImportEdge[]): Map<string, ImportEdge[]>;
+//# sourceMappingURL=import-graph.d.ts.map

package/dist/governance/intent/import-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-graph.d.ts","sourceRoot":"","sources":["../../../src/governance/intent/import-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;CACnB;AAoDD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,UAAU,EAAE,CAsB9E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAWrF"}

package/dist/governance/intent/import-graph.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Import Graph Extraction — bounded, deterministic, diff-scoped.
+ *
+ * Extracts import edges (file → imported specifier) from the **added** lines of
+ * a parsed diff. This is intentionally narrow:
+ *
+ *   - **Bounded scope**: only files in the diff, only added lines.
+ *     We never re-parse the entire project. This keeps drift detection fast
+ *     and proportional to the size of the change, not the size of the codebase.
+ *
+ *   - **Regex-based parsing**: not AST. For governance signals on imports
+ *     specifically, ECMAScript `import`/`require` statements are unambiguous
+ *     enough that regex matches what an AST would catch. False positives in
+ *     pathological edge cases (e.g. import strings inside template literals)
+ *     are acceptable — drift findings are advisory in Phase 1.
+ *
+ *   - **TS/JS/Python first**: matchers for ESM imports, CJS requires, and
+ *     Python `from X import` / `import X`. Other languages can be added as
+ *     additional matcher entries.
+ *
+ * Intelligence classification: DETERMINISTIC.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImportEdgesFromDiff = extractImportEdgesFromDiff;
+exports.groupImportEdgesByFile = groupImportEdgesByFile;
+/**
+ * The matcher set. Order is irrelevant — every matcher is run against every
+ * added line. A single line could in theory match multiple matchers; in
+ * practice the regexes are disjoint.
+ */
+const IMPORT_MATCHERS = [
+    // ESM: `import X from "..."`, `import "..."`, `import { X } from "..."`
+    {
+        id: 'esm-import-from',
+        pattern: /\bimport\s+[^'"]*?from\s+['"]([^'"]+)['"]/,
+    },
+    {
+        id: 'esm-import-side-effect',
+        pattern: /\bimport\s+['"]([^'"]+)['"]/,
+    },
+    // ESM: dynamic `import("...")`
+    {
+        id: 'esm-import-dynamic',
+        pattern: /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/,
+    },
+    // CJS: `require("...")`
+    {
+        id: 'cjs-require',
+        pattern: /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/,
+    },
+    // Python: `from foo.bar import baz`
+    {
+        id: 'py-from-import',
+        pattern: /^\s*from\s+([\w.]+)\s+import\s+/,
+    },
+    // Python: `import foo.bar`
+    {
+        id: 'py-import',
+        pattern: /^\s*import\s+([\w.]+)(?:\s+as\s+\w+)?\s*$/,
+    },
+];
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Extract all import edges from the added lines of the diff.
+ *
+ * Pure function — same `diffFiles` produces the same `ImportEdge[]` every time,
+ * with deterministic ordering (files in input order; lines in hunk order;
+ * matchers in declaration order).
+ */
+function extractImportEdgesFromDiff(diffFiles) {
+    const edges = [];
+    for (const file of diffFiles) {
+        if (!file.hunks)
+            continue;
+        for (const hunk of file.hunks) {
+            if (!hunk.lines)
+                continue;
+            // newStart is the line number of the first line in the new file
+            let currentLine = hunk.newStart ?? 1;
+            for (const line of hunk.lines) {
+                if (line.type === 'added') {
+                    collectMatchesFromLine(file.path, line.content ?? '', currentLine, edges);
+                    currentLine += 1;
+                }
+                else if (line.type === 'context') {
+                    currentLine += 1;
+                }
+                // 'removed' lines do not advance newStart counter
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Group edges by source file. Used by the drift detector to iterate
+ * file-by-file when classifying layers.
+ */
+function groupImportEdgesByFile(edges) {
+    const grouped = new Map();
+    for (const edge of edges) {
+        const existing = grouped.get(edge.fromFile);
+        if (existing) {
+            existing.push(edge);
+        }
+        else {
+            grouped.set(edge.fromFile, [edge]);
+        }
+    }
+    return grouped;
+}
+// ── Internal ─────────────────────────────────────────────────────────────────
+function collectMatchesFromLine(fromFile, rawContent, line, out) {
+    // Diff hunks may include a leading "+" in some representations; the
+    // @neurcode-ai/diff-parser strips it but we guard defensively.
+    const content = rawContent.startsWith('+') ? rawContent.slice(1) : rawContent;
+    for (const matcher of IMPORT_MATCHERS) {
+        const match = matcher.pattern.exec(content);
+        if (!match)
+            continue;
+        const specifier = match[1];
+        if (!specifier)
+            continue;
+        out.push({
+            fromFile,
+            specifier,
+            line,
+            rawStatement: content.trim(),
+            matcherId: matcher.id,
+        });
+    }
+}
+//# sourceMappingURL=import-graph.js.map

package/dist/governance/intent/import-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-graph.js","sourceRoot":"","sources":["../../../src/governance/intent/import-graph.ts"],"names":[],"mappings":"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"}