npm - codeep - Versions diffs - 1.0.0 - Mend

codeep 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (103) hide show

package/LICENSE +201 -0
package/README.md +576 -0
package/dist/api/index.d.ts +8 -0
package/dist/api/index.js +421 -0
package/dist/app.d.ts +2 -0
package/dist/app.js +1406 -0
package/dist/components/AgentProgress.d.ts +33 -0
package/dist/components/AgentProgress.js +97 -0
package/dist/components/Export.d.ts +8 -0
package/dist/components/Export.js +27 -0
package/dist/components/Help.d.ts +2 -0
package/dist/components/Help.js +3 -0
package/dist/components/Input.d.ts +9 -0
package/dist/components/Input.js +89 -0
package/dist/components/Loading.d.ts +9 -0
package/dist/components/Loading.js +31 -0
package/dist/components/Login.d.ts +7 -0
package/dist/components/Login.js +77 -0
package/dist/components/Logo.d.ts +8 -0
package/dist/components/Logo.js +89 -0
package/dist/components/LogoutPicker.d.ts +8 -0
package/dist/components/LogoutPicker.js +61 -0
package/dist/components/Message.d.ts +10 -0
package/dist/components/Message.js +234 -0
package/dist/components/MessageList.d.ts +10 -0
package/dist/components/MessageList.js +8 -0
package/dist/components/ProjectPermission.d.ts +7 -0
package/dist/components/ProjectPermission.js +52 -0
package/dist/components/Search.d.ts +10 -0
package/dist/components/Search.js +30 -0
package/dist/components/SessionPicker.d.ts +9 -0
package/dist/components/SessionPicker.js +88 -0
package/dist/components/Sessions.d.ts +12 -0
package/dist/components/Sessions.js +102 -0
package/dist/components/Settings.d.ts +7 -0
package/dist/components/Settings.js +162 -0
package/dist/components/Status.d.ts +2 -0
package/dist/components/Status.js +12 -0
package/dist/config/config.test.d.ts +1 -0
package/dist/config/config.test.js +157 -0
package/dist/config/index.d.ts +121 -0
package/dist/config/index.js +555 -0
package/dist/config/providers.d.ts +43 -0
package/dist/config/providers.js +82 -0
package/dist/config/providers.test.d.ts +1 -0
package/dist/config/providers.test.js +132 -0
package/dist/index.d.ts +2 -0
package/dist/index.js +38 -0
package/dist/utils/agent.d.ts +37 -0
package/dist/utils/agent.js +627 -0
package/dist/utils/codeReview.d.ts +36 -0
package/dist/utils/codeReview.js +390 -0
package/dist/utils/context.d.ts +49 -0
package/dist/utils/context.js +216 -0
package/dist/utils/diffPreview.d.ts +57 -0
package/dist/utils/diffPreview.js +335 -0
package/dist/utils/export.d.ts +19 -0
package/dist/utils/export.js +94 -0
package/dist/utils/git.d.ts +85 -0
package/dist/utils/git.js +399 -0
package/dist/utils/git.test.d.ts +1 -0
package/dist/utils/git.test.js +193 -0
package/dist/utils/history.d.ts +93 -0
package/dist/utils/history.js +348 -0
package/dist/utils/interactive.d.ts +34 -0
package/dist/utils/interactive.js +206 -0
package/dist/utils/keychain.d.ts +17 -0
package/dist/utils/keychain.js +160 -0
package/dist/utils/learning.d.ts +89 -0
package/dist/utils/learning.js +330 -0
package/dist/utils/logger.d.ts +33 -0
package/dist/utils/logger.js +130 -0
package/dist/utils/project.d.ts +86 -0
package/dist/utils/project.js +415 -0
package/dist/utils/project.test.d.ts +1 -0
package/dist/utils/project.test.js +212 -0
package/dist/utils/ratelimit.d.ts +26 -0
package/dist/utils/ratelimit.js +132 -0
package/dist/utils/ratelimit.test.d.ts +1 -0
package/dist/utils/ratelimit.test.js +131 -0
package/dist/utils/retry.d.ts +28 -0
package/dist/utils/retry.js +109 -0
package/dist/utils/retry.test.d.ts +1 -0
package/dist/utils/retry.test.js +163 -0
package/dist/utils/search.d.ts +11 -0
package/dist/utils/search.js +29 -0
package/dist/utils/shell.d.ts +45 -0
package/dist/utils/shell.js +242 -0
package/dist/utils/skills.d.ts +144 -0
package/dist/utils/skills.js +1137 -0
package/dist/utils/smartContext.d.ts +29 -0
package/dist/utils/smartContext.js +441 -0
package/dist/utils/tools.d.ts +224 -0
package/dist/utils/tools.js +731 -0
package/dist/utils/update.d.ts +22 -0
package/dist/utils/update.js +128 -0
package/dist/utils/validation.d.ts +28 -0
package/dist/utils/validation.js +141 -0
package/dist/utils/validation.test.d.ts +1 -0
package/dist/utils/validation.test.js +164 -0
package/dist/utils/verify.d.ts +78 -0
package/dist/utils/verify.js +464 -0
package/package.json +68 -0

