ai-spec-dev 0.29.1 → 0.30.0

package/README.md

@@ -1223,7 +1223,8 @@ Attempting auto-fix (3 error(s))...
 ✔ All checks passed after 2 cycle(s).
 ```
 
-- 按文件分组错误，逐文件提交 AI 修复（携带 DSL 上下文）
+- 按文件分组错误，**依据 import 依赖图排序后**逐文件修复（被依赖文件先修，cascade 错误在 cycle 1 消除率更高）
+- 每个文件修复 prompt 携带 DSL 上下文，避免「把错误藏起来」式修复
 - 任一 cycle 全部通过则提前结束
 - 2 次后仍有错误 → 给出警告提示（不中断流水线）
 
@@ -1523,12 +1524,12 @@ ai-spec-dev-poc/
 │   ├── combined-generator.ts       # Spec + Tasks 合并单次 AI 调用
 │   ├── reviewer.ts                 # AI 代码审查（git diff / 文件内容双模式）
 │   ├── test-generator.ts           # 测试骨架生成器（DSL → Jest/Vitest 骨架）
-│   ├── error-feedback.ts           # 错误反馈自动修复（测试+lint检测 · AI修复循环）
+│   ├── error-feedback.ts           # 错误反馈自动修复（测试+lint检测 · 依赖图排序修复 · AI修复循环）
 │   ├── knowledge-memory.ts         # 经验积累：审查 issue → 宪法§9
 │   ├── workspace-loader.ts         # [Phase 4] 工作区配置加载 + repo 类型自动检测
 │   ├── requirement-decomposer.ts   # [Phase 4] 需求跨 repo 拆分 + UX 决策生成
 │   ├── contract-bridge.ts          # [Phase 4] 后端 DSL → 前端 TS 接口契约桥接
-│   ├── frontend-context-loader.ts  # [v0.8] 前端深度感知（hook/store/API封装/测试框架/分页 pattern 检测）
+│   ├── frontend-context-loader.ts  # [v0.8] 前端深度感知（hook/store/API封装/测试框架/分页 pattern 检测；v0.30.0 升级为多行 import 解析，覆盖换行 named import 写法）
 │   └── global-constitution.ts      # [v0.8] 全局宪法：加载 / 合并 / 保存（跨项目共享规范）
 ├── git/
 │   └── worktree.ts                 # Git Worktree 管理

package/RELEASE_LOG.md

@@ -2,6 +2,30 @@
 
 ---
 
+## [0.30.0] 2026-03-29 — 错误修复依赖图排序 + 前端 Import 多行感知解析
+
+### 改进内容
+
+**Improvement #1 — Error Repair 升级为依赖图排序（`core/error-feedback.ts`）**
+
+- **问题**：`attemptFix()` 对出错文件的修复顺序完全取决于 `Map` 的插入顺序（即错误首次出现的顺序），与文件间的 import 关系无关。典型场景：`userService.ts` 导出一个类型，`userController.ts` 和 `userStore.ts` 同时 import 它，三个文件都出错时，若 controller/store 先被修复，修复 prompt 中的 service 仍是破损版本，cycle 1 无法消除 cascade 错误，只能等 cycle 2 补救。
+- **修复**：新增 `parseRelativeImports()` + `buildRepairOrder()` 两个函数：
+  - `parseRelativeImports(content, fromFile)` — 从文件内容中解析相对 import 路径（`./foo`、`../foo`），规范化为项目根相对路径（不含扩展名），跳过 `import type`（仅类型，不影响运行时错误）
+  - `buildRepairOrder(errorsByFile, workingDir)` — 读取所有出错文件的 import 声明，构建「出错文件子图」，使用 Kahn 拓扑排序将被依赖的文件排在前面，有环依赖的文件追加到末尾
+  - `attemptFix()` 调用 `await buildRepairOrder()` 替换原先直接遍历 `errorsByFile`
+- **效果**：上例中 `userService.ts` 先被修复，cycle 1 即可消除 controller / store 的 cascade 错误，2 轮上限的利用率提升，复杂跨文件依赖错误的一次性修复率提高
+
+**Improvement #2 — `httpClientImport` / `layoutImport` 升级为多行感知解析（`core/frontend-context-loader.ts`）**
+
+- **问题**：旧版 `httpClientImport` 提取使用单行正则 `httpImportRegex`，`[^}]+` 不跨换行符，导致所有多行 named import（`import {\n  request\n} from '@/utils/http'`）静默匹配失败，回退到 `undefined`，AI 自由发挥 import 路径；`layoutImport` 同样依赖单行正则，多行动态 import 写法（`const Layout = defineAsyncComponent(\n  () => import('...')\n)`）无法识别。
+- **修复**：
+  - 新增 `parseImportStatements(content)` — 轻量 import 解析器：先将多行 named import block（`import { ... }`）折叠为单行，再逐行匹配，返回 `{ line, modulePath, specifiers }` 结构化对象，跳过 `import type`；不引入任何新依赖
+  - 新增 `HTTP_MODULE_PATTERNS` — 三类模式数组（路径别名 `@/` `~/` `#/` / 已知 HTTP 库名 / 含关键词的相对路径），独立于 import 行格式，匹配逻辑与解析逻辑解耦
+  - 新增 `findHttpClientImport(content)` — 组合以上两者，替换旧版 `httpImportRegex` 的调用处
+  - `extractRouteModuleContext()` 中 `layoutImport` 静态 import 改用 `parseImportStatements()` 提取；动态 import（`const Layout = ...`）增加多行折叠预处理后再匹配，覆盖 `defineAsyncComponent` 等包装写法
+
+---
+
 ## [0.29.0] 2026-03-27 — 全量审查修复（RunLogger 插桩、update 快照、Score Trend 升级、死代码清理）
 
 ### 修复内容

