codeep 1.2.17 → 1.2.19

package/dist/utils/agent.test.js

@@ -1,315 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-// Mock 'fs' before importing the module under test - use importOriginal to
-// preserve all fs exports that transitive dependencies need (e.g. mkdirSync).
-vi.mock('fs', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        existsSync: vi.fn(),
-        readFileSync: vi.fn(),
-    };
-});
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { loadProjectRules, formatAgentResult, formatChatHistoryForAgent } from './agent.js';
-// Cast mocked functions for convenience
-const mockExistsSync = existsSync;
-const mockReadFileSync = readFileSync;
-describe('loadProjectRules', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('should return formatted rules when .codeep/rules.md exists', () => {
-        const projectRoot = '/my/project';
-        const rulesContent = 'Always use TypeScript.\nNo console.log in production.';
-        mockExistsSync.mockImplementation((filePath) => {
-            return filePath === join(projectRoot, '.codeep', 'rules.md');
-        });
-        mockReadFileSync.mockReturnValue(rulesContent);
-        const result = loadProjectRules(projectRoot);
-        expect(result).toContain('## Project Rules');
-        expect(result).toContain('Always use TypeScript.');
-        expect(result).toContain('No console.log in production.');
-        expect(mockExistsSync).toHaveBeenCalledWith(join(projectRoot, '.codeep', 'rules.md'));
-        expect(mockReadFileSync).toHaveBeenCalledWith(join(projectRoot, '.codeep', 'rules.md'), 'utf-8');
-    });
-    it('should fall back to CODEEP.md when .codeep/rules.md does not exist', () => {
-        const projectRoot = '/my/project';
-        const rulesContent = 'Follow the style guide.';
-        mockExistsSync.mockImplementation((filePath) => {
-            return filePath === join(projectRoot, 'CODEEP.md');
-        });
-        mockReadFileSync.mockReturnValue(rulesContent);
-        const result = loadProjectRules(projectRoot);
-        expect(result).toContain('## Project Rules');
-        expect(result).toContain('Follow the style guide.');
-        // Should have checked .codeep/rules.md first
-        expect(mockExistsSync).toHaveBeenCalledWith(join(projectRoot, '.codeep', 'rules.md'));
-        // Then checked CODEEP.md
-        expect(mockExistsSync).toHaveBeenCalledWith(join(projectRoot, 'CODEEP.md'));
-        expect(mockReadFileSync).toHaveBeenCalledWith(join(projectRoot, 'CODEEP.md'), 'utf-8');
-    });
-    it('should return empty string when neither rules file exists', () => {
-        const projectRoot = '/my/project';
-        mockExistsSync.mockReturnValue(false);
-        const result = loadProjectRules(projectRoot);
-        expect(result).toBe('');
-        expect(mockExistsSync).toHaveBeenCalledTimes(2);
-        expect(mockReadFileSync).not.toHaveBeenCalled();
-    });
-    it('should return empty string when rules file exists but is empty', () => {
-        const projectRoot = '/my/project';
-        mockExistsSync.mockImplementation((filePath) => {
-            return filePath === join(projectRoot, '.codeep', 'rules.md');
-        });
-        mockReadFileSync.mockReturnValue('   \n  \n  ');
-        const result = loadProjectRules(projectRoot);
-        // Empty after trim, so should skip and check next candidate
-        expect(mockExistsSync).toHaveBeenCalledWith(join(projectRoot, '.codeep', 'rules.md'));
-        // Since the first file was empty (whitespace-only), it checks the second
-        expect(mockExistsSync).toHaveBeenCalledWith(join(projectRoot, 'CODEEP.md'));
-    });
-    it('should return empty string when both files exist but are empty', () => {
-        const projectRoot = '/my/project';
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('   ');
-        const result = loadProjectRules(projectRoot);
-        expect(result).toBe('');
-    });
-    it('should return empty string when readFileSync throws an error', () => {
-        const projectRoot = '/my/project';
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockImplementation(() => {
-            throw new Error('EACCES: permission denied');
-        });
-        const result = loadProjectRules(projectRoot);
-        // Both candidates exist but both throw on read, so should return ''
-        expect(result).toBe('');
-        // Should have attempted to read both files
-        expect(mockReadFileSync).toHaveBeenCalledTimes(2);
-    });
-    it('should fall back to CODEEP.md when .codeep/rules.md read throws', () => {
-        const projectRoot = '/my/project';
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockImplementation((filePath) => {
-            if (filePath === join(projectRoot, '.codeep', 'rules.md')) {
-                throw new Error('EACCES: permission denied');
-            }
-            return 'Fallback rules content';
-        });
-        const result = loadProjectRules(projectRoot);
-        expect(result).toContain('## Project Rules');
-        expect(result).toContain('Fallback rules content');
-        expect(mockReadFileSync).toHaveBeenCalledTimes(2);
-    });
-    it('should prefer .codeep/rules.md over CODEEP.md when both exist', () => {
-        const projectRoot = '/my/project';
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockImplementation((filePath) => {
-            if (filePath === join(projectRoot, '.codeep', 'rules.md')) {
-                return 'Primary rules';
-            }
-            return 'Secondary rules';
-        });
-        const result = loadProjectRules(projectRoot);
-        expect(result).toContain('Primary rules');
-        expect(result).not.toContain('Secondary rules');
-        // Should only read the first file since it had content
-        expect(mockReadFileSync).toHaveBeenCalledTimes(1);
-    });
-    it('should include the MUST follow preamble in the returned string', () => {
-        const projectRoot = '/my/project';
-        mockExistsSync.mockImplementation((filePath) => {
-            return filePath === join(projectRoot, '.codeep', 'rules.md');
-        });
-        mockReadFileSync.mockReturnValue('Some rules');
-        const result = loadProjectRules(projectRoot);
-        expect(result).toContain('You MUST follow these rules');
-    });
-});
-describe('formatAgentResult', () => {
-    it('should format a successful result with iterations', () => {
-        const result = {
-            success: true,
-            iterations: 3,
-            actions: [],
-            finalResponse: 'All done',
-        };
-        const formatted = formatAgentResult(result);
-        expect(formatted).toContain('Agent completed in 3 iteration(s)');
-    });
-    it('should format a failed result with error message', () => {
-        const result = {
-            success: false,
-            iterations: 5,
-            actions: [],
-            finalResponse: '',
-            error: 'Exceeded maximum duration',
-        };
-        const formatted = formatAgentResult(result);
-        expect(formatted).toContain('Agent failed: Exceeded maximum duration');
-    });
-    it('should format an aborted result', () => {
-        const result = {
-            success: false,
-            iterations: 2,
-            actions: [],
-            finalResponse: 'Agent was stopped by user',
-            aborted: true,
-        };
-        const formatted = formatAgentResult(result);
-        expect(formatted).toContain('Agent was stopped by user');
-    });
-    it('should list actions when present', () => {
-        const result = {
-            success: true,
-            iterations: 2,
-            actions: [
-                { type: 'read', target: 'src/index.ts', result: 'success', timestamp: Date.now() },
-                { type: 'write', target: 'src/new-file.ts', result: 'success', timestamp: Date.now() },
-                { type: 'command', target: 'npm install', result: 'error', timestamp: Date.now() },
-            ],
-            finalResponse: 'Done',
-        };
-        const formatted = formatAgentResult(result);
-        expect(formatted).toContain('Actions performed:');
-        expect(formatted).toContain('read: src/index.ts');
-        expect(formatted).toContain('write: src/new-file.ts');
-        expect(formatted).toContain('command: npm install');
-    });
-    it('should show check mark for successful actions and cross for errors', () => {
-        const result = {
-            success: true,
-            iterations: 1,
-            actions: [
-                { type: 'write', target: 'file.ts', result: 'success', timestamp: Date.now() },
-                { type: 'edit', target: 'other.ts', result: 'error', timestamp: Date.now() },
-            ],
-            finalResponse: 'Done',
-        };
-        const formatted = formatAgentResult(result);
-        const lines = formatted.split('\n');
-        const successLine = lines.find(l => l.includes('write: file.ts'));
-        const errorLine = lines.find(l => l.includes('edit: other.ts'));
-        expect(successLine).toMatch(/✓/);
-        expect(errorLine).toMatch(/✗/);
-    });
-    it('should not show actions section when there are no actions', () => {
-        const result = {
-            success: true,
-            iterations: 1,
-            actions: [],
-            finalResponse: 'Nothing to do',
-        };
-        const formatted = formatAgentResult(result);
-        expect(formatted).not.toContain('Actions performed:');
-    });
-    it('should format a failed result without aborted flag', () => {
-        const result = {
-            success: false,
-            iterations: 10,
-            actions: [
-                { type: 'read', target: 'config.json', result: 'success', timestamp: Date.now() },
-            ],
-            finalResponse: '',
-            error: 'Exceeded maximum of 10 iterations',
-        };
-        const formatted = formatAgentResult(result);
-        expect(formatted).toContain('Agent failed: Exceeded maximum of 10 iterations');
-        expect(formatted).toContain('Actions performed:');
-        expect(formatted).toContain('read: config.json');
-    });
-    it('should format result with single iteration correctly', () => {
-        const result = {
-            success: true,
-            iterations: 1,
-            actions: [],
-            finalResponse: 'Quick task',
-        };
-        const formatted = formatAgentResult(result);
-        expect(formatted).toContain('Agent completed in 1 iteration(s)');
-    });
-    it('should handle all action types', () => {
-        const actionTypes = ['read', 'write', 'edit', 'delete', 'command', 'search', 'list', 'mkdir', 'fetch'];
-        const result = {
-            success: true,
-            iterations: 5,
-            actions: actionTypes.map(type => ({
-                type,
-                target: `target-for-${type}`,
-                result: 'success',
-                timestamp: Date.now(),
-            })),
-            finalResponse: 'Done',
-        };
-        const formatted = formatAgentResult(result);
-        for (const type of actionTypes) {
-            expect(formatted).toContain(`${type}: target-for-${type}`);
-        }
-    });
-});
-describe('formatChatHistoryForAgent', () => {
-    it('should return empty string for undefined input', () => {
-        expect(formatChatHistoryForAgent(undefined)).toBe('');
-    });
-    it('should return empty string for empty array', () => {
-        expect(formatChatHistoryForAgent([])).toBe('');
-    });
-    it('should format simple chat history', () => {
-        const history = [
-            { role: 'user', content: 'How do I fix the login bug?' },
-            { role: 'assistant', content: 'Check the auth middleware in src/auth.ts' },
-        ];
-        const result = formatChatHistoryForAgent(history);
-        expect(result).toContain('## Prior Conversation Context');
-        expect(result).toContain('**User:** How do I fix the login bug?');
-        expect(result).toContain('**Assistant:** Check the auth middleware in src/auth.ts');
-    });
-    it('should filter out [AGENT] messages', () => {
-        const history = [
-            { role: 'user', content: 'Hello' },
-            { role: 'user', content: '[AGENT] fix the bug' },
-            { role: 'assistant', content: 'Agent completed in 3 iteration(s)' },
-            { role: 'user', content: 'Thanks' },
-        ];
-        const result = formatChatHistoryForAgent(history);
-        expect(result).toContain('**User:** Hello');
-        expect(result).toContain('**User:** Thanks');
-        expect(result).not.toContain('[AGENT]');
-        expect(result).not.toContain('Agent completed');
-    });
-    it('should filter out [DRY RUN] messages', () => {
-        const history = [
-            { role: 'user', content: '[DRY RUN] test task' },
-        ];
-        const result = formatChatHistoryForAgent(history);
-        expect(result).toBe('');
-    });
-    it('should filter out Agent failed/stopped messages', () => {
-        const history = [
-            { role: 'assistant', content: 'Agent failed: timeout' },
-            { role: 'assistant', content: 'Agent stopped by user' },
-        ];
-        const result = formatChatHistoryForAgent(history);
-        expect(result).toBe('');
-    });
-    it('should respect character budget and keep newest messages', () => {
-        const history = [
-            { role: 'user', content: 'A'.repeat(5000) },
-            { role: 'assistant', content: 'B'.repeat(5000) },
-            { role: 'user', content: 'Most recent message' },
-        ];
-        const result = formatChatHistoryForAgent(history, 6000);
-        expect(result).toContain('Most recent message');
-        // The first 5000-char message should be dropped due to budget
-        expect(result).not.toContain('AAAAA');
-    });
-    it('should truncate a single very long message', () => {
-        const history = [
-            { role: 'user', content: 'X'.repeat(20000) },
-        ];
-        const result = formatChatHistoryForAgent(history, 8000);
-        expect(result).toContain('[truncated]');
-        expect(result.length).toBeLessThan(9000);
-    });
-});

