gencode-ai 0.1.3 → 0.3.0

package/src/providers/vertex-ai.ts

@@ -1,16 +1,25 @@
 /**
- * Google Vertex AI Provider Implementation
- * Supports Claude models deployed on Google Cloud Vertex AI
+ * Anthropic Vertex AI Provider
+ * Supports Claude models via Google Cloud Vertex AI
+ *
+ * Documentation: https://code.claude.com/docs/en/google-vertex-ai
+ *
+ * Required environment variables:
+ * - CLAUDE_CODE_USE_VERTEX=1
+ * - ANTHROPIC_VERTEX_PROJECT_ID=your-project-id
+ * - CLOUD_ML_REGION=global (or specific region like us-east5)
  *
  * Authentication uses Google Cloud's default credential chain:
- * 1. GOOGLE_APPLICATION_CREDENTIALS (service account JSON)
- * 2. gcloud auth application-default login (ADC)
+ * 1. gcloud auth application-default login (recommended)
+ * 2. GOOGLE_APPLICATION_CREDENTIALS (service account JSON)
  * 3. GCE/GKE metadata service (when running on GCP)
  */
 
 import { GoogleAuth } from 'google-auth-library';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
+  ProviderClassMeta,
   CompletionOptions,
   CompletionResponse,
   StreamChunk,
@@ -128,23 +137,40 @@ type StreamEvent =
   | { type: 'message_stop' }
   | { type: 'ping' };
 
