gencode-ai 0.1.2 → 0.2.0

package/examples/test-interrupt-cleanup.ts

@@ -0,0 +1,94 @@
+/**
+ * Test Interrupt Cleanup
+ *
+ * Simulates the interrupt scenario and verifies cleanup works correctly
+ */
+
+import { Agent } from '../src/agent/index.js';
+import type { Message } from '../src/providers/types.js';
+
+async function testInterruptCleanup() {
+  console.log('🧪 Testing Interrupt Cleanup\n');
+
+  const agent = new Agent({
+    provider: 'anthropic',
+    model: 'claude-3-5-sonnet-20241022',
+    cwd: process.cwd(),
+  });
+
+  try {
+    // Simulate incomplete tool_use message (what happens during interrupt)
+    console.log('1️⃣  Simulating incomplete tool_use message...');
+
+    // Access private messages array via getHistory and direct manipulation
+    const history = agent.getHistory();
+    console.log(`   Initial history: ${history.length} messages`);
+
+    // Add a user message
+    (agent as any).messages.push({
+      role: 'user',
+      content: 'Create a file',
+    });
+    console.log(`   After user message: ${agent.getHistory().length} messages`);
+
+    // Add an assistant message with tool_use (simulating interrupt point)
+    (agent as any).messages.push({
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'I will create the file.' },
+        {
+          type: 'tool_use',
+          id: 'toolu_test_123',
+          name: 'Write',
+          input: { file_path: 'test.txt', content: 'hello' },
+        },
+      ],
+    });
+    console.log(`   After assistant+tool_use: ${agent.getHistory().length} messages`);
+    console.log(`   Last message role: ${agent.getHistory()[agent.getHistory().length - 1].role}`);
+
+    // Verify incomplete state
+    const lastMessage = agent.getHistory()[agent.getHistory().length - 1];
+    const hasToolUse = Array.isArray(lastMessage.content) &&
+      lastMessage.content.some((c: any) => c.type === 'tool_use');
+    console.log(`   Has incomplete tool_use: ${hasToolUse}\n`);
+
+    console.log('2️⃣  Calling cleanupIncompleteMessages()...');
+    agent.cleanupIncompleteMessages();
+
+    const afterCleanup = agent.getHistory();
+    console.log(`   After cleanup: ${afterCleanup.length} messages`);
+
+    if (afterCleanup.length === 1 && afterCleanup[0].role === 'user') {
+      console.log('   ✓ Incomplete assistant message removed!\n');
+    } else {
+      console.log('   ✗ Cleanup failed!\n');
+      console.log('   Remaining messages:', JSON.stringify(afterCleanup, null, 2));
+    }
+
+    console.log('3️⃣  Testing with complete messages (no tool_use)...');
+
+    // Add complete assistant message
+    (agent as any).messages.push({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Here is your answer.' }],
+    });
+    console.log(`   Before cleanup: ${agent.getHistory().length} messages`);
+
+    agent.cleanupIncompleteMessages();
+    console.log(`   After cleanup: ${agent.getHistory().length} messages`);
+
+    if (agent.getHistory().length === 2) {
+      console.log('   ✓ Complete messages preserved!\n');
+    } else {
+      console.log('   ✗ Complete message was incorrectly removed!\n');
+    }
+
+    console.log('✅ All tests passed!\n');
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+  }
+}
+
+// Run the test
+testInterruptCleanup();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencode-ai",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "An open-source AI assistant for your terminal",
   "type": "module",
   "main": "dist/index.js",

package/src/agent/agent.ts

@@ -16,6 +16,16 @@ import { SessionManager } from '../session/index.js';
 import { MemoryManager, type LoadedMemory } from '../memory/index.js';
 import type { AgentConfig, AgentEvent } from './types.js';
 import { buildSystemPromptForModel, debugPromptLoading } from '../prompts/index.js';
