codeep 1.2.17 → 1.2.18

package/dist/utils/gitignore.test.js

@@ -1,167 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock fs
-vi.mock('fs', () => ({
-    existsSync: vi.fn(),
-    readFileSync: vi.fn(),
-}));
-import { existsSync, readFileSync } from 'fs';
-import { loadIgnoreRules, isIgnored } from './gitignore.js';
-const mockExistsSync = existsSync;
-const mockReadFileSync = readFileSync;
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('loadIgnoreRules', () => {
-    it('returns built-in ignores when no .gitignore exists', () => {
-        mockExistsSync.mockReturnValue(false);
-        const rules = loadIgnoreRules('/project');
-        expect(rules.projectRoot).toBe('/project');
-        expect(rules.patterns.length).toBeGreaterThan(0);
-        // node_modules should be a built-in
-        expect(isIgnored('node_modules/foo.js', rules)).toBe(true);
-    });
-    it('loads .gitignore when it exists', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('*.log\ntmp/\n');
-        const rules = loadIgnoreRules('/project');
-        expect(isIgnored('error.log', rules)).toBe(true);
-        expect(isIgnored('tmp/cache', rules)).toBe(true);
-    });
-    it('handles read errors gracefully', () => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockImplementation(() => { throw new Error('EACCES'); });
-        const rules = loadIgnoreRules('/project');
-        // Should still have built-in ignores
-        expect(rules.patterns.length).toBeGreaterThan(0);
-    });
-});
-describe('isIgnored — built-in ignores', () => {
-    let rules;
-    beforeEach(() => {
-        mockExistsSync.mockReturnValue(false);
-        rules = loadIgnoreRules('/project');
-    });
-    it('ignores node_modules', () => {
-        expect(isIgnored('node_modules/package/index.js', rules)).toBe(true);
-        expect(isIgnored('/project/node_modules', rules)).toBe(true);
-    });
-    it('ignores .git', () => {
-        expect(isIgnored('.git/config', rules)).toBe(true);
-    });
-    it('ignores .codeep', () => {
-        expect(isIgnored('.codeep/state.json', rules)).toBe(true);
-    });
-    it('ignores dist and build', () => {
-        expect(isIgnored('dist/bundle.js', rules)).toBe(true);
-        expect(isIgnored('build/output.js', rules)).toBe(true);
-    });
-    it('ignores __pycache__', () => {
-        expect(isIgnored('src/__pycache__/module.pyc', rules)).toBe(true);
-    });
-    it('ignores .next', () => {
-        expect(isIgnored('.next/static/chunks/main.js', rules)).toBe(true);
-    });
-    it('ignores coverage', () => {
-        expect(isIgnored('coverage/lcov.info', rules)).toBe(true);
-    });
-    it('does not ignore regular source files', () => {
-        expect(isIgnored('src/index.ts', rules)).toBe(false);
-        expect(isIgnored('package.json', rules)).toBe(false);
-        expect(isIgnored('README.md', rules)).toBe(false);
-    });
-    it('does not ignore files that contain ignore names as substrings', () => {
-        expect(isIgnored('src/builder.ts', rules)).toBe(false);
-        expect(isIgnored('src/distribute.ts', rules)).toBe(false);
-    });
-});
-describe('isIgnored — .gitignore patterns', () => {
-    function rulesFrom(gitignore) {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue(gitignore);
-        return loadIgnoreRules('/project');
-    }
-    it('matches simple file patterns', () => {
-        const rules = rulesFrom('*.log');
-        expect(isIgnored('error.log', rules)).toBe(true);
-        expect(isIgnored('logs/debug.log', rules)).toBe(true);
-        expect(isIgnored('error.txt', rules)).toBe(false);
-    });
-    it('matches directory patterns', () => {
-        const rules = rulesFrom('tmp/');
-        expect(isIgnored('tmp/file.txt', rules)).toBe(true);
-        expect(isIgnored('src/tmp/file.txt', rules)).toBe(true);
-    });
-    it('matches anchored patterns (leading /)', () => {
-        const rules = rulesFrom('/config.local');
-        expect(isIgnored('config.local', rules)).toBe(true);
-        expect(isIgnored('sub/config.local', rules)).toBe(false);
-    });
-    it('matches ** glob patterns', () => {
-        const rules = rulesFrom('docs/**/*.md');
-        expect(isIgnored('docs/readme.md', rules)).toBe(true);
-        expect(isIgnored('docs/guides/setup.md', rules)).toBe(true);
-        expect(isIgnored('src/readme.md', rules)).toBe(false);
-    });
-    it('matches ? single char wildcard', () => {
-        const rules = rulesFrom('file?.txt');
-        expect(isIgnored('file1.txt', rules)).toBe(true);
-        expect(isIgnored('fileA.txt', rules)).toBe(true);
-        expect(isIgnored('file10.txt', rules)).toBe(false);
-    });
-    it('matches character classes [...]', () => {
-        const rules = rulesFrom('file[0-9].txt');
-        expect(isIgnored('file5.txt', rules)).toBe(true);
-        expect(isIgnored('fileA.txt', rules)).toBe(false);
-    });
-    it('handles negation patterns', () => {
-        const rules = rulesFrom('*.log\n!important.log');
-        expect(isIgnored('error.log', rules)).toBe(true);
-        expect(isIgnored('important.log', rules)).toBe(false);
-    });
-    it('skips comments and empty lines', () => {
-        const rules = rulesFrom('# this is a comment\n\n*.tmp');
-        expect(isIgnored('file.tmp', rules)).toBe(true);
-        expect(isIgnored('# this is a comment', rules)).toBe(false);
-    });
-    it('handles .env files', () => {
-        const rules = rulesFrom('.env\n.env.local\n.env.*.local');
-        expect(isIgnored('.env', rules)).toBe(true);
-        expect(isIgnored('.env.local', rules)).toBe(true);
-        expect(isIgnored('.env.production.local', rules)).toBe(true);
-        expect(isIgnored('.env.example', rules)).toBe(false);
-    });
-    it('handles complex real-world .gitignore', () => {
-        const rules = rulesFrom([
-            'node_modules/',
-            '*.log',
-            '.env',
-            '/dist',
-            '!dist/keep.txt',
-            '**/*.map',
-        ].join('\n'));
-        expect(isIgnored('app.log', rules)).toBe(true);
-        expect(isIgnored('.env', rules)).toBe(true);
-        expect(isIgnored('dist/bundle.js', rules)).toBe(true);
-        expect(isIgnored('src/utils/helper.js.map', rules)).toBe(true);
-        expect(isIgnored('src/index.ts', rules)).toBe(false);
-    });
-});
-describe('isIgnored — path normalization', () => {
-    let rules;
-    beforeEach(() => {
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('*.log');
-        rules = loadIgnoreRules('/project');
-    });
-    it('handles absolute paths under project root', () => {
-        expect(isIgnored('/project/error.log', rules)).toBe(true);
-        expect(isIgnored('/project/src/debug.log', rules)).toBe(true);
-    });
-    it('handles relative paths', () => {
-        expect(isIgnored('error.log', rules)).toBe(true);
-        expect(isIgnored('src/debug.log', rules)).toBe(true);
-    });
-    it('returns false for empty path', () => {
-        expect(isIgnored('', rules)).toBe(false);
-    });
-});

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

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

