gencode-ai 0.1.3 → 0.3.0

package/src/agent/agent.ts

@@ -2,8 +2,8 @@
  * Agent - Core agent implementation with tool loop and session support
  */
 
-import type { LLMProvider, Message, ToolResultContent } from '../providers/types.js';
-import { createProvider, inferProvider } from '../providers/index.js';
+import type { LLMProvider, Message, ToolResultContent, Provider, AuthMethod } from '../providers/types.js';
+import { createProvider, inferProvider, inferAuthMethod } from '../providers/index.js';
 import { ToolRegistry, createDefaultRegistry } from '../tools/index.js';
 import {
   PermissionManager,
@@ -17,6 +17,12 @@ 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[]>;
@@ -27,6 +33,7 @@ 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;
@@ -40,7 +47,10 @@ export class Agent {
       ...config,
     };
 
-    this.provider = createProvider({ provider: config.provider });
+    this.provider = createProvider({
+      provider: config.provider,
+      authMethod: config.authMethod,
+    });
     this.registry = createDefaultRegistry();
     this.permissions = new PermissionManager({
       config: config.permissions,
@@ -48,6 +58,7 @@ export class Agent {
     });
     this.sessionManager = new SessionManager();
     this.memoryManager = new MemoryManager();
+    this.planModeManager = getPlanModeManager();
   }
 
   /**
@@ -133,10 +144,99 @@ export class Agent {
    */
   async loadMemory(): Promise<LoadedMemory> {
     const cwd = this.config.cwd ?? process.cwd();
-    this.loadedMemory = await this.memoryManager.load({ cwd });
+
+    // Determine memory merge strategy (priority: env var > config > default)
+    const envStrategy = process.env.GEN_MEMORY_STRATEGY as
+      | 'fallback'
+      | 'both'
+      | 'gen-only'
+      | 'claude-only'
+      | undefined;
+    const strategy =
+      envStrategy ?? this.config.memoryMergeStrategy ?? 'fallback';
+
+    this.loadedMemory = await this.memoryManager.load({ cwd, strategy });
+
+    // Log verbose summary if verbose mode is enabled
+    if (this.config.verbose) {
+      console.log(this.memoryManager.getVerboseSummary(strategy));
+    }
+
     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
    */
@@ -153,15 +253,30 @@ export class Agent {
 
   /**
    * Set the model to use (auto-switches provider if needed)
+   * @param model Model ID to use
+   * @param provider Optional: explicit provider (otherwise inferred from model name)
+   * @param authMethod Optional: explicit auth method (otherwise inferred or use current)
    */
-  setModel(model: string): void {
+  setModel(model: string, provider?: string, authMethod?: string): void {
     this.config.model = model;
 
-    // Auto-switch provider based on model name
-    const newProvider = inferProvider(model);
-    if (newProvider !== this.config.provider) {
+    // Determine new provider and authMethod
+    const newProvider = (provider as Provider | undefined) ?? inferProvider(model);
+    const newAuthMethod = (authMethod as AuthMethod | undefined) ??
+                         inferAuthMethod(model) ??
+                         this.config.authMethod;
+
+    // Recreate provider if either provider or authMethod changed
+    const providerChanged = newProvider !== this.config.provider;
+    const authMethodChanged = newAuthMethod !== this.config.authMethod;
+
+    if (providerChanged || authMethodChanged) {
       this.config.provider = newProvider;
-      this.provider = createProvider({ provider: newProvider });
+      this.config.authMethod = newAuthMethod;
+      this.provider = createProvider({
+        provider: newProvider,
+        authMethod: newAuthMethod,
+      });
     }
   }
 
@@ -172,6 +287,13 @@ export class Agent {
     return this.config.model;
   }
 
+  /**
+   * Get current provider
+   */
+  getProvider(): Provider {
+    return this.config.provider;
+  }
+
   /**
    * List available models from the provider API
    */
@@ -290,8 +412,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;
@@ -341,7 +463,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;
       }
 
@@ -388,6 +510,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/types.ts

@@ -3,15 +3,20 @@
  */
 
 import type { PermissionConfig } from '../permissions/types.js';
+import type { CostEstimate } from '../pricing/types.js';
+import type { Provider, AuthMethod } from '../providers/types.js';
 
 export interface AgentConfig {
-  provider: 'openai' | 'anthropic' | 'gemini' | 'vertex-ai';
+  provider: Provider;
+  authMethod?: AuthMethod;
   model: string;
   systemPrompt?: string;
   tools?: string[];
   cwd?: string;
   maxTurns?: number;
   permissions?: Partial<PermissionConfig>;
+  memoryMergeStrategy?: 'fallback' | 'both' | 'gen-only' | 'claude-only';
+  verbose?: boolean;
 }
 
 // Agent Events
@@ -59,6 +64,11 @@ export interface AgentEventError {
 export interface AgentEventDone {
   type: 'done';
   text: string;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+  cost?: CostEstimate;
 }
 
 export interface 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;
+}

package/src/checkpointing/index.ts

@@ -0,0 +1,45 @@
+/**
+ * Checkpointing Module
+ *
+ * Provides automatic tracking of file changes with undo/rewind capabilities.
+ *
+ * Usage:
+ *   import { getCheckpointManager, initCheckpointManager } from './checkpointing';
+ *
+ *   // Initialize at session start
+ *   const manager = initCheckpointManager('session-123');
+ *
+ *   // Record changes (done automatically by ToolRegistry)
+ *   manager.recordChange({
+ *     path: '/path/to/file.ts',
+ *     changeType: 'modify',
+ *     previousContent: 'old content',
+ *     newContent: 'new content',
+ *     toolName: 'Edit'
+ *   });
+ *
+ *   // List changes
+ *   console.log(manager.formatCheckpointList());
+ *
+ *   // Rewind changes
+ *   await manager.rewind({ all: true });
+ */
+
+// Type exports
+export type {
+  ChangeType,
+  FileCheckpoint,
+  CheckpointSession,
+  RewindOptions,
+  RewindResult,
+  CheckpointSummary,
+  RecordChangeInput,
+} from './types.js';
+
+// Manager exports
+export {
+  CheckpointManager,
+  getCheckpointManager,
+  initCheckpointManager,
+  resetCheckpointManager,
+} from './checkpoint-manager.js';