ai-xray 1.2.0 → 2.0.0

package/ana-suggestions.md

@@ -1,105 +0,0 @@
-# Ana 功能建议 — ai-xray 增强方向
-
-> 来源：Ana 与用户讨论（2026-03-06）
-> 状态：待评估，后续归纳到 PRD
-
-## 背景
-ai-xray 当前定位：**AI Agent 的上下文采集器**（Structured Context Gathering for AI Agents）。
-以下建议基于通用 AI Agent 工作场景中的常见痛点，均为**通用需求**（非专项项目需求）。
-
----
-
-## 建议 1: `hotspots` — 文件重要性排序
-
-**痛点**：Agent 进入陌生 repo 后不知道哪些文件最关键，容易在边缘文件上浪费 token。
-
-**功能**：
-```
-ai-xray hotspots [dir] [--top=N] [--by=imports|commits|both]
-```
-
-**输出**：按重要性排序的文件列表，指标包括：
-- **import 频率**：被其他文件引用最多的文件（核心模块）
-- **commit 频率**：最近 N 天改动最频繁的文件（活跃热点）
-- **综合评分**：两者加权
-
-**价值**：Agent 可以优先阅读最重要的文件，避免在不重要文件上浪费上下文。
-
----
-
-## 建议 2: `coverage` — 测试覆盖快照
-
-**痛点**：Agent 修 bug 或加功能时，不知道哪些模块有测试保护、哪些是裸奔的。
-
-**功能**：
-```
-ai-xray coverage [--format=summary|detail]
-```
-
-**输出**：
-- 哪些源文件有对应的测试文件
-- 哪些模块完全没有测试（风险区域）
-- 测试文件与源文件的映射关系
-
-**注意**：不是跑真实 coverage（太重），而是通过文件名匹配 + 目录结构推断（轻量级）。
-
----
-
-## 建议 3: `pulse` — 项目活跃度脉搏
-
-**痛点**：Agent（特别是做开源贡献的）需要判断项目是否还活跃、maintainer 是否还在。
-
-**功能**：
-```
-ai-xray pulse [--days=90]
-```
-
-**输出**：
-- 最近 N 天的 commit 趋势（每周/每月频率）
-- 最近一次 commit 距今天数
-- 活跃贡献者数量
-- issue/PR 响应速度（如果能从 git log 推断）
-- 一句话判断：`Active` / `Slow` / `Dormant` / `Abandoned`
-
-**价值**：帮 Agent 快速判断是否值得在这个项目上投入时间。对大荒的谛听角色特别有用。
-
----
-
-## 建议 4: `deps` — 依赖关系图
-
-**痛点**：Agent 要修改某个文件时，不知道会影响多少其他文件。
-
-**功能**：
-```
-ai-xray deps <file> [--depth=N] [--direction=in|out|both]
-```
-
-**输出**：
-- **in**：谁引用了这个文件（影响范围）
-- **out**：这个文件引用了谁（依赖链）
-- 循环依赖检测
-
-**价值**：Agent 修改前先查影响范围，避免引入 breaking changes。
-
----
-
-## 建议 5: `entrypoints` — 入口点发现
-
-**痛点**：Agent 需要快速定位项目的入口点（main、CLI entry、route handlers、exports）。
-
-**功能**：
-```
-ai-xray entrypoints [--type=cli|web|lib|all]
-```
-
-**输出**：
-- package.json 的 main/bin/exports
-- 框架入口（Next.js pages、Express routes 等）
-- CLI 命令注册点
-
----
-
-## 后续
-- [ ] 与用户评估优先级
-- [ ] 选择 1-2 个最有价值的先实现
-- [ ] 归纳到正式 PRD

package/tests/cli.test.ts

