codeep 1.0.0

package/dist/utils/project.test.js

@@ -0,0 +1,212 @@
+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';
+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.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Rate limiting utility to prevent API abuse
+ */
+/**
+ * Update rate limiters with new config values
+ */
+export declare function updateRateLimits(): void;
+export declare function checkApiRateLimit(): {
+    allowed: boolean;
+    message?: string;
+};
+export declare function checkCommandRateLimit(): {
+    allowed: boolean;
+    message?: string;
+};
+export declare function resetRateLimits(): void;
+export declare function getRateLimitStatus(): {
+    api: {
+        count: number;
+        limit: number;
+    };
+    commands: {
+        count: number;
+        limit: number;
+    };
+};

package/dist/utils/ratelimit.js

@@ -0,0 +1,132 @@
+/**
+ * Rate limiting utility to prevent API abuse
+ */
+import { config } from '../config';
+class RateLimiter {
+    requests = [];
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Check if request is allowed
+     */
+    isAllowed() {
+        const now = Date.now();
+        const windowStart = now - this.config.windowMs;
+        // Remove old requests outside the window
+        this.requests = this.requests.filter(timestamp => timestamp > windowStart);
+        // Check if we're under the limit
+        if (this.requests.length >= this.config.maxRequests) {
+            return false;
+        }
+        // Add current request
+        this.requests.push(now);
+        return true;
+    }
+    /**
+     * Get time until next request is allowed (in ms)
+     */
+    getRetryAfter() {
+        if (this.requests.length === 0)
+            return 0;
+        const now = Date.now();
+        const oldestRequest = this.requests[0];
+        const windowStart = now - this.config.windowMs;
+        if (oldestRequest > windowStart) {
+            // Still in window, calculate wait time
+            return oldestRequest + this.config.windowMs - now;
+        }
+        return 0;
+    }
+    /**
+     * Reset the rate limiter
+     */
+    reset() {
+        this.requests = [];
+    }
+    /**
+     * Get current request count in window
+     */
+    getRequestCount() {
+        const now = Date.now();
+        const windowStart = now - this.config.windowMs;
+        return this.requests.filter(timestamp => timestamp > windowStart).length;
+    }
+    /**
+     * Get formatted retry message
+     */
+    getRetryMessage() {
+        const retryAfter = this.getRetryAfter();
+        if (retryAfter === 0)
+            return '';
+        const seconds = Math.ceil(retryAfter / 1000);
+        if (seconds < 60) {
+            return `Please wait ${seconds} second${seconds > 1 ? 's' : ''}`;
+        }
+        const minutes = Math.ceil(seconds / 60);
+        return `Please wait ${minutes} minute${minutes > 1 ? 's' : ''}`;
+    }
+}
+// Default rate limiters - configs are loaded from user settings
+let apiRateLimiter = new RateLimiter({
+    maxRequests: config.get('rateLimitApi') || 30,
+    windowMs: 60 * 1000, // per minute
+});
+let commandRateLimiter = new RateLimiter({
+    maxRequests: config.get('rateLimitCommands') || 100,
+    windowMs: 60 * 1000, // per minute
+});
+/**
+ * Update rate limiters with new config values
+ */
+export function updateRateLimits() {
+    apiRateLimiter = new RateLimiter({
+        maxRequests: config.get('rateLimitApi') || 30,
+        windowMs: 60 * 1000,
+    });
+    commandRateLimiter = new RateLimiter({
+        maxRequests: config.get('rateLimitCommands') || 100,
+        windowMs: 60 * 1000,
+    });
+}
+export function checkApiRateLimit() {
+    if (apiRateLimiter.isAllowed()) {
+        return { allowed: true };
+    }
+    return {
+        allowed: false,
+        message: `Rate limit exceeded (${apiRateLimiter.getConfig().maxRequests}/min). ${apiRateLimiter.getRetryMessage()}.`,
+    };
+}
+export function checkCommandRateLimit() {
+    if (commandRateLimiter.isAllowed()) {
+        return { allowed: true };
+    }
+    return {
+        allowed: false,
+        message: `Too many commands. ${commandRateLimiter.getRetryMessage()}.`,
+    };
+}
+export function resetRateLimits() {
+    apiRateLimiter.reset();
+    commandRateLimiter.reset();
+}
+export function getRateLimitStatus() {
+    return {
+        api: {
+            count: apiRateLimiter.getRequestCount(),
+            limit: apiRateLimiter.getConfig().maxRequests,
+        },
+        commands: {
+            count: commandRateLimiter.getRequestCount(),
+            limit: commandRateLimiter.getConfig().maxRequests,
+        },
+    };
+}

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

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

