@neurcode-ai/cli 0.10.1 → 0.14.0

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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"}

package/dist/governance/intent/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Intent-Aware Governance — public surface.
+ *
+ * Phase 1 capabilities:
+ *   - Declarative intent contract (`.neurcode/intent.json`) → typed IntentGraph
+ *   - Deterministic import-graph extraction from a diff
+ *   - Deterministic architectural drift detection (layer rules)
+ *   - Explicit intelligence-boundary classification
+ *
+ * What this module is NOT:
+ *   - A graph database
+ *   - An AI-driven architecture inferrer
+ *   - A replacement for change-contract or the intent-engine (NL coverage)
+ *
+ * See individual modules for the principles each surface adheres to.
+ */
+export { EMPTY_INTENT_GRAPH, INTENT_GRAPH_SCHEMA_VERSION, isEmptyIntentGraph, intentGraphHasEnforcement, type IntentEdge, type IntentGraph, type IntentLayer, type IntentModule, type IntentTrustBoundary, } from './intent-graph';
+export { INTENT_CONTRACT_FILENAME, INTENT_CONTRACT_RELATIVE_PATH, buildIntentGraphFromRaw, loadIntentContract, resolveIntentContractPath, type IntentContractLoadResult, } from './intent-contract';
+export { compileGlob, firstMatchingGlob, matchesAnyGlob, matchesGlob, normalizePathForGlob, } from './glob-match';
+export { extractImportEdgesFromDiff, groupImportEdgesByFile, type ImportEdge, } from './import-graph';
+export { intentGraphIsEnforceable, runDriftDetection, type ClassifiedFile, type DriftDetectorInput, type DriftReport, type DriftViolation, } from './drift-detector';
+export { activeIntelligenceClasses, getIntelligenceClassificationMap, hasNonDeterministicSurface, PHASE_1_SURFACES, type IntelligenceClass, type IntelligenceSurface, } from './intelligence-boundaries';
+//# sourceMappingURL=index.d.ts.map

package/dist/governance/intent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/governance/intent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,wBAAwB,EACxB,6BAA6B,EAC7B,uBAAuB,EACvB,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,wBAAwB,GAC9B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,0BAA0B,EAC1B,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,2BAA2B,CAAC"}

