codeep 1.0.0

package/dist/utils/history.js

@@ -0,0 +1,348 @@
+/**
+ * Agent action history for undo/rollback functionality
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, rmSync, statSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+// In-memory current session
+let currentSession = null;
+// History storage path
+const HISTORY_DIR = join(homedir(), '.codeep', 'history');
+/**
+ * Initialize history directory
+ */
+function ensureHistoryDir() {
+    if (!existsSync(HISTORY_DIR)) {
+        mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+}
+/**
+ * Generate unique ID
+ */
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Start a new action session
+ */
+export function startSession(prompt, projectRoot) {
+    const sessionId = generateId();
+    currentSession = {
+        id: sessionId,
+        startTime: Date.now(),
+        prompt,
+        actions: [],
+        projectRoot,
+    };
+    return sessionId;
+}
+/**
+ * End current session and save to disk
+ */
+export function endSession() {
+    if (!currentSession)
+        return;
+    currentSession.endTime = Date.now();
+    // Only save if there were actions
+    if (currentSession.actions.length > 0) {
+        ensureHistoryDir();
+        const filename = `${currentSession.id}.json`;
+        const filepath = join(HISTORY_DIR, filename);
+        writeFileSync(filepath, JSON.stringify(currentSession, null, 2));
+    }
+    currentSession = null;
+}
+/**
+ * Record a file write action (before it happens)
+ */
+export function recordWrite(path) {
+    if (!currentSession)
+        return null;
+    const record = {
+        id: generateId(),
+        timestamp: Date.now(),
+        type: 'write',
+        path,
+        previousExisted: existsSync(path),
+    };
+    // Save previous content if file existed
+    if (record.previousExisted) {
+        try {
+            record.previousContent = readFileSync(path, 'utf-8');
+        }
+        catch {
+            // Could be binary or unreadable
+        }
+    }
+    currentSession.actions.push(record);
+    return record;
+}
+/**
+ * Record a file edit action (before it happens)
+ */
+export function recordEdit(path) {
+    if (!currentSession)
+        return null;
+    const record = {
+        id: generateId(),
+        timestamp: Date.now(),
+        type: 'edit',
+        path,
+        previousExisted: true,
+    };
+    // Save previous content
+    try {
+        record.previousContent = readFileSync(path, 'utf-8');
+    }
+    catch {
+        // Could be binary or unreadable
+    }
+    currentSession.actions.push(record);
+    return record;
+}
+/**
+ * Record a file/directory delete action (before it happens)
+ */
+export function recordDelete(path) {
+    if (!currentSession)
+        return null;
+    const record = {
+        id: generateId(),
+        timestamp: Date.now(),
+        type: 'delete',
+        path,
+        previousExisted: true,
+    };
+    try {
+        const stat = statSync(path);
+        record.wasDirectory = stat.isDirectory();
+        if (!record.wasDirectory) {
+            record.deletedContent = readFileSync(path, 'utf-8');
+        }
+        // Note: For directories, we can't easily restore all contents
+        // User should use git for that
+    }
+    catch {
+        // Ignore errors
+    }
+    currentSession.actions.push(record);
+    return record;
+}
+/**
+ * Record a mkdir action
+ */
+export function recordMkdir(path) {
+    if (!currentSession)
+        return null;
+    const record = {
+        id: generateId(),
+        timestamp: Date.now(),
+        type: 'mkdir',
+        path,
+        previousExisted: existsSync(path),
+    };
+    currentSession.actions.push(record);
+    return record;
+}
+/**
+ * Record a command execution (can't be undone, but tracked)
+ */
+export function recordCommand(command, args) {
+    if (!currentSession)
+        return null;
+    const record = {
+        id: generateId(),
+        timestamp: Date.now(),
+        type: 'command',
+        command,
+        args,
+    };
+    currentSession.actions.push(record);
+    return record;
+}
+/**
+ * Get current session
+ */
+export function getCurrentSession() {
+    return currentSession;
+}
+/**
+ * Undo the last action in current session
+ */
+export function undoLastAction() {
+    if (!currentSession || currentSession.actions.length === 0) {
+        return { success: false, message: 'No actions to undo' };
+    }
+    // Find last non-undone action
+    const action = [...currentSession.actions].reverse().find(a => !a.undone);
+    if (!action) {
+        return { success: false, message: 'All actions already undone' };
+    }
+    return undoAction(action);
+}
+/**
+ * Undo a specific action
+ */
+export function undoAction(action) {
+    try {
+        switch (action.type) {
+            case 'write':
+                if (action.previousExisted && action.previousContent !== undefined) {
+                    // Restore previous content
+                    writeFileSync(action.path, action.previousContent);
+                    action.undone = true;
+                    return { success: true, message: `Restored: ${action.path}` };
+                }
+                else if (!action.previousExisted) {
+                    // Delete the newly created file
+                    if (existsSync(action.path)) {
+                        unlinkSync(action.path);
+                    }
+                    action.undone = true;
+                    return { success: true, message: `Deleted new file: ${action.path}` };
+                }
+                break;
+            case 'edit':
+                if (action.previousContent !== undefined) {
+                    writeFileSync(action.path, action.previousContent);
+                    action.undone = true;
+                    return { success: true, message: `Restored: ${action.path}` };
+                }
+                break;
+            case 'delete':
+                if (action.deletedContent !== undefined) {
+                    // Recreate the file
+                    const dir = dirname(action.path);
+                    if (!existsSync(dir)) {
+                        mkdirSync(dir, { recursive: true });
+                    }
+                    writeFileSync(action.path, action.deletedContent);
+                    action.undone = true;
+                    return { success: true, message: `Restored deleted file: ${action.path}` };
+                }
+                else if (action.wasDirectory) {
+                    return { success: false, message: `Cannot restore directory: ${action.path}. Use git checkout.` };
+                }
+                break;
+            case 'mkdir':
+                if (!action.previousExisted && existsSync(action.path)) {
+                    // Only remove if empty
+                    try {
+                        rmSync(action.path, { recursive: false });
+                        action.undone = true;
+                        return { success: true, message: `Removed directory: ${action.path}` };
+                    }
+                    catch {
+                        return { success: false, message: `Cannot remove non-empty directory: ${action.path}` };
+                    }
+                }
+                break;
+            case 'command':
+                return { success: false, message: `Cannot undo command: ${action.command} ${action.args?.join(' ')}` };
+        }
+        return { success: false, message: 'Cannot undo this action' };
+    }
+    catch (error) {
+        const err = error;
+        return { success: false, message: `Undo failed: ${err.message}` };
+    }
+}
+/**
+ * Undo all actions in current session
+ */
+export function undoAllActions() {
+    if (!currentSession || currentSession.actions.length === 0) {
+        return { success: false, results: ['No actions to undo'] };
+    }
+    const results = [];
+    let allSuccess = true;
+    // Undo in reverse order
+    const actions = [...currentSession.actions].reverse();
+    for (const action of actions) {
+        if (action.undone)
+            continue;
+        const result = undoAction(action);
+        results.push(result.message);
+        if (!result.success)
+            allSuccess = false;
+    }
+    return { success: allSuccess, results };
+}
+/**
+ * Get list of recent sessions
+ */
+export function getRecentSessions(limit = 10) {
+    ensureHistoryDir();
+    try {
+        const files = require('fs').readdirSync(HISTORY_DIR)
+            .filter((f) => f.endsWith('.json'))
+            .sort()
+            .reverse()
+            .slice(0, limit);
+        return files.map((f) => {
+            try {
+                const content = readFileSync(join(HISTORY_DIR, f), 'utf-8');
+                return JSON.parse(content);
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get a specific session by ID
+ */
+export function getSession(sessionId) {
+    const filepath = join(HISTORY_DIR, `${sessionId}.json`);
+    if (!existsSync(filepath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(filepath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Format session for display
+ */
+export function formatSession(session) {
+    const date = new Date(session.startTime).toLocaleString();
+    const duration = session.endTime
+        ? `${Math.round((session.endTime - session.startTime) / 1000)}s`
+        : 'ongoing';
+    const lines = [
+        `Session: ${session.id}`,
+        `Date: ${date}`,
+        `Duration: ${duration}`,
+        `Prompt: ${session.prompt.slice(0, 50)}${session.prompt.length > 50 ? '...' : ''}`,
+        `Actions (${session.actions.length}):`,
+    ];
+    for (const action of session.actions) {
+        const status = action.undone ? '↩️' : '✓';
+        const target = action.path || `${action.command} ${action.args?.join(' ')}`;
+        lines.push(`  ${status} ${action.type}: ${target}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Clear all history
+ */
+export function clearHistory() {
+    ensureHistoryDir();
+    try {
+        const files = require('fs').readdirSync(HISTORY_DIR);
+        for (const f of files) {
+            unlinkSync(join(HISTORY_DIR, f));
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}

package/dist/utils/interactive.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Interactive Mode - agent asks clarifying questions when needed
+ */
+export interface ClarificationQuestion {
+    question: string;
+    options?: string[];
+    type: 'choice' | 'text' | 'confirm';
+    context?: string;
+}
+export interface InteractiveContext {
+    needsClarification: boolean;
+    questions: ClarificationQuestion[];
+    originalPrompt: string;
+}
+/**
+ * Analyze prompt for ambiguity and generate clarifying questions
+ */
+export declare function analyzeForClarification(prompt: string): InteractiveContext;
+/**
+ * Format questions for display
+ */
+export declare function formatQuestions(context: InteractiveContext): string;
+/**
+ * Parse user's answers to questions
+ */
+export declare function parseAnswers(response: string, context: InteractiveContext): Map<number, string>;
+/**
+ * Enhance prompt with user's answers
+ */
+export declare function enhancePromptWithAnswers(context: InteractiveContext, answers: Map<number, string>): string;
+/**
+ * Generate interactive prompt for agent
+ */
+export declare function getInteractiveSystemPrompt(): string;

package/dist/utils/interactive.js

@@ -0,0 +1,206 @@
+/**
+ * Interactive Mode - agent asks clarifying questions when needed
+ */
+// Patterns that indicate ambiguity
+const AMBIGUOUS_PATTERNS = [
+    {
+        pattern: /add\s+(?:an?\s+)?auth(?:entication)?/i,
+        question: 'What type of authentication do you want?',
+        options: ['JWT tokens', 'Session-based', 'OAuth (Google/GitHub)', 'Basic auth'],
+        type: 'choice',
+    },
+    {
+        pattern: /add\s+(?:a\s+)?database/i,
+        question: 'Which database do you want to use?',
+        options: ['PostgreSQL', 'MySQL', 'MongoDB', 'SQLite', 'Redis'],
+        type: 'choice',
+    },
+    {
+        pattern: /create\s+(?:an?\s+)?api/i,
+        question: 'What type of API do you want?',
+        options: ['REST API', 'GraphQL', 'gRPC', 'WebSocket'],
+        type: 'choice',
+    },
+    {
+        pattern: /add\s+(?:a\s+)?form/i,
+        question: 'What fields should the form have?',
+        type: 'text',
+    },
+    {
+        pattern: /add\s+(?:a\s+)?component/i,
+        question: 'Should this be a functional or class component?',
+        options: ['Functional (hooks)', 'Class component'],
+        type: 'choice',
+    },
+    {
+        pattern: /add\s+(?:a\s+)?test/i,
+        question: 'What testing framework should I use?',
+        options: ['Vitest', 'Jest', 'Mocha', 'PHPUnit', 'pytest'],
+        type: 'choice',
+    },
+    {
+        pattern: /refactor/i,
+        question: 'What aspect should I focus on?',
+        options: ['Performance', 'Readability', 'Type safety', 'Modularity', 'All of the above'],
+        type: 'choice',
+    },
+    {
+        pattern: /add\s+(?:a\s+)?state\s+management/i,
+        question: 'Which state management solution?',
+        options: ['React Context', 'Redux', 'Zustand', 'MobX', 'Jotai'],
+        type: 'choice',
+    },
+    {
+        pattern: /add\s+(?:a\s+)?(?:css|style|styling)/i,
+        question: 'Which styling approach?',
+        options: ['CSS Modules', 'Tailwind CSS', 'Styled Components', 'SCSS/Sass', 'Plain CSS'],
+        type: 'choice',
+    },
+    {
+        pattern: /deploy/i,
+        question: 'Where do you want to deploy?',
+        options: ['Vercel', 'Netlify', 'AWS', 'Docker', 'Heroku'],
+        type: 'choice',
+    },
+];
+/**
+ * Analyze prompt for ambiguity and generate clarifying questions
+ */
+export function analyzeForClarification(prompt) {
+    const questions = [];
+    for (const pattern of AMBIGUOUS_PATTERNS) {
+        if (pattern.pattern.test(prompt)) {
+            // Check if the prompt already specifies details
+            const hasDetails = checkForDetails(prompt, pattern);
+            if (!hasDetails) {
+                questions.push({
+                    question: pattern.question,
+                    options: pattern.options,
+                    type: pattern.type,
+                });
+            }
+        }
+    }
+    return {
+        needsClarification: questions.length > 0,
+        questions,
+        originalPrompt: prompt,
+    };
+}
+/**
+ * Check if prompt already contains specific details
+ */
+function checkForDetails(prompt, pattern) {
+    if (!pattern.options)
+        return false;
+    const promptLower = prompt.toLowerCase();
+    // Check if any option is mentioned in the prompt
+    for (const option of pattern.options) {
+        const optionWords = option.toLowerCase().split(/[\s/()]+/);
+        for (const word of optionWords) {
+            if (word.length > 3 && promptLower.includes(word)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Format questions for display
+ */
+export function formatQuestions(context) {
+    if (!context.needsClarification) {
+        return '';
+    }
+    const lines = ['I have a few questions before proceeding:', ''];
+    for (let i = 0; i < context.questions.length; i++) {
+        const q = context.questions[i];
+        lines.push(`${i + 1}. ${q.question}`);
+        if (q.options) {
+            for (let j = 0; j < q.options.length; j++) {
+                lines.push(`   ${String.fromCharCode(97 + j)}) ${q.options[j]}`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push('Please answer the questions or say "proceed" to let me decide.');
+    return lines.join('\n');
+}
+/**
+ * Parse user's answers to questions
+ */
+export function parseAnswers(response, context) {
+    const answers = new Map();
+    const responseLower = response.toLowerCase();
+    // Check for "proceed" or similar
+    if (/proceed|continue|decide|auto|skip/i.test(response)) {
+        return answers; // Empty answers = let agent decide
+    }
+    // Try to match answers
+    for (let i = 0; i < context.questions.length; i++) {
+        const q = context.questions[i];
+        if (q.options) {
+            // Check if user selected an option by letter (a, b, c)
+            const letterMatch = response.match(new RegExp(`${i + 1}[.:\\s]*([a-z])`, 'i'));
+            if (letterMatch) {
+                const letterIndex = letterMatch[1].toLowerCase().charCodeAt(0) - 97;
+                if (letterIndex >= 0 && letterIndex < q.options.length) {
+                    answers.set(i, q.options[letterIndex]);
+                    continue;
+                }
+            }
+            // Check if user mentioned an option directly
+            for (const option of q.options) {
+                if (responseLower.includes(option.toLowerCase())) {
+                    answers.set(i, option);
+                    break;
+                }
+            }
+        }
+        else {
+            // Free text - try to extract answer
+            const textMatch = response.match(new RegExp(`${i + 1}[.:\\s]*(.+?)(?=\\d+[.:]|$)`, 'i'));
+            if (textMatch) {
+                answers.set(i, textMatch[1].trim());
+            }
+        }
+    }
+    return answers;
+}
+/**
+ * Enhance prompt with user's answers
+ */
+export function enhancePromptWithAnswers(context, answers) {
+    let enhancedPrompt = context.originalPrompt;
+    const specifications = [];
+    for (let i = 0; i < context.questions.length; i++) {
+        const q = context.questions[i];
+        const answer = answers.get(i);
+        if (answer) {
+            specifications.push(`${q.question} -> ${answer}`);
+        }
+    }
+    if (specifications.length > 0) {
+        enhancedPrompt += '\n\nUser specifications:\n- ' + specifications.join('\n- ');
+    }
+    return enhancedPrompt;
+}
+/**
+ * Generate interactive prompt for agent
+ */
+export function getInteractiveSystemPrompt() {
+    return `
+## Interactive Mode
+When the task is ambiguous, you may ask clarifying questions before proceeding.
+Format your questions like this:
+
+CLARIFICATION_NEEDED:
+1. [Question]
+   a) Option 1
+   b) Option 2
+   c) Option 3
+
+The user will respond with their choices. Once you have enough information, proceed with the task.
+Only ask questions when truly necessary - don't over-ask.
+`;
+}

package/dist/utils/keychain.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Secure storage for API keys using native keychain
+ * - macOS: Keychain
+ * - Linux: Secret Service API (libsecret)
+ * - Windows: Credential Vault
+ */
+export interface SecureStorage {
+    getApiKey(providerId: string): Promise<string | null>;
+    setApiKey(providerId: string, apiKey: string): Promise<void>;
+    deleteApiKey(providerId: string): Promise<void>;
+    hasApiKey(providerId: string): Promise<boolean>;
+}
+/**
+ * Migrate existing plain-text API keys to keychain
+ */
+export declare function migrateApiKeysToKeychain(config: any): Promise<void>;
+export declare function createSecureStorage(config: any): SecureStorage;