@optave/codegraph 3.1.5 → 3.3.0

package/dist/features/batch.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Run a query command against multiple targets, returning all results.
+ *
+ * @param {string} command - One of the keys in BATCH_COMMANDS
+ * @param {string[]} targets - List of target names/paths
+ * @param {string} [customDbPath] - Path to graph.db
+ * @param {object} [opts] - Shared options passed to every invocation
+ * @returns {{ command: string, total: number, succeeded: number, failed: number, results: object[] }}
+ */
+export function batchData(command: string, targets: string[], customDbPath?: string, opts?: object): {
+    command: string;
+    total: number;
+    succeeded: number;
+    failed: number;
+    results: object[];
+};
+/**
+ * Expand comma-separated positional args into individual entries.
+ * `['a,b', 'c']` → `['a', 'b', 'c']`.
+ * Trims whitespace, filters empties. Passes through object items unchanged.
+ *
+ * @param {Array<string|object>} targets
+ * @returns {Array<string|object>}
+ */
+export function splitTargets(targets: Array<string | object>): Array<string | object>;
+/**
+ * Multi-command batch orchestration — run different commands per target.
+ *
+ * @param {Array<{command: string, target: string, opts?: object}>} items
+ * @param {string} [customDbPath]
+ * @param {object} [sharedOpts] - Default opts merged under per-item opts
+ * @returns {{ mode: 'multi', total: number, succeeded: number, failed: number, results: object[] }}
+ */
+export function multiBatchData(items: Array<{
+    command: string;
+    target: string;
+    opts?: object;
+}>, customDbPath?: string, sharedOpts?: object): {
+    mode: "multi";
+    total: number;
+    succeeded: number;
+    failed: number;
+    results: object[];
+};
+/**
+ * Map of supported batch commands → their data function + first-arg semantics.
+ * `sig` describes how the target string is passed to the data function:
+ *   - 'name'   → dataFn(target, dbPath, opts)
+ *   - 'target' → dataFn(target, dbPath, opts)
+ *   - 'file'   → dataFn(target, dbPath, opts)
+ *   - 'dbOnly' → dataFn(dbPath, { ...opts, target })  (target goes into opts)
+ */
+export const BATCH_COMMANDS: {
+    'fn-impact': {
+        fn: typeof fnImpactData;
+        sig: string;
+    };
+    context: {
+        fn: typeof contextData;
+        sig: string;
+    };
+    explain: {
+        fn: typeof explainData;
+        sig: string;
+    };
+    where: {
+        fn: typeof whereData;
+        sig: string;
+    };
+    query: {
+        fn: typeof fnDepsData;
+        sig: string;
+    };
+    impact: {
+        fn: typeof impactAnalysisData;
+        sig: string;
+    };
+    deps: {
+        fn: typeof fileDepsData;
+        sig: string;
+    };
+    exports: {
+        fn: typeof exportsData;
+        sig: string;
+    };
+    flow: {
+        fn: typeof flowData;
+        sig: string;
+    };
+    dataflow: {
+        fn: typeof dataflowData;
+        sig: string;
+    };
+    complexity: {
+        fn: typeof complexityData;
+        sig: string;
+    };
+};
+import { fnImpactData } from '../domain/queries.js';
+import { contextData } from '../domain/queries.js';
+import { explainData } from '../domain/queries.js';
+import { whereData } from '../domain/queries.js';
+import { fnDepsData } from '../domain/queries.js';
+import { impactAnalysisData } from '../domain/queries.js';
+import { fileDepsData } from '../domain/queries.js';
+import { exportsData } from '../domain/queries.js';
+import { flowData } from './flow.js';
+import { dataflowData } from './dataflow.js';
+import { complexityData } from './complexity.js';
+//# sourceMappingURL=batch.d.ts.map

package/dist/features/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/features/batch.js"],"names":[],"mappings":"AA4CA;;;;;;;;GAQG;AACH,mCANW,MAAM,WACN,MAAM,EAAE,iBACR,MAAM,SACN,MAAM,GACJ;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAiCpG;AAED;;;;;;;GAOG;AACH,sCAHW,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,GAClB,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAehC;AAED;;;;;;;GAOG;AACH,sCALW,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC,iBACvD,MAAM,eACN,MAAM,GACJ;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAwClG;AArID;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYE;6BA1BK,sBAAsB;4BAAtB,sBAAsB;4BAAtB,sBAAsB;0BAAtB,sBAAsB;2BAAtB,sBAAsB;mCAAtB,sBAAsB;6BAAtB,sBAAsB;4BAAtB,sBAAsB;yBAIJ,WAAW;6BADP,eAAe;+BADb,iBAAiB"}

