codeep 1.0.0

package/dist/utils/retry.test.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi } from 'vitest';
+import { withRetry, isNetworkError, isTimeoutError, fetchWithTimeout, } from './retry';
+describe('retry utilities', () => {
+    describe('isNetworkError', () => {
+        it('should detect fetch TypeError', () => {
+            const error = new TypeError('Failed to fetch');
+            expect(isNetworkError(error)).toBe(true);
+        });
+        it('should detect network TypeError', () => {
+            const error = new TypeError('Network request failed');
+            expect(isNetworkError(error)).toBe(true);
+        });
+        it('should detect ECONNREFUSED', () => {
+            const error = { code: 'ECONNREFUSED' };
+            expect(isNetworkError(error)).toBe(true);
+        });
+        it('should detect ENOTFOUND', () => {
+            const error = { code: 'ENOTFOUND' };
+            expect(isNetworkError(error)).toBe(true);
+        });
+        it('should detect ETIMEDOUT', () => {
+            const error = { code: 'ETIMEDOUT' };
+            expect(isNetworkError(error)).toBe(true);
+        });
+        it('should detect ENETUNREACH', () => {
+            const error = { code: 'ENETUNREACH' };
+            expect(isNetworkError(error)).toBe(true);
+        });
+        it('should detect ECONNRESET', () => {
+            const error = { code: 'ECONNRESET' };
+            expect(isNetworkError(error)).toBe(true);
+        });
+        it('should return false for non-network errors', () => {
+            expect(isNetworkError(new Error('Some other error'))).toBe(false);
+            expect(isNetworkError({ status: 400 })).toBe(false);
+            expect(isNetworkError({ code: 'EPERM' })).toBe(false);
+        });
+    });
+    describe('isTimeoutError', () => {
+        it('should detect AbortError', () => {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            expect(isTimeoutError(error)).toBe(true);
+        });
+        it('should detect ETIMEDOUT', () => {
+            const error = { code: 'ETIMEDOUT' };
+            expect(isTimeoutError(error)).toBe(true);
+        });
+        it('should return false for non-timeout errors', () => {
+            expect(isTimeoutError(new Error('Some error'))).toBe(false);
+            expect(isTimeoutError({ code: 'ECONNREFUSED' })).toBe(false);
+        });
+    });
+    describe('withRetry', () => {
+        it('should return result on first success', async () => {
+            const fn = vi.fn().mockResolvedValue('success');
+            const result = await withRetry(fn);
+            expect(result).toBe('success');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should retry on failure and succeed', async () => {
+            const fn = vi.fn()
+                .mockRejectedValueOnce(new Error('fail 1'))
+                .mockRejectedValueOnce(new Error('fail 2'))
+                .mockResolvedValue('success');
+            const result = await withRetry(fn, { baseDelay: 10 });
+            expect(result).toBe('success');
+            expect(fn).toHaveBeenCalledTimes(3);
+        });
+        it('should throw after max attempts', async () => {
+            const fn = vi.fn().mockRejectedValue(new Error('always fails'));
+            await expect(withRetry(fn, { maxAttempts: 3, baseDelay: 10 }))
+                .rejects.toThrow('always fails');
+            expect(fn).toHaveBeenCalledTimes(3);
+        });
+        it('should not retry on AbortError', async () => {
+            const abortError = new Error('Aborted');
+            abortError.name = 'AbortError';
+            const fn = vi.fn().mockRejectedValue(abortError);
+            await expect(withRetry(fn, { maxAttempts: 3, baseDelay: 10 }))
+                .rejects.toThrow('Aborted');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should call onRetry callback', async () => {
+            const onRetry = vi.fn();
+            const fn = vi.fn()
+                .mockRejectedValueOnce(new Error('fail'))
+                .mockResolvedValue('success');
+            await withRetry(fn, { baseDelay: 10, onRetry });
+            expect(onRetry).toHaveBeenCalledTimes(1);
+            expect(onRetry).toHaveBeenCalledWith(1, expect.any(Error), expect.any(Number));
+        });
+        it('should respect shouldRetry option', async () => {
+            const shouldRetry = vi.fn().mockReturnValue(false);
+            const fn = vi.fn().mockRejectedValue(new Error('fail'));
+            await expect(withRetry(fn, { shouldRetry, maxAttempts: 3, baseDelay: 10 }))
+                .rejects.toThrow('fail');
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should not retry on 4xx errors by default', async () => {
+            const error = { status: 400, message: 'Bad Request' };
+            const fn = vi.fn().mockRejectedValue(error);
+            await expect(withRetry(fn, { maxAttempts: 3, baseDelay: 10 }))
+                .rejects.toEqual(error);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('should retry on 5xx errors by default', async () => {
+            const error = { status: 500, message: 'Server Error' };
+            const fn = vi.fn()
+                .mockRejectedValueOnce(error)
+                .mockResolvedValue('success');
+            const result = await withRetry(fn, { baseDelay: 10 });
+            expect(result).toBe('success');
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+        it('should respect maxDelay', async () => {
+            const onRetry = vi.fn();
+            const fn = vi.fn()
+                .mockRejectedValueOnce(new Error('fail 1'))
+                .mockRejectedValueOnce(new Error('fail 2'))
+                .mockResolvedValue('success');
+            await withRetry(fn, { baseDelay: 1000, maxDelay: 100, onRetry });
+            // All delays should be capped at maxDelay
+            for (const call of onRetry.mock.calls) {
+                expect(call[2]).toBeLessThanOrEqual(100);
+            }
+        });
+    });
+    describe('fetchWithTimeout', () => {
+        it('should make fetch request', async () => {
+            const mockResponse = new Response('ok', { status: 200 });
+            global.fetch = vi.fn().mockResolvedValue(mockResponse);
+            const response = await fetchWithTimeout('https://example.com');
+            expect(response.status).toBe(200);
+            expect(global.fetch).toHaveBeenCalledWith('https://example.com', expect.objectContaining({ signal: expect.any(AbortSignal) }));
+        });
+        it('should abort on timeout', async () => {
+            global.fetch = vi.fn().mockImplementation(() => new Promise((_, reject) => {
+                setTimeout(() => {
+                    const error = new Error('Aborted');
+                    error.name = 'AbortError';
+                    reject(error);
+                }, 100);
+            }));
+            await expect(fetchWithTimeout('https://example.com', { timeout: 50 }))
+                .rejects.toThrow();
+        });
+        it('should pass through fetch options', async () => {
+            const mockResponse = new Response('ok');
+            global.fetch = vi.fn().mockResolvedValue(mockResponse);
+            await fetchWithTimeout('https://example.com', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ test: true }),
+            });
+            expect(global.fetch).toHaveBeenCalledWith('https://example.com', expect.objectContaining({
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ test: true }),
+            }));
+        });
+    });
+});

