@webpieces/ai-hook-rules 0.0.1 → 0.2.114

package/src/adapters/openclaw-plugin.ts

@@ -1,88 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-
-import { run } from '../core/runner';
-import { NormalizedToolInput, NormalizedEdit, ToolKind } from '../core/types';
-import { toError } from '../core/to-error';
-
-interface ToolCallEvent {
-    toolName: string;
-    // webpieces-disable no-any-unknown -- openclaw SDK passes opaque tool arguments
-    arguments: Record<string, unknown>;
-}
-
-interface HookContext {
-    // webpieces-disable no-any-unknown -- openclaw SDK context shape is opaque
-    [key: string]: unknown;
-}
-
-class OpenclawHandlerResult {
-    readonly status: 'approved' | 'rejected';
-    readonly reason: string | undefined;
-
-    constructor(status: 'approved' | 'rejected', reason?: string) {
-        this.status = status;
-        this.reason = reason;
-    }
-}
-
-const TOOL_MAP: Record<string, ToolKind> = {
-    'write': 'Write',
-    'edit': 'Edit',
-};
-
-function mapToolName(openclawName: string): ToolKind | null {
-    return TOOL_MAP[openclawName] || null;
-}
-
-// webpieces-disable no-any-unknown -- openclaw SDK passes opaque tool arguments
-function mapToolInput(toolName: string, args: Record<string, unknown>): NormalizedToolInput | null {
-    const filePath = typeof args['path'] === 'string' ? args['path'] as string : null;
-    if (!filePath) return null;
-
-    if (toolName === 'write') {
-        const content = typeof args['content'] === 'string' ? args['content'] as string : '';
-        return new NormalizedToolInput(filePath, [new NormalizedEdit('', content)]);
-    }
-    if (toolName === 'edit') {
-        const oldStr = typeof args['old_string'] === 'string' ? args['old_string'] as string : '';
-        const newStr = typeof args['new_string'] === 'string' ? args['new_string'] as string : '';
-        return new NormalizedToolInput(filePath, [new NormalizedEdit(oldStr, newStr)]);
-    }
-    return null;
-}
-
-function findWorkspaceRoot(filePath: string): string | null {
-    let dir = path.dirname(filePath);
-    while (true) {
-        if (fs.existsSync(path.join(dir, 'webpieces.ai-hooks.json'))) return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir) return null;
-        dir = parent;
-    }
-}
-
-export default async function handler(
-    event: ToolCallEvent,
-    _context: HookContext,
-): Promise<OpenclawHandlerResult | undefined> {
-    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
-    try {
-        const toolKind = mapToolName(event.toolName);
-        if (!toolKind) return undefined;
-
-        const input = mapToolInput(event.toolName, event.arguments);
-        if (!input) return undefined;
-
-        const wsRoot = findWorkspaceRoot(input.filePath);
-        if (!wsRoot) return undefined;
-
-        const result = run(toolKind, input, wsRoot);
-        if (!result) return new OpenclawHandlerResult('approved');
-        return new OpenclawHandlerResult('rejected', result.report);
-    } catch (err: unknown) {
-        const error = toError(err);
-        console.error(`[ai-hooks] openclaw adapter crashed (failing open): ${error.message}`);
-        return undefined;
-    }
-}

package/src/core/__tests__/disable-directives.test.ts