package/dist/utils/project.test.js

@@ -1,212 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { isProjectDirectory, getProjectType, scanDirectory, generateTreeStructure, readProjectFile, deleteProjectFile, writeProjectFile, } from './project.js';
-const TEST_DIR = join(tmpdir(), 'codeep-project-test-' + Date.now());
-describe('project utilities', () => {
-    beforeEach(() => {
-        mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterEach(() => {
-        try {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        catch { }
-    });
-    describe('isProjectDirectory', () => {
-        it('should return true for directory with package.json', () => {
-            writeFileSync(join(TEST_DIR, 'package.json'), '{}');
-            expect(isProjectDirectory(TEST_DIR)).toBe(true);
-        });
-        it('should return true for directory with Cargo.toml', () => {
-            writeFileSync(join(TEST_DIR, 'Cargo.toml'), '[package]');
-            expect(isProjectDirectory(TEST_DIR)).toBe(true);
-        });
-        it('should return true for directory with go.mod', () => {
-            writeFileSync(join(TEST_DIR, 'go.mod'), 'module test');
-            expect(isProjectDirectory(TEST_DIR)).toBe(true);
-        });
-        it('should return true for directory with .git', () => {
-            mkdirSync(join(TEST_DIR, '.git'), { recursive: true });
-            expect(isProjectDirectory(TEST_DIR)).toBe(true);
-        });
-        it('should return false for empty directory', () => {
-            expect(isProjectDirectory(TEST_DIR)).toBe(false);
-        });
-    });
-    describe('getProjectType', () => {
-        it('should detect TypeScript project', () => {
-            writeFileSync(join(TEST_DIR, 'package.json'), JSON.stringify({
-                devDependencies: { typescript: '^5.0.0' }
-            }));
-            expect(getProjectType(TEST_DIR)).toBe('TypeScript/Node.js');
-        });
-        it('should detect TypeScript project with tsconfig', () => {
-            writeFileSync(join(TEST_DIR, 'package.json'), '{}');
-            writeFileSync(join(TEST_DIR, 'tsconfig.json'), '{}');
-            expect(getProjectType(TEST_DIR)).toBe('TypeScript/Node.js');
-        });
-        it('should detect JavaScript project', () => {
-            writeFileSync(join(TEST_DIR, 'package.json'), '{}');
-            expect(getProjectType(TEST_DIR)).toBe('JavaScript/Node.js');
-        });
-        it('should detect Rust project', () => {
-            writeFileSync(join(TEST_DIR, 'Cargo.toml'), '[package]');
-            expect(getProjectType(TEST_DIR)).toBe('Rust');
-        });
-        it('should detect Go project', () => {
-            writeFileSync(join(TEST_DIR, 'go.mod'), 'module test');
-            expect(getProjectType(TEST_DIR)).toBe('Go');
-        });
-        it('should detect Python project', () => {
-            writeFileSync(join(TEST_DIR, 'requirements.txt'), 'flask');
-            expect(getProjectType(TEST_DIR)).toBe('Python');
-        });
-        it('should return Unknown for unrecognized project', () => {
-            expect(getProjectType(TEST_DIR)).toBe('Unknown');
-        });
-    });
-    describe('scanDirectory', () => {
-        it('should scan files in directory', () => {
-            writeFileSync(join(TEST_DIR, 'index.ts'), 'export {}');
-            writeFileSync(join(TEST_DIR, 'utils.js'), '// utils');
-            writeFileSync(join(TEST_DIR, 'package.json'), '{}');
-            const files = scanDirectory(TEST_DIR);
-            const names = files.map(f => f.name);
-            expect(names).toContain('index.ts');
-            expect(names).toContain('utils.js');
-            expect(names).toContain('package.json');
-        });
-        it('should ignore node_modules', () => {
-            mkdirSync(join(TEST_DIR, 'node_modules'), { recursive: true });
-            writeFileSync(join(TEST_DIR, 'node_modules', 'dep.js'), '// dep');
-            writeFileSync(join(TEST_DIR, 'index.ts'), 'export {}');
-            const files = scanDirectory(TEST_DIR);
-            const paths = files.map(f => f.relativePath);
-            expect(paths).not.toContain('node_modules/dep.js');
-            expect(paths.some(p => p.includes('node_modules'))).toBe(false);
-        });
-        it('should ignore .git directory', () => {
-            mkdirSync(join(TEST_DIR, '.git'), { recursive: true });
-            writeFileSync(join(TEST_DIR, '.git', 'config'), '# git config');
-            const files = scanDirectory(TEST_DIR);
-            const paths = files.map(f => f.relativePath);
-            expect(paths.some(p => p.includes('.git'))).toBe(false);
-        });
-        it('should respect maxDepth', () => {
-            mkdirSync(join(TEST_DIR, 'a', 'b', 'c', 'd'), { recursive: true });
-            writeFileSync(join(TEST_DIR, 'a', 'b', 'c', 'd', 'deep.ts'), '// deep');
-            writeFileSync(join(TEST_DIR, 'a', 'shallow.ts'), '// shallow');
-            const files = scanDirectory(TEST_DIR, 2);
-            const names = files.map(f => f.name);
-            expect(names).toContain('shallow.ts');
-            expect(names).not.toContain('deep.ts');
-        });
-        it('should include directories in results', () => {
-            mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
-            writeFileSync(join(TEST_DIR, 'src', 'index.ts'), 'export {}');
-            const files = scanDirectory(TEST_DIR);
-            const dirs = files.filter(f => f.isDirectory);
-            expect(dirs.some(d => d.name === 'src')).toBe(true);
-        });
-    });
-    describe('generateTreeStructure', () => {
-        it('should generate tree structure', () => {
-            mkdirSync(join(TEST_DIR, 'src'), { recursive: true });
-            writeFileSync(join(TEST_DIR, 'src', 'index.ts'), 'export {}');
-            writeFileSync(join(TEST_DIR, 'package.json'), '{}');
-            const files = scanDirectory(TEST_DIR);
-            const tree = generateTreeStructure(files);
-            expect(tree).toContain('src/');
-            expect(tree).toContain('index.ts');
-            expect(tree).toContain('package.json');
-        });
-        it('should truncate when exceeding maxLines', () => {
-            // Create many files
-            for (let i = 0; i < 50; i++) {
-                writeFileSync(join(TEST_DIR, `file${i}.ts`), '// file');
-            }
-            const files = scanDirectory(TEST_DIR);
-            const tree = generateTreeStructure(files, 10);
-            // The function uses "(+N more)" format for truncation
-            expect(tree).toContain('more');
-        });
-    });
-    describe('readProjectFile', () => {
-        it('should read file content', () => {
-            const content = 'export const hello = "world";';
-            writeFileSync(join(TEST_DIR, 'test.ts'), content);
-            const result = readProjectFile(join(TEST_DIR, 'test.ts'));
-            expect(result).not.toBeNull();
-            expect(result.content).toBe(content);
-            expect(result.truncated).toBe(false);
-        });
-        it('should return null for non-existent file', () => {
-            const result = readProjectFile(join(TEST_DIR, 'nonexistent.ts'));
-            expect(result).toBeNull();
-        });
-        it('should return null for directories', () => {
-            mkdirSync(join(TEST_DIR, 'subdir'), { recursive: true });
-            const result = readProjectFile(join(TEST_DIR, 'subdir'));
-            expect(result).toBeNull();
-        });
-        it('should truncate large files', () => {
-            // File size is 60000 bytes, maxSize is 50000
-            // Function skips files > maxSize * 2 (100000), so 60000 should be read and truncated
-            const largeContent = 'x'.repeat(60000);
-            writeFileSync(join(TEST_DIR, 'large.ts'), largeContent);
-            const result = readProjectFile(join(TEST_DIR, 'large.ts'), 50000);
-            expect(result).not.toBeNull();
-            expect(result.truncated).toBe(true);
-            expect(result.content.length).toBeLessThan(largeContent.length);
-            expect(result.content).toContain('truncated');
-        });
-        it('should skip very large files', () => {
-            const hugeContent = 'x'.repeat(200000);
-            writeFileSync(join(TEST_DIR, 'huge.ts'), hugeContent);
-            const result = readProjectFile(join(TEST_DIR, 'huge.ts'), 50000);
-            expect(result).toBeNull();
-        });
-    });
-    describe('writeProjectFile', () => {
-        it('should write file content', () => {
-            const filePath = join(TEST_DIR, 'output.ts');
-            const content = 'export const test = true;';
-            const result = writeProjectFile(filePath, content);
-            expect(result.success).toBe(true);
-            const written = readProjectFile(filePath);
-            expect(written.content).toBe(content);
-        });
-        it('should create parent directories', () => {
-            const filePath = join(TEST_DIR, 'new', 'nested', 'dir', 'file.ts');
-            const content = '// nested file';
-            const result = writeProjectFile(filePath, content);
-            expect(result.success).toBe(true);
-            const written = readProjectFile(filePath);
-            expect(written.content).toBe(content);
-        });
-        it('should overwrite existing file', () => {
-            const filePath = join(TEST_DIR, 'existing.ts');
-            writeFileSync(filePath, 'old content');
-            const result = writeProjectFile(filePath, 'new content');
-            expect(result.success).toBe(true);
-            const written = readProjectFile(filePath);
-            expect(written.content).toBe('new content');
-        });
-    });
-    describe('deleteProjectFile', () => {
-        it('should delete existing file', () => {
-            const filePath = join(TEST_DIR, 'to-delete.ts');
-            writeFileSync(filePath, 'delete me');
-            const result = deleteProjectFile(filePath);
-            expect(result.success).toBe(true);
-            expect(readProjectFile(filePath)).toBeNull();
-        });
-        it('should return error for non-existent file', () => {
-            const result = deleteProjectFile(join(TEST_DIR, 'nonexistent.ts'));
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('does not exist');
-        });
-    });
-});

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

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

package/dist/utils/ratelimit.test.js

@@ -1,131 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { checkApiRateLimit, checkCommandRateLimit, resetRateLimits, getRateLimitStatus, } from './ratelimit.js';
-describe('ratelimit utilities', () => {
-    beforeEach(() => {
-        // Reset rate limiters before each test
-        resetRateLimits();
-    });
-    describe('checkApiRateLimit', () => {
-        it('should allow requests under limit', () => {
-            const result = checkApiRateLimit();
-            expect(result.allowed).toBe(true);
-            expect(result.message).toBeUndefined();
-        });
-        it('should track request count', () => {
-            // Make some requests
-            checkApiRateLimit();
-            checkApiRateLimit();
-            checkApiRateLimit();
-            const status = getRateLimitStatus();
-            expect(status.api.count).toBe(3);
-        });
-        it('should block requests over limit', () => {
-            // Make requests up to the limit (default 30)
-            for (let i = 0; i < 30; i++) {
-                const result = checkApiRateLimit();
-                expect(result.allowed).toBe(true);
-            }
-            // Next request should be blocked
-            const result = checkApiRateLimit();
-            expect(result.allowed).toBe(false);
-            expect(result.message).toContain('Rate limit exceeded');
-        });
-        it('should include retry message when blocked', () => {
-            // Fill up the limit
-            for (let i = 0; i < 30; i++) {
-                checkApiRateLimit();
-            }
-            const result = checkApiRateLimit();
-            expect(result.message).toContain('Please wait');
-        });
-    });
-    describe('checkCommandRateLimit', () => {
-        it('should allow commands under limit', () => {
-            const result = checkCommandRateLimit();
-            expect(result.allowed).toBe(true);
-        });
-        it('should track command count', () => {
-            checkCommandRateLimit();
-            checkCommandRateLimit();
-            const status = getRateLimitStatus();
-            expect(status.commands.count).toBe(2);
-        });
-        it('should block commands over limit', () => {
-            // Make commands up to the limit (default 100)
-            for (let i = 0; i < 100; i++) {
-                checkCommandRateLimit();
-            }
-            const result = checkCommandRateLimit();
-            expect(result.allowed).toBe(false);
-            expect(result.message).toContain('Too many commands');
-        });
-    });
-    describe('resetRateLimits', () => {
-        it('should reset all counters', () => {
-            // Make some requests
-            checkApiRateLimit();
-            checkApiRateLimit();
-            checkCommandRateLimit();
-            checkCommandRateLimit();
-            checkCommandRateLimit();
-            let status = getRateLimitStatus();
-            expect(status.api.count).toBe(2);
-            expect(status.commands.count).toBe(3);
-            // Reset
-            resetRateLimits();
-            status = getRateLimitStatus();
-            expect(status.api.count).toBe(0);
-            expect(status.commands.count).toBe(0);
-        });
-        it('should allow requests after reset', () => {
-            // Fill up the limit
-            for (let i = 0; i < 30; i++) {
-                checkApiRateLimit();
-            }
-            // Should be blocked
-            expect(checkApiRateLimit().allowed).toBe(false);
-            // Reset
-            resetRateLimits();
-            // Should be allowed again
-            expect(checkApiRateLimit().allowed).toBe(true);
-        });
-    });
-    describe('getRateLimitStatus', () => {
-        it('should return current counts and limits', () => {
-            const status = getRateLimitStatus();
-            expect(status.api).toHaveProperty('count');
-            expect(status.api).toHaveProperty('limit');
-            expect(status.commands).toHaveProperty('count');
-            expect(status.commands).toHaveProperty('limit');
-        });
-        it('should return correct limits', () => {
-            const status = getRateLimitStatus();
-            expect(status.api.limit).toBe(30);
-            expect(status.commands.limit).toBe(100);
-        });
-        it('should update count after requests', () => {
-            expect(getRateLimitStatus().api.count).toBe(0);
-            checkApiRateLimit();
-            expect(getRateLimitStatus().api.count).toBe(1);
-            checkApiRateLimit();
-            expect(getRateLimitStatus().api.count).toBe(2);
-        });
-    });
-    describe('sliding window behavior', () => {
-        it('should expire old requests after window', async () => {
-            // This test uses fake timers to simulate time passing
-            vi.useFakeTimers();
-            // Make some requests
-            for (let i = 0; i < 30; i++) {
-                checkApiRateLimit();
-            }
-            // Should be blocked
-            expect(checkApiRateLimit().allowed).toBe(false);
-            // Advance time past the window (60 seconds)
-            vi.advanceTimersByTime(61000);
-            // Should be allowed again (old requests expired)
-            expect(checkApiRateLimit().allowed).toBe(true);
-            vi.useRealTimers();
-        });
-    });
-});

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

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