package/dist/utils/search.d.ts

@@ -0,0 +1,11 @@
+import { Message } from '../config/index';
+export interface SearchResult {
+    messageIndex: number;
+    role: 'user' | 'assistant';
+    content: string;
+    matchedText: string;
+}
+/**
+ * Search through chat history for a term
+ */
+export declare function searchMessages(messages: Message[], searchTerm: string): SearchResult[];

package/dist/utils/search.js

@@ -0,0 +1,29 @@
+/**
+ * Search through chat history for a term
+ */
+export function searchMessages(messages, searchTerm) {
+    const results = [];
+    const term = searchTerm.toLowerCase();
+    messages.forEach((message, index) => {
+        const content = message.content.toLowerCase();
+        if (content.includes(term)) {
+            // Find the matching snippet with context
+            const matchIndex = content.indexOf(term);
+            const start = Math.max(0, matchIndex - 50);
+            const end = Math.min(content.length, matchIndex + term.length + 50);
+            let snippet = message.content.substring(start, end);
+            // Add ellipsis if truncated
+            if (start > 0)
+                snippet = '...' + snippet;
+            if (end < content.length)
+                snippet = snippet + '...';
+            results.push({
+                messageIndex: index,
+                role: message.role,
+                content: message.content,
+                matchedText: snippet,
+            });
+        }
+    });
+    return results;
+}

