ai-xray 1.2.0 → 2.0.0

package/tests/output.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { estimateTokens, applyBudget } from '../src/utils/output';
-
-describe('Output & Budget Manager', () => {
-    it('should estimate tokens roughly correctly', () => {
-        // 4 chars ~ 1 token
-        expect(estimateTokens('1234')).toBe(1);
-        expect(estimateTokens('12345678')).toBe(2);
-        expect(estimateTokens('')).toBe(1); // min 1
-    });
-
-    it('should pass through data when budget is undefined or unlimited', () => {
-        const data = { hello: 'world' };
-        const res = applyBudget(data, 0);
-        expect(res).toEqual({ hello: 'world' });
-    });
-
-    it('should actually truncate data when budget is exceeded', () => {
-        const data = { a: 'b', c: 'a very long string that will exceed a tiny budget' };
-        // estimated tokens for this stringified JSON is roughly ~15-20
-        const res = applyBudget(data, 5);
-
-        // With actual truncation, data should be hard-truncated since budget is very small (5 tokens = 20 chars)
-        expect(res._meta.truncated).toBe(true);
-        expect(res._meta.budget).toBe(5);
-        expect(res._meta.hint).toContain('exceeded budget');
-    });
-
-    it('should prune large fields when moderately over budget', () => {
-        const data = { name: 'test', items: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] };
-        // Give a budget that's smaller than full data but large enough to keep some
-        const serialized = JSON.stringify(data);
-        const fullTokens = Math.ceil(serialized.length / 4);
-        const res = applyBudget(data, Math.floor(fullTokens * 0.6));
-
-        expect(res._meta.truncated).toBe(true);
-        expect(res._meta.hint).toContain('exceeded budget');
-    });
-
-    it('should attach standard meta when budget is met', () => {
-        const data = { a: 'b' };
-        const res = applyBudget(data, 100);
-
-        expect(res.a).toBe('b');
-        expect(res._meta.truncated).toBe(false);
-        expect(res._meta.budget).toBe(100);
-        expect(res._meta.tokensEstimate).toBeGreaterThan(0);
-    });
-});

