@webpieces/ai-hook-rules 0.0.1

package/src/core/__tests__/rules/no-shell-substitution.test.ts

@@ -0,0 +1,118 @@
+/* eslint-disable @webpieces/max-method-lines -- test describe blocks are inherently large */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { runBash } from '../../runner';
+
+function makeWorkspace(): string {
+    const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-hooks-bash-test-'));
+    fs.writeFileSync(
+        path.join(ws, 'webpieces.ai-hooks.json'),
+        JSON.stringify({
+            rules: {
+                'no-any-unknown': { enabled: false },
+                'max-file-lines': { enabled: false },
+                'file-location': { enabled: false },
+                'no-destructure': { enabled: false },
+                'require-return-type': { enabled: false },
+                'no-unmanaged-exceptions': { enabled: false },
+                'catch-error-pattern': { enabled: false },
+                'no-shell-substitution': { enabled: true },
+            },
+            rulesDir: [],
+        }),
+    );
+    return ws;
+}
+
+describe('no-shell-substitution', () => {
+    it('blocks $(...) command substitution', () => {
+        const ws = makeWorkspace();
+        const result = runBash('echo $(date)', ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('no-shell-substitution');
+        expect(result!.report).toContain('$(...)');
+    });
+
+    it('blocks backtick substitution', () => {
+        const ws = makeWorkspace();
+        const result = runBash('echo `date`', ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('backtick');
+    });
+
+    it('blocks $VAR expansion', () => {
+        const ws = makeWorkspace();
+        const result = runBash('echo $HOME', ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('variable expansion');
+    });
+
+    it('blocks ${VAR} expansion', () => {
+        const ws = makeWorkspace();
+        const result = runBash('echo ${PATH}', ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('variable expansion');
+    });
+
+    it('allows plain commands', () => {
+        const ws = makeWorkspace();
+        expect(runBash('git status', ws)).toBeNull();
+        expect(runBash('ls -la', ws)).toBeNull();
+        expect(runBash('pnpm nx build config', ws)).toBeNull();
+    });
+
+    it('allows single-quoted literals containing $ and backticks', () => {
+        const ws = makeWorkspace();
+        expect(runBash("grep '$pattern' file.txt", ws)).toBeNull();
+        expect(runBash("echo 'literal `backtick` here'", ws)).toBeNull();
+    });
+
+    it('allows escaped $ in double-quoted strings', () => {
+        const ws = makeWorkspace();
+        expect(runBash('echo "price is \\$5"', ws)).toBeNull();
+    });
+
+    it('allows empty-looking commands with $ in non-variable position', () => {
+        const ws = makeWorkspace();
+        expect(runBash('echo hello', ws)).toBeNull();
+    });
+
+    it('returns null when rule is disabled', () => {
+        const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-hooks-bash-disabled-'));
+        fs.writeFileSync(
+            path.join(ws, 'webpieces.ai-hooks.json'),
+            JSON.stringify({
+                rules: {
+                    'no-any-unknown': { enabled: false },
+                    'max-file-lines': { enabled: false },
+                    'file-location': { enabled: false },
+                    'no-destructure': { enabled: false },
+                    'require-return-type': { enabled: false },
+                    'no-unmanaged-exceptions': { enabled: false },
+                    'catch-error-pattern': { enabled: false },
+                    'no-shell-substitution': { enabled: false },
+                },
+                rulesDir: [],
+            }),
+        );
+        const result = runBash('echo $(date)', ws);
+        expect(result).toBeNull();
+    });
+
+    it('returns null when no config in tree', () => {
+        const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-hooks-bash-noconfig-'));
+        const result = runBash('echo $(date)', ws);
+        expect(result).toBeNull();
+    });
+
+    it('reports multiple violation categories for combined command', () => {
+        const ws = makeWorkspace();
+        const result = runBash('echo $(date) "$HOME" `whoami`', ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('$(...)');
+        expect(result!.report).toContain('backtick');
+        expect(result!.report).toContain('variable expansion');
+    });
+});

package/src/core/__tests__/rules/no-unmanaged-exceptions.test.ts

@@ -0,0 +1,54 @@
+import { run } from '../../runner';
+import { NormalizedToolInput, NormalizedEdit } from '../../types';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+function ws(): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'no-exc-'));
+    fs.writeFileSync(path.join(dir, 'webpieces.ai-hooks.json'), JSON.stringify({
+        rules: { 'no-any-unknown': { enabled: false }, 'max-file-lines': { enabled: false },
+            'file-location': { enabled: false }, 'no-destructure': { enabled: false },
+            'require-return-type': { enabled: false }, 'catch-error-pattern': { enabled: false } },
+        rulesDir: [],
+    }));
+    return dir;
+}
+
+describe('no-unmanaged-exceptions rule', () => {
+    it('blocks try/catch without disable comment', () => {
+        const w = ws();
+        const content = 'try {\n    doSomething();\n} catch (e) {\n    console.error(e);\n}';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).not.toBeNull();
+        expect(r!.report).toContain('no-unmanaged-exceptions');
+    });
+
+    it('allows try with eslint-disable-next-line', () => {
+        const w = ws();
+        const content = '// eslint-disable-next-line @webpieces/no-unmanaged-exceptions\ntry {\n    doSomething();\n} catch (e) {}';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).toBeNull();
+    });
+
+    it('allows try with ai-hook-disable', () => {
+        const w = ws();
+        const content = '// ai-hook-disable no-unmanaged-exceptions -- tested externally\ntry {\n    doSomething();\n} catch (e) {}';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).toBeNull();
+    });
+
+    it('does not fire on the word try in a string', () => {
+        const w = ws();
+        const content = 'const msg = "try again later";';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).toBeNull();
+    });
+
+    it('does not fire on the word try in a comment', () => {
+        const w = ws();
+        const content = '// try this approach instead\nconst x = 1;';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).toBeNull();
+    });
+});