package/dist/features/batch.js

@@ -0,0 +1,138 @@
+/**
+ * Batch query orchestration — run the same query command against multiple targets
+ * and return all results in a single JSON payload.
+ *
+ * Designed for multi-agent swarms that need to dispatch 20+ queries in one call.
+ */
+import { contextData, explainData, exportsData, fileDepsData, fnDepsData, fnImpactData, impactAnalysisData, whereData, } from '../domain/queries.js';
+import { ConfigError } from '../shared/errors.js';
+import { complexityData } from './complexity.js';
+import { dataflowData } from './dataflow.js';
+import { flowData } from './flow.js';
+/**
+ * Map of supported batch commands → their data function + first-arg semantics.
+ * `sig` describes how the target string is passed to the data function:
+ *   - 'name'   → dataFn(target, dbPath, opts)
+ *   - 'target' → dataFn(target, dbPath, opts)
+ *   - 'file'   → dataFn(target, dbPath, opts)
+ *   - 'dbOnly' → dataFn(dbPath, { ...opts, target })  (target goes into opts)
+ */
+export const BATCH_COMMANDS = {
+    'fn-impact': { fn: fnImpactData, sig: 'name' },
+    context: { fn: contextData, sig: 'name' },
+    explain: { fn: explainData, sig: 'target' },
+    where: { fn: whereData, sig: 'target' },
+    query: { fn: fnDepsData, sig: 'name' },
+    impact: { fn: impactAnalysisData, sig: 'file' },
+    deps: { fn: fileDepsData, sig: 'file' },
+    exports: { fn: exportsData, sig: 'file' },
+    flow: { fn: flowData, sig: 'name' },
+    dataflow: { fn: dataflowData, sig: 'name' },
+    complexity: { fn: complexityData, sig: 'dbOnly' },
+};
+/**
+ * Run a query command against multiple targets, returning all results.
+ *
+ * @param {string} command - One of the keys in BATCH_COMMANDS
+ * @param {string[]} targets - List of target names/paths
+ * @param {string} [customDbPath] - Path to graph.db
+ * @param {object} [opts] - Shared options passed to every invocation
+ * @returns {{ command: string, total: number, succeeded: number, failed: number, results: object[] }}
+ */
+export function batchData(command, targets, customDbPath, opts = {}) {
+    const entry = BATCH_COMMANDS[command];
+    if (!entry) {
+        throw new ConfigError(`Unknown batch command "${command}". Valid commands: ${Object.keys(BATCH_COMMANDS).join(', ')}`);
+    }
+    const results = [];
+    let succeeded = 0;
+    let failed = 0;
+    for (const target of targets) {
+        try {
+            let data;
+            if (entry.sig === 'dbOnly') {
+                // complexityData(dbPath, { ...opts, target })
+                data = entry.fn(customDbPath, { ...opts, target });
+            }
+            else {
+                // All other: dataFn(target, dbPath, opts)
+                data = entry.fn(target, customDbPath, opts);
+            }
+            results.push({ target, ok: true, data });
+            succeeded++;
+        }
+        catch (err) {
+            results.push({ target, ok: false, error: err.message });
+            failed++;
+        }
+    }
+    return { command, total: targets.length, succeeded, failed, results };
+}
+/**
+ * Expand comma-separated positional args into individual entries.
+ * `['a,b', 'c']` → `['a', 'b', 'c']`.
+ * Trims whitespace, filters empties. Passes through object items unchanged.
+ *
+ * @param {Array<string|object>} targets
+ * @returns {Array<string|object>}
+ */
+export function splitTargets(targets) {
+    const out = [];
+    for (const item of targets) {
+        if (typeof item !== 'string') {
+            out.push(item);
+            continue;
+        }
+        for (const part of item.split(',')) {
+            const trimmed = part.trim();
+            if (trimmed)
+                out.push(trimmed);
+        }
+    }
+    return out;
+}
+/**
+ * Multi-command batch orchestration — run different commands per target.
+ *
+ * @param {Array<{command: string, target: string, opts?: object}>} items
+ * @param {string} [customDbPath]
+ * @param {object} [sharedOpts] - Default opts merged under per-item opts
+ * @returns {{ mode: 'multi', total: number, succeeded: number, failed: number, results: object[] }}
+ */
+export function multiBatchData(items, customDbPath, sharedOpts = {}) {
+    const results = [];
+    let succeeded = 0;
+    let failed = 0;
+    for (const item of items) {
+        const { command, target, opts: itemOpts } = item;
+        const entry = BATCH_COMMANDS[command];
+        if (!entry) {
+            results.push({
+                command,
+                target,
+                ok: false,
+                error: `Unknown batch command "${command}". Valid commands: ${Object.keys(BATCH_COMMANDS).join(', ')}`,
+            });
+            failed++;
+            continue;
+        }
+        const merged = { ...sharedOpts, ...itemOpts };
+        try {
+            let data;
+            if (entry.sig === 'dbOnly') {
+                data = entry.fn(customDbPath, { ...merged, target });
+            }
+            else {
+                data = entry.fn(target, customDbPath, merged);
+            }
+            results.push({ command, target, ok: true, data });
+            succeeded++;
+        }
+        catch (err) {
+            results.push({ command, target, ok: false, error: err.message });
+            failed++;
+        }
+    }
+    return { mode: 'multi', total: items.length, succeeded, failed, results };
+}
+//# sourceMappingURL=batch.js.map