package/core/error-feedback.ts

@@ -197,6 +197,104 @@ function parseErrors(output: string, source: ErrorEntry["source"]): ErrorEntry[]
   return errors;
 }
 
+// ─── Dependency-Ordered Repair ──────────────────────────────────────────────────
+
+/**
+ * Extract relative import paths from a file's content.
+ * Returns paths normalized to project-root-relative form (no extension).
+ * Only considers relative imports (./foo, ../foo) — skips aliases and node_modules.
+ */
+function parseRelativeImports(content: string, fromFileRel: string): string[] {
+  const relDir = path.dirname(fromFileRel);
+  const results: string[] = [];
+
+  // Normalize multi-line imports so `import {\n  foo,\n} from '...'` becomes one line
+  const normalized = content.replace(/import\s*\{[^}]*\}/gs, (m) => m.replace(/\n\s*/g, " "));
+
+  for (const line of normalized.split("\n")) {
+    const trimmed = line.trim();
+    // Skip type-only imports — they don't affect runtime errors
+    if (/^import\s+type\b/.test(trimmed)) continue;
+    // Match only relative imports (starting with ./ or ../)
+    const match = trimmed.match(/^import\b[^'"]*from\s+['"](\.\.?\/[^'"]+)['"]/);
+    if (!match) continue;
+
+    const resolved = path.normalize(path.join(relDir, match[1]));
+    results.push(resolved);
+  }
+
+  return results;
+}
+
+/**
+ * Sort errored files so that dependencies (upstream exports) are fixed before their importers.
+ * Example: if A exports a type used by B and C, fix A first so cycle 1 can cascade correctly.
+ * Uses Kahn's topological sort; cycles are appended at the end (unavoidable, fix last).
+ */
+async function buildRepairOrder(
+  errorsByFile: Map<string, ErrorEntry[]>,
+  workingDir: string
+): Promise<[string, ErrorEntry[]][]> {
+  const files = Array.from(errorsByFile.keys());
+  if (files.length <= 1) return Array.from(errorsByFile.entries());
+
+  // Build: file → errored files it depends on (imports from)
+  const deps = new Map<string, string[]>(files.map((f) => [f, []]));
+
+  for (const file of files) {
+    try {
+      const content = await fs.readFile(path.join(workingDir, file), "utf-8");
+      const importedPaths = parseRelativeImports(content, file);
+
+      for (const importedPath of importedPaths) {
+        const matched = files.find((f) => {
+          if (f === file) return false;
+          const fNoExt = f.replace(/\.[^.]+$/, "");
+          return (
+            importedPath === fNoExt ||
+            importedPath === f ||
+            `${importedPath}.ts` === f ||
+            `${importedPath}.tsx` === f ||
+            `${importedPath}.js` === f ||
+            `${importedPath}.jsx` === f
+          );
+        });
+        if (matched) deps.get(file)!.push(matched);
+      }
+    } catch {
+      // file unreadable — treat as no deps
+    }
+  }
+
+  // Reverse adjacency: dep → files that import it (its dependents)
+  const dependents = new Map<string, string[]>(files.map((f) => [f, []]));
+  for (const [file, fileDeps] of deps) {
+    for (const dep of fileDeps) dependents.get(dep)!.push(file);
+  }
+
+  // Kahn's algorithm: files with no deps go first
+  const inDegree = new Map(files.map((f) => [f, deps.get(f)!.length]));
+  const queue = files.filter((f) => inDegree.get(f) === 0);
+  const sorted: string[] = [];
+
+  while (queue.length > 0) {
+    const file = queue.shift()!;
+    sorted.push(file);
+    for (const dependent of dependents.get(file) ?? []) {
+      const degree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, degree);
+      if (degree === 0) queue.push(dependent);
+    }
+  }
+
+  // Append remaining files (cycles) — fix them last since ordering is ambiguous
+  for (const f of files) {
+    if (!sorted.includes(f)) sorted.push(f);
+  }
+
+  return sorted.map((f) => [f, errorsByFile.get(f)!]);
+}
+
 // ─── Auto-Fix ───────────────────────────────────────────────────────────────────
 
 async function attemptFix(
@@ -207,7 +305,7 @@ async function attemptFix(
 ): Promise<FixResult[]> {
   const results: FixResult[] = [];
 
-  // Group errors by file (fix one file at a time)
+  // Group errors by file, then sort by dependency order so upstream files are fixed first
   const errorsByFile = new Map<string, ErrorEntry[]>();
   for (const err of errors) {
     const file = err.file || "(unknown)";
@@ -215,7 +313,9 @@ async function attemptFix(
     errorsByFile.get(file)!.push(err);
   }
 
-  for (const [file, fileErrors] of errorsByFile) {
+  const sortedEntries = await buildRepairOrder(errorsByFile, workingDir);
+
+  for (const [file, fileErrors] of sortedEntries) {
     const fullPath = path.join(workingDir, file);
     let existingContent = "";
     try {

package/core/frontend-context-loader.ts

@@ -68,6 +68,84 @@ export interface FrontendContext {
   paginationExample?: string;
 }
 
+// ─── Lightweight Import Parser ────────────────────────────────────────────────
+
+interface ImportStatement {
+  /** The full original import line (for verbatim injection into prompts) */
+  line: string;
+  /** Resolved module path (e.g. '@/utils/http', 'axios', '../lib/request') */
+  modulePath: string;
+  /** Everything between `import` and `from` (specifiers) */
+  specifiers: string;
+}
+
+/**
+ * Parse all non-type import statements from a TypeScript/JavaScript file.
+ *
+ * Improvements over a single-line regex:
+ *  - Handles multi-line named imports: `import {\n  foo,\n  bar\n} from '...'`
+ *  - Skips `import type { ... }` to avoid false positives
+ *  - Returns structured objects so callers can inspect specifiers vs module path
+ *    without re-running a second regex
+ */
+function parseImportStatements(content: string): ImportStatement[] {
+  // 1. Strip block comments (/* ... */) to avoid matching imports inside comments
+  const stripped = content.replace(/\/\*[\s\S]*?\*\//g, (m) => "\n".repeat(m.split("\n").length - 1));
+
+  // 2. Collapse multi-line named import blocks onto a single logical line so
+  //    a single-line pattern can match them reliably.
+  //    e.g. `import {\n  foo,\n  bar\n} from 'x'` → `import { foo,  bar } from 'x'`
+  const collapsed = stripped.replace(/import\s*\{[^}]*\}/gs, (m) => m.replace(/\n\s*/g, " "));
+
+  const results: ImportStatement[] = [];
+
+  for (const rawLine of collapsed.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    // Skip type-only imports — they never affect runtime behaviour
+    if (/^import\s+type\b/.test(line)) continue;
+    if (!line.startsWith("import")) continue;
+
+    const match = line.match(/^(import\s+([\s\S]+?)\s+from\s+['"]([^'"]+)['"])/);
+    if (!match) continue;
+
+    results.push({
+      line: match[1],
+      modulePath: match[3],
+      specifiers: match[2],
+    });
+  }
+
+  return results;
+}
+
+const HTTP_MODULE_PATTERNS: RegExp[] = [
+  // Project path aliases (@/, @@/, ~/, #/) — catches '@/utils/request', '~/lib/http', etc.
+  /^(?:@{1,2}|~|#)[/\\]/,
+  // Well-known HTTP libraries (exact name match)
+  /^(?:axios|ky(?:-universal)?|undici|node-fetch|cross-fetch|got|superagent|alova|openapi-fetch)$/,
+  // Relative imports whose path contains an HTTP-utility keyword
+  /\.{1,2}\/[^'"]*(?:http|request|fetch|client|api)[^'"]*/,
+];
+
+/**
+ * Find the HTTP client import line from an API file's content.
+ * Returns the verbatim import statement or undefined if not found.
+ *
+ * More reliable than the old single-line regex because:
+ *  - Handles multi-line named imports (e.g. `import {\n  request\n} from '@/utils/http'`)
+ *  - Module-path matching is done on the resolved path string, not the full line,
+ *    so a long specifier list doesn't prevent a match
+ */
+function findHttpClientImport(content: string): string | undefined {
+  for (const stmt of parseImportStatements(content)) {
+    if (HTTP_MODULE_PATTERNS.some((p) => p.test(stmt.modulePath))) {
+      return stmt.line;
+    }
+  }
+  return undefined;
+}
+
 // ─── Detection Maps ────────────────────────────────────────────────────────────
 
 const STATE_MANAGEMENT_LIBS = [
@@ -303,18 +381,15 @@ export async function loadFrontendContext(
     // e.g. "import request from '@/utils/http'" or "import axios from 'axios'"
     // This is ground truth — prevents the AI from inventing a different import path.
     //
-    // Matches (in priority order):
-    //   1. Project alias imports: @/, ~/, #/, @@/ (common in Vite/webpack projects)
-    //   2. Named HTTP libraries: axios, ky, undici, node-fetch, etc.
-    //   3. Relative imports whose path contains http-utility keywords
-    const httpImportRegex =
-      /^import(?!\s+type)\s+(?:[\w*]+|\{[^}]+\})\s+from\s+['"]((?:@{1,2}|~|#)[/\\][^'"]+|\.{1,2}\/[^'"]*(?:http|request|fetch|client|api)[^'"]*|axios|ky(?:-universal)?|undici|node-fetch|cross-fetch|got|superagent|alova|openapi-fetch)['"]/im;
+    // Uses parseImportStatements() + HTTP_MODULE_PATTERNS instead of a single-line regex
+    // so multi-line named imports (e.g. `import {\n  request\n} from '@/utils/http'`)
+    // are handled correctly without a secondary normalisation pass at call-site.
     for (const relPath of ctx.existingApiFiles.slice(0, 5)) {
       try {
         const content = await fs.readFile(path.join(projectRoot, relPath), "utf-8");
-        const match = content.match(httpImportRegex);
-        if (match) {
-          ctx.httpClientImport = match[0].trim();
+        const found = findHttpClientImport(content);
+        if (found) {
+          ctx.httpClientImport = found;
           break;
         }
       } catch {
@@ -498,23 +573,45 @@ async function extractRouteModuleContext(
 
   if (moduleFiles.length === 0) return;
 
-  // Layout import regex — matches common patterns:
-  //   const Layout = () => import('@/layout/index.vue')
-  //   import Layout from '@/layouts/default/index.vue'
-  //   const Layout = defineAsyncComponent(() => import('@/layout/index.vue'))
-  const layoutImportRegex =
-    /^(?:const\s+Layout\s*=.*import\(['"][^'"]+['"]\)|import\s+Layout\s+from\s+['"][^'"]+['"])/m;
+  // Layout import extraction — handles two patterns:
+  //   1. Static:  `import Layout from '@/layout/index.vue'`
+  //   2. Dynamic: `const Layout = () => import('@/layout/index.vue')`
+  //              `const Layout = defineAsyncComponent(() => import('@/layout/index.vue'))`
+  //
+  // Pattern 1 is resolved via parseImportStatements() (handles multi-line named imports).
+  // Pattern 2 is matched with a targeted regex on the collapsed (single-line) content.
+  const dynamicLayoutRegex =
+    /const\s+Layout\s*=\s*(?:defineAsyncComponent\s*\(\s*)?(?:\(\s*\))?\s*(?:=>|function[^(]*\()\s*(?:[^)]*\))?\s*(?:=>)?\s*import\s*\(\s*['"]([^'"]+)['"]\s*\)/;
 
   for (const relPath of moduleFiles) {
     try {
       const content = await fs.readFile(path.join(projectRoot, relPath), "utf-8");
-      const match = content.match(layoutImportRegex);
-      if (match) {
-        ctx.layoutImport = match[0].trim();
-        // Use this file as the route module template (cap at 100 lines)
+
+      // ── Pattern 1: static import Layout ────────────────────────────────────
+      const stmts = parseImportStatements(content);
+      const staticLayout = stmts.find(
+        (s) => /\bLayout\b/.test(s.specifiers) && /layout/i.test(s.modulePath)
+      );
+      if (staticLayout) {
+        ctx.layoutImport = staticLayout.line;
         const preview = content.split("\n").slice(0, 100).join("\n");
         ctx.routeModuleExample = { path: relPath, content: preview };
-        break; // first match is enough
+        break;
+      }
+
+      // ── Pattern 2: dynamic / async-component import ─────────────────────────
+      // Collapse multi-line dynamic import declarations before matching
+      const singleLine = content.replace(/const\s+Layout\s*=[\s\S]*?import\s*\([^)]+\)/gm, (m) =>
+        m.replace(/\n\s*/g, " ")
+      );
+      const dynMatch = singleLine.match(dynamicLayoutRegex);
+      if (dynMatch) {
+        // Re-extract the full const declaration line from the original content
+        const constMatch = content.match(/^const\s+Layout\s*=.+/m);
+        ctx.layoutImport = constMatch ? constMatch[0].trim() : dynMatch[0].trim();
+        const preview = content.split("\n").slice(0, 100).join("\n");
+        ctx.routeModuleExample = { path: relPath, content: preview };
+        break;
       }
     } catch {
       // skip

package/dist/cli/index.js

@@ -5518,6 +5518,41 @@ async function loadDslForSpec(specFilePath) {
 // core/frontend-context-loader.ts
 var fs7 = __toESM(require("fs-extra"));
 var path6 = __toESM(require("path"));
+function parseImportStatements(content) {
+  const stripped = content.replace(/\/\*[\s\S]*?\*\//g, (m) => "\n".repeat(m.split("\n").length - 1));
+  const collapsed = stripped.replace(/import\s*\{[^}]*\}/gs, (m) => m.replace(/\n\s*/g, " "));
+  const results = [];
+  for (const rawLine of collapsed.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (/^import\s+type\b/.test(line)) continue;
+    if (!line.startsWith("import")) continue;
+    const match = line.match(/^(import\s+([\s\S]+?)\s+from\s+['"]([^'"]+)['"])/);
+    if (!match) continue;
+    results.push({
+      line: match[1],
+      modulePath: match[3],
+      specifiers: match[2]
+    });
+  }
+  return results;
+}
+var HTTP_MODULE_PATTERNS = [
+  // Project path aliases (@/, @@/, ~/, #/) — catches '@/utils/request', '~/lib/http', etc.
+  /^(?:@{1,2}|~|#)[/\\]/,
+  // Well-known HTTP libraries (exact name match)
+  /^(?:axios|ky(?:-universal)?|undici|node-fetch|cross-fetch|got|superagent|alova|openapi-fetch)$/,
+  // Relative imports whose path contains an HTTP-utility keyword
+  /\.{1,2}\/[^'"]*(?:http|request|fetch|client|api)[^'"]*/
+];
+function findHttpClientImport(content) {
+  for (const stmt of parseImportStatements(content)) {
+    if (HTTP_MODULE_PATTERNS.some((p) => p.test(stmt.modulePath))) {
+      return stmt.line;
+    }
+  }
+  return void 0;
+}
 var STATE_MANAGEMENT_LIBS = [
   "zustand",
   "redux",
@@ -5706,13 +5741,12 @@ ${preview}`);
       } catch {
       }
     }
-    const httpImportRegex = /^import(?!\s+type)\s+(?:[\w*]+|\{[^}]+\})\s+from\s+['"]((?:@{1,2}|~|#)[/\\][^'"]+|\.{1,2}\/[^'"]*(?:http|request|fetch|client|api)[^'"]*|axios|ky(?:-universal)?|undici|node-fetch|cross-fetch|got|superagent|alova|openapi-fetch)['"]/im;
     for (const relPath of ctx.existingApiFiles.slice(0, 5)) {
       try {
         const content = await fs7.readFile(path6.join(projectRoot, relPath), "utf-8");
-        const match = content.match(httpImportRegex);
-        if (match) {
-          ctx.httpClientImport = match[0].trim();
+        const found = findHttpClientImport(content);
+        if (found) {
+          ctx.httpClientImport = found;
           break;
         }
       } catch {
@@ -5842,13 +5876,28 @@ async function extractRouteModuleContext(projectRoot, ctx) {
     moduleFiles.push(...files);
   }
   if (moduleFiles.length === 0) return;
-  const layoutImportRegex = /^(?:const\s+Layout\s*=.*import\(['"][^'"]+['"]\)|import\s+Layout\s+from\s+['"][^'"]+['"])/m;
+  const dynamicLayoutRegex = /const\s+Layout\s*=\s*(?:defineAsyncComponent\s*\(\s*)?(?:\(\s*\))?\s*(?:=>|function[^(]*\()\s*(?:[^)]*\))?\s*(?:=>)?\s*import\s*\(\s*['"]([^'"]+)['"]\s*\)/;
   for (const relPath of moduleFiles) {
     try {
       const content = await fs7.readFile(path6.join(projectRoot, relPath), "utf-8");
-      const match = content.match(layoutImportRegex);
-      if (match) {
-        ctx.layoutImport = match[0].trim();
+      const stmts = parseImportStatements(content);
+      const staticLayout = stmts.find(
+        (s) => /\bLayout\b/.test(s.specifiers) && /layout/i.test(s.modulePath)
+      );
+      if (staticLayout) {
+        ctx.layoutImport = staticLayout.line;
+        const preview = content.split("\n").slice(0, 100).join("\n");
+        ctx.routeModuleExample = { path: relPath, content: preview };
+        break;
+      }
+      const singleLine = content.replace(
+        /const\s+Layout\s*=[\s\S]*?import\s*\([^)]+\)/gm,
+        (m) => m.replace(/\n\s*/g, " ")
+      );
+      const dynMatch = singleLine.match(dynamicLayoutRegex);
+      if (dynMatch) {
+        const constMatch = content.match(/^const\s+Layout\s*=.+/m);
+        ctx.layoutImport = constMatch ? constMatch[0].trim() : dynMatch[0].trim();
         const preview = content.split("\n").slice(0, 100).join("\n");
         ctx.routeModuleExample = { path: relPath, content: preview };
         break;
@@ -7833,6 +7882,60 @@ function parseErrors(output, source) {
   }
   return errors;
 }
+function parseRelativeImports(content, fromFileRel) {
+  const relDir = path15.dirname(fromFileRel);
+  const results = [];
+  const normalized = content.replace(/import\s*\{[^}]*\}/gs, (m) => m.replace(/\n\s*/g, " "));
+  for (const line of normalized.split("\n")) {
+    const trimmed = line.trim();
+    if (/^import\s+type\b/.test(trimmed)) continue;
+    const match = trimmed.match(/^import\b[^'"]*from\s+['"](\.\.?\/[^'"]+)['"]/);
+    if (!match) continue;
+    const resolved = path15.normalize(path15.join(relDir, match[1]));
+    results.push(resolved);
+  }
+  return results;
+}
+async function buildRepairOrder(errorsByFile, workingDir) {
+  const files = Array.from(errorsByFile.keys());
+  if (files.length <= 1) return Array.from(errorsByFile.entries());
+  const deps = new Map(files.map((f) => [f, []]));
+  for (const file of files) {
+    try {
+      const content = await fs16.readFile(path15.join(workingDir, file), "utf-8");
+      const importedPaths = parseRelativeImports(content, file);
+      for (const importedPath of importedPaths) {
+        const matched = files.find((f) => {
+          if (f === file) return false;
+          const fNoExt = f.replace(/\.[^.]+$/, "");
+          return importedPath === fNoExt || importedPath === f || `${importedPath}.ts` === f || `${importedPath}.tsx` === f || `${importedPath}.js` === f || `${importedPath}.jsx` === f;
+        });
+        if (matched) deps.get(file).push(matched);
+      }
+    } catch {
+    }
+  }
+  const dependents = new Map(files.map((f) => [f, []]));
+  for (const [file, fileDeps] of deps) {
+    for (const dep of fileDeps) dependents.get(dep).push(file);
+  }
+  const inDegree = new Map(files.map((f) => [f, deps.get(f).length]));
+  const queue = files.filter((f) => inDegree.get(f) === 0);
+  const sorted = [];
+  while (queue.length > 0) {
+    const file = queue.shift();
+    sorted.push(file);
+    for (const dependent of dependents.get(file) ?? []) {
+      const degree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, degree);
+      if (degree === 0) queue.push(dependent);
+    }
+  }
+  for (const f of files) {
+    if (!sorted.includes(f)) sorted.push(f);
+  }
+  return sorted.map((f) => [f, errorsByFile.get(f)]);
+}
 async function attemptFix(provider, errors, workingDir, dsl) {
   const results = [];
   const errorsByFile = /* @__PURE__ */ new Map();
@@ -7841,7 +7944,8 @@ async function attemptFix(provider, errors, workingDir, dsl) {
     if (!errorsByFile.has(file)) errorsByFile.set(file, []);
     errorsByFile.get(file).push(err);
   }
-  for (const [file, fileErrors] of errorsByFile) {
+  const sortedEntries = await buildRepairOrder(errorsByFile, workingDir);
+  for (const [file, fileErrors] of sortedEntries) {
     const fullPath = path15.join(workingDir, file);
     let existingContent = "";
     try {