@webpieces/ai-hook-rules 0.0.1

package/src/adapters/claude-code-hook.ts

@@ -0,0 +1,117 @@
+import { run, runBash } from '../core/runner';
+import { logRejection } from '../core/rejection-log';
+import { NormalizedToolInput, NormalizedEdit, ToolKind } from '../core/types';
+import { toError } from '../core/to-error';
+
+const HANDLED_FILE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit']);
+
+interface ClaudeCodePayload {
+    tool_name: string;
+    tool_input: ClaudeCodeToolInput;
+}
+
+interface ClaudeCodeToolInput {
+    file_path?: string;
+    content?: string;
+    old_string?: string;
+    new_string?: string;
+    edits?: ClaudeCodeEditEntry[];
+    command?: string;
+}
+
+interface ClaudeCodeEditEntry {
+    old_string?: string;
+    new_string?: string;
+}
+
+function readStdin(): Promise<string> {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk: string) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', () => resolve(''));
+        if (process.stdin.isTTY) resolve('');
+    });
+}
+
+function safeParse(raw: string): ClaudeCodePayload | null {
+    if (!raw || raw.trim() === '') return null;
+    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+    try {
+        return JSON.parse(raw) as ClaudeCodePayload;
+    } catch (err: unknown) {
+        const error = toError(err);
+        void error;
+        return null;
+    }
+}
+
+function normalizeToolKind(toolName: string): ToolKind | null {
+    if (HANDLED_FILE_TOOLS.has(toolName)) return toolName as ToolKind;
+    return null;
+}
+
+function normalizeToolInput(toolKind: ToolKind, toolInput: ClaudeCodeToolInput): NormalizedToolInput | null {
+    const filePath = toolInput.file_path;
+    if (!filePath) return null;
+
+    if (toolKind === 'Write') {
+        return new NormalizedToolInput(filePath, [
+            new NormalizedEdit('', toolInput.content || ''),
+        ]);
+    }
+    if (toolKind === 'Edit') {
+        return new NormalizedToolInput(filePath, [
+            new NormalizedEdit(toolInput.old_string || '', toolInput.new_string || ''),
+        ]);
+    }
+    if (toolKind === 'MultiEdit') {
+        const raw = Array.isArray(toolInput.edits) ? toolInput.edits : [];
+        const edits = raw.map((e) => new NormalizedEdit(e.old_string || '', e.new_string || ''));
+        return new NormalizedToolInput(filePath, edits);
+    }
+    return null;
+}
+
+export async function main(): Promise<void> {
+    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+    try {
+        const raw = await readStdin();
+        const payload = safeParse(raw);
+        if (!payload) { process.exit(0); return; }
+
+        const cwd = process.cwd();
+
+        if (payload.tool_name === 'Bash') {
+            const command = payload.tool_input.command;
+            if (!command || command.trim() === '') { process.exit(0); return; }
+            const result = runBash(command, cwd);
+            if (!result) { process.exit(0); return; }
+            process.stderr.write(result.report);
+            process.exit(2);
+            return;
+        }
+
+        const toolKind = normalizeToolKind(payload.tool_name);
+        if (!toolKind) { process.exit(0); return; }
+
+        const input = normalizeToolInput(toolKind, payload.tool_input);
+        if (!input) { process.exit(0); return; }
+
+        const result = run(toolKind, input, cwd);
+        if (!result) { process.exit(0); return; }
+
+        logRejection(toolKind, input, result, cwd);
+        process.stderr.write(result.report);
+        process.exit(2);
+    } catch (err: unknown) {
+        const error = toError(err);
+        process.stderr.write(`[ai-hooks] claude-code adapter crashed (failing open): ${error.message}\n`);
+        process.exit(0);
+    }
+}
+
+if (require.main === module) {
+    main();
+}

package/src/adapters/openclaw-plugin.ts

@@ -0,0 +1,88 @@
+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

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

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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,68 @@
+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

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