@getcoherent/cli 0.6.45 → 0.6.47

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
+};