@@ -1,172 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// We test the CLI routing logic by extracting the core routing behavior.
-// Since cli.ts calls main() on import and uses process.argv / process.exit,
-// we test the command routing indirectly through the individual handlers,
-// and verify the arg-parsing logic directly.
-
-// Mock all command handlers
-vi.mock('../src/commands/env', () => ({ handleEnvCommand: vi.fn(() => ({ mock: 'env' })) }));
-vi.mock('../src/commands/tree', () => ({ handleTreeCommand: vi.fn(() => ({ mock: 'tree' })) }));
-vi.mock('../src/commands/read', () => ({ handleReadCommand: vi.fn(() => ({ mock: 'read' })) }));
-vi.mock('../src/commands/diff', () => ({ handleDiffCommand: vi.fn(() => ({ mock: 'diff' })) }));
-vi.mock('../src/commands/scout', () => ({ handleScoutCommand: vi.fn(() => ({ mock: 'scout' })) }));
-vi.mock('../src/commands/init', () => ({ handleInitCommand: vi.fn(() => ({ mock: 'init' })) }));
-
-// Mock output to prevent process.exit calls
-vi.mock('../src/utils/output', () => ({
-    outputSuccess: vi.fn(),
-    outputError: vi.fn(),
-}));
-
-import { handleEnvCommand } from '../src/commands/env';
-import { handleTreeCommand } from '../src/commands/tree';
-import { handleReadCommand } from '../src/commands/read';
-import { handleDiffCommand } from '../src/commands/diff';
-import { handleScoutCommand } from '../src/commands/scout';
-import { handleInitCommand } from '../src/commands/init';
-import { outputSuccess, outputError } from '../src/utils/output';
-
-/**
- * Re-implements the CLI arg parsing and routing logic from src/cli.ts
- * to test it in isolation without triggering process.exit or auto-execution.
- */
-function routeCommand(args: string[]): { command: string; result?: any; error?: string; isHelp?: boolean } {
-    if (args.length === 0 || args[0] === 'help' || args.includes('--help') || args.includes('-h')) {
-        return { command: 'help', isHelp: true };
-    }
-
-    const command = args[0];
-    const originalParams = args.slice(1);
-
-    let budget: number | undefined;
-    const commandParams: string[] = [];
-
-    for (const p of originalParams) {
-        if (p.startsWith('--budget=')) {
-            budget = parseInt(p.split('=')[1], 10);
-            if (isNaN(budget)) {
-                return { command, error: 'Invalid --budget value. Must be a number.' };
-            }
-        } else if (p === '--pretty') {
-            // handled globally
-        } else {
-            commandParams.push(p);
-        }
-    }
-
-    let result: any;
-    switch (command) {
-        case 'scout':
-            result = (handleScoutCommand as any)(budget);
-            break;
-        case 'env':
-            result = (handleEnvCommand as any)();
-            break;
-        case 'tree':
-            result = (handleTreeCommand as any)(commandParams, budget);
-            break;
-        case 'read':
-            result = (handleReadCommand as any)(commandParams, budget);
-            break;
-        case 'diff':
-            result = (handleDiffCommand as any)(commandParams, budget);
-            break;
-        case 'init':
-            result = (handleInitCommand as any)(commandParams);
-            break;
-        default:
-            return { command, error: `Unknown command: ${command}` };
-    }
-
-    return { command, result };
-}
-
-describe('CLI Routing', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it('should show help when no arguments provided', () => {
-        const res = routeCommand([]);
-        expect(res.isHelp).toBe(true);
-        expect(res.command).toBe('help');
-    });
-
-    it('should show help when "help" is the first argument (args[0] === "help" fix)', () => {
-        const res = routeCommand(['help']);
-        expect(res.isHelp).toBe(true);
-    });
-
-    it('should show help when --help flag is present anywhere', () => {
-        const res = routeCommand(['env', '--help']);
-        expect(res.isHelp).toBe(true);
-    });
-
-    it('should show help when -h flag is present', () => {
-        const res = routeCommand(['-h']);
-        expect(res.isHelp).toBe(true);
-    });
-
-    it('should route to env command', () => {
-        const res = routeCommand(['env']);
-        expect(res.command).toBe('env');
-        expect(handleEnvCommand).toHaveBeenCalled();
-    });
-
-    it('should route to tree command with params', () => {
-        routeCommand(['tree', 'src/', '--depth=5']);
-        expect(handleTreeCommand).toHaveBeenCalledWith(['src/', '--depth=5'], undefined);
-    });
-
-    it('should route to read command', () => {
-        routeCommand(['read', 'file.ts']);
-        expect(handleReadCommand).toHaveBeenCalledWith(['file.ts'], undefined);
-    });
-
-    it('should route to diff command', () => {
-        routeCommand(['diff', '--full']);
-        expect(handleDiffCommand).toHaveBeenCalledWith(['--full'], undefined);
-    });
-
-    it('should route to scout command', () => {
-        routeCommand(['scout']);
-        expect(handleScoutCommand).toHaveBeenCalledWith(undefined);
-    });
-
-    it('should route to init command', () => {
-        routeCommand(['init', '--format=claude']);
-        expect(handleInitCommand).toHaveBeenCalledWith(['--format=claude']);
-    });
-
-    it('should return error for unknown commands', () => {
-        const res = routeCommand(['foobar']);
-        expect(res.error).toBe('Unknown command: foobar');
-    });
-
-    it('should extract --budget flag and pass as number', () => {
-        routeCommand(['scout', '--budget=500']);
-        expect(handleScoutCommand).toHaveBeenCalledWith(500);
-    });
-
-    it('should pass budget to tree command', () => {
-        routeCommand(['tree', 'src/', '--budget=1000', '--depth=2']);
-        expect(handleTreeCommand).toHaveBeenCalledWith(['src/', '--depth=2'], 1000);
-    });
-
-    it('should error on invalid budget value (NaN)', () => {
-        const res = routeCommand(['env', '--budget=abc']);
-        expect(res.error).toContain('Invalid --budget value');
-    });
-
-    it('should strip --pretty from command params', () => {
-        routeCommand(['tree', 'src/', '--pretty']);
-        // --pretty should not be passed to the command handler
-        expect(handleTreeCommand).toHaveBeenCalledWith(['src/'], undefined);
-    });
-
-    it('should handle multiple flags together', () => {
-        routeCommand(['read', 'file.ts', '--lines=1-10', '--budget=200', '--pretty']);
-        expect(handleReadCommand).toHaveBeenCalledWith(['file.ts', '--lines=1-10'], 200);
-    });
-});

