ts6to7 0.1.0

package/README.md

@@ -0,0 +1,82 @@
+# ts6to7
+
+Codemod that migrates a **TypeScript 6** project to **TypeScript 7 (tsgo)**.
+No install needed — try it in 10 seconds:
+
+```bash
+npx ts6to7 --dry
+```
+
+![ts6to7 rewriting a legacy tsconfig for TypeScript 7](docs/demo.gif)
+
+TypeScript 7 is the native (Go) rewrite of the compiler. It removes every option
+that TypeScript 6 marked as deprecated and flips some defaults. This tool
+rewrites your config files to the TS7 equivalents and prints a checklist of the
+things it cannot safely change for you.
+
+## Usage
+
+```bash
+# preview changes without writing anything
+npx ts6to7 --dry
+
+# apply to the current directory (monorepos: scans every package)
+npx ts6to7
+
+# apply to a specific directory
+npx ts6to7 packages/app
+```
+
+Then:
+
+```bash
+npm install          # picks up typescript ^7.0.0
+npx tsc --noEmit     # fix any remaining errors it reports
+```
+
+## What it rewrites
+
+### `tsconfig*.json` (comments and formatting are preserved)
+
+| Before (TS6) | After (TS7) |
+| --- | --- |
+| `"target": "es3"` / `"es5"` | `"ES2015"` — ES5 output was removed |
+| `"module": "amd"` / `"umd"` / `"system"` / `"none"` | `"ESNext"` |
+| `"moduleResolution": "node"` / `"node10"` / `"classic"` | `"NodeNext"` (Node-style projects) or `"Bundler"` |
+| `"importsNotUsedAsValues"`, `"preserveValueImports"` | `"verbatimModuleSyntax": true` |
+| `"baseUrl"` | folded into `"paths"` (mappings become tsconfig-relative) |
+| `charset`, `keyofStringsOnly`, `out`, `noImplicitUseStrict`, `noStrictGenericChecks`, `suppressExcessPropertyErrors`, `suppressImplicitAnyIndexErrors` | removed |
+| `strict` unset | pinned to `false` to preserve behavior (TS7 defaults to `true`) — delete it when you're ready |
+
+### `package.json`
+
+- Bumps the `typescript` dependency to `^7.0.0`.
+- Warns about tools built on the TS compiler API (`ts-node`, `ts-jest`,
+  `ts-patch`, `ttypescript`, `ts-loader`, `fork-ts-checker-webpack-plugin`) —
+  tsgo 7.0 does not expose the old JS compiler API (a new one ships in 7.1), so
+  each of these needs a TS7-compatible version or a replacement.
+
+## What it can't do for you
+
+- **ES5 runtimes**: if you still ship to ES5-only environments, transpile TS7's
+  output with Babel/SWC.
+- **NodeNext strictness**: relative ESM imports need explicit `.js` extensions;
+  `tsc` will list them.
+- **`verbatimModuleSyntax` errors**: type-only imports must become
+  `import type { ... }`; editors can auto-fix these.
+- **Ambient types**: TS7 no longer auto-includes every `@types/*` package —
+  add `"types": ["node", ...]` explicitly if you relied on that.
+
+Everything in this list is also printed as a `Needs manual review` item when
+the codemod runs, scoped to the file that triggered it.
+
+## Development
+
+```bash
+npm install
+npm test
+```
+
+## License
+
+MIT

package/bin/ts6to7.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { run } from '../src/cli.js';
+
+run(process.argv.slice(2)).then(
+  (code) => process.exit(code),
+  (err) => {
+    console.error(err?.stack ?? String(err));
+    process.exit(1);
+  },
+);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "ts6to7",
+  "version": "0.1.0",
+  "description": "Codemod that migrates a TypeScript 6 project to TypeScript 7 (tsgo): rewrites tsconfig.json options removed in TS7 and flags changes that need manual review.",
+  "type": "module",
+  "bin": {
+    "ts6to7": "bin/ts6to7.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "typescript",
+    "codemod",
+    "migration",
+    "tsgo",
+    "typescript-7"
+  ],
+  "dependencies": {
+    "jsonc-parser": "^3.3.1"
+  },
+  "license": "MIT"
+}

package/src/cli.js

