@webpieces/ai-hook-rules 0.0.1 → 0.2.113

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

@@ -1,79 +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(), '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

@@ -1,288 +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 { 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

@@ -1,109 +0,0 @@
-/* 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');
-    });
-});

package/src/core/build-context.ts

@@ -1,96 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-import { stripTsNoise } from './strip-ts-noise';
-import { createIsLineDisabled } from './disable-directives';
-import {
-    ToolKind, NormalizedToolInput, NormalizedEdit,
-    EditContext, FileContext, BashContext,
-} from './types';
-
-export class BuiltContexts {
-    readonly fileContext: FileContext;
-    readonly editContexts: readonly EditContext[];
-
-    constructor(fileContext: FileContext, editContexts: readonly EditContext[]) {
-        this.fileContext = fileContext;
-        this.editContexts = editContexts;
-    }
-}
-
-export function buildContexts(
-    toolKind: ToolKind,
-    input: NormalizedToolInput,
-    workspaceRoot: string,
-): BuiltContexts {
-    const filePath = input.filePath;
-    const relativePath = path.relative(workspaceRoot, filePath);
-    const edits = input.edits;
-
-    const currentFileLines = readCurrentFileLines(filePath);
-    let linesAdded = 0;
-    let linesRemoved = 0;
-    for (const e of edits) {
-        linesAdded += countLines(e.newString);
-        linesRemoved += countLines(e.oldString);
-    }
-
-    const projectedFileLines =
-        toolKind === 'Write'
-            ? countLines(edits.length > 0 ? edits[0].newString : '')
-            : currentFileLines + linesAdded - linesRemoved;
-
-    const fileContext = new FileContext(
-        toolKind,
-        filePath,
-        relativePath,
-        workspaceRoot,
-        currentFileLines,
-        linesAdded,
-        linesRemoved,
-        projectedFileLines,
-    );
-
-    const editContexts = edits.map((e, idx) => {
-        const addedContent = e.newString;
-        const stripped = stripTsNoise(addedContent);
-        const isLineDisabled = createIsLineDisabled(addedContent);
-        return new EditContext(
-            toolKind,
-            idx,
-            edits.length,
-            filePath,
-            relativePath,
-            workspaceRoot,
-            addedContent,
-            stripped,
-            addedContent.split('\n'),
-            stripped.split('\n'),
-            e.oldString,
-            isLineDisabled,
-        );
-    });
-
-    return new BuiltContexts(fileContext, editContexts);
-}
-
-export function buildBashContext(command: string, workspaceRoot: string): BashContext {
-    return new BashContext(command, workspaceRoot);
-}
-
-function readCurrentFileLines(filePath: string): number {
-    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
-    try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        return countLines(content);
-    } catch (err: unknown) {
-        // eslint-disable-next-line @webpieces/catch-error-pattern -- file-not-found is expected for new Write targets
-        void err;
-        return 0;
-    }
-}
-
-function countLines(s: string): number {
-    if (!s) return 0;
-    return s.split('\n').length;
-}

package/src/core/disable-directives.ts

@@ -1,90 +0,0 @@
-import type { IsLineDisabled } from './types';
-
-const DIRECTIVE_RE =
-    /\/\/\s*(?:ai-hook-disable|webpieces-disable)(?:-(next|file|all))?(?:\s+([\w\-*,\s]+?))?(?:\s*--\s*(.*))?\s*$/;
-
-export class DirectiveIndex {
-    private readonly lineDisables: Map<number, Set<string>>;
-    private readonly fileDisables: Set<string>;
-
-    constructor(lineDisables: Map<number, Set<string>>, fileDisables: Set<string>) {
-        this.lineDisables = lineDisables;
-        this.fileDisables = fileDisables;
-    }
-
-    isLineDisabled(lineNum: number, ruleName: string): boolean {
-        if (this.fileDisables.has('*') || this.fileDisables.has(ruleName)) return true;
-        const set = this.lineDisables.get(lineNum);
-        if (!set) return false;
-        return set.has('*') || set.has(ruleName);
-    }
-}
-
-function parseRuleList(raw: string | undefined): readonly string[] {
-    if (!raw || raw.trim() === '' || raw.trim() === '*') return ['*'];
-    return raw.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
-}
-
-function nextTargetLine(lines: readonly string[], lineIdx: number): number | null {
-    for (let j = lineIdx + 1; j < lines.length; j += 1) {
-        const trimmed = lines[j].trim();
-        if (trimmed === '') continue;
-        if (/^\/\/\s*(?:ai-hook-disable|webpieces-disable)/.test(trimmed)) continue;
-        return j + 1;
-    }
-    return null;
-}
-
-function addDisable(map: Map<number, Set<string>>, lineNum: number, rules: readonly string[]): void {
-    if (!map.has(lineNum)) map.set(lineNum, new Set<string>());
-    const set = map.get(lineNum)!;
-    for (const r of rules) set.add(r);
-}
-
-function resolveTarget(
-    line: string, lines: readonly string[], i: number,
-    map: Map<number, Set<string>>, rules: readonly string[],
-): void {
-    const beforeComment = line.slice(0, line.indexOf('//')).trim();
-    if (beforeComment !== '') {
-        addDisable(map, i + 1, rules);
-    } else {
-        const target = nextTargetLine(lines, i);
-        if (target !== null) addDisable(map, target, rules);
-    }
-}
-
-export function parseDirectives(source: string): DirectiveIndex {
-    const lines = source.split('\n');
-    const lineDisables = new Map<number, Set<string>>();
-    const fileDisables = new Set<string>();
-
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        const match = line.match(DIRECTIVE_RE);
-        if (!match) continue;
-        const variant = match[1] || null;
-        const rules = parseRuleList(match[2] || '');
-
-        if (variant === 'file') {
-            if (i < 20) { for (const r of rules) fileDisables.add(r); }
-            continue;
-        }
-        if (variant === 'next') {
-            const target = nextTargetLine(lines, i);
-            if (target !== null) addDisable(lineDisables, target, rules);
-            continue;
-        }
-        if (variant === 'all') {
-            resolveTarget(line, lines, i, lineDisables, ['*']);
-            continue;
-        }
-        resolveTarget(line, lines, i, lineDisables, rules);
-    }
-    return new DirectiveIndex(lineDisables, fileDisables);
-}
-
-export function createIsLineDisabled(source: string): IsLineDisabled {
-    const index = parseDirectives(source);
-    return (lineNum: number, ruleName: string): boolean => index.isLineDisabled(lineNum, ruleName);
-}

package/src/core/instruct-ai-writer.ts

@@ -1,15 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-const INSTRUCT_DIR = '.webpieces/instruct-ai';
-
-export function writeTemplateIfMissing(workspaceRoot: string, templateName: string): void {
-    const dir = path.join(workspaceRoot, INSTRUCT_DIR);
-    const filePath = path.join(dir, templateName);
-    if (fs.existsSync(filePath)) return;
-
-    const templatePath = path.join(__dirname, '..', '..', 'templates', templateName);
-    const content = fs.readFileSync(templatePath, 'utf-8');
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(filePath, content);
-}

package/src/core/load-config.ts

@@ -1,3 +0,0 @@
-// Re-export the shared workspace config loader so ai-hooks and the Nx
-// validate-code executor use the same webpieces.config.json.
-export { loadConfig, findConfigFile, CONFIG_FILENAME } from '@webpieces/rules-config';