codeep 1.1.35 → 1.2.0

package/dist/renderer/main.js

@@ -15,12 +15,15 @@ import { config, loadApiKey, loadAllApiKeys, getCurrentProvider, getModelsForCur
 import { isProjectDirectory, getProjectContext } from '../utils/project.js';
 import { getCurrentVersion } from '../utils/update.js';
 import { getProviderList } from '../config/providers.js';
+import { getSessionStats } from '../utils/tokenTracker.js';
 // State
 let projectPath = process.cwd();
 let projectContext = null;
 let hasWriteAccess = false;
 let sessionId = getCurrentSessionId();
 let app;
+// Added file context (/add, /drop)
+const addedFiles = new Map();
 /**
  * Get current status
  */
@@ -28,6 +31,7 @@ function getStatus() {
     const provider = getCurrentProvider();
     const providers = getProviderList();
     const providerInfo = providers.find(p => p.id === provider.id);
+    const stats = getSessionStats();
     return {
         version: getCurrentVersion(),
         provider: providerInfo?.name || 'Unknown',
@@ -37,14 +41,29 @@ function getStatus() {
         hasWriteAccess,
         sessionId,
         messageCount: 0, // Will be updated
+        tokenStats: {
+            totalTokens: stats.totalTokens,
+            promptTokens: stats.totalPromptTokens,
+            completionTokens: stats.totalCompletionTokens,
+            requestCount: stats.requestCount,
+        },
     };
 }
 // Agent state
 let isAgentRunning = false;
 let agentAbortController = null;
 /**
- * Handle chat submission
+ * Format added files as context to prepend to user messages
  */
+function formatAddedFilesContext() {
+    if (addedFiles.size === 0)
+        return '';
+    const parts = ['[Attached files]'];
+    for (const [, file] of addedFiles) {
+        parts.push(`\nFile: ${file.relativePath}\n\`\`\`\n${file.content}\n\`\`\``);
+    }
+    return parts.join('\n') + '\n\n';
+}
 async function handleSubmit(message) {
     // Check if we're waiting for interactive mode answers
     if (pendingInteractiveContext) {
@@ -112,7 +131,10 @@ async function handleSubmit(message) {
         app.startStreaming();
         // Get conversation history for context
         const history = app.getChatHistory();
-        const response = await chat(message, history, (chunk) => {
+        // Prepend added file context if any
+        const fileContext = formatAddedFilesContext();
+        const enrichedMessage = fileContext ? fileContext + message : message;
+        const response = await chat(enrichedMessage, history, (chunk) => {
             app.addStreamChunk(chunk);
         }, undefined, projectContext, undefined);
         app.endStreaming();
@@ -290,7 +312,10 @@ async function executeAgentTask(task, dryRun = false) {
     // Store context in local variable for TypeScript narrowing
     const context = projectContext;
     try {
-        const result = await runAgent(task, context, {
+        // Enrich task with added file context if any
+        const fileContext = formatAddedFilesContext();
+        const enrichedTask = fileContext ? fileContext + task : task;
+        const result = await runAgent(enrichedTask, context, {
             dryRun,
             onIteration: (iteration) => {
                 app.updateAgentProgress(iteration);
@@ -312,37 +337,64 @@ async function executeAgentTask(task, dryRun = false) {
                 // Update agent thinking
                 const shortTarget = target.length > 50 ? '...' + target.slice(-47) : target;
                 app.setAgentThinking(`${actionType}: ${shortTarget}`);
-                // Set code preview and add chat message for write/edit operations
+                // Add chat message with diff preview for write/edit operations
                 if (actionType === 'write' && tool.parameters.content) {
                     const filePath = tool.parameters.path;
-                    const ext = filePath.split('.').pop() || '';
-                    app.addMessage({
-                        role: 'system',
-                        content: `**Write** \`${filePath}\`\n\n\`\`\`${ext}\n${tool.parameters.content}\n\`\`\``,
-                    });
-                    app.setAgentCodePreview({
-                        path: filePath,
-                        actionType: 'write',
-                        content: tool.parameters.content,
-                    });
+                    try {
+                        const { createFileDiff, formatDiffForDisplay } = require('../utils/diffPreview');
+                        const diff = createFileDiff(filePath, tool.parameters.content, context.root);
+                        const diffText = formatDiffForDisplay(diff);
+                        const additions = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === 'add').length, 0);
+                        const deletions = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === 'remove').length, 0);
+                        app.addMessage({
+                            role: 'system',
+                            content: `**${diff.type === 'create' ? 'Create' : 'Write'}** \`${filePath}\` (+${additions} -${deletions})\n\n\`\`\`diff\n${diffText}\n\`\`\``,
+                        });
+                    }
+                    catch {
+                        const ext = filePath.split('.').pop() || '';
+                        app.addMessage({
+                            role: 'system',
+                            content: `**Write** \`${filePath}\`\n\n\`\`\`${ext}\n${tool.parameters.content}\n\`\`\``,
+                        });
+                    }
                 }
                 else if (actionType === 'edit' && tool.parameters.new_text) {
                     const filePath = tool.parameters.path;
-                    const ext = filePath.split('.').pop() || '';
+                    try {
+                        const { createEditDiff, formatDiffForDisplay } = require('../utils/diffPreview');
+                        const diff = createEditDiff(filePath, tool.parameters.old_text, tool.parameters.new_text, context.root);
+                        if (diff) {
+                            const additions = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === 'add').length, 0);
+                            const deletions = diff.hunks.reduce((sum, h) => sum + h.lines.filter((l) => l.type === 'remove').length, 0);
+                            app.addMessage({
+                                role: 'system',
+                                content: `**Edit** \`${filePath}\` (+${additions} -${deletions})\n\n\`\`\`diff\n${formatDiffForDisplay(diff)}\n\`\`\``,
+                            });
+                        }
+                        else {
+                            const ext = filePath.split('.').pop() || '';
+                            app.addMessage({
+                                role: 'system',
+                                content: `**Edit** \`${filePath}\`\n\n\`\`\`${ext}\n${tool.parameters.new_text}\n\`\`\``,
+                            });
+                        }
+                    }
+                    catch {
+                        const ext = filePath.split('.').pop() || '';
+                        app.addMessage({
+                            role: 'system',
+                            content: `**Edit** \`${filePath}\`\n\n\`\`\`${ext}\n${tool.parameters.new_text}\n\`\`\``,
+                        });
+                    }
+                }
+                else if (actionType === 'delete') {
+                    const filePath = tool.parameters.path;
                     app.addMessage({
                         role: 'system',
-                        content: `**Edit** \`${filePath}\`\n\n\`\`\`${ext}\n${tool.parameters.new_text}\n\`\`\``,
-                    });
-                    app.setAgentCodePreview({
-                        path: filePath,
-                        actionType: 'edit',
-                        content: tool.parameters.new_text,
-                        oldContent: tool.parameters.old_text,
+                        content: `**Delete** \`${filePath}\``,
                     });
                 }
-                else {
-                    app.setAgentCodePreview(null);
-                }
             },
             onToolResult: (result, toolCall) => {
                 const toolName = toolCall.tool.toLowerCase();
@@ -374,6 +426,34 @@ async function executeAgentTask(task, dryRun = false) {
             const summary = result.finalResponse || `Completed ${result.actions.length} actions in ${result.iterations} steps.`;
             app.addMessage({ role: 'assistant', content: summary });
             app.notify(`Agent completed: ${result.actions.length} actions`);
+            // Auto-commit if enabled and there were file changes
+            if (!dryRun && config.get('agentAutoCommit') && result.actions.length > 0) {
+                try {
+                    const { autoCommitAgentChanges, createBranchAndCommit } = await import('../utils/git.js');
+                    const useBranch = config.get('agentAutoCommitBranch');
+                    if (useBranch) {
+                        const commitResult = createBranchAndCommit(task, result.actions, context.root);
+                        if (commitResult.success) {
+                            app.addMessage({ role: 'system', content: `Auto-committed on branch \`${commitResult.branch}\` (${commitResult.hash?.slice(0, 7)})` });
+                        }
+                        else if (commitResult.error !== 'No changes detected by git') {
+                            app.addMessage({ role: 'system', content: `Auto-commit failed: ${commitResult.error}` });
+                        }
+                    }
+                    else {
+                        const commitResult = autoCommitAgentChanges(task, result.actions, context.root);
+                        if (commitResult.success) {
+                            app.addMessage({ role: 'system', content: `Auto-committed: ${commitResult.hash?.slice(0, 7)}` });
+                        }
+                        else if (commitResult.error !== 'No changes detected by git') {
+                            app.addMessage({ role: 'system', content: `Auto-commit failed: ${commitResult.error}` });
+                        }
+                    }
+                }
+                catch {
+                    // Silently ignore commit errors
+                }
+            }
         }
         else if (result.aborted) {
             app.addMessage({ role: 'assistant', content: 'Agent stopped by user.' });
@@ -397,6 +477,91 @@ async function executeAgentTask(task, dryRun = false) {
         app.setAgentRunning(false);
     }
 }
+/**
+ * Run a skill by name or shortcut with the given args.
+ * Wires the skill execution engine to App's UI.
+ */
+async function runSkill(nameOrShortcut, args) {
+    const { findSkill, parseSkillArgs, executeSkill, trackSkillUsage } = await import('../utils/skills.js');
+    const skill = findSkill(nameOrShortcut);
+    if (!skill)
+        return false;
+    // Pre-flight checks
+    if (skill.requiresGit) {
+        const { getGitStatus } = await import('../utils/git.js');
+        if (!projectPath || !getGitStatus(projectPath).isRepo) {
+            app.notify('This skill requires a git repository');
+            return true;
+        }
+    }
+    if (skill.requiresWriteAccess && !hasWriteAccess) {
+        app.notify('This skill requires write access. Use /grant first.');
+        return true;
+    }
+    const params = parseSkillArgs(args.join(' '), skill);
+    app.addMessage({ role: 'user', content: `/${skill.name}${args.length ? ' ' + args.join(' ') : ''}` });
+    trackSkillUsage(skill.name);
+    const { execSync } = await import('child_process');
+    try {
+        const result = await executeSkill(skill, params, {
+            onCommand: async (cmd) => {
+                try {
+                    const output = execSync(cmd, {
+                        cwd: projectPath || process.cwd(),
+                        encoding: 'utf-8',
+                        timeout: 60000,
+                    });
+                    return output.trim();
+                }
+                catch (err) {
+                    const error = err;
+                    throw new Error(error.stderr || error.message || 'Command failed');
+                }
+            },
+            onPrompt: (prompt) => {
+                return new Promise((resolve, reject) => {
+                    handleSubmit(prompt).then(() => {
+                        // The AI response will be displayed in chat.
+                        // We resolve with an empty string since the response is already shown.
+                        resolve('');
+                    }).catch(reject);
+                });
+            },
+            onAgent: (task) => {
+                return new Promise((resolve, reject) => {
+                    if (!projectContext) {
+                        reject(new Error('Agent requires project context'));
+                        return;
+                    }
+                    runAgentTask(task).then(() => resolve('Agent completed')).catch(reject);
+                });
+            },
+            onConfirm: (message) => {
+                return new Promise((resolve) => {
+                    app.showConfirm({
+                        title: 'Confirm',
+                        message: [message],
+                        confirmLabel: 'Yes',
+                        cancelLabel: 'No',
+                        onConfirm: () => resolve(true),
+                        onCancel: () => resolve(false),
+                    });
+                });
+            },
+            onNotify: (message) => {
+                app.notify(message);
+            },
+        });
+        if (!result.success && result.output !== 'Cancelled by user') {
+            app.notify(`Skill failed: ${result.output}`);
+        }
+    }
+    catch (err) {
+        app.notify(`Skill error: ${err.message}`);
+        trackSkillUsage(skill.name, false);
+    }
+    return true;
+}
 /**
  * Run a chain of commands sequentially
  */
@@ -560,28 +725,6 @@ function handleCommand(command, args) {
             });
             break;
         }
-        case 'commit': {
-            if (!projectContext) {
-                app.notify('No project context');
-                return;
-            }
-            import('../utils/git.js').then(({ getGitDiff, getGitStatus, suggestCommitMessage }) => {
-                const status = getGitStatus(projectPath);
-                if (!status.isRepo) {
-                    app.notify('Not a git repository');
-                    return;
-                }
-                const diff = getGitDiff(true, projectPath);
-                if (!diff.success || !diff.diff) {
-                    app.notify('No staged changes. Use git add first.');
-                    return;
-                }
-                const suggestion = suggestCommitMessage(diff.diff);
-                app.addMessage({ role: 'user', content: '/commit' });
-                handleSubmit(`Generate a commit message for these staged changes. Suggestion: "${suggestion}"\n\nDiff:\n\`\`\`diff\n${diff.diff.slice(0, 2000)}\n\`\`\``);
-            });
-            break;
-        }
         case 'undo': {
             import('../utils/agent.js').then(({ undoLastAction }) => {
                 const result = undoLastAction();
@@ -980,6 +1123,81 @@ function handleCommand(command, args) {
             });
             break;
         }
+        // File context commands
+        case 'add': {
+            if (!args.length) {
+                if (addedFiles.size === 0) {
+                    app.notify('Usage: /add <file-path> [file2] ... | No files added');
+                }
+                else {
+                    const fileList = Array.from(addedFiles.values()).map(f => f.relativePath).join(', ');
+                    app.notify(`Added files (${addedFiles.size}): ${fileList}`);
+                }
+                return;
+            }
+            const path = require('path');
+            const fs = require('fs');
+            const root = projectContext?.root || projectPath;
+            let added = 0;
+            const errors = [];
+            for (const filePath of args) {
+                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(root, filePath);
+                const relativePath = path.isAbsolute(filePath) ? path.relative(root, filePath) : filePath;
+                try {
+                    const stat = fs.statSync(fullPath);
+                    if (!stat.isFile()) {
+                        errors.push(`${filePath}: not a file`);
+                        continue;
+                    }
+                    if (stat.size > 100000) {
+                        errors.push(`${filePath}: too large (${Math.round(stat.size / 1024)}KB, max 100KB)`);
+                        continue;
+                    }
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    addedFiles.set(fullPath, { relativePath, content });
+                    added++;
+                }
+                catch {
+                    errors.push(`${filePath}: file not found`);
+                }
+            }
+            if (added > 0) {
+                app.notify(`Added ${added} file(s) to context (${addedFiles.size} total)`);
+            }
+            if (errors.length > 0) {
+                app.notify(errors.join(', '));
+            }
+            break;
+        }
+        case 'drop': {
+            if (!args.length) {
+                if (addedFiles.size === 0) {
+                    app.notify('No files in context');
+                }
+                else {
+                    const count = addedFiles.size;
+                    addedFiles.clear();
+                    app.notify(`Dropped all ${count} file(s) from context`);
+                }
+                return;
+            }
+            const path = require('path');
+            const root = projectContext?.root || projectPath;
+            let dropped = 0;
+            for (const filePath of args) {
+                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(root, filePath);
+                if (addedFiles.delete(fullPath)) {
+                    dropped++;
+                }
+            }
+            if (dropped > 0) {
+                app.notify(`Dropped ${dropped} file(s) (${addedFiles.size} remaining)`);
+            }
+            else {
+                app.notify('File not found in context. Use /add to see added files.');
+            }
+            break;
+        }
         // Agent history and changes
         case 'history': {
             import('../utils/agent.js').then(({ getAgentHistory }) => {
@@ -1121,120 +1339,37 @@ function handleCommand(command, args) {
             break;
         }
         // Skills shortcuts
-        case 'c': {
-            handleCommand('commit', []);
-            break;
-        }
-        case 't': {
-            if (!projectContext) {
-                app.notify('No project context');
-                return;
-            }
-            app.addMessage({ role: 'user', content: '/test' });
-            handleSubmit('Generate and run tests for the current project. Focus on untested code.');
-            break;
-        }
-        case 'd': {
-            if (!projectContext) {
-                app.notify('No project context');
-                return;
-            }
-            app.addMessage({ role: 'user', content: '/docs' });
-            handleSubmit('Add documentation to the code. Focus on functions and classes that lack proper documentation.');
-            break;
-        }
-        case 'r': {
-            if (!projectContext) {
-                app.notify('No project context');
-                return;
-            }
-            app.addMessage({ role: 'user', content: '/refactor' });
-            handleSubmit('Refactor the code to improve quality, readability, and maintainability.');
-            break;
-        }
-        case 'f': {
-            if (!projectContext) {
-                app.notify('No project context');
-                return;
-            }
-            app.addMessage({ role: 'user', content: '/fix' });
-            handleSubmit('Debug and fix any issues in the current code. Look for bugs, errors, and potential problems.');
-            break;
-        }
-        case 'e': {
-            if (!args.length) {
-                app.notify('Usage: /e <file or code to explain>');
-                return;
-            }
-            app.addMessage({ role: 'user', content: `/explain ${args.join(' ')}` });
-            handleSubmit(`Explain this code or concept: ${args.join(' ')}`);
-            break;
-        }
-        case 'o': {
-            if (!projectContext) {
-                app.notify('No project context');
-                return;
-            }
-            app.addMessage({ role: 'user', content: '/optimize' });
-            handleSubmit('Optimize the code for better performance. Focus on efficiency and speed improvements.');
-            break;
-        }
-        case 'b': {
-            if (!projectContext) {
-                app.notify('No project context');
-                return;
-            }
-            app.addMessage({ role: 'user', content: '/debug' });
-            handleSubmit('Help debug the current issue. Analyze the code and identify the root cause of problems.');
-            break;
-        }
-        case 'p': {
-            // Push shortcut
-            import('child_process').then(({ execSync }) => {
-                try {
-                    execSync('git push', { cwd: projectPath, encoding: 'utf-8' });
-                    app.notify('Pushed successfully');
-                }
-                catch (err) {
-                    app.notify(`Push failed: ${err.message}`);
-                }
-            });
-            break;
-        }
-        // Full skill names
+        // Skill shortcuts and full names — delegated to skill execution engine
+        case 'c':
+        case 'commit':
+        case 't':
         case 'test':
+        case 'd':
         case 'docs':
+        case 'r':
         case 'refactor':
+        case 'f':
         case 'fix':
+        case 'e':
         case 'explain':
+        case 'o':
         case 'optimize':
-        case 'debug': {
-            const skillMap = {
-                test: 't',
-                docs: 'd',
-                refactor: 'r',
-                fix: 'f',
-                explain: 'e',
-                optimize: 'o',
-                debug: 'b',
-            };
-            handleCommand(skillMap[command], args);
-            break;
-        }
-        case 'push': {
-            handleCommand('p', args);
-            break;
-        }
-        case 'pull': {
-            import('child_process').then(({ execSync }) => {
-                try {
-                    execSync('git pull', { cwd: projectPath, encoding: 'utf-8' });
-                    app.notify('Pulled successfully');
-                }
-                catch (err) {
-                    app.notify(`Pull failed: ${err.message}`);
-                }
-            });
+        case 'b':
+        case 'debug':
+        case 'p':
+        case 'push':
+        case 'pull':
+        case 'amend':
+        case 'pr':
+        case 'changelog':
+        case 'branch':
+        case 'stash':
+        case 'unstash':
+        case 'build':
+        case 'deploy':
+        case 'release':
+        case 'publish': {
+            runSkill(command, args);
             break;
         }
         case 'skills': {
@@ -1336,7 +1471,12 @@ function handleCommand(command, args) {
             break;
         }
         default:
-            app.notify(`Unknown command: /${command}`);
+            // Try to run as a skill (handles custom skills and any built-in not in the switch)
+            runSkill(command, args).then(handled => {
+                if (!handled) {
+                    app.notify(`Unknown command: /${command}`);
+                }
+            });
     }
 }
 /**

package/dist/utils/agent.d.ts

@@ -30,6 +30,11 @@ export interface AgentResult {
     error?: string;
     aborted?: boolean;
 }
+/**
+ * Load project rules from .codeep/rules.md or CODEEP.md
+ * Returns the rules content formatted for system prompt, or empty string if no rules found
+ */
+export declare function loadProjectRules(projectRoot: string): string;
 /**
  * Run the agent loop
  */