@@ -1,114 +0,0 @@
-/* eslint-disable @webpieces/max-method-lines -- test describe blocks are inherently large */
-import { parseDirectives } from '../disable-directives';
-
-describe('parseDirectives', () => {
-    it('inline disable on same line as code', () => {
-        const d = parseDirectives('const x: any = 1; // ai-hook-disable no-any-unknown -- legacy');
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(1, 'no-destructure')).toBe(false);
-    });
-
-    it('line-above disable affects next non-blank line', () => {
-        const d = parseDirectives('// ai-hook-disable no-any-unknown -- reason\nconst x: any = 1;');
-        expect(d.isLineDisabled(2, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(false);
-    });
-
-    it('skips blank lines before target', () => {
-        const d = parseDirectives('// ai-hook-disable no-any-unknown -- reason\n\n\nconst x: any = 1;');
-        expect(d.isLineDisabled(4, 'no-any-unknown')).toBe(true);
-    });
-
-    it('handles comma-separated rules', () => {
-        const d = parseDirectives('const { a } = obj; // ai-hook-disable no-destructure, no-any-unknown -- reason');
-        expect(d.isLineDisabled(1, 'no-destructure')).toBe(true);
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(1, 'other-rule')).toBe(false);
-    });
-
-    it('ai-hook-disable-next explicit form', () => {
-        const d = parseDirectives('// ai-hook-disable-next no-any-unknown -- reason\nconst x: any = 1;');
-        expect(d.isLineDisabled(2, 'no-any-unknown')).toBe(true);
-    });
-
-    it('ai-hook-disable-file within first 20 lines', () => {
-        const src = '// ai-hook-disable-file no-any-unknown -- wraps API\nconst a = 1;\nconst b: any = 2;\nconst c: any = 3;';
-        const d = parseDirectives(src);
-        expect(d.isLineDisabled(3, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(4, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(3, 'no-destructure')).toBe(false);
-    });
-
-    it('ai-hook-disable-file beyond line 20 is ignored', () => {
-        const filler = Array(25).fill('const a = 1;').join('\n');
-        const src = filler + '\n// ai-hook-disable-file no-any-unknown -- too late\nconst x: any = 1;';
-        const d = parseDirectives(src);
-        expect(d.isLineDisabled(27, 'no-any-unknown')).toBe(false);
-    });
-
-    it('ai-hook-disable-all on its own line', () => {
-        const d = parseDirectives('// ai-hook-disable-all -- hack\nconst x: any = 1;');
-        expect(d.isLineDisabled(2, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(2, 'require-return-type')).toBe(true);
-    });
-
-    it('ai-hook-disable-all inline', () => {
-        const d = parseDirectives('const x: any = 1; // ai-hook-disable-all -- hack');
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(1, 'anything-else')).toBe(true);
-    });
-
-    it('no directives present', () => {
-        const d = parseDirectives('const x: any = 1;');
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(false);
-    });
-
-    it('star rule name matches anything', () => {
-        const d = parseDirectives('const x: any = 1; // ai-hook-disable * -- nuclear');
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(1, 'require-return-type')).toBe(true);
-    });
-
-    it('directive without reason still parses', () => {
-        const d = parseDirectives('const x: any = 1; // ai-hook-disable no-any-unknown');
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(true);
-    });
-
-    it('chained disable comments skip each other', () => {
-        const src = '// ai-hook-disable no-any-unknown -- r1\n// ai-hook-disable no-destructure -- r2\nconst { a }: any = obj;';
-        const d = parseDirectives(src);
-        expect(d.isLineDisabled(3, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(3, 'no-destructure')).toBe(true);
-    });
-
-    it('webpieces-disable inline works same as ai-hook-disable', () => {
-        const d = parseDirectives('const x: any = 1; // webpieces-disable no-any-unknown -- legacy');
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(1, 'no-destructure')).toBe(false);
-    });
-
-    it('webpieces-disable on line above', () => {
-        const d = parseDirectives('// webpieces-disable no-any-unknown -- reason\nconst x: any = 1;');
-        expect(d.isLineDisabled(2, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(1, 'no-any-unknown')).toBe(false);
-    });
-
-    it('webpieces-disable-file within first 20 lines', () => {
-        const src = '// webpieces-disable-file no-any-unknown -- wraps API\nconst a = 1;\nconst b: any = 2;';
-        const d = parseDirectives(src);
-        expect(d.isLineDisabled(3, 'no-any-unknown')).toBe(true);
-    });
-
-    it('webpieces-disable-all suppresses all rules', () => {
-        const d = parseDirectives('// webpieces-disable-all -- hack\nconst x: any = 1;');
-        expect(d.isLineDisabled(2, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(2, 'require-return-type')).toBe(true);
-    });
-
-    it('webpieces-disable chained with ai-hook-disable', () => {
-        const src = '// webpieces-disable no-any-unknown -- r1\n// ai-hook-disable no-destructure -- r2\nconst { a }: any = obj;';
-        const d = parseDirectives(src);
-        expect(d.isLineDisabled(3, 'no-any-unknown')).toBe(true);
-        expect(d.isLineDisabled(3, 'no-destructure')).toBe(true);
-    });
-});

package/src/core/__tests__/rules/file-location.test.ts

@@ -1,90 +0,0 @@
-/* eslint-disable @webpieces/max-method-lines -- test describe blocks are inherently large */
-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(), 'file-loc-'));
-    fs.writeFileSync(path.join(dir, 'webpieces.ai-hooks.json'), JSON.stringify({
-        rules: { 'no-any-unknown': { enabled: false }, 'max-file-lines': { enabled: false },
-            'no-destructure': { enabled: false }, 'require-return-type': { enabled: false },
-            'no-unmanaged-exceptions': { enabled: false },
-            'file-location': { enabled: true, allowedRootFiles: ['jest.setup.ts'], excludePaths: ['scripts', 'tmp'] } },
-        rulesDir: [],
-    }));
-    return dir;
-}
-
-describe('file-location rule', () => {
-    it('blocks Write to root (orphan)', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'orphan.ts'), [new NormalizedEdit('', 'const x = 1;')]), w);
-        expect(r).not.toBeNull();
-        expect(r!.report).toContain('file-location');
-        expect(r!.report).toContain('not inside any Nx project');
-    });
-
-    it('allows Write to allowedRootFiles', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'jest.setup.ts'), [new NormalizedEdit('', 'const x = 1;')]), w);
-        expect(r).toBeNull();
-    });
-
-    it('allows Write under src/ of a project', () => {
-        const w = ws();
-        const projectDir = path.join(w, 'packages', 'mylib');
-        fs.mkdirSync(path.join(projectDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(projectDir, 'project.json'), '{}');
-        const r = run('Write', new NormalizedToolInput(
-            path.join(projectDir, 'src', 'foo.ts'),
-            [new NormalizedEdit('', 'const x = 1;')],
-        ), w);
-        expect(r).toBeNull();
-    });
-
-    it('blocks Write outside src/ of a project', () => {
-        const w = ws();
-        const projectDir = path.join(w, 'packages', 'mylib');
-        fs.mkdirSync(path.join(projectDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(projectDir, 'project.json'), '{}');
-        const r = run('Write', new NormalizedToolInput(
-            path.join(projectDir, 'stray.ts'),
-            [new NormalizedEdit('', 'const x = 1;')],
-        ), w);
-        expect(r).not.toBeNull();
-        expect(r!.report).toContain('outside its src/ directory');
-    });
-
-    it('allows jest.config.ts at project root', () => {
-        const w = ws();
-        const projectDir = path.join(w, 'packages', 'mylib');
-        fs.mkdirSync(path.join(projectDir, 'src'), { recursive: true });
-        fs.writeFileSync(path.join(projectDir, 'project.json'), '{}');
-        const r = run('Write', new NormalizedToolInput(
-            path.join(projectDir, 'jest.config.ts'),
-            [new NormalizedEdit('', 'export default {};')],
-        ), w);
-        expect(r).toBeNull();
-    });
-
-    it('skips excluded top-level dirs', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(
-            path.join(w, 'scripts', 'tool.ts'),
-            [new NormalizedEdit('', 'const x = 1;')],
-        ), w);
-        expect(r).toBeNull();
-    });
-
-    it('does not fire on Edit (file already exists)', () => {
-        const w = ws();
-        const target = path.join(w, 'orphan.ts');
-        fs.writeFileSync(target, 'const old = 1;');
-        const r = run('Edit', new NormalizedToolInput(target, [
-            new NormalizedEdit('const old = 1;', 'const updated = 2;'),
-        ]), w);
-        expect(r).toBeNull();
-    });
-});