package/dist/utils/agent.js ADDED Viewed

@@ -0,0 +1,627 @@
+/**
+ * Agent loop - autonomous task execution
+ */
+import { parseToolCalls, executeTool, createActionLog, formatToolDefinitions, getOpenAITools, getAnthropicTools, parseOpenAIToolCalls, parseAnthropicToolCalls } from './tools';
+import { config, getApiKey } from '../config/index';
+import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools } from '../config/providers';
+import { startSession, endSession, undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession } from './history';
+import { runAllVerifications, formatErrorsForAgent, hasVerificationErrors, getVerificationSummary } from './verify';
+import { gatherSmartContext, formatSmartContext, extractTargetFile } from './smartContext';
+const DEFAULT_OPTIONS = {
+    maxIterations: 20,
+    maxDuration: 5 * 60 * 1000, // 5 minutes
+};
+/**
+ * Generate system prompt for agent mode (used with native tool calling)
+ */
+function getAgentSystemPrompt(projectContext) {
+    return `You are an AI coding agent with FULL autonomous access to this project.
+## Your Capabilities
+- Read, write, edit, and delete files and directories
+- Create directories with create_directory tool
+- Execute shell commands (npm, git, build tools, etc.)
+- Search code in the project
+- List directory contents
+## IMPORTANT: Follow User Instructions Exactly
+- Do EXACTLY what the user asks, nothing more
+- If user says "create folder X" -> use create_directory tool to create folder X
+- If user says "delete file X" -> use delete_file tool to delete file X
+- Do NOT interpret or expand simple requests into complex tasks
+- Simple tasks should be completed in 1-2 tool calls
+- The user may write in any language - understand their request and execute it
+- Tool names and parameters must ALWAYS be in English (e.g., "create_directory", not "kreiraj_direktorij")
+## Rules
+1. Always read files before editing them to understand the current content
+2. Use edit_file for modifications to existing files (preserves other content)
+3. Use write_file only for creating new files or complete overwrites
+4. Use create_directory to create new folders/directories
+5. When the task is complete, respond with a summary of what you did
+## Self-Verification
+After you make changes, the system will automatically run build and tests.
+If there are errors, you will receive them and must fix them.
+- Read error messages carefully
+- Fix the specific files and lines mentioned
+- Keep trying until verification passes
+## Project Context
+**Name:** ${projectContext.name}
+**Type:** ${projectContext.type}
+**Structure:**
+\`\`\`
+${projectContext.structure}
+\`\`\`
+**Key Files:** ${projectContext.keyFiles.join(', ')}
+You have FULL READ AND WRITE access. Use the tools to complete tasks autonomously.`;
+}
+/**
+ * Generate fallback system prompt (text-based tool calling)
+ */
+function getFallbackSystemPrompt(projectContext) {
+    return `You are an AI coding agent with FULL autonomous access to this project.
+## IMPORTANT: Follow User Instructions Exactly
+- Do EXACTLY what the user asks, nothing more
+- If user says "create folder X" -> use create_directory tool
+- If user says "delete file X" -> use delete_file tool
+- Do NOT interpret or expand simple requests into complex tasks
+- The user may write in any language - understand and execute
+- Tool names and parameters must ALWAYS be in English
+## Available Tools
+${formatToolDefinitions()}
+## Tool Call Format
+When you need to use a tool, respond with:
+<tool_call>
+{"tool": "tool_name", "parameters": {"param1": "value1"}}
+</tool_call>
+## Examples
+<tool_call>
+{"tool": "create_directory", "parameters": {"path": "my-folder"}}
+</tool_call>
+<tool_call>
+{"tool": "write_file", "parameters": {"path": "test/index.html", "content": "<!DOCTYPE html>..."}}
+</tool_call>
+## Rules
+1. Use the exact format shown above
+2. Always read files before editing
+3. When done, respond WITHOUT tool calls
+## Project: ${projectContext.name} (${projectContext.type})
+${projectContext.structure}
+You have FULL access. Execute tasks autonomously.`;
+}
+/**
+ * Make a chat API call for agent mode with native tool support
+ */
+async function agentChat(messages, systemPrompt, onChunk, abortSignal) {
+    const protocol = config.get('protocol');
+    const model = config.get('model');
+    const apiKey = getApiKey();
+    const providerId = config.get('provider');
+    const baseUrl = getProviderBaseUrl(providerId, protocol);
+    const authHeader = getProviderAuthHeader(providerId, protocol);
+    if (!baseUrl) {
+        throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);
+    }
+    // Check if provider supports native tools - if not, use text-based fallback directly
+    if (!supportsNativeTools(providerId, protocol)) {
+        // Provider doesn't support native tools, use text-based fallback
+        return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), config.get('apiTimeout'));
+    if (abortSignal) {
+        abortSignal.addEventListener('abort', () => controller.abort());
+    }
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (authHeader === 'Bearer') {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    else {
+        headers['x-api-key'] = apiKey;
+    }
+    if (protocol === 'anthropic') {
+        headers['anthropic-version'] = '2023-06-01';
+    }
+    try {
+        let endpoint;
+        let body;
+        if (protocol === 'openai') {
+            endpoint = `${baseUrl}/chat/completions`;
+            body = {
+                model,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    ...messages,
+                ],
+                tools: getOpenAITools(),
+                tool_choice: 'auto',
+                temperature: config.get('temperature'),
+                max_tokens: config.get('maxTokens'),
+            };
+        }
+        else {
+            endpoint = `${baseUrl}/v1/messages`;
+            body = {
+                model,
+                system: systemPrompt,
+                messages: messages,
+                tools: getAnthropicTools(),
+                temperature: config.get('temperature'),
+                max_tokens: config.get('maxTokens'),
+            };
+        }
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            // Check if error is due to tools not being supported - fallback to text mode
+            if (errorText.includes('tools') || errorText.includes('function') || response.status === 400) {
+                return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
+            }
+            throw new Error(`API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        if (protocol === 'openai') {
+            const message = data.choices?.[0]?.message;
+            const content = message?.content || '';
+            const toolCalls = parseOpenAIToolCalls(message?.tool_calls || []);
+            if (onChunk && content) {
+                onChunk(content);
+            }
+            return { content, toolCalls, usedNativeTools: true };
+        }
+        else {
+            // Anthropic format
+            const contentBlocks = data.content || [];
+            let textContent = '';
+            for (const block of contentBlocks) {
+                if (block.type === 'text') {
+                    textContent += block.text;
+                    if (onChunk)
+                        onChunk(block.text);
+                }
+            }
+            const toolCalls = parseAnthropicToolCalls(contentBlocks);
+            return { content: textContent, toolCalls, usedNativeTools: true };
+        }
+    }
+    catch (error) {
+        const err = error;
+        // If native tools failed, try fallback
+        if (err.message.includes('tools') || err.message.includes('function')) {
+            return await agentChatFallback(messages, systemPrompt, onChunk, abortSignal);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Fallback chat without native tools (text-based parsing)
+ */
+async function agentChatFallback(messages, systemPrompt, onChunk, abortSignal) {
+    const protocol = config.get('protocol');
+    const model = config.get('model');
+    const apiKey = getApiKey();
+    const providerId = config.get('provider');
+    const baseUrl = getProviderBaseUrl(providerId, protocol);
+    const authHeader = getProviderAuthHeader(providerId, protocol);
+    if (!baseUrl) {
+        throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), config.get('apiTimeout'));
+    if (abortSignal) {
+        abortSignal.addEventListener('abort', () => controller.abort());
+    }
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (authHeader === 'Bearer') {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    else {
+        headers['x-api-key'] = apiKey;
+    }
+    if (protocol === 'anthropic') {
+        headers['anthropic-version'] = '2023-06-01';
+    }
+    // Use fallback system prompt with text-based tool format
+    const fallbackPrompt = systemPrompt.includes('## Available Tools')
+        ? systemPrompt
+        : systemPrompt + '\n\n' + formatToolDefinitions();
+    try {
+        let endpoint;
+        let body;
+        if (protocol === 'openai') {
+            endpoint = `${baseUrl}/chat/completions`;
+            body = {
+                model,
+                messages: [
+                    { role: 'system', content: fallbackPrompt },
+                    ...messages,
+                ],
+                stream: Boolean(onChunk),
+                temperature: config.get('temperature'),
+                max_tokens: config.get('maxTokens'),
+            };
+        }
+        else {
+            endpoint = `${baseUrl}/v1/messages`;
+            body = {
+                model,
+                messages: [
+                    { role: 'user', content: fallbackPrompt },
+                    { role: 'assistant', content: 'Understood. I will use the tools as specified.' },
+                    ...messages,
+                ],
+                stream: Boolean(onChunk),
+                temperature: config.get('temperature'),
+                max_tokens: config.get('maxTokens'),
+            };
+        }
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`API error: ${response.status} - ${error}`);
+        }
+        let content;
+        if (onChunk && response.body) {
+            content = await handleStream(response.body, protocol, onChunk);
+        }
+        else {
+            const data = await response.json();
+            if (protocol === 'openai') {
+                content = data.choices?.[0]?.message?.content || '';
+            }
+            else {
+                content = data.content?.[0]?.text || '';
+            }
+        }
+        // Parse tool calls from text response
+        const toolCalls = parseToolCalls(content);
+        return { content, toolCalls, usedNativeTools: false };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Handle streaming response
+ */
+async function handleStream(body, protocol, onChunk) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const data = line.slice(6);
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const parsed = JSON.parse(data);
+                    let content;
+                    if (protocol === 'openai') {
+                        content = parsed.choices?.[0]?.delta?.content;
+                    }
+                    else if (parsed.type === 'content_block_delta') {
+                        content = parsed.delta?.text;
+                    }
+                    if (content) {
+                        chunks.push(content);
+                        onChunk(content);
+                    }
+                }
+                catch {
+                    // Skip parse errors
+                }
+            }
+        }
+    }
+    return chunks.join('');
+}
+/**
+ * Run the agent loop
+ */
+export async function runAgent(prompt, projectContext, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const startTime = Date.now();
+    const actions = [];
+    const messages = [];
+    // Start history session for undo support
+    const sessionId = startSession(prompt, projectContext.root || process.cwd());
+    // Gather smart context based on the task
+    const targetFile = extractTargetFile(prompt);
+    const smartContext = gatherSmartContext(targetFile, projectContext, prompt);
+    const smartContextStr = formatSmartContext(smartContext);
+    // Check if provider supports native tools
+    const protocol = config.get('protocol');
+    const providerId = config.get('provider');
+    const useNativeTools = supportsNativeTools(providerId, protocol);
+    // Build system prompt - use fallback format if native tools not supported
+    let systemPrompt = useNativeTools
+        ? getAgentSystemPrompt(projectContext)
+        : getFallbackSystemPrompt(projectContext);
+    if (smartContextStr) {
+        systemPrompt += '\n\n' + smartContextStr;
+    }
+    // Initial user message
+    messages.push({ role: 'user', content: prompt });
+    let iteration = 0;
+    let finalResponse = '';
+    let result;
+    try {
+        while (iteration < opts.maxIterations) {
+            // Check timeout
+            if (Date.now() - startTime > opts.maxDuration) {
+                result = {
+                    success: false,
+                    iterations: iteration,
+                    actions,
+                    finalResponse: 'Agent timed out',
+                    error: `Exceeded maximum duration of ${opts.maxDuration / 1000} seconds`,
+                };
+                return result;
+            }
+            // Check abort signal
+            if (opts.abortSignal?.aborted) {
+                result = {
+                    success: false,
+                    iterations: iteration,
+                    actions,
+                    finalResponse: 'Agent was stopped by user',
+                    aborted: true,
+                };
+                return result;
+            }
+            iteration++;
+            opts.onIteration?.(iteration, `Iteration ${iteration}/${opts.maxIterations}`);
+            // Get AI response
+            let chatResponse;
+            try {
+                chatResponse = await agentChat(messages, systemPrompt, opts.onThinking, opts.abortSignal);
+            }
+            catch (error) {
+                const err = error;
+                if (err.name === 'AbortError') {
+                    result = {
+                        success: false,
+                        iterations: iteration,
+                        actions,
+                        finalResponse: 'Agent was stopped',
+                        aborted: true,
+                    };
+                    return result;
+                }
+                throw error;
+            }
+            let { content, toolCalls, usedNativeTools } = chatResponse;
+            // If native tools were used but no tool calls returned, try parsing text-based tool calls
+            // This handles models that accept tools parameter but respond with text anyway
+            if (usedNativeTools && toolCalls.length === 0 && iteration === 1) {
+                const textToolCalls = parseToolCalls(content);
+                if (textToolCalls.length > 0) {
+                    toolCalls = textToolCalls;
+                }
+            }
+            // If no tool calls, this is the final response
+            if (toolCalls.length === 0) {
+                // Remove <think>...</think> tags from response (some models include thinking)
+                finalResponse = content.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+                break;
+            }
+            // Add assistant response to history
+            messages.push({ role: 'assistant', content });
+            // Execute tool calls
+            const toolResults = [];
+            for (const toolCall of toolCalls) {
+                opts.onToolCall?.(toolCall);
+                let toolResult;
+                if (opts.dryRun) {
+                    // In dry run mode, simulate success
+                    toolResult = {
+                        success: true,
+                        output: `[DRY RUN] Would execute: ${toolCall.tool}`,
+                        tool: toolCall.tool,
+                        parameters: toolCall.parameters,
+                    };
+                }
+                else {
+                    // Actually execute the tool
+                    toolResult = executeTool(toolCall, projectContext.root || process.cwd());
+                }
+                opts.onToolResult?.(toolResult);
+                // Log action
+                const actionLog = createActionLog(toolCall, toolResult);
+                actions.push(actionLog);
+                // Format result for AI
+                if (toolResult.success) {
+                    toolResults.push(`Tool ${toolCall.tool} succeeded:\n${toolResult.output}`);
+                }
+                else {
+                    toolResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);
+                }
+            }
+            // Add tool results to messages
+            messages.push({
+                role: 'user',
+                content: `Tool results:\n\n${toolResults.join('\n\n')}\n\nContinue with the task. If done, provide a final summary without any tool calls.`,
+            });
+        }
+        // Check if we hit max iterations
+        if (iteration >= opts.maxIterations && !finalResponse) {
+            result = {
+                success: false,
+                iterations: iteration,
+                actions,
+                finalResponse: 'Agent reached maximum iterations',
+                error: `Exceeded maximum of ${opts.maxIterations} iterations`,
+            };
+            return result;
+        }
+        // Self-verification: Run build/test and fix errors if needed
+        const autoVerify = opts.autoVerify ?? config.get('agentAutoVerify');
+        const maxFixAttempts = opts.maxFixAttempts ?? config.get('agentMaxFixAttempts');
+        if (autoVerify && !opts.dryRun) {
+            // Check if we made any file changes worth verifying
+            const hasFileChanges = actions.some(a => a.type === 'write' || a.type === 'edit' || a.type === 'delete');
+            if (hasFileChanges) {
+                let fixAttempt = 0;
+                while (fixAttempt < maxFixAttempts) {
+                    // Check abort signal
+                    if (opts.abortSignal?.aborted) {
+                        break;
+                    }
+                    opts.onIteration?.(iteration, `Verification attempt ${fixAttempt + 1}/${maxFixAttempts}`);
+                    // Run verifications
+                    const verifyResults = runAllVerifications(projectContext.root || process.cwd(), {
+                        runBuild: true,
+                        runTest: true,
+                        runTypecheck: true,
+                        runLint: false,
+                    });
+                    opts.onVerification?.(verifyResults);
+                    // Check if all passed
+                    if (!hasVerificationErrors(verifyResults)) {
+                        const summary = getVerificationSummary(verifyResults);
+                        finalResponse += `\n\n✓ Verification passed: ${summary.passed}/${summary.total} checks`;
+                        break;
+                    }
+                    fixAttempt++;
+                    // If we've exceeded attempts, report the errors
+                    if (fixAttempt >= maxFixAttempts) {
+                        const summary = getVerificationSummary(verifyResults);
+                        finalResponse += `\n\n✗ Verification failed after ${fixAttempt} fix attempts: ${summary.errors} errors remaining`;
+                        break;
+                    }
+                    // Ask agent to fix the errors
+                    const errorMessage = formatErrorsForAgent(verifyResults);
+                    messages.push({ role: 'assistant', content: finalResponse });
+                    messages.push({
+                        role: 'user',
+                        content: `${errorMessage}\n\nFix these errors. After fixing, I will re-run verification.`
+                    });
+                    iteration++;
+                    if (iteration >= opts.maxIterations) {
+                        break;
+                    }
+                    // Get AI response to fix errors
+                    try {
+                        const fixResponse = await agentChat(messages, systemPrompt, opts.onThinking, opts.abortSignal);
+                        const { content: fixContent, toolCalls: fixToolCalls } = fixResponse;
+                        if (fixToolCalls.length === 0) {
+                            // Agent gave up or thinks it's fixed
+                            finalResponse = fixContent.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+                            continue; // Re-run verification
+                        }
+                        // Execute fix tool calls
+                        messages.push({ role: 'assistant', content: fixContent });
+                        const fixResults = [];
+                        for (const toolCall of fixToolCalls) {
+                            opts.onToolCall?.(toolCall);
+                            const toolResult = executeTool(toolCall, projectContext.root || process.cwd());
+                            opts.onToolResult?.(toolResult);
+                            const actionLog = createActionLog(toolCall, toolResult);
+                            actions.push(actionLog);
+                            if (toolResult.success) {
+                                fixResults.push(`Tool ${toolCall.tool} succeeded:\n${toolResult.output}`);
+                            }
+                            else {
+                                fixResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);
+                            }
+                        }
+                        messages.push({
+                            role: 'user',
+                            content: `Fix results:\n\n${fixResults.join('\n\n')}\n\nContinue fixing if needed. Re-running verification...`,
+                        });
+                    }
+                    catch (error) {
+                        // If fix attempt failed, continue to next attempt
+                        break;
+                    }
+                }
+            }
+        }
+        result = {
+            success: true,
+            iterations: iteration,
+            actions,
+            finalResponse,
+        };
+        return result;
+    }
+    catch (error) {
+        const err = error;
+        result = {
+            success: false,
+            iterations: iteration,
+            actions,
+            finalResponse: '',
+            error: err.message,
+        };
+        return result;
+    }
+    finally {
+        // End session and save history
+        endSession();
+    }
+}
+/**
+ * Format agent result for display
+ */
+export function formatAgentResult(result) {
+    const lines = [];
+    if (result.success) {
+        lines.push(`Agent completed in ${result.iterations} iteration(s)`);
+    }
+    else if (result.aborted) {
+        lines.push('Agent was stopped by user');
+    }
+    else {
+        lines.push(`Agent failed: ${result.error}`);
+    }
+    if (result.actions.length > 0) {
+        lines.push('');
+        lines.push('Actions performed:');
+        for (const action of result.actions) {
+            const status = action.result === 'success' ? '✓' : '✗';
+            lines.push(`  ${status} ${action.type}: ${action.target}`);
+        }
+    }
+    return lines.join('\n');
+}
+// Re-export history functions for undo support
+export { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession };

package/dist/utils/codeReview.d.ts ADDED Viewed

@@ -0,0 +1,36 @@
+/**
+ * Code Review Mode - AI-powered code review
+ */
+import { ProjectContext } from './project';
+export interface ReviewIssue {
+    file: string;
+    line?: number;
+    severity: 'error' | 'warning' | 'info' | 'suggestion';
+    category: ReviewCategory;
+    message: string;
+    suggestion?: string;
+}
+export type ReviewCategory = 'security' | 'performance' | 'maintainability' | 'bug' | 'style' | 'types' | 'best-practice' | 'documentation';
+export interface ReviewResult {
+    files: string[];
+    issues: ReviewIssue[];
+    summary: ReviewSummary;
+    score: number;
+}
+export interface ReviewSummary {
+    totalIssues: number;
+    byCategory: Record<ReviewCategory, number>;
+    bySeverity: Record<string, number>;
+}
+/**
+ * Perform code review
+ */
+export declare function performCodeReview(projectContext: ProjectContext, specificFiles?: string[]): ReviewResult;
+/**
+ * Format review result for display
+ */
+export declare function formatReviewResult(result: ReviewResult): string;
+/**
+ * Get review prompt for AI-enhanced review
+ */
+export declare function getReviewSystemPrompt(result: ReviewResult): string;