package/dist/utils/git.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/git.test.js

@@ -1,193 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { execSync } from 'child_process';
-import { mkdirSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { isGitRepository, getGitStatus, getGitDiff, getChangedFiles, suggestCommitMessage, createCommit, stageAll, formatDiffForDisplay, } from './git.js';
-// Create a temp directory for git tests
-const TEST_DIR = join(tmpdir(), 'codeep-git-test-' + Date.now());
-const NON_GIT_DIR = join(tmpdir(), 'codeep-non-git-test-' + Date.now());
-describe('git utilities', () => {
-    beforeEach(() => {
-        // Create test directories
-        mkdirSync(TEST_DIR, { recursive: true });
-        mkdirSync(NON_GIT_DIR, { recursive: true });
-        // Initialize git repo in TEST_DIR
-        execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
-        execSync('git config user.email "test@test.com"', { cwd: TEST_DIR, stdio: 'ignore' });
-        execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
-    });
-    afterEach(() => {
-        // Cleanup
-        try {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-            rmSync(NON_GIT_DIR, { recursive: true, force: true });
-        }
-        catch { }
-    });
-    describe('isGitRepository', () => {
-        it('should return true for git repository', () => {
-            expect(isGitRepository(TEST_DIR)).toBe(true);
-        });
-        it('should return false for non-git directory', () => {
-            expect(isGitRepository(NON_GIT_DIR)).toBe(false);
-        });
-        it('should return false for non-existent directory', () => {
-            expect(isGitRepository('/non/existent/path')).toBe(false);
-        });
-    });
-    describe('getGitStatus', () => {
-        it('should return isRepo: false for non-git directory', () => {
-            const status = getGitStatus(NON_GIT_DIR);
-            expect(status.isRepo).toBe(false);
-        });
-        it('should return correct status for git repo', () => {
-            // Create initial commit so we have a branch
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
-            const status = getGitStatus(TEST_DIR);
-            expect(status.isRepo).toBe(true);
-            expect(status.branch).toBeDefined();
-            expect(status.hasChanges).toBe(false);
-        });
-        it('should detect changes', () => {
-            // Create initial commit
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
-            // Make a change
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello world');
-            const status = getGitStatus(TEST_DIR);
-            expect(status.hasChanges).toBe(true);
-        });
-    });
-    describe('getGitDiff', () => {
-        it('should return error for non-git directory', () => {
-            const result = getGitDiff(false, NON_GIT_DIR);
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('Not a git repository');
-        });
-        it('should return empty diff when no changes', () => {
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
-            const result = getGitDiff(false, TEST_DIR);
-            expect(result.success).toBe(true);
-            expect(result.diff).toBe('');
-        });
-        it('should return diff for unstaged changes', () => {
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello world');
-            const result = getGitDiff(false, TEST_DIR);
-            expect(result.success).toBe(true);
-            expect(result.diff).toContain('hello world');
-        });
-        it('should return diff for staged changes', () => {
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello world');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            const result = getGitDiff(true, TEST_DIR);
-            expect(result.success).toBe(true);
-            expect(result.diff).toContain('hello world');
-        });
-    });
-    describe('getChangedFiles', () => {
-        it('should return empty array for non-git directory', () => {
-            expect(getChangedFiles(NON_GIT_DIR)).toEqual([]);
-        });
-        it('should return changed files', () => {
-            writeFileSync(join(TEST_DIR, 'file1.txt'), 'content1');
-            writeFileSync(join(TEST_DIR, 'file2.txt'), 'content2');
-            const files = getChangedFiles(TEST_DIR);
-            expect(files).toContain('file1.txt');
-            expect(files).toContain('file2.txt');
-        });
-    });
-    describe('suggestCommitMessage', () => {
-        it('should suggest feat for new files', () => {
-            const diff = 'new file mode 100644\n+++ b/newfile.ts';
-            expect(suggestCommitMessage(diff)).toBe('feat: add new files');
-        });
-        it('should suggest chore for deleted files', () => {
-            const diff = 'deleted file mode 100644\n--- a/oldfile.ts';
-            expect(suggestCommitMessage(diff)).toBe('chore: remove files');
-        });
-        it('should suggest chore for package.json changes', () => {
-            const diff = '+++ b/package.json\n+  "new-dep": "1.0.0"';
-            expect(suggestCommitMessage(diff)).toBe('chore: update dependencies');
-        });
-        it('should suggest docs for README changes', () => {
-            const diff = '+++ b/README.md\n+ New documentation';
-            expect(suggestCommitMessage(diff)).toBe('docs: update documentation');
-        });
-        it('should suggest test for test file changes', () => {
-            const diff = '+++ b/utils.test.ts\n+ test case';
-            expect(suggestCommitMessage(diff)).toBe('test: update tests');
-        });
-    });
-    describe('createCommit', () => {
-        it('should return error for non-git directory', () => {
-            const result = createCommit('test message', NON_GIT_DIR);
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('Not a git repository');
-        });
-        it('should return error when no staged changes', () => {
-            const result = createCommit('test message', TEST_DIR);
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('No staged changes to commit');
-        });
-        it('should create commit successfully', () => {
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            const result = createCommit('test commit message', TEST_DIR);
-            expect(result.success).toBe(true);
-            expect(result.hash).toBeDefined();
-            expect(result.hash.length).toBeGreaterThan(0);
-        });
-        it('should handle special characters in commit message safely', () => {
-            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
-            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
-            // Test with potentially dangerous characters that could cause shell injection
-            const dangerousMessage = 'test `whoami` $(echo dangerous) ; rm -rf /';
-            const result = createCommit(dangerousMessage, TEST_DIR);
-            expect(result.success).toBe(true);
-            // Verify the commit message was stored correctly (not executed)
-            const log = execSync('git log -1 --format=%s', { cwd: TEST_DIR, encoding: 'utf-8' });
-            expect(log.trim()).toBe(dangerousMessage);
-        });
-    });
-    describe('stageAll', () => {
-        it('should return false for non-git directory', () => {
-            expect(stageAll(NON_GIT_DIR)).toBe(false);
-        });
-        it('should stage all files', () => {
-            writeFileSync(join(TEST_DIR, 'file1.txt'), 'content1');
-            writeFileSync(join(TEST_DIR, 'file2.txt'), 'content2');
-            expect(stageAll(TEST_DIR)).toBe(true);
-            // Verify files are staged
-            const staged = execSync('git diff --cached --name-only', { cwd: TEST_DIR, encoding: 'utf-8' });
-            expect(staged).toContain('file1.txt');
-            expect(staged).toContain('file2.txt');
-        });
-    });
-    describe('formatDiffForDisplay', () => {
-        it('should return full diff if under limit', () => {
-            const diff = 'line1\nline2\nline3';
-            expect(formatDiffForDisplay(diff, 10)).toBe(diff);
-        });
-        it('should truncate long diffs', () => {
-            const lines = Array.from({ length: 100 }, (_, i) => `line${i}`);
-            const diff = lines.join('\n');
-            const result = formatDiffForDisplay(diff, 10);
-            expect(result).toContain('line0');
-            expect(result).toContain('line9');
-            expect(result).not.toContain('line99');
-            expect(result).toContain('90 more lines');
-        });
-    });
-});

package/dist/utils/gitignore.test.d.ts

@@ -1 +0,0 @@
-export {};