package/src/core/__tests__/rules/require-return-type.test.ts

@@ -0,0 +1,79 @@
+import { run } from '../../runner';
+import { NormalizedToolInput, NormalizedEdit } from '../../types';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+function ws(): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ret-type-'));
+    fs.writeFileSync(path.join(dir, 'webpieces.ai-hooks.json'), JSON.stringify({
+        rules: { 'no-any-unknown': { enabled: false }, 'max-file-lines': { enabled: false },
+            'file-location': { enabled: false }, 'no-destructure': { enabled: false },
+            'no-unmanaged-exceptions': { enabled: false } },
+        rulesDir: [],
+    }));
+    return dir;
+}
+
+describe('require-return-type rule', () => {
+    it('blocks function without return type', () => {
+        const w = ws();
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [
+            new NormalizedEdit('', 'function foo(x: number) {\n  return x;\n}'),
+        ]), w);
+        expect(r).not.toBeNull();
+        expect(r!.report).toContain('require-return-type');
+    });
+
+    it('allows function with return type', () => {
+        const w = ws();
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [
+            new NormalizedEdit('', 'function foo(x: number): number {\n  return x;\n}'),
+        ]), w);
+        expect(r).toBeNull();
+    });
+
+    it('blocks async method without return type', () => {
+        const w = ws();
+        const content = '    async fetchData(id: string) {\n        return null;\n    }';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).not.toBeNull();
+    });
+
+    it('allows async method with return type', () => {
+        const w = ws();
+        const content = '    async fetchData(id: string): Promise<string> {\n        return "";\n    }';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).toBeNull();
+    });
+
+    it('skips constructors', () => {
+        const w = ws();
+        const content = '    constructor(private x: number) {\n        this.x = x;\n    }';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).toBeNull();
+    });
+
+    it('blocks arrow function without return type', () => {
+        const w = ws();
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [
+            new NormalizedEdit('', 'const fn = (x: number) => x + 1;'),
+        ]), w);
+        expect(r).not.toBeNull();
+    });
+
+    it('allows arrow function with return type', () => {
+        const w = ws();
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [
+            new NormalizedEdit('', 'const fn = (x: number): number => x + 1;'),
+        ]), w);
+        expect(r).toBeNull();
+    });
+
+    it('respects ai-hook-disable', () => {
+        const w = ws();
+        const content = '// ai-hook-disable require-return-type -- generated\nfunction foo(x: number) {\n  return x;\n}';
+        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
+        expect(r).toBeNull();
+    });
+});

package/src/core/__tests__/runner.test.ts

