gencode-ai 0.3.0 → 0.4.0

package/src/cli/components/CommandSuggestions.tsx

@@ -25,6 +25,8 @@ export const COMMANDS: Command[] = [
   { name: '/memory', description: 'Show memory files' },
   { name: '/changes', description: 'List file changes' },
   { name: '/rewind', description: 'Undo file changes' },
+  { name: '/context', description: 'Show context usage stats' },
+  { name: '/compact', description: 'Manually compact conversation' },
 ];
 
 interface CommandSuggestionsProps {

package/src/cli/components/Header.tsx

@@ -6,9 +6,14 @@ interface HeaderProps {
   provider: string;
   model: string;
   cwd: string;
+  contextStats?: {
+    activeMessages: number;
+    totalMessages: number;
+    usagePercent: number;
+  };
 }
 
-export function Header({ model, cwd }: HeaderProps) {
+export function Header({ model, cwd, contextStats }: HeaderProps) {
   return (
     <Box flexDirection="column" marginTop={1}>
       <BigLogo />
@@ -16,6 +21,16 @@ export function Header({ model, cwd }: HeaderProps) {
         <Text color={colors.textSecondary}>{model}</Text>
         <Text color={colors.textMuted}> · </Text>
         <Text color={colors.textMuted}>{cwd}</Text>
+
+        {contextStats && contextStats.activeMessages > 0 && (
+          <>
+            <Text color={colors.textMuted}> · </Text>
+            <Text color={colors.textSecondary}>
+              Context: {contextStats.activeMessages}/{contextStats.totalMessages} msgs
+            </Text>
+            <Text color={colors.textMuted}> ({Math.round(contextStats.usagePercent)}%)</Text>
+          </>
+        )}
       </Box>
     </Box>
   );

package/src/cli/components/Messages.tsx

@@ -110,29 +110,35 @@ interface ToolCallProps {
 function formatToolInput(name: string, input: Record<string, unknown>): string {
   switch (name) {
     case 'Read':
-      return input.file_path as string || '';
     case 'Write':
     case 'Edit':
-      return input.file_path as string || '';
+      return (input.file_path as string) || '';
+
     case 'Glob':
-      return input.pattern as string || '';
-    case 'Grep':
-      return `"${input.pattern}"` + (input.path ? ` in ${input.path}` : '');
+      return (input.pattern as string) || '';
+
+    case 'Grep': {
+      const pattern = `"${input.pattern}"`;
+      return input.path ? `${pattern} in ${input.path}` : pattern;
+    }
+
     case 'Bash':
-      return truncate(input.command as string || '', 50);
+      return truncate((input.command as string) || '', 50);
+
     case 'WebFetch':
-      return input.url as string || '';
+      return (input.url as string) || '';
+
     case 'WebSearch':
       return `"${input.query}"` || '';
+
     case 'TodoWrite': {
-      const todos = input.todos as Array<{ content: string; status: string }> || [];
+      const todos = (input.todos as Array<{ content: string; status: string }>) || [];
       return `${todos.length} task${todos.length !== 1 ? 's' : ''}`;
     }
-    case 'AskUserQuestion': {
-      // Show collapsed JSON preview
-      const json = JSON.stringify(input);
-      return truncate(json, 60);
-    }
+
+    case 'AskUserQuestion':
+      return truncate(JSON.stringify(input), 60);
+
     default:
       return truncate(JSON.stringify(input), 40);
   }
@@ -368,7 +374,7 @@ export function CompletionMessage({ durationMs, usage, cost }: CompletionMessage
     );
   }
 
-  if (cost) {
+  if (cost && cost.totalCost > 0) {
     parts.push(`(~${formatCost(cost.totalCost)})`);
   }
 

package/src/cli/index.tsx

@@ -34,7 +34,7 @@ async function setupProxy(): Promise<void> {
 // Configuration
 // ============================================================================
 function detectConfig(settings: Settings, providersConfig: ProvidersConfigManager): AgentConfig {
-  let provider: Provider = 'gemini';
+  let provider: Provider = 'google';
   let authMethod: AuthMethod | undefined;
   let model = 'gemini-2.0-flash';
 
@@ -60,7 +60,7 @@ function detectConfig(settings: Settings, providersConfig: ProvidersConfigManage
     authMethod = 'api_key';
     model = 'gpt-4o';
   } else if (process.env.GOOGLE_API_KEY) {
-    provider = 'gemini';
+    provider = 'google';
     authMethod = 'api_key';
     model = 'gemini-2.0-flash';
   }
@@ -99,6 +99,7 @@ function detectConfig(settings: Settings, providersConfig: ProvidersConfigManage
     model,
     cwd: process.cwd(),
     maxTurns: 20,
+    compression: settings.compression,
   };
 }
 

package/src/config/types.ts

@@ -17,7 +17,7 @@ import * as path from 'path';
 // Provider Types
 // =============================================================================
 
-export type Provider = 'openai' | 'anthropic' | 'gemini';
+export type Provider = 'openai' | 'anthropic' | 'google';
 export type AuthMethod = 'api_key' | 'vertex' | 'bedrock' | 'azure' | 'oauth';
 
 // Legacy type alias for backward compatibility
@@ -70,6 +70,31 @@ export interface Settings {
   // Memory configuration
   memoryMergeStrategy?: 'fallback' | 'both' | 'gen-only' | 'claude-only';
 
+  // Compression configuration
+  compression?: {
+    enabled?: boolean;
+    enablePruning?: boolean;
+    enableCompaction?: boolean;
+    pruneMinimum?: number;
+    pruneProtect?: number;
+    reservedOutputTokens?: number;
+    model?: string;
+  };
+
+  // Input history configuration
+  inputHistory?: {
+    enabled?: boolean;
+    maxSize?: number;
+    savePath?: string;
+    deduplicateConsecutive?: boolean;
+  };
+
+  // Input behavior configuration
+  input?: {
+    multilineEnabled?: boolean; // Default: true - Enable Shift+Enter for multi-line input
+    ctrlCClear?: boolean; // Default: true - Clear input on Ctrl+C if text present
+  };
+
   // Managed-only fields (cannot be overridden by lower levels)
   strictKnownMarketplaces?: unknown[];
 

package/src/index.ts

@@ -2,7 +2,7 @@
  * Recode - Multi-LLM Agent SDK
  *
  * A unified SDK for building AI agents with support for
- * OpenAI, Anthropic, and Google Gemini models.
+ * OpenAI, Anthropic, and Google models.
  */
 
 // Providers
@@ -24,13 +24,13 @@ export {
   type StopReason,
   type OpenAIConfig,
   type AnthropicConfig,
-  type GeminiConfig,
+  type GoogleConfig,
   type ProviderConfig,
   type ProviderName,
   // Providers
   OpenAIProvider,
   AnthropicProvider,
-  GeminiProvider,
+  GoogleProvider,
   // Factory
   createProvider,
   inferProvider,

package/src/input/history-manager.ts

@@ -0,0 +1,289 @@
+/**
+ * Input History Manager
+ * Manages command history with persistence, navigation, and deduplication
+ */
+
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+
+export interface HistoryEntry {
+  text: string;
+  timestamp: string;
+}
+
+export interface HistoryConfig {
+  enabled?: boolean;
+  maxSize?: number;
+  savePath?: string;
+  deduplicateConsecutive?: boolean;
+}
+
+interface HistoryFile {
+  entries: HistoryEntry[];
+  maxSize: number;
+}
+
+const DEFAULT_CONFIG: Required<HistoryConfig> = {
+  enabled: true,
+  maxSize: 1000,
+  savePath: '~/.gen/input-history.json',
+  deduplicateConsecutive: true,
+};
+
+export class InputHistoryManager {
+  private entries: HistoryEntry[] = [];
+  private currentPosition = -1; // -1 means not navigating
+  private config: Required<HistoryConfig>;
+  private savePath: string;
+  private saveTimeout: NodeJS.Timeout | null = null;
+  private isLoaded = false;
+
+  constructor(config: HistoryConfig = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.savePath = this.resolveTildePath(this.config.savePath);
+  }
+
+  /**
+   * Resolve ~ to home directory
+   */
+  private resolveTildePath(path: string): string {
+    return path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
+  }
+
+  /**
+   * Load history from disk
+   */
+  async load(): Promise<void> {
+    if (!this.config.enabled) {
+      return;
+    }
+
+    try {
+      const data = await fs.readFile(this.savePath, 'utf-8');
+      const historyFile: HistoryFile = JSON.parse(data);
+
+      // Validate and load entries
+      if (Array.isArray(historyFile.entries)) {
+        this.entries = historyFile.entries.filter(
+          (entry) => entry && typeof entry.text === 'string'
+        );
+
+        // Prune if maxSize changed
+        if (this.entries.length > this.config.maxSize) {
+          this.entries = this.entries.slice(-this.config.maxSize);
+        }
+      }
+
+      this.isLoaded = true;
+    } catch (error: unknown) {
+      // File doesn't exist or is corrupt - start with empty history
+      if (error instanceof Error && 'code' in error && error.code !== 'ENOENT') {
+        console.error('Failed to load input history:', error.message);
+      }
+      this.entries = [];
+      this.isLoaded = true;
+    }
+  }
+
+  /**
+   * Save history to disk (async, debounced)
+   */
+  async save(): Promise<void> {
+    if (!this.config.enabled || !this.isLoaded) {
+      return;
+    }
+
+    // Debounce saves to avoid excessive writes
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+    }
+
+    this.saveTimeout = setTimeout(async () => {
+      try {
+        // Ensure directory exists
+        const dir = dirname(this.savePath);
+        await fs.mkdir(dir, { recursive: true });
+
+        const historyFile: HistoryFile = {
+          entries: this.entries,
+          maxSize: this.config.maxSize,
+        };
+
+        await fs.writeFile(
+          this.savePath,
+          JSON.stringify(historyFile, null, 2),
+          'utf-8'
+        );
+      } catch (error: unknown) {
+        // Log but don't throw - saving history should not break the app
+        const message = error instanceof Error ? error.message : String(error);
+        console.error('Failed to save input history:', message);
+      }
+    }, 100); // 100ms debounce
+  }
+
+  /**
+   * Flush pending saves immediately (for app exit)
+   */
+  async flush(): Promise<void> {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = null;
+    }
+
+    if (!this.config.enabled || !this.isLoaded) {
+      return;
+    }
+
+    try {
+      const dir = dirname(this.savePath);
+      await fs.mkdir(dir, { recursive: true });
+
+      const historyFile: HistoryFile = {
+        entries: this.entries,
+        maxSize: this.config.maxSize,
+      };
+
+      await fs.writeFile(
+        this.savePath,
+        JSON.stringify(historyFile, null, 2),
+        'utf-8'
+      );
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error('Failed to flush input history:', message);
+    }
+  }
+
+  /**
+   * Add a new entry to history
+   */
+  add(text: string): void {
+    if (!this.config.enabled || !text.trim()) {
+      return;
+    }
+
+    const trimmedText = text.trim();
+
+    // Deduplicate consecutive entries
+    if (this.config.deduplicateConsecutive && this.entries.length > 0) {
+      const lastEntry = this.entries[this.entries.length - 1];
+      if (lastEntry.text === trimmedText) {
+        return; // Skip duplicate
+      }
+    }
+
+    // Add new entry
+    this.entries.push({
+      text: trimmedText,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Prune old entries if exceeding maxSize
+    if (this.entries.length > this.config.maxSize) {
+      this.entries = this.entries.slice(-this.config.maxSize);
+    }
+
+    // Reset navigation position
+    this.currentPosition = -1;
+
+    // Save asynchronously
+    void this.save();
+  }
+
+  /**
+   * Navigate to previous entry (older)
+   * Returns the entry text or null if at beginning
+   */
+  previous(): string | null {
+    if (!this.config.enabled || this.entries.length === 0) {
+      return null;
+    }
+
+    // First time navigating - start from end
+    if (this.currentPosition === -1) {
+      this.currentPosition = this.entries.length - 1;
+      return this.entries[this.currentPosition].text;
+    }
+
+    // Already at beginning
+    if (this.currentPosition === 0) {
+      return this.entries[0].text;
+    }
+
+    // Move to previous entry
+    this.currentPosition--;
+    return this.entries[this.currentPosition].text;
+  }
+
+  /**
+   * Navigate to next entry (newer)
+   * Returns the entry text or null if at end (original input)
+   */
+  next(): string | null {
+    if (!this.config.enabled || this.entries.length === 0) {
+      return null;
+    }
+
+    // Not navigating or at end
+    if (this.currentPosition === -1) {
+      return null;
+    }
+
+    // Move to next entry
+    this.currentPosition++;
+
+    // Reached end - return to original input
+    if (this.currentPosition >= this.entries.length) {
+      this.currentPosition = -1;
+      return null; // Signal to restore original input
+    }
+
+    return this.entries[this.currentPosition].text;
+  }
+
+  /**
+   * Reset navigation state (cancel history navigation)
+   */
+  reset(): void {
+    this.currentPosition = -1;
+  }
+
+  /**
+   * Check if currently navigating history
+   */
+  isNavigating(): boolean {
+    return this.currentPosition !== -1;
+  }
+
+  /**
+   * Get current position in history (-1 if not navigating)
+   */
+  getPosition(): number {
+    return this.currentPosition;
+  }
+
+  /**
+   * Get total number of entries
+   */
+  size(): number {
+    return this.entries.length;
+  }
+
+  /**
+   * Get all entries (for debugging/testing)
+   */
+  getEntries(): readonly HistoryEntry[] {
+    return this.entries;
+  }
+
+  /**
+   * Clear all history
+   */
+  clear(): void {
+    this.entries = [];
+    this.currentPosition = -1;
+    void this.save();
+  }
+}

package/src/input/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Input module - history management and enhanced input components
+ */
+
+export { InputHistoryManager } from './history-manager.js';
+export type { HistoryEntry, HistoryConfig } from './history-manager.js';

package/src/prompts/index.test.ts

@@ -104,7 +104,8 @@ describe('Prompt Loader', () => {
     it('should map known providers correctly', () => {
       expect(mapProviderToPromptType('anthropic')).toBe('anthropic');
       expect(mapProviderToPromptType('openai')).toBe('openai');
-      expect(mapProviderToPromptType('gemini')).toBe('gemini');
+      // Google provider uses Gemini models, so it maps to gemini prompt
+      expect(mapProviderToPromptType('google')).toBe('gemini');
     });
 
     it('should return generic for unknown providers', () => {

package/src/prompts/index.ts

@@ -83,7 +83,7 @@ export function getProviderForModel(model: string): string | null {
  * Handles both "provider" and "provider:authMethod" formats
  */
 export function mapProviderToPromptType(provider: string): ProviderType {
-  // Extract provider prefix (e.g., "gemini:api_key" → "gemini")
+  // Extract provider prefix (e.g., "google:api_key" → "google")
   const providerPrefix = provider.split(':')[0];
 
   switch (providerPrefix) {
@@ -91,8 +91,8 @@ export function mapProviderToPromptType(provider: string): ProviderType {
       return 'anthropic';
     case 'openai':
       return 'openai';
-    case 'gemini':
-      return 'gemini';
+    case 'google':
+      return 'gemini'; // Google provider uses Gemini models, so use gemini prompt
     default:
       return 'generic';
   }

package/src/providers/{gemini.ts → google.ts}

@@ -1,6 +1,6 @@
 /**
- * Google Gemini Provider Implementation
- * Supports Gemini 1.5 Pro, Gemini 1.5 Flash, Gemini 2.0, etc.
+ * Google Provider Implementation
+ * Supports Gemini models: Gemini 1.5 Pro, Gemini 1.5 Flash, Gemini 2.0, etc.
  */
 
 import { GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
@@ -16,28 +16,28 @@ import type {
   MessageContent,
   ToolDefinition,
   StopReason,
-  GeminiConfig,
+  GoogleConfig,
   JSONSchema,
   ModelInfo,
 } from './types.js';
 
-export class GeminiProvider implements LLMProvider {
+export class GoogleProvider implements LLMProvider {
   static readonly meta: ProviderClassMeta = {
-    provider: 'gemini',
+    provider: 'google',
     authMethod: 'api_key',
     envVars: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
-    displayName: 'Direct API',
-    description: 'Direct API access',
+    displayName: 'Google',
+    description: 'Google Generative AI (Gemini models)',
   };
 
-  readonly name = 'gemini';
+  readonly name = 'google';
   private client: GoogleGenerativeAI;
   private apiKey: string;
 
-  constructor(config: GeminiConfig = {}) {
+  constructor(config: GoogleConfig = {}) {
     const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
     if (!apiKey) {
-      throw new Error('Gemini API key is required. Set GOOGLE_API_KEY or GEMINI_API_KEY.');
+      throw new Error('Google API key is required. Set GOOGLE_API_KEY or GEMINI_API_KEY.');
     }
     this.apiKey = apiKey;
     this.client = new GoogleGenerativeAI(apiKey);
@@ -95,6 +95,12 @@ export class GeminiProvider implements LLMProvider {
           const id = `call_${callIndex++}`;
           // Capture thoughtSignature for Gemini 3+ models
           const partAny = part as { thoughtSignature?: string };
+
+          // Emit reasoning content if available (Gemini 3+ thinking)
+          if (partAny.thoughtSignature) {
+            yield { type: 'reasoning', text: partAny.thoughtSignature };
+          }
+
           functionCalls.push({
             id,
             name: fc.name,
@@ -125,13 +131,31 @@ export class GeminiProvider implements LLMProvider {
     const finalResponse = await result.response;
     const stopReason = this.getStopReason(finalResponse, functionCalls.length > 0);
 
+    // Debug: Log usage metadata
+    if (process.env.DEBUG_TOKENS) {
+      console.error('[Google] usageMetadata:', JSON.stringify(finalResponse.usageMetadata, null, 2));
+    }
+
     const usage = finalResponse.usageMetadata
       ? {
           inputTokens: finalResponse.usageMetadata.promptTokenCount ?? 0,
-          outputTokens: finalResponse.usageMetadata.candidatesTokenCount ?? 0,
+          // Fix: candidatesTokenCount is unreliable, calculate from total - prompt
+          // Ensure outputTokens is never negative
+          outputTokens: Math.max(
+            0,
+            (finalResponse.usageMetadata.totalTokenCount ?? 0) - (finalResponse.usageMetadata.promptTokenCount ?? 0)
+          ),
         }
       : undefined;
 
+    // Warn if suspicious token count
+    if (usage && usage.outputTokens === 0 && content.length > 0) {
+      console.warn(
+        '[Google] Warning: usageMetadata shows 0 output tokens but content was returned. ' +
+        'This may indicate a Gemini API issue.'
+      );
+    }
+
     const cost = usage ? calculateCost(this.name, options.model, usage) : undefined;
 
     yield {
@@ -276,13 +300,31 @@ export class GeminiProvider implements LLMProvider {
 
     const hasFunctionCalls = parts.some((p) => 'functionCall' in p);
 
+    // Debug: Log usage metadata
+    if (process.env.DEBUG_TOKENS) {
+      console.error('[Google complete] usageMetadata:', JSON.stringify(response.usageMetadata, null, 2));
+    }
+
     const usage = response.usageMetadata
       ? {
           inputTokens: response.usageMetadata.promptTokenCount ?? 0,
-          outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
+          // Fix: candidatesTokenCount is unreliable, calculate from total - prompt
+          // Ensure outputTokens is never negative
+          outputTokens: Math.max(
+            0,
+            (response.usageMetadata.totalTokenCount ?? 0) - (response.usageMetadata.promptTokenCount ?? 0)
+          ),
         }
       : undefined;
 
+    // Warn if suspicious token count
+    if (usage && usage.outputTokens === 0 && content.length > 0) {
+      console.warn(
+        '[Google] Warning: usageMetadata shows 0 output tokens but content was returned. ' +
+        'This may indicate a Gemini API issue.'
+      );
+    }
+
     const cost = usage ? calculateCost(this.name, model, usage) : undefined;
 
     return {
@@ -299,13 +341,22 @@ export class GeminiProvider implements LLMProvider {
     }
 
     const finishReason = response.candidates?.[0]?.finishReason;
-    switch (finishReason) {
-      case 'MAX_TOKENS':
-        return 'max_tokens';
-      case 'STOP':
-      default:
-        return 'end_turn';
+
+    if (finishReason === 'MAX_TOKENS') {
+      return 'max_tokens';
+    }
+
+    if (finishReason === 'STOP') {
+      return 'end_turn';
+    }
+
+    if (finishReason === 'SAFETY' || finishReason === 'RECITATION') {
+      console.warn(`[Google] Content blocked by ${finishReason} filter`);
+      return 'end_turn';
     }
+
+    console.warn(`[Google] Unknown finishReason: ${finishReason}`);
+    return 'end_turn';
   }
 
   async listModels(): Promise<ModelInfo[]> {