@shipispec/tsfix 0.1.0 → 0.3.0

package/dist/index.js

@@ -0,0 +1,576 @@
+// src/validatorInProcess.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as ts from "typescript";
+var programCache = /* @__PURE__ */ new Map();
+function runInProcessTsc(opts) {
+  const { workspaceRoot, generatedFiles, logger } = opts;
+  const tsconfigPath = path.join(workspaceRoot, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) {
+    return {
+      passed: true,
+      output: "(no tsconfig.json \u2014 skipped)",
+      diagnostics: [],
+      lineCount: 1
+    };
+  }
+  const program = getOrCreateProgram(workspaceRoot, tsconfigPath, logger);
+  if (!program) {
+    return {
+      passed: true,
+      output: "(failed to create program \u2014 skipping)",
+      diagnostics: [],
+      lineCount: 1
+    };
+  }
+  const allDiagnostics = ts.getPreEmitDiagnostics(program);
+  const structured = formatDiagnostics(allDiagnostics, workspaceRoot);
+  const filtered = generatedFiles?.length ? structured.filter(
+    (d) => generatedFiles.some((g) => g.replace(/^\.\//, "") === d.file.replace(/^\.\//, ""))
+  ) : structured;
+  const errors = filtered.filter((d) => d.category === "error");
+  const output = errors.map((d) => `${d.file}(${d.line},${d.column}): error ${d.code}: ${d.message}`).join("\n");
+  return {
+    passed: errors.length === 0,
+    output: output || "(no errors)",
+    diagnostics: filtered,
+    lineCount: output.split("\n").length
+  };
+}
+function getOrCreateProgram(workspaceRoot, tsconfigPath, logger) {
+  let configMtime = 0;
+  try {
+    configMtime = fs.statSync(tsconfigPath).mtimeMs;
+  } catch {
+    return null;
+  }
+  const cached = programCache.get(workspaceRoot);
+  if (cached && cached.configMtime === configMtime) {
+    try {
+      const refreshed = ts.createProgram({
+        rootNames: cached.rootFiles,
+        options: cached.options,
+        host: cached.host,
+        oldProgram: cached.program
+      });
+      cached.program = refreshed;
+      return refreshed;
+    } catch (err) {
+      logger.warn(
+        `[in-process-tsc] refresh failed; rebuilding: ${err instanceof Error ? err.message : String(err)}`
+      );
+      programCache.delete(workspaceRoot);
+    }
+  }
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  if (configFile.error) {
+    logger.error(
+      `[in-process-tsc] tsconfig parse error: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+    );
+    return null;
+  }
+  const parsed = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    path.dirname(tsconfigPath)
+  );
+  if (parsed.errors.length > 0) {
+    const msgs = parsed.errors.map((e) => ts.flattenDiagnosticMessageText(e.messageText, "\n")).join("; ");
+    logger.warn(`[in-process-tsc] tsconfig parse warnings: ${msgs}`);
+  }
+  const host = ts.createCompilerHost(parsed.options);
+  const workspaceLibDir = path.join(workspaceRoot, "node_modules", "typescript", "lib");
+  if (fs.existsSync(workspaceLibDir)) {
+    const originalGetDefaultLibFileName = host.getDefaultLibFileName.bind(host);
+    host.getDefaultLibLocation = () => workspaceLibDir;
+    host.getDefaultLibFileName = (options) => {
+      const fileName = path.basename(originalGetDefaultLibFileName(options));
+      return path.join(workspaceLibDir, fileName);
+    };
+  }
+  let program;
+  try {
+    program = ts.createProgram({
+      rootNames: parsed.fileNames,
+      options: parsed.options,
+      host
+    });
+  } catch (err) {
+    logger.error(
+      `[in-process-tsc] createProgram failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+  programCache.set(workspaceRoot, {
+    rootFiles: parsed.fileNames,
+    options: parsed.options,
+    host,
+    program,
+    configMtime
+  });
+  return program;
+}
+function formatDiagnostics(diagnostics, workspaceRoot) {
+  const out = [];
+  for (const d of diagnostics) {
+    if (!d.file || d.start === void 0) {
+      out.push({
+        file: "(global)",
+        line: 0,
+        column: 0,
+        code: `TS${d.code}`,
+        message: ts.flattenDiagnosticMessageText(d.messageText, "\n"),
+        category: categoryName(d.category)
+      });
+      continue;
+    }
+    const fileName = d.file.fileName;
+    if (fileName.includes("node_modules")) {
+      continue;
+    }
+    if (/lib\.[a-z0-9.]+\.d\.ts$/.test(fileName)) {
+      continue;
+    }
+    const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+    out.push({
+      file: path.relative(workspaceRoot, fileName) || fileName,
+      line: line + 1,
+      column: character + 1,
+      code: `TS${d.code}`,
+      message: ts.flattenDiagnosticMessageText(d.messageText, "\n"),
+      category: categoryName(d.category)
+    });
+  }
+  return out;
+}
+function categoryName(c) {
+  switch (c) {
+    case ts.DiagnosticCategory.Error:
+      return "error";
+    case ts.DiagnosticCategory.Warning:
+      return "warning";
+    case ts.DiagnosticCategory.Message:
+      return "message";
+    case ts.DiagnosticCategory.Suggestion:
+      return "suggestion";
+  }
+}
+function resetInProcessTscCache() {
+  programCache.clear();
+}
+function isInProcessTscEnabled() {
+  return process.env.SPECTOSHIP_TSC_INPROCESS !== "false";
+}
+
+// src/tsLanguageServiceFixer.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import * as ts2 from "typescript";
+var SAFE_FIXABLE_CODES = /* @__PURE__ */ new Set([
+  2304,
+  // Cannot find name 'X'
+  2305,
+  // Module '...' has no exported member 'X'
+  2551,
+  // Property 'X' does not exist on type 'Y'. Did you mean 'Z'?
+  2552,
+  // Cannot find name 'X'. Did you mean 'Y'?
+  2724
+  // '...' has no exported member named 'X'. Did you mean 'Y'?
+]);
+var SAFE_FIX_NAMES = /* @__PURE__ */ new Set([
+  "import",
+  // auto-add import statement (TS2304, TS2305)
+  "fixImport",
+  // alternative auto-import in some scenarios
+  "spelling",
+  // did-you-mean rename for TS2552 (the actual fixName the LSP returns)
+  "fixSpelling"
+  // alternate spelling-fix name some TS versions emit
+]);
+function runLSPFixerPass(opts) {
+  const { workspaceRoot, targetFiles, logger } = opts;
+  const maxIterations = opts.maxIterations ?? 5;
+  const dryRun = opts.dryRun ?? false;
+  const tsconfigPath = path2.join(workspaceRoot, "tsconfig.json");
+  if (!fs2.existsSync(tsconfigPath)) {
+    return {
+      fixesApplied: 0,
+      filesEdited: [],
+      iterations: 0,
+      allResolved: true,
+      remainingErrors: []
+    };
+  }
+  const compilerOptions = readCompilerOptions(tsconfigPath, logger);
+  if (!compilerOptions) {
+    return {
+      fixesApplied: 0,
+      filesEdited: [],
+      iterations: 0,
+      allResolved: true,
+      remainingErrors: []
+    };
+  }
+  const snapshots = /* @__PURE__ */ new Map();
+  const filesEdited = /* @__PURE__ */ new Set();
+  let totalFixes = 0;
+  const workspaceLibDir = path2.join(workspaceRoot, "node_modules", "typescript", "lib");
+  const hasWorkspaceLib = fs2.existsSync(workspaceLibDir);
+  const host = {
+    getScriptFileNames: () => Array.from(snapshots.keys()),
+    getScriptVersion: (fileName) => String(snapshots.get(fileName)?.version ?? 0),
+    getScriptSnapshot: (fileName) => {
+      const cached = snapshots.get(fileName);
+      if (cached) {
+        return ts2.ScriptSnapshot.fromString(cached.content);
+      }
+      if (!fs2.existsSync(fileName)) {
+        return void 0;
+      }
+      try {
+        const content = fs2.readFileSync(fileName, "utf-8");
+        snapshots.set(fileName, { content, version: 1 });
+        return ts2.ScriptSnapshot.fromString(content);
+      } catch {
+        return void 0;
+      }
+    },
+    getCurrentDirectory: () => workspaceRoot,
+    getCompilationSettings: () => compilerOptions,
+    getDefaultLibFileName: (options) => {
+      if (hasWorkspaceLib) {
+        return path2.join(workspaceLibDir, path2.basename(ts2.getDefaultLibFilePath(options)));
+      }
+      return ts2.getDefaultLibFilePath(options);
+    },
+    fileExists: (fileName) => snapshots.has(fileName) || fs2.existsSync(fileName),
+    readFile: (fileName) => snapshots.get(fileName)?.content ?? (fs2.existsSync(fileName) ? fs2.readFileSync(fileName, "utf-8") : void 0),
+    readDirectory: ts2.sys.readDirectory,
+    directoryExists: ts2.sys.directoryExists,
+    getDirectories: ts2.sys.getDirectories
+  };
+  for (const f of targetFiles) {
+    const abs = path2.isAbsolute(f) ? f : path2.join(workspaceRoot, f);
+    if (!fs2.existsSync(abs)) {
+      continue;
+    }
+    const content = fs2.readFileSync(abs, "utf-8");
+    snapshots.set(abs, { content, version: 1 });
+  }
+  const service = ts2.createLanguageService(host, ts2.createDocumentRegistry());
+  let iter = 0;
+  let lastErrorSignatures = /* @__PURE__ */ new Set();
+  for (iter = 1; iter <= maxIterations; iter++) {
+    const fixableErrors = collectFixableErrors(service, snapshots, workspaceRoot);
+    if (fixableErrors.length === 0) {
+      break;
+    }
+    const signatures = computeErrorSignatures(fixableErrors);
+    if (signatureSetsEqual(signatures, lastErrorSignatures)) {
+      logger.info(
+        `[ts-lsp-fixer] iteration ${iter}: no progress (${fixableErrors.length} fixable error(s), same set as last iter) \u2014 stopping`
+      );
+      break;
+    }
+    lastErrorSignatures = signatures;
+    let appliedThisIter = 0;
+    for (const err of fixableErrors) {
+      const fixes = safeGetCodeFixes(service, err);
+      if (!fixes || fixes.length === 0) {
+        continue;
+      }
+      const safeFixes = fixes.filter((f) => SAFE_FIX_NAMES.has(f.fixName));
+      if (safeFixes.length === 0) {
+        continue;
+      }
+      if (safeFixes.length > 1 && !fixesAreEquivalent(safeFixes)) {
+        continue;
+      }
+      const fix = safeFixes[0];
+      const applied = applyFixToSnapshots(fix, snapshots);
+      if (applied > 0) {
+        appliedThisIter++;
+        totalFixes++;
+        for (const change of fix.changes) {
+          filesEdited.add(change.fileName);
+        }
+      }
+    }
+    logger.info(
+      `[ts-lsp-fixer] iteration ${iter}: applied ${appliedThisIter}/${fixableErrors.length} fixes`
+    );
+    if (appliedThisIter === 0) {
+      break;
+    }
+  }
+  if (dryRun) {
+    if (filesEdited.size > 0) {
+      logger.info(
+        `[ts-lsp-fixer] dry-run: skipped writing ${filesEdited.size} file(s): ${[...filesEdited].map((f) => path2.relative(workspaceRoot, f) || f).join(", ")}`
+      );
+    }
+  } else {
+    for (const fileName of filesEdited) {
+      const snap = snapshots.get(fileName);
+      if (snap) {
+        try {
+          fs2.writeFileSync(fileName, snap.content, "utf-8");
+        } catch (err) {
+          logger.warn(
+            `[ts-lsp-fixer] failed to write ${fileName}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+  }
+  const remaining = collectAllErrors(service, snapshots, workspaceRoot);
+  service.dispose();
+  return {
+    fixesApplied: totalFixes,
+    filesEdited: Array.from(filesEdited).map((f) => path2.relative(workspaceRoot, f) || f),
+    iterations: iter,
+    allResolved: remaining.length === 0,
+    remainingErrors: remaining
+  };
+}
+function readCompilerOptions(tsconfigPath, logger) {
+  const configFile = ts2.readConfigFile(tsconfigPath, ts2.sys.readFile);
+  if (configFile.error) {
+    logger.error(
+      `[ts-lsp-fixer] tsconfig parse error: ${ts2.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+    );
+    return null;
+  }
+  const parsed = ts2.parseJsonConfigFileContent(
+    configFile.config,
+    ts2.sys,
+    path2.dirname(tsconfigPath)
+  );
+  return parsed.options;
+}
+function collectFixableErrors(service, snapshots, workspaceRoot) {
+  const out = [];
+  for (const [fileName] of snapshots) {
+    if (fileName.includes("node_modules")) {
+      continue;
+    }
+    if (/lib\.[a-z0-9.]+\.d\.ts$/.test(fileName)) {
+      continue;
+    }
+    const semantic = service.getSemanticDiagnostics(fileName);
+    const syntactic = service.getSyntacticDiagnostics(fileName);
+    for (const d of [...semantic, ...syntactic]) {
+      if (!SAFE_FIXABLE_CODES.has(d.code)) {
+        continue;
+      }
+      if (d.start === void 0 || d.length === void 0) {
+        continue;
+      }
+      out.push({ file: fileName, start: d.start, length: d.length, code: d.code });
+    }
+  }
+  void workspaceRoot;
+  return out;
+}
+function collectAllErrors(service, snapshots, workspaceRoot) {
+  const out = [];
+  for (const [fileName] of snapshots) {
+    if (fileName.includes("node_modules")) {
+      continue;
+    }
+    if (/lib\.[a-z0-9.]+\.d\.ts$/.test(fileName)) {
+      continue;
+    }
+    const semantic = service.getSemanticDiagnostics(fileName);
+    const syntactic = service.getSyntacticDiagnostics(fileName);
+    for (const d of [...semantic, ...syntactic]) {
+      if (d.category !== ts2.DiagnosticCategory.Error) {
+        continue;
+      }
+      let line = 0;
+      let column = 0;
+      if (d.file && d.start !== void 0) {
+        const pos = d.file.getLineAndCharacterOfPosition(d.start);
+        line = pos.line + 1;
+        column = pos.character + 1;
+      }
+      out.push({
+        file: path2.relative(workspaceRoot, fileName) || fileName,
+        line,
+        column,
+        code: `TS${d.code}`,
+        message: ts2.flattenDiagnosticMessageText(d.messageText, "\n")
+      });
+    }
+  }
+  return out;
+}
+function safeGetCodeFixes(service, err) {
+  try {
+    return service.getCodeFixesAtPosition(
+      err.file,
+      err.start,
+      err.start + err.length,
+      [err.code],
+      {},
+      {}
+    );
+  } catch {
+    return null;
+  }
+}
+function computeErrorSignatures(errors) {
+  return new Set(errors.map((e) => `${e.file}:${e.start}:${e.code}`));
+}
+function signatureSetsEqual(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const s of a) {
+    if (!b.has(s)) {
+      return false;
+    }
+  }
+  return true;
+}
+function fixesAreEquivalent(fixes) {
+  if (fixes.length === 0) {
+    return false;
+  }
+  const first = serializeFix(fixes[0]);
+  for (let i = 1; i < fixes.length; i++) {
+    if (serializeFix(fixes[i]) !== first) {
+      return false;
+    }
+  }
+  return true;
+}
+function serializeFix(fix) {
+  return fix.changes.map(
+    (c) => `${c.fileName}|${c.textChanges.map((t) => `${t.span.start}:${t.span.length}:${t.newText}`).join(";")}`
+  ).join("||");
+}
+function applyFixToSnapshots(fix, snapshots) {
+  let applied = 0;
+  for (const change of fix.changes) {
+    const snap = snapshots.get(change.fileName);
+    if (!snap) {
+      continue;
+    }
+    const sorted = [...change.textChanges].sort((a, b) => b.span.start - a.span.start);
+    let next = snap.content;
+    for (const tc of sorted) {
+      next = next.slice(0, tc.span.start) + tc.newText + next.slice(tc.span.start + tc.span.length);
+    }
+    snapshots.set(change.fileName, { content: next, version: snap.version + 1 });
+    applied++;
+  }
+  return applied;
+}
+function isLSPFixerEnabled() {
+  return process.env.SPECTOSHIP_TS_LSP_FIXER !== "false";
+}
+function resetLSPFixerCache() {
+}
+
+// src/index.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+var noopLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function discoverTsFiles(workspaceRoot) {
+  const out = [];
+  const skip = /* @__PURE__ */ new Set(["node_modules", ".next", "dist", "build", ".git", "out", "coverage"]);
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (skip.has(e.name)) {
+          continue;
+        }
+        walk(path3.join(dir, e.name));
+      } else if (e.isFile() && !e.name.endsWith(".d.ts")) {
+        if (e.name.endsWith(".ts") || e.name.endsWith(".tsx")) {
+          out.push(path3.relative(workspaceRoot, path3.join(dir, e.name)));
+        }
+      }
+    }
+  };
+  walk(workspaceRoot);
+  return out;
+}
+function runValidationLoop(opts) {
+  const { workspaceRoot, skipLSPFixer = false, dryRun = false } = opts;
+  const logger = opts.logger ?? noopLogger;
+  if (!fs3.existsSync(workspaceRoot)) {
+    throw new Error(`workspace not found: ${workspaceRoot}`);
+  }
+  if (!fs3.existsSync(path3.join(workspaceRoot, "tsconfig.json"))) {
+    throw new Error(`no tsconfig.json in ${workspaceRoot}`);
+  }
+  const targetFiles = opts.targetFiles ?? discoverTsFiles(workspaceRoot);
+  const startMs = Date.now();
+  resetInProcessTscCache();
+  const before = runInProcessTsc({ workspaceRoot, generatedFiles: targetFiles, logger });
+  const errorsBefore = before.diagnostics.filter((d) => d.category === "error").length;
+  let after = before;
+  let lspFixer = {
+    ran: false,
+    fixesApplied: 0,
+    filesEdited: [],
+    iterations: 0
+  };
+  if (errorsBefore > 0 && !skipLSPFixer) {
+    const lsp = runLSPFixerPass({ workspaceRoot, targetFiles, logger, dryRun });
+    lspFixer = {
+      ran: true,
+      fixesApplied: lsp.fixesApplied,
+      filesEdited: lsp.filesEdited,
+      iterations: lsp.iterations
+    };
+    if (lsp.fixesApplied > 0 && !dryRun) {
+      resetInProcessTscCache();
+      after = runInProcessTsc({ workspaceRoot, generatedFiles: targetFiles, logger });
+    }
+  }
+  const errorDiags = after.diagnostics.filter((d) => d.category === "error");
+  const errorsAfter = errorDiags.length;
+  const remainingByCode = {};
+  const remainingByFile = {};
+  for (const d of errorDiags) {
+    remainingByCode[d.code] = (remainingByCode[d.code] ?? 0) + 1;
+    remainingByFile[d.file] = (remainingByFile[d.file] ?? 0) + 1;
+  }
+  return {
+    passed: errorsAfter === 0,
+    errorsBefore,
+    errorsAfter,
+    lspFixer,
+    remainingByCode,
+    remainingByFile,
+    diagnostics: after.diagnostics,
+    elapsedMs: Date.now() - startMs
+  };
+}
+export {
+  discoverTsFiles,
+  isInProcessTscEnabled,
+  isLSPFixerEnabled,
+  resetInProcessTscCache,
+  resetLSPFixerCache,
+  runInProcessTsc,
+  runLSPFixerPass,
+  runValidationLoop
+};