-export class VertexAIProvider implements LLMProvider {
-  readonly name = 'vertex-ai';
+export class AnthropicVertexProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'anthropic',
+    authMethod: 'vertex',
+    envVars: [
+      'CLAUDE_CODE_USE_VERTEX',
+      'ANTHROPIC_VERTEX_PROJECT_ID',
+      'CLOUD_ML_REGION',
+    ],
+    displayName: 'Google Vertex AI',
+    description: 'Claude via Google Cloud Platform',
+  };
+
+  readonly name = 'anthropic-vertex';
   private projectId: string;
   private region: string;
   private auth: GoogleAuth;
   private accessToken?: string;
 
   constructor(config: VertexAIConfig = {}) {
+    // Project ID priority (per Claude Code docs):
+    // 1. config.projectId
+    // 2. ANTHROPIC_VERTEX_PROJECT_ID
+    // 3. GCLOUD_PROJECT
+    // 4. GOOGLE_CLOUD_PROJECT
     this.projectId =
       config.projectId ??
       process.env.ANTHROPIC_VERTEX_PROJECT_ID ??
+      process.env.GCLOUD_PROJECT ??
       process.env.GOOGLE_CLOUD_PROJECT ??
       '';
 
     this.region =
       config.region ??
-      process.env.ANTHROPIC_VERTEX_REGION ??
       process.env.CLOUD_ML_REGION ??
       'us-east5';
 
@@ -152,7 +178,7 @@ export class VertexAIProvider implements LLMProvider {
 
     if (!this.projectId) {
       throw new Error(
-        'Vertex AI requires a project ID. Set ANTHROPIC_VERTEX_PROJECT_ID environment variable.'
+        'Vertex AI requires a project ID. Set one of: ANTHROPIC_VERTEX_PROJECT_ID, GCLOUD_PROJECT, or GOOGLE_CLOUD_PROJECT'
       );
     }
 
@@ -166,12 +192,23 @@ export class VertexAIProvider implements LLMProvider {
       return this.accessToken;
     }
 
-    const client = await this.auth.getClient();
-    const tokenResponse = await client.getAccessToken();
-    if (!tokenResponse.token) {
-      throw new Error('Failed to get access token from Google Cloud');
+    try {
+      const client = await this.auth.getClient();
+      const tokenResponse = await client.getAccessToken();
+      if (!tokenResponse.token) {
+        throw new Error('Failed to get access token from Google Cloud');
+      }
+      return tokenResponse.token;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Failed to authenticate with Google Cloud. Please ensure you have:\n` +
+        `1. Run: gcloud auth application-default login\n` +
+        `2. Set ANTHROPIC_VERTEX_PROJECT_ID or GOOGLE_CLOUD_PROJECT\n` +
+        `3. Enabled Vertex AI API in your GCP project\n` +
+        `Original error: ${message}`
+      );
     }
-    return tokenResponse.token;
   }
 
   private getEndpoint(model: string, stream: boolean = false): string {
@@ -210,7 +247,7 @@ export class VertexAIProvider implements LLMProvider {
     }
 
     const data = (await response.json()) as VertexAIResponse;
-    return this.convertResponse(data);
+    return this.convertResponse(data, options.model);
   }
 
   async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
@@ -337,15 +374,20 @@ export class VertexAIProvider implements LLMProvider {
     // Build final response
     const content = this.buildFinalContent(contentBlocks, toolInputBuffers);
 
+    const usage = {
+      inputTokens,
+      outputTokens,
+    };
+
+    const cost = calculateCost(this.name, options.model, usage);
+
     yield {
       type: 'done',
       response: {
         content,
         stopReason,
-        usage: {
-          inputTokens,
-          outputTokens,
-        },
+        usage,
+        cost,
       },
     };
   }
@@ -449,14 +491,19 @@ export class VertexAIProvider implements LLMProvider {
     }));
   }
 
-  private convertResponse(response: VertexAIResponse): CompletionResponse {
+  private convertResponse(response: VertexAIResponse, model: string): CompletionResponse {
+    const usage = {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens,
+    };
+
+    const cost = calculateCost(this.name, model, usage);
+
     return {
       content: this.convertContent(response.content),
       stopReason: this.convertStopReason(response.stop_reason),
-      usage: {
-        inputTokens: response.usage.input_tokens,
-        outputTokens: response.usage.output_tokens,
-      },
+      usage,
+      cost,
     };
   }
 

package/src/session/manager.ts

@@ -326,6 +326,15 @@ export class SessionManager {
     }
   }
 
+  /**
+   * Remove the last message from current session
+   */
+  removeLastMessage(): void {
+    if (this.currentSession && this.currentSession.messages.length > 0) {
+      this.currentSession.messages.pop();
+    }
+  }
+
   /**
    * Export session to JSON
    */

package/src/session/types.ts

@@ -42,7 +42,7 @@ export interface SessionConfig {
 }
 
 export const DEFAULT_SESSION_CONFIG: SessionConfig = {
-  storageDir: '~/.gencode/sessions',
+  storageDir: '~/.gen/sessions',
   maxSessions: 50,
   maxAge: 30,
   autoSave: true,

package/src/tools/index.ts

@@ -28,6 +28,9 @@ export type {
   AskUserQuestionResult,
 } from './builtin/ask-user.js';
 
+// Plan mode tools
+export { enterPlanModeTool, exitPlanModeTool } from '../planning/index.js';
+
 import { ToolRegistry } from './registry.js';
 import { readTool } from './builtin/read.js';
 import { writeTool } from './builtin/write.js';
@@ -39,6 +42,7 @@ import { webfetchTool } from './builtin/webfetch.js';
 import { websearchTool } from './builtin/websearch.js';
 import { todowriteTool } from './builtin/todowrite.js';
 import { askUserQuestionTool } from './builtin/ask-user.js';
+import { enterPlanModeTool, exitPlanModeTool } from '../planning/index.js';
 
 /**
  * Create a registry with all built-in tools
@@ -56,6 +60,8 @@ export function createDefaultRegistry(): ToolRegistry {
     websearchTool,
     todowriteTool,
     askUserQuestionTool,
+    enterPlanModeTool,
+    exitPlanModeTool,
   ]);
   return registry;
 }
@@ -74,4 +80,6 @@ export const builtinTools = [
   websearchTool,
   todowriteTool,
   askUserQuestionTool,
+  enterPlanModeTool,
+  exitPlanModeTool,
 ];

package/src/tools/registry.ts

@@ -2,9 +2,16 @@
  * Tool Registry - Manages available tools
  */
 
+import * as fs from 'fs/promises';
 import type { Tool, ToolContext, ToolResult } from './types.js';
-import { zodToJsonSchema, getErrorMessage } from './types.js';
+import { zodToJsonSchema, getErrorMessage, resolvePath } from './types.js';
 import type { ToolDefinition } from '../providers/types.js';
+import { getPlanModeManager } from '../planning/index.js';
+import { getCheckpointManager } from '../checkpointing/index.js';
+import type { ChangeType } from '../checkpointing/index.js';
+
+// Tools that modify files and should be tracked for checkpointing
+const CHECKPOINT_TOOLS = ['Write', 'Edit'];
 
 export class ToolRegistry {
   private tools: Map<string, Tool> = new Map();
@@ -50,6 +57,20 @@ export class ToolRegistry {
       .filter((t): t is ToolDefinition => t !== null);
   }
 
+  /**
+   * Get tool definitions filtered by plan mode
+   * In plan mode, only read-only tools are returned
+   */
+  getFilteredDefinitions(toolNames?: string[]): ToolDefinition[] {
+    const planManager = getPlanModeManager();
+    const names = toolNames ?? this.list();
+
+    // Filter tools based on plan mode state
+    const filteredNames = planManager.filterTools(names);
+
+    return this.getDefinitions(filteredNames);
+  }
+
   /**
    * Execute a tool by name
    */
@@ -75,9 +96,81 @@ export class ToolRegistry {
         };
       }
 
-      return await tool.execute(parsed.data, context);
+      // Capture pre-execution state for checkpointing
+      let preState: { filePath: string; content: string | null; existed: boolean } | null = null;
+      if (CHECKPOINT_TOOLS.includes(name) && parsed.data && typeof parsed.data === 'object') {
+        const filePath = (parsed.data as { file_path?: string }).file_path;
+        if (filePath) {
+          preState = await this.captureFileState(filePath, context.cwd);
+        }
+      }
+
+      // Execute the tool
+      const result = await tool.execute(parsed.data, context);
+
+      // Record checkpoint on successful file modification
+      if (result.success && preState) {
+        await this.recordCheckpoint(name, preState, context.cwd);
+      }
+
+      return result;
     } catch (error) {
       return { success: false, output: '', error: `Tool execution failed: ${getErrorMessage(error)}` };
     }
   }
+
+  /**
+   * Capture file state before modification
+   */
+  private async captureFileState(
+    filePath: string,
+    cwd: string
+  ): Promise<{ filePath: string; content: string | null; existed: boolean }> {
+    const resolvedPath = resolvePath(filePath, cwd);
+    try {
+      const content = await fs.readFile(resolvedPath, 'utf-8');
+      return { filePath: resolvedPath, content, existed: true };
+    } catch {
+      // File doesn't exist
+      return { filePath: resolvedPath, content: null, existed: false };
+    }
+  }
+
+  /**
+   * Record a checkpoint after file modification
+   */
+  private async recordCheckpoint(
+    toolName: string,
+    preState: { filePath: string; content: string | null; existed: boolean },
+    cwd: string
+  ): Promise<void> {
+    const checkpointManager = getCheckpointManager();
+
+    // Read current file content
+    let newContent: string | null = null;
+    try {
+      newContent = await fs.readFile(preState.filePath, 'utf-8');
+    } catch {
+      // File was deleted or doesn't exist
+    }
+
+    // Determine change type
+    let changeType: ChangeType;
+    if (!preState.existed && newContent !== null) {
+      changeType = 'create';
+    } else if (preState.existed && newContent === null) {
+      changeType = 'delete';
+    } else {
+      changeType = 'modify';
+    }
+
+    // Record the change
+    checkpointManager.recordChange({
+      path: preState.filePath,
+      changeType,
+      previousContent: preState.content,
+      newContent,
+      toolName,
+    });
+  }
 }

package/.gencode/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(cd /Users/myan/Workspace/ideas/gencode:*)"
-    ]
-  }
-}

package/CLAUDE.md

@@ -1,86 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-**GenCode** (npm: `gencode-ai`) is an open-source AI assistant for the terminal. Extensible tools, customizable prompts, multi-provider support.
-
-## Build & Run Commands
-
-```bash
-npm install          # Install dependencies
-npm run build        # Compile TypeScript to dist/
-npm run dev          # Watch mode compilation
-npm start            # Run CLI directly via tsx
-npm run example      # Run examples/basic.ts
-```
-
-## Architecture
-
-### Provider Abstraction Layer (`src/providers/`)
-
-Unified `LLMProvider` interface abstracts API differences:
-- `complete()` - Non-streaming completion
-- `stream()` - Streaming completion (AsyncGenerator)
-
-Each provider (OpenAI, Anthropic, Gemini) translates the unified message format to its native API format and back. The `createProvider()` factory instantiates providers by name.
-
-### Tool System (`src/tools/`)
-
-Tools are defined with Zod schemas for input validation:
-```typescript
-interface Tool<TInput> {
-  name: string;
-  description: string;
-  parameters: z.ZodSchema<TInput>;
-  execute(input: TInput, context: ToolContext): Promise<ToolResult>;
-}
-```
-
-`ToolRegistry` manages tools and converts Zod schemas to JSON Schema for LLM consumption via `zodToJsonSchema()`.
-
-### Agent Loop (`src/agent/agent.ts`)
-
-The `Agent` class implements the core conversation loop:
-1. User message → LLM with tools
-2. If `stopReason === 'tool_use'`: execute tools, append results, loop back
-3. If `stopReason !== 'tool_use'`: done
-
-Events are yielded as `AgentEvent` (text, tool_start, tool_result, done, error).
-
-### Session Management (`src/session/`)
-
-Sessions persist conversation history to `~/.gencode/sessions/` as JSON files. Supports resume, fork, list, and delete operations.
-
-## Configuration
-
-Provider/model selection priority:
-1. `GENCODE_PROVIDER` / `GENCODE_MODEL` env vars
-2. Auto-detect from available API keys (ANTHROPIC_API_KEY → OPENAI_API_KEY → GOOGLE_API_KEY)
-3. Default: Gemini
-
-Proxy: Set `HTTP_PROXY` or `HTTPS_PROXY` for network proxy support.
-
-## Key Patterns
-
-- All file paths in tools should be resolved relative to `ToolContext.cwd`
-- Tool input validation uses Zod; errors returned as `ToolResult.error`
-- Provider implementations handle message format conversion internally
-- CLI commands start with `/` (e.g., `/sessions`, `/resume`, `/help`)
-
-## Reference Projects
-
-Similar projects for learning and reference:
-
-| Project | Path | Description |
-|---------|------|-------------|
-| OpenCode | `/Users/myan/Workspace/opencode` | Go-based AI coding assistant with TUI, multi-provider support |
-| System Prompts Collection | `/Users/myan/Workspace/ideas/system-prompts-and-models-of-ai-tools` | Collection of system prompts from various AI tools (Claude Code, Cursor, etc.) |
-| Learn Claude Code | `/Users/myan/Workspace/ideas/learn-claude-code` | Educational resources for understanding Claude Code internals |
-
-### Key Learnings from References
-
-- **OpenCode**: Go implementation with Ink-based TUI, LSP integration, conversation sessions
-- **System Prompts**: Study prompt engineering patterns used by production AI tools
-- **Learn Claude Code**: Understand Claude Code's tool system, agent loop, and UX patterns