aiseerr 1.0.0

package/tests/scout.test.ts

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

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

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "outDir": "./dist"
+    },
+    "include": [
+        "src/**/*"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/cli.ts'],
+    format: ['cjs'],
+    target: 'node18',
+    clean: true,
+    minify: true,
+    // We bundle everything so there are zero dependencies at runtime
+    noExternal: [/(.*)/],
+});