oxlint-harness 1.0.0

package/README.md

@@ -0,0 +1,212 @@
+# oxlint-harness
+
+A harness for [oxlint](https://oxc.rs) that provides ESLint-style bulk suppressions support. This tool allows you to gradually adopt stricter linting rules by suppressing existing violations while preventing new ones.
+
+## Features
+
+- ✅ **Bulk Suppressions**: Suppress specific counts of lint violations per file per rule
+- ✅ **Incremental Adoption**: Only fail on new violations beyond suppressed counts
+- ✅ **Rich Colored Output**: Beautiful terminal colors with syntax highlighting
+- ✅ **Code Snippets**: Show actual code context for files with few errors (configurable)
+- ✅ **Smart Package Detection**: Auto-detects pnpm/yarn/npm with monorepo support
+- ✅ **Update Mode**: Generate/update suppression files automatically
+- ✅ **Pass-through**: Forward all arguments to oxlint seamlessly
+
+## Installation
+
+```bash
+npm install oxlint-harness
+# or
+pnpm add oxlint-harness
+# or
+yarn add oxlint-harness
+```
+
+## Quick Start
+
+```bash
+# Run oxlint with suppressions (fails on excess errors)
+npx oxlint-harness src/
+
+# Generate initial suppression file
+npx oxlint-harness --update src/
+
+# Use custom suppression file
+npx oxlint-harness --suppressions .my-suppressions.json src/
+```
+
+## Suppression File Format
+
+The suppression file uses a count-based format:
+
+```json
+{
+  "src/App.tsx": {
+    "@typescript-eslint/no-unused-vars": { "count": 1 },
+    "eqeqeq": { "count": 1 },
+    "no-var": { "count": 1 },
+    "prefer-const": { "count": 1 }
+  },
+  "src/utils.ts": {
+    "no-console": { "count": 3 }
+  }
+}
+```
+
+## 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 | - |
+
+All additional arguments are passed directly to oxlint.
+
+## Usage Examples
+
+### Basic Usage
+
+```bash
+# Check files with suppressions
+npx oxlint-harness src/ lib/
+
+# Pass oxlint options
+npx oxlint-harness --type-aware src/
+
+# Use different suppression file
+npx oxlint-harness -s .eslint-suppressions.json src/
+
+# Show code snippets for files with ≤1 error
+npx oxlint-harness --show-code 1 src/
+
+# Disable code snippets (simple list only)
+npx oxlint-harness --show-code 0 src/
+```
+
+### Generating Suppressions
+
+```bash
+# Create initial suppression file (records current error counts)
+npx oxlint-harness --update src/
+
+# Update existing suppressions with new counts
+npx oxlint-harness --update --suppressions custom.json src/
+```
+
+### CI Integration
+
+```bash
+# In CI: fail build if new errors are introduced
+npx oxlint-harness src/
+
+# For reporting mode (don't fail build)
+npx oxlint-harness --no-fail-on-excess src/
+```
+
+## Workflow
+
+### Initial Setup
+
+1. Run with `--update` to create initial suppression file:
+   ```bash
+   npx oxlint-harness --update src/
+   ```
+
+2. Commit the `.oxlint-suppressions.json` file
+
+3. Configure CI to run `npx oxlint-harness src/`
+
+### Daily Development
+
+- **Normal runs**: Only new violations (beyond suppressed counts) will cause failures
+- **Fixing violations**: Counts automatically decrease as issues are resolved
+- **Adding suppressions**: Update counts manually or re-run with `--update`
+
+### Example Output
+
+#### With Code Snippets (default for files with ≤3 errors)
+```
+❌ Found unsuppressed errors:
+
+📄 src/App.tsx:
+  ⚠️  eslint(no-unused-vars): 1 excess error (expected: 0, actual: 1)
+
+  × eslint(no-unused-vars): Variable 'thing' is declared but never used. Unused variables should start with a '_'.
+     ╭─[24:7]
+  24 │ }));
+  25 │
+  26 │ const thing = 3;
+              ─────────────
+  27 │
+  28 │ const PartnerAppRootBase: React.VFC = () => {
+     ╰────
+  help: Consider removing this declaration.
+
+    📝 To suppress, add to suppression file:
+       "src/App.tsx": { "eslint(no-unused-vars)": { "count": 1 } }
+
+📊 Summary:
+   • Files with issues: 1
+   • Rules with excess errors: 1
+   • Total excess errors: 1
+
+💡 To suppress all current errors, run:
+   oxlint-harness --update src/
+```
+
+#### Simple List (for files with many errors)
+```
+📄 src/Components.tsx:
+  ⚠️  prefer-const: 15 excess errors (expected: 10, actual: 25)
+    • src/Components.tsx:42:12: 'data' is never reassigned
+    • 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 } }
+```
+
+## Requirements
+
+- Node.js 22+ (for native TypeScript support)
+- `oxlint` installed and available (via pnpm/yarn/npm)
+
+## How It Works
+
+1. **Package Manager Detection**: Automatically detects if you're using pnpm, yarn, or npm by looking for lock files up the directory tree (supports monorepos)
+2. **Oxlint Execution**: Runs `pnpm oxlint`, `yarn oxlint`, or `npx oxlint` with JSON output
+3. **Suppression Matching**: Compares actual error counts against your suppression file
+4. **Smart Reporting**: Shows code snippets for files with few errors, simple lists for files with many errors
+5. **Colored Output**: Beautiful terminal colors that automatically disable in non-TTY environments
+
+## Contributing
+
+Issues and pull requests are welcome! Please see the [GitHub repository](https://github.com/MIreland/oxlint-harness) for more information.
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Run tests
+pnpm test
+
+# Type checking
+pnpm typecheck
+
+# Lint
+pnpm lint
+
+# Development mode
+pnpm dev --help
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

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

package/dist/code-snippet.d.ts

@@ -0,0 +1,17 @@
+import { ProcessedDiagnostic } from './types.js';
+export interface CodeSnippet {
+    beforeLines: string[];
+    targetLine: string;
+    afterLines: string[];
+    lineNumber: number;
+    columnStart: number;
+    columnEnd: number;
+}
+export declare class CodeSnippetExtractor {
+    private fileCache;
+    private colors;
+    getCodeSnippet(diagnostic: ProcessedDiagnostic): CodeSnippet | null;
+    private getFileLines;
+    formatCodeSnippet(snippet: CodeSnippet, rule: string, message: string, help?: string): string;
+    private highlightSyntax;
+}

package/dist/code-snippet.js

@@ -0,0 +1,94 @@
+import { readFileSync, existsSync } from 'fs';
+import { ColorFormatter } from './colors.js';
+export class CodeSnippetExtractor {
+    fileCache = new Map();
+    colors = new ColorFormatter();
+    getCodeSnippet(diagnostic) {
+        if (!diagnostic.line || !diagnostic.filename) {
+            return null;
+        }
+        const lines = this.getFileLines(diagnostic.filename);
+        if (!lines) {
+            return null;
+        }
+        const lineIndex = diagnostic.line - 1; // Convert to 0-based index
+        const contextLines = 2; // Show 2 lines before/after
+        const beforeLines = lines.slice(Math.max(0, lineIndex - contextLines), lineIndex);
+        const targetLine = lines[lineIndex] || '';
+        const afterLines = lines.slice(lineIndex + 1, Math.min(lines.length, lineIndex + 1 + contextLines));
+        return {
+            beforeLines,
+            targetLine,
+            afterLines,
+            lineNumber: diagnostic.line,
+            columnStart: diagnostic.column || 0,
+            columnEnd: (diagnostic.column || 0) + (diagnostic.message.length || 10), // Rough estimate
+        };
+    }
+    getFileLines(filename) {
+        if (this.fileCache.has(filename)) {
+            return this.fileCache.get(filename);
+        }
+        if (!existsSync(filename)) {
+            return null;
+        }
+        try {
+            const content = readFileSync(filename, 'utf8');
+            const lines = content.split('\n');
+            this.fileCache.set(filename, lines);
+            return lines;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    formatCodeSnippet(snippet, rule, message, help) {
+        let output = '';
+        // Error header with colors
+        output += `  ${this.colors.errorIcon()} ${this.colors.rule(rule)}: ${message}\n`;
+        const startLineNum = snippet.lineNumber - snippet.beforeLines.length;
+        const endLineNum = snippet.lineNumber + snippet.afterLines.length;
+        // File path and line range with colors
+        output += `     ${this.colors.border('╭─')}${this.colors.filename(`[${startLineNum}:${snippet.columnStart}]`)}\n`;
+        // Before lines
+        snippet.beforeLines.forEach((line, index) => {
+            const lineNum = startLineNum + index;
+            const lineNumStr = this.colors.lineNumber(lineNum.toString().padStart(4));
+            const border = this.colors.border(' │ ');
+            output += `${lineNumStr}${border}${this.highlightSyntax(line)}\n`;
+        });
+        // Target line with error highlight
+        const targetLineNumStr = this.colors.lineNumber(snippet.lineNumber.toString().padStart(4));
+        const targetBorder = this.colors.border(' │ ');
+        output += `${targetLineNumStr}${targetBorder}${this.highlightSyntax(snippet.targetLine)}\n`;
+        // Error pointer with color
+        const indent = ' '.repeat(4 + 3 + snippet.columnStart); // Line number + "│ " + column offset
+        const pointer = this.colors.errorPointer('─'.repeat(Math.max(1, Math.min(snippet.columnEnd - snippet.columnStart, 20))));
+        output += `${indent}${pointer}\n`;
+        // After lines
+        snippet.afterLines.forEach((line, index) => {
+            const lineNum = snippet.lineNumber + 1 + index;
+            const lineNumStr = this.colors.lineNumber(lineNum.toString().padStart(4));
+            const border = this.colors.border(' │ ');
+            output += `${lineNumStr}${border}${this.highlightSyntax(line)}\n`;
+        });
+        output += `     ${this.colors.border('╰────')}\n`;
+        // Help text with color
+        if (help) {
+            output += `  ${this.colors.help('help:')} ${help}\n`;
+        }
+        return output;
+    }
+    highlightSyntax(line) {
+        // Simple syntax highlighting for common patterns
+        return line
+            // Keywords
+            .replace(/\b(const|let|var|function|class|if|else|for|while|return|import|export|from|await|async)\b/g, match => this.colors.keyword(match))
+            // Strings
+            .replace(/(['"`])((?:\\.|(?!\1)[^\\])*)\1/g, match => this.colors.string(match))
+            // Comments
+            .replace(/(\/\/.*$|\/\*.*?\*\/)/g, match => this.colors.comment(match))
+            // Numbers
+            .replace(/\b\d+\b/g, match => this.colors.info(match));
+    }
+}

package/dist/colors.d.ts

@@ -0,0 +1,51 @@
+export declare const colors: {
+    reset: string;
+    bright: string;
+    dim: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    bgRed: string;
+    bgGreen: string;
+    bgYellow: string;
+    bgBlue: string;
+    bgMagenta: string;
+    bgCyan: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+};
+export declare class ColorFormatter {
+    private useColors;
+    constructor(useColors?: boolean);
+    private colorize;
+    error(text: string): string;
+    warning(text: string): string;
+    success(text: string): string;
+    info(text: string): string;
+    rule(text: string): string;
+    filename(text: string): string;
+    lineNumber(text: string): string;
+    highlight(text: string): string;
+    help(text: string): string;
+    keyword(text: string): string;
+    string(text: string): string;
+    comment(text: string): string;
+    border(text: string): string;
+    emphasis(text: string): string;
+    muted(text: string): string;
+    errorPointer(text: string): string;
+    errorIcon(): string;
+    warningIcon(): string;
+    successIcon(): string;
+    infoIcon(): string;
+}

package/dist/colors.js

@@ -0,0 +1,107 @@
+// ANSI color codes for terminal output
+export const colors = {
+    // Basic colors
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Foreground colors
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+    // Background colors
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    // Bright foreground colors
+    brightRed: '\x1b[91m',
+    brightGreen: '\x1b[92m',
+    brightYellow: '\x1b[93m',
+    brightBlue: '\x1b[94m',
+    brightMagenta: '\x1b[95m',
+    brightCyan: '\x1b[96m',
+    brightWhite: '\x1b[97m',
+};
+export class ColorFormatter {
+    useColors;
+    constructor(useColors = true) {
+        this.useColors = useColors && process.stdout.isTTY;
+    }
+    colorize(text, color) {
+        if (!this.useColors)
+            return text;
+        return `${color}${text}${colors.reset}`;
+    }
+    // Error levels
+    error(text) {
+        return this.colorize(text, colors.brightRed);
+    }
+    warning(text) {
+        return this.colorize(text, colors.brightYellow);
+    }
+    success(text) {
+        return this.colorize(text, colors.brightGreen);
+    }
+    info(text) {
+        return this.colorize(text, colors.brightBlue);
+    }
+    // Syntax highlighting
+    rule(text) {
+        return this.colorize(text, colors.brightRed);
+    }
+    filename(text) {
+        return this.colorize(text, colors.brightBlue);
+    }
+    lineNumber(text) {
+        return this.colorize(text, colors.gray);
+    }
+    highlight(text) {
+        return this.colorize(text, colors.brightMagenta);
+    }
+    help(text) {
+        return this.colorize(text, colors.cyan);
+    }
+    // Code elements
+    keyword(text) {
+        return this.colorize(text, colors.magenta);
+    }
+    string(text) {
+        return this.colorize(text, colors.green);
+    }
+    comment(text) {
+        return this.colorize(text, colors.gray);
+    }
+    // UI elements
+    border(text) {
+        return this.colorize(text, colors.gray);
+    }
+    emphasis(text) {
+        return this.colorize(text, colors.bright);
+    }
+    muted(text) {
+        return this.colorize(text, colors.dim);
+    }
+    // Special formatting
+    errorPointer(text) {
+        return this.colorize(text, colors.brightMagenta);
+    }
+    errorIcon() {
+        return this.error('×');
+    }
+    warningIcon() {
+        return this.warning('⚠️');
+    }
+    successIcon() {
+        return this.success('✅');
+    }
+    infoIcon() {
+        return this.info('💡');
+    }
+}

package/dist/command.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class OxlintHarness extends Command {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    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>;
+    };
+    static args: {
+        paths: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/command.js

@@ -0,0 +1,89 @@
+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';
+export default class OxlintHarness extends Command {
+    static summary = 'Run oxlint with bulk suppressions support';
+    static description = `
+Runs oxlint with support for bulk suppressions similar to ESLint.
+
+The suppression file format uses counts per rule per file:
+{
+  "src/App.tsx": {
+    "no-unused-vars": { "count": 1 },
+    "prefer-const": { "count": 2 }
+  }
+}
+  `;
+    static examples = [
+        '<%= 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',
+        }),
+        update: Flags.boolean({
+            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',
+            default: true,
+            allowNo: true,
+        }),
+        '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' }),
+    };
+    static args = {
+        paths: Args.string({
+            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);
+        const colors = new ColorFormatter();
+        try {
+            // Run oxlint with remaining args
+            const runner = new OxlintRunner();
+            const diagnostics = await runner.run(argv);
+            // Handle suppression logic
+            const suppressionManager = new SuppressionManager(flags.suppressions);
+            if (flags.update) {
+                // Update mode: generate/update suppression 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())}`);
+                return;
+            }
+            // Normal mode: check suppressions
+            const suppressions = suppressionManager.loadSuppressions();
+            const excessErrors = suppressionManager.findExcessErrors(diagnostics, suppressions);
+            if (excessErrors.length === 0) {
+                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']) {
+                this.exit(1);
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/error-reporter.d.ts

@@ -0,0 +1,6 @@
+import { ExcessError } from './types.js';
+export declare class ErrorReporter {
+    private snippetExtractor;
+    private colors;
+    reportExcessErrors(excessErrors: ExcessError[], showCodeThreshold?: number): void;
+}

package/dist/error-reporter.js

@@ -0,0 +1,70 @@
+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`);
+        let totalExcess = 0;
+        // Group errors by file for better readability
+        const errorsByFile = new Map();
+        for (const error of excessErrors) {
+            if (!errorsByFile.has(error.filename)) {
+                errorsByFile.set(error.filename, []);
+            }
+            errorsByFile.get(error.filename).push(error);
+        }
+        for (const [filename, fileErrors] of errorsByFile.entries()) {
+            console.error(`📄 ${this.colors.filename(filename)}:`);
+            for (const error of fileErrors) {
+                const excess = error.actual - error.expected;
+                totalExcess += excess;
+                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);
+                        }
+                        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)}`);
+                        }
+                    }
+                    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(`\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]')}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { OxlintRunner } from './oxlint-runner.js';
+export { SuppressionManager } from './suppression-manager.js';
+export { ErrorReporter } from './error-reporter.js';
+export { CodeSnippetExtractor } from './code-snippet.js';
+export { ColorFormatter } from './colors.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { OxlintRunner } from './oxlint-runner.js';
+export { SuppressionManager } from './suppression-manager.js';
+export { ErrorReporter } from './error-reporter.js';
+export { CodeSnippetExtractor } from './code-snippet.js';
+export { ColorFormatter } from './colors.js';
+export * from './types.js';

package/dist/oxlint-runner.d.ts

@@ -0,0 +1,7 @@
+import { ProcessedDiagnostic } from './types.js';
+export declare class OxlintRunner {
+    private findLockFile;
+    private detectPackageManager;
+    run(args?: string[]): Promise<ProcessedDiagnostic[]>;
+    private parseOxlintOutput;
+}

package/dist/oxlint-runner.js

@@ -0,0 +1,133 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve, dirname, parse } from 'path';
+export class OxlintRunner {
+    findLockFile(startDir) {
+        let currentDir = startDir;
+        const root = parse(currentDir).root;
+        while (currentDir !== root) {
+            // Check for lock files in order of preference
+            const lockFiles = ['pnpm-lock.yaml', 'yarn.lock', 'package-lock.json'];
+            for (const lockFile of lockFiles) {
+                if (existsSync(resolve(currentDir, lockFile))) {
+                    return resolve(currentDir, lockFile);
+                }
+            }
+            // Move up one directory
+            const parent = dirname(currentDir);
+            if (parent === currentDir)
+                break; // Reached filesystem root
+            currentDir = parent;
+        }
+        return null;
+    }
+    detectPackageManager() {
+        const cwd = process.cwd();
+        const lockFile = this.findLockFile(cwd);
+        if (lockFile) {
+            const lockFileName = parse(lockFile).base;
+            if (lockFileName === 'pnpm-lock.yaml') {
+                return { command: 'pnpm', args: ['exec', 'oxlint'] };
+            }
+            if (lockFileName === 'yarn.lock') {
+                return { command: 'yarn', args: ['exec', 'oxlint'] };
+            }
+            if (lockFileName === 'package-lock.json') {
+                return { command: 'npx', args: ['oxlint'] };
+            }
+        }
+        // Fallback to direct oxlint if no lock file found
+        return { command: 'oxlint', args: [] };
+    }
+    async run(args = []) {
+        const packageManager = this.detectPackageManager();
+        const finalArgs = [...packageManager.args, '-f', 'json', ...args];
+        return new Promise((resolve, reject) => {
+            const process = spawn(packageManager.command, finalArgs, {
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            process.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            process.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            process.on('close', (code) => {
+                try {
+                    // oxlint exits with non-zero when linting issues are found
+                    // We still want to parse the JSON output
+                    const diagnostics = this.parseOxlintOutput(stdout);
+                    resolve(diagnostics);
+                }
+                catch (error) {
+                    reject(new Error(`Failed to parse oxlint output: ${error instanceof Error ? error.message : String(error)}\nStdout: ${stdout}\nStderr: ${stderr}`));
+                }
+            });
+            process.on('error', (error) => {
+                reject(new Error(`Failed to run ${packageManager.command}: ${error.message}`));
+            });
+        });
+    }
+    parseOxlintOutput(output) {
+        if (!output.trim()) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(output);
+            const diagnostics = [];
+            // Handle the new oxlint JSON format with diagnostics array
+            if (parsed.diagnostics && Array.isArray(parsed.diagnostics)) {
+                for (const diagnostic of parsed.diagnostics) {
+                    const processed = {
+                        filename: diagnostic.filename || 'unknown',
+                        rule: diagnostic.code || 'unknown',
+                        severity: diagnostic.severity,
+                        message: diagnostic.message,
+                        help: diagnostic.help,
+                        url: diagnostic.url
+                    };
+                    // Extract line/column from labels if available
+                    if (diagnostic.labels && diagnostic.labels.length > 0) {
+                        const firstLabel = diagnostic.labels[0];
+                        if (firstLabel.span) {
+                            processed.line = firstLabel.span.line;
+                            processed.column = firstLabel.span.column;
+                        }
+                    }
+                    diagnostics.push(processed);
+                }
+            }
+            // Fallback to old format if needed
+            else if (typeof parsed === 'object' && !Array.isArray(parsed)) {
+                for (const [filename, fileDiagnostics] of Object.entries(parsed)) {
+                    if (Array.isArray(fileDiagnostics)) {
+                        for (const diagnostic of fileDiagnostics) {
+                            const processed = {
+                                filename,
+                                rule: diagnostic.rule_id || diagnostic.code || 'unknown',
+                                severity: diagnostic.severity,
+                                message: diagnostic.message,
+                                help: diagnostic.help,
+                                url: diagnostic.url
+                            };
+                            if (diagnostic.labels && diagnostic.labels.length > 0) {
+                                const firstLabel = diagnostic.labels[0];
+                                if (firstLabel.span) {
+                                    processed.line = firstLabel.span.line || firstLabel.span.start;
+                                    processed.column = firstLabel.span.column || (firstLabel.span.end - firstLabel.span.start);
+                                }
+                            }
+                            diagnostics.push(processed);
+                        }
+                    }
+                }
+            }
+            return diagnostics;
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON output: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/suppression-manager.d.ts

@@ -0,0 +1,10 @@
+import { SuppressionFile, ProcessedDiagnostic, ExcessError } from './types.js';
+export declare class SuppressionManager {
+    private suppressionFile;
+    constructor(suppressionFile?: string);
+    loadSuppressions(): SuppressionFile;
+    saveSuppressions(suppressions: SuppressionFile): void;
+    generateSuppressions(diagnostics: ProcessedDiagnostic[]): SuppressionFile;
+    findExcessErrors(diagnostics: ProcessedDiagnostic[], suppressions: SuppressionFile): ExcessError[];
+    updateSuppressions(currentSuppressions: SuppressionFile, diagnostics: ProcessedDiagnostic[]): SuppressionFile;
+}

package/dist/suppression-manager.js

@@ -0,0 +1,96 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+export class SuppressionManager {
+    suppressionFile;
+    constructor(suppressionFile = '.oxlint-suppressions.json') {
+        this.suppressionFile = suppressionFile;
+    }
+    loadSuppressions() {
+        if (!existsSync(this.suppressionFile)) {
+            return {};
+        }
+        try {
+            const content = readFileSync(this.suppressionFile, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse suppression file ${this.suppressionFile}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    saveSuppressions(suppressions) {
+        try {
+            const content = JSON.stringify(suppressions, null, 2);
+            writeFileSync(this.suppressionFile, content, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to write suppression file ${this.suppressionFile}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    generateSuppressions(diagnostics) {
+        const suppressions = {};
+        // Group diagnostics by file and rule
+        const counts = new Map();
+        for (const diagnostic of diagnostics) {
+            if (!counts.has(diagnostic.filename)) {
+                counts.set(diagnostic.filename, new Map());
+            }
+            const fileRules = counts.get(diagnostic.filename);
+            const currentCount = fileRules.get(diagnostic.rule) || 0;
+            fileRules.set(diagnostic.rule, currentCount + 1);
+        }
+        // Convert to suppression format
+        for (const [filename, rules] of counts.entries()) {
+            suppressions[filename] = {};
+            for (const [rule, count] of rules.entries()) {
+                suppressions[filename][rule] = { count };
+            }
+        }
+        return suppressions;
+    }
+    findExcessErrors(diagnostics, suppressions) {
+        const excessErrors = [];
+        // Group diagnostics by file and rule
+        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);
+            if (!fileRules.has(diagnostic.rule)) {
+                fileRules.set(diagnostic.rule, []);
+            }
+            fileRules.get(diagnostic.rule).push(diagnostic);
+        }
+        // Compare actual vs suppressed counts
+        for (const [filename, rules] of actualCounts.entries()) {
+            for (const [rule, diagnosticsForRule] of rules.entries()) {
+                const actual = diagnosticsForRule.length;
+                const expected = suppressions[filename]?.[rule]?.count || 0;
+                if (actual > expected) {
+                    excessErrors.push({
+                        rule,
+                        filename,
+                        expected,
+                        actual,
+                        diagnostics: diagnosticsForRule
+                    });
+                }
+            }
+        }
+        return excessErrors;
+    }
+    updateSuppressions(currentSuppressions, diagnostics) {
+        const newSuppressions = this.generateSuppressions(diagnostics);
+        // Merge with existing suppressions, using new counts
+        const updated = { ...currentSuppressions };
+        for (const [filename, rules] of Object.entries(newSuppressions)) {
+            updated[filename] = { ...updated[filename], ...rules };
+        }
+        // Remove files with no rules
+        for (const [filename, rules] of Object.entries(updated)) {
+            if (Object.keys(rules).length === 0) {
+                delete updated[filename];
+            }
+        }
+        return updated;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+export interface OxlintDiagnostic {
+    severity: 'error' | 'warning';
+    message: string;
+    labels: Array<{
+        span: {
+            start: number;
+            end: number;
+        };
+        message: string;
+    }>;
+    rule_id?: string;
+    help?: string;
+    url?: string;
+}
+export interface OxlintOutput {
+    [filename: string]: OxlintDiagnostic[];
+}
+export interface SuppressionRule {
+    count: number;
+}
+export interface SuppressionFile {
+    [filename: string]: {
+        [ruleName: string]: SuppressionRule;
+    };
+}
+export interface ProcessedDiagnostic {
+    filename: string;
+    rule: string;
+    severity: 'error' | 'warning';
+    message: string;
+    line?: number;
+    column?: number;
+    help?: string;
+    url?: string;
+}
+export interface ExcessError {
+    rule: string;
+    filename: string;
+    expected: number;
+    actual: number;
+    diagnostics: ProcessedDiagnostic[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "oxlint-harness",
+  "version": "1.0.0",
+  "description": "A harness for oxlint with bulk suppressions support",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "oxlint-harness": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsgo",
+    "prepublishOnly": "npm run build",
+    "dev": "node src/cli.ts",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "lint": "oxlint src/",
+    "typecheck": "tsgo"
+  },
+  "keywords": ["oxlint", "linting", "suppressions", "eslint", "bulk-suppressions", "cli"],
+  "author": "Generated with Claude Code",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MIreland/oxlint-harness.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MIreland/oxlint-harness/issues"
+  },
+  "homepage": "https://github.com/MIreland/oxlint-harness#readme",
+  "dependencies": {
+    "@oclif/core": "^4.0.0",
+    "@oclif/plugin-help": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@typescript/native-preview": "7.0.0-dev.20251222.1",
+    "vitest": "4.0.16"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}