package/src/core/__tests__/rules/max-file-lines.test.ts

@@ -1,53 +0,0 @@
-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(limit: number = 10): string {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'max-file-'));
-    fs.writeFileSync(path.join(dir, 'webpieces.ai-hooks.json'), JSON.stringify({
-        rules: { 'no-any-unknown': { enabled: false }, 'file-location': { enabled: false },
-            'no-destructure': { enabled: false }, 'require-return-type': { enabled: false },
-            'no-unmanaged-exceptions': { enabled: false },
-            'max-file-lines': { enabled: true, limit } },
-        rulesDir: [],
-    }));
-    return dir;
-}
-
-describe('max-file-lines rule', () => {
-    it('blocks a file that exceeds the limit', () => {
-        const w = ws(5);
-        const content = Array(10).fill('const x = 1;').join('\n');
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'big.ts'), [new NormalizedEdit('', content)]), w);
-        expect(r).not.toBeNull();
-        expect(r!.report).toContain('max-file-lines');
-        expect(r!.report).toContain('10 lines');
-    });
-
-    it('allows a file within the limit', () => {
-        const w = ws(20);
-        const content = Array(5).fill('const x = 1;').join('\n');
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'small.ts'), [new NormalizedEdit('', content)]), w);
-        expect(r).toBeNull();
-    });
-
-    it('computes projected lines for Edit (current + added - removed)', () => {
-        const w = ws(5);
-        const target = path.join(w, 'existing.ts');
-        fs.writeFileSync(target, Array(4).fill('const x = 1;').join('\n'));
-        const r = run('Edit', new NormalizedToolInput(target, [
-            new NormalizedEdit('const x = 1;', 'const a = 1;\nconst b = 2;\nconst c = 3;'),
-        ]), w);
-        expect(r).not.toBeNull();
-        expect(r!.report).toContain('6 lines');
-    });
-
-    it('ignores non-ts files', () => {
-        const w = ws(3);
-        const content = Array(10).fill('line').join('\n');
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'big.md'), [new NormalizedEdit('', content)]), w);
-        expect(r).toBeNull();
-    });
-});