+import type { Question, QuestionAnswer } from '../tools/types.js';
+import {
+  getPlanModeManager,
+  type PlanModeManager,
+  type ModeType,
+  type AllowedPrompt,
+} from '../planning/index.js';
+
+// Type for askUser callback
+export type AskUserCallback = (questions: Question[]) => Promise<QuestionAnswer[]>;
 
 export class Agent {
   private provider: LLMProvider;
@@ -23,10 +33,12 @@ export class Agent {
   private permissions: PermissionManager;
   private sessionManager: SessionManager;
   private memoryManager: MemoryManager;
+  private planModeManager: PlanModeManager;
   private config: AgentConfig;
   private messages: Message[] = [];
   private sessionId: string | null = null;
   private loadedMemory: LoadedMemory | null = null;
+  private askUserCallback: AskUserCallback | null = null;
 
   constructor(config: AgentConfig) {
     this.config = {
@@ -43,6 +55,7 @@ export class Agent {
     });
     this.sessionManager = new SessionManager();
     this.memoryManager = new MemoryManager();
+    this.planModeManager = getPlanModeManager();
   }
 
   /**
@@ -101,6 +114,14 @@ export class Agent {
     return this.permissions;
   }
 
+  /**
+   * Set callback for AskUserQuestion tool
+   * This allows the CLI to handle user questioning
+   */
+  setAskUserCallback(callback: AskUserCallback): void {
+    this.askUserCallback = callback;
+  }
+
   /**
    * Get memory manager for direct access
    */
@@ -124,6 +145,78 @@ export class Agent {
     return this.loadedMemory;
   }
 
+  // ============================================================================
+  // Plan Mode
+  // ============================================================================
+
+  /**
+   * Get plan mode manager for external access
+   */
+  getPlanModeManager(): PlanModeManager {
+    return this.planModeManager;
+  }
+
+  /**
+   * Check if plan mode is active
+   */
+  isPlanModeActive(): boolean {
+    return this.planModeManager.isActive();
+  }
+
+  /**
+   * Get current mode (build or plan)
+   */
+  getCurrentMode(): ModeType {
+    return this.planModeManager.getCurrentMode();
+  }
+
+  /**
+   * Enter plan mode programmatically
+   */
+  async enterPlanMode(taskDescription?: string): Promise<string> {
+    const { createPlanFile } = await import('../planning/index.js');
+    const cwd = this.config.cwd ?? process.cwd();
+    const planFile = await createPlanFile(cwd, taskDescription);
+    this.planModeManager.enter(planFile.path, taskDescription);
+    return planFile.path;
+  }
+
+  /**
+   * Exit plan mode
+   */
+  exitPlanMode(approved: boolean = false): void {
+    if (approved) {
+      // Add allowed prompts from plan mode to permissions
+      const allowedPrompts = this.planModeManager.getRequestedPermissions();
+      if (allowedPrompts.length > 0) {
+        this.permissions.addAllowedPrompts(allowedPrompts);
+      }
+    }
+    this.planModeManager.exit(approved);
+  }
+
+  /**
+   * Toggle plan mode
+   */
+  async togglePlanMode(): Promise<void> {
+    if (this.planModeManager.isActive()) {
+      this.planModeManager.exit(false);
+    } else {
+      await this.enterPlanMode();
+    }
+  }
+
+  /**
+   * Get plan mode requested permissions
+   */
+  getPlanModePermissions(): AllowedPrompt[] {
+    return this.planModeManager.getRequestedPermissions();
+  }
+
+  // ============================================================================
+  // Session Management
+  // ============================================================================
+
   /**
    * Get current session ID
    */
@@ -277,8 +370,8 @@ export class Agent {
     while (turns < maxTurns) {
       turns++;
 
-      // Get tool definitions
-      const toolDefs = this.registry.getDefinitions(this.config.tools);
+      // Get tool definitions (filtered by plan mode if active)
+      const toolDefs = this.registry.getFilteredDefinitions(this.config.tools);
 
       // Call LLM
       let response;
@@ -328,7 +421,7 @@ export class Agent {
       await this.sessionManager.addMessage({ role: 'assistant', content: response.content });
 
       if (response.stopReason !== 'tool_use' || toolCalls.length === 0) {
-        yield { type: 'done', text: textContent };
+        yield { type: 'done', text: textContent, usage: response.usage, cost: response.cost };
         return;
       }
 
@@ -336,12 +429,18 @@ export class Agent {
       const toolResults: ToolResultContent[] = [];
       const cwd = this.config.cwd ?? process.cwd();
 
+      // Build tool context with askUser callback
+      const toolContext = {
+        cwd,
+        askUser: this.askUserCallback ?? undefined,
+      };
+
       for (const call of toolCalls) {
         yield { type: 'tool_start', id: call.id, name: call.name, input: call.input };
 
         const allowed = await this.permissions.requestPermission(call.name, call.input);
         const result = allowed
-          ? await this.registry.execute(call.name, call.input, { cwd })
+          ? await this.registry.execute(call.name, call.input, toolContext)
           : { success: false, output: '', error: 'Permission denied by user' };
 
         yield { type: 'tool_result', id: call.id, name: call.name, result };
@@ -369,6 +468,33 @@ export class Agent {
     this.sessionManager.clearMessages();
   }
 
+  /**
+   * Clean up incomplete tool use messages (after interruption)
+   * Removes the last assistant message if it contains tool_use without corresponding tool_result
+   */
+  cleanupIncompleteMessages(): void {
+    if (this.messages.length === 0) return;
+
+    const lastMessage = this.messages[this.messages.length - 1];
+
+    // Check if last message is an assistant message with tool_use
+    if (lastMessage.role === 'assistant' && Array.isArray(lastMessage.content)) {
+      const hasToolUse = lastMessage.content.some((c) => c.type === 'tool_use');
+
+      if (hasToolUse) {
+        // Remove the incomplete assistant message
+        this.messages.pop();
+
+        // Also remove from session manager
+        // Note: SessionManager should have corresponding cleanup method
+        const messages = this.sessionManager.getMessages();
+        if (messages.length > 0 && messages[messages.length - 1].role === 'assistant') {
+          this.sessionManager.removeLastMessage();
+        }
+      }
+    }
+  }
+
   /**
    * Get conversation history
    */

package/src/agent/index.ts

@@ -4,3 +4,4 @@
 
 export * from './types.js';
 export { Agent } from './agent.js';
+export type { AskUserCallback } from './agent.js';

package/src/agent/types.ts

@@ -3,6 +3,7 @@
  */
 
 import type { PermissionConfig } from '../permissions/types.js';
+import type { CostEstimate } from '../pricing/types.js';
 
 export interface AgentConfig {
   provider: 'openai' | 'anthropic' | 'gemini' | 'vertex-ai';
@@ -59,6 +60,22 @@ export interface AgentEventError {
 export interface AgentEventDone {
   type: 'done';
   text: string;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+  cost?: CostEstimate;
+}
+
+export interface AgentEventAskUser {
+  type: 'ask_user';
+  id: string;
+  questions: Array<{
+    question: string;
+    header: string;
+    options: Array<{ label: string; description: string }>;
+    multiSelect: boolean;
+  }>;
 }
 
 export type AgentEvent =
@@ -67,4 +84,5 @@ export type AgentEvent =
   | AgentEventToolResult
   | AgentEventThinking
   | AgentEventError
-  | AgentEventDone;
+  | AgentEventDone
+  | AgentEventAskUser;

package/src/checkpointing/checkpoint-manager.ts

@@ -0,0 +1,327 @@
+/**
+ * Checkpoint Manager - Core checkpointing logic
+ *
+ * Tracks file changes and provides rewind capabilities.
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type {
+  FileCheckpoint,
+  CheckpointSession,
+  RewindOptions,
+  RewindResult,
+  CheckpointSummary,
+  RecordChangeInput,
+} from './types.js';
+
+/**
+ * Generates a unique ID for checkpoints
+ */
+function generateId(): string {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/**
+ * CheckpointManager manages file change tracking and rewind operations.
+ *
+ * Usage:
+ *   const manager = new CheckpointManager('session-123');
+ *   manager.recordChange({ path: '/path/to/file', changeType: 'modify', ... });
+ *   await manager.rewind({ all: true });
+ */
+export class CheckpointManager {
+  private session: CheckpointSession;
+
+  constructor(sessionId: string = 'default') {
+    this.session = {
+      sessionId,
+      checkpoints: [],
+      createdAt: new Date(),
+    };
+  }
+
+  /**
+   * Get the session ID
+   */
+  getSessionId(): string {
+    return this.session.sessionId;
+  }
+
+  /**
+   * Record a file change as a checkpoint
+   */
+  recordChange(input: RecordChangeInput): FileCheckpoint {
+    const checkpoint: FileCheckpoint = {
+      id: generateId(),
+      path: input.path,
+      changeType: input.changeType,
+      timestamp: new Date(),
+      previousContent: input.previousContent,
+      newContent: input.newContent,
+      toolName: input.toolName,
+    };
+
+    this.session.checkpoints.push(checkpoint);
+    return checkpoint;
+  }
+
+  /**
+   * Get all checkpoints
+   */
+  getCheckpoints(): FileCheckpoint[] {
+    return [...this.session.checkpoints];
+  }
+
+  /**
+   * Get checkpoints for a specific file
+   */
+  getFileHistory(filePath: string): FileCheckpoint[] {
+    return this.session.checkpoints.filter((cp) => cp.path === filePath);
+  }
+
+  /**
+   * Get a summary of all changes
+   */
+  getSummary(): CheckpointSummary {
+    const summary: CheckpointSummary = {
+      created: 0,
+      modified: 0,
+      deleted: 0,
+      total: this.session.checkpoints.length,
+    };
+
+    for (const cp of this.session.checkpoints) {
+      switch (cp.changeType) {
+        case 'create':
+          summary.created++;
+          break;
+        case 'modify':
+          summary.modified++;
+          break;
+        case 'delete':
+          summary.deleted++;
+          break;
+      }
+    }
+
+    return summary;
+  }
+
+  /**
+   * Check if there are any checkpoints
+   */
+  hasCheckpoints(): boolean {
+    return this.session.checkpoints.length > 0;
+  }
+
+  /**
+   * Get the number of checkpoints
+   */
+  getCheckpointCount(): number {
+    return this.session.checkpoints.length;
+  }
+
+  /**
+   * Rewind changes based on options
+   */
+  async rewind(options: RewindOptions): Promise<RewindResult> {
+    const result: RewindResult = {
+      success: true,
+      revertedFiles: [],
+      errors: [],
+    };
+
+    // Determine which checkpoints to rewind
+    let checkpointsToRewind: FileCheckpoint[] = [];
+
+    if (options.checkpointId) {
+      // Rewind specific checkpoint
+      const cp = this.session.checkpoints.find((c) => c.id === options.checkpointId);
+      if (cp) {
+        checkpointsToRewind = [cp];
+      }
+    } else if (options.path) {
+      // Rewind all changes to a specific file (in reverse order)
+      checkpointsToRewind = this.session.checkpoints
+        .filter((c) => c.path === options.path)
+        .reverse();
+    } else if (options.count) {
+      // Rewind last N changes (in reverse order)
+      checkpointsToRewind = this.session.checkpoints.slice(-options.count).reverse();
+    } else if (options.all) {
+      // Rewind all changes (in reverse order)
+      checkpointsToRewind = [...this.session.checkpoints].reverse();
+    }
+
+    // Apply reverts
+    for (const checkpoint of checkpointsToRewind) {
+      try {
+        await this.revertCheckpoint(checkpoint);
+        result.revertedFiles.push({
+          path: checkpoint.path,
+          action: this.getRevertAction(checkpoint),
+        });
+
+        // Remove the checkpoint from session
+        const index = this.session.checkpoints.findIndex((c) => c.id === checkpoint.id);
+        if (index !== -1) {
+          this.session.checkpoints.splice(index, 1);
+        }
+      } catch (error) {
+        result.success = false;
+        result.errors.push({
+          path: checkpoint.path,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Revert a single checkpoint
+   */
+  private async revertCheckpoint(checkpoint: FileCheckpoint): Promise<void> {
+    switch (checkpoint.changeType) {
+      case 'create':
+        // File was created, delete it to revert
+        await fs.unlink(checkpoint.path);
+        break;
+
+      case 'modify':
+        // File was modified, restore previous content
+        if (checkpoint.previousContent !== null) {
+          await fs.writeFile(checkpoint.path, checkpoint.previousContent, 'utf-8');
+        }
+        break;
+
+      case 'delete':
+        // File was deleted, recreate it with previous content
+        if (checkpoint.previousContent !== null) {
+          await fs.mkdir(path.dirname(checkpoint.path), { recursive: true });
+          await fs.writeFile(checkpoint.path, checkpoint.previousContent, 'utf-8');
+        }
+        break;
+    }
+  }
+
+  /**
+   * Get the action that will be taken to revert a checkpoint
+   */
+  private getRevertAction(checkpoint: FileCheckpoint): 'restored' | 'deleted' | 'recreated' {
+    switch (checkpoint.changeType) {
+      case 'create':
+        return 'deleted';
+      case 'modify':
+        return 'restored';
+      case 'delete':
+        return 'recreated';
+    }
+  }
+
+  /**
+   * Clear all checkpoints
+   */
+  clearCheckpoints(): void {
+    this.session.checkpoints = [];
+  }
+
+  /**
+   * Format checkpoints for display
+   */
+  formatCheckpointList(includeUsage: boolean = false): string {
+    if (this.session.checkpoints.length === 0) {
+      return 'No file changes in this session.';
+    }
+
+    const lines: string[] = [];
+
+    this.session.checkpoints.forEach((cp, index) => {
+      const timeAgo = this.formatTimeAgo(cp.timestamp);
+      const action = this.formatChangeType(cp.changeType);
+      const fileName = cp.path.split('/').pop() || cp.path;
+      lines.push(`  [${index + 1}] ${timeAgo.padEnd(8)} ${fileName.padEnd(30)} (${action})`);
+    });
+
+    const summary = this.getSummary();
+    lines.push('');
+    lines.push(
+      `Total: ${summary.created} created, ${summary.modified} modified, ${summary.deleted} deleted`
+    );
+
+    if (includeUsage) {
+      lines.push('');
+      lines.push('Usage: /rewind [n] to revert change #n, /rewind all to revert all');
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format a change type for display
+   */
+  private formatChangeType(changeType: string): string {
+    switch (changeType) {
+      case 'create':
+        return 'created';
+      case 'modify':
+        return 'modified';
+      case 'delete':
+        return 'deleted';
+      default:
+        return changeType;
+    }
+  }
+
+  /**
+   * Format a timestamp as relative time
+   */
+  private formatTimeAgo(date: Date): string {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+
+    if (seconds < 60) {
+      return `${seconds}s ago`;
+    }
+
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) {
+      return `${minutes}m ago`;
+    }
+
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ago`;
+  }
+}
+
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+
+let globalCheckpointManager: CheckpointManager | null = null;
+
+/**
+ * Get the global checkpoint manager instance
+ */
+export function getCheckpointManager(): CheckpointManager {
+  if (!globalCheckpointManager) {
+    globalCheckpointManager = new CheckpointManager();
+  }
+  return globalCheckpointManager;
+}
+
+/**
+ * Initialize checkpoint manager with a session ID
+ */
+export function initCheckpointManager(sessionId: string): CheckpointManager {
+  globalCheckpointManager = new CheckpointManager(sessionId);
+  return globalCheckpointManager;
+}
+
+/**
+ * Reset the global checkpoint manager (for testing)
+ */
+export function resetCheckpointManager(): void {
+  globalCheckpointManager = null;
+}