@getcoherent/cli 0.6.46 → 0.6.48

package/dist/chunk-U6M76BKY.js

@@ -0,0 +1,50 @@
+// src/commands/fix-validation.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var cachedTs = null;
+var cachedProjectRoot = null;
+function isValidTsx(code, projectRoot, ext = ".tsx") {
+  if (ext !== ".tsx" && ext !== ".ts") return true;
+  const pkgJson = join(projectRoot, "package.json");
+  if (!existsSync(pkgJson)) return true;
+  try {
+    if (!cachedTs || cachedProjectRoot !== projectRoot) {
+      const req = createRequire(pkgJson);
+      cachedTs = req("typescript");
+      cachedProjectRoot = projectRoot;
+    }
+    const sf = cachedTs.createSourceFile(
+      "check.tsx",
+      code,
+      cachedTs.ScriptTarget.Latest,
+      false,
+      cachedTs.ScriptKind.TSX
+    );
+    const diagnostics = sf.parseDiagnostics;
+    return !diagnostics || diagnostics.length === 0;
+  } catch {
+    return true;
+  }
+}
+function safeWrite(filePath, newContent, projectRoot, backups) {
+  if (!backups.has(filePath)) {
+    try {
+      backups.set(filePath, readFileSync(filePath, "utf-8"));
+    } catch {
+    }
+  }
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  writeFileSync(filePath, newContent, "utf-8");
+  if (!isValidTsx(newContent, projectRoot, ext)) {
+    const original = backups.get(filePath);
+    if (original) writeFileSync(filePath, original, "utf-8");
+    return { ok: false };
+  }
+  return { ok: true };
+}
+
+export {
+  isValidTsx,
+  safeWrite
+};

package/dist/chunk-XPBD3L7V.js