package/dist/governance/intent/index.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Intent-Aware Governance — public surface.
+ *
+ * Phase 1 capabilities:
+ *   - Declarative intent contract (`.neurcode/intent.json`) → typed IntentGraph
+ *   - Deterministic import-graph extraction from a diff
+ *   - Deterministic architectural drift detection (layer rules)
+ *   - Explicit intelligence-boundary classification
+ *
+ * What this module is NOT:
+ *   - A graph database
+ *   - An AI-driven architecture inferrer
+ *   - A replacement for change-contract or the intent-engine (NL coverage)
+ *
+ * See individual modules for the principles each surface adheres to.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHASE_1_SURFACES = exports.hasNonDeterministicSurface = exports.getIntelligenceClassificationMap = exports.activeIntelligenceClasses = exports.runDriftDetection = exports.intentGraphIsEnforceable = exports.groupImportEdgesByFile = exports.extractImportEdgesFromDiff = exports.normalizePathForGlob = exports.matchesGlob = exports.matchesAnyGlob = exports.firstMatchingGlob = exports.compileGlob = exports.resolveIntentContractPath = exports.loadIntentContract = exports.buildIntentGraphFromRaw = exports.INTENT_CONTRACT_RELATIVE_PATH = exports.INTENT_CONTRACT_FILENAME = exports.intentGraphHasEnforcement = exports.isEmptyIntentGraph = exports.INTENT_GRAPH_SCHEMA_VERSION = exports.EMPTY_INTENT_GRAPH = void 0;
+var intent_graph_1 = require("./intent-graph");
+Object.defineProperty(exports, "EMPTY_INTENT_GRAPH", { enumerable: true, get: function () { return intent_graph_1.EMPTY_INTENT_GRAPH; } });
+Object.defineProperty(exports, "INTENT_GRAPH_SCHEMA_VERSION", { enumerable: true, get: function () { return intent_graph_1.INTENT_GRAPH_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "isEmptyIntentGraph", { enumerable: true, get: function () { return intent_graph_1.isEmptyIntentGraph; } });
+Object.defineProperty(exports, "intentGraphHasEnforcement", { enumerable: true, get: function () { return intent_graph_1.intentGraphHasEnforcement; } });
+var intent_contract_1 = require("./intent-contract");
+Object.defineProperty(exports, "INTENT_CONTRACT_FILENAME", { enumerable: true, get: function () { return intent_contract_1.INTENT_CONTRACT_FILENAME; } });
+Object.defineProperty(exports, "INTENT_CONTRACT_RELATIVE_PATH", { enumerable: true, get: function () { return intent_contract_1.INTENT_CONTRACT_RELATIVE_PATH; } });
+Object.defineProperty(exports, "buildIntentGraphFromRaw", { enumerable: true, get: function () { return intent_contract_1.buildIntentGraphFromRaw; } });
+Object.defineProperty(exports, "loadIntentContract", { enumerable: true, get: function () { return intent_contract_1.loadIntentContract; } });
+Object.defineProperty(exports, "resolveIntentContractPath", { enumerable: true, get: function () { return intent_contract_1.resolveIntentContractPath; } });
+var glob_match_1 = require("./glob-match");
+Object.defineProperty(exports, "compileGlob", { enumerable: true, get: function () { return glob_match_1.compileGlob; } });
+Object.defineProperty(exports, "firstMatchingGlob", { enumerable: true, get: function () { return glob_match_1.firstMatchingGlob; } });
+Object.defineProperty(exports, "matchesAnyGlob", { enumerable: true, get: function () { return glob_match_1.matchesAnyGlob; } });
+Object.defineProperty(exports, "matchesGlob", { enumerable: true, get: function () { return glob_match_1.matchesGlob; } });
+Object.defineProperty(exports, "normalizePathForGlob", { enumerable: true, get: function () { return glob_match_1.normalizePathForGlob; } });
+var import_graph_1 = require("./import-graph");
+Object.defineProperty(exports, "extractImportEdgesFromDiff", { enumerable: true, get: function () { return import_graph_1.extractImportEdgesFromDiff; } });
+Object.defineProperty(exports, "groupImportEdgesByFile", { enumerable: true, get: function () { return import_graph_1.groupImportEdgesByFile; } });
+var drift_detector_1 = require("./drift-detector");
+Object.defineProperty(exports, "intentGraphIsEnforceable", { enumerable: true, get: function () { return drift_detector_1.intentGraphIsEnforceable; } });
+Object.defineProperty(exports, "runDriftDetection", { enumerable: true, get: function () { return drift_detector_1.runDriftDetection; } });
+var intelligence_boundaries_1 = require("./intelligence-boundaries");
+Object.defineProperty(exports, "activeIntelligenceClasses", { enumerable: true, get: function () { return intelligence_boundaries_1.activeIntelligenceClasses; } });
+Object.defineProperty(exports, "getIntelligenceClassificationMap", { enumerable: true, get: function () { return intelligence_boundaries_1.getIntelligenceClassificationMap; } });
+Object.defineProperty(exports, "hasNonDeterministicSurface", { enumerable: true, get: function () { return intelligence_boundaries_1.hasNonDeterministicSurface; } });
+Object.defineProperty(exports, "PHASE_1_SURFACES", { enumerable: true, get: function () { return intelligence_boundaries_1.PHASE_1_SURFACES; } });
+//# sourceMappingURL=index.js.map

package/dist/governance/intent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/governance/intent/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,+CAUwB;AATtB,kHAAA,kBAAkB,OAAA;AAClB,2HAAA,2BAA2B,OAAA;AAC3B,kHAAA,kBAAkB,OAAA;AAClB,yHAAA,yBAAyB,OAAA;AAQ3B,qDAO2B;AANzB,2HAAA,wBAAwB,OAAA;AACxB,gIAAA,6BAA6B,OAAA;AAC7B,0HAAA,uBAAuB,OAAA;AACvB,qHAAA,kBAAkB,OAAA;AAClB,4HAAA,yBAAyB,OAAA;AAI3B,2CAMsB;AALpB,yGAAA,WAAW,OAAA;AACX,+GAAA,iBAAiB,OAAA;AACjB,4GAAA,cAAc,OAAA;AACd,yGAAA,WAAW,OAAA;AACX,kHAAA,oBAAoB,OAAA;AAGtB,+CAIwB;AAHtB,0HAAA,0BAA0B,OAAA;AAC1B,sHAAA,sBAAsB,OAAA;AAIxB,mDAO0B;AANxB,0HAAA,wBAAwB,OAAA;AACxB,mHAAA,iBAAiB,OAAA;AAOnB,qEAOmC;AANjC,oIAAA,yBAAyB,OAAA;AACzB,2IAAA,gCAAgC,OAAA;AAChC,qIAAA,0BAA0B,OAAA;AAC1B,2HAAA,gBAAgB,OAAA"}

package/dist/governance/intent/intelligence-boundaries.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Intelligence Boundaries — explicit classification of every governance-intelligence
+ * surface in the intent module.
+ *
+ * NEURCODE'S NON-NEGOTIABLE PRINCIPLE:
+ *
+ *   Governance findings must be **explainable**, **deterministic-first**, and
+ *   **bounded**. A finding's source must be inspectable. AI augmentation, when
+ *   it exists, must be optional, advisory, and clearly labelled. Opaque AI
+ *   governance theater is BANNED.
+ *
+ * This file enumerates every function/surface in `governance/intent/*` and
+ * assigns one of four classifications:
+ *
+ *   - `deterministic`   : Same input → same output, no randomness, no I/O,
+ *                          no probabilistic models. Findings are direct
+ *                          consequences of declared rules.
+ *
+ *   - `heuristic`       : Pattern-based reasoning with bounded confidence.
+ *                          May have false positives/negatives. Used for
+ *                          fallback classification, never for blocking decisions.
+ *
+ *   - `ai_augmented`    : Uses an LLM or external model. Output is advisory-only.
+ *                          Must include the model output AND the deterministic
+ *                          findings side-by-side so reviewers can compare.
+ *
+ *   - `banned`          : Forbidden patterns. Used as a guard against accidental
+ *                          introduction of opaque AI paths.
+ *
+ * Phase 1 INVARIANT: Every surface in the intent module is `deterministic` or
+ * `banned`. There are NO heuristic or AI-augmented surfaces yet. Future phases
+ * may introduce them, but only with explicit board-review and a corresponding
+ * entry here.
+ *
+ * Testing: `intent-governance.test.ts` enforces that the classification map is
+ * complete and contains no AI-augmented entries in Phase 1.
+ */
+export type IntelligenceClass = 'deterministic' | 'heuristic' | 'ai_augmented' | 'banned';
+export interface IntelligenceSurface {
+    /** Module path + exported symbol, e.g. `governance/intent/drift-detector#runDriftDetection`. */
+    surface: string;
+    classification: IntelligenceClass;
+    /** Brief justification, shown in audit reports. */
+    rationale: string;
+}
+/**
+ * The canonical Phase 1 classification map. This is the SOURCE OF TRUTH for
+ * how every intent-module surface is classified. Tests assert that:
+ *   - No surface is `ai_augmented` in Phase 1.
+ *   - Every public export of the intent module appears here.
+ *   - No `banned` patterns are reachable from the public API.
+ */
+export declare const PHASE_1_SURFACES: IntelligenceSurface[];
+/**
+ * Returns the classification map. Use this in audit/replay payloads to record
+ * which intelligence classes were active for this verify run.
+ */
+export declare function getIntelligenceClassificationMap(): IntelligenceSurface[];
+/**
+ * Returns the unique set of classifications present in the map.
+ * Useful for assertions like "this build has no AI-augmented surfaces".
+ */
+export declare function activeIntelligenceClasses(): IntelligenceClass[];
+/**
+ * Returns true if any surface is classified as `ai_augmented` or `heuristic`.
+ * In Phase 1 this MUST return false. The CI test asserts this invariant.
+ */
+export declare function hasNonDeterministicSurface(): boolean;
+//# sourceMappingURL=intelligence-boundaries.d.ts.map

package/dist/governance/intent/intelligence-boundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-boundaries.d.ts","sourceRoot":"","sources":["../../../src/governance/intent/intelligence-boundaries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAIH,MAAM,MAAM,iBAAiB,GACzB,eAAe,GACf,WAAW,GACX,cAAc,GACd,QAAQ,CAAC;AAEb,MAAM,WAAW,mBAAmB;IAClC,gGAAgG;IAChG,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,iBAAiB,CAAC;IAClC,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;CACnB;AAID;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,mBAAmB,EAsFjD,CAAC;AAIF;;;GAGG;AACH,wBAAgB,gCAAgC,IAAI,mBAAmB,EAAE,CAGxE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,iBAAiB,EAAE,CAI/D;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAOpD"}

package/dist/governance/intent/intelligence-boundaries.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Intelligence Boundaries — explicit classification of every governance-intelligence
+ * surface in the intent module.
+ *
+ * NEURCODE'S NON-NEGOTIABLE PRINCIPLE:
+ *
+ *   Governance findings must be **explainable**, **deterministic-first**, and
+ *   **bounded**. A finding's source must be inspectable. AI augmentation, when
+ *   it exists, must be optional, advisory, and clearly labelled. Opaque AI
+ *   governance theater is BANNED.
+ *
+ * This file enumerates every function/surface in `governance/intent/*` and
+ * assigns one of four classifications:
+ *
+ *   - `deterministic`   : Same input → same output, no randomness, no I/O,
+ *                          no probabilistic models. Findings are direct
+ *                          consequences of declared rules.
+ *
+ *   - `heuristic`       : Pattern-based reasoning with bounded confidence.
+ *                          May have false positives/negatives. Used for
+ *                          fallback classification, never for blocking decisions.
+ *
+ *   - `ai_augmented`    : Uses an LLM or external model. Output is advisory-only.
+ *                          Must include the model output AND the deterministic
+ *                          findings side-by-side so reviewers can compare.
+ *
+ *   - `banned`          : Forbidden patterns. Used as a guard against accidental
+ *                          introduction of opaque AI paths.
+ *
+ * Phase 1 INVARIANT: Every surface in the intent module is `deterministic` or
+ * `banned`. There are NO heuristic or AI-augmented surfaces yet. Future phases
+ * may introduce them, but only with explicit board-review and a corresponding
+ * entry here.
+ *
+ * Testing: `intent-governance.test.ts` enforces that the classification map is
+ * complete and contains no AI-augmented entries in Phase 1.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHASE_1_SURFACES = void 0;
+exports.getIntelligenceClassificationMap = getIntelligenceClassificationMap;
+exports.activeIntelligenceClasses = activeIntelligenceClasses;
+exports.hasNonDeterministicSurface = hasNonDeterministicSurface;
+// ── Phase 1 surface map ──────────────────────────────────────────────────────
+/**
+ * The canonical Phase 1 classification map. This is the SOURCE OF TRUTH for
+ * how every intent-module surface is classified. Tests assert that:
+ *   - No surface is `ai_augmented` in Phase 1.
+ *   - Every public export of the intent module appears here.
+ *   - No `banned` patterns are reachable from the public API.
+ */
+exports.PHASE_1_SURFACES = [
+    // intent-graph.ts
+    {
+        surface: 'governance/intent/intent-graph#IntentGraph',
+        classification: 'deterministic',
+        rationale: 'Pure TypeScript type. Carries no runtime behaviour.',
+    },
+    {
+        surface: 'governance/intent/intent-graph#isEmptyIntentGraph',
+        classification: 'deterministic',
+        rationale: 'Pure predicate over graph shape.',
+    },
+    {
+        surface: 'governance/intent/intent-graph#intentGraphHasEnforcement',
+        classification: 'deterministic',
+        rationale: 'Pure predicate over graph shape.',
+    },
+    // intent-contract.ts
+    {
+        surface: 'governance/intent/intent-contract#loadIntentContract',
+        classification: 'deterministic',
+        rationale: 'Reads a JSON file from disk. Same file bytes → same graph. ' +
+            'No network, no clock, no randomness. Filesystem read is the only I/O.',
+    },
+    {
+        surface: 'governance/intent/intent-contract#buildIntentGraphFromRaw',
+        classification: 'deterministic',
+        rationale: 'Pure parser/validator. No I/O.',
+    },
+    {
+        surface: 'governance/intent/intent-contract#resolveIntentContractPath',
+        classification: 'deterministic',
+        rationale: 'Path arithmetic only.',
+    },
+    // glob-match.ts
+    {
+        surface: 'governance/intent/glob-match#compileGlob',
+        classification: 'deterministic',
+        rationale: 'Pure pattern compilation to RegExp.',
+    },
+    {
+        surface: 'governance/intent/glob-match#matchesGlob',
+        classification: 'deterministic',
+        rationale: 'Pure regex test.',
+    },
+    {
+        surface: 'governance/intent/glob-match#matchesAnyGlob',
+        classification: 'deterministic',
+        rationale: 'Pure regex test over an array.',
+    },
+    {
+        surface: 'governance/intent/glob-match#firstMatchingGlob',
+        classification: 'deterministic',
+        rationale: 'Pure regex test; returns first matching pattern.',
+    },
+    // import-graph.ts
+    {
+        surface: 'governance/intent/import-graph#extractImportEdgesFromDiff',
+        classification: 'deterministic',
+        rationale: 'Regex-based extraction from the added lines of a parsed diff. Output is a ' +
+            'pure function of the input diff. No project-level AST, no filesystem access.',
+    },
+    {
+        surface: 'governance/intent/import-graph#groupImportEdgesByFile',
+        classification: 'deterministic',
+        rationale: 'Pure grouping of edges by `fromFile`.',
+    },
+    // drift-detector.ts
+    {
+        surface: 'governance/intent/drift-detector#runDriftDetection',
+        classification: 'deterministic',
+        rationale: 'Pure function of (graph, diffFiles). Same inputs → same DriftReport, ' +
+            'including identical violation ordering (sorted by file/line/specifier).',
+    },
+    {
+        surface: 'governance/intent/drift-detector#intentGraphIsEnforceable',
+        classification: 'deterministic',
+        rationale: 'Pure predicate.',
+    },
+];
+// ── Public predicates ────────────────────────────────────────────────────────
+/**
+ * Returns the classification map. Use this in audit/replay payloads to record
+ * which intelligence classes were active for this verify run.
+ */
+function getIntelligenceClassificationMap() {
+    // Return a shallow copy so callers cannot mutate the canonical map.
+    return exports.PHASE_1_SURFACES.slice();
+}
+/**
+ * Returns the unique set of classifications present in the map.
+ * Useful for assertions like "this build has no AI-augmented surfaces".
+ */
+function activeIntelligenceClasses() {
+    const set = new Set();
+    for (const s of exports.PHASE_1_SURFACES)
+        set.add(s.classification);
+    return [...set].sort();
+}
+/**
+ * Returns true if any surface is classified as `ai_augmented` or `heuristic`.
+ * In Phase 1 this MUST return false. The CI test asserts this invariant.
+ */
+function hasNonDeterministicSurface() {
+    for (const s of exports.PHASE_1_SURFACES) {
+        if (s.classification === 'ai_augmented' || s.classification === 'heuristic') {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=intelligence-boundaries.js.map

package/dist/governance/intent/intelligence-boundaries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence-boundaries.js","sourceRoot":"","sources":["../../../src/governance/intent/intelligence-boundaries.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;;;AAyHH,4EAGC;AAMD,8DAIC;AAMD,gEAOC;AAjID,gFAAgF;AAEhF;;;;;;GAMG;AACU,QAAA,gBAAgB,GAA0B;IACrD,kBAAkB;IAClB;QACE,OAAO,EAAE,4CAA4C;QACrD,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,qDAAqD;KACjE;IACD;QACE,OAAO,EAAE,mDAAmD;QAC5D,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,kCAAkC;KAC9C;IACD;QACE,OAAO,EAAE,0DAA0D;QACnE,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,kCAAkC;KAC9C;IAED,qBAAqB;IACrB;QACE,OAAO,EAAE,sDAAsD;QAC/D,cAAc,EAAE,eAAe;QAC/B,SAAS,EACP,6DAA6D;YAC7D,uEAAuE;KAC1E;IACD;QACE,OAAO,EAAE,2DAA2D;QACpE,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,gCAAgC;KAC5C;IACD;QACE,OAAO,EAAE,6DAA6D;QACtE,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,uBAAuB;KACnC;IAED,gBAAgB;IAChB;QACE,OAAO,EAAE,0CAA0C;QACnD,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,qCAAqC;KACjD;IACD;QACE,OAAO,EAAE,0CAA0C;QACnD,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,kBAAkB;KAC9B;IACD;QACE,OAAO,EAAE,6CAA6C;QACtD,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,gCAAgC;KAC5C;IACD;QACE,OAAO,EAAE,gDAAgD;QACzD,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,kDAAkD;KAC9D;IAED,kBAAkB;IAClB;QACE,OAAO,EAAE,2DAA2D;QACpE,cAAc,EAAE,eAAe;QAC/B,SAAS,EACP,4EAA4E;YAC5E,8EAA8E;KACjF;IACD;QACE,OAAO,EAAE,uDAAuD;QAChE,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,uCAAuC;KACnD;IAED,oBAAoB;IACpB;QACE,OAAO,EAAE,oDAAoD;QAC7D,cAAc,EAAE,eAAe;QAC/B,SAAS,EACP,uEAAuE;YACvE,yEAAyE;KAC5E;IACD;QACE,OAAO,EAAE,2DAA2D;QACpE,cAAc,EAAE,eAAe;QAC/B,SAAS,EAAE,iBAAiB;KAC7B;CACF,CAAC;AAEF,gFAAgF;AAEhF;;;GAGG;AACH,SAAgB,gCAAgC;IAC9C,oEAAoE;IACpE,OAAO,wBAAgB,CAAC,KAAK,EAAE,CAAC;AAClC,CAAC;AAED;;;GAGG;AACH,SAAgB,yBAAyB;IACvC,MAAM,GAAG,GAAG,IAAI,GAAG,EAAqB,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,wBAAgB;QAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;IAC5D,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AACzB,CAAC;AAED;;;GAGG;AACH,SAAgB,0BAA0B;IACxC,KAAK,MAAM,CAAC,IAAI,wBAAgB,EAAE,CAAC;QACjC,IAAI,CAAC,CAAC,cAAc,KAAK,cAAc,IAAI,CAAC,CAAC,cAAc,KAAK,WAAW,EAAE,CAAC;YAC5E,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}