package/tests/read.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleReadCommand } from '../src/commands/read';
-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(),
-        statSync: vi.fn()
-    };
-});
-
-const mockExistsSync = fs.existsSync as any;
-const mockReadFileSync = fs.readFileSync as any;
-const mockStatSync = fs.statSync as any;
-
-describe('Read Command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-    });
-
-    it('should throw when no files are provided', () => {
-        expect(() => handleReadCommand([])).toThrow('No files provided to read.');
-    });
-
-    it('should read a single file and return content', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('line1\nline2\nline3\n');
-
-        const result = handleReadCommand(['test.ts']);
-        expect(result.file).toBe('test.ts');
-        expect(result.content).toBe('line1\nline2\nline3\n');
-        expect(result.lines).toBe(4); // 3 lines + trailing newline = 4 elements from split
-    });
-
-    it('should handle missing files gracefully', () => {
-        mockExistsSync.mockReturnValue(false);
-
-        const result = handleReadCommand(['missing.ts']);
-        expect(result.file).toBe('missing.ts');
-        expect(result.error).toBe('File not found');
-    });
-
-    it('should handle directory targets', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({ isDirectory: () => true });
-
-        const result = handleReadCommand(['somedir']);
-        expect(result.error).toBe('Target is a directory, not a file');
-    });
-
-    it('should extract line ranges with --lines flag', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('line1\nline2\nline3\nline4\nline5\n');
-
-        const result = handleReadCommand(['file.ts', '--lines=2-4']);
-        expect(result.content).toBe('line2\nline3\nline4');
-        expect(result.context.range).toEqual([2, 4]);
-    });
-
-    it('should extract JSON keys with --keys flag', () => {
-        mockExistsSync.mockReturnValue(true);
-        const jsonContent = JSON.stringify({
-            name: 'test',
-            version: '1.0.0',
-            dependencies: { react: '18.0.0' },
-            devDependencies: { vitest: '1.0.0' }
-        });
-        mockReadFileSync.mockReturnValue(jsonContent);
-
-        const result = handleReadCommand(['package.json', '--keys=name,dependencies']);
-        expect(result.content).toEqual({
-            name: 'test',
-            dependencies: { react: '18.0.0' }
-        });
-    });
-
-    it('should fallback to raw text for --keys on invalid JSON', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('not valid json {{{');
-
-        const result = handleReadCommand(['data.json', '--keys=name']);
-        // Should fallback to raw content string since JSON.parse fails
-        expect(typeof result.content).toBe('string');
-        expect(result.content).toBe('not valid json {{{');
-    });
-
-    it('should read multiple files and return array', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockImplementation((path: string) => {
-            if (path === 'a.ts') return 'content a';
-            if (path === 'b.ts') return 'content b';
-            return '';
-        });
-
-        const result = handleReadCommand(['a.ts', 'b.ts']);
-        expect(result.files).toHaveLength(2);
-        expect(result.files[0].file).toBe('a.ts');
-        expect(result.files[1].file).toBe('b.ts');
-    });
-
-    it('should handle mixed existing and missing files', () => {
-        mockExistsSync.mockImplementation((p: string) => p === 'exists.ts');
-        mockReadFileSync.mockReturnValue('content');
-
-        const result = handleReadCommand(['exists.ts', 'missing.ts']);
-        expect(result.files).toHaveLength(2);
-        expect(result.files[0].content).toBe('content');
-        expect(result.files[1].error).toBe('File not found');
-    });
-
-    it('should truncate content when budget is exceeded', () => {
-        mockExistsSync.mockReturnValue(true);
-        // Create a large content string (over budget)
-        const bigContent = 'x'.repeat(1000);
-        mockReadFileSync.mockReturnValue(bigContent);
-
-        // Budget of 50 tokens = ~200 chars
-        const result = handleReadCommand(['big.ts', '--budget=50'], 50);
-        // The content should be truncated
-        if (result.truncated) {
-            expect(result.content.length).toBeLessThan(bigContent.length);
-            expect(result.content).toContain('[TRUNCATED BY BUDGET]');
-        }
-    });
-
-    it('should skip file entirely if budget is exhausted', () => {
-        mockExistsSync.mockReturnValue(true);
-        const bigContent = 'x'.repeat(2000);
-        mockReadFileSync.mockReturnValue(bigContent);
-
-        // Very tiny budget
-        const result = handleReadCommand(['file1.ts', 'file2.ts'], 5);
-        // With a budget of 5 tokens (~20 chars), first file gets truncated or error,
-        // second file should be skipped
-        expect(result.files).toBeDefined();
-    });
-
-    it('should not apply --keys extraction to non-JSON files', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('const x = 1;');
-
-        // --keys only works on .json files
-        const result = handleReadCommand(['code.ts', '--keys=name']);
-        expect(typeof result.content).toBe('string');
-        expect(result.content).toBe('const x = 1;');
-    });
-
-    it('should handle line range that exceeds file length', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('line1\nline2\nline3');
-
-        const result = handleReadCommand(['file.ts', '--lines=1-100']);
-        expect(result.content).toBe('line1\nline2\nline3');
-        expect(result.context.range[1]).toBe(3); // capped to actual line count
-    });
-
-    it('should handle file read errors gracefully', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-        mockReadFileSync.mockImplementation(() => { throw new Error('Permission denied'); });
-
-        const result = handleReadCommand(['protected.ts']);
-        expect(result.error).toBe('Permission denied');
-    });
-});

