@eddacraft/anvil-core 0.1.0

package/dist/architecture/edge-detector.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Edge detector for architecture boundary analysis
+ *
+ * Extracts import edges from source files and compares them against
+ * the baseline to identify NEW vs existing violations.
+ *
+ * **Limitations**:
+ * - Import extraction is line-based regex. Multi-line imports split across
+ *   lines (e.g., imports with many named exports) may not be detected.
+ * - For accurate detection, use TypeScript compiler API in production.
+ */
+import type { DependencyEdge, BaselineViolation } from './types.js';
+/**
+ * Import edge extracted from source code
+ */
+export interface ImportEdge {
+    /** Source file path (relative to workspace) */
+    from: string;
+    /** Target file path (resolved, relative to workspace) - used for baseline comparison */
+    to: string;
+    /** Line number of import statement (1-based) */
+    line: number;
+    /** Type of import */
+    type: 'import' | 'require' | 'dynamic';
+    /** Raw import specifier as written in code */
+    specifier: string;
+}
+/**
+ * Result of baseline comparison
+ */
+export interface BaselineComparison {
+    /** Edges that exist in baseline (existing violations) */
+    existing: ImportEdge[];
+    /** Edges NOT in baseline (new violations) */
+    new: ImportEdge[];
+    /** Edges in baseline but not in current (fixed violations) */
+    fixed: BaselineViolation[];
+}
+/**
+ * Options for import extraction
+ */
+export interface ExtractOptions {
+    /** Include dynamic imports (default: true) */
+    includeDynamic?: boolean;
+    /** Include require() calls (default: true) */
+    includeRequire?: boolean;
+}
+/**
+ * Resolve an import specifier to a workspace-relative path
+ *
+ * Relative imports (./foo, ../bar) are resolved against the importing file.
+ * Absolute/package imports are returned as-is (external dependencies).
+ */
+export declare function resolveImportPath(specifier: string, fromFile: string): string;
+/**
+ * Create a stable fingerprint for an edge
+ *
+ * Used for deduplication and baseline comparison.
+ * Format: SHA-256 hash of "from:to:line"
+ */
+export declare function createEdgeFingerprint(from: string, to: string, line: number): string;
+/**
+ * Create a fingerprint for an ImportEdge
+ */
+export declare function fingerprintEdge(edge: ImportEdge): string;
+/**
+ * Extract all import edges from a source file
+ *
+ * @param filePath - Path to source file (relative to workspace)
+ * @param workspaceRoot - Workspace root directory
+ * @param options - Extraction options
+ * @returns Array of import edges found in the file
+ */
+export declare function extractImports(filePath: string, workspaceRoot: string, options?: ExtractOptions): ImportEdge[];
+/**
+ * Extract imports from multiple files
+ *
+ * @param filePaths - Array of file paths (relative to workspace)
+ * @param workspaceRoot - Workspace root directory
+ * @param options - Extraction options
+ * @returns Array of all import edges
+ */
+export declare function extractImportsFromFiles(filePaths: string[], workspaceRoot: string, options?: ExtractOptions): ImportEdge[];
+/**
+ * Compare current edges against baseline violations
+ *
+ * @param currentEdges - Edges extracted from current code
+ * @param baselineViolations - Violations recorded in baseline
+ * @returns Comparison result with new, existing, and fixed violations
+ */
+export declare function compareToBaseline(currentEdges: ImportEdge[], baselineViolations: BaselineViolation[]): BaselineComparison;
+/**
+ * Convert ImportEdge to DependencyEdge
+ *
+ * @param edge - Import edge to convert
+ * @param fromLayer - Source layer (null if unknown)
+ * @param toLayer - Target layer (null if unknown)
+ * @returns DependencyEdge for use in violation tracking
+ */
+export declare function toDependencyEdge(edge: ImportEdge, fromLayer?: string | null, toLayer?: string | null): DependencyEdge;
+/**
+ * Deduplicate edges by fingerprint
+ *
+ * @param edges - Array of edges (may contain duplicates)
+ * @returns Deduplicated array
+ */
+export declare function deduplicateEdges(edges: ImportEdge[]): ImportEdge[];
+/**
+ * Filter edges to only include those crossing layer boundaries
+ *
+ * @param edges - All import edges
+ * @param getLayer - Function to determine layer for a file path
+ * @returns Edges that cross layer boundaries
+ */
+export declare function filterCrossLayerEdges(edges: ImportEdge[], getLayer: (filePath: string) => string | null): ImportEdge[];
+//# sourceMappingURL=edge-detector.d.ts.map