package/tests/diff.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleDiffCommand } from '../src/commands/diff';
-import * as child_process from 'child_process';
-import * as fs from 'fs';
-
-vi.mock('fs', async () => {
-    const actual = await vi.importActual<typeof import('fs')>('fs');
-    return { ...actual, existsSync: vi.fn() };
-});
-
-vi.mock('child_process', () => ({
-    execFileSync: vi.fn()
-}));
-
-const mockExistsSync = fs.existsSync as any;
-const mockExecFileSync = child_process.execFileSync as any;
-
-describe('Diff Command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it('should throw when not a git repository', () => {
-        mockExistsSync.mockReturnValue(false);
-        expect(() => handleDiffCommand([])).toThrow('Not a git repository');
-    });
-
-    it('should return branch, ahead/behind counts, staged/unstaged/untracked', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) return 'feature-x\n';
-            if (args.includes('--left-right')) return '3\t1\n';
-            if (args.includes('--porcelain')) return 'M  staged.ts\n M unstaged.ts\n?? new.ts\n';
-            if (args.includes('--numstat') && args.includes('--cached')) return '10\t2\tstaged.ts\n';
-            if (args.includes('--numstat')) return '5\t3\tunstaged.ts\n';
-            return '';
-        });
-
-        const result = handleDiffCommand([]);
-        expect(result.branch).toBe('feature-x');
-        expect(result.ahead).toBe(3);
-        expect(result.behind).toBe(1);
-        expect(result.staged).toEqual([{ file: 'staged.ts', status: 'M', insertions: 10, deletions: 2 }]);
-        expect(result.unstaged).toEqual([{ file: 'unstaged.ts', status: 'M', insertions: 5, deletions: 3 }]);
-        expect(result.untracked).toEqual(['new.ts']);
-    });
-
-    it('should handle --full flag and attach raw diff output', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) return 'main\n';
-            if (args.includes('--left-right')) return null;
-            if (args.includes('--porcelain')) return '';
-            if (args[0] === 'diff' && args.includes('--cached')) return 'staged diff content\n';
-            if (args[0] === 'diff' && !args.includes('--cached') && !args.includes('--numstat')) return 'unstaged diff content\n';
-            return '';
-        });
-
-        const result = handleDiffCommand(['--full']);
-        expect(result.stagedDiff).toBe('staged diff content');
-        expect(result.unstagedDiff).toBe('unstaged diff content');
-    });
-
-    it('should filter by --file flag', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) return 'main\n';
-            if (args.includes('--left-right')) return '';
-            if (args.includes('--porcelain')) return 'M  target.ts\nM  other.ts\n';
-            return '';
-        });
-
-        const result = handleDiffCommand(['--file=target.ts']);
-        expect(result.staged.length).toBe(1);
-        expect(result.staged[0].file).toBe('target.ts');
-        // other.ts should be filtered out
-        expect(result.unstaged.length).toBe(0);
-    });
-
-    it('should use execFileSync (not execSync) to prevent shell injection', () => {
-        // Verify the module uses execFileSync by checking the import
-        // execFileSync takes command and args array separately — no shell interpretation
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation(() => '');
-
-        handleDiffCommand([]);
-
-        // All calls should be to execFileSync (our mock), not execSync
-        expect(mockExecFileSync).toHaveBeenCalled();
-        // Verify args are passed as arrays (safe), not concatenated strings
-        for (const call of mockExecFileSync.mock.calls) {
-            expect(call[0]).toBe('git');
-            expect(Array.isArray(call[1])).toBe(true);
-        }
-    });
-
-    it('should handle no tracking info gracefully (ahead/behind = 0)', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) return 'main\n';
-            if (args.includes('--left-right')) return null; // no upstream
-            if (args.includes('--porcelain')) return '';
-            return '';
-        });
-
-        const result = handleDiffCommand([]);
-        expect(result.ahead).toBe(0);
-        expect(result.behind).toBe(0);
-    });
-
-    it('should handle empty git status (clean working directory)', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) return 'main\n';
-            if (args.includes('--left-right')) return '0\t0\n';
-            if (args.includes('--porcelain')) return '';
-            return null;
-        });
-
-        const result = handleDiffCommand([]);
-        expect(result.staged).toEqual([]);
-        expect(result.unstaged).toEqual([]);
-        expect(result.untracked).toEqual([]);
-    });
-
-    it('should not attach stagedDiff/unstagedDiff without --full flag', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) return 'main\n';
-            if (args.includes('--left-right')) return '';
-            if (args.includes('--porcelain')) return '';
-            return '';
-        });
-
-        const result = handleDiffCommand([]);
-        expect(result.stagedDiff).toBeUndefined();
-        expect(result.unstagedDiff).toBeUndefined();
-    });
-
-    it('should handle --full with --file to scope diff', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) return 'main\n';
-            if (args.includes('--left-right')) return '';
-            if (args.includes('--porcelain')) return '';
-            // When --full + --file=target.ts, diff args should include the file
-            if (args[0] === 'diff' && args.includes('target.ts')) return 'targeted diff\n';
-            if (args[0] === 'diff') return '';
-            return '';
-        });
-
-        const result = handleDiffCommand(['--full', '--file=target.ts']);
-        // The --file flag should cause diff to be scoped to target.ts
-        expect(result).toBeDefined();
-    });
-
-    it('should handle branch detection failure', () => {
-        mockExistsSync.mockImplementation((p: string) => p.endsWith('.git'));
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (args.includes('--abbrev-ref')) { throw new Error('git failed'); }
-            if (args.includes('--left-right')) return null;
-            if (args.includes('--porcelain')) return '';
-            return null;
-        });
-
-        const result = handleDiffCommand([]);
-        expect(result.branch).toBe('unknown');
-    });
-});

