oxlint-harness 1.0.0 → 1.0.2

package/README.md

@@ -55,16 +55,40 @@ The suppression file uses a count-based format:
 
 ## CLI Options
 
-| Option | Short | Description | Default |
-|--------|--------|-------------|---------|
-| `--suppressions` | `-s` | Path to suppression file | `.oxlint-suppressions.json` |
-| `--update` | `-u` | Update/create suppression file | `false` |
-| `--show-code` |  | Show code snippets for files with N or fewer errors (0 to disable) | `3` |
-| `--fail-on-excess` |  | Exit 1 if unsuppressed errors exist | `true` |
-| `--no-fail-on-excess` |  | Don't exit 1 on unsuppressed errors | - |
-| `--help` | `-h` | Show help | - |
+| Option                | Short | Description                                                        | Default                     |
+| --------------------- | ----- | ------------------------------------------------------------------ | --------------------------- |
+| `--suppressions`      | `-s`  | Path to suppression file                                           | `.oxlint-suppressions.json` |
+| `--update`            | `-u`  | Update/create suppression file                                     | `false`                     |
+| `--show-code`         |       | Show code snippets for files with N or fewer errors (0 to disable) | `3`                         |
+| `--fail-on-excess`    |       | Exit 1 if unsuppressed errors exist                                | `true`                      |
+| `--no-fail-on-excess` |       | Don't exit 1 on unsuppressed errors                                | -                           |
+| `--help`              | `-h`  | Show help                                                          | -                           |
 
-All additional arguments are passed directly to oxlint.
+### Environment Variables
+
+| Variable                                  | Description                                                                                                | Equivalent Flag |
+| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------- | --------------- |
+| `OXLINT_HARNESS_UPDATE_BULK_SUPPRESSION`  | Set to `true` to update/create suppression file                                                            | `--update`      |
+| `OXLINT_HARNESS_TIGHTEN_BULK_SUPPRESSION` | Set to `true` to automatically remove/reduce suppressions for cleaned-up violations during non-update runs | -               |
+
+Example:
+
+```bash
+OXLINT_HARNESS_UPDATE_BULK_SUPPRESSION=true npx oxlint-harness src/
+OXLINT_HARNESS_TIGHTEN_BULK_SUPPRESSION=true npx oxlint-harness src/
+```
+
+### Passing Additional oxlint Flags
+
+All additional arguments and unknown flags are passed directly to oxlint. This allows you to use any oxlint-specific options, even if they are not documented here.
+
+For example, to enable type-aware linting:
+
+```bash
+npx oxlint-harness --type-aware src/
+```
+
+Any flag not recognized by oxlint-harness will be forwarded to oxlint automatically.
 
 ## Usage Examples
 
@@ -112,6 +136,7 @@ npx oxlint-harness --no-fail-on-excess src/
 ### Initial Setup
 
 1. Run with `--update` to create initial suppression file:
+
    ```bash
    npx oxlint-harness --update src/
    ```
@@ -129,6 +154,7 @@ npx oxlint-harness --no-fail-on-excess src/
 ### Example Output
 
 #### With Code Snippets (default for files with ≤3 errors)
+
 ```
 ❌ Found unsuppressed errors:
 
@@ -146,8 +172,8 @@ npx oxlint-harness --no-fail-on-excess src/
      ╰────
   help: Consider removing this declaration.
 
-    📝 To suppress, add to suppression file:
-       "src/App.tsx": { "eslint(no-unused-vars)": { "count": 1 } }
+    📝 To suppress, re-run with:
+    OXLINT_HARNESS_UPDATE_BULK_SUPPRESSION=true oxlint-harness [your-args]
 
 📊 Summary:
    • Files with issues: 1
@@ -158,17 +184,24 @@ npx oxlint-harness --no-fail-on-excess src/
    oxlint-harness --update src/
 ```
 
-#### Simple List (for files with many errors)
+#### With Many Errors (first error shown with code snippet)
+
 ```
 📄 src/Components.tsx:
   ⚠️  prefer-const: 15 excess errors (expected: 10, actual: 25)
-    • src/Components.tsx:42:12: 'data' is never reassigned
+
+  × prefer-const: 'data' is never reassigned. Use 'const' instead.
+     ╭─[42:12]
+  42 │ let data = fetchData();
+              ─────────────
+  help: Use 'const' instead.
+
     • src/Components.tsx:58:8: 'config' is never reassigned
     • src/Components.tsx:74:15: 'result' is never reassigned
     ... and 12 more
 
-    📝 To suppress, add to suppression file:
-       "src/Components.tsx": { "prefer-const": { "count": 25 } }
+    📝 To suppress, re-run with:
+    OXLINT_HARNESS_UPDATE_BULK_SUPPRESSION=true oxlint-harness [your-args]
 ```
 
 ## Requirements