package/dist/utils/ratelimit.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { checkApiRateLimit, checkCommandRateLimit, resetRateLimits, getRateLimitStatus, } from './ratelimit';
+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.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Retry utility with exponential backoff
+ */
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    shouldRetry?: (error: any) => boolean;
+    onRetry?: (attempt: number, error: any, delay: number) => void;
+}
+/**
+ * Check if error is a network error (no internet connection)
+ */
+export declare function isNetworkError(error: any): boolean;
+/**
+ * Check if error is a timeout error
+ */
+export declare function isTimeoutError(error: any): boolean;
+/**
+ * Wrap an async function with retry logic
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Create a fetch with timeout
+ */
+export declare function fetchWithTimeout(url: string, options?: RequestInit & {
+    timeout?: number;
+}): Promise<Response>;

package/dist/utils/retry.js

@@ -0,0 +1,109 @@
+/**
+ * Retry utility with exponential backoff
+ */
+const defaultOptions = {
+    maxAttempts: 3,
+    baseDelay: 1000,
+    maxDelay: 10000,
+    shouldRetry: (error) => {
+        // Retry on network errors
+        if (error instanceof TypeError && error.message.includes('fetch')) {
+            return true;
+        }
+        // Retry on 5xx server errors
+        if (error.status && error.status >= 500) {
+            return true;
+        }
+        // Don't retry on 4xx client errors
+        if (error.status && error.status >= 400 && error.status < 500) {
+            return false;
+        }
+        // Retry on generic network errors
+        if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND' || error.code === 'ETIMEDOUT') {
+            return true;
+        }
+        return true; // Default to retry for unknown errors
+    },
+    onRetry: () => { },
+};
+/**
+ * Calculate delay with exponential backoff and jitter
+ */
+function calculateDelay(attempt, baseDelay, maxDelay) {
+    const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+    const jitter = Math.random() * 0.3 * exponentialDelay; // 0-30% jitter
+    return Math.min(exponentialDelay + jitter, maxDelay);
+}
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Check if error is a network error (no internet connection)
+ */
+export function isNetworkError(error) {
+    if (error instanceof TypeError) {
+        const msg = error.message.toLowerCase();
+        return msg.includes('fetch') || msg.includes('network') || msg.includes('failed to fetch');
+    }
+    if (error.code) {
+        return ['ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'ENETUNREACH', 'ECONNRESET'].includes(error.code);
+    }
+    return false;
+}
+/**
+ * Check if error is a timeout error
+ */
+export function isTimeoutError(error) {
+    return error.name === 'AbortError' || error.code === 'ETIMEDOUT';
+}
+/**
+ * Wrap an async function with retry logic
+ */
+export async function withRetry(fn, options = {}) {
+    const opts = { ...defaultOptions, ...options };
+    let lastError;
+    for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            const err = error;
+            // Don't retry on abort (user cancelled)
+            if (err.name === 'AbortError') {
+                throw error;
+            }
+            // Check if we should retry
+            if (attempt < opts.maxAttempts && opts.shouldRetry(error)) {
+                const delay = calculateDelay(attempt, opts.baseDelay, opts.maxDelay);
+                opts.onRetry(attempt, error, delay);
+                await sleep(delay);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    throw lastError;
+}
+/**
+ * Create a fetch with timeout
+ */
+export function fetchWithTimeout(url, options = {}) {
+    const { timeout = 30000, ...fetchOptions } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    // Merge abort signals if one was provided
+    if (fetchOptions.signal) {
+        fetchOptions.signal.addEventListener('abort', () => controller.abort());
+    }
+    return fetch(url, {
+        ...fetchOptions,
+        signal: controller.signal,
+    }).finally(() => {
+        clearTimeout(timeoutId);
+    });
+}

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

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