@@ -0,0 +1,88 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import { findFiles } from './find-files.js';
+import { transformTsconfig } from './transform-tsconfig.js';
+import { transformPackageJson } from './transform-package-json.js';
+
+const tty = process.stdout.isTTY;
+const bold = (s) => (tty ? `\x1b[1m${s}\x1b[0m` : s);
+const green = (s) => (tty ? `\x1b[32m${s}\x1b[0m` : s);
+const yellow = (s) => (tty ? `\x1b[33m${s}\x1b[0m` : s);
+const dim = (s) => (tty ? `\x1b[2m${s}\x1b[0m` : s);
+
+const HELP = `ts6to7 — migrate a TypeScript 6 project to TypeScript 7 (tsgo)
+
+Usage:
+  npx ts6to7 [directory] [options]
+
+Options:
+  --dry, -d     Show what would change without writing files
+  --help, -h    Show this help
+
+What it does:
+  tsconfig*.json
+    - target es3/es5            -> ES2015 (removed in TS7)
+    - module amd/umd/system     -> ESNext (removed in TS7)
+    - moduleResolution node10/classic -> NodeNext or Bundler
+    - importsNotUsedAsValues / preserveValueImports -> verbatimModuleSyntax
+    - baseUrl                   -> folded into "paths" (removed in TS7)
+    - removes charset, keyofStringsOnly, out, noImplicitUseStrict, ...
+    - pins strict: false if unset (TS7 defaults strict to true)
+  package.json
+    - typescript dependency     -> ^7.0.0
+    - warns about compiler-API tools (ts-node, ts-patch, ts-jest, ...)
+`;
+
+export async function run(argv) {
+  const args = [...argv];
+  const dry = args.includes('--dry') || args.includes('-d');
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return 0;
+  }
+  const dirArg = args.find((a) => !a.startsWith('-'));
+  const root = resolve(process.cwd(), dirArg ?? '.');
+
+  const { tsconfigs, packageJsons } = findFiles(root);
+  if (tsconfigs.length === 0 && packageJsons.length === 0) {
+    console.error(`No tsconfig*.json or package.json found under ${root}`);
+    return 1;
+  }
+
+  let filesChanged = 0;
+  const allWarnings = [];
+
+  const process1 = (file, transform) => {
+    const original = readFileSync(file, 'utf8');
+    const { text, changes, warnings } = transform(original);
+    const rel = relative(root, file) || file;
+
+    if (changes.length > 0) {
+      filesChanged++;
+      console.log(`\n${bold(rel)}`);
+      for (const c of changes) console.log(`  ${green('~')} ${c}`);
+      if (!dry && text !== original) writeFileSync(file, text);
+    }
+    for (const w of warnings) allWarnings.push({ rel, w });
+  };
+
+  for (const file of tsconfigs) process1(file, transformTsconfig);
+  for (const file of packageJsons) process1(file, transformPackageJson);
+
+  if (allWarnings.length > 0) {
+    console.log(`\n${bold('Needs manual review:')}`);
+    for (const { rel, w } of allWarnings) {
+      console.log(`  ${yellow('!')} ${dim(`[${rel}]`)} ${w}`);
+    }
+  }
+
+  console.log(
+    dry
+      ? `\n${filesChanged} file(s) would be updated (dry run — nothing written).`
+      : `\n${filesChanged} file(s) updated.`,
+  );
+  if (!dry && filesChanged > 0) {
+    console.log(dim('Next: reinstall dependencies, then run `tsc --noEmit` (or `tsgo`) and fix remaining errors.'));
+  }
+  return 0;
+}

package/src/find-files.js

@@ -0,0 +1,36 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'out', 'coverage', '.next', '.turbo']);
+const TSCONFIG_RE = /^tsconfig(\..+)?\.json$/;
+
+/**
+ * Recursively collect tsconfig*.json and package.json files under root.
+ * Returns { tsconfigs: string[], packageJsons: string[] }.
+ */
+export function findFiles(root) {
+  const tsconfigs = [];
+  const packageJsons = [];
+
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith('.')) walk(full);
+      } else if (TSCONFIG_RE.test(entry.name)) {
+        tsconfigs.push(full);
+      } else if (entry.name === 'package.json') {
+        packageJsons.push(full);
+      }
+    }
+  };
+
+  walk(root);
+  return { tsconfigs, packageJsons };
+}

package/src/transform-package-json.js