package/dist/utils/shell.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shell command execution utilities with safety checks
+ */
+export interface CommandResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+    command: string;
+    args: string[];
+}
+export interface CommandOptions {
+    cwd?: string;
+    timeout?: number;
+    env?: Record<string, string>;
+    projectRoot?: string;
+}
+/**
+ * Validate if a command is safe to execute
+ */
+export declare function validateCommand(command: string, args: string[], options?: CommandOptions): {
+    valid: boolean;
+    reason?: string;
+};
+/**
+ * Execute a shell command with safety checks
+ */
+export declare function executeCommand(command: string, args?: string[], options?: CommandOptions): CommandResult;
+/**
+ * Execute a command and return only stdout if successful
+ */
+export declare function execSimple(command: string, args?: string[], options?: CommandOptions): string | null;
+/**
+ * Check if a command exists in PATH
+ */
+export declare function commandExists(command: string): boolean;
+/**
+ * Get list of allowed commands
+ */
+export declare function getAllowedCommands(): string[];
+/**
+ * Format command result for display
+ */
+export declare function formatCommandResult(result: CommandResult): string;

package/dist/utils/shell.js

@@ -0,0 +1,242 @@
+/**
+ * Shell command execution utilities with safety checks
+ */
+import { spawnSync } from 'child_process';
+import { resolve, relative, isAbsolute } from 'path';
+import { existsSync } from 'fs';
+// Dangerous command patterns that should never be executed
+const BLOCKED_COMMANDS = new Set([
+    'sudo',
+    'su',
+    'chmod',
+    'chown',
+    'mkfs',
+    'fdisk',
+    'dd',
+    'mount',
+    'umount',
+    'systemctl',
+    'service',
+    'shutdown',
+    'reboot',
+    'init',
+    'kill',
+    'killall',
+    'pkill',
+]);
+// Dangerous argument patterns
+const BLOCKED_PATTERNS = [
+    /rm\s+(-[rf]+\s+)*\/(?![\w])/, // rm -rf / (root)
+    /rm\s+(-[rf]+\s+)*~/, // rm home directory
+    />\s*\/etc\//, // redirect to /etc
+    />\s*\/usr\//, // redirect to /usr
+    />\s*\/var\//, // redirect to /var
+    />\s*\/bin\//, // redirect to /bin
+    />\s*\/sbin\//, // redirect to /sbin
+    /curl.*\|\s*(ba)?sh/, // curl pipe to shell
+    /wget.*\|\s*(ba)?sh/, // wget pipe to shell
+    /eval\s+/, // eval command
+    /`.*`/, // command substitution in backticks
+    /\$\(.*\)/, // command substitution
+];
+// Allowed commands for agent mode (whitelist approach for extra safety)
+const ALLOWED_COMMANDS = new Set([
+    // Package managers
+    'npm', 'npx', 'yarn', 'pnpm', 'bun',
+    'pip', 'pip3', 'poetry', 'pipenv',
+    'cargo', 'rustup',
+    'go',
+    'composer',
+    'gem', 'bundle',
+    'brew',
+    // Build tools
+    'make', 'cmake', 'gradle', 'mvn',
+    'tsc', 'esbuild', 'vite', 'webpack', 'rollup',
+    // Version control
+    'git',
+    // File operations (safe ones)
+    'ls', 'cat', 'head', 'tail', 'grep', 'find', 'wc',
+    'mkdir', 'touch', 'cp', 'mv', 'rm', 'rmdir',
+    // Node.js
+    'node', 'deno',
+    // Python
+    'python', 'python3',
+    // PHP
+    'php', 'composer', 'phpunit', 'artisan',
+    // Testing
+    'jest', 'vitest', 'pytest', 'mocha',
+    // Linting/Formatting
+    'eslint', 'prettier', 'black', 'rustfmt',
+    // Other common tools
+    'echo', 'pwd', 'which', 'env', 'date',
+    'curl', 'wget', // allowed but patterns checked
+    'tar', 'unzip', 'zip',
+    // HTTP tools
+    'http', 'https',
+]);
+/**
+ * Validate if a command is safe to execute
+ */
+export function validateCommand(command, args, options) {
+    // Check if command is in blocked list
+    if (BLOCKED_COMMANDS.has(command)) {
+        return { valid: false, reason: `Command '${command}' is not allowed for security reasons` };
+    }
+    // Check if command is in allowed list (whitelist mode)
+    if (!ALLOWED_COMMANDS.has(command)) {
+        return { valid: false, reason: `Command '${command}' is not in the allowed list` };
+    }
+    // Check full command string against dangerous patterns
+    const fullCommand = `${command} ${args.join(' ')}`;
+    for (const pattern of BLOCKED_PATTERNS) {
+        if (pattern.test(fullCommand)) {
+            return { valid: false, reason: `Command contains blocked pattern: ${pattern}` };
+        }
+    }
+    // Validate paths in arguments stay within project
+    if (options?.projectRoot) {
+        for (const arg of args) {
+            // Skip flags
+            if (arg.startsWith('-'))
+                continue;
+            // Check if argument looks like a path
+            if (arg.includes('/') || arg.includes('\\')) {
+                const absolutePath = isAbsolute(arg) ? arg : resolve(options.cwd || options.projectRoot, arg);
+                const relativePath = relative(options.projectRoot, absolutePath);
+                // Path escapes project root
+                if (relativePath.startsWith('..')) {
+                    return { valid: false, reason: `Path '${arg}' is outside project directory` };
+                }
+            }
+        }
+    }
+    // Special validation for rm command
+    if (command === 'rm') {
+        const hasRecursive = args.some(a => a.includes('r'));
+        const hasForce = args.some(a => a.includes('f'));
+        if (hasRecursive && hasForce) {
+            // rm -rf requires extra validation
+            const paths = args.filter(a => !a.startsWith('-'));
+            if (paths.length === 0) {
+                return { valid: false, reason: 'rm -rf without specific paths is not allowed' };
+            }
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Execute a shell command with safety checks
+ */
+export function executeCommand(command, args = [], options) {
+    const startTime = Date.now();
+    const cwd = options?.cwd || process.cwd();
+    const timeout = options?.timeout || 60000; // Default 1 minute
+    // Validate command first
+    const validation = validateCommand(command, args, options);
+    if (!validation.valid) {
+        return {
+            success: false,
+            stdout: '',
+            stderr: validation.reason || 'Command validation failed',
+            exitCode: -1,
+            duration: 0,
+            command,
+            args,
+        };
+    }
+    // Ensure cwd exists
+    if (!existsSync(cwd)) {
+        return {
+            success: false,
+            stdout: '',
+            stderr: `Working directory does not exist: ${cwd}`,
+            exitCode: -1,
+            duration: 0,
+            command,
+            args,
+        };
+    }
+    const spawnOptions = {
+        cwd,
+        timeout,
+        encoding: 'utf-8',
+        env: {
+            ...process.env,
+            ...options?.env,
+        },
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+    };
+    try {
+        const result = spawnSync(command, args, spawnOptions);
+        const duration = Date.now() - startTime;
+        // Handle timeout
+        if (result.signal === 'SIGTERM') {
+            return {
+                success: false,
+                stdout: result.stdout?.toString() || '',
+                stderr: `Command timed out after ${timeout}ms`,
+                exitCode: -1,
+                duration,
+                command,
+                args,
+            };
+        }
+        return {
+            success: result.status === 0,
+            stdout: result.stdout?.toString() || '',
+            stderr: result.stderr?.toString() || '',
+            exitCode: result.status ?? -1,
+            duration,
+            command,
+            args,
+        };
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        const err = error;
+        return {
+            success: false,
+            stdout: '',
+            stderr: err.message || 'Unknown error executing command',
+            exitCode: -1,
+            duration,
+            command,
+            args,
+        };
+    }
+}
+/**
+ * Execute a command and return only stdout if successful
+ */
+export function execSimple(command, args = [], options) {
+    const result = executeCommand(command, args, options);
+    return result.success ? result.stdout.trim() : null;
+}
+/**
+ * Check if a command exists in PATH
+ */
+export function commandExists(command) {
+    const result = spawnSync('which', [command], { encoding: 'utf-8' });
+    return result.status === 0;
+}
+/**
+ * Get list of allowed commands
+ */
+export function getAllowedCommands() {
+    return Array.from(ALLOWED_COMMANDS).sort();
+}
+/**
+ * Format command result for display
+ */
+export function formatCommandResult(result) {
+    const status = result.success ? '✓' : '✗';
+    const cmd = `${result.command} ${result.args.join(' ')}`.trim();
+    let output = `${status} ${cmd} (${result.duration}ms, exit ${result.exitCode})`;
+    if (result.stdout) {
+        output += `\n  stdout: ${result.stdout.slice(0, 500)}${result.stdout.length > 500 ? '...' : ''}`;
+    }
+    if (result.stderr && !result.success) {
+        output += `\n  stderr: ${result.stderr.slice(0, 500)}${result.stderr.length > 500 ? '...' : ''}`;
+    }
+    return output;
+}

package/dist/utils/skills.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Skills System - predefined workflows and commands
+ */
+import { ProjectContext } from './project';
+export interface SkillStep {
+    type: 'prompt' | 'command' | 'confirm' | 'notify' | 'agent';
+    content: string;
+    optional?: boolean;
+}
+export interface SkillParameter {
+    name: string;
+    description: string;
+    required?: boolean;
+    default?: string;
+}
+export interface Skill {
+    name: string;
+    description: string;
+    shortcut?: string;
+    category: SkillCategory;
+    steps: SkillStep[];
+    parameters?: SkillParameter[];
+    requiresWriteAccess?: boolean;
+    requiresGit?: boolean;
+}
+export type SkillCategory = 'git' | 'testing' | 'documentation' | 'refactoring' | 'debugging' | 'deployment' | 'generation' | 'devops' | 'custom';
+export interface SkillExecutionResult {
+    success: boolean;
+    output: string;
+    steps: {
+        step: SkillStep;
+        result: string;
+        success: boolean;
+    }[];
+}
+export interface SkillChain {
+    skills: string[];
+    stopOnError: boolean;
+}
+/**
+ * Get all built-in skills
+ */
+export declare function getBuiltInSkills(): Skill[];
+/**
+ * Load custom skills from disk
+ */
+export declare function loadCustomSkills(): Skill[];
+/**
+ * Get all skills (built-in + custom)
+ */
+export declare function getAllSkills(): Skill[];
+/**
+ * Find skill by name or shortcut
+ */
+export declare function findSkill(nameOrShortcut: string): Skill | null;
+/**
+ * Parse skill chain (e.g., "commit+push" → ["commit", "push"])
+ */
+export declare function parseSkillChain(input: string): SkillChain | null;
+/**
+ * Parse skill parameters from args string
+ * Supports: "value" for first param, key=value, key="value with spaces"
+ */
+export declare function parseSkillArgs(args: string, skill: Skill): Record<string, string>;
+/**
+ * Interpolate parameters into skill step content
+ */
+export declare function interpolateParams(content: string, params: Record<string, string>): string;
+/**
+ * Save a custom skill
+ */
+export declare function saveCustomSkill(skill: Skill): void;
+/**
+ * Delete a custom skill
+ */
+export declare function deleteCustomSkill(name: string): boolean;
+/**
+ * Generate prompt for a skill with parameters
+ */
+export declare function generateSkillPrompt(skill: Skill, context: ProjectContext, additionalContext?: string, params?: Record<string, string>): string;
+/**
+ * Get skill steps that need execution
+ */
+export declare function getExecutableSteps(skill: Skill): SkillStep[];
+/**
+ * Format skills list for display
+ */
+export declare function formatSkillsList(skills: Skill[]): string;
+/**
+ * Format skill help
+ */
+export declare function formatSkillHelp(skill: Skill): string;
+/**
+ * Create a custom skill from template
+ */
+export declare function createSkillTemplate(name: string): Skill;
+/**
+ * Wizard step for creating custom skills
+ */
+export interface WizardStep {
+    field: 'name' | 'description' | 'shortcut' | 'step_type' | 'step_content' | 'add_another' | 'done';
+    prompt: string;
+    validate?: (input: string) => string | null;
+}
+export declare const WIZARD_STEPS: WizardStep[];
+/**
+ * Parse skill definition from YAML-like string
+ */
+export declare function parseSkillDefinition(content: string): Skill | null;
+/**
+ * Get skill categories summary
+ */
+export declare function getSkillsSummary(): Record<SkillCategory, number>;
+/**
+ * Search skills by keyword
+ */
+export declare function searchSkills(query: string): Skill[];
+/**
+ * Track skill usage
+ */
+export declare function trackSkillUsage(skillName: string, success?: boolean): void;
+/**
+ * Get recently used skills
+ */
+export declare function getRecentSkills(limit?: number): string[];
+/**
+ * Get most frequently used skills
+ */
+export declare function getMostUsedSkills(limit?: number): Array<{
+    name: string;
+    count: number;
+}>;
+/**
+ * Get skill usage statistics
+ */
+export declare function getSkillStats(): {
+    totalUsage: number;
+    uniqueSkills: number;
+    successRate: number;
+};
+/**
+ * Clear skill usage history
+ */
+export declare function clearSkillHistory(): void;