@@ -209,4 +242,4 @@ pnpm dev --help
 
 ## License
 
-MIT
+MIT

package/dist/cli.js

@@ -1,6 +1,3 @@
 #!/usr/bin/env node
 import OxlintHarness from './command.js';
-OxlintHarness.run().catch((error) => {
-    console.error(error);
-    process.exit(1);
-});
+OxlintHarness.run();

package/dist/command.d.ts

@@ -1,4 +1,4 @@
-import { Command } from '@oclif/core';
+import { Command } from "@oclif/core";
 export default class OxlintHarness extends Command {
     static summary: string;
     static description: string;
@@ -6,13 +6,15 @@ export default class OxlintHarness extends Command {
     static flags: {
         suppressions: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         update: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'fail-on-excess': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'show-code': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
-        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        "fail-on-excess": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "show-code": import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        "results-path": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "save-results": import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static args: {
         paths: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static strict: boolean;
     run(): Promise<void>;
+    private saveResults;
 }

package/dist/command.js

@@ -1,10 +1,12 @@
-import { Command, Flags, Args } from '@oclif/core';
-import { OxlintRunner } from './oxlint-runner.js';
-import { SuppressionManager } from './suppression-manager.js';
-import { ErrorReporter } from './error-reporter.js';
-import { ColorFormatter } from './colors.js';
+import { Command, Flags, Args } from "@oclif/core";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { OxlintRunner } from "./oxlint-runner.js";
+import { SuppressionManager } from "./suppression-manager.js";
+import { ErrorReporter } from "./error-reporter.js";
+import { ColorFormatter } from "./colors.js";
 export default class OxlintHarness extends Command {
-    static summary = 'Run oxlint with bulk suppressions support';
+    static summary = "Run oxlint with bulk suppressions support";
     static description = `
 Runs oxlint with support for bulk suppressions similar to ESLint.
 
@@ -17,46 +19,181 @@ The suppression file format uses counts per rule per file:
 }
   `;
     static examples = [
-        '<%= config.bin %> <%= command.id %> src/',
-        '<%= config.bin %> <%= command.id %> --update src/',
-        '<%= config.bin %> <%= command.id %> --suppressions .my-suppressions.json src/',
+        "<%= config.bin %> <%= command.id %> src/",
+        "<%= config.bin %> <%= command.id %> --update src/",
+        "<%= config.bin %> <%= command.id %> --suppressions .my-suppressions.json src/",
     ];
     static flags = {
         suppressions: Flags.string({
-            char: 's',
-            description: 'Path to suppression file',
-            default: '.oxlint-suppressions.json',
+            char: "s",
+            description: "Path to suppression file",
+            default: ".oxlint-suppressions.json",
         }),
         update: Flags.boolean({
-            char: 'u',
-            description: 'Update/create suppression file with current error counts',
+            char: "u",
+            description: "Update/create suppression file with current error counts",
             default: false,
         }),
-        'fail-on-excess': Flags.boolean({
-            description: 'Exit with non-zero code if there are unsuppressed errors',
+        "fail-on-excess": Flags.boolean({
+            description: "Exit with non-zero code if there are unsuppressed errors",
             default: true,
             allowNo: true,
         }),
-        'show-code': Flags.integer({
-            description: 'Show code snippets for files with N or fewer errors (0 to disable)',
+        "show-code": Flags.integer({
+            description: "Show code snippets for files with N or fewer errors (0 to disable)",
             default: 3,
         }),
-        help: Flags.help({ char: 'h' }),
+        "results-path": Flags.string({
+            description: "Path to save oxlint JSON results (default: artifacts/oxlint-results.json)",
+            default: "artifacts/oxlint-results.json",
+            env: "OXLINT_HARNESS_RESULTS_PATH",
+        }),
+        "save-results": Flags.boolean({
+            description: "Save oxlint JSON results to file",
+            default: true,
+            allowNo: true,
+        }),
     };
     static args = {
         paths: Args.string({
-            description: 'Files or directories to lint (passed to oxlint)',
+            description: "Files or directories to lint (passed to oxlint)",
             required: false,
         }),
     };
     static strict = false; // Allow additional args to be passed to oxlint
     async run() {
-        const { flags, argv } = await this.parse(OxlintHarness);
+        // Check for help flag first - check both this.argv and process.argv
+        const rawArgs = this.argv.slice(1);
+        const processArgs = process.argv.slice(2); // Skip 'node' and script path
+        const hasHelp = rawArgs.includes("--help") ||
+            rawArgs.includes("-h") ||
+            processArgs.includes("--help") ||
+            processArgs.includes("-h");
+        if (hasHelp) {
+            this.log(OxlintHarness.description);
+            this.log("");
+            this.log("USAGE");
+            this.log(`  $ oxlint-harness [FLAGS] [ARGS]`);
+            this.log("");
+            this.log("FLAGS");
+            this.log("  -s, --suppressions <path>    Path to suppression file (default: .oxlint-suppressions.json)");
+            this.log("  -u, --update                  Update/create suppression file with current error counts");
+            this.log("      --fail-on-excess          Exit 1 if unsuppressed errors exist (default: true)");
+            this.log("      --no-fail-on-excess       Don't exit 1 on unsuppressed errors");
+            this.log("      --show-code <number>      Show code snippets for files with N or fewer errors (default: 3, 0 to disable)");
+            this.log("      --results-path <path>     Path to save oxlint JSON results (default: artifacts/oxlint-results.json)");
+            this.log("      --no-save-results         Don't save oxlint JSON results to file");
+            this.log("  -h, --help                    Show this help message");
+            this.log("");
+            this.log("ENVIRONMENT VARIABLES");
+            this.log("  OXLINT_HARNESS_RESULTS_PATH          Override the results file path");
+            this.log("  OXLINT_HARNESS_NO_FAIL_ON_EXCESS     Set to 'true' to exit 0 on new errors");
+            this.log("");
+            this.log("ARGS");
+            this.log("  <paths>                       Files or directories to lint (passed to oxlint)");
+            this.log("");
+            this.log("EXAMPLES");
+            this.log(`  $ oxlint-harness src/`);
+            this.log(`  $ oxlint-harness --update src/`);
+            this.log(`  $ oxlint-harness --type-aware src/`);
+            this.log(`  $ oxlint-harness --suppressions .my-suppressions.json src/`);
+            return;
+        }
+        // Parse with error handling for unknown flags
+        let flags;
+        let oxlintArgs = [];
+        try {
+            const parsed = await this.parse(OxlintHarness);
+            flags = parsed.flags;
+            oxlintArgs = parsed.argv;
+        }
+        catch (error) {
+            // If error is due to unknown flags (NonExistentFlagsError), manually parse
+            if (error.name === "NonExistentFlagsError" ||
+                (error.flags && Array.isArray(error.flags))) {
+                const parsedFlags = {
+                    suppressions: ".oxlint-suppressions.json",
+                    update: false,
+                    "fail-on-excess": true,
+                    "show-code": 3,
+                    "results-path": process.env.OXLINT_HARNESS_RESULTS_PATH ||
+                        "artifacts/oxlint-results.json",
+                    "save-results": true,
+                };
+                const knownFlagNames = new Set([
+                    "--suppressions",
+                    "-s",
+                    "--update",
+                    "-u",
+                    "--fail-on-excess",
+                    "--no-fail-on-excess",
+                    "--show-code",
+                    "--results-path",
+                    "--save-results",
+                    "--no-save-results",
+                ]);
+                // Manually parse known flags and collect unknown ones
+                for (let i = 0; i < rawArgs.length; i++) {
+                    const arg = rawArgs[i];
+                    if (arg === "--suppressions" || arg === "-s") {
+                        parsedFlags.suppressions = rawArgs[++i] || parsedFlags.suppressions;
+                    }
+                    else if (arg === "--update" || arg === "-u") {
+                        parsedFlags.update = true;
+                    }
+                    else if (arg === "--fail-on-excess") {
+                        parsedFlags["fail-on-excess"] = true;
+                    }
+                    else if (arg === "--no-fail-on-excess") {
+                        parsedFlags["fail-on-excess"] = false;
+                    }
+                    else if (arg === "--show-code") {
+                        const value = rawArgs[++i];
+                        if (value)
+                            parsedFlags["show-code"] = parseInt(value, 10) || 3;
+                    }
+                    else if (arg === "--results-path") {
+                        parsedFlags["results-path"] =
+                            rawArgs[++i] || parsedFlags["results-path"];
+                    }
+                    else if (arg === "--save-results") {
+                        parsedFlags["save-results"] = true;
+                    }
+                    else if (arg === "--no-save-results") {
+                        parsedFlags["save-results"] = false;
+                    }
+                    else if (!knownFlagNames.has(arg) &&
+                        arg !== "--help" &&
+                        arg !== "-h") {
+                        // Unknown flag or positional arg - pass to oxlint
+                        oxlintArgs.push(arg);
+                    }
+                }
+                flags = parsedFlags;
+            }
+            else {
+                // Re-throw if it's a different error
+                throw error;
+            }
+        }
+        // Check for OXLINT_HARNESS_UPDATE_BULK_SUPPRESSION environment variable
+        if (process.env.OXLINT_HARNESS_UPDATE_BULK_SUPPRESSION?.toLowerCase() ===
+            "true") {
+            flags.update = true;
+        }
+        // Check for OXLINT_HARNESS_NO_FAIL_ON_EXCESS environment variable
+        if (process.env.OXLINT_HARNESS_NO_FAIL_ON_EXCESS?.toLowerCase() === "true") {
+            flags["fail-on-excess"] = false;
+        }
         const colors = new ColorFormatter();
         try {
             // Run oxlint with remaining args
             const runner = new OxlintRunner();
-            const diagnostics = await runner.run(argv);
+            const diagnostics = await runner.run(oxlintArgs);
+            // Save results if enabled
+            if (flags["save-results"]) {
+                await this.saveResults(flags["results-path"], diagnostics);
+            }
             // Handle suppression logic
             const suppressionManager = new SuppressionManager(flags.suppressions);
             if (flags.update) {
@@ -64,21 +201,30 @@ The suppression file format uses counts per rule per file:
                 const currentSuppressions = suppressionManager.loadSuppressions();
                 const updatedSuppressions = suppressionManager.updateSuppressions(currentSuppressions, diagnostics);
                 suppressionManager.saveSuppressions(updatedSuppressions);
-                this.log(`${colors.success('Updated suppression file:')} ${colors.filename(flags.suppressions)}`);
-                this.log(`${colors.info('Total diagnostics:')} ${colors.emphasis(diagnostics.length.toString())}`);
+                this.log(`${colors.success("Updated suppression file:")} ${colors.filename(flags.suppressions)}`);
+                this.log(`${colors.info("Total diagnostics:")} ${colors.emphasis(diagnostics.length.toString())}`);
                 return;
             }
             // Normal mode: check suppressions
             const suppressions = suppressionManager.loadSuppressions();
             const excessErrors = suppressionManager.findExcessErrors(diagnostics, suppressions);
+            // Check for OXLINT_HARNESS_TIGHTEN_BULK_SUPPRESSION environment variable
+            const shouldTighten = process.env.OXLINT_HARNESS_TIGHTEN_BULK_SUPPRESSION?.toLowerCase() ===
+                "true";
+            if (shouldTighten) {
+                // Tighten suppressions by removing/reducing cleaned-up violations
+                const tightenedSuppressions = suppressionManager.tightenSuppressions(suppressions, diagnostics);
+                suppressionManager.saveSuppressions(tightenedSuppressions);
+                this.log(`${colors.success("Tightened suppression file:")} ${colors.filename(flags.suppressions)}`);
+            }
             if (excessErrors.length === 0) {
-                this.log(`${colors.successIcon()} ${colors.success('All errors are suppressed')}`);
+                this.log(`${colors.successIcon()} ${colors.success("All errors are suppressed")}`);
                 return;
             }
             // Report excess errors
             const reporter = new ErrorReporter();
-            reporter.reportExcessErrors(excessErrors, flags['show-code']);
-            if (flags['fail-on-excess']) {
+            reporter.reportExcessErrors(excessErrors, flags["show-code"]);
+            if (flags["fail-on-excess"]) {
                 this.exit(1);
             }
         }
@@ -86,4 +232,9 @@ The suppression file format uses counts per rule per file:
             this.error(error instanceof Error ? error.message : String(error));
         }
     }
+    async saveResults(path, diagnostics) {
+        const dir = dirname(path);
+        await mkdir(dir, { recursive: true });
+        await writeFile(path, JSON.stringify(diagnostics, null, 2));
+    }
 }

package/dist/error-reporter.d.ts

@@ -1,4 +1,4 @@
-import { ExcessError } from './types.js';
+import { ExcessError } from "./types.js";
 export declare class ErrorReporter {
     private snippetExtractor;
     private colors;

package/dist/error-reporter.js

@@ -1,10 +1,10 @@
-import { CodeSnippetExtractor } from './code-snippet.js';
-import { ColorFormatter } from './colors.js';
+import { CodeSnippetExtractor } from "./code-snippet.js";
+import { ColorFormatter } from "./colors.js";
 export class ErrorReporter {
     snippetExtractor = new CodeSnippetExtractor();
     colors = new ColorFormatter();
     reportExcessErrors(excessErrors, showCodeThreshold = 3) {
-        console.error(`${this.colors.error('❌')} Found unsuppressed errors:\n`);
+        console.error(`${this.colors.error("❌")} Found unsuppressed errors:\n`);
         let totalExcess = 0;
         // Group errors by file for better readability
         const errorsByFile = new Map();
@@ -19,52 +19,80 @@ export class ErrorReporter {
             for (const error of fileErrors) {
                 const excess = error.actual - error.expected;
                 totalExcess += excess;
-                const excessText = excess === 1 ? 'error' : 'errors';
+                const excessText = excess === 1 ? "error" : "errors";
                 console.error(`  ${this.colors.warningIcon()}  ${this.colors.rule(error.rule)}: ${this.colors.emphasis(excess.toString())} excess ${excessText} (expected: ${this.colors.muted(error.expected.toString())}, actual: ${this.colors.emphasis(error.actual.toString())})`);
-                // Show detailed code snippets for files with few errors
-                if (showCodeThreshold > 0 && error.diagnostics.length <= showCodeThreshold) {
-                    console.error(''); // Add spacing before code snippets
-                    error.diagnostics.forEach((diagnostic, index) => {
-                        const snippet = this.snippetExtractor.getCodeSnippet(diagnostic);
-                        if (snippet) {
-                            const formattedSnippet = this.snippetExtractor.formatCodeSnippet(snippet, diagnostic.rule, diagnostic.message, diagnostic.help);
-                            console.error(formattedSnippet);
+                // Always show the first diagnostic with full code snippet
+                if (showCodeThreshold > 0 && error.diagnostics.length > 0) {
+                    console.error(""); // Add spacing before code snippets
+                    // Always show first diagnostic with code snippet
+                    const firstDiagnostic = error.diagnostics[0];
+                    const snippet = this.snippetExtractor.getCodeSnippet(firstDiagnostic);
+                    if (snippet) {
+                        const formattedSnippet = this.snippetExtractor.formatCodeSnippet(snippet, firstDiagnostic.rule, firstDiagnostic.message, firstDiagnostic.help);
+                        console.error(formattedSnippet);
+                    }
+                    else {
+                        // Fallback to simple format if can't read file
+                        const location = firstDiagnostic.line
+                            ? `:${this.colors.lineNumber(firstDiagnostic.line.toString())}:${this.colors.lineNumber((firstDiagnostic.column || 0).toString())}`
+                            : "";
+                        console.error(`    • ${this.colors.filename(firstDiagnostic.filename)}${location}: ${firstDiagnostic.message}`);
+                        if (firstDiagnostic.help) {
+                            console.error(`      ${this.colors.infoIcon()} ${this.colors.help(firstDiagnostic.help)}`);
                         }
-                        else {
-                            // Fallback to simple format if can't read file
-                            const location = diagnostic.line ? `:${this.colors.lineNumber(diagnostic.line.toString())}:${this.colors.lineNumber((diagnostic.column || 0).toString())}` : '';
-                            console.error(`    • ${this.colors.filename(diagnostic.filename)}${location}: ${diagnostic.message}`);
-                            if (diagnostic.help) {
-                                console.error(`      ${this.colors.infoIcon()} ${this.colors.help(diagnostic.help)}`);
+                    }
+                    // If there are more diagnostics, show them based on threshold
+                    if (error.diagnostics.length > 1) {
+                        if (error.diagnostics.length <= showCodeThreshold) {
+                            // Show remaining diagnostics with snippets if under threshold
+                            for (let i = 1; i < error.diagnostics.length; i++) {
+                                const diagnostic = error.diagnostics[i];
+                                const snippet = this.snippetExtractor.getCodeSnippet(diagnostic);
+                                if (snippet) {
+                                    const formattedSnippet = this.snippetExtractor.formatCodeSnippet(snippet, diagnostic.rule, diagnostic.message, diagnostic.help);
+                                    console.error(formattedSnippet);
+                                }
+                                else {
+                                    // Fallback to simple format if can't read file
+                                    const location = diagnostic.line
+                                        ? `:${this.colors.lineNumber(diagnostic.line.toString())}:${this.colors.lineNumber((diagnostic.column || 0).toString())}`
+                                        : "";
+                                    console.error(`    • ${this.colors.filename(diagnostic.filename)}${location}: ${diagnostic.message}`);
+                                    if (diagnostic.help) {
+                                        console.error(`      ${this.colors.infoIcon()} ${this.colors.help(diagnostic.help)}`);
+                                    }
+                                }
                             }
                         }
-                    });
-                }
-                else {
-                    // Show up to 3 example diagnostics for files with many errors
-                    const exampleCount = Math.min(3, error.diagnostics.length);
-                    for (let i = 0; i < exampleCount; i++) {
-                        const diagnostic = error.diagnostics[i];
-                        const location = diagnostic.line ? `:${this.colors.lineNumber(diagnostic.line.toString())}:${this.colors.lineNumber((diagnostic.column || 0).toString())}` : '';
-                        console.error(`    • ${this.colors.filename(diagnostic.filename)}${location}: ${diagnostic.message}`);
-                        if (diagnostic.help) {
-                            console.error(`      ${this.colors.infoIcon()} ${this.colors.help(diagnostic.help)}`);
+                        else {
+                            // Show remaining diagnostics (up to 2 more) as simple list items
+                            const remainingCount = Math.min(2, error.diagnostics.length - 1);
+                            for (let i = 1; i <= remainingCount; i++) {
+                                const diagnostic = error.diagnostics[i];
+                                const location = diagnostic.line
+                                    ? `:${this.colors.lineNumber(diagnostic.line.toString())}:${this.colors.lineNumber((diagnostic.column || 0).toString())}`
+                                    : "";
+                                console.error(`    • ${this.colors.filename(diagnostic.filename)}${location}: ${diagnostic.message}`);
+                                if (diagnostic.help) {
+                                    console.error(`      ${this.colors.infoIcon()} ${this.colors.help(diagnostic.help)}`);
+                                }
+                            }
+                            if (error.diagnostics.length > remainingCount + 1) {
+                                console.error(`    ${this.colors.muted(`... and ${error.diagnostics.length - remainingCount - 1} more`)}`);
+                            }
                         }
                     }
-                    if (error.diagnostics.length > exampleCount) {
-                        console.error(`    ${this.colors.muted(`... and ${error.diagnostics.length - exampleCount} more`)}`);
-                    }
                 }
                 // Suggestion to suppress
-                console.error(`    📝 ${this.colors.info('To suppress, add to suppression file:')}`);
-                console.error(`       ${this.colors.muted('"')}${this.colors.filename(error.filename)}${this.colors.muted('"')}: { ${this.colors.muted('"')}${this.colors.rule(error.rule)}${this.colors.muted('"')}: { ${this.colors.muted('"count"')}: ${this.colors.emphasis(error.actual.toString())} } }\n`);
+                console.error(`    📝 ${this.colors.info("To suppress, re-run with:")}`);
+                console.error(`    ${this.colors.emphasis("OXLINT_HARNESS_UPDATE_BULK_SUPPRESSION=true oxlint-harness [your-args]")}\n`);
             }
         }
-        console.error(`\n📊 ${this.colors.info('Summary:')}`);
+        console.error(`\n📊 ${this.colors.info("Summary:")}`);
         console.error(`   • Files with issues: ${this.colors.emphasis(errorsByFile.size.toString())}`);
         console.error(`   • Rules with excess errors: ${this.colors.emphasis(excessErrors.length.toString())}`);
         console.error(`   • Total excess errors: ${this.colors.emphasis(totalExcess.toString())}`);
-        console.error(`\n${this.colors.infoIcon()} ${this.colors.info('To suppress all current errors, run:')}`);
-        console.error(`   ${this.colors.emphasis('oxlint-harness --update [your-args]')}`);
+        console.error(`\n${this.colors.infoIcon()} ${this.colors.info("To suppress all current errors, run:")}`);
+        console.error(`   ${this.colors.emphasis("oxlint-harness --update [your-args]")}`);
     }
 }

package/dist/suppression-manager.d.ts

@@ -1,4 +1,4 @@
-import { SuppressionFile, ProcessedDiagnostic, ExcessError } from './types.js';
+import { SuppressionFile, ProcessedDiagnostic, ExcessError } from "./types.js";
 export declare class SuppressionManager {
     private suppressionFile;
     constructor(suppressionFile?: string);
@@ -7,4 +7,5 @@ export declare class SuppressionManager {
     generateSuppressions(diagnostics: ProcessedDiagnostic[]): SuppressionFile;
     findExcessErrors(diagnostics: ProcessedDiagnostic[], suppressions: SuppressionFile): ExcessError[];
     updateSuppressions(currentSuppressions: SuppressionFile, diagnostics: ProcessedDiagnostic[]): SuppressionFile;
+    tightenSuppressions(currentSuppressions: SuppressionFile, diagnostics: ProcessedDiagnostic[]): SuppressionFile;
 }

package/dist/suppression-manager.js

@@ -1,7 +1,7 @@
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync } from "fs";
 export class SuppressionManager {
     suppressionFile;
-    constructor(suppressionFile = '.oxlint-suppressions.json') {
+    constructor(suppressionFile = ".oxlint-suppressions.json") {
         this.suppressionFile = suppressionFile;
     }
     loadSuppressions() {
@@ -9,7 +9,7 @@ export class SuppressionManager {
             return {};
         }
         try {
-            const content = readFileSync(this.suppressionFile, 'utf8');
+            const content = readFileSync(this.suppressionFile, "utf8");
             return JSON.parse(content);
         }
         catch (error) {
@@ -19,7 +19,7 @@ export class SuppressionManager {
     saveSuppressions(suppressions) {
         try {
             const content = JSON.stringify(suppressions, null, 2);
-            writeFileSync(this.suppressionFile, content, 'utf8');
+            writeFileSync(this.suppressionFile, content, "utf8");
         }
         catch (error) {
             throw new Error(`Failed to write suppression file ${this.suppressionFile}: ${error instanceof Error ? error.message : String(error)}`);
@@ -71,7 +71,7 @@ export class SuppressionManager {
                         filename,
                         expected,
                         actual,
-                        diagnostics: diagnosticsForRule
+                        diagnostics: diagnosticsForRule,
                     });
                 }
             }
@@ -93,4 +93,45 @@ export class SuppressionManager {
         }
         return updated;
     }
+    tightenSuppressions(currentSuppressions, diagnostics) {
+        // Group diagnostics by file and rule to get actual counts
+        const actualCounts = new Map();
+        for (const diagnostic of diagnostics) {
+            if (!actualCounts.has(diagnostic.filename)) {
+                actualCounts.set(diagnostic.filename, new Map());
+            }
+            const fileRules = actualCounts.get(diagnostic.filename);
+            const currentCount = fileRules.get(diagnostic.rule) || 0;
+            fileRules.set(diagnostic.rule, currentCount + 1);
+        }
+        // Create a copy of current suppressions to modify
+        const tightened = { ...currentSuppressions };
+        // Process each file in current suppressions
+        for (const [filename, rules] of Object.entries(tightened)) {
+            const fileRules = { ...rules };
+            // Process each rule in the file
+            for (const [rule, suppression] of Object.entries(fileRules)) {
+                const expected = suppression.count;
+                const actual = actualCounts.get(filename)?.get(rule) || 0;
+                if (actual === 0) {
+                    // Remove entry if no actual errors exist
+                    delete fileRules[rule];
+                }
+                else if (actual < expected) {
+                    // Reduce count to actual if violations were cleaned up
+                    fileRules[rule] = { count: actual };
+                }
+                // If actual >= expected, keep as is (excess errors handled by findExcessErrors)
+            }
+            // Update the file entry
+            if (Object.keys(fileRules).length === 0) {
+                // Remove file entry if no rules remain
+                delete tightened[filename];
+            }
+            else {
+                tightened[filename] = fileRules;
+            }
+        }
+        return tightened;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-harness",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A harness for oxlint with bulk suppressions support",
   "type": "module",
   "main": "dist/index.js",
@@ -43,5 +43,6 @@
   },
   "engines": {
     "node": ">=22"
-  }
-}
+  },
+  "packageManager": "pnpm@9.15.9"
+}