package/tests/scout.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleScoutCommand } from '../src/commands/scout';
-import * as fs from 'fs';
-import * as child_process from 'child_process';
-
-vi.mock('fs', async () => {
-    const actual = await vi.importActual<typeof import('fs')>('fs');
-    return {
-        ...actual,
-        existsSync: vi.fn(),
-        readFileSync: vi.fn(),
-        readdirSync: vi.fn(),
-        statSync: vi.fn()
-    };
-});
-
-vi.mock('child_process', () => ({
-    execFileSync: vi.fn()
-}));
-
-const mockExistsSync = fs.existsSync as any;
-const mockReadFileSync = fs.readFileSync as any;
-const mockReaddirSync = fs.readdirSync as any;
-const mockStatSync = fs.statSync as any;
-const mockExecFileSync = child_process.execFileSync as any;
-
-function setupBasicProject() {
-    mockExistsSync.mockImplementation((p: string) => {
-        const norm = p.replace(/\\/g, '/');
-        if (norm.endsWith('package.json')) return true;
-        if (norm.endsWith('.git')) return true;
-        if (norm.endsWith('README.md')) return true;
-        if (norm.endsWith('.gitignore')) return false;
-        if (norm.endsWith('.cursorrules')) return false;
-        if (norm.endsWith('CLAUDE.md')) return false;
-        if (norm.endsWith('AGENTS.md')) return false;
-        if (norm.endsWith('copilot-instructions.md')) return false;
-        if (norm.endsWith('Readme.md')) return false;
-        if (norm.endsWith('readme.md')) return false;
-        return true;
-    });
-
-    mockReadFileSync.mockImplementation((p: string) => {
-        const norm = p.replace(/\\/g, '/');
-        if (norm.endsWith('package.json')) {
-            return JSON.stringify({
-                name: 'test-project',
-                dependencies: { react: '18.0.0' },
-                devDependencies: { vitest: '1.0.0' }
-            });
-        }
-        if (norm.endsWith('README.md')) return '# Test Project\n\nA test project.';
-        return '';
-    });
-
-    mockExecFileSync.mockImplementation((cmd: string, args: string[]) => {
-        if (args.includes('--version')) return '9.0.0\n';
-        if (args.includes('--abbrev-ref')) return 'main\n';
-        if (args.includes('--porcelain')) return '';
-        if (args.includes('remote.origin.url')) return 'https://github.com/test/test.git\n';
-        if (args.includes('--left-right')) return '0\t0\n';
-        return '';
-    });
-
-    mockReaddirSync.mockReturnValue(['src', 'package.json', 'README.md']);
-    mockStatSync.mockImplementation((p: string, opts?: any) => {
-        const norm = p.replace(/\\/g, '/');
-        if (norm.endsWith('src')) return { isDirectory: () => true };
-        return { isDirectory: () => false };
-    });
-}
-
-describe('Scout Command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it('should return a combined result with env, tree, readme, diff sections', () => {
-        setupBasicProject();
-
-        const result = handleScoutCommand();
-        expect(result.env).toBeDefined();
-        expect(result.tree).toBeDefined();
-        expect(result.readme).toBeDefined();
-        expect(result.diff).toBeDefined();
-    });
-
-    it('should include readme content (truncated to 60 lines)', () => {
-        setupBasicProject();
-
-        const result = handleScoutCommand();
-        expect(result.readme).toContain('# Test Project');
-    });
-
-    it('should truncate long readmes to 60 lines', () => {
-        setupBasicProject();
-        // Override README to be very long
-        const longReadme = Array.from({ length: 100 }, (_, i) => `Line ${i + 1}`).join('\n');
-        mockReadFileSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('package.json')) {
-                return JSON.stringify({ name: 'test', dependencies: {} });
-            }
-            if (norm.endsWith('README.md')) return longReadme;
-            return '';
-        });
-
-        const result = handleScoutCommand();
-        expect(result.readme).toContain('[TRUNCATED TO 60 LINES]');
-    });
-
-    it('should handle missing env gracefully (error in env)', () => {
-        // No package.json, no git
-        mockExistsSync.mockReturnValue(false);
-        mockReadFileSync.mockReturnValue('');
-        mockReaddirSync.mockReturnValue([]);
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-
-        const result = handleScoutCommand();
-        // env should still be present (returns a "not node project" result)
-        expect(result.env).toBeDefined();
-    });
-
-    it('should handle missing readme', () => {
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('README.md') || norm.endsWith('Readme.md') || norm.endsWith('readme.md')) return false;
-            if (norm.endsWith('package.json')) return true;
-            if (norm.endsWith('.git')) return false;
-            if (norm.endsWith('.gitignore')) return false;
-            if (norm.endsWith('.cursorrules')) return false;
-            if (norm.endsWith('CLAUDE.md')) return false;
-            if (norm.endsWith('AGENTS.md')) return false;
-            if (norm.endsWith('copilot-instructions.md')) return false;
-            return true;
-        });
-        mockReadFileSync.mockImplementation((p: string) => {
-            if (p.includes('package.json')) return JSON.stringify({ name: 'test' });
-            return '';
-        });
-        mockReaddirSync.mockReturnValue([]);
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-
-        const result = handleScoutCommand();
-        expect(result.readme).toBeNull();
-    });
-
-    it('should set diff to null when not a git repo', () => {
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('.git')) return false;
-            if (norm.endsWith('package.json')) return true;
-            if (norm.endsWith('.gitignore')) return false;
-            if (norm.endsWith('.cursorrules')) return false;
-            if (norm.endsWith('CLAUDE.md')) return false;
-            if (norm.endsWith('AGENTS.md')) return false;
-            if (norm.endsWith('copilot-instructions.md')) return false;
-            if (norm.endsWith('README.md') || norm.endsWith('Readme.md') || norm.endsWith('readme.md')) return false;
-            return true;
-        });
-        mockReadFileSync.mockImplementation((p: string) => {
-            if (p.includes('package.json')) return JSON.stringify({ name: 'test' });
-            return '';
-        });
-        mockReaddirSync.mockReturnValue([]);
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-
-        const result = handleScoutCommand();
-        expect(result.diff).toBeNull();
-    });
-
-    it('should strip full diffs from scout diff output (stagedDiff/unstagedDiff removed)', () => {
-        setupBasicProject();
-        // Even if handleDiffCommand returned these, scout should delete them
-        const result = handleScoutCommand();
-        if (result.diff) {
-            expect(result.diff.stagedDiff).toBeUndefined();
-            expect(result.diff.unstagedDiff).toBeUndefined();
-        }
-    });
-
-    it('should set agentRules to null when no rule files exist', () => {
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('.cursorrules')) return false;
-            if (norm.endsWith('CLAUDE.md')) return false;
-            if (norm.endsWith('AGENTS.md')) return false;
-            if (norm.endsWith('copilot-instructions.md')) return false;
-            if (norm.endsWith('README.md') || norm.endsWith('Readme.md') || norm.endsWith('readme.md')) return false;
-            if (norm.endsWith('package.json')) return true;
-            if (norm.endsWith('.git')) return false;
-            if (norm.endsWith('.gitignore')) return false;
-            return true;
-        });
-        mockReadFileSync.mockImplementation((p: string) => {
-            if (p.includes('package.json')) return JSON.stringify({ name: 'test' });
-            return '';
-        });
-        mockReaddirSync.mockReturnValue([]);
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-
-        const result = handleScoutCommand();
-        expect(result.agentRules).toBeNull();
-    });
-
-    it('should detect agent rules from .cursorrules', () => {
-        setupBasicProject();
-        mockExistsSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('.cursorrules')) return true;
-            if (norm.endsWith('package.json')) return true;
-            if (norm.endsWith('.git')) return true;
-            if (norm.endsWith('README.md')) return true;
-            if (norm.endsWith('.gitignore')) return false;
-            if (norm.endsWith('CLAUDE.md')) return false;
-            if (norm.endsWith('AGENTS.md')) return false;
-            if (norm.endsWith('copilot-instructions.md')) return false;
-            if (norm.endsWith('Readme.md') || norm.endsWith('readme.md')) return false;
-            return true;
-        });
-        mockReadFileSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('.cursorrules')) return 'Use TypeScript strict mode';
-            if (norm.endsWith('package.json')) return JSON.stringify({ name: 'test', dependencies: {} });
-            if (norm.endsWith('README.md')) return '# Test';
-            return '';
-        });
-
-        const result = handleScoutCommand();
-        expect(result.agentRules).toBeDefined();
-        expect(result.agentRules.source).toBe('.cursorrules');
-        expect(result.agentRules.content).toContain('TypeScript strict mode');
-    });
-
-    it('should pass budget allocation to tree (approx 50%)', () => {
-        setupBasicProject();
-        // We verify that tree gets called with a budget argument
-        // by checking the result completes without error with a budget
-        const result = handleScoutCommand(1000);
-        expect(result.tree).toBeDefined();
-    });
-
-    it('should set workspaces to null when not present', () => {
-        setupBasicProject();
-        const result = handleScoutCommand();
-        expect(result.workspaces).toBeNull();
-    });
-});

