gencode-ai 0.1.2 → 0.2.0

package/src/providers/openai.ts

@@ -4,6 +4,7 @@
  */
 
 import OpenAI from 'openai';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
   CompletionOptions,
@@ -44,7 +45,7 @@ export class OpenAIProvider implements LLMProvider {
       temperature: options.temperature,
     });
 
-    return this.convertResponse(response);
+    return this.convertResponse(response, options.model);
   }
 
   async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
@@ -195,7 +196,10 @@ export class OpenAIProvider implements LLMProvider {
     }));
   }
 
-  private convertResponse(response: OpenAI.Chat.Completions.ChatCompletion): CompletionResponse {
+  private convertResponse(
+    response: OpenAI.Chat.Completions.ChatCompletion,
+    model: string
+  ): CompletionResponse {
     const choice = response.choices[0];
     const content: MessageContent[] = [];
 
@@ -216,15 +220,20 @@ export class OpenAIProvider implements LLMProvider {
       }
     }
 
+    const usage = response.usage
+      ? {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens,
+        }
+      : undefined;
+
+    const cost = usage ? calculateCost(this.name, model, usage) : undefined;
+
     return {
       content,
       stopReason: this.convertStopReason(choice.finish_reason),
-      usage: response.usage
-        ? {
-            inputTokens: response.usage.prompt_tokens,
-            outputTokens: response.usage.completion_tokens,
-          }
-        : undefined,
+      usage,
+      cost,
     };
   }
 

package/src/providers/types.ts

@@ -3,6 +3,8 @@
  * Abstracts differences between OpenAI, Anthropic, and Gemini APIs
  */
 
+import type { CostEstimate } from '../pricing/types.js';
+
 // ============================================================================
 // Message Types
 // ============================================================================
@@ -92,6 +94,7 @@ export interface CompletionResponse {
     inputTokens: number;
     outputTokens: number;
   };
+  cost?: CostEstimate;
 }
 
 // ============================================================================

package/src/providers/vertex-ai.ts

@@ -9,6 +9,7 @@
  */
 
 import { GoogleAuth } from 'google-auth-library';
+import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
   CompletionOptions,
@@ -210,7 +211,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 +338,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 +455,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/tools/builtin/ask-user.ts