package/dist/architecture/edge-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-detector.d.ts","sourceRoot":"","sources":["../../src/architecture/edge-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAOpE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,wFAAwF;IACxF,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;IACvC,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,6CAA6C;IAC7C,GAAG,EAAE,UAAU,EAAE,CAAC;IAClB,8DAA8D;IAC9D,KAAK,EAAE,iBAAiB,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,8CAA8C;IAC9C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,8CAA8C;IAC9C,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAOD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAO7E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGpF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAExD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,cAAmB,GAC3B,UAAU,EAAE,CA8Ed;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EAAE,EACnB,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,cAAmB,GAC3B,UAAU,EAAE,CASd;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,UAAU,EAAE,EAC1B,kBAAkB,EAAE,iBAAiB,EAAE,GACtC,kBAAkB,CAuBpB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,UAAU,EAChB,SAAS,GAAE,MAAM,GAAG,IAAW,EAC/B,OAAO,GAAE,MAAM,GAAG,IAAW,GAC5B,cAAc,CAShB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAalE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EAAE,EACnB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAC5C,UAAU,EAAE,CAQd"}

package/dist/architecture/edge-detector.js

@@ -0,0 +1,229 @@
+/**
+ * Edge detector for architecture boundary analysis
+ *
+ * Extracts import edges from source files and compares them against
+ * the baseline to identify NEW vs existing violations.
+ *
+ * **Limitations**:
+ * - Import extraction is line-based regex. Multi-line imports split across
+ *   lines (e.g., imports with many named exports) may not be detected.
+ * - For accurate detection, use TypeScript compiler API in production.
+ */
+import { readFileSync } from 'node:fs';
+import { join, dirname, normalize, extname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { createViolationId } from './types.js';
+import { extractHtmlEdges, extractCssEdges } from './edge-detector-web.js';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('edge-detector');
+const IMPORT_FROM_REGEX = /import\s+(?:[\w\s{},*]+\s+from\s+)?['"]([^'"]+)['"]/g;
+const DYNAMIC_IMPORT_REGEX = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const REQUIRE_REGEX = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const EXPORT_FROM_REGEX = /export\s+(?:[\w\s{},*]+\s+from\s+)['"]([^'"]+)['"]/g;
+/**
+ * Resolve an import specifier to a workspace-relative path
+ *
+ * Relative imports (./foo, ../bar) are resolved against the importing file.
+ * Absolute/package imports are returned as-is (external dependencies).
+ */
+export function resolveImportPath(specifier, fromFile) {
+    if (specifier.startsWith('.')) {
+        const fromDir = dirname(fromFile);
+        const resolved = normalize(join(fromDir, specifier));
+        return resolved.replace(/\\/g, '/');
+    }
+    return specifier;
+}
+/**
+ * Create a stable fingerprint for an edge
+ *
+ * Used for deduplication and baseline comparison.
+ * Format: SHA-256 hash of "from:to:line"
+ */
+export function createEdgeFingerprint(from, to, line) {
+    const input = `${from}:${to}:${line}`;
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+/**
+ * Create a fingerprint for an ImportEdge
+ */
+export function fingerprintEdge(edge) {
+    return createEdgeFingerprint(edge.from, edge.to, edge.line);
+}
+/**
+ * Extract all import edges from a source file
+ *
+ * @param filePath - Path to source file (relative to workspace)
+ * @param workspaceRoot - Workspace root directory
+ * @param options - Extraction options
+ * @returns Array of import edges found in the file
+ */
+export function extractImports(filePath, workspaceRoot, options = {}) {
+    const { includeDynamic = true, includeRequire = true } = options;
+    const edges = [];
+    let content;
+    try {
+        const fullPath = workspaceRoot ? join(workspaceRoot, filePath) : filePath;
+        content = readFileSync(fullPath, 'utf-8');
+    }
+    catch (err) {
+        debug('failed to read file for import extraction:', err);
+        return edges;
+    }
+    // Delegate to HTML/CSS extractors based on file extension
+    const ext = extname(filePath).toLowerCase();
+    if (ext === '.html' || ext === '.htm') {
+        return extractHtmlEdges(filePath, content);
+    }
+    if (ext === '.css' || ext === '.scss' || ext === '.less') {
+        return extractCssEdges(filePath, content);
+    }
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+        for (const match of line.matchAll(IMPORT_FROM_REGEX)) {
+            const specifier = match[1];
+            edges.push({
+                from: filePath,
+                to: resolveImportPath(specifier, filePath),
+                line: lineNumber,
+                type: 'import',
+                specifier,
+            });
+        }
+        for (const match of line.matchAll(EXPORT_FROM_REGEX)) {
+            const specifier = match[1];
+            edges.push({
+                from: filePath,
+                to: resolveImportPath(specifier, filePath),
+                line: lineNumber,
+                type: 'import',
+                specifier,
+            });
+        }
+        if (includeDynamic) {
+            for (const match of line.matchAll(DYNAMIC_IMPORT_REGEX)) {
+                const specifier = match[1];
+                edges.push({
+                    from: filePath,
+                    to: resolveImportPath(specifier, filePath),
+                    line: lineNumber,
+                    type: 'dynamic',
+                    specifier,
+                });
+            }
+        }
+        if (includeRequire) {
+            for (const match of line.matchAll(REQUIRE_REGEX)) {
+                const specifier = match[1];
+                edges.push({
+                    from: filePath,
+                    to: resolveImportPath(specifier, filePath),
+                    line: lineNumber,
+                    type: 'require',
+                    specifier,
+                });
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Extract imports from multiple files
+ *
+ * @param filePaths - Array of file paths (relative to workspace)
+ * @param workspaceRoot - Workspace root directory
+ * @param options - Extraction options
+ * @returns Array of all import edges
+ */
+export function extractImportsFromFiles(filePaths, workspaceRoot, options = {}) {
+    const allEdges = [];
+    for (const filePath of filePaths) {
+        const edges = extractImports(filePath, workspaceRoot, options);
+        allEdges.push(...edges);
+    }
+    return allEdges;
+}
+function edgeToViolationId(edge) {
+    return createViolationId(edge.from, edge.to, edge.line);
+}
+/**
+ * Compare current edges against baseline violations
+ *
+ * @param currentEdges - Edges extracted from current code
+ * @param baselineViolations - Violations recorded in baseline
+ * @returns Comparison result with new, existing, and fixed violations
+ */
+export function compareToBaseline(currentEdges, baselineViolations) {
+    const baselineIds = new Set(baselineViolations.map((v) => v.id));
+    const currentIds = new Set(currentEdges.map((e) => edgeToViolationId(e)));
+    const existingEdges = [];
+    const newEdges = [];
+    for (const edge of currentEdges) {
+        const violationId = edgeToViolationId(edge);
+        if (baselineIds.has(violationId)) {
+            existingEdges.push(edge);
+        }
+        else {
+            newEdges.push(edge);
+        }
+    }
+    const fixedViolations = baselineViolations.filter((v) => !currentIds.has(v.id));
+    return {
+        existing: existingEdges,
+        new: newEdges,
+        fixed: fixedViolations,
+    };
+}
+/**
+ * Convert ImportEdge to DependencyEdge
+ *
+ * @param edge - Import edge to convert
+ * @param fromLayer - Source layer (null if unknown)
+ * @param toLayer - Target layer (null if unknown)
+ * @returns DependencyEdge for use in violation tracking
+ */
+export function toDependencyEdge(edge, fromLayer = null, toLayer = null) {
+    return {
+        from: edge.from,
+        to: edge.to,
+        from_layer: fromLayer,
+        to_layer: toLayer,
+        line: edge.line,
+        type: edge.type,
+    };
+}
+/**
+ * Deduplicate edges by fingerprint
+ *
+ * @param edges - Array of edges (may contain duplicates)
+ * @returns Deduplicated array
+ */
+export function deduplicateEdges(edges) {
+    const seen = new Set();
+    const unique = [];
+    for (const edge of edges) {
+        const fingerprint = fingerprintEdge(edge);
+        if (!seen.has(fingerprint)) {
+            seen.add(fingerprint);
+            unique.push(edge);
+        }
+    }
+    return unique;
+}
+/**
+ * Filter edges to only include those crossing layer boundaries
+ *
+ * @param edges - All import edges
+ * @param getLayer - Function to determine layer for a file path
+ * @returns Edges that cross layer boundaries
+ */
+export function filterCrossLayerEdges(edges, getLayer) {
+    return edges.filter((edge) => {
+        const fromLayer = getLayer(edge.from);
+        const toLayer = getLayer(edge.to);
+        // Only include if both have layers and they're different
+        return fromLayer !== null && toLayer !== null && fromLayer !== toLayer;
+    });
+}

package/dist/architecture/entry-detector.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Entry point detection heuristics
+ *
+ * Detects application entry points from file patterns and exports.
+ */
+import type { EntryPoint } from './types.js';
+/**
+ * Entry point detector
+ */
+export declare class EntryPointDetector {
+    private workspaceRoot;
+    constructor(workspaceRoot: string);
+    /**
+     * Detect entry point type for a file
+     *
+     * Detection priority:
+     * 1. package.json bin entries (highest - explicit CLI declaration)
+     * 2. File name matches (specific file names like main.ts, cli.ts)
+     * 3. Directory matches (files in specific directories like routes/, workers/)
+     * 4. package.json main/exports (fallback for package entries)
+     */
+    detectEntryPoint(filePath: string): EntryPoint | null;
+    /**
+     * Check if file is a bin entry in package.json
+     */
+    private checkPackageJsonBin;
+    /**
+     * Check if file is referenced in package.json main or exports
+     */
+    private checkPackageJsonMainExports;
+    /**
+     * Detect all entry points from a list of files
+     */
+    detectEntryPoints(filePaths: string[]): EntryPoint[];
+    /**
+     * Filter to only non-test entry points
+     */
+    filterNonTestEntryPoints(entryPoints: EntryPoint[]): EntryPoint[];
+}
+/**
+ * Create an entry point detector
+ */
+export declare function createEntryPointDetector(workspaceRoot: string): EntryPointDetector;
+//# sourceMappingURL=entry-detector.d.ts.map

package/dist/architecture/entry-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-detector.d.ts","sourceRoot":"","sources":["../../src/architecture/entry-detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAuC,MAAM,YAAY,CAAC;AA8ElF;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,aAAa,CAAS;gBAElB,aAAa,EAAE,MAAM;IAIjC;;;;;;;;OAQG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAuDrD;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAgC3B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAiEnC;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,UAAU,EAAE;IAgCpD;;OAEG;IACH,wBAAwB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE;CAGlE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,MAAM,GAAG,kBAAkB,CAElF"}

package/dist/architecture/entry-detector.js

@@ -0,0 +1,263 @@
+/**
+ * Entry point detection heuristics
+ *
+ * Detects application entry points from file patterns and exports.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join, basename, dirname } from 'node:path';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('entry-detector');
+/**
+ * Default entry point patterns
+ *
+ * Order matters: more specific patterns (application, cli, worker) come before
+ * generic ones (package). File name matches take priority over directory matches.
+ */
+const ENTRY_POINT_PATTERNS = [
+    // Tests (check first - test files should always be identified as tests)
+    {
+        type: 'test',
+        filePatterns: [/\.(test|spec)\.(ts|js)$/, /^test\.(ts|js)$/],
+        directoryPatterns: [/^__tests__$/, /^tests?$/, /^spec$/],
+        confidence: 'high',
+    },
+    // Application entries (specific file names)
+    {
+        type: 'application',
+        filePatterns: [
+            /^main\.(ts|js|mjs|cjs)$/,
+            /^app\.(ts|js|mjs|cjs)$/,
+            /^server\.(ts|js|mjs|cjs)$/,
+            /^start\.(ts|js|mjs|cjs)$/,
+        ],
+        directoryPatterns: [/^app$/, /^server$/], // Removed /^src$/ - too generic
+        confidence: 'high',
+    },
+    // CLI commands (specific file names and directories)
+    {
+        type: 'cli',
+        filePatterns: [/^cli\.(ts|js)$/, /^bin\.(ts|js)$/, /^command\.(ts|js)$/],
+        directoryPatterns: [/^cli$/, /^bin$/, /^commands$/],
+        confidence: 'high',
+    },
+    // Workers (specific file names and directories)
+    {
+        type: 'worker',
+        filePatterns: [/^worker\.(ts|js)$/, /^job\.(ts|js)$/, /^consumer\.(ts|js)$/],
+        directoryPatterns: [/^workers$/, /^jobs$/, /^consumers$/, /^queues$/],
+        confidence: 'high',
+    },
+    // HTTP handlers (specific directories)
+    {
+        type: 'http',
+        filePatterns: [/^routes\.(ts|js)$/, /^router\.(ts|js)$/],
+        directoryPatterns: [/^routes$/, /^controllers$/, /^handlers$/],
+        confidence: 'high',
+    },
+    // API handlers (specific directories)
+    {
+        type: 'api',
+        filePatterns: [/^api\.(ts|js)$/, /^handler\.(ts|js)$/],
+        directoryPatterns: [/^api$/, /^endpoints$/],
+        confidence: 'medium',
+    },
+    // Package entries (generic - check last)
+    {
+        type: 'package',
+        filePatterns: [/^index\.(ts|js|mjs|cjs)$/],
+        directoryPatterns: [], // Removed /^src$/ - too generic, causes false positives
+        confidence: 'high',
+    },
+];
+/**
+ * Entry point detector
+ */
+export class EntryPointDetector {
+    workspaceRoot;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+    }
+    /**
+     * Detect entry point type for a file
+     *
+     * Detection priority:
+     * 1. package.json bin entries (highest - explicit CLI declaration)
+     * 2. File name matches (specific file names like main.ts, cli.ts)
+     * 3. Directory matches (files in specific directories like routes/, workers/)
+     * 4. package.json main/exports (fallback for package entries)
+     */
+    detectEntryPoint(filePath) {
+        const fileName = basename(filePath);
+        const relativePath = filePath.startsWith(this.workspaceRoot)
+            ? filePath.slice(this.workspaceRoot.length + 1)
+            : filePath;
+        // Get all directory segments for matching (e.g., src/api/v1 -> ['src', 'api', 'v1'])
+        const pathSegments = dirname(relativePath).split(/[/\\]/).filter(Boolean);
+        // First: check package.json bin entries (explicit CLI declaration takes priority)
+        const binEntry = this.checkPackageJsonBin(relativePath);
+        if (binEntry) {
+            return binEntry;
+        }
+        // Second: check file name patterns (highest priority for pattern matching)
+        for (const pattern of ENTRY_POINT_PATTERNS) {
+            const fileMatch = pattern.filePatterns.some((p) => p.test(fileName));
+            if (fileMatch) {
+                const dirMatch = pathSegments.some((segment) => pattern.directoryPatterns.some((p) => p.test(segment)));
+                return {
+                    path: relativePath,
+                    type: pattern.type,
+                    confidence: fileMatch && dirMatch ? 'high' : pattern.confidence,
+                };
+            }
+        }
+        // Third: check directory patterns (any segment in path)
+        for (const pattern of ENTRY_POINT_PATTERNS) {
+            const dirMatch = pathSegments.some((segment) => pattern.directoryPatterns.some((p) => p.test(segment)));
+            if (dirMatch) {
+                return {
+                    path: relativePath,
+                    type: pattern.type,
+                    confidence: pattern.confidence,
+                };
+            }
+        }
+        // Fourth: check package.json main/exports (fallback)
+        const pkgEntry = this.checkPackageJsonMainExports(relativePath);
+        if (pkgEntry) {
+            return pkgEntry;
+        }
+        return null;
+    }
+    /**
+     * Check if file is a bin entry in package.json
+     */
+    checkPackageJsonBin(filePath) {
+        const pkgPath = join(this.workspaceRoot, 'package.json');
+        if (!existsSync(pkgPath)) {
+            return null;
+        }
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            const normalisedPath = filePath.replace(/\\/g, '/');
+            if (pkg.bin) {
+                const binEntries = typeof pkg.bin === 'string' ? { [pkg.name]: pkg.bin } : pkg.bin;
+                for (const binPath of Object.values(binEntries)) {
+                    const normalisedBin = binPath.replace(/^\.\//, '');
+                    if (normalisedPath === normalisedBin || normalisedPath.endsWith(normalisedBin)) {
+                        return {
+                            path: filePath,
+                            type: 'cli',
+                            confidence: 'high',
+                        };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            debug('failed to parse package.json bin entries', err);
+        }
+        return null;
+    }
+    /**
+     * Check if file is referenced in package.json main or exports
+     */
+    checkPackageJsonMainExports(filePath) {
+        const pkgPath = join(this.workspaceRoot, 'package.json');
+        if (!existsSync(pkgPath)) {
+            return null;
+        }
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            const normalisedPath = filePath.replace(/\\/g, '/');
+            // Check main entry
+            if (pkg.main) {
+                const mainPath = pkg.main.replace(/^\.\//, '');
+                if (normalisedPath === mainPath || normalisedPath.endsWith(mainPath)) {
+                    return {
+                        path: filePath,
+                        type: 'package',
+                        confidence: 'high',
+                    };
+                }
+            }
+            // Check exports (depth-limited to prevent abuse via deeply nested exports)
+            if (pkg.exports) {
+                const MAX_EXPORTS_DEPTH = 10;
+                const checkExports = (exports, prefix = '', depth = 0) => {
+                    if (depth >= MAX_EXPORTS_DEPTH)
+                        return null;
+                    for (const [key, value] of Object.entries(exports)) {
+                        if (typeof value === 'string') {
+                            const exportPath = value.replace(/^\.\//, '');
+                            if (normalisedPath === exportPath || normalisedPath.endsWith(exportPath)) {
+                                return {
+                                    path: filePath,
+                                    type: 'package',
+                                    confidence: 'high',
+                                    exports: [prefix + key],
+                                };
+                            }
+                        }
+                        else if (typeof value === 'object' && value !== null) {
+                            const result = checkExports(value, prefix + key + '/', depth + 1);
+                            if (result)
+                                return result;
+                        }
+                    }
+                    return null;
+                };
+                const exportEntry = checkExports(pkg.exports);
+                if (exportEntry)
+                    return exportEntry;
+            }
+        }
+        catch (err) {
+            debug('failed to parse package.json main/exports', err);
+        }
+        return null;
+    }
+    /**
+     * Detect all entry points from a list of files
+     */
+    detectEntryPoints(filePaths) {
+        const entryPoints = [];
+        const seen = new Set();
+        for (const filePath of filePaths) {
+            const entry = this.detectEntryPoint(filePath);
+            if (entry && !seen.has(entry.path)) {
+                seen.add(entry.path);
+                entryPoints.push(entry);
+            }
+        }
+        // Sort by confidence and type
+        return entryPoints.sort((a, b) => {
+            const confOrder = { high: 0, medium: 1, low: 2 };
+            const confDiff = confOrder[a.confidence] - confOrder[b.confidence];
+            if (confDiff !== 0)
+                return confDiff;
+            const typeOrder = {
+                package: 0,
+                application: 1,
+                http: 2,
+                api: 3,
+                cli: 4,
+                worker: 5,
+                test: 6,
+                unknown: 7,
+            };
+            return typeOrder[a.type] - typeOrder[b.type];
+        });
+    }
+    /**
+     * Filter to only non-test entry points
+     */
+    filterNonTestEntryPoints(entryPoints) {
+        return entryPoints.filter((e) => e.type !== 'test');
+    }
+}
+/**
+ * Create an entry point detector
+ */
+export function createEntryPointDetector(workspaceRoot) {
+    return new EntryPointDetector(workspaceRoot);
+}

package/dist/architecture/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Architecture analysis module
+ *
+ * Provides architecture baseline management, layer detection,
+ * entry point detection, and boundary violation analysis.
+ */
+export { EntryPointTypeSchema, type EntryPointType, DetectionConfidenceSchema, type DetectionConfidence, EntryPointSchema, type EntryPoint, StandardLayerSchema, type StandardLayer, LayerSchema, type Layer, LayersSchema, type Layers, BoundarySchema, type Boundary, BaselineViolationSchema, type BaselineViolation, BaselineSnapshotSchema, type BaselineSnapshot, ArchitectureBaselineSchema, type ArchitectureBaseline, LayerAssignmentSchema, type LayerAssignment, DependencyEdgeSchema, type DependencyEdge, BoundaryViolationSchema, type BoundaryViolation, createViolationId, isExistingViolation, createDefaultLayers, createDefaultBoundaries, } from './types.js';
+export { LayerDetector, createLayerDetector } from './layer-detector.js';
+export { EntryPointDetector, createEntryPointDetector } from './entry-detector.js';
+export { BASELINE_FILENAME, ANVIL_DIR, getBaselinePath, baselineExists, loadBaseline, saveBaseline, createBaseline, updateBaseline, mergeViolations, findNewViolations, findFixedViolations, BaselineManager, createBaselineManager, } from './baseline.js';
+export { type AnalysisResult, type AnalyzerOptions, type InferBaselineOptions, ArchitectureAnalyzer, createArchitectureAnalyzer, analyseArchitecture, inferBaseline, } from './analyzer.js';
+export { extractHtmlEdges, extractCssEdges } from './edge-detector-web.js';
+export { type ImportEdge, type BaselineComparison, type ExtractOptions, createEdgeFingerprint, fingerprintEdge, resolveImportPath, extractImports, extractImportsFromFiles, compareToBaseline, toDependencyEdge, deduplicateEdges, filterCrossLayerEdges, } from './edge-detector.js';
+export { ArchitectureTemplateSchema, type ArchitectureTemplate, LayerDefinitionSchema, type LayerDefinition, BoundedContextSchema, type BoundedContext, RuleSeveritySchema, type RuleSeverity, ArchitectureRuleSchema, type ArchitectureRule, ArchitectureOptionsSchema, type ArchitectureOptions, ArchitectureDefinitionSchema, type ArchitectureDefinition, AVAILABLE_TEMPLATES, getAvailableTemplates, isValidTemplate, ARCHITECTURE_DEFINITION_VERSION, validateArchitectureDefinition, getDefaultOptions, } from './definition-schema.js';
+export { ARCHITECTURE_YAML_FILENAME, getArchitectureYamlPath, architectureYamlExists, parseArchitectureDefinition, writeArchitectureYaml, getTemplateDefaults, mergeWithTemplate, createDefinitionFromTemplate, } from './yaml-parser.js';
+export { DC_CONFIG_FILENAME, getDCConfigPath, dcConfigExists, needsRegeneration, writeDCConfig, generateDCConfig, } from './dc-generator.js';
+export { GENERATED_POLICIES_DIR, REGO_FILENAME, REGO_PACKAGE, getRegoPath, regoExists, needsRegoRegeneration, writeRegoPolicy, generateRegoPolicy, } from './rego-generator.js';
+export { type CompileResult, type CompileOptions, compileArchitecture, needsCompilation, } from './compiler.js';
+export { type TemplateFile, type LoadedTemplate, TemplateLoader, getTemplateLoader, listTemplates, getTemplate as getArchitectureTemplate, validateTemplate, } from './templates/index.js';
+export { ArchViolationSeveritySchema, type ArchViolationSeverity, ArchViolationSchema, type ArchViolation, ModuleInfoSchema, type ModuleInfo, LayerStatsSchema, type LayerStats, ArchitectureContextSchema, type ArchitectureContext, createEmptyContext, ArchitectureContextBuilder, createContextBuilder, } from './context.js';
+//# sourceMappingURL=index.d.ts.map