package/dist/features/batch.js.map

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

package/dist/features/boundaries.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Convert a simple glob pattern to a RegExp.
+ * Supports `**` (any path segment), `*` (non-slash), `?` (single non-slash char).
+ * @param {string} pattern
+ * @returns {RegExp}
+ */
+export function globToRegex(pattern: string): RegExp;
+/**
+ * Parse module definitions into a Map of name → { regex, pattern, layer? }.
+ * Supports string shorthand and object form.
+ * @param {object} boundaryConfig - The `manifesto.boundaries` config object
+ * @returns {Map<string, { regex: RegExp, pattern: string, layer?: string }>}
+ */
+export function resolveModules(boundaryConfig: object): Map<string, {
+    regex: RegExp;
+    pattern: string;
+    layer?: string;
+}>;
+/**
+ * Validate a boundary configuration object.
+ * @param {object} config - The `manifesto.boundaries` config
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateBoundaryConfig(config: object): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Evaluate boundary rules against the dependency graph.
+ *
+ * @param {object} db - Open SQLite database (readonly)
+ * @param {object} boundaryConfig - The `manifesto.boundaries` config
+ * @param {object} [opts]
+ * @param {string[]} [opts.scopeFiles] - Only check edges from these files (diff-impact mode)
+ * @param {boolean} [opts.noTests] - Exclude test files
+ * @returns {{ violations: object[], violationCount: number }}
+ */
+export function evaluateBoundaries(db: object, boundaryConfig: object, opts?: {
+    scopeFiles?: string[] | undefined;
+    noTests?: boolean | undefined;
+}): {
+    violations: object[];
+    violationCount: number;
+};
+export namespace PRESETS {
+    namespace hexagonal {
+        let layers: string[];
+        let description: string;
+    }
+    namespace layered {
+        let layers_1: string[];
+        export { layers_1 as layers };
+        let description_1: string;
+        export { description_1 as description };
+    }
+    namespace clean {
+        let layers_2: string[];
+        export { layers_2 as layers };
+        let description_2: string;
+        export { description_2 as description };
+    }
+    namespace onion {
+        let layers_3: string[];
+        export { layers_3 as layers };
+        let description_3: string;
+        export { description_3 as description };
+    }
+}
+//# sourceMappingURL=boundaries.d.ts.map

package/dist/features/boundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundaries.d.ts","sourceRoot":"","sources":["../../src/features/boundaries.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,qCAHW,MAAM,GACJ,MAAM,CA6BlB;AA8BD;;;;;GAKG;AACH,+CAHW,MAAM,GACJ,GAAG,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAmB3E;AAuGD;;;;GAIG;AACH,+CAHW,MAAM,GACJ;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAahD;AAwDD;;;;;;;;;GASG;AACH,uCAPW,MAAM,kBACN,MAAM,SAEd;IAAwB,UAAU;IACX,OAAO;CAC9B,GAAU;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAsF5D"}