package/src/core/__tests__/rules/no-any.test.ts

@@ -1,68 +0,0 @@
-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-any-'));
-    fs.writeFileSync(path.join(dir, 'webpieces.ai-hooks.json'), JSON.stringify({
-        rules: { 'max-file-lines': { enabled: false }, 'file-location': { enabled: false },
-            'no-destructure': { enabled: false }, 'require-return-type': { enabled: false },
-            'no-unmanaged-exceptions': { enabled: false } },
-        rulesDir: [],
-    }));
-    return dir;
-}
-
-describe('no-any rule', () => {
-    it('blocks : any', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const x: any = 1;')]), w);
-        expect(r).not.toBeNull();
-        expect(r!.report).toContain('no-any-unknown');
-    });
-
-    it('blocks as any', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const x = y as any;')]), w);
-        expect(r).not.toBeNull();
-    });
-
-    it('blocks Array<any>', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const x: Array<any> = [];')]), w);
-        expect(r).not.toBeNull();
-    });
-
-    it('allows any in a string', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const x = "has any keyword";')]), w);
-        expect(r).toBeNull();
-    });
-
-    it('allows any in a comment', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', '// any is fine here\nconst x = 1;')]), w);
-        expect(r).toBeNull();
-    });
-
-    it('respects ai-hook-disable', () => {
-        const w = ws();
-        const content = '// ai-hook-disable no-any-unknown -- legacy\nconst x: any = 1;';
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
-        expect(r).toBeNull();
-    });
-
-    it('allows unknown keyword', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const x: unknown = 1;')]), w);
-        expect(r).toBeNull();
-    });
-
-    it('ignores non-ts files', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.md'), [new NormalizedEdit('', 'const x: any = 1;')]), w);
-        expect(r).toBeNull();
-    });
-});

package/src/core/__tests__/rules/no-destructure.test.ts

@@ -1,50 +0,0 @@
-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-destr-'));
-    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 }, 'require-return-type': { enabled: false },
-            'no-unmanaged-exceptions': { enabled: false } },
-        rulesDir: [],
-    }));
-    return dir;
-}
-
-describe('no-destructure rule', () => {
-    it('blocks const { x } = obj', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const { x } = obj;')]), w);
-        expect(r).not.toBeNull();
-        expect(r!.report).toContain('no-destructure');
-    });
-
-    it('blocks let { x } = obj', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'let { a, b } = obj;')]), w);
-        expect(r).not.toBeNull();
-    });
-
-    it('allows const x = obj.x (no destructure)', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const x = obj.x;')]), w);
-        expect(r).toBeNull();
-    });
-
-    it('respects ai-hook-disable', () => {
-        const w = ws();
-        const content = '// ai-hook-disable no-destructure -- needed for spread\nconst { a, ...rest } = obj;';
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', content)]), w);
-        expect(r).toBeNull();
-    });
-
-    it('allows object literal (not destructure)', () => {
-        const w = ws();
-        const r = run('Write', new NormalizedToolInput(path.join(w, 'f.ts'), [new NormalizedEdit('', 'const obj = { x: 1, y: 2 };')]), w);
-        expect(r).toBeNull();
-    });
-});

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

@@ -1,118 +0,0 @@
-/* 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

@@ -1,54 +0,0 @@
-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();
-    });
-});