@@ -0,0 +1,185 @@
+/**
+ * AskUserQuestion Tool - Structured user questioning
+ *
+ * Allows the agent to pause execution and present structured questions
+ * to the user with predefined options. Supports single-select, multi-select,
+ * and custom "Other" input.
+ */
+
+import { z } from 'zod';
+import type { Tool, ToolResult, ToolContext } from '../types.js';
+import { loadToolDescription } from '../../prompts/index.js';
+
+// ============================================================================
+// Zod Schemas
+// ============================================================================
+
+export const QuestionOptionSchema = z.object({
+  label: z
+    .string()
+    .min(1)
+    .max(50)
+    .describe('Display text for this option (1-5 words, concise)'),
+  description: z
+    .string()
+    .min(1)
+    .max(200)
+    .describe('Explanation of what this option means or implications'),
+});
+
+export const QuestionSchema = z.object({
+  question: z
+    .string()
+    .min(1)
+    .describe('The complete question to ask the user, ending with a question mark'),
+  header: z
+    .string()
+    .min(1)
+    .max(12)
+    .describe('Very short label displayed as a chip/tag (max 12 chars)'),
+  options: z
+    .array(QuestionOptionSchema)
+    .min(2)
+    .max(4)
+    .describe('2-4 options for the user to choose from'),
+  multiSelect: z
+    .boolean()
+    .describe('Set to true to allow multiple selections, false for single choice'),
+});
+
+export const AskUserQuestionInputSchema = z.object({
+  questions: z
+    .array(QuestionSchema)
+    .min(1)
+    .max(4)
+    .describe('1-4 questions to ask the user'),
+});
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type QuestionOption = z.infer<typeof QuestionOptionSchema>;
+export type Question = z.infer<typeof QuestionSchema>;
+export type AskUserQuestionInput = z.infer<typeof AskUserQuestionInputSchema>;
+
+export interface QuestionAnswer {
+  question: string;
+  header: string;
+  selectedOptions: string[];
+  customInput?: string;
+}
+
+export interface AskUserQuestionResult {
+  answers: QuestionAnswer[];
+}
+
+// ============================================================================
+// Answer Formatting
+// ============================================================================
+
+/**
+ * Format answers for display to the agent
+ */
+export function formatAnswersForAgent(answers: QuestionAnswer[]): string {
+  const lines: string[] = ['User answered the following questions:', ''];
+
+  answers.forEach((answer, index) => {
+    lines.push(`${index + 1}. ${answer.header} (${answer.question})`);
+
+    if (answer.selectedOptions.length > 0) {
+      lines.push(`   Selected: ${answer.selectedOptions.join(', ')}`);
+    }
+
+    if (answer.customInput) {
+      lines.push(`   Custom input: ${answer.customInput}`);
+    }
+
+    lines.push('');
+  });
+
+  lines.push('Proceeding with user selections.');
+
+  return lines.join('\n');
+}
+
+/**
+ * Format answers for CLI confirmation display
+ */
+export function formatAnswersForDisplay(answers: QuestionAnswer[]): string {
+  return answers
+    .map((answer) => {
+      const selections = answer.customInput
+        ? [...answer.selectedOptions, answer.customInput].join(', ')
+        : answer.selectedOptions.join(', ');
+      return `✔ ${answer.header}: ${selections}`;
+    })
+    .join('\n');
+}
+
+// ============================================================================
+// Tool Implementation
+// ============================================================================
+
+/**
+ * AskUserQuestion tool
+ *
+ * This tool is special - it doesn't execute immediately but signals
+ * the agent loop to pause and wait for user input via the CLI.
+ *
+ * The actual questioning is handled by the CLI layer (QuestionPrompt component).
+ * This tool just validates the input and returns a marker for the agent loop.
+ */
+export const askUserQuestionTool: Tool<AskUserQuestionInput> = {
+  name: 'AskUserQuestion',
+  description: loadToolDescription('ask-user'),
+  parameters: AskUserQuestionInputSchema,
+
+  async execute(input: AskUserQuestionInput, context: ToolContext): Promise<ToolResult> {
+    // Validation is handled by Zod schema
+    // Additional validation for recommended options format
+    for (const question of input.questions) {
+      // Check if first option has (Recommended) - this is just a hint, not enforced
+      const firstOption = question.options[0];
+      if (firstOption && !firstOption.label.includes('(Recommended)')) {
+        // This is fine - recommended suffix is optional
+      }
+    }
+
+    // Check if context has askUser callback
+    if (context.askUser) {
+      try {
+        const answers = await context.askUser(input.questions);
+        return {
+          success: true,
+          output: formatAnswersForAgent(answers),
+          metadata: {
+            title: 'AskUserQuestion',
+            subtitle: `${answers.length} answer(s) received`,
+          },
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: '',
+          error: `Failed to get user response: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
+    }
+
+    // If no askUser callback, return a special marker
+    // The agent loop should detect this and handle it specially
+    return {
+      success: true,
+      output: JSON.stringify({
+        type: 'ask_user_question',
+        questions: input.questions,
+        requiresUserInput: true,
+      }),
+      metadata: {
+        title: 'AskUserQuestion',
+        subtitle: `${input.questions.length} question(s) pending`,
+      },
+    };
+  },
+};

package/src/tools/index.ts

@@ -15,6 +15,21 @@ export { grepTool } from './builtin/grep.js';
 export { webfetchTool } from './builtin/webfetch.js';
 export { websearchTool } from './builtin/websearch.js';
 export { todowriteTool, getTodos, clearTodos } from './builtin/todowrite.js';
+export {
+  askUserQuestionTool,
+  formatAnswersForAgent,
+  formatAnswersForDisplay,
+} from './builtin/ask-user.js';
+export type {
+  Question as AskUserQuestion,
+  QuestionOption as AskUserQuestionOption,
+  QuestionAnswer as AskUserQuestionAnswer,
+  AskUserQuestionInput,
+  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';
@@ -26,6 +41,8 @@ import { grepTool } from './builtin/grep.js';
 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
@@ -42,6 +59,9 @@ export function createDefaultRegistry(): ToolRegistry {
     webfetchTool,
     websearchTool,
     todowriteTool,
+    askUserQuestionTool,
+    enterPlanModeTool,
+    exitPlanModeTool,
   ]);
   return registry;
 }
@@ -59,4 +79,7 @@ export const builtinTools = [
   webfetchTool,
   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/src/tools/types.ts

@@ -9,9 +9,27 @@ import { z } from 'zod';
 // Tool Definition Types
 // ============================================================================
 
+// Forward declaration for Question type (used by AskUserQuestion tool)
+export interface Question {
+  question: string;
+  header: string;
+  options: Array<{ label: string; description: string }>;
+  multiSelect: boolean;
+}
+
+// Forward declaration for QuestionAnswer type (used by AskUserQuestion tool)
+export interface QuestionAnswer {
+  question: string;
+  header: string;
+  selectedOptions: string[];
+  customInput?: string;
+}
+
 export interface ToolContext {
   cwd: string;
   abortSignal?: AbortSignal;
+  /** Callback for AskUserQuestion tool to interact with user */
+  askUser?: (questions: Question[]) => Promise<QuestionAnswer[]>;
 }
 
 export interface ToolResultMetadata {

package/.gencode/settings.local.json

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