@@ -0,0 +1,288 @@
+/* eslint-disable @webpieces/max-method-lines -- test describe blocks are inherently large */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import { run } from '../runner';
+import { NormalizedToolInput, NormalizedEdit } from '../types';
+
+function makeWorkspace(): string {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'ai-hooks-runner-test-'));
+}
+
+function writeFile(p: string, content: string): void {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, content);
+}
+
+describe('core runner', () => {
+    it('returns null when no config in tree', () => {
+        const ws = makeWorkspace();
+        const input = new NormalizedToolInput(
+            path.join(ws, 'foo.ts'),
+            [new NormalizedEdit('', 'const x: number = 1;')],
+        );
+        const result = run('Write', input, ws);
+        expect(result).toBeNull();
+    });
+
+    it('returns null when all rules disabled', () => {
+        const ws = makeWorkspace();
+        writeFile(
+            path.join(ws, 'webpieces.ai-hooks.json'),
+            JSON.stringify({
+                rules: {
+                    'no-any-unknown': { enabled: false },
+                    'max-file-lines': { enabled: false },
+                    'file-location': { enabled: false },
+                    'no-destructure': { enabled: false },
+                    'require-return-type': { enabled: false },
+                    'no-unmanaged-exceptions': { enabled: false },
+                },
+                rulesDir: [],
+            }),
+        );
+        const input = new NormalizedToolInput(
+            path.join(ws, 'foo.ts'),
+            [new NormalizedEdit('', 'const x: number = 1;')],
+        );
+        const result = run('Write', input, ws);
+        expect(result).toBeNull();
+    });
+
+    it('blocks custom edit-scope rule on proposed content', () => {
+        const ws = makeWorkspace();
+        const rulesDir = path.join(ws, 'ai-hooks-rules');
+        writeFile(
+            path.join(rulesDir, 'ban-foo.js'),
+            `module.exports = {
+                name: 'ban-foo',
+                description: 'Ban foo',
+                scope: 'edit',
+                files: ['**/*.ts'],
+                defaultOptions: {},
+                fixHint: ['use bar instead'],
+                check(ctx) {
+                    const violations = [];
+                    ctx.strippedLines.forEach((line, i) => {
+                        if (/\\bfoo\\b/.test(line)) {
+                            violations.push({ line: i + 1, snippet: ctx.lines[i].trim(), message: 'foo is banned' });
+                        }
+                    });
+                    return violations;
+                },
+            };`,
+        );
+        writeFile(
+            path.join(ws, 'webpieces.ai-hooks.json'),
+            JSON.stringify({
+                rules: {
+                    'no-any-unknown': { enabled: false },
+                    'max-file-lines': { enabled: false },
+                    'file-location': { enabled: false },
+                    'no-destructure': { enabled: false },
+                    'require-return-type': { enabled: false },
+                    'no-unmanaged-exceptions': { enabled: false },
+                    'ban-foo': { enabled: true },
+                },
+                rulesDir: ['ai-hooks-rules'],
+            }),
+        );
+        const input = new NormalizedToolInput(
+            path.join(ws, 'evil.ts'),
+            [new NormalizedEdit('', 'const x = foo;\nconst y = bar;')],
+        );
+        const result = run('Write', input, ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('ban-foo');
+        expect(result!.report).toContain('L1');
+        expect(result!.report).toContain('foo is banned');
+        expect(result!.report).not.toContain('L2');
+    });
+
+    it('disable directive suppresses violation', () => {
+        const ws = makeWorkspace();
+        const rulesDir = path.join(ws, 'ai-hooks-rules');
+        writeFile(
+            path.join(rulesDir, 'ban-foo.js'),
+            `module.exports = {
+                name: 'ban-foo',
+                description: 'Ban foo',
+                scope: 'edit',
+                files: ['**/*.ts'],
+                defaultOptions: {},
+                fixHint: [],
+                check(ctx) {
+                    const violations = [];
+                    ctx.strippedLines.forEach((line, i) => {
+                        if (/\\bfoo\\b/.test(line) && !ctx.isLineDisabled(i + 1, 'ban-foo')) {
+                            violations.push({ line: i + 1, snippet: ctx.lines[i].trim(), message: 'no foo' });
+                        }
+                    });
+                    return violations;
+                },
+            };`,
+        );
+        writeFile(
+            path.join(ws, 'webpieces.ai-hooks.json'),
+            JSON.stringify({
+                rules: {
+                    'no-any-unknown': { enabled: false },
+                    'max-file-lines': { enabled: false },
+                    'file-location': { enabled: false },
+                    'no-destructure': { enabled: false },
+                    'require-return-type': { enabled: false },
+                    'no-unmanaged-exceptions': { enabled: false },
+                    'ban-foo': { enabled: true },
+                },
+                rulesDir: ['ai-hooks-rules'],
+            }),
+        );
+        const input = new NormalizedToolInput(
+            path.join(ws, 'allowed.ts'),
+            [new NormalizedEdit('', 'const x = foo; // ai-hook-disable ban-foo -- legacy')],
+        );
+        const result = run('Write', input, ws);
+        expect(result).toBeNull();
+    });
+
+    it('file-scope rule sees projectedFileLines', () => {
+        const ws = makeWorkspace();
+        const rulesDir = path.join(ws, 'ai-hooks-rules');
+        writeFile(
+            path.join(rulesDir, 'max-five.js'),
+            `module.exports = {
+                name: 'max-five',
+                description: 'File must be <= 5 lines',
+                scope: 'file',
+                files: ['**/*.ts'],
+                defaultOptions: { limit: 5 },
+                fixHint: [],
+                check(ctx) {
+                    if (ctx.projectedFileLines > ctx.options.limit) {
+                        return [{ line: 1, snippet: '(file too long)', message: 'Projected ' + ctx.projectedFileLines + ' lines exceeds limit ' + ctx.options.limit }];
+                    }
+                    return [];
+                },
+            };`,
+        );
+        writeFile(
+            path.join(ws, 'webpieces.ai-hooks.json'),
+            JSON.stringify({
+                rules: {
+                    'no-any-unknown': { enabled: false },
+                    'max-file-lines': { enabled: false },
+                    'file-location': { enabled: false },
+                    'no-destructure': { enabled: false },
+                    'require-return-type': { enabled: false },
+                    'no-unmanaged-exceptions': { enabled: false },
+                    'max-five': { enabled: true },
+                },
+                rulesDir: ['ai-hooks-rules'],
+            }),
+        );
+        const longContent = Array(10).fill('const x = 1;').join('\n');
+        const input = new NormalizedToolInput(
+            path.join(ws, 'big.ts'),
+            [new NormalizedEdit('', longContent)],
+        );
+        const result = run('Write', input, ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('max-five');
+        expect(result!.report).toContain('Projected 10 lines');
+    });
+
+    it('Edit tool uses new_string as added content', () => {
+        const ws = makeWorkspace();
+        const target = path.join(ws, 'existing.ts');
+        writeFile(target, 'const a = 1;\nconst b = 2;\n');
+        const rulesDir = path.join(ws, 'ai-hooks-rules');
+        writeFile(
+            path.join(rulesDir, 'ban-foo.js'),
+            `module.exports = {
+                name: 'ban-foo',
+                description: 'Ban foo',
+                scope: 'edit',
+                files: ['**/*.ts'],
+                defaultOptions: {},
+                fixHint: [],
+                check(ctx) {
+                    const vs = [];
+                    ctx.strippedLines.forEach((l, i) => {
+                        if (/foo/.test(l)) vs.push({ line: i+1, snippet: ctx.lines[i].trim(), message: 'no foo' });
+                    });
+                    return vs;
+                },
+            };`,
+        );
+        writeFile(
+            path.join(ws, 'webpieces.ai-hooks.json'),
+            JSON.stringify({
+                rules: {
+                    'no-any-unknown': { enabled: false },
+                    'max-file-lines': { enabled: false },
+                    'file-location': { enabled: false },
+                    'no-destructure': { enabled: false },
+                    'require-return-type': { enabled: false },
+                    'no-unmanaged-exceptions': { enabled: false },
+                    'ban-foo': { enabled: true },
+                },
+                rulesDir: ['ai-hooks-rules'],
+            }),
+        );
+        const input = new NormalizedToolInput(target, [
+            new NormalizedEdit('const a = 1;', 'const a = foo;'),
+        ]);
+        const result = run('Edit', input, ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('ban-foo');
+    });
+
+    it('MultiEdit reports which edit triggered', () => {
+        const ws = makeWorkspace();
+        const target = path.join(ws, 'multi.ts');
+        writeFile(target, 'const a = 1;\nconst b = 2;\nconst c = 3;\n');
+        const rulesDir = path.join(ws, 'ai-hooks-rules');
+        writeFile(
+            path.join(rulesDir, 'ban-foo.js'),
+            `module.exports = {
+                name: 'ban-foo',
+                description: 'Ban foo',
+                scope: 'edit',
+                files: ['**/*.ts'],
+                defaultOptions: {},
+                fixHint: [],
+                check(ctx) {
+                    const vs = [];
+                    ctx.strippedLines.forEach((l, i) => {
+                        if (/foo/.test(l)) vs.push({ line: i+1, snippet: ctx.lines[i].trim(), message: 'no foo' });
+                    });
+                    return vs;
+                },
+            };`,
+        );
+        writeFile(
+            path.join(ws, 'webpieces.ai-hooks.json'),
+            JSON.stringify({
+                rules: {
+                    'no-any-unknown': { enabled: false },
+                    'max-file-lines': { enabled: false },
+                    'file-location': { enabled: false },
+                    'no-destructure': { enabled: false },
+                    'require-return-type': { enabled: false },
+                    'no-unmanaged-exceptions': { enabled: false },
+                    'ban-foo': { enabled: true },
+                },
+                rulesDir: ['ai-hooks-rules'],
+            }),
+        );
+        const input = new NormalizedToolInput(target, [
+            new NormalizedEdit('const a = 1;', 'const a = 11;'),
+            new NormalizedEdit('const b = 2;', 'const b = foo;'),
+            new NormalizedEdit('const c = 3;', 'const c = 33;'),
+        ]);
+        const result = run('MultiEdit', input, ws);
+        expect(result).not.toBeNull();
+        expect(result!.report).toContain('edit 2/3');
+    });
+});

package/src/core/__tests__/strip-ts-noise.test.ts

@@ -0,0 +1,109 @@
+/* eslint-disable @webpieces/max-method-lines -- test describe blocks are inherently large */
+import { stripTsNoise } from '../strip-ts-noise';
+
+describe('stripTsNoise', () => {
+    it('passes code through unchanged', () => {
+        const src = 'const x: number = 1;\nconst y = x + 2;\n';
+        expect(stripTsNoise(src)).toBe(src);
+    });
+
+    it('preserves line count for all inputs', () => {
+        const cases = [
+            'a\nb\nc',
+            '// comment\nconst x = 1;',
+            '/* multi\n   line\n   comment */\nconst x = 1;',
+            '"string with\\nescaped newline"',
+            '`template\nwith\nnewlines`',
+            '"multi\nline"\nconst y = 2;',
+        ];
+        for (const src of cases) {
+            const out = stripTsNoise(src);
+            expect(out.split('\n').length).toBe(src.split('\n').length);
+            expect(out.length).toBe(src.length);
+        }
+    });
+
+    it('replaces double-quoted string interior with spaces', () => {
+        const src = 'const x = "has any keyword";';
+        const out = stripTsNoise(src);
+        expect(out).not.toContain('any');
+    });
+
+    it('replaces single-quoted string interior', () => {
+        const src = "const x = 'any';";
+        const out = stripTsNoise(src);
+        expect(out).not.toContain('any');
+    });
+
+    it('handles escaped quotes inside strings', () => {
+        const src = 'const x = "has \\"any\\" keyword";';
+        const out = stripTsNoise(src);
+        expect(out).not.toContain('any');
+    });
+
+    it('replaces line comment body with spaces', () => {
+        const src = '// this has any in it\nconst x = 1;';
+        const out = stripTsNoise(src);
+        expect(out.split('\n')[0]).not.toContain('any');
+    });
+
+    it('replaces block comment body, preserves newlines', () => {
+        const src = '/* line1 any\n   line2 any */\nconst x = 1;';
+        const out = stripTsNoise(src);
+        expect(out).not.toContain('any');
+        expect(out.split('\n').length).toBe(3);
+    });
+
+    it('strips template literal body but keeps ${} interp as code', () => {
+        const src = 'const x = `prefix ${value + 1} suffix any`;';
+        const out = stripTsNoise(src);
+        expect(out).not.toMatch(/prefix/);
+        expect(out).not.toMatch(/ any`/);
+        expect(out).toMatch(/\$\{value \+ 1\}/);
+    });
+
+    it('handles nested template inside interpolation', () => {
+        const src = 'const x = `outer ${`inner ${y} end`} done`;';
+        const out = stripTsNoise(src);
+        expect(out).toMatch(/\$\{y\}/);
+        expect(out).not.toMatch(/outer/);
+        expect(out).not.toMatch(/inner/);
+        expect(out).not.toMatch(/end/);
+        expect(out).not.toMatch(/done/);
+    });
+
+    it('strips string inside template interpolation', () => {
+        const src = 'const x = `prefix ${"some any string"} suffix`;';
+        const out = stripTsNoise(src);
+        expect(out).not.toContain('some any string');
+    });
+
+    it('keeps any keyword in real code visible', () => {
+        const src = 'const x: any = 1;\nconst y: number = 2;';
+        const out = stripTsNoise(src);
+        expect(out).toContain(': any');
+        expect(out).toContain(': number');
+    });
+
+    it('hides any keyword inside comment', () => {
+        const src = 'const x: number = 1; // this returns any maybe';
+        const out = stripTsNoise(src);
+        expect(out).toContain(': number');
+        expect(out.indexOf('any')).toBe(-1);
+    });
+
+    it('does not treat division as a comment', () => {
+        const src = 'const x = a / b;\nconst y = c / d;';
+        expect(stripTsNoise(src)).toBe(src);
+    });
+
+    it('handles empty input', () => {
+        expect(stripTsNoise('')).toBe('');
+    });
+
+    it('does not bleed comment into next line', () => {
+        const src = '// disable rule\nconst x: any = 1;';
+        const out = stripTsNoise(src);
+        expect(out).toContain(': any');
+    });
+});