@@ -0,0 +1,260 @@
+import {
+  safeWrite
+} from "./chunk-U6M76BKY.js";
+
+// src/utils/tsc-autofix.ts
+import { existsSync, readFileSync } from "fs";
+import { execSync } from "child_process";
+import { resolve } from "path";
+
+// src/utils/tsc-error-parser.ts
+var ERROR_RE = /^(.+?)\((\d+),(\d+)\): error (TS\d+): (.+)$/;
+var RELATED_LOCATION_RE = /^(.+?)\((\d+),(\d+)\):\s/;
+function parseTscOutput(output) {
+  const lines = output.split("\n");
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = null;
+  for (const raw of lines) {
+    const trimmed = raw.trimStart();
+    const match = trimmed.match(ERROR_RE);
+    if (match) {
+      const [, file, lineStr, colStr, code, msg] = match;
+      const isRelated = raw.startsWith("  ");
+      if (isRelated && current) {
+        const cleanFile = file.trim();
+        if (!current.relatedFiles.includes(cleanFile)) {
+          current.relatedFiles.push(cleanFile);
+        }
+      } else {
+        flushCurrent();
+        current = {
+          file: file.trim(),
+          line: parseInt(lineStr, 10),
+          col: parseInt(colStr, 10),
+          code,
+          message: msg,
+          relatedFiles: []
+        };
+      }
+    } else if (current && raw.startsWith("  ") && raw.trim().length > 0) {
+      const locMatch = trimmed.match(RELATED_LOCATION_RE);
+      if (locMatch) {
+        const cleanFile = locMatch[1].trim();
+        if (!current.relatedFiles.includes(cleanFile)) {
+          current.relatedFiles.push(cleanFile);
+        }
+      } else {
+        current.message += "\n" + raw.trim();
+      }
+    }
+  }
+  flushCurrent();
+  return errors;
+  function flushCurrent() {
+    if (!current) return;
+    const key = `${current.file}:${current.line}:${current.code}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      errors.push(current);
+    }
+    current = null;
+  }
+}
+
+// src/utils/tsc-autofix.ts
+function runTscCheck(projectRoot, timeout = 3e4) {
+  const tsconfigPath = resolve(projectRoot, "tsconfig.json");
+  if (!existsSync(tsconfigPath)) return [];
+  try {
+    execSync("npx tsc --noEmit 2>&1", {
+      cwd: projectRoot,
+      timeout,
+      encoding: "utf-8"
+    });
+    return [];
+  } catch (err) {
+    if (err && typeof err === "object" && "killed" in err && err.killed) {
+      console.log("  \u26A0 TypeScript check timed out \u2014 skipping");
+      return [];
+    }
+    const e = err;
+    const output = (e.stdout || "") + (e.stderr || "");
+    return parseTscOutput(output);
+  }
+}
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+  return dp[m][n];
+}
+function maxLevenshtein(fieldName) {
+  return Math.max(1, Math.floor(fieldName.length * 0.4));
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var MISSING_PROP_RE = /Property '(\w+)' is missing in type '\{([^}]*)\}'/;
+var UNION_RE = /Type 'string' is not assignable to type '((?:"[^"]+"\s*\|\s*)*"[^"]+")'/;
+var MISSING_REQUIRED_RE = /Property '(\w+)' is missing in type .* but required/;
+function extractFieldsFromCode(code, line) {
+  const lines = code.split("\n");
+  const searchRange = lines.slice(Math.max(0, line - 3), line + 3).join(" ");
+  const fieldMatches = searchRange.match(/(\w+)\s*:/g);
+  if (!fieldMatches) return [];
+  return fieldMatches.map((m) => m.replace(/\s*:$/, ""));
+}
+function fixFieldRename(code, error, errorLine) {
+  const match = error.message.match(MISSING_PROP_RE);
+  const expectedField = match?.[1] ?? error.message.match(/Property '(\w+)' is missing/)?.[1];
+  if (!expectedField) return null;
+  let typeFields;
+  if (match?.[2]) {
+    typeFields = match[2].split(";").map((f) => f.trim().split(":")[0]?.trim()).filter(Boolean);
+  } else {
+    typeFields = extractFieldsFromCode(code, errorLine ?? error.line);
+  }
+  let bestMatch = null;
+  let bestDist = Infinity;
+  for (const field of typeFields) {
+    if (field === expectedField) continue;
+    if (field.includes(expectedField) || expectedField.includes(field)) {
+      bestMatch = field;
+      bestDist = 0;
+      break;
+    }
+    const dist = levenshtein(field.toLowerCase(), expectedField.toLowerCase());
+    if (dist <= maxLevenshtein(expectedField) && dist < bestDist) {
+      bestDist = dist;
+      bestMatch = field;
+    }
+  }
+  if (!bestMatch) return null;
+  const targetLine = errorLine ?? error.line;
+  const lines = code.split("\n");
+  const targetIdx = targetLine - 1;
+  const windowStart = Math.max(0, targetIdx - 5);
+  const windowEnd = Math.min(lines.length, targetIdx + 6);
+  const fieldRe = new RegExp(`(\\b)${escapeRegExp(bestMatch)}(\\s*:)`, "g");
+  for (let i = windowStart; i < windowEnd; i++) {
+    if (fieldRe.test(lines[i])) {
+      lines[i] = lines[i].replace(fieldRe, `$1${expectedField}$2`);
+    }
+    fieldRe.lastIndex = 0;
+  }
+  const newCode = lines.join("\n");
+  if (newCode === code) return null;
+  return { code: newCode, field: `${bestMatch} \u2192 ${expectedField}` };
+}
+function fixUnionType(code, error) {
+  const match = error.message.match(UNION_RE);
+  if (!match) return null;
+  const variants = match[1].match(/"([^"]+)"/g)?.map((v) => v.replace(/"/g, ""));
+  if (!variants || variants.length === 0) return null;
+  const lines = code.split("\n");
+  const errorLine = lines[error.line - 1];
+  if (!errorLine) return null;
+  for (const variant of variants) {
+    const caseInsensitiveRe = new RegExp(`['"]${escapeRegExp(variant)}['"]`, "i");
+    const exactRe = new RegExp(`['"]${escapeRegExp(variant)}['"]`);
+    if (caseInsensitiveRe.test(errorLine) && !exactRe.test(errorLine)) {
+      lines[error.line - 1] = errorLine.replace(caseInsensitiveRe, `'${variant}'`);
+      return { code: lines.join("\n"), fix: `union case: '${variant}'` };
+    }
+  }
+  return null;
+}
+function fixMissingEventHandler(code, error) {
+  const match = error.message.match(MISSING_REQUIRED_RE);
+  if (!match) return null;
+  const propName = match[1];
+  if (!propName.startsWith("on") || propName.length < 3) return null;
+  if (propName[2] !== propName[2].toUpperCase()) return null;
+  const lines = code.split("\n");
+  const errorLine = lines[error.line - 1];
+  if (!errorLine) return null;
+  const closingMatch = errorLine.match(/(\s*\/?>)/);
+  if (!closingMatch) return null;
+  const insertPos = errorLine.lastIndexOf(closingMatch[1]);
+  lines[error.line - 1] = errorLine.slice(0, insertPos) + ` ${propName}={() => {}}` + errorLine.slice(insertPos);
+  return { code: lines.join("\n"), prop: propName };
+}
+function deduplicateErrors(errors) {
+  const seen = /* @__PURE__ */ new Set();
+  return errors.filter((e) => {
+    const key = `${e.file}:${e.line}:${e.code}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function applyDeterministicFixes(errors, projectRoot, backups) {
+  const deduped = deduplicateErrors(errors);
+  const fixed = [];
+  const remaining = [];
+  const fileErrors = /* @__PURE__ */ new Map();
+  for (const err of deduped) {
+    const list = fileErrors.get(err.file) || [];
+    list.push(err);
+    fileErrors.set(err.file, list);
+  }
+  for (const [file, errs] of fileErrors) {
+    const absPath = resolve(projectRoot, file);
+    let code;
+    try {
+      code = readFileSync(absPath, "utf-8");
+    } catch {
+      remaining.push(...errs);
+      continue;
+    }
+    let changed = false;
+    const fileRemaining = [];
+    for (const e of errs) {
+      const renameResult = fixFieldRename(code, e, e.line);
+      if (renameResult) {
+        code = renameResult.code;
+        changed = true;
+        continue;
+      }
+      const unionResult = fixUnionType(code, e);
+      if (unionResult) {
+        code = unionResult.code;
+        changed = true;
+        continue;
+      }
+      const handlerResult = fixMissingEventHandler(code, e);
+      if (handlerResult) {
+        code = handlerResult.code;
+        changed = true;
+        continue;
+      }
+      fileRemaining.push(e);
+    }
+    if (changed) {
+      const { ok } = safeWrite(absPath, code, projectRoot, backups);
+      if (ok) {
+        fixed.push(file);
+        remaining.push(...fileRemaining);
+      } else {
+        remaining.push(...errs);
+      }
+    } else {
+      remaining.push(...fileRemaining);
+    }
+  }
+  return { fixed, remaining };
+}
+
+export {
+  runTscCheck,
+  fixFieldRename,
+  fixUnionType,
+  fixMissingEventHandler,
+  applyDeterministicFixes
+};

package/dist/index.js

@@ -53,6 +53,10 @@ import {
   savePlan,
   updateArchitecturePlan
 } from "./chunk-VLBVBF6V.js";
+import {
+  isValidTsx,
+  safeWrite
+} from "./chunk-U6M76BKY.js";
 import {
   toKebabCase,
   toTitleCase
@@ -5018,6 +5022,65 @@ async function applyModification(request, dsm, cm, pm, projectRoot, aiProvider,
             allFixes.forEach((f) => console.log(chalk8.dim(`     ${f}`)));
           }
           await writeFile(filePath, codeToWrite);
+          try {
+            const { runTscCheck, applyDeterministicFixes } = await import("./tsc-autofix-S5PKMFSC.js");
+            const tscBackups = /* @__PURE__ */ new Map();
+            const relPath = filePath.replace(projectRoot + "/", "").replace(projectRoot + "\\", "");
+            const tscErrors = runTscCheck(projectRoot).filter((e) => e.file === relPath);
+            if (tscErrors.length > 0) {
+              let bestSnapshot = codeToWrite;
+              const detResult = await applyDeterministicFixes(tscErrors, projectRoot, tscBackups);
+              const bestErrorCount = detResult.remaining.length;
+              if (detResult.fixed.length > 0) {
+                codeToWrite = await readFile(filePath);
+                bestSnapshot = codeToWrite;
+                console.log(
+                  chalk8.green(`  \u2714 Fixed ${tscErrors.length - detResult.remaining.length} TypeScript error(s)`)
+                );
+              }
+              if (detResult.remaining.length > 0 && aiProvider) {
+                try {
+                  const ai = await createAIProvider(aiProvider);
+                  if (ai.editPageCode) {
+                    const errorList = detResult.remaining.map((e) => `Line ${e.line}: [${e.code}] ${e.message.split("\n")[0]}`).join("\n");
+                    const tscFixed = await ai.editPageCode(
+                      codeToWrite,
+                      `Fix these TypeScript errors:
+${errorList}
+
+Keep all existing functionality intact.`,
+                      page.name || page.id || "Page"
+                    );
+                    if (tscFixed && tscFixed.length > 100) {
+                      const { code: reFixed } = await autoFixCode(tscFixed, autoFixCtx);
+                      await writeFile(filePath, reFixed);
+                      const afterErrors = runTscCheck(projectRoot).filter((e) => e.file === relPath);
+                      if (afterErrors.length > bestErrorCount) {
+                        await writeFile(filePath, bestSnapshot);
+                        codeToWrite = bestSnapshot;
+                        console.log(chalk8.yellow(`  \u26A0 AI fix regressed TypeScript errors. Reverted to best version.`));
+                      } else {
+                        codeToWrite = reFixed;
+                        console.log(
+                          chalk8.green(
+                            `  \u2714 Fixed ${detResult.remaining.length - afterErrors.length} TypeScript error(s) via AI`
+                          )
+                        );
+                      }
+                    }
+                  }
+                } catch (tscAiErr) {
+                  console.log(
+                    chalk8.dim(`  \u26A0 AI tsc fix skipped: ${tscAiErr instanceof Error ? tscAiErr.message : "unknown"}`)
+                  );
+                }
+              }
+            }
+          } catch (tscErr) {
+            console.log(
+              chalk8.dim(`  \u26A0 TypeScript check skipped: ${tscErr instanceof Error ? tscErr.message : "unknown"}`)
+            );
+          }
           const pageIdx = dsm.getConfig().pages.findIndex((p) => p.id === page.id);
           if (pageIdx !== -1) {
             const cfg = dsm.getConfig();
@@ -8084,8 +8147,8 @@ async function regenerateDocsCommand() {
 
 // src/commands/fix.ts
 import chalk15 from "chalk";
-import { readdirSync as readdirSync7, readFileSync as readFileSync11, existsSync as existsSync15, rmSync as rmSync5, mkdirSync as mkdirSync7 } from "fs";
-import { resolve as resolve8, join as join12, relative as relative5, basename as basename3 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync10, existsSync as existsSync14, rmSync as rmSync5, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve8, join as join11, relative as relative5, basename as basename3 } from "path";
 import {
   DesignSystemManager as DesignSystemManager9,
   ComponentManager as ComponentManager5,
@@ -8094,54 +8157,6 @@ import {
   loadManifest as loadManifest9,
   saveManifest as saveManifest5
 } from "@getcoherent/core";
-
-// src/commands/fix-validation.ts
-import { createRequire } from "module";
-import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
-import { join as join11 } from "path";
-var cachedTs = null;
-var cachedProjectRoot = null;
-function isValidTsx(code, projectRoot, ext = ".tsx") {
-  if (ext !== ".tsx" && ext !== ".ts") return true;
-  const pkgJson = join11(projectRoot, "package.json");
-  if (!existsSync14(pkgJson)) return true;
-  try {
-    if (!cachedTs || cachedProjectRoot !== projectRoot) {
-      const req = createRequire(pkgJson);
-      cachedTs = req("typescript");
-      cachedProjectRoot = projectRoot;
-    }
-    const sf = cachedTs.createSourceFile(
-      "check.tsx",
-      code,
-      cachedTs.ScriptTarget.Latest,
-      false,
-      cachedTs.ScriptKind.TSX
-    );
-    const diagnostics = sf.parseDiagnostics;
-    return !diagnostics || diagnostics.length === 0;
-  } catch {
-    return true;
-  }
-}
-function safeWrite(filePath, newContent, projectRoot, backups) {
-  if (!backups.has(filePath)) {
-    try {
-      backups.set(filePath, readFileSync10(filePath, "utf-8"));
-    } catch {
-    }
-  }
-  const ext = filePath.slice(filePath.lastIndexOf("."));
-  writeFileSync9(filePath, newContent, "utf-8");
-  if (!isValidTsx(newContent, projectRoot, ext)) {
-    const original = backups.get(filePath);
-    if (original) writeFileSync9(filePath, original, "utf-8");
-    return { ok: false };
-  }
-  return { ok: true };
-}
-
-// src/commands/fix.ts
 function extractComponentIdsFromCode2(code) {
   const ids = /* @__PURE__ */ new Set();
   const allMatches = code.matchAll(/@\/components\/((?:ui\/)?[a-z0-9-]+)/g);
@@ -8159,7 +8174,7 @@ function listTsxFiles(dir) {
   try {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = join12(dir, e.name);
+      const full = join11(dir, e.name);
       if (e.isDirectory() && e.name !== "node_modules" && !e.name.startsWith(".")) {
         files.push(...listTsxFiles(full));
       } else if (e.isFile() && e.name.endsWith(".tsx")) {
@@ -8190,8 +8205,8 @@ async function fixCommand(opts = {}) {
     console.log(chalk15.cyan("\ncoherent fix\n"));
   }
   if (!skipCache) {
-    const nextDir = join12(projectRoot, ".next");
-    if (existsSync15(nextDir)) {
+    const nextDir = join11(projectRoot, ".next");
+    if (existsSync14(nextDir)) {
       if (!dryRun) rmSync5(nextDir, { recursive: true, force: true });
       fixes.push("Cleared build cache");
       console.log(chalk15.green("  \u2714 Cleared build cache"));
@@ -8218,7 +8233,7 @@ async function fixCommand(opts = {}) {
   const componentsTsxFiles = listTsxFiles(resolve8(projectRoot, "components"));
   const allComponentIds = /* @__PURE__ */ new Set();
   for (const file of [...allTsxFiles, ...componentsTsxFiles]) {
-    const content = readFileSync11(file, "utf-8");
+    const content = readFileSync10(file, "utf-8");
     extractComponentIdsFromCode2(content).forEach((id) => allComponentIds.add(id));
   }
   let dsm = null;
@@ -8238,7 +8253,7 @@ async function fixCommand(opts = {}) {
       } else {
         const fileName = toKebabCase(id) + ".tsx";
         const filePath = resolve8(projectRoot, "components", "ui", fileName);
-        if (!existsSync15(filePath)) missingFiles.push(id);
+        if (!existsSync14(filePath)) missingFiles.push(id);
       }
     }
     const provider = getComponentProvider();
@@ -8287,7 +8302,7 @@ async function fixCommand(opts = {}) {
       }
     }
   }
-  if (!dsm && existsSync15(project.configPath)) {
+  if (!dsm && existsSync14(project.configPath)) {
     dsm = new DesignSystemManager9(project.configPath);
     await dsm.load();
   }
@@ -8296,8 +8311,8 @@ async function fixCommand(opts = {}) {
     let derivedName = null;
     try {
       const pkgPath = resolve8(projectRoot, "package.json");
-      if (existsSync15(pkgPath)) {
-        const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+      if (existsSync14(pkgPath)) {
+        const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
         if (typeof pkg.name === "string" && pkg.name) {
           derivedName = toTitleCase2(pkg.name);
         }
@@ -8334,8 +8349,8 @@ async function fixCommand(opts = {}) {
     const configName = dsm.getConfig().name;
     if (configName && configName !== "My App") {
       const appLayoutPath = resolve8(projectRoot, "app", "(app)", "layout.tsx");
-      if (existsSync15(appLayoutPath)) {
-        let appLayoutCode = readFileSync11(appLayoutPath, "utf-8");
+      if (existsSync14(appLayoutPath)) {
+        let appLayoutCode = readFileSync10(appLayoutPath, "utf-8");
         if (appLayoutCode.includes("My App")) {
           appLayoutCode = appLayoutCode.replace(/My App/g, configName);
           if (!dryRun) {
@@ -8353,11 +8368,11 @@ async function fixCommand(opts = {}) {
         }
       }
       const sharedDir = resolve8(projectRoot, "components", "shared");
-      if (existsSync15(sharedDir)) {
+      if (existsSync14(sharedDir)) {
         try {
           for (const f of readdirSync7(sharedDir).filter((n) => n.endsWith(".tsx"))) {
-            const sharedPath = join12(sharedDir, f);
-            const sharedCode = readFileSync11(sharedPath, "utf-8");
+            const sharedPath = join11(sharedDir, f);
+            const sharedCode = readFileSync10(sharedPath, "utf-8");
             if (sharedCode.includes("My App")) {
               const updated = sharedCode.replace(/My App/g, configName);
               if (!dryRun) {
@@ -8381,7 +8396,7 @@ async function fixCommand(opts = {}) {
   let syntaxFixed = 0;
   for (const file of userTsxFiles) {
     try {
-      const content = readFileSync11(file, "utf-8");
+      const content = readFileSync10(file, "utf-8");
       const fixed = fixUnescapedLtInJsx(
         fixEscapedClosingQuotes(sanitizeMetadataStrings(ensureUseClientIfNeeded(content)))
       );
@@ -8424,7 +8439,7 @@ async function fixCommand(opts = {}) {
       console.log(chalk15.green(`  \u2714 Verified group layouts: ${layoutTypes}`));
       const hasSidebar = plan.groups.some((g) => g.layout === "sidebar" || g.layout === "both");
       const sidebarPath = resolve8(projectRoot, "components", "shared", "sidebar.tsx");
-      if (hasSidebar && !existsSync15(sidebarPath) && !dryRun) {
+      if (hasSidebar && !existsSync14(sidebarPath) && !dryRun) {
         if (!dsm) {
           dsm = new DesignSystemManager9(project.configPath);
           await dsm.load();
@@ -8443,8 +8458,8 @@ async function fixCommand(opts = {}) {
       }
       if (hasSidebar && !dryRun) {
         const rootLayoutPath = resolve8(projectRoot, "app", "layout.tsx");
-        if (existsSync15(rootLayoutPath)) {
-          let rootCode = readFileSync11(rootLayoutPath, "utf-8");
+        if (existsSync14(rootLayoutPath)) {
+          let rootCode = readFileSync10(rootLayoutPath, "utf-8");
           if (rootCode.includes("<Header")) {
             rootCode = rootCode.replace(/import\s*\{[^}]*Header[^}]*\}[^;\n]*[;\n]?\s*/g, "").replace(/import\s*\{[^}]*Footer[^}]*\}[^;\n]*[;\n]?\s*/g, "").replace(/import\s+ShowWhenNotAuthRoute[^;\n]*[;\n]?\s*/g, "").replace(/<ShowWhenNotAuthRoute>[\s\S]*?<\/ShowWhenNotAuthRoute>/g, (match) => {
               const inner = match.replace(/<\/?ShowWhenNotAuthRoute>/g, "").trim();
@@ -8462,8 +8477,8 @@ async function fixCommand(opts = {}) {
           }
         }
         const publicLayoutPath = resolve8(projectRoot, "app", "(public)", "layout.tsx");
-        const publicExists = existsSync15(publicLayoutPath);
-        const needsPublicLayout = !publicExists || !readFileSync11(publicLayoutPath, "utf-8").includes("<Header");
+        const publicExists = existsSync14(publicLayoutPath);
+        const needsPublicLayout = !publicExists || !readFileSync10(publicLayoutPath, "utf-8").includes("<Header");
         if (needsPublicLayout) {
           const { buildPublicLayoutCodeForSidebar } = await import("./code-generator-YSGVHVNN.js");
           mkdirSync7(resolve8(projectRoot, "app", "(public)"), { recursive: true });
@@ -8476,8 +8491,8 @@ async function fixCommand(opts = {}) {
           }
         }
         const sidebarComponentPath2 = resolve8(projectRoot, "components", "shared", "sidebar.tsx");
-        if (existsSync15(sidebarComponentPath2)) {
-          const existingSidebarCode = readFileSync11(sidebarComponentPath2, "utf-8");
+        if (existsSync14(sidebarComponentPath2)) {
+          const existingSidebarCode = readFileSync10(sidebarComponentPath2, "utf-8");
           const sidebarConfigName = dsm?.getConfig().name ?? "";
           const hasWrongName = existingSidebarCode.includes("My App") && sidebarConfigName !== "My App";
           const hasTrigger = existingSidebarCode.includes("SidebarTrigger");
@@ -8505,7 +8520,7 @@ async function fixCommand(opts = {}) {
         }
         const rootPagePath = resolve8(projectRoot, "app", "page.tsx");
         const publicPagePath = resolve8(projectRoot, "app", "(public)", "page.tsx");
-        if (existsSync15(rootPagePath) && !existsSync15(publicPagePath)) {
+        if (existsSync14(rootPagePath) && !existsSync14(publicPagePath)) {
           const { renameSync } = await import("fs");
           mkdirSync7(resolve8(projectRoot, "app", "(public)"), { recursive: true });
           renameSync(rootPagePath, publicPagePath);
@@ -8513,7 +8528,7 @@ async function fixCommand(opts = {}) {
           console.log(chalk15.green("  \u2714 Moved app/page.tsx \u2192 app/(public)/page.tsx (gets Header/Footer)"));
         }
         const themeTogglePath = resolve8(projectRoot, "components", "shared", "theme-toggle.tsx");
-        if (!existsSync15(themeTogglePath)) {
+        if (!existsSync14(themeTogglePath)) {
           const { generateThemeToggleCode } = await import("./code-generator-YSGVHVNN.js");
           mkdirSync7(resolve8(projectRoot, "components", "shared"), { recursive: true });
           const themeResult = safeWrite(themeTogglePath, generateThemeToggleCode(), projectRoot, backups);
@@ -8530,8 +8545,8 @@ async function fixCommand(opts = {}) {
     console.log(chalk15.yellow(`  \u26A0 Layout repair skipped: ${err instanceof Error ? err.message : "unknown error"}`));
   }
   const appLayoutRepairPath = resolve8(projectRoot, "app", "(app)", "layout.tsx");
-  if (existsSync15(appLayoutRepairPath) && dsm) {
-    const appLayoutCode = readFileSync11(appLayoutRepairPath, "utf-8");
+  if (existsSync14(appLayoutRepairPath) && dsm) {
+    const appLayoutCode = readFileSync10(appLayoutRepairPath, "utf-8");
     const isMinimal = appLayoutCode.length < 500 && !appLayoutCode.includes("Header") && !appLayoutCode.includes("Footer") && !appLayoutCode.includes("Sidebar") && !appLayoutCode.includes("SidebarProvider") && !appLayoutCode.includes("SidebarTrigger") && !appLayoutCode.includes("Sheet");
     const navType = dsm.getConfig().navigation?.type || "header";
     if (isMinimal && navType !== "none") {
@@ -8559,7 +8574,7 @@ async function fixCommand(opts = {}) {
     const qualityFixDetails = [];
     for (const file of allValidationFiles) {
       try {
-        const content = readFileSync11(file, "utf-8");
+        const content = readFileSync10(file, "utf-8");
         const { code: autoFixed, fixes: fileFixes } = await autoFixCode(content);
         if (autoFixed !== content) {
           if (!dryRun) {
@@ -8594,7 +8609,7 @@ async function fixCommand(opts = {}) {
     let mockFixed = 0;
     for (const file of allValidationFiles) {
       try {
-        const content = readFileSync11(file, "utf-8");
+        const content = readFileSync10(file, "utf-8");
         const mockIssues = validateMockData(content);
         if (mockIssues.length > 0) {
           const fixed = applyMockDataFixes(content, mockIssues);
@@ -8625,7 +8640,7 @@ async function fixCommand(opts = {}) {
   for (const file of modifiedFiles) {
     if (!backups.has(file)) continue;
     const before = backups.get(file);
-    const after = readFileSync11(file, "utf-8");
+    const after = readFileSync10(file, "utf-8");
     const issues = verifyIncrementalEdit(before, after);
     if (issues.length > 0) {
       for (const issue of issues) {
@@ -8638,7 +8653,7 @@ async function fixCommand(opts = {}) {
   const fileIssues = [];
   for (const file of allValidationFiles) {
     try {
-      const code = readFileSync11(file, "utf-8");
+      const code = readFileSync10(file, "utf-8");
       const relativePath = file.replace(projectRoot + "/", "");
       const baseName = file.split("/").pop() || "";
       const isAuthPage = relativePath.includes("(auth)");
@@ -8748,26 +8763,64 @@ async function fixCommand(opts = {}) {
   }
   try {
     const tsconfigPath = resolve8(projectRoot, "tsconfig.json");
-    if (existsSync15(tsconfigPath)) {
-      const { execSync: execSync2 } = await import("child_process");
-      execSync2("npx tsc --noEmit 2>&1", {
-        cwd: projectRoot,
-        timeout: 3e4,
-        encoding: "utf-8"
-      });
-      fixes.push("TypeScript compilation clean");
-      console.log(chalk15.green("  \u2714 TypeScript compilation clean"));
-    }
-  } catch (err) {
-    const output = (err.stdout || "") + (err.stderr || "");
-    const errorLines = output.split("\n").filter((l) => l.includes("error TS"));
-    if (errorLines.length > 0) {
-      for (const line of errorLines.slice(0, 10)) {
-        remaining.push(line.trim());
+    if (existsSync14(tsconfigPath)) {
+      const { runTscCheck, applyDeterministicFixes } = await import("./tsc-autofix-S5PKMFSC.js");
+      const { applyAiFixes } = await import("./tsc-ai-fix-O3EMRWV2.js");
+      const tscErrors = runTscCheck(projectRoot);
+      if (tscErrors.length === 0) {
+        fixes.push("TypeScript compilation clean");
+        console.log(chalk15.green("  \u2714 TypeScript compilation clean"));
+      } else {
+        const detResult = await applyDeterministicFixes(tscErrors, projectRoot, backups);
+        if (detResult.fixed.length > 0) {
+          fixes.push(`TypeScript: fixed ${detResult.fixed.length} file(s) deterministically`);
+          console.log(chalk15.green(`  \u2714 TypeScript: fixed ${detResult.fixed.length} file(s) deterministically`));
+        }
+        if (detResult.remaining.length > 0) {
+          let aiProvider;
+          try {
+            const { createAIProvider: createAIProvider2 } = await import("./ai-provider-CGSIYFZT.js");
+            aiProvider = await createAIProvider2("auto");
+          } catch {
+          }
+          if (aiProvider?.editPageCode) {
+            console.log(chalk15.dim(`  \u23F3 Using AI to fix ${detResult.remaining.length} TypeScript error(s)...`));
+            const aiResult = await applyAiFixes(detResult.remaining, projectRoot, backups, aiProvider);
+            if (aiResult.fixed.length > 0) {
+              fixes.push(`TypeScript: fixed ${aiResult.fixed.length} file(s) via AI`);
+              console.log(chalk15.green(`  \u2714 TypeScript: fixed ${aiResult.fixed.length} file(s) via AI`));
+            }
+            if (aiResult.failed.length > 0) {
+              for (const e of aiResult.failed.slice(0, 10)) {
+                remaining.push(`${e.file}(${e.line}): [${e.code}] ${e.message.split("\n")[0]}`);
+              }
+              if (aiResult.failed.length > 10) {
+                remaining.push(`... and ${aiResult.failed.length - 10} more TypeScript errors`);
+              }
+              console.log(chalk15.yellow(`  \u26A0 TypeScript: ${aiResult.failed.length} error(s) remaining`));
+            }
+          } else {
+            for (const e of detResult.remaining.slice(0, 10)) {
+              remaining.push(`${e.file}(${e.line}): [${e.code}] ${e.message.split("\n")[0]}`);
+            }
+            if (detResult.remaining.length > 10) {
+              remaining.push(`... and ${detResult.remaining.length - 10} more TypeScript errors`);
+            }
+            console.log(
+              chalk15.yellow(
+                `  \u26A0 TypeScript: ${detResult.remaining.length} error(s) remaining. Configure API key for auto-fix.`
+              )
+            );
+          }
+        }
+        const finalErrors = runTscCheck(projectRoot);
+        if (finalErrors.length === 0) {
+          console.log(chalk15.green("  \u2714 TypeScript compilation now clean"));
+        }
       }
-      if (errorLines.length > 10) remaining.push(`... and ${errorLines.length - 10} more TypeScript errors`);
-      console.log(chalk15.yellow(`  \u26A0 TypeScript: ${errorLines.length} error(s)`));
     }
+  } catch (err) {
+    console.log(chalk15.yellow(`  \u26A0 TypeScript check skipped: ${err instanceof Error ? err.message : "unknown error"}`));
   }
   if (fixes.length === 0 && totalErrors === 0 && totalWarnings === 0 && remaining.length === 0) {
     console.log(chalk15.green("\n  \u2705 Everything looks good \u2014 no issues found\n"));
@@ -8798,7 +8851,7 @@ async function fixCommand(opts = {}) {
 // src/commands/check.ts
 import chalk16 from "chalk";
 import { resolve as resolve9 } from "path";
-import { readdirSync as readdirSync8, readFileSync as readFileSync12, statSync as statSync3, existsSync as existsSync16 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync11, statSync as statSync3, existsSync as existsSync15 } from "fs";
 import { loadManifest as loadManifest10 } from "@getcoherent/core";
 var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", "design-system"]);
 function findTsxFiles(dir) {
@@ -8855,7 +8908,7 @@ async function checkCommand(opts = {}) {
       "NATIVE_TABLE"
     ]);
     for (const file of files) {
-      const code = readFileSync12(file, "utf-8");
+      const code = readFileSync11(file, "utf-8");
       const relativePath = file.replace(projectRoot + "/", "");
       const baseName = file.split("/").pop() || "";
       const isAuthPage = relativePath.includes("(auth)");
@@ -8897,7 +8950,7 @@ async function checkCommand(opts = {}) {
     routeSet.add("/");
     routeSet.add("#");
     for (const file of files) {
-      const code = readFileSync12(file, "utf-8");
+      const code = readFileSync11(file, "utf-8");
       const relativePath = file.replace(projectRoot + "/", "");
       const lines = code.split("\n");
       const linkHrefRe = /href\s*=\s*["'](\/[a-z0-9/-]*)["']/gi;
@@ -8930,7 +8983,7 @@ async function checkCommand(opts = {}) {
       if (manifest.shared.length > 0) {
         for (const entry of manifest.shared) {
           const fullPath = resolve9(project.root, entry.file);
-          if (!existsSync16(fullPath)) {
+          if (!existsSync15(fullPath)) {
             result.pages.withErrors++;
             if (!opts.json) console.log(chalk16.red(`
   \u2717 Missing shared component file: ${entry.id} (${entry.file})`));
@@ -8955,7 +9008,7 @@ async function checkCommand(opts = {}) {
       let _nameMismatch = 0;
       for (const entry of manifest.shared) {
         const filePath = resolve9(projectRoot, entry.file);
-        const fileExists = existsSync16(filePath);
+        const fileExists = existsSync15(filePath);
         if (!fileExists) {
           _orphaned++;
           if (!opts.json) {
@@ -8965,7 +9018,7 @@ async function checkCommand(opts = {}) {
           continue;
         }
         try {
-          const code = readFileSync12(filePath, "utf-8");
+          const code = readFileSync11(filePath, "utf-8");
           const actualExports = extractExportedComponentNames(code);
           if (actualExports.length > 0 && !actualExports.includes(entry.name)) {
             _nameMismatch++;
@@ -9033,7 +9086,7 @@ async function checkCommand(opts = {}) {
           id: e.id,
           name: e.name,
           type: e.type,
-          status: existsSync16(resolve9(projectRoot, e.file)) ? "ok" : "unused",
+          status: existsSync15(resolve9(projectRoot, e.file)) ? "ok" : "unused",
           message: "",
           suggestions: void 0
         }))
@@ -9047,11 +9100,11 @@ async function checkCommand(opts = {}) {
       const { inferPageTypeFromRoute: inferPageTypeFromRoute2 } = await import("./design-constraints-HGNEY3W3.js");
       const manifest = await loadManifest10(projectRoot);
       const appDir = resolve9(projectRoot, "app");
-      const pageFiles = existsSync16(appDir) ? findTsxFiles(appDir) : [];
+      const pageFiles = existsSync15(appDir) ? findTsxFiles(appDir) : [];
       if (manifest.shared.length > 0 && pageFiles.length > 0) {
         const reuseWarnings = [];
         for (const file of pageFiles) {
-          const code = readFileSync12(file, "utf-8");
+          const code = readFileSync11(file, "utf-8");
           const relativePath = file.replace(projectRoot + "/", "");
           const route = "/" + relativePath.replace(/^app\//, "").replace(/\/page\.tsx$/, "").replace(/^\(.*?\)\//, "");
           const pageType = inferPageTypeFromRoute2(route);
@@ -9162,12 +9215,12 @@ import {
   generateSharedComponent as generateSharedComponent4,
   integrateSharedLayoutIntoRootLayout as integrateSharedLayoutIntoRootLayout2
 } from "@getcoherent/core";
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { resolve as resolve10 } from "path";
 
 // src/utils/ds-files.ts
 import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
-import { join as join13, dirname as dirname5 } from "path";
+import { join as join12, dirname as dirname5 } from "path";
 import { DesignSystemGenerator } from "@getcoherent/core";
 var SHARED_DS_KEYS = [
   "app/design-system/shared/page.tsx",
@@ -9181,7 +9234,7 @@ async function writeDesignSystemFiles(projectRoot, config2, options) {
   const toWrite = options?.sharedOnly ? new Map([...files].filter(([path3]) => SHARED_DS_KEYS.includes(path3))) : files;
   const written = [];
   for (const [relativePath, content] of toWrite) {
-    const fullPath = join13(projectRoot, relativePath);
+    const fullPath = join12(projectRoot, relativePath);
     await mkdir3(dirname5(fullPath), { recursive: true });
     await writeFile4(fullPath, content, "utf-8");
     written.push(relativePath);
@@ -9317,7 +9370,7 @@ function createComponentsCommand() {
       if (updated) console.log(chalk22.cyan("   Updated app/layout.tsx to use shared layout components.\n"));
     }
     const sharedPagePath = resolve10(project.root, "app/design-system/shared/page.tsx");
-    if (!existsSync17(sharedPagePath)) {
+    if (!existsSync16(sharedPagePath)) {
       try {
         const dsm = new DesignSystemManager10(project.configPath);
         await dsm.load();
@@ -9343,8 +9396,8 @@ function createComponentsCommand() {
 import chalk23 from "chalk";
 import ora6 from "ora";
 import { writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
-import { resolve as resolve11, join as join14, dirname as dirname6 } from "path";
-import { existsSync as existsSync18 } from "fs";
+import { resolve as resolve11, join as join13, dirname as dirname6 } from "path";
+import { existsSync as existsSync17 } from "fs";
 import {
   FigmaClient,
   parseFigmaFileResponse,
@@ -9491,7 +9544,7 @@ async function importFigmaAction(urlOrKey, opts) {
       stats.filesWritten.push(filePath);
       return;
     }
-    const fullPath = join14(projectRoot, filePath);
+    const fullPath = join13(projectRoot, filePath);
     await mkdir4(dirname6(fullPath), { recursive: true });
     await writeFile5(fullPath, content, "utf-8");
     stats.filesWritten.push(filePath);
@@ -9593,7 +9646,7 @@ async function importFigmaAction(urlOrKey, opts) {
       spinner.start("Updating design-system.config.ts...");
       const configPath = resolve11(projectRoot, DESIGN_SYSTEM_CONFIG_PATH);
       const dsm = new DesignSystemManager11(configPath);
-      if (existsSync18(configPath)) {
+      if (existsSync17(configPath)) {
         await dsm.load();
         const existing = dsm.getConfig();
         dsm.updateConfig({
@@ -9622,8 +9675,8 @@ export const config = ${JSON.stringify(fullConfig, null, 2)} as const
       stats.configUpdated = true;
       spinner.succeed("design-system.config.ts updated");
       spinner.start("Ensuring root layout...");
-      const layoutPath = join14(projectRoot, "app/layout.tsx");
-      if (!existsSync18(layoutPath)) {
+      const layoutPath = join13(projectRoot, "app/layout.tsx");
+      if (!existsSync17(layoutPath)) {
         await mkdir4(dirname6(layoutPath), { recursive: true });
         await writeFile5(layoutPath, MINIMAL_ROOT_LAYOUT, "utf-8");
         stats.filesWritten.push("app/layout.tsx");
@@ -9713,8 +9766,8 @@ async function dsRegenerateCommand() {
 // src/commands/update.ts
 import chalk25 from "chalk";
 import ora8 from "ora";
-import { readFileSync as readFileSync13, existsSync as existsSync19 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync18 } from "fs";
+import { join as join14 } from "path";
 import { DesignSystemManager as DesignSystemManager13, CLI_VERSION as CLI_VERSION4 } from "@getcoherent/core";
 
 // src/utils/migrations.ts
@@ -9883,20 +9936,20 @@ var EXPECTED_CSS_VARS = [
   "--sidebar-ring"
 ];
 function checkMissingCssVars(projectRoot) {
-  const globalsPath = join15(projectRoot, "app", "globals.css");
-  if (!existsSync19(globalsPath)) return [];
+  const globalsPath = join14(projectRoot, "app", "globals.css");
+  if (!existsSync18(globalsPath)) return [];
   try {
-    const content = readFileSync13(globalsPath, "utf-8");
+    const content = readFileSync12(globalsPath, "utf-8");
     return EXPECTED_CSS_VARS.filter((v) => !content.includes(v));
   } catch {
     return [];
   }
 }
 function patchGlobalsCss(projectRoot, missingVars) {
-  const globalsPath = join15(projectRoot, "app", "globals.css");
-  if (!existsSync19(globalsPath) || missingVars.length === 0) return;
-  const { writeFileSync: writeFileSync12 } = __require("fs");
-  let content = readFileSync13(globalsPath, "utf-8");
+  const globalsPath = join14(projectRoot, "app", "globals.css");
+  if (!existsSync18(globalsPath) || missingVars.length === 0) return;
+  const { writeFileSync: writeFileSync11 } = __require("fs");
+  let content = readFileSync12(globalsPath, "utf-8");
   const defaultValues = {
     "--chart-1": "220 70% 50%",
     "--chart-2": "160 60% 45%",
@@ -9924,7 +9977,7 @@ function patchGlobalsCss(projectRoot, missingVars) {
   const lightSectionEnd = content.indexOf("}");
   if (lightSectionEnd > 0) {
     content = content.slice(0, lightSectionEnd) + "\n" + injection + "\n" + content.slice(lightSectionEnd);
-    writeFileSync12(globalsPath, content, "utf-8");
+    writeFileSync11(globalsPath, content, "utf-8");
   }
 }
 
@@ -9974,26 +10027,26 @@ async function undoCommand(options) {
 // src/commands/sync.ts
 import chalk27 from "chalk";
 import ora9 from "ora";
-import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
-import { join as join16, relative as relative6, dirname as dirname7 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
+import { join as join15, relative as relative6, dirname as dirname7 } from "path";
 import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
 import { DesignSystemManager as DesignSystemManager14 } from "@getcoherent/core";
 import { loadManifest as loadManifest12, saveManifest as saveManifest6, findSharedComponent } from "@getcoherent/core";
 function extractTokensFromProject(projectRoot) {
   const lightColors = {};
   const darkColors = {};
-  const globalsPath = join16(projectRoot, "app", "globals.css");
-  if (existsSync20(globalsPath)) {
-    const css = readFileSync14(globalsPath, "utf-8");
+  const globalsPath = join15(projectRoot, "app", "globals.css");
+  if (existsSync19(globalsPath)) {
+    const css = readFileSync13(globalsPath, "utf-8");
     const rootMatch = css.match(/:root\s*\{([^}]+)\}/s);
     if (rootMatch) parseVarsInto(rootMatch[1], lightColors);
     const darkMatch = css.match(/\.dark\s*\{([^}]+)\}/s);
     if (darkMatch) parseVarsInto(darkMatch[1], darkColors);
   }
-  const layoutPath = join16(projectRoot, "app", "layout.tsx");
+  const layoutPath = join15(projectRoot, "app", "layout.tsx");
   let layoutCode = "";
-  if (existsSync20(layoutPath)) {
-    layoutCode = readFileSync14(layoutPath, "utf-8");
+  if (existsSync19(layoutPath)) {
+    layoutCode = readFileSync13(layoutPath, "utf-8");
     const rootInline = layoutCode.match(/:root\s*\{([^}]+)\}/s);
     if (rootInline && Object.keys(lightColors).length === 0) {
       parseVarsInto(rootInline[1], lightColors);
@@ -10011,7 +10064,7 @@ function extractTokensFromProject(projectRoot) {
     defaultMode = "dark";
   }
   let radius;
-  const allCss = [existsSync20(globalsPath) ? readFileSync14(globalsPath, "utf-8") : "", layoutCode].join("\n");
+  const allCss = [existsSync19(globalsPath) ? readFileSync13(globalsPath, "utf-8") : "", layoutCode].join("\n");
   const radiusMatch = allCss.match(/--radius:\s*([^;]+);/);
   if (radiusMatch) radius = radiusMatch[1].trim();
   return {
@@ -10034,8 +10087,8 @@ function parseVarsInto(block, target) {
 }
 async function detectCustomComponents(projectRoot, allPageCode) {
   const results = [];
-  const componentsDir = join16(projectRoot, "components");
-  if (!existsSync20(componentsDir)) return results;
+  const componentsDir = join15(projectRoot, "components");
+  if (!existsSync19(componentsDir)) return results;
   const files = [];
   await walkForTsx(componentsDir, files, ["ui"]);
   const fileResults = await Promise.all(
@@ -10062,7 +10115,7 @@ async function walkForTsx(dir, files, skipDirs) {
     return;
   }
   for (const e of entries) {
-    const full = join16(dir, e.name);
+    const full = join15(dir, e.name);
     if (e.isDirectory()) {
       if (skipDirs.includes(e.name) || e.name.startsWith(".")) continue;
       await walkForTsx(full, files, skipDirs);
@@ -10136,7 +10189,7 @@ async function discoverPages(appDir) {
       return;
     }
     for (const entry of entries) {
-      const full = join16(dir, entry.name);
+      const full = join15(dir, entry.name);
       if (entry.isDirectory()) {
         if (["design-system", "api", "_not-found"].includes(entry.name)) continue;
         if (entry.name.startsWith(".")) continue;
@@ -10225,8 +10278,8 @@ async function syncCommand(options = {}) {
   if (dryRun) console.log(chalk27.yellow("  [dry-run] No files will be written\n"));
   const spinner = ora9("Scanning project files...").start();
   try {
-    const appDir = join16(project.root, "app");
-    if (!existsSync20(appDir)) {
+    const appDir = join15(project.root, "app");
+    if (!existsSync19(appDir)) {
       spinner.fail("No app/ directory found");
       process.exit(1);
     }
@@ -10456,53 +10509,53 @@ async function syncCommand(options = {}) {
 // src/commands/migrate.ts
 import chalk28 from "chalk";
 import ora10 from "ora";
-import { existsSync as existsSync21, mkdirSync as mkdirSync8, cpSync, rmSync as rmSync6, writeFileSync as writeFileSync10, readFileSync as readFileSync15, readdirSync as readdirSync9 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync8, cpSync, rmSync as rmSync6, writeFileSync as writeFileSync9, readFileSync as readFileSync14, readdirSync as readdirSync9 } from "fs";
+import { join as join16 } from "path";
 function backupDir(projectRoot) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return join17(projectRoot, ".coherent", "backups", `pre-migrate-${ts}`);
+  return join16(projectRoot, ".coherent", "backups", `pre-migrate-${ts}`);
 }
 function guardPath(projectRoot) {
-  return join17(projectRoot, ".coherent", "migration-in-progress");
+  return join16(projectRoot, ".coherent", "migration-in-progress");
 }
 function createBackup2(projectRoot) {
-  const uiDir = join17(projectRoot, "components", "ui");
+  const uiDir = join16(projectRoot, "components", "ui");
   const dest = backupDir(projectRoot);
   mkdirSync8(dest, { recursive: true });
-  if (existsSync21(uiDir)) {
-    cpSync(uiDir, join17(dest, "components-ui"), { recursive: true });
+  if (existsSync20(uiDir)) {
+    cpSync(uiDir, join16(dest, "components-ui"), { recursive: true });
   }
-  const configPath = join17(projectRoot, "design-system.config.ts");
-  if (existsSync21(configPath)) {
-    cpSync(configPath, join17(dest, "design-system.config.ts"));
+  const configPath = join16(projectRoot, "design-system.config.ts");
+  if (existsSync20(configPath)) {
+    cpSync(configPath, join16(dest, "design-system.config.ts"));
   }
   return dest;
 }
 function setGuard(projectRoot, backupPath) {
   const guard = guardPath(projectRoot);
-  mkdirSync8(join17(projectRoot, ".coherent"), { recursive: true });
-  writeFileSync10(guard, JSON.stringify({ backup: backupPath, startedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+  mkdirSync8(join16(projectRoot, ".coherent"), { recursive: true });
+  writeFileSync9(guard, JSON.stringify({ backup: backupPath, startedAt: (/* @__PURE__ */ new Date()).toISOString() }));
 }
 function clearGuard(projectRoot) {
   const guard = guardPath(projectRoot);
-  if (existsSync21(guard)) rmSync6(guard);
+  if (existsSync20(guard)) rmSync6(guard);
 }
 function rollback(projectRoot) {
   const guard = guardPath(projectRoot);
-  if (!existsSync21(guard)) return false;
+  if (!existsSync20(guard)) return false;
   try {
-    const data = JSON.parse(readFileSync15(guard, "utf-8"));
+    const data = JSON.parse(readFileSync14(guard, "utf-8"));
     const backup = data.backup;
-    if (!existsSync21(backup)) return false;
-    const uiBackup = join17(backup, "components-ui");
-    const uiDir = join17(projectRoot, "components", "ui");
-    if (existsSync21(uiBackup)) {
-      if (existsSync21(uiDir)) rmSync6(uiDir, { recursive: true });
+    if (!existsSync20(backup)) return false;
+    const uiBackup = join16(backup, "components-ui");
+    const uiDir = join16(projectRoot, "components", "ui");
+    if (existsSync20(uiBackup)) {
+      if (existsSync20(uiDir)) rmSync6(uiDir, { recursive: true });
       cpSync(uiBackup, uiDir, { recursive: true });
     }
-    const configBackup = join17(backup, "design-system.config.ts");
-    const configDest = join17(projectRoot, "design-system.config.ts");
-    if (existsSync21(configBackup)) {
+    const configBackup = join16(backup, "design-system.config.ts");
+    const configDest = join16(projectRoot, "design-system.config.ts");
+    if (existsSync20(configBackup)) {
       cpSync(configBackup, configDest);
     }
     clearGuard(projectRoot);
@@ -10530,13 +10583,13 @@ async function migrateAction(options) {
     return;
   }
   const guard = guardPath(projectRoot);
-  if (existsSync21(guard)) {
+  if (existsSync20(guard)) {
     console.log(chalk28.yellow("A migration is already in progress."));
     console.log(chalk28.dim("Run `coherent migrate --rollback` to undo, or delete .coherent/migration-in-progress"));
     return;
   }
-  const uiDir = join17(projectRoot, "components", "ui");
-  if (!existsSync21(uiDir)) {
+  const uiDir = join16(projectRoot, "components", "ui");
+  if (!existsSync20(uiDir)) {
     console.log(chalk28.yellow("No components/ui directory found. Nothing to migrate."));
     return;
   }
@@ -10562,8 +10615,8 @@ Found ${migratable.length} component(s) to migrate:`));
   setGuard(projectRoot, backup);
   try {
     for (const id of migratable) {
-      const filePath = join17(uiDir, `${id}.tsx`);
-      if (existsSync21(filePath)) rmSync6(filePath);
+      const filePath = join16(uiDir, `${id}.tsx`);
+      if (existsSync20(filePath)) rmSync6(filePath);
     }
     const results = await provider.installBatch(migratable, projectRoot, { force: true });
     let migrated = 0;
@@ -10585,20 +10638,20 @@ Found ${migratable.length} component(s) to migrate:`));
 }
 
 // src/utils/update-notifier.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync9, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync10 } from "fs";
+import { join as join17 } from "path";
 import { homedir } from "os";
 import chalk29 from "chalk";
 import { CLI_VERSION as CLI_VERSION5 } from "@getcoherent/core";
 var DEBUG5 = process.env.COHERENT_DEBUG === "1";
 var PACKAGE_NAME = "@getcoherent/cli";
-var CACHE_DIR = join18(homedir(), ".coherent");
-var CACHE_FILE = join18(CACHE_DIR, "update-check.json");
+var CACHE_DIR = join17(homedir(), ".coherent");
+var CACHE_FILE = join17(CACHE_DIR, "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function readCache() {
   try {
-    if (!existsSync22(CACHE_FILE)) return null;
-    const raw = readFileSync16(CACHE_FILE, "utf-8");
+    if (!existsSync21(CACHE_FILE)) return null;
+    const raw = readFileSync15(CACHE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch (e) {
     if (DEBUG5) console.error("Failed to read update cache:", e);
@@ -10607,8 +10660,8 @@ function readCache() {
 }
 function writeCache(data) {
   try {
-    if (!existsSync22(CACHE_DIR)) mkdirSync9(CACHE_DIR, { recursive: true });
-    writeFileSync11(CACHE_FILE, JSON.stringify(data), "utf-8");
+    if (!existsSync21(CACHE_DIR)) mkdirSync9(CACHE_DIR, { recursive: true });
+    writeFileSync10(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (e) {
     if (DEBUG5) console.error("Failed to write update cache:", e);
   }

package/dist/tsc-ai-fix-O3EMRWV2.js

@@ -0,0 +1,98 @@
+import {
+  runTscCheck
+} from "./chunk-XPBD3L7V.js";
+import {
+  safeWrite
+} from "./chunk-U6M76BKY.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/utils/tsc-ai-fix.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+var MAX_AI_FILES = 5;
+async function applyAiFixes(errors, projectRoot, backups, aiProvider) {
+  if (!aiProvider?.editPageCode) {
+    return { fixed: [], failed: errors };
+  }
+  const fileErrors = /* @__PURE__ */ new Map();
+  for (const err of errors) {
+    const list = fileErrors.get(err.file) || [];
+    list.push(err);
+    fileErrors.set(err.file, list);
+  }
+  const fixed = [];
+  const failed = [];
+  let filesProcessed = 0;
+  for (const [file, errs] of fileErrors) {
+    filesProcessed++;
+    if (filesProcessed > MAX_AI_FILES) {
+      failed.push(...errs);
+      continue;
+    }
+    const absPath = resolve(projectRoot, file);
+    let code;
+    try {
+      code = readFileSync(absPath, "utf-8");
+    } catch {
+      failed.push(...errs);
+      continue;
+    }
+    const relatedContext = gatherRelatedContext(errs, projectRoot);
+    const errorList = errs.map((e) => `Line ${e.line}: [${e.code}] ${e.message}`).join("\n");
+    const instruction = [
+      "Fix these TypeScript compilation errors:",
+      errorList,
+      "",
+      relatedContext ? `Reference interfaces (DO NOT modify these):
+${relatedContext}` : "",
+      "",
+      "Rules:",
+      "- Fix the data/props to match the expected types",
+      "- Do NOT change component interfaces or imports from shared components",
+      "- Keep all existing functionality intact"
+    ].filter(Boolean).join("\n");
+    try {
+      const fixedCode = await aiProvider.editPageCode(code, instruction, file);
+      if (!fixedCode || fixedCode.length < 50) {
+        failed.push(...errs);
+        continue;
+      }
+      const { ok } = safeWrite(absPath, fixedCode, projectRoot, backups);
+      if (!ok) {
+        failed.push(...errs);
+        continue;
+      }
+      const afterErrors = runTscCheck(projectRoot).filter((e) => e.file === file);
+      if (afterErrors.length >= errs.length) {
+        const original = backups.get(absPath);
+        if (original) safeWrite(absPath, original, projectRoot, backups);
+        failed.push(...errs);
+      } else {
+        fixed.push(file);
+        if (afterErrors.length > 0) failed.push(...afterErrors);
+      }
+    } catch {
+      failed.push(...errs);
+    }
+  }
+  return { fixed, failed };
+}
+function gatherRelatedContext(errors, projectRoot) {
+  const relatedFiles = /* @__PURE__ */ new Set();
+  for (const err of errors) {
+    for (const f of err.relatedFiles) relatedFiles.add(f);
+  }
+  const parts = [];
+  for (const file of relatedFiles) {
+    try {
+      const content = readFileSync(resolve(projectRoot, file), "utf-8");
+      parts.push(`// --- ${file} ---
+${content}`);
+    } catch {
+    }
+  }
+  return parts.join("\n\n");
+}
+export {
+  applyAiFixes
+};

package/dist/tsc-autofix-S5PKMFSC.js

@@ -0,0 +1,16 @@
+import {
+  applyDeterministicFixes,
+  fixFieldRename,
+  fixMissingEventHandler,
+  fixUnionType,
+  runTscCheck
+} from "./chunk-XPBD3L7V.js";
+import "./chunk-U6M76BKY.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  applyDeterministicFixes,
+  fixFieldRename,
+  fixMissingEventHandler,
+  fixUnionType,
+  runTscCheck
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.46",
+  "version": "0.6.48",
   "description": "CLI interface for Coherent Design Method",
   "type": "module",
   "main": "./dist/index.js",