ts-suppress 0.2.0 → 0.4.0

package/README.md

@@ -4,67 +4,88 @@ Incremental TypeScript strictness adoption via bulk error suppression.
 
 Instead of scattering `@ts-ignore` or `@ts-expect-error` comments throughout your codebase, `ts-suppress` captures all TypeScript errors into a single `.ts-suppressions.json` file. This lets you enable stricter compiler options immediately and fix errors at your own pace.
 
-## How It Works
-
-Each suppression is a fingerprint of a TypeScript error, consisting of:
-
-- **file** — relative path to the source file
-- **code** — TypeScript error code (e.g. `2322`)
-- **hash** — hex hash of the diagnostic message text
-- **scope** — dot-separated scope chain (e.g. `MyClass.myMethod`)
-
-The `check` command diffs the current diagnostics against the suppression file and reports:
-
-- **Unsuppressed errors** — new errors not yet in the suppression file
-- **Stale suppressions** — entries that no longer match any current error (i.e. errors that have been fixed)
-
 ## Install
 
 ```bash
-bun add -d ts-suppress
+npm install -D ts-suppress
 ```
 
-## Usage
-
-### `init`
-
-Create an empty `.ts-suppressions.json`:
-
 ```bash
-bunx ts-suppress init
+pnpm add -D ts-suppress
 ```
 
-### `suppress`
-
-Snapshot all current TypeScript errors into `.ts-suppressions.json`:
+```bash
+yarn add -D ts-suppress
+```
 
 ```bash
-bunx ts-suppress suppress
+bun add -d ts-suppress
 ```
 
-### `check`
+> **Note:** TypeScript >= 5.9.3 is a peer dependency.
 
-Verify that all errors are suppressed and no suppressions are stale. Exits non-zero on failure — useful in CI:
+## Usage
 
 ```bash
-bunx ts-suppress check
-```
+# Create an empty .ts-suppressions.json
+npx ts-suppress init
 
-### `update`
+# Snapshot all current TypeScript errors
+npx ts-suppress suppress
 
-Add new suppressions and remove stale ones in a single pass:
+# Verify all errors are suppressed and no suppressions are stale (useful in CI)
+npx ts-suppress check
 
-```bash
-bunx ts-suppress update
+# Add new suppressions and remove stale ones in a single pass
+npx ts-suppress update
 ```
 
-Also available as `bunx ts-suppress fix`.
-
 ## Typical Workflow
 
 1. Enable a stricter TypeScript option (e.g. `"strict": true`)
-2. Run `bunx ts-suppress suppress` to baseline all existing errors
+2. Run `npx ts-suppress suppress` to baseline all existing errors
 3. Commit `.ts-suppressions.json`
-4. Add `bunx ts-suppress check` to CI
+4. Add `npx ts-suppress check` to CI
 5. Fix errors over time — `check` will flag stale suppressions as you go
