gencode-ai 0.1.3 → 0.2.0

package/docs/operating-modes.md

@@ -0,0 +1,96 @@
+# Operating Modes
+
+> Reference: [Claude Code](https://claude.ai/code) operating modes
+
+GenCode has **3 operating modes** that can be cycled with `Shift+Tab`:
+
+```
+Normal (default)
+    ↓ Shift+Tab
+Plan (⏸ plan mode on)
+    ↓ Shift+Tab
+Accept (⏵⏵ accept edits on)
+    ↓ Shift+Tab
+Normal
+    ...
+```
+
+## Mode Comparison
+
+| Mode | Status Indicator | Edit Confirmation | Available Tools |
+|------|------------------|-------------------|-----------------|
+| **Normal** | _(none)_ | Required | All |
+| **Plan** | `⏸ plan mode on (shift+tab to cycle)` | N/A (edits blocked) | Read-only |
+| **Accept** | `⏵⏵ accept edits on (shift+tab to cycle)` | Auto-approved | All |
+
+## Mode Details
+
+### 1. Normal Mode (Default)
+
+- Normal execution mode
+- Every Write/Edit operation requires user confirmation
+- All tools available
+- Default mode when GenCode starts
+
+### 2. Plan Mode
+
+- Read-only exploration mode for designing implementation approaches
+- Write, Edit, and Bash tools are blocked
+- Used for understanding codebase and creating implementation plans
+
+**Allowed Tools:** Read, Glob, Grep, WebFetch, WebSearch, TodoWrite, AskUserQuestion
+
+**Blocked Tools:** Write, Edit, Bash
+
+### 3. Auto-accept Mode
+
+- Automatic edit acceptance mode
+- Write/Edit operations are automatically approved without confirmation
+- Useful when trusting the agent or after approving a plan
+- **Caution**: May cause unintended file changes
+
+## Plan Mode Workflow
+
+When in Plan mode, the agent goes through 5 phases:
+
+```
+EnterPlanMode
+     ↓
+┌─────────────┐
+│Understanding│ ← Explore codebase
+└──────┬──────┘
+       ↓
+┌─────────────┐
+│   Design    │ ← Design approach
+└──────┬──────┘
+       ↓
+┌─────────────┐
+│   Review    │ ← (Optional) Clarify requirements
+└──────┬──────┘
+       ↓
+┌─────────────┐
+│   Final     │ ← Write plan to file
+└──────┬──────┘
+       ↓
+ExitPlanMode
+       ↓
+┌─────────────┐
+│  Approval   │ ← User approves/modifies/cancels
+└─────────────┘
+```
+
+## Plan Approval Options
+
+When exiting Plan mode:
+
+| Option | Description | Next Mode |
+|--------|-------------|-----------|
+| **approve** | Accept plan, auto-accept edits | Accept |
+| **approve_manual** | Accept plan, manually approve each edit | Normal |
+| **modify** | Return to modify the plan | Plan |
+| **cancel** | Cancel plan entirely | Normal |
+
+## References
+
+- [Claude Code Best Practices](https://www.anthropic.com/engineering/claude-code-best-practices)
+- [Plan Mode Proposal](./proposals/0004-plan-mode.md)

package/docs/proposals/0025-cost-tracking.md

@@ -2,9 +2,10 @@
 
 - **Proposal ID**: 0025
 - **Author**: mycode team
-- **Status**: Draft
+- **Status**: Implemented
 - **Created**: 2025-01-15
-- **Updated**: 2025-01-15
+- **Updated**: 2026-01-16
+- **Implemented**: 2026-01-16
 
 ## Summary
 
@@ -439,6 +440,63 @@ Only show costs after session ends.
 
 No breaking changes.
 
+## Implementation Notes
+
+### Phase 1 Complete (2026-01-16)
+
+Implemented core cost tracking functionality with real-time display in CLI.
+
+### Files Created
+
+| File | Description |
+|------|-------------|
+| `src/pricing/types.ts` | Type definitions for pricing and costs |
+| `src/pricing/models.ts` | Model pricing database (updated Jan 2025) |
+| `src/pricing/calculator.ts` | Cost calculation and formatting utilities |
+| `src/pricing/index.ts` | Module exports |
+| `examples/test-cost-tracking.ts` | Test script for cost tracking |
+| `docs/cost-tracking-comparison.md` | Detailed comparison with OpenCode |
+
+### Files Modified
+
+| File | Changes |
+|------|---------|
+| `src/providers/types.ts` | Added `cost?: CostEstimate` to `CompletionResponse` |
+| `src/providers/anthropic.ts` | Calculate and return cost in responses |
+| `src/providers/openai.ts` | Calculate and return cost in responses |
+| `src/providers/gemini.ts` | Calculate and return cost in responses |
+| `src/providers/vertex-ai.ts` | Calculate and return cost in responses |
+| `src/agent/types.ts` | Added `usage` and `cost` to `AgentEventDone` |
+| `src/agent/agent.ts` | Pass usage and cost to done event |
+| `src/cli/components/App.tsx` | Pass cost data to CompletionMessage |
+| `src/cli/components/Messages.tsx` | Display cost and token usage |
+
+### Key Implementation Details
+
+1. **Pricing Database**: Comprehensive pricing for all major models (Anthropic, OpenAI, Google Gemini/Vertex AI) as of January 2025
+
+2. **Cost Calculation**: Simple formula `(tokens / 1M) * pricePerMillion` for each token type
+
+3. **CLI Display Format**: `✻ Done for 2.3s • Tokens: 1.2K in / 567 out • (~$0.02)`
+
+4. **Provider Integration**: All 4 providers (Anthropic, OpenAI, Gemini, Vertex AI) calculate cost when usage data is available
+
+5. **Graceful Degradation**: Cost displays only when provider returns usage data (some stream modes may not include it)
+
+### Testing
+
+- Tested cost calculation with sample data
+- Verified correct pricing for all providers
+- Confirmed CLI display formatting
+
+### Future Enhancements (Phase 2+)
+
+- Session cost aggregation
+- Budget system with alerts
+- Cost reporting (`/costs` command)
+- Multi-provider cost comparison
+- Advanced token types (reasoning, cache)
+
 ## References
 
 - [Anthropic Pricing](https://www.anthropic.com/pricing)

package/docs/proposals/README.md

@@ -47,7 +47,7 @@ This directory contains enhancement proposals for the gencode project. Each prop
 | [0022](./0022-plugin-system.md) | Plugin System | Draft |
 | [0023](./0023-permission-enhancements.md) | Permission Enhancements | Draft |
 | [0024](./0024-keyboard-shortcuts.md) | Keyboard Shortcuts | Draft |
-| [0025](./0025-cost-tracking.md) | Cost Tracking | Draft |
+| [0025](./0025-cost-tracking.md) | Cost Tracking | Implemented |
 | [0026](./0026-git-integration.md) | Git Integration | Draft |
 | [0027](./0027-enhanced-read-tool.md) | Enhanced Read Tool | Draft |
 | [0028](./0028-enhanced-bash-tool.md) | Enhanced Bash Tool | Draft |

package/examples/test-checkpointing.ts

@@ -0,0 +1,121 @@
+/**
+ * Test Checkpointing System
+ *
+ * This example demonstrates the automatic file change tracking and rewind capabilities.
+ */
+
+import { CheckpointManager } from '../src/checkpointing/index.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function testCheckpointing() {
+  console.log('🧪 Testing Checkpointing System\n');
+
+  const manager = new CheckpointManager('test-session');
+  const testDir = path.join(__dirname, '../.test-checkpoints');
+  const testFile = path.join(testDir, 'example.txt');
+
+  try {
+    // Create test directory
+    await fs.mkdir(testDir, { recursive: true });
+
+    console.log('1️⃣  Recording file creation...');
+    const originalContent = 'Hello, World!';
+    await fs.writeFile(testFile, originalContent, 'utf-8');
+
+    manager.recordChange({
+      path: testFile,
+      changeType: 'create',
+      previousContent: null,
+      newContent: originalContent,
+      toolName: 'Write',
+    });
+
+    console.log('   ✓ File created:', testFile);
+    console.log('   ✓ Checkpoint recorded\n');
+
+    console.log('2️⃣  Recording file modification...');
+    const modifiedContent = 'Hello, Checkpointing!';
+    await fs.writeFile(testFile, modifiedContent, 'utf-8');
+
+    manager.recordChange({
+      path: testFile,
+      changeType: 'modify',
+      previousContent: originalContent,
+      newContent: modifiedContent,
+      toolName: 'Edit',
+    });
+
+    console.log('   ✓ File modified');
+    console.log('   ✓ Checkpoint recorded\n');
+
+    console.log('3️⃣  Listing checkpoints...');
+    console.log(manager.formatCheckpointList(true));
+    console.log();
+
+    console.log('4️⃣  Getting summary...');
+    const summary = manager.getSummary();
+    console.log(`   Created: ${summary.created}`);
+    console.log(`   Modified: ${summary.modified}`);
+    console.log(`   Deleted: ${summary.deleted}`);
+    console.log(`   Total: ${summary.total}\n`);
+
+    console.log('5️⃣  Rewinding last change...');
+    const result = await manager.rewind({ count: 1 });
+
+    if (result.success) {
+      console.log('   ✓ Rewind successful');
+      result.revertedFiles.forEach((f) => {
+        console.log(`     • ${path.basename(f.path)} (${f.action})`);
+      });
+
+      // Verify content was restored
+      const restoredContent = await fs.readFile(testFile, 'utf-8');
+      if (restoredContent === originalContent) {
+        console.log('   ✓ Content restored correctly\n');
+      } else {
+        console.log('   ✗ Content mismatch!\n');
+      }
+    } else {
+      console.log('   ✗ Rewind failed');
+      result.errors.forEach((e) => console.log(`     ${e.error}`));
+    }
+
+    console.log('6️⃣  Rewinding all changes...');
+    const finalResult = await manager.rewind({ all: true });
+
+    if (finalResult.success) {
+      console.log('   ✓ All changes reverted');
+      finalResult.revertedFiles.forEach((f) => {
+        console.log(`     • ${path.basename(f.path)} (${f.action})`);
+      });
+
+      // Verify file was deleted
+      try {
+        await fs.access(testFile);
+        console.log('   ✗ File still exists!\n');
+      } catch {
+        console.log('   ✓ File was deleted as expected\n');
+      }
+    }
+
+    console.log('✅ All tests passed!\n');
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+  } finally {
+    // Cleanup
+    try {
+      await fs.rm(testDir, { recursive: true, force: true });
+      console.log('🧹 Cleaned up test directory');
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+// Run the test
+testCheckpointing();

package/examples/test-cost-tracking.ts

@@ -0,0 +1,77 @@
+/**
+ * Test cost tracking functionality
+ */
+
+import { createProvider } from '../src/providers/index.js';
+import { calculateCost, formatCost, formatTokens } from '../src/pricing/calculator.js';
+
+async function testCostTracking() {
+  console.log('='.repeat(60));
+  console.log('Testing Cost Tracking Feature');
+  console.log('='.repeat(60));
+  console.log();
+
+  // Test 1: Cost Calculation
+  console.log('Test 1: Cost Calculation');
+  console.log('-'.repeat(60));
+
+  const testCases = [
+    { provider: 'anthropic', model: 'claude-sonnet-4', input: 1000, output: 500 },
+    { provider: 'openai', model: 'gpt-4o', input: 1000, output: 500 },
+    { provider: 'gemini', model: 'gemini-2.0-flash', input: 1000, output: 500 },
+  ];
+
+  for (const test of testCases) {
+    const cost = calculateCost(test.provider, test.model, {
+      inputTokens: test.input,
+      outputTokens: test.output,
+    });
+
+    console.log(`\n${test.provider}/${test.model}:`);
+    console.log(`  Input: ${formatTokens(test.input)} tokens`);
+    console.log(`  Output: ${formatTokens(test.output)} tokens`);
+    console.log(`  Cost: ${formatCost(cost.totalCost)}`);
+    console.log(`  Breakdown: ${formatCost(cost.inputCost)} (input) + ${formatCost(cost.outputCost)} (output)`);
+  }
+
+  console.log();
+  console.log('='.repeat(60));
+  console.log();
+
+  // Test 2: Real API Call (if env var is set)
+  if (process.env.ANTHROPIC_API_KEY) {
+    console.log('Test 2: Real API Call with Anthropic');
+    console.log('-'.repeat(60));
+
+    const provider = createProvider({ provider: 'anthropic', model: 'claude-haiku-3-5' });
+
+    const response = await provider.complete({
+      model: 'claude-haiku-3-5',
+      messages: [{ role: 'user', content: 'Say hello in one word' }],
+      maxTokens: 10,
+    });
+
+    console.log('\nResponse:', response.content[0]?.type === 'text' ? response.content[0].text : '');
+
+    if (response.usage) {
+      console.log(`\nToken Usage:`);
+      console.log(`  Input: ${formatTokens(response.usage.inputTokens)}`);
+      console.log(`  Output: ${formatTokens(response.usage.outputTokens)}`);
+    }
+
+    if (response.cost) {
+      console.log(`\nCost Estimate:`);
+      console.log(`  Total: ${formatCost(response.cost.totalCost)}`);
+      console.log(`  Input: ${formatCost(response.cost.inputCost)}`);
+      console.log(`  Output: ${formatCost(response.cost.outputCost)}`);
+    }
+
+    console.log();
+    console.log('='.repeat(60));
+  } else {
+    console.log('Skipping API test (no ANTHROPIC_API_KEY)');
+    console.log('='.repeat(60));
+  }
+}
+
+testCostTracking().catch(console.error);

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.3",
+  "version": "0.2.0",
   "description": "An open-source AI assistant for your terminal",
   "type": "module",
   "main": "dist/index.js",

package/src/agent/agent.ts

@@ -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;
@@ -48,6 +55,7 @@ export class Agent {
     });
     this.sessionManager = new SessionManager();
     this.memoryManager = new MemoryManager();
+    this.planModeManager = getPlanModeManager();
   }
 
   /**
@@ -137,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
    */
@@ -290,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;
@@ -341,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;
       }
 
@@ -388,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/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,11 @@ export interface AgentEventError {
 export interface AgentEventDone {
   type: 'done';
   text: string;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+  cost?: CostEstimate;
 }
 
 export interface AgentEventAskUser {