@neurcode-ai/cli 0.10.0 → 0.12.0

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

package/dist/governance/intent/intent-contract.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Intent Contract — declarative architectural intent.
+ *
+ * Canonical path: `.neurcode/intent.json` (project-relative).
+ *
+ * The contract is the *human-authored* form. The loader validates it and
+ * converts it into a typed `IntentGraph` for the drift engine.
+ *
+ * Canonical form is JSON for two reasons:
+ *   1. Replay determinism — JSON parsing is locale-free and YAML has historical
+ *      ambiguities ("yes" → bool, leading zeros, multiline). The contract is a
+ *      replay-relevant artifact, so we lock it to JSON.
+ *   2. Zero extra dependencies — adding a YAML parser to the CLI is unjustified
+ *      for a configuration file the team writes once.
+ *
+ * Contract example:
+ *
+ *   {
+ *     "schemaVersion": 1,
+ *     "layers": [
+ *       { "id": "controller", "glob": ["src/commands/**", "src/handlers/**"] },
+ *       { "id": "service",    "glob": ["src/services/**"] },
+ *       { "id": "persistence","glob": ["src/repositories/**", "src/db/**"] }
+ *     ],
+ *     "allowedEdges": [
+ *       { "from": "controller", "to": "service" },
+ *       { "from": "service",    "to": "persistence" }
+ *     ],
+ *     "forbiddenEdges": [
+ *       { "from": "controller", "to": "persistence",
+ *         "reason": "Controllers must access data via service layer" }
+ *     ]
+ *   }
+ *
+ * Intelligence classification: DETERMINISTIC.
+ */
+import { type IntentGraph } from './intent-graph';
+export declare const INTENT_CONTRACT_FILENAME = "intent.json";
+export declare const INTENT_CONTRACT_RELATIVE_PATH = ".neurcode/intent.json";
+export interface IntentContractLoadResult {
+    /** Absolute path the loader probed. */
+    path: string;
+    /** True if a contract file exists at `path`. */
+    exists: boolean;
+    /** Parsed graph, or `EMPTY_INTENT_GRAPH` when absent / invalid. */
+    graph: IntentGraph;
+    /** Validation errors encountered while loading. Empty array on success. */
+    errors: string[];
+    /** Soft warnings — e.g. unknown fields, zero-glob layer. */
+    warnings: string[];
+}
+/**
+ * Resolve the canonical contract path for a project. Does not check existence.
+ */
+export declare function resolveIntentContractPath(projectRoot: string, override?: string): string;
+/**
+ * Load and validate the intent contract for a project.
+ *
+ * Behaviour:
+ *   - If the file does not exist → `exists: false`, graph is empty, no errors.
+ *   - If the file is malformed JSON → `exists: true`, graph is empty, `errors`
+ *     contains the parser error.
+ *   - If the schema is wrong → `exists: true`, graph is empty, `errors` lists
+ *     every validation failure.
+ *   - On success → `exists: true`, graph is populated, errors is empty.
+ *
+ * The loader never throws. Drift detection is opt-in; an unparseable contract
+ * must not break verification.
+ */
+export declare function loadIntentContract(projectRoot: string, override?: string): IntentContractLoadResult;
+/**
+ * Parse + validate a raw contract value (already-parsed JSON) and build the graph.
+ * Exposed for tests so we don't need to touch the filesystem.
+ */
+export declare function buildIntentGraphFromRaw(raw: unknown): IntentContractLoadResult;
+//# sourceMappingURL=intent-contract.d.ts.map

package/dist/governance/intent/intent-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-contract.d.ts","sourceRoot":"","sources":["../../../src/governance/intent/intent-contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAKH,OAAO,EAIL,KAAK,WAAW,EAIjB,MAAM,gBAAgB,CAAC;AAIxB,eAAO,MAAM,wBAAwB,gBAAgB,CAAC;AACtD,eAAO,MAAM,6BAA6B,0BAA0C,CAAC;AAIrF,MAAM,WAAW,wBAAwB;IACvC,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,MAAM,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,KAAK,EAAE,WAAW,CAAC;IACnB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAID;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAKxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,wBAAwB,CA0C1B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,wBAAwB,CAE9E"}