package/tests/env.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { handleEnvCommand } from '../src/commands/env';
-import * as child_process from 'child_process';
-import * as fs from 'fs';
-
-// We mock readFileSync and existsSync heavily for this test
-vi.mock('fs', async () => {
-    const actualFs = await vi.importActual<typeof import('fs')>('fs');
-    return {
-        ...actualFs,
-        existsSync: vi.fn(),
-        readFileSync: vi.fn()
-    };
-});
-
-vi.mock('child_process', () => ({
-    execFileSync: vi.fn()
-}));
-
-const mockExistsSync = fs.existsSync as any;
-const mockReadFileSync = fs.readFileSync as any;
-const mockExecFileSync = child_process.execFileSync as any;
-
-describe('Env Command', () => {
-    it('should detect pnpm and frameworks', () => {
-        // Setup virtual filesystem
-        mockExistsSync.mockImplementation((path: string) => {
-            if (path.includes('package.json')) return true;
-            if (path.includes('pnpm-lock.yaml')) return true;
-            if (path.includes('.git')) return true;
-            return false;
-        });
-
-        mockReadFileSync.mockImplementation((path: string) => {
-            if (path.includes('package.json')) {
-                return JSON.stringify({
-                    name: 'test-app',
-                    engines: { node: '>=18' },
-                    dependencies: { next: '14.0.0', react: '18.0.0' },
-                    devDependencies: { vitest: '1.0.0' }
-                });
-            }
-            return '';
-        });
-
-        mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-            if (cmd === 'pnpm' && args.includes('--version')) return '9.1.0\n';
-            if (cmd === 'git' && args.includes('rev-parse')) return 'main\n';
-            if (cmd === 'git' && args.includes('--porcelain')) return ' M file.ts\n';
-            return '';
-        });
-
-        const result = handleEnvCommand();
-
-        // Assertions
-        expect(result.packageManager.name).toBe('pnpm');
-        expect(result.packageManager.version).toBe('9.1.0');
-        expect(result.frameworks).toContain('next');
-        expect(result.frameworks).toContain('react');
-
-        // Test framework inference
-        expect(result.testFramework?.name).toBe('vitest');
-        expect(result.testFramework?.runCommand).toContain('vitest run');
-
-        // Git detection
-        expect(result.git.branch).toBe('main');
-        expect(result.git.hasUncommitted).toBe(true);
-    });
-});