@@ -0,0 +1,49 @@
+import { parse, modify, applyEdits } from 'jsonc-parser';
+
+const FORMAT = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+
+/** Packages built on the TS compiler API, which tsgo (TS7) does not expose (new API lands in 7.1). */
+const API_DEPENDENT = ['ts-patch', 'ttypescript', 'ts-node', 'ts-loader', 'ts-jest', 'fork-ts-checker-webpack-plugin'];
+
+const DEP_FIELDS = ['dependencies', 'devDependencies'];
+
+function majorOf(range) {
+  const m = String(range).match(/(\d+)\./);
+  return m ? Number(m[1]) : null;
+}
+
+/**
+ * Bump the typescript dependency to ^7 and warn about compiler-API tooling.
+ * Returns { text, changes, warnings }.
+ */
+export function transformPackageJson(text) {
+  const changes = [];
+  const warnings = [];
+  let result = text;
+
+  const json = parse(text) ?? {};
+
+  for (const field of DEP_FIELDS) {
+    const deps = json[field];
+    if (typeof deps !== 'object' || deps === null) continue;
+
+    if (typeof deps.typescript === 'string') {
+      const major = majorOf(deps.typescript);
+      if (major !== null && major < 7) {
+        result = applyEdits(result, modify(result, [field, 'typescript'], '^7.0.0', FORMAT));
+        changes.push(`${field}.typescript: "${deps.typescript}" -> "^7.0.0"`);
+      }
+    }
+
+    for (const name of API_DEPENDENT) {
+      if (deps[name]) {
+        warnings.push(
+          `"${name}" uses the TypeScript compiler API, which tsgo does not expose in 7.0 ` +
+            '(a new API ships with 7.1). Check that your version supports TS7 or find an alternative.',
+        );
+      }
+    }
+  }
+
+  return { text: result, changes, warnings };
+}

package/src/transform-tsconfig.js

