gencode-ai 0.1.3 → 0.2.0

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