package/tests/init.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleInitCommand } from '../src/commands/init';
-import * as fs from 'fs';
-
-vi.mock('fs', async () => {
-    const actual = await vi.importActual<typeof import('fs')>('fs');
-    return {
-        ...actual,
-        existsSync: vi.fn(),
-        readFileSync: vi.fn(),
-        writeFileSync: vi.fn()
-    };
-});
-
-const mockExistsSync = fs.existsSync as any;
-const mockReadFileSync = fs.readFileSync as any;
-const mockWriteFileSync = fs.writeFileSync as any;
-
-describe('Init Command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it('should create AGENTS.md by default when no rule files exist', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        const result = handleInitCommand([]);
-        expect(result.action).toBe('created');
-        expect(result.target).toBe('AGENTS.md');
-        expect(mockWriteFileSync).toHaveBeenCalledTimes(1);
-        // Check content includes the template
-        const writtenContent = mockWriteFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain('ai-xray');
-        expect(writtenContent).toContain('# AI Agent Rules');
-    });
-
-    it('should inject into existing file that does not have marker', () => {
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('AGENTS.md')) return true;
-            return false;
-        });
-        mockReadFileSync.mockReturnValue('# Existing Rules\n\nSome rules here.');
-
-        const result = handleInitCommand([]);
-        expect(result.action).toBe('injected');
-        expect(result.target).toBe('AGENTS.md');
-
-        const writtenContent = mockWriteFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain('# Existing Rules');
-        expect(writtenContent).toContain('ai-xray:start');
-    });
-
-    it('should skip injection if marker already exists', () => {
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('AGENTS.md')) return true;
-            return false;
-        });
-        mockReadFileSync.mockReturnValue('# Rules\n<!-- ai-xray:start -->\nstuff\n<!-- ai-xray:end -->');
-
-        const result = handleInitCommand([]);
-        expect(result.action).toBe('skipped');
-        expect(result.reason).toBe('Already injected');
-        expect(mockWriteFileSync).not.toHaveBeenCalled();
-    });
-
-    it('should use --format=claude to target CLAUDE.md', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        const result = handleInitCommand(['--format=claude']);
-        expect(result.target).toBe('CLAUDE.md');
-        expect(result.action).toBe('created');
-    });
-
-    it('should use --format=cursorrules to target .cursorrules', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        const result = handleInitCommand(['--format=cursorrules']);
-        expect(result.target).toBe('.cursorrules');
-        expect(result.action).toBe('created');
-    });
-
-    it('should use --format=agents to target AGENTS.md', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        const result = handleInitCommand(['--format=agents']);
-        expect(result.target).toBe('AGENTS.md');
-        expect(result.action).toBe('created');
-    });
-
-    it('should throw on unknown format', () => {
-        expect(() => handleInitCommand(['--format=unknown'])).toThrow('Unknown format: unknown');
-    });
-
-    it('should auto-detect existing CLAUDE.md and inject there', () => {
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            // AGENTS.md doesn't exist, but CLAUDE.md does
-            if (norm.endsWith('AGENTS.md')) return false;
-            if (norm.endsWith('CLAUDE.md')) return true;
-            return false;
-        });
-        mockReadFileSync.mockReturnValue('# Claude Rules\n\nSome content.');
-
-        const result = handleInitCommand([]);
-        expect(result.target).toBe('CLAUDE.md');
-        expect(result.action).toBe('injected');
-    });
-
-    it('should auto-detect .cursorrules before CLAUDE.md', () => {
-        // The search order is: AGENTS.md, CLAUDE.md, .cursorrules, copilot-instructions.md
-        // But since AGENTS.md is checked first, if it exists it takes priority
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('AGENTS.md')) return true;
-            if (norm.endsWith('CLAUDE.md')) return true;
-            if (norm.endsWith('.cursorrules')) return true;
-            return false;
-        });
-        mockReadFileSync.mockReturnValue('# Agent rules');
-
-        const result = handleInitCommand([]);
-        // AGENTS.md is first in the search list
-        expect(result.target).toBe('AGENTS.md');
-    });
-
-    it('should include linesAdded count in result', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        const result = handleInitCommand([]);
-        expect(result.linesAdded).toBeGreaterThan(0);
-    });
-
-    it('should include marker info in result', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        const result = handleInitCommand([]);
-        expect(result.marker).toBe('ai-xray:start');
-    });
-
-    it('should write UTF-8 encoded files', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        handleInitCommand([]);
-        // Check that writeFileSync was called with utf-8 encoding
-        expect(mockWriteFileSync).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.any(String),
-            'utf-8'
-        );
-    });
-
-    it('should inject template with correct content markers', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        handleInitCommand([]);
-        const content = mockWriteFileSync.mock.calls[0][1];
-        expect(content).toContain('<!-- ai-xray:start -->');
-        expect(content).toContain('<!-- ai-xray:end -->');
-        expect(content).toContain('npx ai-xray scout --budget=2000');
-        expect(content).toContain('npx ai-xray diff --full');
-    });
-});