@eddacraft/anvil-core 0.1.0

package/dist/architecture/dc-generator.js

@@ -0,0 +1,220 @@
+import { writeFile, mkdir, readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('compiler');
+export const DC_CONFIG_FILENAME = 'dependency-cruiser.js';
+export const ANVIL_DIR = '.anvil';
+export function getDCConfigPath(workspaceRoot) {
+    return join(workspaceRoot, ANVIL_DIR, DC_CONFIG_FILENAME);
+}
+export function dcConfigExists(workspaceRoot) {
+    return existsSync(getDCConfigPath(workspaceRoot));
+}
+export async function needsRegeneration(workspaceRoot, definition) {
+    const configPath = getDCConfigPath(workspaceRoot);
+    if (!existsSync(configPath)) {
+        return true;
+    }
+    const existingContent = await readFile(configPath, 'utf-8');
+    const hashMatch = existingContent.match(/\/\/ hash: ([a-f0-9]+)/);
+    if (!hashMatch) {
+        return true;
+    }
+    const currentHash = computeDefinitionHash(definition);
+    return hashMatch[1] !== currentHash;
+}
+function computeDefinitionHash(definition) {
+    const content = JSON.stringify(definition);
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+export async function writeDCConfig(workspaceRoot, definition) {
+    const configPath = getDCConfigPath(workspaceRoot);
+    debug('writing dependency-cruiser config', configPath);
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) {
+        await mkdir(configDir, { recursive: true });
+    }
+    const content = generateDCConfig(definition);
+    await writeFile(configPath, content, 'utf-8');
+    return configPath;
+}
+export function generateDCConfig(definition) {
+    const hash = computeDefinitionHash(definition);
+    const rules = generateRules(definition);
+    const options = definition.options ?? {
+        detect_orphans: true,
+        detect_circular: true,
+        default_severity: 'error',
+        exclude_patterns: ['**/*.test.ts', '**/*.spec.ts', '**/__tests__/**', '**/node_modules/**'],
+    };
+    const config = {
+        forbidden: rules,
+        options: {
+            doNotFollow: {
+                path: 'node_modules',
+            },
+            exclude: {
+                path: options.exclude_patterns,
+            },
+            tsPreCompilationDeps: true,
+            enhancedResolveOptions: {
+                exportsFields: ['exports'],
+                conditionNames: ['import', 'require', 'node', 'default'],
+            },
+        },
+    };
+    return `// Auto-generated by Anvil - do not edit manually
+// hash: ${hash}
+// Generated from: .anvil/architecture.yaml
+
+/** @type {import('dependency-cruiser').IConfiguration} */
+module.exports = ${JSON.stringify(config, null, 2)};
+`;
+}
+/**
+ * Deduplicates rules by name, allowing later rules to override earlier ones.
+ *
+ * When multiple rules share the same name, the LAST rule wins but appears at
+ * the position of the FIRST occurrence. This allows user-defined rules in the
+ * architecture definition to override auto-generated rules (e.g., no-circular)
+ * while maintaining a predictable output order.
+ */
+function deduplicateRules(rules) {
+    const byName = new Map();
+    for (let i = 0; i < rules.length; i++) {
+        const existing = byName.get(rules[i].name);
+        byName.set(rules[i].name, {
+            index: existing?.index ?? i,
+            rule: rules[i],
+        });
+    }
+    return Array.from(byName.values())
+        .sort((a, b) => a.index - b.index)
+        .map((entry) => entry.rule);
+}
+function generateRules(definition) {
+    const rules = [];
+    const options = definition.options ?? {
+        detect_orphans: true,
+        detect_circular: true,
+        default_severity: 'error',
+    };
+    if (options.detect_circular) {
+        rules.push({
+            name: 'no-circular',
+            severity: mapSeverity(options.default_severity),
+            comment: 'Circular dependencies are not allowed',
+            from: {},
+            to: { circular: true },
+        });
+    }
+    if (options.detect_orphans) {
+        rules.push({
+            name: 'no-orphans',
+            severity: mapSeverity(options.default_severity ?? 'warn'),
+            comment: 'Modules without dependents or dependencies',
+            from: {
+                pathNot: ['\\.d\\.ts$', '\\.test\\.(ts|js)$', '\\.spec\\.(ts|js)$', 'index\\.(ts|js)$'],
+            },
+            to: {},
+        });
+    }
+    const layerNames = Object.keys(definition.layers);
+    for (const [layerName, layerDef] of Object.entries(definition.layers)) {
+        const allowedDeps = layerDef.depends_on;
+        const disallowedLayers = layerNames.filter((l) => l !== layerName && !allowedDeps.includes(l));
+        if (disallowedLayers.length > 0) {
+            const fromPattern = layerPathsToRegex(layerDef.patterns);
+            const toPatterns = disallowedLayers
+                .map((l) => definition.layers[l]?.patterns ?? [])
+                .flat()
+                .map((p) => globToRegex(p));
+            if (toPatterns.length > 0) {
+                rules.push({
+                    name: `no-${layerName}-to-disallowed`,
+                    severity: mapSeverity(options.default_severity),
+                    comment: `${layerName} layer must not depend on: ${disallowedLayers.join(', ')}`,
+                    from: { path: fromPattern },
+                    to: { path: toPatterns.join('|') },
+                });
+            }
+        }
+    }
+    for (const rule of definition.rules) {
+        const fromLayer = definition.layers[rule.from];
+        const toLayer = definition.layers[rule.to];
+        if (!fromLayer || !toLayer)
+            continue;
+        if (!rule.allowed) {
+            rules.push({
+                name: rule.name,
+                severity: mapSeverity(rule.severity),
+                comment: rule.message,
+                from: { path: layerPathsToRegex(fromLayer.patterns) },
+                to: { path: layerPathsToRegex(toLayer.patterns) },
+            });
+        }
+    }
+    return deduplicateRules(rules);
+}
+function mapSeverity(severity) {
+    switch (severity) {
+        case 'error':
+            return 'error';
+        case 'warn':
+        case 'warning':
+            return 'warn';
+        case 'info':
+            return 'info';
+        case 'ignore':
+            return 'ignore';
+        default:
+            throw new Error(`Unknown architecture rule severity "${severity}". Expected: error, warn, warning, info, ignore.`);
+    }
+}
+const REGEX_METACHARACTERS = /[+?()[\]{}|^$\\]/g;
+function globToRegex(glob) {
+    let result = '';
+    let i = 0;
+    while (i < glob.length) {
+        const char = glob[i];
+        const nextChar = glob[i + 1];
+        const charAfterNext = glob[i + 2];
+        if (char === '*' && nextChar === '*') {
+            if (charAfterNext === '/') {
+                result += '(.*\\/)?';
+                i += 3;
+            }
+            else {
+                result += '.*';
+                i += 2;
+            }
+        }
+        else if (char === '*') {
+            result += '[^\\/]*';
+            i += 1;
+        }
+        else if (char === '.') {
+            result += '\\.';
+            i += 1;
+        }
+        else if (char === '/') {
+            result += '\\/';
+            i += 1;
+        }
+        else if (REGEX_METACHARACTERS.test(char)) {
+            result += '\\' + char;
+            i += 1;
+        }
+        else {
+            result += char;
+            i += 1;
+        }
+    }
+    return result;
+}
+function layerPathsToRegex(patterns) {
+    return patterns.map((p) => globToRegex(p) + '$').join('|');
+}

package/dist/architecture/definition-schema.d.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+export declare const ARCHITECTURE_DEFINITION_VERSION: "0.1.0";
+export declare const ArchitectureTemplateSchema: z.ZodEnum<{
+    custom: "custom";
+    starter: "starter";
+    layered: "layered";
+    hexagonal: "hexagonal";
+    clean: "clean";
+    ddd: "ddd";
+    monorepo: "monorepo";
+    serverless: "serverless";
+    "nx-workspace": "nx-workspace";
+}>;
+export type ArchitectureTemplate = z.infer<typeof ArchitectureTemplateSchema>;
+export declare const LayerDefinitionSchema: z.ZodObject<{
+    patterns: z.ZodArray<z.ZodString>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LayerDefinition = z.infer<typeof LayerDefinitionSchema>;
+export declare const BoundedContextSchema: z.ZodObject<{
+    layers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        patterns: z.ZodArray<z.ZodString>;
+        depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    allowed_dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BoundedContext = z.infer<typeof BoundedContextSchema>;
+export declare const RuleSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warn: "warn";
+    ignore: "ignore";
+}>;
+export type RuleSeverity = z.infer<typeof RuleSeveritySchema>;
+export declare const ArchitectureRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    severity: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+        ignore: "ignore";
+    }>>;
+    allowed: z.ZodDefault<z.ZodBoolean>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ArchitectureRule = z.infer<typeof ArchitectureRuleSchema>;
+export declare const ArchitectureOptionsSchema: z.ZodObject<{
+    detect_orphans: z.ZodDefault<z.ZodBoolean>;
+    detect_circular: z.ZodDefault<z.ZodBoolean>;
+    default_severity: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+        ignore: "ignore";
+    }>>;
+    exclude_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ArchitectureOptions = z.infer<typeof ArchitectureOptionsSchema>;
+export declare const ArchitectureDefinitionSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<"0.1.0">>;
+    template: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        starter: "starter";
+        layered: "layered";
+        hexagonal: "hexagonal";
+        clean: "clean";
+        ddd: "ddd";
+        monorepo: "monorepo";
+        serverless: "serverless";
+        "nx-workspace": "nx-workspace";
+    }>>;
+    layers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        patterns: z.ZodArray<z.ZodString>;
+        depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    bounded_contexts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        layers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            patterns: z.ZodArray<z.ZodString>;
+            depends_on: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        allowed_dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        severity: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+            ignore: "ignore";
+        }>>;
+        allowed: z.ZodDefault<z.ZodBoolean>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    options: z.ZodOptional<z.ZodObject<{
+        detect_orphans: z.ZodDefault<z.ZodBoolean>;
+        detect_circular: z.ZodDefault<z.ZodBoolean>;
+        default_severity: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+            ignore: "ignore";
+        }>>;
+        exclude_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ArchitectureDefinition = z.infer<typeof ArchitectureDefinitionSchema>;
+export declare const AVAILABLE_TEMPLATES: ArchitectureTemplate[];
+export declare function getAvailableTemplates(): ArchitectureTemplate[];
+export declare function isValidTemplate(template: string): template is ArchitectureTemplate;
+export declare function validateArchitectureDefinition(data: unknown): {
+    success: true;
+    data: ArchitectureDefinition;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+export declare function getDefaultOptions(): ArchitectureOptions;
+//# sourceMappingURL=definition-schema.d.ts.map

package/dist/architecture/definition-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-schema.d.ts","sourceRoot":"","sources":["../../src/architecture/definition-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,+BAA+B,EAAG,OAAgB,CAAC;AAEhE,eAAO,MAAM,0BAA0B;;;;;;;;;;EAUrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,oBAAoB;;;;;;;;iBAI/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,kBAAkB;;;;;EAA8C,CAAC;AAC9E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAOjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAapC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,mBAAmB,EAAE,oBAAoB,EAUrD,CAAC;AAEF,wBAAgB,qBAAqB,IAAI,oBAAoB,EAAE,CAE9D;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,IAAI,oBAAoB,CAElF;AAED,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,OAAO,GACZ;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,sBAAsB,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAA;CAAE,CAMzF;AAED,wBAAgB,iBAAiB,IAAI,mBAAmB,CAavD"}

package/dist/architecture/definition-schema.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export const ARCHITECTURE_DEFINITION_VERSION = '0.1.0';
+export const ArchitectureTemplateSchema = z.enum([
+    'starter',
+    'layered',
+    'hexagonal',
+    'clean',
+    'ddd',
+    'monorepo',
+    'serverless',
+    'nx-workspace',
+    'custom',
+]);
+export const LayerDefinitionSchema = z.object({
+    patterns: z.array(z.string()).min(1),
+    depends_on: z.array(z.string()).default([]),
+    description: z.string().optional(),
+});
+export const BoundedContextSchema = z.object({
+    layers: z.record(z.string(), LayerDefinitionSchema).optional(),
+    allowed_dependencies: z.array(z.string()).default([]),
+    description: z.string().optional(),
+});
+export const RuleSeveritySchema = z.enum(['error', 'warn', 'info', 'ignore']);
+export const ArchitectureRuleSchema = z.object({
+    name: z.string(),
+    from: z.string(),
+    to: z.string(),
+    severity: RuleSeveritySchema.default('error'),
+    allowed: z.boolean().default(false),
+    message: z.string().optional(),
+});
+export const ArchitectureOptionsSchema = z.object({
+    detect_orphans: z.boolean().default(true),
+    detect_circular: z.boolean().default(true),
+    default_severity: RuleSeveritySchema.default('error'),
+    exclude_patterns: z
+        .array(z.string())
+        .default([
+        '**/*.test.ts',
+        '**/*.spec.ts',
+        '**/__tests__/**',
+        '**/__fixtures__/**',
+        '**/node_modules/**',
+    ]),
+});
+export const ArchitectureDefinitionSchema = z.object({
+    schema_version: z
+        .literal(ARCHITECTURE_DEFINITION_VERSION)
+        .default(ARCHITECTURE_DEFINITION_VERSION),
+    template: ArchitectureTemplateSchema.default('custom'),
+    layers: z.record(z.string(), LayerDefinitionSchema).default({}),
+    bounded_contexts: z.record(z.string(), BoundedContextSchema).optional(),
+    rules: z.array(ArchitectureRuleSchema).default([]),
+    options: ArchitectureOptionsSchema.optional(),
+});
+export const AVAILABLE_TEMPLATES = [
+    'starter',
+    'layered',
+    'hexagonal',
+    'clean',
+    'ddd',
+    'monorepo',
+    'serverless',
+    'nx-workspace',
+    'custom',
+];
+export function getAvailableTemplates() {
+    return [...AVAILABLE_TEMPLATES];
+}
+export function isValidTemplate(template) {
+    return AVAILABLE_TEMPLATES.includes(template);
+}
+export function validateArchitectureDefinition(data) {
+    const result = ArchitectureDefinitionSchema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+}
+export function getDefaultOptions() {
+    return {
+        detect_orphans: true,
+        detect_circular: true,
+        default_severity: 'error',
+        exclude_patterns: [
+            '**/*.test.ts',
+            '**/*.spec.ts',
+            '**/__tests__/**',
+            '**/__fixtures__/**',
+            '**/node_modules/**',
+        ],
+    };
+}

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

@@ -0,0 +1,6 @@
+/**
+ * @deprecated This file has been renamed to edge-detector-web.ts
+ * This re-export exists for backward compatibility.
+ */
+export { extractHtmlEdges, extractCssEdges } from './edge-detector-web.js';
+//# sourceMappingURL=edge-detector-html.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edge-detector-html.d.ts","sourceRoot":"","sources":["../../src/architecture/edge-detector-html.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/architecture/edge-detector-html.js

@@ -0,0 +1,5 @@
+/**
+ * @deprecated This file has been renamed to edge-detector-web.ts
+ * This re-export exists for backward compatibility.
+ */
+export { extractHtmlEdges, extractCssEdges } from './edge-detector-web.js';

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

@@ -0,0 +1,32 @@
+/**
+ * HTML/CSS Edge Detector
+ *
+ * Extracts dependency edges from HTML and CSS files.
+ * Detects:
+ * - <script src="..."> references
+ * - <link href="..."> stylesheet references
+ * - CSS @import url("...") references
+ * - CSS url() references
+ *
+ * External URLs (http/https, data:, //) are skipped per D-002.
+ *
+ * @module architecture/edge-detector-web
+ */
+import type { ImportEdge } from './edge-detector.js';
+/**
+ * Extract dependency edges from HTML file content
+ *
+ * @param filePath - Path to HTML file (relative to workspace)
+ * @param content - File content
+ * @returns Array of import edges found in the file
+ */
+export declare function extractHtmlEdges(filePath: string, content: string): ImportEdge[];
+/**
+ * Extract dependency edges from CSS file content
+ *
+ * @param filePath - Path to CSS file (relative to workspace)
+ * @param content - File content
+ * @returns Array of import edges found in the file
+ */
+export declare function extractCssEdges(filePath: string, content: string): ImportEdge[];
+//# sourceMappingURL=edge-detector-web.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edge-detector-web.d.ts","sourceRoot":"","sources":["../../src/architecture/edge-detector-web.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAiCrD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CA6ChF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CA0C/E"}

package/dist/architecture/edge-detector-web.js

@@ -0,0 +1,133 @@
+/**
+ * HTML/CSS Edge Detector
+ *
+ * Extracts dependency edges from HTML and CSS files.
+ * Detects:
+ * - <script src="..."> references
+ * - <link href="..."> stylesheet references
+ * - CSS @import url("...") references
+ * - CSS url() references
+ *
+ * External URLs (http/https, data:, //) are skipped per D-002.
+ *
+ * @module architecture/edge-detector-web
+ */
+import { resolveImportPath } from './edge-detector.js';
+// HTML regexes
+const SCRIPT_SRC_REGEX = /<script[^>]+src\s*=\s*["']([^"']+)["']/g;
+const LINK_TAG_REGEX = /<link\s[^>]*>/g;
+const HREF_ATTR_REGEX = /href\s*=\s*["']([^"']+)["']/;
+// CSS regexes
+const CSS_IMPORT_REGEX = /@import\s+(?:url\(\s*(?:["']([^"']+)["']|([^)]+?))\s*\)|["']([^"']+)["'])/g;
+const CSS_URL_REGEX = /url\(\s*["']?([^"')]+)["']?\s*\)/g;
+/**
+ * Check if a URL is external (http/https, data:, or protocol-relative //)
+ */
+function isExternalUrl(url) {
+    return (url.startsWith('http://') ||
+        url.startsWith('https://') ||
+        url.startsWith('data:') ||
+        url.startsWith('//'));
+}
+/**
+ * Check if a <link> tag is a stylesheet reference
+ * Matches rel="stylesheet" or .css extension in href
+ */
+function isStylesheetLink(fullTag, href) {
+    return /rel\s*=\s*["']stylesheet["']/i.test(fullTag) || href.endsWith('.css');
+}
+/**
+ * Extract dependency edges from HTML file content
+ *
+ * @param filePath - Path to HTML file (relative to workspace)
+ * @param content - File content
+ * @returns Array of import edges found in the file
+ */
+export function extractHtmlEdges(filePath, content) {
+    const edges = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+        // <script src="...">
+        let match;
+        SCRIPT_SRC_REGEX.lastIndex = 0;
+        while ((match = SCRIPT_SRC_REGEX.exec(line)) !== null) {
+            const specifier = match[1];
+            if (!isExternalUrl(specifier)) {
+                edges.push({
+                    from: filePath,
+                    to: resolveImportPath(specifier, filePath),
+                    line: lineNumber,
+                    type: 'import',
+                    specifier,
+                });
+            }
+        }
+        // <link href="..."> (stylesheet only)
+        LINK_TAG_REGEX.lastIndex = 0;
+        while ((match = LINK_TAG_REGEX.exec(line)) !== null) {
+            const fullTag = match[0];
+            const hrefMatch = fullTag.match(HREF_ATTR_REGEX);
+            if (hrefMatch) {
+                const specifier = hrefMatch[1];
+                if (!isExternalUrl(specifier) && isStylesheetLink(fullTag, specifier)) {
+                    edges.push({
+                        from: filePath,
+                        to: resolveImportPath(specifier, filePath),
+                        line: lineNumber,
+                        type: 'import',
+                        specifier,
+                    });
+                }
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Extract dependency edges from CSS file content
+ *
+ * @param filePath - Path to CSS file (relative to workspace)
+ * @param content - File content
+ * @returns Array of import edges found in the file
+ */
+export function extractCssEdges(filePath, content) {
+    const edges = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+        // @import url("...") or @import "..." or @import url(...)
+        let match;
+        CSS_IMPORT_REGEX.lastIndex = 0;
+        while ((match = CSS_IMPORT_REGEX.exec(line)) !== null) {
+            const specifier = (match[1] ?? match[2] ?? match[3])?.trim();
+            if (specifier && !isExternalUrl(specifier)) {
+                edges.push({
+                    from: filePath,
+                    to: resolveImportPath(specifier, filePath),
+                    line: lineNumber,
+                    type: 'import',
+                    specifier,
+                });
+            }
+        }
+        // url() references (skip external and data: URIs)
+        CSS_URL_REGEX.lastIndex = 0;
+        while ((match = CSS_URL_REGEX.exec(line)) !== null) {
+            const specifier = match[1];
+            // Skip if already captured by @import, external, or data: URI
+            if (!isExternalUrl(specifier) && !line.includes('@import')) {
+                edges.push({
+                    from: filePath,
+                    to: resolveImportPath(specifier, filePath),
+                    line: lineNumber,
+                    type: 'import',
+                    specifier,
+                });
+            }
+        }
+    }
+    return edges;
+}