-6. Run `bunx ts-suppress update` to sync the suppression file after fixing errors
+6. Run `npx ts-suppress update` to sync the suppression file after fixing errors
+
+## How It Works
+
+Each suppression is a fingerprint of a TypeScript error, consisting of:
+
+- **file** — relative path to the source file
+- **code** — TypeScript error code (e.g. `2322`)
+- **hash** — hex hash of the diagnostic message text
+- **scope** — dot-separated scope chain (e.g. `MyClass.myMethod`)
+
+The `check` command diffs the current diagnostics against the suppression file and reports:
+
+- **Unsuppressed errors** — new errors not yet in the suppression file
+- **Stale suppressions** — entries that no longer match any current error (i.e. errors that have been fixed)
+
+## Comparison with ts-bulk-suppress
+
+ts-suppress is inspired by [ts-bulk-suppress](https://github.com/tiktok/ts-bulk-suppress) by TikTok and shares the same core idea: capture TypeScript errors into an external file instead of scattering `@ts-ignore` comments. The two tools take different approaches to the problem.
+
+|                          | ts-suppress                                                | ts-bulk-suppress                                                      |
+| ------------------------ | ---------------------------------------------------------- | --------------------------------------------------------------------- |
+| **Suppression file**     | Single `.ts-suppressions.json`                             | `.ts-bulk-suppressions.json`                                          |
+| **Error identification** | file + error code + message hash + scope                   | file + error code + scope                                             |
+| **tsc integration**      | Standalone — reads diagnostics via TypeScript compiler API | Wraps/intercepts tsc output                                           |
+| **CLI interface**        | Separate commands: `init`, `suppress`, `check`, `update`   | Flag-based: `--gen-bulk-suppress`, `--changed`                        |
+| **Runtime dependencies** | 1 (mri) + TypeScript as peer dep                           | 37 packages                                                           |
+| **Maintenance**          | Actively maintained                                        | [Last published 2024](https://www.npmjs.com/package/ts-bulk-suppress) |
+
+### Key differences
+
+- **Hash-based fingerprinting** — ts-suppress includes a SHA-256 hash of the diagnostic message text in each suppression entry. This means two errors on the same line with the same error code but different messages are tracked independently, reducing false matches.
+- **No tsc patching** — ts-suppress uses the TypeScript compiler API directly to collect diagnostics rather than wrapping or intercepting tsc. This avoids coupling to tsc's output format.
+- **Explicit CLI commands** — Each operation (`init`, `suppress`, `check`, `update`) is a separate command rather than a flag, making the workflow easier to script and understand.
+
+## Acknowledgements
+
+Inspired by [ts-bulk-suppress](https://github.com/tiktok/ts-bulk-suppress) by TikTok.
+
+## License
+
+MIT

package/dist/ast.js

@@ -0,0 +1,11 @@
+import ts from "typescript";
+/** Find the most specific (deepest) AST node at the given position in a source file. */
+export function findNodeAtPosition(sourceFile, position) {
+    function visit(node) {
+        if (position >= node.getStart(sourceFile) && position < node.getEnd()) {
+            return ts.forEachChild(node, visit) ?? node;
+        }
+        return undefined;
+    }
+    return visit(sourceFile);
+}

package/dist/cli.js

@@ -1,4 +1,5 @@
-import { parse } from "@bomb.sh/args";
+#!/usr/bin/env node
+import mri from "mri";
 import { createProject } from "./project.js";
 import { runCheck } from "./commands/check.js";
 import { runInit } from "./commands/init.js";
@@ -16,7 +17,7 @@ function printHelp() {
     const lines = commands.map(([name, desc]) => `  ${name.padEnd(longest + 4)}${desc}`);
     console.log(`ts-suppress v${VERSION}\nIncremental TypeScript strictness adoption via bulk error suppression\n\nCommands:\n${lines.join("\n")}\n\nRun ts-suppress <command> --help for details.`);
 }
-const args = parse(process.argv.slice(2), {
+const args = mri(process.argv.slice(2), {
     boolean: ["help", "version"],
     alias: { h: "help", v: "version" },
 });

package/dist/commands/init.js

@@ -2,4 +2,5 @@ import { writeSuppressions, SUPPRESSIONS_FILENAME } from "../suppressions.js";
 export async function runInit() {
     await writeSuppressions(process.cwd(), []);
     console.log(`Created ${SUPPRESSIONS_FILENAME}`);
+    console.log(`\nTip: Add ${SUPPRESSIONS_FILENAME} to your formatter's ignore list (e.g. .prettierignore, .oxfmtignore) to preserve its compact format.`);
 }

package/dist/commands/suppress.js

@@ -2,7 +2,6 @@ import { collectDiagnostics } from "../diagnostics.js";
 import { writeSuppressions, SUPPRESSIONS_FILENAME } from "../suppressions.js";
 /**
  * Core logic, extracted for testability.
- * Accepts a ts-morph Project and roots separately so tests can pass in-memory projects.
  * outputRoot is where the suppression file is written (may differ from projectRoot in tests).
  */
 export async function runSuppress(project, projectRoot, outputRoot = projectRoot) {

package/dist/diagnostics.js

@@ -1,25 +1,31 @@
+import ts from "typescript";
 import { relative } from "node:path";
 import { hashMessage } from "./hash.js";
 import { buildScopePath } from "./scope.js";
+import { findNodeAtPosition } from "./ast.js";
+// Only the top-level message is used for fingerprinting; chained sub-messages
+// are diagnostic detail that varies with context and would produce unstable hashes.
+function flattenDiagnosticMessage(messageText) {
+    return typeof messageText === "string" ? messageText : messageText.messageText;
+}
 /**
- * Collect all pre-emit diagnostics from a ts-morph Project as Suppression fingerprints.
+ * Collect all pre-emit diagnostics from a TypeScript Program as Suppression fingerprints.
  * Project creation is the caller's responsibility — this enables in-memory testing.
  */
 export function collectDiagnostics(project, projectRoot) {
-    const diagnostics = project.getPreEmitDiagnostics();
+    const diagnostics = ts.getPreEmitDiagnostics(project.program);
     const suppressions = [];
     for (const diag of diagnostics) {
-        const sourceFile = diag.getSourceFile();
+        const sourceFile = diag.file;
         if (!sourceFile)
             continue;
-        const filePath = relative(projectRoot, sourceFile.getFilePath());
-        const code = diag.getCode();
-        const messageText = diag.getMessageText();
-        const message = typeof messageText === "string" ? messageText : messageText.getMessageText();
-        const start = diag.getStart();
+        const filePath = relative(projectRoot, sourceFile.fileName);
+        const code = diag.code;
+        const message = flattenDiagnosticMessage(diag.messageText);
+        const start = diag.start;
         let scope = "";
         if (start != null) {
-            const node = sourceFile.getDescendantAtPos(start);
+            const node = findNodeAtPosition(sourceFile, start);
             if (node) {
                 scope = buildScopePath(node);
             }

package/dist/project.js

@@ -1,4 +1,3 @@
-import { Project } from "ts-morph";
 import ts from "typescript";
 import { dirname } from "node:path";
 /**
@@ -6,19 +5,27 @@ import { dirname } from "node:path";
  * Uses TypeScript's own findConfigFile for correct resolution behavior.
  */
 export function findTsConfig(cwd) {
-    const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.json");
+    const configPath = ts.findConfigFile(cwd, (f) => ts.sys.fileExists(f), "tsconfig.json");
     if (!configPath) {
         throw new Error(`No tsconfig.json found starting from ${cwd}`);
     }
     return configPath;
 }
 /**
- * Create a ts-morph Project from the nearest tsconfig.json.
- * Returns the Project and the resolved project root (directory containing tsconfig.json).
+ * Create a TypeScript Program from the nearest tsconfig.json.
+ * Returns the Program and the resolved project root (directory containing tsconfig.json).
  */
 export function createProject(cwd) {
     const tsConfigFilePath = findTsConfig(cwd);
     const projectRoot = dirname(tsConfigFilePath);
-    const project = new Project({ tsConfigFilePath });
-    return { project, projectRoot };
+    const configFile = ts.readConfigFile(tsConfigFilePath, (f) => ts.sys.readFile(f));
+    if (configFile.error) {
+        throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
+    }
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, projectRoot);
+    if (parsed.errors.length > 0) {
+        throw new Error(ts.flattenDiagnosticMessageText(parsed.errors[0].messageText, "\n"));
+    }
+    const program = ts.createProgram(parsed.fileNames, parsed.options);
+    return { project: { program }, projectRoot };
 }

package/dist/scope.js

@@ -1,5 +1,4 @@
-// src/scope.ts
-import { Node } from "ts-morph";
+import ts from "typescript";
 /**
  * Build a dot-separated scope path by walking up the AST from a node.
  * Returns empty string for module-level code.
@@ -19,34 +18,36 @@ export function buildScopePath(node) {
         if (name != null) {
             parts.unshift(name);
         }
-        current = current.getParent();
+        current = current.parent;
     }
     return parts.join(".");
 }
 function getScopeName(node) {
-    if (Node.isFunctionDeclaration(node)) {
-        return node.getName() ?? null;
+    if (ts.isFunctionDeclaration(node)) {
+        return node.name?.text ?? null;
     }
-    if (Node.isMethodDeclaration(node)) {
-        return node.getName();
+    if (ts.isMethodDeclaration(node)) {
+        return ts.isIdentifier(node.name) ? node.name.text : node.name.getText();
     }
-    if (Node.isClassDeclaration(node)) {
-        return node.getName() ?? null;
+    if (ts.isClassDeclaration(node)) {
+        return node.name?.text ?? null;
     }
-    if (Node.isGetAccessorDeclaration(node)) {
-        return `get:${node.getName()}`;
+    if (ts.isGetAccessorDeclaration(node)) {
+        const name = ts.isIdentifier(node.name) ? node.name.text : node.name.getText();
+        return `get:${name}`;
     }
-    if (Node.isSetAccessorDeclaration(node)) {
-        return `set:${node.getName()}`;
+    if (ts.isSetAccessorDeclaration(node)) {
+        const name = ts.isIdentifier(node.name) ? node.name.text : node.name.getText();
+        return `set:${name}`;
     }
-    if (Node.isConstructorDeclaration(node)) {
+    if (ts.isConstructorDeclaration(node)) {
         return "constructor";
     }
     // Arrow function or function expression assigned to a variable
-    if (Node.isArrowFunction(node) || Node.isFunctionExpression(node)) {
-        const parent = node.getParent();
-        if (parent && Node.isVariableDeclaration(parent)) {
-            return parent.getName();
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        const parent = node.parent;
+        if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
         }
         return null; // anonymous, no scope name
     }

package/dist/suppressions.js

@@ -42,8 +42,9 @@ export async function readSuppressions(projectRoot) {
 export async function writeSuppressions(projectRoot, suppressions) {
     const filePath = resolve(projectRoot, SUPPRESSIONS_FILENAME);
     const sorted = [...suppressions].sort(compareSuppression);
-    const data = { suppressions: sorted };
-    await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    const lines = sorted.map((s) => "  " + JSON.stringify(s));
+    const content = `{"suppressions": [\n${lines.join(",\n")}\n]}\n`;
+    await writeFile(filePath, content);
 }
 /**
  * Diff existing suppressions against current diagnostics.

package/dist/test-helpers.js

@@ -0,0 +1,36 @@
+import ts from "typescript";
+export function createInMemoryProject(files) {
+    const fileMap = new Map();
+    const fileNames = [];
+    for (const [name, content] of Object.entries(files)) {
+        const fullPath = `/${name}`;
+        fileMap.set(fullPath, content);
+        fileNames.push(fullPath);
+    }
+    const options = {
+        strict: true,
+        target: ts.ScriptTarget.ESNext,
+        lib: ["lib.esnext.d.ts"],
+        moduleDetection: ts.ModuleDetectionKind.Force,
+        types: [],
+    };
+    const host = ts.createCompilerHost(options);
+    const originalGetSourceFile = host.getSourceFile.bind(host);
+    const originalFileExists = host.fileExists.bind(host);
+    const originalReadFile = host.readFile.bind(host);
+    host.getSourceFile = (fileName, languageVersion) => {
+        const content = fileMap.get(fileName);
+        if (content != null) {
+            return ts.createSourceFile(fileName, content, languageVersion, true);
+        }
+        return originalGetSourceFile(fileName, languageVersion);
+    };
+    host.fileExists = (fileName) => {
+        return fileMap.has(fileName) || originalFileExists(fileName);
+    };
+    host.readFile = (fileName) => {
+        return fileMap.get(fileName) ?? originalReadFile(fileName);
+    };
+    const program = ts.createProgram(fileNames, options, host);
+    return { program };
+}

package/dist/types.js

@@ -1,2 +1 @@
-// src/types.ts
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-suppress",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Incremental TypeScript strictness adoption via bulk error suppression",
   "keywords": [
     "migration",
@@ -31,24 +31,10 @@
     "!skills/_artifacts"
   ],
   "type": "module",
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "test": "bun test",
-    "prepublishOnly": "bun run build",
-    "fmt": "oxfmt",
-    "fmt:check": "oxfmt --check",
-    "knip": "knip",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "prepare": "husky",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
-    "@bomb.sh/args": "^0.3.1",
-    "ts-morph": "^27.0.2"
+    "mri": "^1.2.0"
   },
   "devDependencies": {
-    "@types/bun": "latest",
     "@types/node": "^24",
     "husky": "^9.1.7",
     "knip": "^5.87.0",
@@ -56,13 +42,21 @@
     "oxfmt": "^0.41.0",
     "oxlint": "^1.56.0",
     "oxlint-tsgolint": "^0.17.0",
-    "typescript": "^5.9.3"
+    "tsx": "^4.19.4",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.1"
   },
   "peerDependencies": {
     "typescript": "^5.9.3"
   },
-  "lint-staged": {
-    "*.{js,jsx,ts,tsx,mjs,cjs}": "bun run lint",
-    "*": "oxfmt --no-error-on-unmatched-pattern"
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
+    "knip": "knip",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "typecheck": "tsc --noEmit"
   }
-}
+}