package/tests/tree.test.ts

@@ -1,222 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleTreeCommand } from '../src/commands/tree';
-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(),
-        readdirSync: vi.fn(),
-        statSync: vi.fn()
-    };
-});
-
-const mockExistsSync = fs.existsSync as any;
-const mockReadFileSync = fs.readFileSync as any;
-const mockReaddirSync = fs.readdirSync as any;
-const mockStatSync = fs.statSync as any;
-
-// Helper to build a virtual filesystem
-function setupVirtualFS(tree: Record<string, 'dir' | 'file' | null>) {
-    mockExistsSync.mockImplementation((p: string) => {
-        // Normalize path separators for matching
-        const normalized = p.replace(/\\/g, '/');
-        // Check .gitignore existence
-        if (normalized.endsWith('.gitignore')) {
-            return tree['.gitignore'] !== undefined;
-        }
-        return true; // default: exists
-    });
-
-    mockReaddirSync.mockImplementation((dirPath: string) => {
-        const normalized = dirPath.replace(/\\/g, '/');
-        const entries: string[] = [];
-        for (const [key, type] of Object.entries(tree)) {
-            // Get entries that are direct children of dirPath
-            const parent = key.substring(0, key.lastIndexOf('/'));
-            const name = key.substring(key.lastIndexOf('/') + 1);
-            if (!key.includes('/') && type !== null) {
-                // Root-level entries
-                entries.push(key);
-            }
-        }
-        return entries;
-    });
-
-    mockStatSync.mockImplementation((p: string, opts?: any) => {
-        const normalized = p.replace(/\\/g, '/');
-        const name = normalized.substring(normalized.lastIndexOf('/') + 1);
-        const entry = tree[name];
-        if (entry === 'dir') return { isDirectory: () => true };
-        if (entry === 'file') return { isDirectory: () => false };
-        // Default: file
-        return { isDirectory: () => false };
-    });
-}
-
-describe('Tree Command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Default: no .gitignore
-        mockReadFileSync.mockReturnValue('');
-    });
-
-    it('should throw when target directory does not exist', () => {
-        mockExistsSync.mockReturnValue(false);
-        expect(() => handleTreeCommand(['nonexistent'])).toThrow('Directory not found: nonexistent');
-    });
-
-    it('should return tree structure with files and directories', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue(''); // empty .gitignore
-
-        // Root has: src/ (dir), README.md (file), package.json (file)
-        mockReaddirSync.mockImplementation((dirPath: string) => {
-            const normalized = dirPath.replace(/\\/g, '/');
-            if (normalized.endsWith('src')) return ['index.ts', 'utils.ts'];
-            return ['src', 'README.md', 'package.json'];
-        });
-
-        mockStatSync.mockImplementation((p: string, opts?: any) => {
-            const normalized = p.replace(/\\/g, '/');
-            if (normalized.endsWith('src')) return { isDirectory: () => true };
-            return { isDirectory: () => false };
-        });
-
-        const result = handleTreeCommand([]);
-        expect(result.root).toBe('.');
-        expect(result.depth).toBe(3);
-        expect(result.structure).toBeDefined();
-        expect(result.stats.totalFiles).toBeGreaterThan(0);
-    });
-
-    it('should respect --depth flag', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('');
-
-        mockReaddirSync.mockImplementation((dirPath: string) => {
-            const norm = dirPath.replace(/\\/g, '/');
-            if (norm.endsWith('deep')) return ['deeper'];
-            if (norm.endsWith('deeper')) return ['deepest.txt'];
-            return ['deep'];
-        });
-
-        mockStatSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('deep') || norm.endsWith('deeper')) return { isDirectory: () => true };
-            return { isDirectory: () => false };
-        });
-
-        // depth=1 should not traverse into subdirs beyond first level
-        const result = handleTreeCommand(['--depth=1']);
-        expect(result.depth).toBe(1);
-        // 'deep/' at depth 1, its children are at depth 2 which exceeds limit
-        expect(result.structure['deep/']).toEqual({ _more: true });
-    });
-
-    it('should ignore default directories (node_modules, .git, dist)', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('');
-
-        mockReaddirSync.mockReturnValue(['src', 'node_modules', '.git', 'dist', 'index.ts']);
-
-        mockStatSync.mockImplementation((p: string) => {
-            const name = p.replace(/\\/g, '/').split('/').pop();
-            if (['src', 'node_modules', '.git', 'dist'].includes(name!)) {
-                return { isDirectory: () => true };
-            }
-            return { isDirectory: () => false };
-        });
-
-        const result = handleTreeCommand([]);
-        // node_modules, .git, dist should be in ignored list
-        expect(result.stats.ignored).toContain('node_modules');
-        expect(result.stats.ignored).toContain('.git');
-        expect(result.stats.ignored).toContain('dist');
-    });
-
-    it('should respect .gitignore patterns', () => {
-        mockExistsSync.mockReturnValue(true);
-        // .gitignore ignores "*.log" and "build/"
-        mockReadFileSync.mockReturnValue('*.log\nbuild/\n');
-
-        mockReaddirSync.mockReturnValue(['src', 'build', 'app.ts', 'debug.log']);
-
-        mockStatSync.mockImplementation((p: string) => {
-            const name = p.replace(/\\/g, '/').split('/').pop();
-            if (['src', 'build'].includes(name!)) return { isDirectory: () => true };
-            return { isDirectory: () => false };
-        });
-
-        const result = handleTreeCommand([]);
-        // build should be ignored (from .gitignore), debug.log should be ignored (*.log pattern)
-        expect(result.stats.ignored).toContain('build');
-    });
-
-    it('should use _files compression for directories with only files', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('');
-
-        // Root has only files
-        mockReaddirSync.mockReturnValue(['a.ts', 'b.ts', 'c.ts']);
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-
-        const result = handleTreeCommand([]);
-        // When a dir has only files, it uses the _files array optimization
-        expect(result.structure._files).toEqual(['a.ts', 'b.ts', 'c.ts']);
-    });
-
-    it('should handle empty directories', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('');
-        mockReaddirSync.mockReturnValue([]);
-
-        const result = handleTreeCommand([]);
-        expect(result.structure).toEqual({});
-        expect(result.stats.totalFiles).toBe(0);
-    });
-
-    it('should accept custom target directory', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('');
-        mockReaddirSync.mockReturnValue(['app.ts']);
-        mockStatSync.mockReturnValue({ isDirectory: () => false });
-
-        const result = handleTreeCommand(['src']);
-        expect(result.root).toBe('src');
-    });
-
-    it('should handle permission errors on directories', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('');
-        mockReaddirSync.mockImplementation(() => { throw new Error('EACCES'); });
-
-        const result = handleTreeCommand([]);
-        // Should return empty structure, not throw
-        expect(result.structure).toEqual({});
-    });
-
-    it('should handle mixed directories and files', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('');
-
-        mockReaddirSync.mockImplementation((dirPath: string) => {
-            const norm = dirPath.replace(/\\/g, '/');
-            if (norm.endsWith('utils')) return ['helper.ts'];
-            return ['utils', 'index.ts', 'config.ts'];
-        });
-
-        mockStatSync.mockImplementation((p: string) => {
-            const norm = p.replace(/\\/g, '/');
-            if (norm.endsWith('utils')) return { isDirectory: () => true };
-            return { isDirectory: () => false };
-        });
-
-        const result = handleTreeCommand([]);
-        // Mixed dir: files should be individual keys, not in _files
-        expect(result.structure['utils/']).toBeDefined();
-        expect(result.structure['index.ts']).toBeDefined();
-    });
-});