@@ -0,0 +1,172 @@
+import { parse, modify, applyEdits } from 'jsonc-parser';
+
+const FORMAT = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+
+/**
+ * Options that were deprecated in TS 5/6 and are removed in TS 7.
+ * They are deleted outright; some carry an extra note for the report.
+ */
+const REMOVED_OPTIONS = {
+  charset: null,
+  keyofStringsOnly: null,
+  noImplicitUseStrict: null,
+  noStrictGenericChecks: null,
+  suppressExcessPropertyErrors: null,
+  suppressImplicitAnyIndexErrors: null,
+  out: 'use "outFile" instead if you relied on single-file output',
+};
+
+function lower(value) {
+  return typeof value === 'string' ? value.toLowerCase() : value;
+}
+
+/** Join a paths-mapping entry onto the old baseUrl, tsconfig-dir relative. */
+function joinBaseUrl(baseUrl, entry) {
+  if (entry.startsWith('/')) return entry;
+  const base = baseUrl.replace(/\/+$/, '');
+  const rest = entry.replace(/^\.\//, '');
+  const joined = base === '.' || base === '' ? rest : `${base}/${rest}`;
+  return joined.startsWith('.') || joined.startsWith('/') ? joined : `./${joined}`;
+}
+
+/**
+ * Transform the text of one tsconfig(-like) JSONC file for TypeScript 7.
+ * Comment/format preserving. Returns { text, changes, warnings }.
+ */
+export function transformTsconfig(text) {
+  const changes = [];
+  const warnings = [];
+  let result = text;
+
+  const json = parse(text) ?? {};
+  const co = json.compilerOptions;
+  if (typeof co !== 'object' || co === null) {
+    return { text: result, changes, warnings };
+  }
+
+  const edit = (key, value) => {
+    result = applyEdits(result, modify(result, ['compilerOptions', key], value, FORMAT));
+  };
+
+  // --- target: es3/es5 removed; minimum is ES2015 -------------------------
+  const target = lower(co.target);
+  if (target === 'es3' || target === 'es5') {
+    edit('target', 'ES2015');
+    changes.push(`target: "${co.target}" -> "ES2015" (ES5 and below removed in TS7)`);
+    warnings.push(
+      'target was raised to ES2015: emitted JS now uses classes, let/const, arrow functions etc. ' +
+        'If you must ship ES5 (e.g. IE11), transpile the TS7 output with Babel/SWC.',
+    );
+  }
+
+  // --- module: amd/umd/system/none removed --------------------------------
+  const module_ = lower(co.module);
+  const removedModules = ['amd', 'umd', 'system', 'none'];
+  if (removedModules.includes(module_)) {
+    edit('module', 'ESNext');
+    changes.push(`module: "${co.module}" -> "ESNext" (removed in TS7)`);
+    warnings.push(
+      `module "${co.module}" no longer exists: the emitted module format changes to ESM. ` +
+        'Your loader/bundler setup needs a manual review.',
+    );
+  }
+
+  // --- moduleResolution: node10/node/classic removed ----------------------
+  const resolution = lower(co.moduleResolution);
+  if (resolution === 'node' || resolution === 'node10' || resolution === 'classic') {
+    // nodenext requires module nodenext; bundler requires module es2015+/preserve.
+    const nodeLike =
+      module_ === 'commonjs' || module_ === 'node16' || module_ === 'nodenext' || module_ === undefined;
+    if (nodeLike) {
+      edit('module', 'NodeNext');
+      edit('moduleResolution', 'NodeNext');
+      changes.push(
+        `moduleResolution: "${co.moduleResolution}" -> "NodeNext"` +
+          (lower(co.module) !== 'nodenext' ? ` (module set to "NodeNext" to match)` : ''),
+      );
+      warnings.push(
+        'NodeNext resolution is stricter than the old "node": relative ESM imports need explicit ' +
+          'file extensions and package.json "exports" is honored. Run tsc once and fix reported imports.',
+      );
+    } else {
+      edit('moduleResolution', 'Bundler');
+      changes.push(`moduleResolution: "${co.moduleResolution}" -> "Bundler"`);
+      warnings.push(
+        'moduleResolution "Bundler" assumes a bundler (Vite/webpack/esbuild) resolves imports at build time.',
+      );
+    }
+  }
+
+  // --- importsNotUsedAsValues / preserveValueImports -> verbatimModuleSyntax
+  const hasINUAV = Object.prototype.hasOwnProperty.call(co, 'importsNotUsedAsValues');
+  const hasPVI = Object.prototype.hasOwnProperty.call(co, 'preserveValueImports');
+  if (hasINUAV || hasPVI) {
+    const wantsVerbatim =
+      co.preserveValueImports === true ||
+      lower(co.importsNotUsedAsValues) === 'error' ||
+      lower(co.importsNotUsedAsValues) === 'preserve';
+    if (hasINUAV) edit('importsNotUsedAsValues', undefined);
+    if (hasPVI) edit('preserveValueImports', undefined);
+    if (wantsVerbatim) {
+      edit('verbatimModuleSyntax', true);
+      changes.push('importsNotUsedAsValues/preserveValueImports -> verbatimModuleSyntax: true');
+      warnings.push(
+        'verbatimModuleSyntax requires type-only imports to be written as `import type`. ' +
+          'tsc will point at each offending import; most editors can auto-fix them.',
+      );
+    } else {
+      changes.push('removed importsNotUsedAsValues/preserveValueImports (defaults match old behavior)');
+    }
+  }
+
+  // --- baseUrl removed: fold it into paths ---------------------------------
+  if (Object.prototype.hasOwnProperty.call(co, 'baseUrl')) {
+    const baseUrl = String(co.baseUrl);
+    if (co.paths && typeof co.paths === 'object') {
+      const newPaths = {};
+      for (const [pattern, targets] of Object.entries(co.paths)) {
+        newPaths[pattern] = Array.isArray(targets)
+          ? targets.map((t) => joinBaseUrl(baseUrl, String(t)))
+          : targets;
+      }
+      edit('paths', newPaths);
+      changes.push(`baseUrl "${baseUrl}" folded into paths (entries now tsconfig-relative)`);
+    } else {
+      edit('paths', { '*': [joinBaseUrl(baseUrl, '*')] });
+      changes.push(`baseUrl "${baseUrl}" -> paths: { "*": ["${joinBaseUrl(baseUrl, '*')}"] }`);
+      warnings.push(
+        'baseUrl-style bare imports (e.g. `import x from "utils/x"`) now rely on the generated ' +
+          '"*" paths mapping. Verify your runtime/bundler resolves them the same way.',
+      );
+    }
+    edit('baseUrl', undefined);
+  }
+
+  // --- options removed without replacement ---------------------------------
+  for (const [key, note] of Object.entries(REMOVED_OPTIONS)) {
+    if (Object.prototype.hasOwnProperty.call(co, key)) {
+      edit(key, undefined);
+      changes.push(`removed ${key} (option no longer exists in TS7)${note ? ` — ${note}` : ''}`);
+    }
+  }
+
+  // --- strict becomes the default in TS7 -----------------------------------
+  if (!Object.prototype.hasOwnProperty.call(co, 'strict')) {
+    edit('strict', false);
+    changes.push('added explicit strict: false (TS7 flips the default to true)');
+    warnings.push(
+      'strict: false was added to preserve current behavior. Consider deleting it and fixing ' +
+        'strict-mode errors instead — TS7 projects are strict by default.',
+    );
+  }
+
+  // --- types auto-inclusion behavior change (report only) -------------------
+  if (!Object.prototype.hasOwnProperty.call(co, 'types')) {
+    warnings.push(
+      'No "types" array: TS7 no longer auto-includes every @types/* package. If you rely on ' +
+        'ambient types (e.g. @types/node), list them explicitly: "types": ["node"].',
+    );
+  }
+
+  return { text: result, changes, warnings };
+}