package/dist/features/boundaries.js

@@ -0,0 +1,344 @@
+import { debug } from '../infrastructure/logger.js';
+import { isTestFile } from '../infrastructure/test-filter.js';
+// ─── Glob-to-Regex ───────────────────────────────────────────────────
+/**
+ * Convert a simple glob pattern to a RegExp.
+ * Supports `**` (any path segment), `*` (non-slash), `?` (single non-slash char).
+ * @param {string} pattern
+ * @returns {RegExp}
+ */
+export function globToRegex(pattern) {
+    let re = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === '*' && pattern[i + 1] === '*') {
+            // ** matches any number of path segments
+            re += '.*';
+            i += 2;
+            // Skip trailing slash after **
+            if (pattern[i] === '/')
+                i++;
+        }
+        else if (ch === '*') {
+            // * matches non-slash characters
+            re += '[^/]*';
+            i++;
+        }
+        else if (ch === '?') {
+            re += '[^/]';
+            i++;
+        }
+        else if (/[.+^${}()|[\]\\]/.test(ch)) {
+            re += `\\${ch}`;
+            i++;
+        }
+        else {
+            re += ch;
+            i++;
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+// ─── Presets ─────────────────────────────────────────────────────────
+/**
+ * Built-in preset definitions.
+ * Each defines layers ordered from innermost (most protected) to outermost.
+ * Inner layers cannot import from outer layers.
+ */
+export const PRESETS = {
+    hexagonal: {
+        layers: ['domain', 'application', 'adapters', 'infrastructure'],
+        description: 'Inner layers cannot import outer layers',
+    },
+    layered: {
+        layers: ['data', 'business', 'presentation'],
+        description: 'Inward-only dependency direction',
+    },
+    clean: {
+        layers: ['entities', 'usecases', 'interfaces', 'frameworks'],
+        description: 'Inward-only dependency direction',
+    },
+    onion: {
+        layers: ['domain-model', 'domain-services', 'application', 'infrastructure'],
+        description: 'Inward-only dependency direction',
+    },
+};
+// ─── Module Resolution ───────────────────────────────────────────────
+/**
+ * Parse module definitions into a Map of name → { regex, pattern, layer? }.
+ * Supports string shorthand and object form.
+ * @param {object} boundaryConfig - The `manifesto.boundaries` config object
+ * @returns {Map<string, { regex: RegExp, pattern: string, layer?: string }>}
+ */
+export function resolveModules(boundaryConfig) {
+    const modules = new Map();
+    const defs = boundaryConfig?.modules;
+    if (!defs || typeof defs !== 'object')
+        return modules;
+    for (const [name, value] of Object.entries(defs)) {
+        if (typeof value === 'string') {
+            modules.set(name, { regex: globToRegex(value), pattern: value });
+        }
+        else if (value && typeof value === 'object' && value.match) {
+            modules.set(name, {
+                regex: globToRegex(value.match),
+                pattern: value.match,
+                ...(value.layer ? { layer: value.layer } : {}),
+            });
+        }
+    }
+    return modules;
+}
+// ─── Validation ──────────────────────────────────────────────────────
+/**
+ * Validate the `modules` section of a boundary config.
+ * @param {object} modules
+ * @param {string[]} errors - Mutated: push any validation errors
+ */
+function validateModules(modules, errors) {
+    if (!modules || typeof modules !== 'object' || Object.keys(modules).length === 0) {
+        errors.push('boundaries.modules must be a non-empty object');
+        return;
+    }
+    for (const [name, value] of Object.entries(modules)) {
+        if (typeof value === 'string')
+            continue;
+        if (value && typeof value === 'object' && typeof value.match === 'string')
+            continue;
+        errors.push(`boundaries.modules.${name}: must be a glob string or { match: "<glob>" }`);
+    }
+}
+/**
+ * Validate the `preset` field of a boundary config.
+ * @param {string|null|undefined} preset
+ * @param {string[]} errors - Mutated: push any validation errors
+ */
+function validatePreset(preset, errors) {
+    if (preset == null)
+        return;
+    if (typeof preset !== 'string' || !PRESETS[preset]) {
+        errors.push(`boundaries.preset: must be one of ${Object.keys(PRESETS).join(', ')} (got "${preset}")`);
+    }
+}
+/**
+ * Validate a single rule's target list (`notTo` or `onlyTo`).
+ * @param {*} list - The target list value
+ * @param {string} field - "notTo" or "onlyTo"
+ * @param {number} idx - Rule index for error messages
+ * @param {Set<string>} moduleNames
+ * @param {string[]} errors - Mutated
+ */
+function validateTargetList(list, field, idx, moduleNames, errors) {
+    if (!Array.isArray(list)) {
+        errors.push(`boundaries.rules[${idx}]: "${field}" must be an array`);
+        return;
+    }
+    for (const target of list) {
+        if (!moduleNames.has(target)) {
+            errors.push(`boundaries.rules[${idx}]: "${field}" references unknown module "${target}"`);
+        }
+    }
+}
+/**
+ * Validate the `rules` array of a boundary config.
+ * @param {Array} rules
+ * @param {object|undefined} modules - The modules config (for cross-referencing names)
+ * @param {string[]} errors - Mutated
+ */
+function validateRules(rules, modules, errors) {
+    if (!rules)
+        return;
+    if (!Array.isArray(rules)) {
+        errors.push('boundaries.rules must be an array');
+        return;
+    }
+    const moduleNames = modules ? new Set(Object.keys(modules)) : new Set();
+    for (let i = 0; i < rules.length; i++) {
+        const rule = rules[i];
+        if (!rule.from) {
+            errors.push(`boundaries.rules[${i}]: missing "from" field`);
+        }
+        else if (!moduleNames.has(rule.from)) {
+            errors.push(`boundaries.rules[${i}]: "from" references unknown module "${rule.from}"`);
+        }
+        if (rule.notTo && rule.onlyTo) {
+            errors.push(`boundaries.rules[${i}]: cannot have both "notTo" and "onlyTo"`);
+        }
+        if (!rule.notTo && !rule.onlyTo) {
+            errors.push(`boundaries.rules[${i}]: must have either "notTo" or "onlyTo"`);
+        }
+        if (rule.notTo)
+            validateTargetList(rule.notTo, 'notTo', i, moduleNames, errors);
+        if (rule.onlyTo)
+            validateTargetList(rule.onlyTo, 'onlyTo', i, moduleNames, errors);
+    }
+}
+/**
+ * Validate that module layer assignments match preset layers.
+ * @param {object} config
+ * @param {string[]} errors - Mutated
+ */
+function validateLayerAssignments(config, errors) {
+    if (!config.preset || !PRESETS[config.preset] || !config.modules)
+        return;
+    const presetLayers = new Set(PRESETS[config.preset].layers);
+    for (const [name, value] of Object.entries(config.modules)) {
+        if (typeof value === 'object' && value.layer && !presetLayers.has(value.layer)) {
+            errors.push(`boundaries.modules.${name}: layer "${value.layer}" not in preset "${config.preset}" (valid: ${[...presetLayers].join(', ')})`);
+        }
+    }
+}
+/**
+ * Validate a boundary configuration object.
+ * @param {object} config - The `manifesto.boundaries` config
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateBoundaryConfig(config) {
+    if (!config || typeof config !== 'object') {
+        return { valid: false, errors: ['boundaries config must be an object'] };
+    }
+    const errors = [];
+    validateModules(config.modules, errors);
+    validatePreset(config.preset, errors);
+    validateRules(config.rules, config.modules, errors);
+    validateLayerAssignments(config, errors);
+    return { valid: errors.length === 0, errors };
+}
+// ─── Preset Rule Generation ─────────────────────────────────────────
+/**
+ * Generate notTo rules from preset layer assignments.
+ * Inner layers cannot import from outer layers.
+ */
+function generatePresetRules(modules, presetName) {
+    const preset = PRESETS[presetName];
+    if (!preset)
+        return [];
+    const layers = preset.layers;
+    const layerIndex = new Map(layers.map((l, i) => [l, i]));
+    // Group modules by layer
+    const modulesByLayer = new Map();
+    for (const [name, mod] of modules) {
+        if (mod.layer && layerIndex.has(mod.layer)) {
+            if (!modulesByLayer.has(mod.layer))
+                modulesByLayer.set(mod.layer, []);
+            modulesByLayer.get(mod.layer).push(name);
+        }
+    }
+    const rules = [];
+    // For each layer, forbid imports to any outer (higher-index) layer
+    for (const [layer, modNames] of modulesByLayer) {
+        const idx = layerIndex.get(layer);
+        const outerModules = [];
+        for (const [otherLayer, otherModNames] of modulesByLayer) {
+            if (layerIndex.get(otherLayer) > idx) {
+                outerModules.push(...otherModNames);
+            }
+        }
+        if (outerModules.length > 0) {
+            for (const from of modNames) {
+                rules.push({ from, notTo: outerModules });
+            }
+        }
+    }
+    return rules;
+}
+// ─── Evaluation ──────────────────────────────────────────────────────
+/**
+ * Classify a file path into a module name. Returns the first matching module or null.
+ */
+function classifyFile(filePath, modules) {
+    for (const [name, mod] of modules) {
+        if (mod.regex.test(filePath))
+            return name;
+    }
+    return null;
+}
+/**
+ * Evaluate boundary rules against the dependency graph.
+ *
+ * @param {object} db - Open SQLite database (readonly)
+ * @param {object} boundaryConfig - The `manifesto.boundaries` config
+ * @param {object} [opts]
+ * @param {string[]} [opts.scopeFiles] - Only check edges from these files (diff-impact mode)
+ * @param {boolean} [opts.noTests] - Exclude test files
+ * @returns {{ violations: object[], violationCount: number }}
+ */
+export function evaluateBoundaries(db, boundaryConfig, opts = {}) {
+    if (!boundaryConfig)
+        return { violations: [], violationCount: 0 };
+    const { valid, errors } = validateBoundaryConfig(boundaryConfig);
+    if (!valid) {
+        debug('boundary config validation failed: %s', errors.join('; '));
+        return { violations: [], violationCount: 0 };
+    }
+    const modules = resolveModules(boundaryConfig);
+    if (modules.size === 0)
+        return { violations: [], violationCount: 0 };
+    // Merge user rules with preset-generated rules
+    let allRules = [];
+    if (boundaryConfig.preset) {
+        allRules = generatePresetRules(modules, boundaryConfig.preset);
+    }
+    if (boundaryConfig.rules && Array.isArray(boundaryConfig.rules)) {
+        allRules = allRules.concat(boundaryConfig.rules);
+    }
+    if (allRules.length === 0)
+        return { violations: [], violationCount: 0 };
+    // Query file-level import edges
+    let edges;
+    try {
+        edges = db
+            .prepare(`SELECT DISTINCT n1.file AS source, n2.file AS target
+         FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         JOIN nodes n2 ON e.target_id = n2.id
+         WHERE n1.file != n2.file AND e.kind IN ('imports', 'imports-type')`)
+            .all();
+    }
+    catch (err) {
+        debug('boundary edge query failed: %s', err.message);
+        return { violations: [], violationCount: 0 };
+    }
+    // Filter by scope and tests
+    if (opts.noTests) {
+        edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
+    }
+    if (opts.scopeFiles) {
+        const scope = new Set(opts.scopeFiles);
+        edges = edges.filter((e) => scope.has(e.source));
+    }
+    // Check each edge against rules
+    const violations = [];
+    for (const edge of edges) {
+        const fromModule = classifyFile(edge.source, modules);
+        const toModule = classifyFile(edge.target, modules);
+        // Skip edges where source or target is not in any module
+        if (!fromModule || !toModule)
+            continue;
+        for (const rule of allRules) {
+            if (rule.from !== fromModule)
+                continue;
+            let isViolation = false;
+            if (rule.notTo?.includes(toModule)) {
+                isViolation = true;
+            }
+            else if (rule.onlyTo && !rule.onlyTo.includes(toModule)) {
+                isViolation = true;
+            }
+            if (isViolation) {
+                violations.push({
+                    rule: 'boundaries',
+                    name: `${fromModule} -> ${toModule}`,
+                    file: edge.source,
+                    targetFile: edge.target,
+                    message: rule.message || `${fromModule} must not depend on ${toModule}`,
+                    value: 1,
+                    threshold: 0,
+                });
+            }
+        }
+    }
+    return { violations, violationCount: violations.length };
+}
+//# sourceMappingURL=boundaries.js.map