aiseerr 1.0.0

package/tests/env.test.ts

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

@@ -0,0 +1,164 @@
+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('aiseerr');
+        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('aiseerr: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<!-- aiseerr:start -->\nstuff\n<!-- aiseerr: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('aiseerr: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('<!-- aiseerr:start -->');
+        expect(content).toContain('<!-- aiseerr:end -->');
+        expect(content).toContain('npx aiseerr scout --budget=2000');
+        expect(content).toContain('npx aiseerr diff --full');
+    });
+});

package/tests/output.test.ts

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

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