codeep 1.2.16 → 1.2.18

package/dist/renderer/Input.js

@@ -448,8 +448,15 @@ export class LineEditor {
                 }
                 break;
             default:
+                // Alt+b / Alt+f — word jump (macOS Option+Left/Right)
+                if (event.alt && event.key === 'b') {
+                    this.wordLeft();
+                }
+                else if (event.alt && event.key === 'f') {
+                    this.wordRight();
+                }
                 // Regular character (single char, not control)
-                if (event.key.length === 1 && !event.ctrl && !event.alt) {
+                else if (event.key.length === 1 && !event.ctrl && !event.alt) {
                     this.value = this.value.slice(0, this.cursorPos) + event.key + this.value.slice(this.cursorPos);
                     this.cursorPos++;
                 }

package/dist/renderer/agentExecution.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Agent task execution, skill dispatch, and command chaining.
+ *
+ * Extracted from main.ts to keep the entry point lean. All functions
+ * receive an AppExecutionContext so they remain decoupled from the
+ * global variables in main.ts.
+ */
+import { App } from './App';
+import { ProjectContext } from '../utils/project';
+export interface AppExecutionContext {
+    app: App;
+    projectPath: string;
+    projectContext: ProjectContext | null;
+    hasWriteAccess: boolean;
+    addedFiles: Map<string, {
+        relativePath: string;
+        content: string;
+    }>;
+    isAgentRunning: () => boolean;
+    setAgentRunning: (v: boolean) => void;
+    abortController: AbortController | null;
+    setAbortController: (ctrl: AbortController | null) => void;
+    formatAddedFilesContext: () => string;
+    handleCommand: (command: string, args: string[]) => Promise<void>;
+}
+export declare function isDangerousTool(toolName: string, parameters: Record<string, unknown>): boolean;
+export declare function requestToolConfirmation(app: App, tool: string, parameters: Record<string, unknown>, onConfirm: () => void, onCancel: () => void): void;
+export interface PendingInteractiveContext {
+    originalTask: string;
+    context: import('../utils/interactive').InteractiveContext;
+    dryRun: boolean;
+}
+export declare function runAgentTask(task: string, dryRun: boolean, ctx: AppExecutionContext, getPendingInteractive: () => PendingInteractiveContext | null, setPendingInteractive: (v: PendingInteractiveContext | null) => void): Promise<void>;
+export declare function executeAgentTask(task: string, dryRun: boolean, ctx: AppExecutionContext): Promise<void>;
+export declare function runSkill(nameOrShortcut: string, args: string[], ctx: AppExecutionContext): Promise<boolean>;
+export declare function runCommandChain(commands: string[], index: number, ctx: AppExecutionContext): void;

package/dist/renderer/agentExecution.js

@@ -0,0 +1,394 @@
+/**
+ * Agent task execution, skill dispatch, and command chaining.
+ *
+ * Extracted from main.ts to keep the entry point lean. All functions
+ * receive an AppExecutionContext so they remain decoupled from the
+ * global variables in main.ts.
+ */
+import { chat } from '../api/index.js';
+import { runAgent } from '../utils/agent.js';
+import { config, autoSaveSession } from '../config/index.js';
+import { getGitStatus } from '../utils/git.js';
+// ─── Dangerous tool detection ────────────────────────────────────────────────
+const DANGEROUS_TOOLS = ['write', 'edit', 'delete', 'command', 'execute', 'shell', 'rm', 'mv'];
+export function isDangerousTool(toolName, parameters) {
+    const lowerName = toolName.toLowerCase();
+    if (DANGEROUS_TOOLS.some(d => lowerName.includes(d)))
+        return true;
+    const command = parameters.command || '';
+    const dangerousCommands = ['rm ', 'rm -', 'rmdir', 'del ', 'delete', 'drop ', 'truncate'];
+    return dangerousCommands.some(c => command.toLowerCase().includes(c));
+}
+export function requestToolConfirmation(app, tool, parameters, onConfirm, onCancel) {
+    const target = parameters.path ||
+        parameters.command ||
+        parameters.pattern ||
+        'unknown';
+    const shortTarget = target.length > 50 ? '...' + target.slice(-47) : target;
+    app.showConfirm({
+        title: '⚠️  Confirm Action',
+        message: [
+            `The agent wants to execute:`,
+            '',
+            `  ${tool}`,
+            `  ${shortTarget}`,
+            '',
+            'Allow this action?',
+        ],
+        confirmLabel: 'Allow',
+        cancelLabel: 'Deny',
+        onConfirm,
+        onCancel,
+    });
+}
+// ─── Agent task execution ─────────────────────────────────────────────────────
+export async function runAgentTask(task, dryRun, ctx, getPendingInteractive, setPendingInteractive) {
+    const { app, projectContext } = ctx;
+    if (!projectContext) {
+        app.notify('Agent requires project context');
+        return;
+    }
+    if (!ctx.hasWriteAccess && !dryRun) {
+        app.notify('Agent requires write access. Use /grant first.');
+        return;
+    }
+    if (ctx.isAgentRunning()) {
+        app.notify('Agent already running. Use /stop to cancel.');
+        return;
+    }
+    const interactiveMode = config.get('agentInteractive') !== false;
+    if (interactiveMode) {
+        const { analyzeForClarification, formatQuestions } = await import('../utils/interactive.js');
+        const interactiveContext = analyzeForClarification(task);
+        if (interactiveContext.needsClarification) {
+            setPendingInteractive({ originalTask: task, context: interactiveContext, dryRun });
+            app.addMessage({ role: 'assistant', content: formatQuestions(interactiveContext) });
+            app.notify('Answer questions or type "proceed" to continue');
+            return;
+        }
+    }
+    const confirmationMode = config.get('agentConfirmation') || 'dangerous';
+    if (confirmationMode === 'never' || dryRun) {
+        executeAgentTask(task, dryRun, ctx);
+        return;
+    }
+    if (confirmationMode === 'always') {
+        const shortTask = task.length > 60 ? task.slice(0, 57) + '...' : task;
+        app.showConfirm({
+            title: '⚠️  Confirm Agent Task',
+            message: [
+                'The agent will execute the following task:',
+                '',
+                `  "${shortTask}"`,
+                '',
+                'This may modify files in your project.',
+                'Do you want to proceed?',
+            ],
+            confirmLabel: 'Run Agent',
+            cancelLabel: 'Cancel',
+            onConfirm: () => executeAgentTask(task, dryRun, ctx),
+            onCancel: () => app.notify('Agent task cancelled'),
+        });
+        return;
+    }
+    // 'dangerous' mode — confirm only for risky keywords
+    const dangerousKeywords = ['delete', 'remove', 'drop', 'reset', 'force', 'overwrite', 'replace all', 'rm ', 'clear'];
+    if (dangerousKeywords.some(k => task.toLowerCase().includes(k))) {
+        const shortTask = task.length > 60 ? task.slice(0, 57) + '...' : task;
+        app.showConfirm({
+            title: '⚠️  Potentially Dangerous Task',
+            message: [
+                'This task contains potentially dangerous operations:',
+                '',
+                `  "${shortTask}"`,
+                '',
+                'Files may be deleted or overwritten.',
+                'Do you want to proceed?',
+            ],
+            confirmLabel: 'Proceed',
+            cancelLabel: 'Cancel',
+            onConfirm: () => executeAgentTask(task, dryRun, ctx),
+            onCancel: () => app.notify('Agent task cancelled'),
+        });
+        return;
+    }
+    executeAgentTask(task, dryRun, ctx);
+}
+export async function executeAgentTask(task, dryRun, ctx) {
+    const { app, projectContext } = ctx;
+    if (!projectContext) {
+        app.notify('Agent requires project context');
+        return;
+    }
+    // Guard against concurrent execution — set flag immediately before any await
+    if (ctx.isAgentRunning()) {
+        app.notify('Agent already running. Use /stop to cancel.');
+        return;
+    }
+    ctx.setAgentRunning(true);
+    const abortController = new AbortController();
+    ctx.setAbortController(abortController);
+    const prefix = dryRun ? '[DRY RUN] ' : '[AGENT] ';
+    app.addMessage({ role: 'user', content: prefix + task });
+    app.setAgentRunning(true);
+    const context = projectContext;
+    try {
+        const fileContext = ctx.formatAddedFilesContext();
+        const enrichedTask = fileContext ? fileContext + task : task;
+        const result = await runAgent(enrichedTask, context, {
+            dryRun,
+            chatHistory: app.getChatHistory(),
+            onIteration: (iteration) => {
+                app.updateAgentProgress(iteration);
+            },
+            onToolCall: (tool) => {
+                const toolName = tool.tool.toLowerCase();
+                const target = tool.parameters.path ||
+                    tool.parameters.command ||
+                    tool.parameters.pattern || '';
+                const actionType = toolName.includes('write') ? 'write' :
+                    toolName.includes('edit') ? 'edit' :
+                        toolName.includes('read') ? 'read' :
+                            toolName.includes('delete') ? 'delete' :
+                                toolName.includes('list') ? 'list' :
+                                    toolName.includes('search') || toolName.includes('grep') ? 'search' :
+                                        toolName.includes('mkdir') ? 'mkdir' :
+                                            toolName.includes('fetch') ? 'fetch' : 'command';
+                const shortTarget = target.length > 50 ? '...' + target.slice(-47) : target;
+                app.setAgentThinking(`${actionType}: ${shortTarget}`);
+                if (actionType === 'write' && tool.parameters.content) {
+                    const filePath = tool.parameters.path;
+                    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;
+                    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: `**Delete** \`${filePath}\`` });
+                }
+            },
+            onToolResult: (result, toolCall) => {
+                const toolName = toolCall.tool.toLowerCase();
+                const target = toolCall.parameters.path || toolCall.parameters.command || '';
+                const actionType = toolName.includes('write') ? 'write' :
+                    toolName.includes('edit') ? 'edit' :
+                        toolName.includes('read') ? 'read' :
+                            toolName.includes('delete') ? 'delete' :
+                                toolName.includes('list') ? 'list' :
+                                    toolName.includes('search') || toolName.includes('grep') ? 'search' :
+                                        toolName.includes('mkdir') ? 'mkdir' :
+                                            toolName.includes('fetch') ? 'fetch' : 'command';
+                app.updateAgentProgress(0, {
+                    type: actionType,
+                    target,
+                    result: result.success ? 'success' : 'error',
+                });
+            },
+            onThinking: (text) => {
+                if (text)
+                    app.setAgentThinking(text);
+            },
+            abortSignal: abortController.signal,
+        });
+        if (result.success) {
+            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 {
+                    // auto-commit is best-effort
+                }
+            }
+        }
+        else if (result.aborted) {
+            app.addMessage({ role: 'assistant', content: 'Agent stopped by user.' });
+        }
+        else {
+            app.addMessage({ role: 'assistant', content: `Agent failed: ${result.error || 'Unknown error'}` });
+        }
+        autoSaveSession(app.getMessages(), ctx.projectPath);
+    }
+    catch (error) {
+        const err = error;
+        app.addMessage({ role: 'assistant', content: `Agent error: ${err.message}` });
+        app.notify(`Agent error: ${err.message}`, 5000);
+    }
+    finally {
+        ctx.setAgentRunning(false);
+        ctx.setAbortController(null);
+        app.setAgentRunning(false);
+    }
+}
+// ─── Skill execution ──────────────────────────────────────────────────────────
+export async function runSkill(nameOrShortcut, args, ctx) {
+    const { findSkill, parseSkillArgs, executeSkill, trackSkillUsage } = await import('../utils/skills.js');
+    const skill = findSkill(nameOrShortcut);
+    if (!skill)
+        return false;
+    if (skill.requiresGit) {
+        if (!ctx.projectPath || !getGitStatus(ctx.projectPath).isRepo) {
+            ctx.app.notify('This skill requires a git repository');
+            return true;
+        }
+    }
+    if (skill.requiresWriteAccess && !ctx.hasWriteAccess) {
+        ctx.app.notify('This skill requires write access. Use /grant first.');
+        return true;
+    }
+    const params = parseSkillArgs(args.join(' '), skill);
+    ctx.app.addMessage({ role: 'user', content: `/${skill.name}${args.length ? ' ' + args.join(' ') : ''}` });
+    trackSkillUsage(skill.name);
+    const { spawnSync } = await import('child_process');
+    try {
+        const result = await executeSkill(skill, params, {
+            onCommand: async (cmd) => {
+                const proc = spawnSync(cmd, {
+                    cwd: ctx.projectPath || process.cwd(),
+                    encoding: 'utf-8',
+                    timeout: 60000,
+                    shell: true,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                const stdout = (proc.stdout || '').trim();
+                const stderr = (proc.stderr || '').trim();
+                const output = stdout || stderr || '';
+                if (proc.status === 0) {
+                    if (output)
+                        ctx.app.addMessage({ role: 'system', content: `\`${cmd}\`\n\`\`\`\n${output}\n\`\`\`` });
+                    return output;
+                }
+                if (output)
+                    ctx.app.addMessage({ role: 'system', content: `\`${cmd}\` failed:\n\`\`\`\n${output}\n\`\`\`` });
+                throw new Error(output || `Command exited with code ${proc.status}`);
+            },
+            onPrompt: async (prompt) => {
+                try {
+                    ctx.app.addMessage({ role: 'user', content: prompt });
+                    ctx.app.startStreaming();
+                    const history = ctx.app.getChatHistory();
+                    const response = await chat(prompt, history, (chunk) => {
+                        ctx.app.addStreamChunk(chunk);
+                    }, undefined, ctx.projectContext, undefined);
+                    ctx.app.endStreaming();
+                    const msgs = ctx.app.getMessages();
+                    const last = msgs[msgs.length - 1];
+                    return (last?.role === 'assistant' ? last.content : response || '').trim();
+                }
+                catch (err) {
+                    ctx.app.endStreaming();
+                    throw err;
+                }
+            },
+            onAgent: (task) => {
+                return new Promise((resolve, reject) => {
+                    if (!ctx.projectContext) {
+                        reject(new Error('Agent requires project context'));
+                        return;
+                    }
+                    executeAgentTask(task, false, ctx).then(() => resolve('Agent completed')).catch(reject);
+                });
+            },
+            onConfirm: (message) => {
+                return new Promise((resolve) => {
+                    ctx.app.showConfirm({
+                        title: 'Confirm',
+                        message: [message],
+                        confirmLabel: 'Yes',
+                        cancelLabel: 'No',
+                        onConfirm: () => resolve(true),
+                        onCancel: () => resolve(false),
+                    });
+                });
+            },
+            onNotify: (message) => {
+                ctx.app.notify(message);
+            },
+        });
+        if (!result.success && result.output !== 'Cancelled by user') {
+            ctx.app.notify(`Skill failed: ${result.output}`);
+        }
+    }
+    catch (err) {
+        ctx.app.notify(`Skill error: ${err.message}`);
+        trackSkillUsage(skill.name, false);
+    }
+    return true;
+}
+// ─── Command chaining ─────────────────────────────────────────────────────────
+export function runCommandChain(commands, index, ctx) {
+    if (index >= commands.length) {
+        ctx.app.notify(`Completed ${commands.length} commands`);
+        return;
+    }
+    const cmd = commands[index].toLowerCase();
+    ctx.app.notify(`Running /${cmd}... (${index + 1}/${commands.length})`);
+    ctx.handleCommand(cmd, []);
+    setTimeout(() => runCommandChain(commands, index + 1, ctx), 500);
+}

package/dist/renderer/commands.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Command dispatch for all /command handlers.
+ *
+ * Extracted from main.ts. Receives an AppCommandContext so it remains
+ * decoupled from global state. Import-heavy commands use dynamic imports
+ * to keep startup time low.
+ */
+import { getProjectContext } from '../utils/project';
+import { AppExecutionContext } from './agentExecution';
+export interface AppCommandContext extends AppExecutionContext {
+    sessionId: string;
+    setSessionId: (id: string) => void;
+    setProjectContext: (ctx: ReturnType<typeof getProjectContext>) => void;
+    setHasWriteAccess: (v: boolean) => void;
+}
+export declare function handleCommand(command: string, args: string[], ctx: AppCommandContext): Promise<void>;