@harness-engineering/core 0.26.4 → 0.27.0

package/dist/{chunk-JIOBXIVB.mjs → chunk-MUWJHO2S.mjs}

@@ -1,131 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/architecture/types.ts
-import { z } from "zod";
-var ArchMetricCategorySchema = z.enum([
-  "circular-deps",
-  "layer-violations",
-  "complexity",
-  "coupling",
-  "forbidden-imports",
-  "module-size",
-  "dependency-depth"
-]);
-var ViolationSchema = z.object({
-  id: z.string(),
-  // stable hash: sha256(relativePath + ':' + category + ':' + normalizedDetail)
-  file: z.string(),
-  // relative to project root
-  category: ArchMetricCategorySchema.optional(),
-  // context for baseline reporting
-  detail: z.string(),
-  // human-readable description
-  severity: z.enum(["error", "warning"])
-});
-var MetricResultSchema = z.object({
-  category: ArchMetricCategorySchema,
-  scope: z.string(),
-  // e.g., 'project', 'src/services', 'src/api/routes.ts'
-  value: z.number(),
-  // numeric metric (violation count, complexity score, etc.)
-  violations: z.array(ViolationSchema),
-  metadata: z.record(z.unknown()).optional()
-});
-var CategoryBaselineSchema = z.object({
-  value: z.number(),
-  // aggregate metric value at baseline time
-  violationIds: z.array(z.string())
-  // stable IDs of known violations (the allowlist)
-});
-var ArchBaselineSchema = z.object({
-  version: z.literal(1),
-  updatedAt: z.string().datetime(),
-  // ISO 8601
-  updatedFrom: z.string(),
-  // commit hash
-  metrics: z.record(ArchMetricCategorySchema, CategoryBaselineSchema)
-});
-var CategoryRegressionSchema = z.object({
-  category: ArchMetricCategorySchema,
-  baselineValue: z.number(),
-  currentValue: z.number(),
-  delta: z.number()
-});
-var ArchDiffResultSchema = z.object({
-  passed: z.boolean(),
-  newViolations: z.array(ViolationSchema),
-  // in current but not in baseline -> FAIL
-  resolvedViolations: z.array(z.string()),
-  // in baseline but not in current -> celebrate
-  preExisting: z.array(z.string()),
-  // in both -> allowed, tracked
-  regressions: z.array(CategoryRegressionSchema)
-  // aggregate value exceeded baseline
-});
-var ThresholdConfigSchema = z.record(
-  ArchMetricCategorySchema,
-  z.union([z.number(), z.record(z.string(), z.number())])
-);
-var ArchConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  baselinePath: z.string().default(".harness/arch/baselines.json"),
-  thresholds: ThresholdConfigSchema.default({}),
-  modules: z.record(z.string(), ThresholdConfigSchema).default({})
-});
-var ConstraintRuleSchema = z.object({
-  id: z.string(),
-  // stable hash: sha256(category + ':' + scope + ':' + description)
-  category: ArchMetricCategorySchema,
-  description: z.string(),
-  // e.g., "Layer 'services' must not import from 'ui'"
-  scope: z.string(),
-  // e.g., 'src/services/', 'project'
-  targets: z.array(z.string()).optional()
-  // forward-compat for governs edges
-});
-var ViolationSnapshotSchema = z.object({
-  timestamp: z.string().datetime(),
-  violations: z.array(ViolationSchema)
-});
-var ViolationHistorySchema = z.object({
-  version: z.literal(1),
-  snapshots: z.array(ViolationSnapshotSchema)
-});
-var EmergenceConfidenceSchema = z.enum(["low", "medium", "high"]);
-var EmergentConstraintSuggestionSchema = z.object({
-  suggestedRule: ConstraintRuleSchema,
-  confidence: EmergenceConfidenceSchema,
-  occurrences: z.number(),
-  uniqueFiles: z.number(),
-  pattern: z.string(),
-  sampleViolations: z.array(ViolationSchema),
-  rationale: z.string()
-});
-var EmergenceResultSchema = z.object({
-  suggestions: z.array(EmergentConstraintSuggestionSchema),
-  totalViolationsAnalyzed: z.number(),
-  windowWeeks: z.number(),
-  minOccurrences: z.number()
-});
-
-// src/architecture/collectors/hash.ts
-import { createHash } from "crypto";
-function violationId(relativePath, category, normalizedDetail) {
-  const input = `${relativePath}:${category}:${normalizedDetail}`;
-  return createHash("sha256").update(input).digest("hex");
-}
-function constraintRuleId(category, scope, description) {
-  const input = `${category}:${scope}:${description}`;
-  return createHash("sha256").update(input).digest("hex");
-}
-
-// src/shared/result.ts
-import { Ok, Err, isOk, isErr } from "@harness-engineering/types";
-
 // src/shared/errors.ts
 function createError(code, message, details = {}, suggestions = []) {
   return { code, message, details, suggestions };
@@ -134,26 +6,17 @@ function createEntropyError(code, message, details = {}, suggestions = []) {
   return { code, message, details, suggestions };
 }
 
-// src/constraints/layers.ts
-import { minimatch } from "minimatch";
-function defineLayer(name, patterns, allowedDependencies) {
-  return {
-    name,
-    patterns,
-    allowedDependencies
-  };
-}
-function resolveFileToLayer(file, layers) {
-  for (const layer of layers) {
-    for (const pattern of layer.patterns) {
-      if (minimatch(file, pattern)) {
-        return layer;
-      }
-    }
-  }
-  return void 0;
+// src/shared/result.ts
+import { Ok, Err, isOk, isErr } from "@harness-engineering/types";
+
+// src/shared/parsers/base.ts
+function createParseError(code, message, details = {}, suggestions = []) {
+  return { code, message, details, suggestions };
 }
 
+// src/shared/parsers/typescript.ts
+import { parse } from "@typescript-eslint/typescript-estree";
+
 // src/shared/fs-utils.ts
 import { access, constants, readFile } from "fs";
 import { promisify } from "util";
@@ -194,485 +57,110 @@ function relativePosix(from, to) {
   return relative(from, to).replaceAll("\\", "/");
 }
 
-// src/constraints/dependencies.ts
-import { dirname, resolve, extname } from "path";
-var EXTENSION_BY_LANG = {
-  typescript: [".ts", ".tsx"],
-  javascript: [".js", ".jsx", ".mjs", ".cjs"],
-  python: [".py"],
-  go: [".go"],
-  rust: [".rs"],
-  java: [".java"]
-};
-var JS_EXT_FALLBACKS = {
-  ".js": [".ts", ".tsx", ".jsx"],
-  ".jsx": [".tsx"],
-  ".mjs": [".mts"],
-  ".cjs": [".cts"]
-};
-function detectLangFromExt(ext) {
-  for (const [lang, exts] of Object.entries(EXTENSION_BY_LANG)) {
-    if (exts.includes(ext)) return lang;
+// src/shared/parsers/typescript.ts
+function walk(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  if ("type" in node) {
+    visitor(node);
   }
-  return null;
-}
-function getExtensionsForLang(lang) {
-  switch (lang) {
-    case "typescript":
-      return [".ts", ".tsx"];
-    case "javascript":
-      return [".js", ".jsx", ".mjs", ".cjs"];
-    case "python":
-      return [".py"];
-    case "go":
-      return [".go"];
-    case "rust":
-      return [".rs"];
-    case "java":
-      return [".java"];
-    default:
-      return [".ts", ".tsx", ".js", ".jsx"];
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => walk(v, visitor));
+    } else {
+      walk(value, visitor);
+    }
   }
 }
-async function resolveImportPath(importSource, fromFile, _rootDir) {
-  if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
-    return null;
-  }
-  const fromDir = dirname(fromFile);
-  const resolved = resolve(fromDir, importSource);
-  const sourceExt = extname(resolved);
-  const fromLang = detectLangFromExt(extname(fromFile));
-  const fallbacks = JS_EXT_FALLBACKS[sourceExt];
-  if (fallbacks) {
-    const base = resolved.slice(0, -sourceExt.length);
-    for (const ext of fallbacks) {
-      const candidate = base + ext;
-      if (await fileExists(candidate)) return candidate.replace(/\\/g, "/");
-    }
-    for (const indexExt of [".ts", ".tsx", ".jsx"]) {
-      const indexPath = resolve(base, "index" + indexExt);
-      if (await fileExists(indexPath)) return indexPath.replace(/\\/g, "/");
+function makeLocation(node) {
+  return {
+    file: "",
+    line: node.loc?.start.line ?? 0,
+    column: node.loc?.start.column ?? 0
+  };
+}
+function processImportSpecifiers(importDecl, imp) {
+  for (const spec of importDecl.specifiers) {
+    if (spec.type === "ImportDefaultSpecifier") {
+      imp.default = spec.local.name;
+    } else if (spec.type === "ImportNamespaceSpecifier") {
+      imp.namespace = spec.local.name;
+    } else if (spec.type === "ImportSpecifier") {
+      imp.specifiers.push(spec.local.name);
+      if (spec.importKind === "type") {
+        imp.kind = "type";
+      }
     }
   }
-  const hasKnownExt = Object.values(EXTENSION_BY_LANG).flat().some((e) => resolved.endsWith(e));
-  if (hasKnownExt) {
-    return resolved.replace(/\\/g, "/");
-  }
-  const extensions = getExtensionsForLang(fromLang);
-  return (resolved + extensions[0]).replace(/\\/g, "/");
 }
-function getImportType(imp) {
-  if (imp.kind === "type") return "type-only";
-  return "static";
+function getExportedName(exported) {
+  return exported.type === "Identifier" ? exported.name : String(exported.value);
 }
-async function buildDependencyGraph(files, parser, graphDependencyData) {
-  if (graphDependencyData) {
-    return Ok({
-      nodes: graphDependencyData.nodes,
-      edges: graphDependencyData.edges
+function processReExportSpecifiers(exportDecl, exports) {
+  for (const spec of exportDecl.specifiers) {
+    if (spec.type !== "ExportSpecifier") continue;
+    exports.push({
+      name: getExportedName(spec.exported),
+      type: "named",
+      location: makeLocation(exportDecl),
+      isReExport: true,
+      source: exportDecl.source.value
     });
   }
-  const isLookup = "getForFile" in parser;
-  const nodes = files.map((f) => f.replace(/\\/g, "/"));
-  const edges = [];
-  for (const file of files) {
-    const normalizedFile = file.replace(/\\/g, "/");
-    const fileParser = isLookup ? parser.getForFile(file) : parser;
-    if (!fileParser) continue;
-    const parseResult = await fileParser.parseFile(file);
-    if (!parseResult.ok) {
-      continue;
-    }
-    const importsResult = fileParser.extractImports(parseResult.value);
-    if (!importsResult.ok) {
-      continue;
-    }
-    for (const imp of importsResult.value) {
-      const resolvedPath = await resolveImportPath(imp.source, file, "");
-      if (resolvedPath) {
-        edges.push({
-          from: normalizedFile,
-          to: resolvedPath,
-          importType: getImportType(imp),
-          line: imp.location.line
+}
+function processExportDeclaration(exportDecl, exports) {
+  const decl = exportDecl.declaration;
+  if (!decl) return;
+  if (decl.type === "VariableDeclaration") {
+    for (const declarator of decl.declarations) {
+      if (declarator.id.type === "Identifier") {
+        exports.push({
+          name: declarator.id.name,
+          type: "named",
+          location: makeLocation(decl),
+          isReExport: false
         });
       }
     }
+  } else if ((decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") && decl.id) {
+    exports.push({
+      name: decl.id.name,
+      type: "named",
+      location: makeLocation(decl),
+      isReExport: false
+    });
   }
-  return Ok({ nodes, edges });
 }
-function checkLayerViolations(graph, layers, rootDir) {
-  const violations = [];
-  for (const edge of graph.edges) {
-    const fromRelative = relativePosix(rootDir, edge.from);
-    const toRelative = relativePosix(rootDir, edge.to);
-    const fromLayer = resolveFileToLayer(fromRelative, layers);
-    const toLayer = resolveFileToLayer(toRelative, layers);
-    if (!fromLayer || !toLayer) continue;
-    if (fromLayer.name === toLayer.name) continue;
-    if (!fromLayer.allowedDependencies.includes(toLayer.name)) {
-      violations.push({
-        file: edge.from,
-        imports: edge.to,
-        fromLayer: fromLayer.name,
-        toLayer: toLayer.name,
-        reason: "WRONG_LAYER",
-        line: edge.line,
-        suggestion: `Move the dependency to an allowed layer (${fromLayer.allowedDependencies.join(", ") || "none"}) or update layer rules`
-      });
-    }
+function processExportListSpecifiers(exportDecl, exports) {
+  for (const spec of exportDecl.specifiers) {
+    if (spec.type !== "ExportSpecifier") continue;
+    exports.push({
+      name: getExportedName(spec.exported),
+      type: "named",
+      location: makeLocation(exportDecl),
+      isReExport: false
+    });
   }
-  return violations;
 }
-async function validateDependencies(config) {
-  const { layers, rootDir, parser, fallbackBehavior = "error", graphDependencyData } = config;
-  if (graphDependencyData) {
-    const graphResult2 = await buildDependencyGraph([], parser, graphDependencyData);
-    if (!graphResult2.ok) {
-      return Err(graphResult2.error);
+var TypeScriptParser = class {
+  name = "typescript";
+  extensions = [".ts", ".tsx", ".mts", ".cts"];
+  async parseFile(path) {
+    const contentResult = await readFileContent(path);
+    if (!contentResult.ok) {
+      return Err(
+        createParseError("NOT_FOUND", `File not found: ${path}`, { path }, [
+          "Check that the file exists",
+          "Verify the path is correct"
+        ])
+      );
     }
-    const violations2 = checkLayerViolations(graphResult2.value, layers, rootDir);
-    return Ok({
-      valid: violations2.length === 0,
-      violations: violations2,
-      graph: graphResult2.value
-    });
-  }
-  const healthResult = await parser.health();
-  if (!healthResult.ok || !healthResult.value.available) {
-    if (fallbackBehavior === "skip") {
-      return Ok({
-        valid: true,
-        violations: [],
-        graph: { nodes: [], edges: [] },
-        skipped: true,
-        reason: "Parser unavailable"
-      });
-    }
-    if (fallbackBehavior === "warn") {
-      console.warn(`Parser ${parser.name} unavailable, skipping validation`);
-      return Ok({
-        valid: true,
-        violations: [],
-        graph: { nodes: [], edges: [] },
-        skipped: true,
-        reason: "Parser unavailable"
-      });
-    }
-    return Err(
-      createError(
-        "PARSER_UNAVAILABLE",
-        `Parser ${parser.name} is not available`,
-        { parser: parser.name },
-        ["Install required runtime", "Use different parser", 'Set fallbackBehavior: "skip"']
-      )
-    );
-  }
-  const allFiles = [];
-  for (const layer of layers) {
-    for (const pattern of layer.patterns) {
-      const files = await findFiles(pattern, rootDir);
-      allFiles.push(...files);
-    }
-  }
-  const uniqueFiles = [...new Set(allFiles)];
-  const graphResult = await buildDependencyGraph(uniqueFiles, parser);
-  if (!graphResult.ok) {
-    return Err(graphResult.error);
-  }
-  const violations = checkLayerViolations(graphResult.value, layers, rootDir);
-  return Ok({
-    valid: violations.length === 0,
-    violations,
-    graph: graphResult.value
-  });
-}
-
-// src/constraints/circular-deps.ts
-function buildAdjacencyList(graph) {
-  const adjacency = /* @__PURE__ */ new Map();
-  const nodeSet = new Set(graph.nodes);
-  for (const node of graph.nodes) {
-    adjacency.set(node, []);
-  }
-  for (const edge of graph.edges) {
-    const neighbors = adjacency.get(edge.from);
-    if (neighbors && nodeSet.has(edge.to)) {
-      neighbors.push(edge.to);
-    }
-  }
-  return adjacency;
-}
-function isCyclicSCC(scc, adjacency) {
-  if (scc.length > 1) return true;
-  if (scc.length === 1) {
-    const selfNode = scc[0];
-    const selfNeighbors = adjacency.get(selfNode) ?? [];
-    return selfNeighbors.includes(selfNode);
-  }
-  return false;
-}
-function processNeighbors(node, neighbors, nodeMap, stack, adjacency, sccs, indexRef) {
-  for (const neighbor of neighbors) {
-    const neighborData = nodeMap.get(neighbor);
-    if (!neighborData) {
-      strongConnectImpl(neighbor, nodeMap, stack, adjacency, sccs, indexRef);
-      const nodeData = nodeMap.get(node);
-      const updatedNeighborData = nodeMap.get(neighbor);
-      nodeData.lowlink = Math.min(nodeData.lowlink, updatedNeighborData.lowlink);
-    } else if (neighborData.onStack) {
-      const nodeData = nodeMap.get(node);
-      nodeData.lowlink = Math.min(nodeData.lowlink, neighborData.index);
-    }
-  }
-}
-function strongConnectImpl(node, nodeMap, stack, adjacency, sccs, indexRef) {
-  nodeMap.set(node, { index: indexRef.value, lowlink: indexRef.value, onStack: true });
-  indexRef.value++;
-  stack.push(node);
-  processNeighbors(node, adjacency.get(node) ?? [], nodeMap, stack, adjacency, sccs, indexRef);
-  const nodeData = nodeMap.get(node);
-  if (nodeData.lowlink === nodeData.index) {
-    const scc = [];
-    let w;
-    do {
-      w = stack.pop();
-      nodeMap.get(w).onStack = false;
-      scc.push(w);
-    } while (w !== node);
-    if (isCyclicSCC(scc, adjacency)) {
-      sccs.push(scc);
-    }
-  }
-}
-function tarjanSCC(graph) {
-  const nodeMap = /* @__PURE__ */ new Map();
-  const stack = [];
-  const sccs = [];
-  const indexRef = { value: 0 };
-  const adjacency = buildAdjacencyList(graph);
-  for (const node of graph.nodes) {
-    if (!nodeMap.has(node)) {
-      strongConnectImpl(node, nodeMap, stack, adjacency, sccs, indexRef);
-    }
-  }
-  return sccs;
-}
-function detectCircularDeps(graph) {
-  const sccs = tarjanSCC(graph);
-  const cycles = sccs.map((scc) => {
-    const reversed = scc.reverse();
-    const firstNode = reversed[reversed.length - 1];
-    const cycle = [...reversed, firstNode];
-    return {
-      cycle,
-      severity: "error",
-      size: scc.length
-    };
-  });
-  const largestCycle = cycles.reduce((max, c) => Math.max(max, c.size), 0);
-  return Ok({
-    hasCycles: cycles.length > 0,
-    cycles,
-    largestCycle
-  });
-}
-async function detectCircularDepsInFiles(files, parser, graphDependencyData) {
-  const graphResult = await buildDependencyGraph(files, parser, graphDependencyData);
-  if (!graphResult.ok) {
-    return graphResult;
-  }
-  return detectCircularDeps(graphResult.value);
-}
-
-// src/architecture/collectors/circular-deps.ts
-function makeStubParser() {
-  return {
-    name: "typescript",
-    extensions: [".ts", ".tsx"],
-    parseFile: async () => ({ ok: false, error: { code: "PARSE_ERROR", message: "not needed" } }),
-    extractImports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "not needed" } }),
-    extractExports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "not needed" } }),
-    health: async () => ({ ok: true, value: { available: true } })
-  };
-}
-function mapCycleViolations(cycles, rootDir, category) {
-  return cycles.map((cycle) => {
-    const cyclePath = cycle.cycle.map((f) => relativePosix(rootDir, f)).join(" -> ");
-    const firstFile = relativePosix(rootDir, cycle.cycle[0]);
-    return {
-      id: violationId(firstFile, category, cyclePath),
-      file: firstFile,
-      detail: `Circular dependency: ${cyclePath}`,
-      severity: cycle.severity
-    };
-  });
-}
-var CircularDepsCollector = class {
-  category = "circular-deps";
-  getRules(_config, _rootDir) {
-    const description = "No circular dependencies allowed";
-    return [
-      {
-        id: constraintRuleId(this.category, "project", description),
-        category: this.category,
-        description,
-        scope: "project"
-      }
-    ];
-  }
-  async collect(_config, rootDir) {
-    const files = await findFiles("**/*.ts", rootDir);
-    const graphResult = await buildDependencyGraph(files, makeStubParser());
-    if (!graphResult.ok) {
-      return [
-        {
-          category: this.category,
-          scope: "project",
-          value: 0,
-          violations: [],
-          metadata: { error: "Failed to build dependency graph" }
-        }
-      ];
-    }
-    const result = detectCircularDeps(graphResult.value);
-    if (!result.ok) {
-      return [
-        {
-          category: this.category,
-          scope: "project",
-          value: 0,
-          violations: [],
-          metadata: { error: "Failed to detect circular deps" }
-        }
-      ];
-    }
-    const { cycles, largestCycle } = result.value;
-    const violations = mapCycleViolations(cycles, rootDir, this.category);
-    return [
-      {
-        category: this.category,
-        scope: "project",
-        value: cycles.length,
-        violations,
-        metadata: { largestCycle, cycleCount: cycles.length }
-      }
-    ];
-  }
-};
-
-// src/shared/parsers/typescript.ts
-import { parse } from "@typescript-eslint/typescript-estree";
-
-// src/shared/parsers/base.ts
-function createParseError(code, message, details = {}, suggestions = []) {
-  return { code, message, details, suggestions };
-}
-
-// src/shared/parsers/typescript.ts
-function walk(node, visitor) {
-  if (!node || typeof node !== "object") return;
-  if ("type" in node) {
-    visitor(node);
-  }
-  for (const value of Object.values(node)) {
-    if (Array.isArray(value)) {
-      value.forEach((v) => walk(v, visitor));
-    } else {
-      walk(value, visitor);
-    }
-  }
-}
-function makeLocation(node) {
-  return {
-    file: "",
-    line: node.loc?.start.line ?? 0,
-    column: node.loc?.start.column ?? 0
-  };
-}
-function processImportSpecifiers(importDecl, imp) {
-  for (const spec of importDecl.specifiers) {
-    if (spec.type === "ImportDefaultSpecifier") {
-      imp.default = spec.local.name;
-    } else if (spec.type === "ImportNamespaceSpecifier") {
-      imp.namespace = spec.local.name;
-    } else if (spec.type === "ImportSpecifier") {
-      imp.specifiers.push(spec.local.name);
-      if (spec.importKind === "type") {
-        imp.kind = "type";
-      }
-    }
-  }
-}
-function getExportedName(exported) {
-  return exported.type === "Identifier" ? exported.name : String(exported.value);
-}
-function processReExportSpecifiers(exportDecl, exports) {
-  for (const spec of exportDecl.specifiers) {
-    if (spec.type !== "ExportSpecifier") continue;
-    exports.push({
-      name: getExportedName(spec.exported),
-      type: "named",
-      location: makeLocation(exportDecl),
-      isReExport: true,
-      source: exportDecl.source.value
-    });
-  }
-}
-function processExportDeclaration(exportDecl, exports) {
-  const decl = exportDecl.declaration;
-  if (!decl) return;
-  if (decl.type === "VariableDeclaration") {
-    for (const declarator of decl.declarations) {
-      if (declarator.id.type === "Identifier") {
-        exports.push({
-          name: declarator.id.name,
-          type: "named",
-          location: makeLocation(decl),
-          isReExport: false
-        });
-      }
-    }
-  } else if ((decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") && decl.id) {
-    exports.push({
-      name: decl.id.name,
-      type: "named",
-      location: makeLocation(decl),
-      isReExport: false
-    });
-  }
-}
-function processExportListSpecifiers(exportDecl, exports) {
-  for (const spec of exportDecl.specifiers) {
-    if (spec.type !== "ExportSpecifier") continue;
-    exports.push({
-      name: getExportedName(spec.exported),
-      type: "named",
-      location: makeLocation(exportDecl),
-      isReExport: false
-    });
-  }
-}
-var TypeScriptParser = class {
-  name = "typescript";
-  extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path) {
-    const contentResult = await readFileContent(path);
-    if (!contentResult.ok) {
-      return Err(
-        createParseError("NOT_FOUND", `File not found: ${path}`, { path }, [
-          "Check that the file exists",
-          "Verify the path is correct"
-        ])
-      );
-    }
-    try {
-      const ast = parse(contentResult.value, {
-        loc: true,
-        range: true,
-        jsx: path.endsWith(".tsx"),
-        errorOnUnknownASTType: false
-      });
+    try {
+      const ast = parse(contentResult.value, {
+        loc: true,
+        range: true,
+        jsx: path.endsWith(".tsx"),
+        errorOnUnknownASTType: false
+      });
       return Ok({
         type: "Program",
         body: ast,
@@ -760,9 +248,6 @@ var TypeScriptParser = class {
   }
 };
 
-// src/code-nav/parser.ts
-import Parser from "web-tree-sitter";
-
 // src/code-nav/types.ts
 var EXTENSION_MAP = {
   ".ts": "typescript",
@@ -784,6 +269,7 @@ function detectLanguage(filePath) {
 }
 
 // src/code-nav/parser.ts
+import Parser from "web-tree-sitter";
 var parserCache = /* @__PURE__ */ new Map();
 var initialized = false;
 var GRAMMAR_MAP = {
@@ -1083,604 +569,218 @@ function formatOutline(outline) {
   return lines.join("\n");
 }
 
-// src/shared/parsers/tree-sitter.ts
-function findSymbolByName(symbols, name) {
-  for (const sym of symbols) {
-    if (sym.name === name) return { line: sym.line, endLine: sym.endLine };
-    if (sym.children) {
-      const found = findSymbolByName(sym.children, name);
-      if (found) return found;
-    }
-  }
-  return null;
-}
-function makeLocation2(node) {
+// src/constraints/layers.ts
+import { minimatch } from "minimatch";
+function defineLayer(name, patterns, allowedDependencies) {
   return {
-    file: "",
-    line: node.startPosition.row + 1,
-    column: node.startPosition.column
+    name,
+    patterns,
+    allowedDependencies
   };
 }
-function makeNamedExport(node) {
-  const name = node.childForFieldName("name");
-  if (!name) return null;
-  return { name: name.text, type: "named", location: makeLocation2(node), isReExport: false };
-}
-function makeImport(node, source) {
-  return { source, specifiers: [], location: makeLocation2(node), kind: "value" };
-}
-function extractPythonImport(child) {
-  const name = child.childForFieldName("name");
-  if (!name) return null;
-  return makeImport(child, name.text);
-}
-function extractPythonFromImport(child) {
-  const moduleName = child.childForFieldName("module_name");
-  const specifiers = [];
-  for (const c of child.children) {
-    if (c.type === "dotted_name" && c !== moduleName) specifiers.push(c.text);
-    if (c.type === "aliased_import") {
-      const n = c.childForFieldName("name");
-      if (n) specifiers.push(n.text);
+function resolveFileToLayer(file, layers) {
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      if (minimatch(file, pattern)) {
+        return layer;
+      }
     }
   }
-  return {
-    source: moduleName?.text ?? "",
-    specifiers,
-    location: makeLocation2(child),
-    kind: "value"
-  };
+  return void 0;
 }
-function extractPythonExport(child) {
-  if (child.type === "function_definition" || child.type === "class_definition") {
-    return makeNamedExport(child);
-  }
-  if (child.type === "assignment") {
-    const left = child.childForFieldName("left") ?? child.children[0];
-    if (left && !left.text.startsWith("_")) {
-      return { name: left.text, type: "named", location: makeLocation2(child), isReExport: false };
-    }
-  }
-  return null;
-}
-var pythonStrategy = {
-  extractImports(root) {
-    const imports = [];
-    for (const child of root.children) {
-      if (child.type === "import_statement") {
-        const imp = extractPythonImport(child);
-        if (imp) imports.push(imp);
-      } else if (child.type === "import_from_statement") {
-        imports.push(extractPythonFromImport(child));
-      }
-    }
-    return imports;
-  },
-  extractExports(root) {
-    const exports = [];
-    for (const child of root.children) {
-      const exp = extractPythonExport(child);
-      if (exp) exports.push(exp);
-    }
-    return exports;
-  }
+
+// src/constraints/dependencies.ts
+import { dirname, resolve, extname } from "path";
+var EXTENSION_BY_LANG = {
+  typescript: [".ts", ".tsx"],
+  javascript: [".js", ".jsx", ".mjs", ".cjs"],
+  python: [".py"],
+  go: [".go"],
+  rust: [".rs"],
+  java: [".java"]
 };
-function extractGoImportPath(spec) {
-  const pathNode = spec.childForFieldName("path") ?? spec.children.find((c) => c.type === "interpreted_string_literal");
-  return pathNode ? pathNode.text.replace(/"/g, "") : null;
-}
-function extractGoImportsFromDecl(child) {
-  const imports = [];
-  for (const spec of child.children.filter((c) => c.type === "import_spec")) {
-    const source = extractGoImportPath(spec);
-    if (source) imports.push(makeImport(child, source));
-  }
-  const specList = child.children.find((c) => c.type === "import_spec_list");
-  if (specList) {
-    for (const spec of specList.children.filter((c) => c.type === "import_spec")) {
-      const source = extractGoImportPath(spec);
-      if (source) imports.push(makeImport(spec, source));
-    }
-  }
-  return imports;
-}
-function isGoExported(name) {
-  return /^[A-Z]/.test(name);
-}
-function extractGoExport(child) {
-  if (child.type === "function_declaration" || child.type === "method_declaration") {
-    const name = child.childForFieldName("name");
-    if (name && isGoExported(name.text)) return makeNamedExport(child);
-  }
-  if (child.type === "type_declaration") {
-    const typeSpec = child.children.find((c) => c.type === "type_spec");
-    if (typeSpec) {
-      const name = typeSpec.childForFieldName("name");
-      if (name && isGoExported(name.text)) {
-        return { name: name.text, type: "named", location: makeLocation2(child), isReExport: false };
-      }
-    }
+var JS_EXT_FALLBACKS = {
+  ".js": [".ts", ".tsx", ".jsx"],
+  ".jsx": [".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"]
+};
+function detectLangFromExt(ext) {
+  for (const [lang, exts] of Object.entries(EXTENSION_BY_LANG)) {
+    if (exts.includes(ext)) return lang;
   }
   return null;
 }
-var goStrategy = {
-  extractImports(root) {
-    const imports = [];
-    for (const child of root.children) {
-      if (child.type === "import_declaration") imports.push(...extractGoImportsFromDecl(child));
-    }
-    return imports;
-  },
-  extractExports(root) {
-    const exports = [];
-    for (const child of root.children) {
-      const exp = extractGoExport(child);
-      if (exp) exports.push(exp);
-    }
-    return exports;
-  }
-};
-var RUST_USE_ARG_TYPES = /* @__PURE__ */ new Set([
-  "scoped_identifier",
-  "use_wildcard",
-  "scoped_use_list",
-  "identifier"
-]);
-var RUST_PUB_ITEM_TYPES = /* @__PURE__ */ new Set([
-  "function_item",
-  "struct_item",
-  "enum_item",
-  "trait_item",
-  "type_item",
-  "const_item",
-  "static_item"
-]);
-var rustStrategy = {
-  extractImports(root) {
-    const imports = [];
-    for (const child of root.children) {
-      if (child.type !== "use_declaration") continue;
-      const arg = child.childForFieldName("argument") ?? child.children.find((c) => RUST_USE_ARG_TYPES.has(c.type));
-      if (arg) imports.push(makeImport(child, arg.text));
-    }
-    return imports;
-  },
-  extractExports(root, source) {
-    const exports = [];
-    const lines = source.split("\n");
-    for (const child of root.children) {
-      const line = lines[child.startPosition.row] ?? "";
-      if (!/^\s*pub\b/.test(line)) continue;
-      if (RUST_PUB_ITEM_TYPES.has(child.type)) {
-        const exp = makeNamedExport(child);
-        if (exp) exports.push(exp);
-      } else if (child.type === "mod_item") {
-        const name = child.childForFieldName("name");
-        if (name) {
-          exports.push({
-            name: name.text,
-            type: "namespace",
-            location: makeLocation2(child),
-            isReExport: false
-          });
-        }
-      }
-    }
-    return exports;
-  }
-};
-var JAVA_IMPORT_TYPES = /* @__PURE__ */ new Set(["scoped_identifier", "scoped_absolute_identifier"]);
-var JAVA_EXPORT_TYPES = /* @__PURE__ */ new Set([
-  "class_declaration",
-  "interface_declaration",
-  "enum_declaration",
-  "record_declaration"
-]);
-var javaStrategy = {
-  extractImports(root) {
-    const imports = [];
-    for (const child of root.children) {
-      if (child.type !== "import_declaration") continue;
-      const scoped = child.children.find((c) => JAVA_IMPORT_TYPES.has(c.type));
-      if (scoped) imports.push(makeImport(child, scoped.text));
-    }
-    return imports;
-  },
-  extractExports(root, source) {
-    const exports = [];
-    const lines = source.split("\n");
-    for (const child of root.children) {
-      if (!JAVA_EXPORT_TYPES.has(child.type)) continue;
-      const line = lines[child.startPosition.row] ?? "";
-      if (!/\bpublic\b/.test(line)) continue;
-      const exp = makeNamedExport(child);
-      if (exp) exports.push(exp);
-    }
-    return exports;
+function getExtensionsForLang(lang) {
+  switch (lang) {
+    case "typescript":
+      return [".ts", ".tsx"];
+    case "javascript":
+      return [".js", ".jsx", ".mjs", ".cjs"];
+    case "python":
+      return [".py"];
+    case "go":
+      return [".go"];
+    case "rust":
+      return [".rs"];
+    case "java":
+      return [".java"];
+    default:
+      return [".ts", ".tsx", ".js", ".jsx"];
   }
-};
-var STRATEGIES = {
-  python: pythonStrategy,
-  go: goStrategy,
-  rust: rustStrategy,
-  java: javaStrategy
-};
-var TreeSitterParser = class {
-  name;
-  extensions;
-  lang;
-  strategy;
-  constructor(lang, extensions, strategy) {
-    this.name = lang;
-    this.lang = lang;
-    this.extensions = extensions;
-    this.strategy = strategy;
+}
+async function resolveImportPath(importSource, fromFile, _rootDir) {
+  if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
+    return null;
   }
-  async parseFile(path) {
-    const contentResult = await readFileContent(path);
-    if (!contentResult.ok) {
-      return Err(
-        createParseError("NOT_FOUND", `File not found: ${path}`, { path }, [
-          "Check that the file exists"
-        ])
-      );
-    }
-    try {
-      const parser = await getParser(this.lang);
-      const tree = parser.parse(contentResult.value);
-      return Ok({
-        type: "Program",
-        body: { tree, source: contentResult.value },
-        language: this.lang
-      });
-    } catch (e) {
-      const error = e;
-      return Err(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path}: ${error.message}`, { path }, [
-          "Check for syntax errors in the file"
-        ])
-      );
+  const fromDir = dirname(fromFile);
+  const resolved = resolve(fromDir, importSource);
+  const sourceExt = extname(resolved);
+  const fromLang = detectLangFromExt(extname(fromFile));
+  const fallbacks = JS_EXT_FALLBACKS[sourceExt];
+  if (fallbacks) {
+    const base = resolved.slice(0, -sourceExt.length);
+    for (const ext of fallbacks) {
+      const candidate = base + ext;
+      if (await fileExists(candidate)) return candidate.replace(/\\/g, "/");
     }
-  }
-  extractImports(ast) {
-    const { tree, source } = ast.body;
-    return Ok(this.strategy.extractImports(tree.rootNode, source));
-  }
-  extractExports(ast) {
-    const { tree, source } = ast.body;
-    return Ok(this.strategy.extractExports(tree.rootNode, source));
-  }
-  async health() {
-    try {
-      await getParser(this.lang);
-      return Ok({ available: true, message: `tree-sitter ${this.lang} grammar loaded` });
-    } catch {
-      return Ok({ available: false, message: `tree-sitter ${this.lang} grammar not available` });
+    for (const indexExt of [".ts", ".tsx", ".jsx"]) {
+      const indexPath = resolve(base, "index" + indexExt);
+      if (await fileExists(indexPath)) return indexPath.replace(/\\/g, "/");
     }
   }
-  outline(filePath, ast) {
-    const { tree, source } = ast.body;
-    return extractOutlineFromTree(tree.rootNode, this.lang, source, filePath);
-  }
-  unfold(filePath, ast, symbolName) {
-    const outlineResult = this.outline(filePath, ast);
-    if (outlineResult.error || !outlineResult.symbols.length) return null;
-    const { source } = ast.body;
-    const match = findSymbolByName(outlineResult.symbols, symbolName);
-    if (!match) return null;
-    const lines = source.split("\n");
-    const content = lines.slice(match.line - 1, match.endLine).join("\n");
-    return {
-      file: filePath,
-      symbolName,
-      startLine: match.line,
-      endLine: match.endLine,
-      content,
-      language: this.lang,
-      fallback: false
-    };
-  }
-};
-function createTreeSitterParser(lang) {
-  const strategy = STRATEGIES[lang];
-  if (!strategy) return null;
-  const extensionMap = {
-    python: [".py"],
-    go: [".go"],
-    rust: [".rs"],
-    java: [".java"]
-  };
-  const extensions = extensionMap[lang];
-  if (!extensions) return null;
-  return new TreeSitterParser(lang, extensions, strategy);
-}
-
-// src/shared/parsers/registry.ts
-var ParserRegistry = class {
-  parsers = /* @__PURE__ */ new Map();
-  register(parser) {
-    this.parsers.set(parser.name, parser);
-  }
-  getByLanguage(lang) {
-    return this.parsers.get(lang) ?? null;
-  }
-  getForFile(filePath) {
-    const lang = detectLanguage(filePath);
-    if (!lang) return null;
-    return this.getByLanguage(lang);
-  }
-  getSupportedExtensions() {
-    return Object.keys(EXTENSION_MAP);
-  }
-  getSupportedLanguages() {
-    return Array.from(this.parsers.keys());
-  }
-  isSupportedExtension(ext) {
-    return ext in EXTENSION_MAP;
-  }
-};
-var defaultRegistry = null;
-function getDefaultRegistry() {
-  if (defaultRegistry) return defaultRegistry;
-  const registry = new ParserRegistry();
-  const tsParser = new TypeScriptParser();
-  registry.register(tsParser);
-  registry.register({
-    name: "javascript",
-    extensions: [".js", ".jsx", ".mjs", ".cjs"],
-    parseFile: tsParser.parseFile.bind(tsParser),
-    extractImports: tsParser.extractImports.bind(tsParser),
-    extractExports: tsParser.extractExports.bind(tsParser),
-    health: tsParser.health.bind(tsParser)
-  });
-  const treeSitterLanguages = ["python", "go", "rust", "java"];
-  for (const lang of treeSitterLanguages) {
-    const parser = createTreeSitterParser(lang);
-    if (parser) {
-      registry.register(parser);
-    }
+  const hasKnownExt = Object.values(EXTENSION_BY_LANG).flat().some((e) => resolved.endsWith(e));
+  if (hasKnownExt) {
+    return resolved.replace(/\\/g, "/");
   }
-  defaultRegistry = registry;
-  return registry;
+  const extensions = getExtensionsForLang(fromLang);
+  return (resolved + extensions[0]).replace(/\\/g, "/");
 }
-
-// src/architecture/collectors/layer-violations.ts
-function mapLayerViolations(layerViolations, rootDir, category) {
-  return layerViolations.map((v) => {
-    const relFile = relativePosix(rootDir, v.file);
-    const relImport = relativePosix(rootDir, v.imports);
-    const detail = `${v.fromLayer} -> ${v.toLayer}: ${relFile} imports ${relImport}`;
-    return {
-      id: violationId(relFile, category ?? "", detail),
-      file: relFile,
-      category,
-      detail,
-      severity: "error"
-    };
-  });
+function getImportType(imp) {
+  if (imp.kind === "type") return "type-only";
+  return "static";
 }
-var LayerViolationCollector = class {
-  category = "layer-violations";
-  getRules(_config, _rootDir) {
-    const description = "No layer boundary violations allowed";
-    return [
-      {
-        id: constraintRuleId(this.category, "project", description),
-        category: this.category,
-        description,
-        scope: "project"
-      }
-    ];
-  }
-  async collect(_config, rootDir) {
-    const registry = getDefaultRegistry();
-    const parser = registry.getByLanguage("typescript") ?? registry.getByLanguage("javascript");
-    const result = await validateDependencies({
-      layers: [],
-      rootDir,
-      parser,
-      fallbackBehavior: "skip"
+async function buildDependencyGraph(files, parser, graphDependencyData) {
+  if (graphDependencyData) {
+    return Ok({
+      nodes: graphDependencyData.nodes,
+      edges: graphDependencyData.edges
     });
-    if (!result.ok) {
-      return [
-        {
-          category: this.category,
-          scope: "project",
-          value: 0,
-          violations: [],
-          metadata: { error: "Failed to validate dependencies" }
-        }
-      ];
-    }
-    const violations = mapLayerViolations(
-      result.value.violations.filter((v) => v.reason === "WRONG_LAYER"),
-      rootDir,
-      this.category
-    );
-    return [{ category: this.category, scope: "project", value: violations.length, violations }];
   }
-};
-
-// src/architecture/baseline-manager.ts
-import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from "fs";
-import { randomBytes } from "crypto";
-import { join, dirname as dirname2 } from "path";
-var ArchBaselineManager = class {
-  baselinesPath;
-  constructor(projectRoot, baselinePath) {
-    this.baselinesPath = baselinePath ? join(projectRoot, baselinePath) : join(projectRoot, ".harness", "arch", "baselines.json");
-  }
-  /**
-   * Snapshot the current metric results into an ArchBaseline.
-   * Aggregates multiple MetricResults for the same category by summing values
-   * and concatenating violation IDs.
-   */
-  capture(results, commitHash) {
-    const metrics = {};
-    for (const result of results) {
-      const existing = metrics[result.category];
-      if (existing) {
-        existing.value += result.value;
-        existing.violationIds.push(...result.violations.map((v) => v.id));
-      } else {
-        metrics[result.category] = {
-          value: result.value,
-          violationIds: result.violations.map((v) => v.id)
-        };
-      }
-    }
-    for (const baseline of Object.values(metrics)) {
-      baseline.violationIds = [...new Set(baseline.violationIds)];
+  const isLookup = "getForFile" in parser;
+  const nodes = files.map((f) => f.replace(/\\/g, "/"));
+  const edges = [];
+  for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
+    const fileParser = isLookup ? parser.getForFile(file) : parser;
+    if (!fileParser) continue;
+    const parseResult = await fileParser.parseFile(file);
+    if (!parseResult.ok) {
+      continue;
     }
-    return {
-      version: 1,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedFrom: commitHash,
-      metrics
-    };
-  }
-  /**
-   * Load the baselines file from disk.
-   * Returns null if the file does not exist, contains invalid JSON,
-   * or fails ArchBaselineSchema validation.
-   */
-  load() {
-    if (!existsSync(this.baselinesPath)) {
-      console.error(`Baseline file not found at: ${this.baselinesPath}`);
-      return null;
+    const importsResult = fileParser.extractImports(parseResult.value);
+    if (!importsResult.ok) {
+      continue;
     }
-    try {
-      const raw = readFileSync(this.baselinesPath, "utf-8");
-      const data = JSON.parse(raw);
-      const parsed = ArchBaselineSchema.safeParse(data);
-      if (!parsed.success) {
-        console.error(
-          `Baseline validation failed for ${this.baselinesPath}:`,
-          parsed.error.format()
-        );
-        return null;
+    for (const imp of importsResult.value) {
+      const resolvedPath = await resolveImportPath(imp.source, file, "");
+      if (resolvedPath) {
+        edges.push({
+          from: normalizedFile,
+          to: resolvedPath,
+          importType: getImportType(imp),
+          line: imp.location.line
+        });
       }
-      return parsed.data;
-    } catch (error) {
-      console.error(`Error loading baseline from ${this.baselinesPath}:`, error);
-      return null;
     }
   }
-  /**
-   * Refresh the on-disk baseline with new results.
-   *
-   * Categories present in `results` overwrite their on-disk entry; categories
-   * absent from `results` are preserved as-is. This prevents silent data loss
-   * when a collector returns no results (e.g. transient failure or a filtered
-   * run) and the regenerated file is committed (issue #268).
-   *
-   * Use this from the `--update-baseline` flow instead of `capture()` + `save()`.
-   */
-  update(results, commitHash) {
-    const fresh = this.capture(results, commitHash);
-    const existing = this.load();
-    if (existing) {
-      fresh.metrics = { ...existing.metrics, ...fresh.metrics };
+  return Ok({ nodes, edges });
+}
+function checkLayerViolations(graph, layers, rootDir) {
+  const violations = [];
+  for (const edge of graph.edges) {
+    const fromRelative = relativePosix(rootDir, edge.from);
+    const toRelative = relativePosix(rootDir, edge.to);
+    const fromLayer = resolveFileToLayer(fromRelative, layers);
+    const toLayer = resolveFileToLayer(toRelative, layers);
+    if (!fromLayer || !toLayer) continue;
+    if (fromLayer.name === toLayer.name) continue;
+    if (!fromLayer.allowedDependencies.includes(toLayer.name)) {
+      violations.push({
+        file: edge.from,
+        imports: edge.to,
+        fromLayer: fromLayer.name,
+        toLayer: toLayer.name,
+        reason: "WRONG_LAYER",
+        line: edge.line,
+        suggestion: `Move the dependency to an allowed layer (${fromLayer.allowedDependencies.join(", ") || "none"}) or update layer rules`
+      });
     }
-    this.save(fresh);
-    return fresh;
-  }
-  /**
-   * Save an ArchBaseline to disk.
-   * Creates parent directories if they do not exist.
-   * Uses atomic write (write to temp file, then rename) to prevent corruption.
-   */
-  save(baseline) {
-    const dir = dirname2(this.baselinesPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+  }
+  return violations;
+}
+async function validateDependencies(config) {
+  const { layers, rootDir, parser, fallbackBehavior = "error", graphDependencyData } = config;
+  if (graphDependencyData) {
+    const graphResult2 = await buildDependencyGraph([], parser, graphDependencyData);
+    if (!graphResult2.ok) {
+      return Err(graphResult2.error);
     }
-    const tmp = this.baselinesPath + "." + randomBytes(4).toString("hex") + ".tmp";
-    writeFileSync(tmp, JSON.stringify(baseline, null, 2));
-    renameSync(tmp, this.baselinesPath);
+    const violations2 = checkLayerViolations(graphResult2.value, layers, rootDir);
+    return Ok({
+      valid: violations2.length === 0,
+      violations: violations2,
+      graph: graphResult2.value
+    });
   }
-};
-
-// src/architecture/diff.ts
-function aggregateByCategory(results) {
-  const map = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    const existing = map.get(result.category);
-    if (existing) {
-      existing.value += result.value;
-      existing.violations.push(...result.violations);
-    } else {
-      map.set(result.category, {
-        value: result.value,
-        violations: [...result.violations]
+  const healthResult = await parser.health();
+  if (!healthResult.ok || !healthResult.value.available) {
+    if (fallbackBehavior === "skip") {
+      return Ok({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
       });
     }
-  }
-  return map;
-}
-function classifyViolations(violations, baselineViolationIds) {
-  const newViolations = [];
-  const preExisting = [];
-  for (const violation of violations) {
-    if (baselineViolationIds.has(violation.id)) {
-      preExisting.push(violation.id);
-    } else {
-      newViolations.push(violation);
+    if (fallbackBehavior === "warn") {
+      console.warn(`Parser ${parser.name} unavailable, skipping validation`);
+      return Ok({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
+      });
     }
+    return Err(
+      createError(
+        "PARSER_UNAVAILABLE",
+        `Parser ${parser.name} is not available`,
+        { parser: parser.name },
+        ["Install required runtime", "Use different parser", 'Set fallbackBehavior: "skip"']
+      )
+    );
   }
-  return { newViolations, preExisting };
-}
-function findResolvedViolations(baselineCategory, currentViolationIds) {
-  if (!baselineCategory) return [];
-  return baselineCategory.violationIds.filter((id) => !currentViolationIds.has(id));
-}
-function collectOrphanedBaselineViolations(baseline, visitedCategories) {
-  const resolved = [];
-  for (const [category, baselineCategory] of Object.entries(baseline.metrics)) {
-    if (!visitedCategories.has(category) && baselineCategory) {
-      resolved.push(...baselineCategory.violationIds);
+  const allFiles = [];
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      const files = await findFiles(pattern, rootDir);
+      allFiles.push(...files);
     }
   }
-  return resolved;
-}
-function diffCategory(category, agg, baselineCategory, acc) {
-  const baselineViolationIds = new Set(baselineCategory?.violationIds ?? []);
-  const baselineValue = baselineCategory?.value ?? 0;
-  const classified = classifyViolations(agg.violations, baselineViolationIds);
-  acc.newViolations.push(...classified.newViolations);
-  acc.preExisting.push(...classified.preExisting);
-  const currentViolationIds = new Set(agg.violations.map((v) => v.id));
-  acc.resolvedViolations.push(...findResolvedViolations(baselineCategory, currentViolationIds));
-  if (baselineCategory && agg.value > baselineValue) {
-    acc.regressions.push({
-      category,
-      baselineValue,
-      currentValue: agg.value,
-      delta: agg.value - baselineValue
-    });
-  }
-}
-function diff(current, baseline) {
-  const aggregated = aggregateByCategory(current);
-  const acc = {
-    newViolations: [],
-    resolvedViolations: [],
-    preExisting: [],
-    regressions: []
-  };
-  const visitedCategories = /* @__PURE__ */ new Set();
-  for (const [category, agg] of aggregated) {
-    visitedCategories.add(category);
-    diffCategory(category, agg, baseline.metrics[category], acc);
+  const uniqueFiles = [...new Set(allFiles)];
+  const graphResult = await buildDependencyGraph(uniqueFiles, parser);
+  if (!graphResult.ok) {
+    return Err(graphResult.error);
   }
-  acc.resolvedViolations.push(...collectOrphanedBaselineViolations(baseline, visitedCategories));
-  return {
-    passed: acc.newViolations.length === 0 && acc.regressions.length === 0,
-    newViolations: acc.newViolations,
-    resolvedViolations: acc.resolvedViolations,
-    preExisting: acc.preExisting,
-    regressions: acc.regressions
-  };
+  const violations = checkLayerViolations(graphResult.value, layers, rootDir);
+  return Ok({
+    valid: violations.length === 0,
+    violations,
+    graph: graphResult.value
+  });
 }
 
 // src/entropy/detectors/complexity.ts
@@ -1985,94 +1085,6 @@ async function detectComplexityViolations(snapshot, config, graphData) {
   });
 }
 
-// src/architecture/collectors/complexity.ts
-function buildSnapshot(files, rootDir) {
-  return {
-    files: files.map((f) => ({
-      path: f,
-      ast: { type: "Program", body: null, language: "typescript" },
-      imports: [],
-      exports: [],
-      internalSymbols: [],
-      jsDocComments: []
-    })),
-    dependencyGraph: { nodes: [], edges: [] },
-    exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
-    docs: [],
-    codeReferences: [],
-    entryPoints: [],
-    rootDir,
-    config: { rootDir, analyze: {} },
-    buildTime: 0
-  };
-}
-function resolveMaxComplexity(config) {
-  const threshold = config.thresholds.complexity;
-  return typeof threshold === "number" ? threshold : threshold?.max ?? 15;
-}
-function mapComplexityViolations(complexityViolations, rootDir, category) {
-  return complexityViolations.filter((v) => v.severity === "error" || v.severity === "warning").map((v) => {
-    const relFile = relativePosix(rootDir, v.file);
-    return {
-      id: violationId(relFile, category ?? "", `${v.metric}:${v.function}`),
-      file: relFile,
-      category,
-      detail: `${v.metric}=${v.value} in ${v.function} (threshold: ${v.threshold})`,
-      severity: v.severity
-    };
-  });
-}
-var ComplexityCollector = class {
-  category = "complexity";
-  getRules(_config, _rootDir) {
-    const description = "Cyclomatic complexity must stay within thresholds";
-    return [
-      {
-        id: constraintRuleId(this.category, "project", description),
-        category: this.category,
-        description,
-        scope: "project"
-      }
-    ];
-  }
-  async collect(_config, rootDir) {
-    const files = await findFiles("**/*.ts", rootDir);
-    const snapshot = buildSnapshot(files, rootDir);
-    const maxComplexity = resolveMaxComplexity(_config);
-    const complexityConfig = {
-      thresholds: {
-        cyclomaticComplexity: { error: maxComplexity, warn: Math.floor(maxComplexity * 0.7) }
-      }
-    };
-    const result = await detectComplexityViolations(snapshot, complexityConfig);
-    if (!result.ok) {
-      return [
-        {
-          category: this.category,
-          scope: "project",
-          value: 0,
-          violations: [],
-          metadata: { error: "Failed to detect complexity violations" }
-        }
-      ];
-    }
-    const { violations: complexityViolations, stats } = result.value;
-    const violations = mapComplexityViolations(complexityViolations, rootDir, this.category);
-    return [
-      {
-        category: this.category,
-        scope: "project",
-        value: violations.length,
-        violations,
-        metadata: {
-          filesAnalyzed: stats.filesAnalyzed,
-          functionsAnalyzed: stats.functionsAnalyzed
-        }
-      }
-    ];
-  }
-};
-
 // src/entropy/detectors/coupling.ts
 var DEFAULT_THRESHOLDS2 = {
   fanOut: { warn: 15 },
@@ -2240,633 +1252,368 @@ async function detectCouplingViolations(snapshot, config, graphData) {
   });
 }
 
-// src/architecture/collectors/coupling.ts
-function buildCouplingSnapshot(files, rootDir) {
+// src/shared/parsers/tree-sitter.ts
+function findSymbolByName(symbols, name) {
+  for (const sym of symbols) {
+    if (sym.name === name) return { line: sym.line, endLine: sym.endLine };
+    if (sym.children) {
+      const found = findSymbolByName(sym.children, name);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function makeLocation2(node) {
   return {
-    files: files.map((f) => ({
-      path: f,
-      ast: { type: "Program", body: null, language: "typescript" },
-      imports: [],
-      exports: [],
-      internalSymbols: [],
-      jsDocComments: []
-    })),
-    dependencyGraph: { nodes: [], edges: [] },
-    exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
-    docs: [],
-    codeReferences: [],
-    entryPoints: [],
-    rootDir,
-    config: { rootDir, analyze: {} },
-    buildTime: 0
+    file: "",
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column
   };
 }
-function mapCouplingViolations(couplingViolations, rootDir, category) {
-  return couplingViolations.filter((v) => v.severity === "error" || v.severity === "warning").map((v) => {
-    const relFile = relativePosix(rootDir, v.file);
-    return {
-      id: violationId(relFile, category ?? "", v.metric),
-      file: relFile,
-      category,
-      detail: `${v.metric}=${v.value} (threshold: ${v.threshold})`,
-      severity: v.severity
-    };
-  });
+function makeNamedExport(node) {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return { name: name.text, type: "named", location: makeLocation2(node), isReExport: false };
 }
-var CouplingCollector = class {
-  category = "coupling";
-  getRules(_config, _rootDir) {
-    const description = "Coupling metrics must stay within thresholds";
-    return [
-      {
-        id: constraintRuleId(this.category, "project", description),
-        category: this.category,
-        description,
-        scope: "project"
-      }
-    ];
-  }
-  async collect(_config, rootDir) {
-    const files = await findFiles("**/*.ts", rootDir);
-    const snapshot = buildCouplingSnapshot(files, rootDir);
-    const result = await detectCouplingViolations(snapshot);
-    if (!result.ok) {
-      return [
-        {
-          category: this.category,
-          scope: "project",
-          value: 0,
-          violations: [],
-          metadata: { error: "Failed to detect coupling violations" }
-        }
-      ];
+function makeImport(node, source) {
+  return { source, specifiers: [], location: makeLocation2(node), kind: "value" };
+}
+function extractPythonImport(child) {
+  const name = child.childForFieldName("name");
+  if (!name) return null;
+  return makeImport(child, name.text);
+}
+function extractPythonFromImport(child) {
+  const moduleName = child.childForFieldName("module_name");
+  const specifiers = [];
+  for (const c of child.children) {
+    if (c.type === "dotted_name" && c !== moduleName) specifiers.push(c.text);
+    if (c.type === "aliased_import") {
+      const n = c.childForFieldName("name");
+      if (n) specifiers.push(n.text);
+    }
+  }
+  return {
+    source: moduleName?.text ?? "",
+    specifiers,
+    location: makeLocation2(child),
+    kind: "value"
+  };
+}
+function extractPythonExport(child) {
+  if (child.type === "function_definition" || child.type === "class_definition") {
+    return makeNamedExport(child);
+  }
+  if (child.type === "assignment") {
+    const left = child.childForFieldName("left") ?? child.children[0];
+    if (left && !left.text.startsWith("_")) {
+      return { name: left.text, type: "named", location: makeLocation2(child), isReExport: false };
     }
-    const { violations: couplingViolations, stats } = result.value;
-    const violations = mapCouplingViolations(couplingViolations, rootDir, this.category);
-    return [
-      {
-        category: this.category,
-        scope: "project",
-        value: violations.length,
-        violations,
-        metadata: { filesAnalyzed: stats.filesAnalyzed }
+  }
+  return null;
+}
+var pythonStrategy = {
+  extractImports(root) {
+    const imports = [];
+    for (const child of root.children) {
+      if (child.type === "import_statement") {
+        const imp = extractPythonImport(child);
+        if (imp) imports.push(imp);
+      } else if (child.type === "import_from_statement") {
+        imports.push(extractPythonFromImport(child));
       }
-    ];
+    }
+    return imports;
+  },
+  extractExports(root) {
+    const exports = [];
+    for (const child of root.children) {
+      const exp = extractPythonExport(child);
+      if (exp) exports.push(exp);
+    }
+    return exports;
   }
 };
-
-// src/architecture/collectors/forbidden-imports.ts
-function mapForbiddenImportViolations(forbidden, rootDir, category) {
-  return forbidden.map((v) => {
-    const relFile = relativePosix(rootDir, v.file);
-    const relImport = relativePosix(rootDir, v.imports);
-    const detail = `forbidden import: ${relFile} -> ${relImport}`;
-    return {
-      id: violationId(relFile, category ?? "", detail),
-      file: relFile,
-      category,
-      detail,
-      severity: "error"
-    };
-  });
+function extractGoImportPath(spec) {
+  const pathNode = spec.childForFieldName("path") ?? spec.children.find((c) => c.type === "interpreted_string_literal");
+  return pathNode ? pathNode.text.replace(/"/g, "") : null;
+}
+function extractGoImportsFromDecl(child) {
+  const imports = [];
+  for (const spec of child.children.filter((c) => c.type === "import_spec")) {
+    const source = extractGoImportPath(spec);
+    if (source) imports.push(makeImport(child, source));
+  }
+  const specList = child.children.find((c) => c.type === "import_spec_list");
+  if (specList) {
+    for (const spec of specList.children.filter((c) => c.type === "import_spec")) {
+      const source = extractGoImportPath(spec);
+      if (source) imports.push(makeImport(spec, source));
+    }
+  }
+  return imports;
+}
+function isGoExported(name) {
+  return /^[A-Z]/.test(name);
 }
-var ForbiddenImportCollector = class {
-  category = "forbidden-imports";
-  getRules(_config, _rootDir) {
-    const description = "No forbidden imports allowed";
-    return [
-      {
-        id: constraintRuleId(this.category, "project", description),
-        category: this.category,
-        description,
-        scope: "project"
+function extractGoExport(child) {
+  if (child.type === "function_declaration" || child.type === "method_declaration") {
+    const name = child.childForFieldName("name");
+    if (name && isGoExported(name.text)) return makeNamedExport(child);
+  }
+  if (child.type === "type_declaration") {
+    const typeSpec = child.children.find((c) => c.type === "type_spec");
+    if (typeSpec) {
+      const name = typeSpec.childForFieldName("name");
+      if (name && isGoExported(name.text)) {
+        return { name: name.text, type: "named", location: makeLocation2(child), isReExport: false };
       }
-    ];
-  }
-  async collect(_config, rootDir) {
-    const registry = getDefaultRegistry();
-    const parser = registry.getByLanguage("typescript") ?? registry.getByLanguage("javascript");
-    const result = await validateDependencies({
-      layers: [],
-      rootDir,
-      parser,
-      fallbackBehavior: "skip"
-    });
-    if (!result.ok) {
-      return [
-        {
-          category: this.category,
-          scope: "project",
-          value: 0,
-          violations: [],
-          metadata: { error: "Failed to validate dependencies" }
+    }
+  }
+  return null;
+}
+var goStrategy = {
+  extractImports(root) {
+    const imports = [];
+    for (const child of root.children) {
+      if (child.type === "import_declaration") imports.push(...extractGoImportsFromDecl(child));
+    }
+    return imports;
+  },
+  extractExports(root) {
+    const exports = [];
+    for (const child of root.children) {
+      const exp = extractGoExport(child);
+      if (exp) exports.push(exp);
+    }
+    return exports;
+  }
+};
+var RUST_USE_ARG_TYPES = /* @__PURE__ */ new Set([
+  "scoped_identifier",
+  "use_wildcard",
+  "scoped_use_list",
+  "identifier"
+]);
+var RUST_PUB_ITEM_TYPES = /* @__PURE__ */ new Set([
+  "function_item",
+  "struct_item",
+  "enum_item",
+  "trait_item",
+  "type_item",
+  "const_item",
+  "static_item"
+]);
+var rustStrategy = {
+  extractImports(root) {
+    const imports = [];
+    for (const child of root.children) {
+      if (child.type !== "use_declaration") continue;
+      const arg = child.childForFieldName("argument") ?? child.children.find((c) => RUST_USE_ARG_TYPES.has(c.type));
+      if (arg) imports.push(makeImport(child, arg.text));
+    }
+    return imports;
+  },
+  extractExports(root, source) {
+    const exports = [];
+    const lines = source.split("\n");
+    for (const child of root.children) {
+      const line = lines[child.startPosition.row] ?? "";
+      if (!/^\s*pub\b/.test(line)) continue;
+      if (RUST_PUB_ITEM_TYPES.has(child.type)) {
+        const exp = makeNamedExport(child);
+        if (exp) exports.push(exp);
+      } else if (child.type === "mod_item") {
+        const name = child.childForFieldName("name");
+        if (name) {
+          exports.push({
+            name: name.text,
+            type: "namespace",
+            location: makeLocation2(child),
+            isReExport: false
+          });
         }
-      ];
+      }
     }
-    const violations = mapForbiddenImportViolations(
-      result.value.violations.filter((v) => v.reason === "FORBIDDEN_IMPORT"),
-      rootDir,
-      this.category
-    );
-    return [{ category: this.category, scope: "project", value: violations.length, violations }];
+    return exports;
   }
 };
-
-// src/architecture/collectors/module-size.ts
-import { readFile as readFile3, readdir } from "fs/promises";
-import { join as join2 } from "path";
-import { DEFAULT_SKIP_DIRS } from "@harness-engineering/graph";
-function isSkippedEntry(name) {
-  return name.startsWith(".") || DEFAULT_SKIP_DIRS.has(name);
-}
-function isTsSourceFile(name) {
-  if (!name.endsWith(".ts") && !name.endsWith(".tsx")) return false;
-  if (name.endsWith(".test.ts") || name.endsWith(".test.tsx") || name.endsWith(".spec.ts"))
-    return false;
-  return true;
-}
-async function countLoc(filePath) {
-  try {
-    const content = await readFile3(filePath, "utf-8");
-    return content.split("\n").filter((line) => line.trim().length > 0).length;
-  } catch {
-    return 0;
-  }
-}
-async function buildModuleStats(rootDir, dir, tsFiles) {
-  let totalLoc = 0;
-  for (const f of tsFiles) {
-    totalLoc += await countLoc(f);
-  }
-  return {
-    modulePath: relativePosix(rootDir, dir),
-    fileCount: tsFiles.length,
-    totalLoc,
-    files: tsFiles.map((f) => relativePosix(rootDir, f))
-  };
-}
-async function scanDir(rootDir, dir, modules) {
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  const tsFiles = [];
-  const subdirs = [];
-  for (const entry of entries) {
-    if (isSkippedEntry(entry.name)) continue;
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      subdirs.push(fullPath);
-      continue;
+var JAVA_IMPORT_TYPES = /* @__PURE__ */ new Set(["scoped_identifier", "scoped_absolute_identifier"]);
+var JAVA_EXPORT_TYPES = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "interface_declaration",
+  "enum_declaration",
+  "record_declaration"
+]);
+var javaStrategy = {
+  extractImports(root) {
+    const imports = [];
+    for (const child of root.children) {
+      if (child.type !== "import_declaration") continue;
+      const scoped = child.children.find((c) => JAVA_IMPORT_TYPES.has(c.type));
+      if (scoped) imports.push(makeImport(child, scoped.text));
     }
-    if (entry.isFile() && isTsSourceFile(entry.name)) {
-      tsFiles.push(fullPath);
+    return imports;
+  },
+  extractExports(root, source) {
+    const exports = [];
+    const lines = source.split("\n");
+    for (const child of root.children) {
+      if (!JAVA_EXPORT_TYPES.has(child.type)) continue;
+      const line = lines[child.startPosition.row] ?? "";
+      if (!/\bpublic\b/.test(line)) continue;
+      const exp = makeNamedExport(child);
+      if (exp) exports.push(exp);
     }
+    return exports;
   }
-  if (tsFiles.length > 0) {
-    modules.push(await buildModuleStats(rootDir, dir, tsFiles));
-  }
-  for (const sub of subdirs) {
-    await scanDir(rootDir, sub, modules);
-  }
-}
-async function discoverModules(rootDir) {
-  const modules = [];
-  await scanDir(rootDir, rootDir, modules);
-  return modules;
-}
-function extractThresholds(config) {
-  const thresholds = config.thresholds["module-size"];
-  let maxLoc = Infinity;
-  let maxFiles = Infinity;
-  if (typeof thresholds === "object" && thresholds !== null) {
-    const t = thresholds;
-    if (t.maxLoc !== void 0) maxLoc = t.maxLoc;
-    if (t.maxFiles !== void 0) maxFiles = t.maxFiles;
-  }
-  return { maxLoc, maxFiles };
-}
-var ModuleSizeCollector = class {
-  category = "module-size";
-  getRules(config, _rootDir) {
-    const { maxLoc, maxFiles } = extractThresholds(config);
-    const rules = [];
-    if (maxLoc < Infinity) {
-      const desc = `Module LOC must not exceed ${maxLoc}`;
-      rules.push({
-        id: constraintRuleId(this.category, "project", desc),
-        category: this.category,
-        description: desc,
-        scope: "project"
-      });
-    }
-    if (maxFiles < Infinity) {
-      const desc = `Module file count must not exceed ${maxFiles}`;
-      rules.push({
-        id: constraintRuleId(this.category, "project", desc),
-        category: this.category,
-        description: desc,
-        scope: "project"
-      });
+};
+var STRATEGIES = {
+  python: pythonStrategy,
+  go: goStrategy,
+  rust: rustStrategy,
+  java: javaStrategy
+};
+var TreeSitterParser = class {
+  name;
+  extensions;
+  lang;
+  strategy;
+  constructor(lang, extensions, strategy) {
+    this.name = lang;
+    this.lang = lang;
+    this.extensions = extensions;
+    this.strategy = strategy;
+  }
+  async parseFile(path) {
+    const contentResult = await readFileContent(path);
+    if (!contentResult.ok) {
+      return Err(
+        createParseError("NOT_FOUND", `File not found: ${path}`, { path }, [
+          "Check that the file exists"
+        ])
+      );
     }
-    if (rules.length === 0) {
-      const desc = "Module size must stay within thresholds";
-      rules.push({
-        id: constraintRuleId(this.category, "project", desc),
-        category: this.category,
-        description: desc,
-        scope: "project"
+    try {
+      const parser = await getParser(this.lang);
+      const tree = parser.parse(contentResult.value);
+      return Ok({
+        type: "Program",
+        body: { tree, source: contentResult.value },
+        language: this.lang
       });
+    } catch (e) {
+      const error = e;
+      return Err(
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path}: ${error.message}`, { path }, [
+          "Check for syntax errors in the file"
+        ])
+      );
     }
-    return rules;
-  }
-  async collect(config, rootDir) {
-    const modules = await discoverModules(rootDir);
-    const { maxLoc, maxFiles } = extractThresholds(config);
-    return modules.map((mod) => {
-      const violations = [];
-      if (mod.totalLoc > maxLoc) {
-        violations.push({
-          id: violationId(mod.modulePath, this.category, "totalLoc-exceeded"),
-          file: mod.modulePath,
-          detail: `Module has ${mod.totalLoc} lines of code (threshold: ${maxLoc})`,
-          severity: "warning"
-        });
-      }
-      if (mod.fileCount > maxFiles) {
-        violations.push({
-          id: violationId(mod.modulePath, this.category, "fileCount-exceeded"),
-          file: mod.modulePath,
-          detail: `Module has ${mod.fileCount} files (threshold: ${maxFiles})`,
-          severity: "warning"
-        });
-      }
-      return {
-        category: this.category,
-        scope: mod.modulePath,
-        value: mod.totalLoc,
-        violations,
-        metadata: { fileCount: mod.fileCount, totalLoc: mod.totalLoc }
-      };
-    });
   }
-};
-
-// src/architecture/collectors/dep-depth.ts
-import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import { join as join3, dirname as dirname3, resolve as resolve2 } from "path";
-import { DEFAULT_SKIP_DIRS as DEFAULT_SKIP_DIRS2 } from "@harness-engineering/graph";
-function extractImportSources(content, filePath) {
-  const importRegex = /(?:import|export)\s+.*?from\s+['"](\.[^'"]+)['"]/g;
-  const dynamicRegex = /import\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
-  const sources = [];
-  const dir = dirname3(filePath);
-  for (const regex of [importRegex, dynamicRegex]) {
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      let resolved = resolve2(dir, match[1]);
-      if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
-        resolved += ".ts";
-      }
-      sources.push(resolved);
-    }
+  extractImports(ast) {
+    const { tree, source } = ast.body;
+    return Ok(this.strategy.extractImports(tree.rootNode, source));
   }
-  return sources;
-}
-function isSkippedEntry2(name) {
-  return name.startsWith(".") || DEFAULT_SKIP_DIRS2.has(name);
-}
-function isTsSourceFile2(name) {
-  if (!name.endsWith(".ts") && !name.endsWith(".tsx")) return false;
-  return !name.endsWith(".test.ts") && !name.endsWith(".test.tsx") && !name.endsWith(".spec.ts");
-}
-async function scanDir2(d, results) {
-  let entries;
-  try {
-    entries = await readdir2(d, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (isSkippedEntry2(entry.name)) continue;
-    const fullPath = join3(d, entry.name);
-    if (entry.isDirectory()) {
-      await scanDir2(fullPath, results);
-    } else if (entry.isFile() && isTsSourceFile2(entry.name)) {
-      results.push(fullPath);
+  extractExports(ast) {
+    const { tree, source } = ast.body;
+    return Ok(this.strategy.extractExports(tree.rootNode, source));
+  }
+  async health() {
+    try {
+      await getParser(this.lang);
+      return Ok({ available: true, message: `tree-sitter ${this.lang} grammar loaded` });
+    } catch {
+      return Ok({ available: false, message: `tree-sitter ${this.lang} grammar not available` });
     }
   }
-}
-async function collectTsFiles(dir) {
-  const results = [];
-  await scanDir2(dir, results);
-  return results;
-}
-function computeLongestChain(file, graph, visited, memo) {
-  if (memo.has(file)) return memo.get(file);
-  if (visited.has(file)) return 0;
-  visited.add(file);
-  const deps = graph.get(file) || [];
-  let maxDepth = 0;
-  for (const dep of deps) {
-    const depth = 1 + computeLongestChain(dep, graph, visited, memo);
-    if (depth > maxDepth) maxDepth = depth;
+  outline(filePath, ast) {
+    const { tree, source } = ast.body;
+    return extractOutlineFromTree(tree.rootNode, this.lang, source, filePath);
   }
-  visited.delete(file);
-  memo.set(file, maxDepth);
-  return maxDepth;
-}
-var DepDepthCollector = class {
-  category = "dependency-depth";
-  getRules(config, _rootDir) {
-    const threshold = typeof config.thresholds["dependency-depth"] === "number" ? config.thresholds["dependency-depth"] : null;
-    const desc = threshold !== null ? `Dependency chain depth must not exceed ${threshold}` : "Dependency chain depth must stay within thresholds";
-    return [
-      {
-        id: constraintRuleId(this.category, "project", desc),
-        category: this.category,
-        description: desc,
-        scope: "project"
-      }
-    ];
-  }
-  async buildImportGraph(allFiles) {
-    const graph = /* @__PURE__ */ new Map();
-    const fileSet = new Set(allFiles);
-    for (const file of allFiles) {
-      try {
-        const content = await readFile4(file, "utf-8");
-        graph.set(
-          file,
-          extractImportSources(content, file).filter((imp) => fileSet.has(imp))
-        );
-      } catch {
-        graph.set(file, []);
-      }
-    }
-    return graph;
-  }
-  buildModuleMap(allFiles, rootDir) {
-    const moduleMap = /* @__PURE__ */ new Map();
-    for (const file of allFiles) {
-      const relDir = relativePosix(rootDir, dirname3(file));
-      if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
-      moduleMap.get(relDir).push(file);
-    }
-    return moduleMap;
-  }
-  async collect(config, rootDir) {
-    const allFiles = await collectTsFiles(rootDir);
-    const graph = await this.buildImportGraph(allFiles);
-    const moduleMap = this.buildModuleMap(allFiles, rootDir);
-    const memo = /* @__PURE__ */ new Map();
-    const threshold = typeof config.thresholds["dependency-depth"] === "number" ? config.thresholds["dependency-depth"] : Infinity;
-    const results = [];
-    for (const [modulePath, files] of moduleMap) {
-      const longestChain = files.reduce((max, file) => {
-        return Math.max(max, computeLongestChain(file, graph, /* @__PURE__ */ new Set(), memo));
-      }, 0);
-      const violations = [];
-      if (longestChain > threshold) {
-        violations.push({
-          id: violationId(modulePath, this.category, "depth-exceeded"),
-          file: modulePath,
-          detail: `Import chain depth is ${longestChain} (threshold: ${threshold})`,
-          severity: "warning"
-        });
-      }
-      results.push({
-        category: this.category,
-        scope: modulePath,
-        value: longestChain,
-        violations,
-        metadata: { longestChain }
-      });
-    }
-    return results;
+  unfold(filePath, ast, symbolName) {
+    const outlineResult = this.outline(filePath, ast);
+    if (outlineResult.error || !outlineResult.symbols.length) return null;
+    const { source } = ast.body;
+    const match = findSymbolByName(outlineResult.symbols, symbolName);
+    if (!match) return null;
+    const lines = source.split("\n");
+    const content = lines.slice(match.line - 1, match.endLine).join("\n");
+    return {
+      file: filePath,
+      symbolName,
+      startLine: match.line,
+      endLine: match.endLine,
+      content,
+      language: this.lang,
+      fallback: false
+    };
   }
 };
-
-// src/architecture/collectors/index.ts
-var defaultCollectors = [
-  new CircularDepsCollector(),
-  new LayerViolationCollector(),
-  new ComplexityCollector(),
-  new CouplingCollector(),
-  new ForbiddenImportCollector(),
-  new ModuleSizeCollector(),
-  new DepDepthCollector()
-];
-async function runAll(config, rootDir, collectors = defaultCollectors) {
-  const results = await Promise.allSettled(collectors.map((c) => c.collect(config, rootDir)));
-  const allResults = [];
-  for (let i = 0; i < results.length; i++) {
-    const result = results[i];
-    if (result.status === "fulfilled") {
-      allResults.push(...result.value);
-    } else {
-      allResults.push({
-        category: collectors[i].category,
-        scope: "project",
-        value: 0,
-        violations: [],
-        metadata: { error: String(result.reason) }
-      });
-    }
-  }
-  return allResults;
-}
-
-// src/architecture/matchers.ts
-function architecture(options) {
-  return {
-    kind: "arch-handle",
-    scope: "project",
-    rootDir: options?.rootDir ?? process.cwd(),
-    config: options?.config
-  };
-}
-function archModule(modulePath, options) {
-  return {
-    kind: "arch-handle",
-    scope: modulePath,
-    rootDir: options?.rootDir ?? process.cwd(),
-    config: options?.config
+function createTreeSitterParser(lang) {
+  const strategy = STRATEGIES[lang];
+  if (!strategy) return null;
+  const extensionMap = {
+    python: [".py"],
+    go: [".go"],
+    rust: [".rs"],
+    java: [".java"]
   };
+  const extensions = extensionMap[lang];
+  if (!extensions) return null;
+  return new TreeSitterParser(lang, extensions, strategy);
 }
-function resolveConfig(handle) {
-  return ArchConfigSchema.parse(handle.config ?? {});
-}
-async function collectCategory(handle, collector) {
-  if ("_mockResults" in handle && handle._mockResults) {
-    return handle._mockResults;
+
+// src/shared/parsers/registry.ts
+var ParserRegistry = class {
+  parsers = /* @__PURE__ */ new Map();
+  register(parser) {
+    this.parsers.set(parser.name, parser);
   }
-  const config = resolveConfig(handle);
-  return collector.collect(config, handle.rootDir);
-}
-function formatViolationList(violations, limit = 10) {
-  const lines = violations.slice(0, limit).map((v) => `  - ${v.file}: ${v.detail}`);
-  if (violations.length > limit) {
-    lines.push(`  ... and ${violations.length - limit} more`);
+  getByLanguage(lang) {
+    return this.parsers.get(lang) ?? null;
   }
-  return lines.join("\n");
-}
-async function toHaveNoCircularDeps(received) {
-  const results = await collectCategory(received, new CircularDepsCollector());
-  const violations = results.flatMap((r) => r.violations);
-  const pass = violations.length === 0;
-  return {
-    pass,
-    message: () => pass ? "Expected circular dependencies but found none" : `Found ${violations.length} circular dependenc${violations.length === 1 ? "y" : "ies"}:
-${formatViolationList(violations)}`
-  };
-}
-async function toHaveNoLayerViolations(received) {
-  const results = await collectCategory(received, new LayerViolationCollector());
-  const violations = results.flatMap((r) => r.violations);
-  const pass = violations.length === 0;
-  return {
-    pass,
-    message: () => pass ? "Expected layer violations but found none" : `Found ${violations.length} layer violation${violations.length === 1 ? "" : "s"}:
-${formatViolationList(violations)}`
-  };
-}
-async function toMatchBaseline(received, options) {
-  let diffResult;
-  if ("_mockDiff" in received && received._mockDiff) {
-    diffResult = received._mockDiff;
-  } else {
-    const config = resolveConfig(received);
-    const results = await runAll(config, received.rootDir);
-    const manager = new ArchBaselineManager(received.rootDir, config.baselinePath);
-    const baseline = manager.load();
-    if (!baseline) {
-      return {
-        pass: false,
-        message: () => "No baseline found. Run `harness check-arch --update-baseline` to create one."
-      };
-    }
-    diffResult = diff(results, baseline);
+  getForFile(filePath) {
+    const lang = detectLanguage(filePath);
+    if (!lang) return null;
+    return this.getByLanguage(lang);
   }
-  const tolerance = options?.tolerance ?? 0;
-  const effectiveNewCount = Math.max(0, diffResult.newViolations.length - tolerance);
-  const pass = effectiveNewCount === 0 && diffResult.regressions.length === 0;
-  return {
-    pass,
-    message: () => {
-      if (pass) {
-        return "Expected baseline regression but architecture matches baseline";
-      }
-      const parts = [];
-      if (diffResult.newViolations.length > 0) {
-        parts.push(
-          `${diffResult.newViolations.length} new violation${diffResult.newViolations.length === 1 ? "" : "s"}${tolerance > 0 ? ` (tolerance: ${tolerance})` : ""}:
-${formatViolationList(diffResult.newViolations)}`
-        );
-      }
-      if (diffResult.regressions.length > 0) {
-        const regLines = diffResult.regressions.map(
-          (r) => `  - ${r.category}: ${r.baselineValue} -> ${r.currentValue} (+${r.delta})`
-        );
-        parts.push(`Regressions:
-${regLines.join("\n")}`);
-      }
-      return `Baseline check failed:
-${parts.join("\n\n")}`;
+  getSupportedExtensions() {
+    return Object.keys(EXTENSION_MAP);
+  }
+  getSupportedLanguages() {
+    return Array.from(this.parsers.keys());
+  }
+  isSupportedExtension(ext) {
+    return ext in EXTENSION_MAP;
+  }
+};
+var defaultRegistry = null;
+function getDefaultRegistry() {
+  if (defaultRegistry) return defaultRegistry;
+  const registry = new ParserRegistry();
+  const tsParser = new TypeScriptParser();
+  registry.register(tsParser);
+  registry.register({
+    name: "javascript",
+    extensions: [".js", ".jsx", ".mjs", ".cjs"],
+    parseFile: tsParser.parseFile.bind(tsParser),
+    extractImports: tsParser.extractImports.bind(tsParser),
+    extractExports: tsParser.extractExports.bind(tsParser),
+    health: tsParser.health.bind(tsParser)
+  });
+  const treeSitterLanguages = ["python", "go", "rust", "java"];
+  for (const lang of treeSitterLanguages) {
+    const parser = createTreeSitterParser(lang);
+    if (parser) {
+      registry.register(parser);
     }
-  };
-}
-function filterByScope(results, scope) {
-  return results.filter(
-    (r) => r.scope === scope || r.scope.startsWith(scope + "/") || r.scope === "project"
-  );
-}
-async function toHaveMaxComplexity(received, maxComplexity) {
-  const results = await collectCategory(received, new ComplexityCollector());
-  const scoped = filterByScope(results, received.scope);
-  const violations = scoped.flatMap((r) => r.violations);
-  const totalValue = scoped.reduce((sum, r) => sum + r.value, 0);
-  const pass = totalValue <= maxComplexity && violations.length === 0;
-  return {
-    pass,
-    message: () => pass ? `Expected complexity to exceed ${maxComplexity} but it was within limits` : `Module '${received.scope}' has complexity violations (${violations.length} violation${violations.length === 1 ? "" : "s"}):
-${formatViolationList(violations)}`
-  };
-}
-async function toHaveMaxCoupling(received, limits) {
-  const config = resolveConfig(received);
-  if (limits.fanIn !== void 0 || limits.fanOut !== void 0) {
-    config.thresholds.coupling = {
-      ...typeof config.thresholds.coupling === "object" ? config.thresholds.coupling : {},
-      ...limits.fanIn !== void 0 ? { maxFanIn: limits.fanIn } : {},
-      ...limits.fanOut !== void 0 ? { maxFanOut: limits.fanOut } : {}
-    };
   }
-  const collector = new CouplingCollector();
-  const results = "_mockResults" in received && received._mockResults ? received._mockResults : await collector.collect(config, received.rootDir);
-  const scoped = filterByScope(results, received.scope);
-  const violations = scoped.flatMap((r) => r.violations);
-  const pass = violations.length === 0;
-  return {
-    pass,
-    message: () => pass ? `Expected coupling violations in '${received.scope}' but found none` : `Module '${received.scope}' has ${violations.length} coupling violation${violations.length === 1 ? "" : "s"} (fanIn limit: ${limits.fanIn ?? "none"}, fanOut limit: ${limits.fanOut ?? "none"}):
-${formatViolationList(violations)}`
-  };
-}
-async function toHaveMaxFileCount(received, maxFiles) {
-  const results = await collectCategory(received, new ModuleSizeCollector());
-  const scoped = filterByScope(results, received.scope);
-  const fileCount = scoped.reduce((max, r) => {
-    const meta = r.metadata;
-    const fc = typeof meta?.fileCount === "number" ? meta.fileCount : 0;
-    return fc > max ? fc : max;
-  }, 0);
-  const pass = fileCount <= maxFiles;
-  return {
-    pass,
-    message: () => pass ? `Expected file count in '${received.scope}' to exceed ${maxFiles} but it was ${fileCount}` : `Module '${received.scope}' has ${fileCount} files (limit: ${maxFiles})`
-  };
-}
-async function toNotDependOn(received, forbiddenModule) {
-  const results = await collectCategory(received, new ForbiddenImportCollector());
-  const allViolations = results.flatMap((r) => r.violations);
-  const scopePrefix = received.scope.replace(/\/+$/, "");
-  const forbiddenPrefix = forbiddenModule.replace(/\/+$/, "");
-  const relevantViolations = allViolations.filter(
-    (v) => (v.file === scopePrefix || v.file.startsWith(scopePrefix + "/")) && (v.detail.includes(forbiddenPrefix + "/") || v.detail.endsWith(forbiddenPrefix))
-  );
-  const pass = relevantViolations.length === 0;
-  return {
-    pass,
-    message: () => pass ? `Expected '${received.scope}' to depend on '${forbiddenModule}' but no such imports found` : `Module '${received.scope}' depends on '${forbiddenModule}' (${relevantViolations.length} import${relevantViolations.length === 1 ? "" : "s"}):
-${formatViolationList(relevantViolations)}`
-  };
-}
-async function toHaveMaxDepDepth(received, maxDepth) {
-  const results = await collectCategory(received, new DepDepthCollector());
-  const scoped = filterByScope(results, received.scope);
-  const maxActual = scoped.reduce((max, r) => r.value > max ? r.value : max, 0);
-  const pass = maxActual <= maxDepth;
-  return {
-    pass,
-    message: () => pass ? `Expected dependency depth in '${received.scope}' to exceed ${maxDepth} but it was ${maxActual}` : `Module '${received.scope}' has dependency depth ${maxActual} (limit: ${maxDepth})`
-  };
+  defaultRegistry = registry;
+  return registry;
 }
-var archMatchers = {
-  toHaveNoCircularDeps,
-  toHaveNoLayerViolations,
-  toMatchBaseline,
-  toHaveMaxComplexity,
-  toHaveMaxCoupling,
-  toHaveMaxFileCount,
-  toNotDependOn,
-  toHaveMaxDepDepth
-};
 
 export {
-  __export,
   createError,
   createEntropyError,
   Ok,
@@ -2889,39 +1636,6 @@ export {
   resolveFileToLayer,
   buildDependencyGraph,
   validateDependencies,
-  detectCircularDeps,
-  detectCircularDepsInFiles,
   detectComplexityViolations,
-  detectCouplingViolations,
-  ArchMetricCategorySchema,
-  ViolationSchema,
-  MetricResultSchema,
-  CategoryBaselineSchema,
-  ArchBaselineSchema,
-  CategoryRegressionSchema,
-  ArchDiffResultSchema,
-  ThresholdConfigSchema,
-  ArchConfigSchema,
-  ConstraintRuleSchema,
-  ViolationSnapshotSchema,
-  ViolationHistorySchema,
-  EmergenceConfidenceSchema,
-  EmergentConstraintSuggestionSchema,
-  EmergenceResultSchema,
-  violationId,
-  constraintRuleId,
-  CircularDepsCollector,
-  LayerViolationCollector,
-  ComplexityCollector,
-  CouplingCollector,
-  ForbiddenImportCollector,
-  ModuleSizeCollector,
-  DepDepthCollector,
-  defaultCollectors,
-  runAll,
-  ArchBaselineManager,
-  diff,
-  architecture,
-  archModule,
-  archMatchers
+  detectCouplingViolations
 };