gencode-ai 0.1.2 → 0.2.0

package/src/checkpointing/index.ts

@@ -0,0 +1,45 @@
+/**
+ * Checkpointing Module
+ *
+ * Provides automatic tracking of file changes with undo/rewind capabilities.
+ *
+ * Usage:
+ *   import { getCheckpointManager, initCheckpointManager } from './checkpointing';
+ *
+ *   // Initialize at session start
+ *   const manager = initCheckpointManager('session-123');
+ *
+ *   // Record changes (done automatically by ToolRegistry)
+ *   manager.recordChange({
+ *     path: '/path/to/file.ts',
+ *     changeType: 'modify',
+ *     previousContent: 'old content',
+ *     newContent: 'new content',
+ *     toolName: 'Edit'
+ *   });
+ *
+ *   // List changes
+ *   console.log(manager.formatCheckpointList());
+ *
+ *   // Rewind changes
+ *   await manager.rewind({ all: true });
+ */
+
+// Type exports
+export type {
+  ChangeType,
+  FileCheckpoint,
+  CheckpointSession,
+  RewindOptions,
+  RewindResult,
+  CheckpointSummary,
+  RecordChangeInput,
+} from './types.js';
+
+// Manager exports
+export {
+  CheckpointManager,
+  getCheckpointManager,
+  initCheckpointManager,
+  resetCheckpointManager,
+} from './checkpoint-manager.js';

package/src/checkpointing/types.ts

@@ -0,0 +1,104 @@
+/**
+ * Checkpointing System Type Definitions
+ *
+ * Provides automatic tracking of file changes with undo/rewind capabilities.
+ */
+
+/**
+ * Type of file change
+ */
+export type ChangeType = 'create' | 'modify' | 'delete';
+
+/**
+ * A single file checkpoint recording a change
+ */
+export interface FileCheckpoint {
+  /** Unique identifier for this checkpoint */
+  id: string;
+  /** Path to the file that was changed */
+  path: string;
+  /** Type of change made */
+  changeType: ChangeType;
+  /** When the change was made */
+  timestamp: Date;
+  /** File content before the change (null for create) */
+  previousContent: string | null;
+  /** File content after the change (null for delete) */
+  newContent: string | null;
+  /** Which tool made the change */
+  toolName: string;
+}
+
+/**
+ * A checkpoint session containing all checkpoints for a session
+ */
+export interface CheckpointSession {
+  /** Session ID this checkpoint session belongs to */
+  sessionId: string;
+  /** All checkpoints in order */
+  checkpoints: FileCheckpoint[];
+  /** When this checkpoint session was created */
+  createdAt: Date;
+}
+
+/**
+ * Options for rewinding changes
+ */
+export interface RewindOptions {
+  /** Rewind a specific checkpoint by ID */
+  checkpointId?: string;
+  /** Rewind changes to a specific file path */
+  path?: string;
+  /** Rewind all changes */
+  all?: boolean;
+  /** Rewind the last N changes */
+  count?: number;
+}
+
+/**
+ * Result of a rewind operation
+ */
+export interface RewindResult {
+  /** Whether the rewind was successful */
+  success: boolean;
+  /** Files that were successfully reverted */
+  revertedFiles: Array<{
+    path: string;
+    action: 'restored' | 'deleted' | 'recreated';
+  }>;
+  /** Any errors that occurred during rewind */
+  errors: Array<{
+    path: string;
+    error: string;
+  }>;
+}
+
+/**
+ * Summary of changes in a checkpoint session
+ */
+export interface CheckpointSummary {
+  /** Number of files created */
+  created: number;
+  /** Number of files modified */
+  modified: number;
+  /** Number of files deleted */
+  deleted: number;
+  /** Total number of checkpoints */
+  total: number;
+}
+
+/**
+ * Input for recording a file change
+ */
+export interface RecordChangeInput {
+  /** Path to the file */
+  path: string;
+  /** Type of change */
+  changeType: ChangeType;
+  /** Content before change (null for create) */
+  previousContent: string | null;
+  /** Content after change (null for delete) */
+  newContent: string | null;
+  /** Tool that made the change */
+  toolName: string;
+}

package/src/cli/components/App.tsx

@@ -6,6 +6,8 @@ import { useState, useEffect, useCallback, useRef } from 'react';
 import { Box, Text, useApp, useInput, Static } from 'ink';
 import { Agent } from '../../agent/index.js';
 import type { AgentConfig } from '../../agent/types.js';
+import { formatTokens, formatCost } from '../../pricing/calculator.js';
+import type { CostEstimate } from '../../pricing/types.js';
 import {
   UserMessage,
   AssistantMessage,
@@ -28,11 +30,18 @@ import {
   PermissionAuditDisplay,
 } from './PermissionPrompt.js';
 import { TodoList } from './TodoList.js';
+import { QuestionPrompt, AnswerDisplay } from './QuestionPrompt.js';
 import { colors, icons } from './theme.js';
-import { getTodos } from '../../tools/index.js';
+import { getTodos, formatAnswersForDisplay } from '../../tools/index.js';
+import type { Question, QuestionAnswer } from '../../tools/types.js';
 import type { ProviderName } from '../../providers/index.js';
 import type { ApprovalAction, ApprovalSuggestion } from '../../permissions/types.js';
 import { gatherContextFiles, buildInitPrompt, getContextSummary } from '../../memory/index.js';
+// ModeIndicator kept for potential future use
+import { PlanApproval } from './PlanApproval.js';
+import type { ModeType, PlanApprovalOption, AllowedPrompt } from '../../planning/types.js';
+// Planning utilities kept for potential future use
+import { getCheckpointManager } from '../../checkpointing/index.js';
 
 // Types
 interface HistoryItem {
@@ -49,6 +58,19 @@ interface ConfirmState {
   resolve: (action: ApprovalAction) => void;
 }
 
+interface QuestionState {
+  questions: Question[];
+  resolve: (answers: QuestionAnswer[]) => void;
+}
+
+interface PlanApprovalState {
+  planSummary: string;
+  requestedPermissions: AllowedPrompt[];
+  filesToChange: Array<{ path: string; action: 'create' | 'modify' | 'delete' }>;
+  planFilePath: string;
+  resolve: (option: PlanApprovalOption, customInput?: string) => void;
+}
+
 interface SettingsManager {
   save: (settings: { model?: string }) => Promise<void>;
   getCwd?: () => string;
@@ -101,6 +123,9 @@ const formatRelativeTime = (dateStr: string) => {
 // ============================================================================
 function HelpPanel() {
   const commands: [string, string][] = [
+    ['/plan [desc]', 'Enter plan mode'],
+    ['/normal', 'Exit to normal mode'],
+    ['/accept', 'Enter auto-accept mode'],
     ['/model [name]', 'Switch model'],
     ['/provider', 'Manage providers'],
     ['/sessions', 'List sessions'],
@@ -110,6 +135,8 @@ function HelpPanel() {
     ['/clear', 'Clear chat'],
     ['/init', 'Generate AGENT.md'],
     ['/memory', 'Show memory files'],
+    ['/changes', 'List file changes'],
+    ['/rewind [n|all]', 'Undo file changes'],
   ];
 
   return (
@@ -235,6 +262,7 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
   const [processingStartTime, setProcessingStartTime] = useState<number | undefined>(undefined);
   const [tokenCount, setTokenCount] = useState(0);
   const [confirmState, setConfirmState] = useState<ConfirmState | null>(null);
+  const [questionState, setQuestionState] = useState<QuestionState | null>(null);
   const [showModelSelector, setShowModelSelector] = useState(false);
   const [showProviderManager, setShowProviderManager] = useState(false);
   const [currentModel, setCurrentModel] = useState(config.model);
@@ -244,6 +272,16 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
   const pendingToolRef = useRef<{ name: string; input: Record<string, unknown> } | null>(null);
   const [todos, setTodos] = useState<ReturnType<typeof getTodos>>([]);
 
+  // Operating mode state (normal → plan → accept → normal)
+  const [currentMode, setCurrentMode] = useState<ModeType>('normal');
+  const currentModeRef = useRef<ModeType>('normal'); // Track mode for confirm callback
+  const [planApprovalState, setPlanApprovalState] = useState<PlanApprovalState | null>(null);
+
+  // Keep ref in sync with state
+  useEffect(() => {
+    currentModeRef.current = currentMode;
+  }, [currentMode]);
+
   // Check if showing command suggestions
   const showCmdSuggestions = input.startsWith('/') && !isProcessing;
   const cmdSuggestions = showCmdSuggestions ? getFilteredCommands(input) : [];
@@ -266,6 +304,11 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
 
       // Set enhanced confirm callback with approval options
       agent.setEnhancedConfirmCallback(async (tool, toolInput, suggestions) => {
+        // Auto-approve in accept mode
+        if (currentModeRef.current === 'accept') {
+          return 'allow_once';
+        }
+
         return new Promise<ApprovalAction>((resolve) => {
           setConfirmState({
             tool,
@@ -276,6 +319,13 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
         });
       });
 
+      // Set askUser callback for AskUserQuestion tool
+      agent.setAskUserCallback(async (questions) => {
+        return new Promise<QuestionAnswer[]>((resolve) => {
+          setQuestionState({ questions, resolve });
+        });
+      });
+
       // Set callback to save permission rules to settings.local.json
       if (settingsManager?.addPermissionRule) {
         agent.setSaveRuleCallback(async (tool, pattern) => {
@@ -295,6 +345,32 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
     init();
   }, [agent, resumeLatest, addHistory, permissionSettings, settingsManager]);
 
+  // Handle question answers (AskUserQuestion)
+  const handleQuestionComplete = useCallback((answers: QuestionAnswer[]) => {
+    if (questionState) {
+      // Show confirmation in history
+      addHistory({
+        type: 'info',
+        content: formatAnswersForDisplay(answers),
+      });
+      questionState.resolve(answers);
+      setQuestionState(null);
+    }
+  }, [questionState, addHistory]);
+
+  // Handle question cancel
+  const handleQuestionCancel = useCallback(() => {
+    if (questionState) {
+      // Clear pending tool display (no more spinner)
+      pendingToolRef.current = null;
+      setPendingTool(null);
+      // Add canceled message to history
+      addHistory({ type: 'info', content: 'Question canceled' });
+      questionState.resolve([]); // Return empty answers on cancel
+      setQuestionState(null);
+    }
+  }, [questionState, addHistory]);
+
   // Handle permission decision
   const handlePermissionDecision = (action: ApprovalAction) => {
     if (confirmState) {
@@ -524,6 +600,110 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
         return true;
       }
 
+      case 'plan': {
+        // Enter plan mode
+        await agent.enterPlanMode(arg);
+        setCurrentMode('plan');
+        return true;
+      }
+
+      case 'normal': {
+        // Exit to normal mode
+        if (agent.isPlanModeActive()) {
+          agent.exitPlanMode(false);
+        }
+        setCurrentMode('normal');
+        return true;
+      }
+
+      case 'accept': {
+        // Enter auto-accept mode
+        if (agent.isPlanModeActive()) {
+          agent.exitPlanMode(false);
+        }
+        setCurrentMode('accept');
+        return true;
+      }
+
+      case 'changes': {
+        // List file changes (checkpoints)
+        const checkpointManager = getCheckpointManager();
+        if (!checkpointManager.hasCheckpoints()) {
+          addHistory({ type: 'info', content: '\nNo file changes in this session' });
+        } else {
+          addHistory({ type: 'info', content: '\n' + checkpointManager.formatCheckpointList(false) });
+        }
+        return true;
+      }
+
+      case 'rewind': {
+        // Rewind file changes
+        const checkpointManager = getCheckpointManager();
+
+        if (!checkpointManager.hasCheckpoints()) {
+          addHistory({ type: 'info', content: 'No file changes to rewind' });
+          return true;
+        }
+
+        if (arg === 'all') {
+          // Rewind all changes
+          const result = await checkpointManager.rewind({ all: true });
+
+          // Build output message showing both successes and failures
+          const messages: string[] = [''];  // Start with empty line for spacing
+
+          if (result.revertedFiles.length > 0) {
+            const files = result.revertedFiles.map((f) => {
+              const fileName = f.path.split('/').pop() || f.path;
+              return `  • ${fileName} (${f.action})`;
+            }).join('\n');
+            messages.push(`Reverted ${result.revertedFiles.length} file(s):\n${files}`);
+          }
+
+          if (result.errors.length > 0) {
+            const errors = result.errors.map((e) => {
+              const fileName = e.path.split('/').pop() || e.path;
+              return `  • ${fileName}: ${e.error}`;
+            }).join('\n');
+            messages.push(`\nFailed to revert ${result.errors.length} file(s):\n${errors}`);
+          }
+
+          if (messages.length > 1) {
+            addHistory({ type: 'info', content: messages.join('\n') });
+          } else {
+            addHistory({ type: 'info', content: '\nNo changes to rewind' });
+          }
+        } else if (arg) {
+          // Rewind specific checkpoint by index
+          const index = parseInt(arg, 10);
+          if (!isNaN(index) && index >= 1) {
+            const checkpoints = checkpointManager.getCheckpoints();
+            if (index <= checkpoints.length) {
+              const checkpoint = checkpoints[index - 1];
+              const result = await checkpointManager.rewind({ checkpointId: checkpoint.id });
+              if (result.success && result.revertedFiles.length > 0) {
+                const f = result.revertedFiles[0];
+                const fileName = f.path.split('/').pop() || f.path;
+                addHistory({ type: 'info', content: `\nReverted: ${fileName} (${f.action})` });
+              } else if (result.errors.length > 0) {
+                const fileName = result.errors[0].path.split('/').pop() || result.errors[0].path;
+                addHistory({ type: 'info', content: `\nFailed: ${fileName} - ${result.errors[0].error}` });
+              } else {
+                addHistory({ type: 'info', content: '\nFailed to rewind change' });
+              }
+            } else {
+              addHistory({ type: 'info', content: '\nInvalid index: ${index}' });
+            }
+          } else {
+            addHistory({ type: 'info', content: '\nUsage: /rewind [n|all]' });
+          }
+        } else {
+          // Show changes and usage in one message
+          addHistory({ type: 'info', content: '\n' + checkpointManager.formatCheckpointList(true) });
+        }
+        return true;
+      }
+
       default:
         return false;
     }
@@ -620,9 +800,13 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
               streamingTextRef.current = '';
               setStreamingText('');
             }
-            // Add completion message with duration
+            // Add completion message with duration and cost info
             const durationMs = Date.now() - startTime;
-            addHistory({ type: 'completion', content: '', meta: { durationMs } });
+            addHistory({
+              type: 'completion',
+              content: '',
+              meta: { durationMs, usage: event.usage, cost: event.cost },
+            });
             setProcessingStartTime(undefined);
             break;
         }
@@ -730,9 +914,36 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
       setIsProcessing(false);
       setStreamingText('');
       streamingTextRef.current = '';
+      // Clear pending tool (stop spinner)
+      pendingToolRef.current = null;
+      setPendingTool(null);
+      // Clean up incomplete tool_use messages to prevent API errors
+      agent.cleanupIncompleteMessages();
       addHistory({ type: 'info', content: 'Interrupted' });
     }
 
+    // Shift+Tab to cycle modes: normal → plan → accept → normal
+    if (key.shift && key.tab && !isProcessing && !confirmState && !questionState && !planApprovalState) {
+      const cycleMode = async () => {
+        const nextMode: Record<ModeType, ModeType> = {
+          normal: 'plan',
+          plan: 'accept',
+          accept: 'normal',
+        };
+        const newMode = nextMode[currentMode];
+
+        // Handle plan mode transitions
+        if (newMode === 'plan') {
+          await agent.enterPlanMode();
+        } else if (currentMode === 'plan') {
+          agent.exitPlanMode(false);
+        }
+
+        setCurrentMode(newMode);
+      };
+      cycleMode();
+    }
+
     // Command suggestion navigation
     if (showCmdSuggestions && cmdSuggestions.length > 0) {
       if (key.upArrow) {
@@ -809,7 +1020,13 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
         }
         return <InfoMessage text={item.content} />;
       case 'completion':
-        return <CompletionMessage durationMs={(item.meta?.durationMs as number) || 0} />;
+        return (
+          <CompletionMessage
+            durationMs={(item.meta?.durationMs as number) || 0}
+            usage={item.meta?.usage as { inputTokens: number; outputTokens: number } | undefined}
+            cost={item.meta?.cost as CostEstimate | undefined}
+          />
+        );
       case 'todos':
         return <TodoList todos={item.meta?.todos as ReturnType<typeof getTodos>} />;
       default:
@@ -818,7 +1035,7 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
   };
 
   return (
-    <Box flexDirection="column">
+    <Box flexDirection="column" paddingBottom={2}>
       <Static items={history}>
         {(item) => <Box key={item.id}>{renderHistoryItem(item)}</Box>}
       </Static>
@@ -837,6 +1054,30 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
         />
       )}
 
+      {questionState && (
+        <QuestionPrompt
+          questions={questionState.questions}
+          onComplete={handleQuestionComplete}
+          onCancel={handleQuestionCancel}
+        />
+      )}
+
+      {/* Plan approval UI */}
+      {planApprovalState && (
+        <Box marginTop={1}>
+          <PlanApproval
+            planSummary={planApprovalState.planSummary}
+            requestedPermissions={planApprovalState.requestedPermissions}
+            filesToChange={planApprovalState.filesToChange}
+            planFilePath={planApprovalState.planFilePath}
+            onDecision={(option, customInput) => {
+              planApprovalState.resolve(option, customInput);
+              setPlanApprovalState(null);
+            }}
+          />
+        </Box>
+      )}
+
       {showModelSelector && (
         <Box marginTop={1}>
           <ModelSelector
@@ -861,8 +1102,8 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
         </Box>
       )}
 
-      {!confirmState && !showModelSelector && !showProviderManager && (
-        <Box flexDirection="column" marginTop={1}>
+      {!confirmState && !questionState && !showModelSelector && !showProviderManager && (
+        <Box flexDirection="column" marginTop={2}>
           <PromptInput
             key={inputKey}
             value={input}
@@ -872,10 +1113,20 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
           {showCmdSuggestions && cmdSuggestions.length > 0 && (
             <CommandSuggestions input={input} selectedIndex={cmdSuggestionIndex} />
           )}
+          {currentMode === 'plan' && !isProcessing && (
+            <Text color={colors.warning} dimColor>
+              {icons.modePlan} plan mode on (shift+tab to cycle)
+            </Text>
+          )}
+          {currentMode === 'accept' && !isProcessing && (
+            <Text color={colors.success} dimColor>
+              {icons.modeAccept} accept edits on (shift+tab to cycle)
+            </Text>
+          )}
         </Box>
       )}
 
-      {isProcessing && !confirmState ? (
+      {isProcessing && !confirmState && !questionState ? (
         <ProgressBar startTime={processingStartTime} tokenCount={tokenCount} isThinking={isThinking} />
       ) : showCmdSuggestions && cmdSuggestions.length > 0 ? (
         <Box marginTop={1}>

package/src/cli/components/CommandSuggestions.tsx

@@ -7,6 +7,9 @@ interface Command {
 }
 
 export const COMMANDS: Command[] = [
+  { name: '/plan', description: 'Enter plan mode (Shift+Tab to cycle)' },
+  { name: '/normal', description: 'Exit to normal mode' },
+  { name: '/accept', description: 'Enter auto-accept mode' },
   { name: '/model', description: 'Switch model' },
   { name: '/provider', description: 'Manage providers' },
   { name: '/permissions', description: 'View permission rules' },
@@ -20,6 +23,8 @@ export const COMMANDS: Command[] = [
   { name: '/help', description: 'Show help' },
   { name: '/init', description: 'Generate AGENT.md' },
   { name: '/memory', description: 'Show memory files' },
+  { name: '/changes', description: 'List file changes' },
+  { name: '/rewind', description: 'Undo file changes' },
 ];
 
 interface CommandSuggestionsProps {

package/src/cli/components/Messages.tsx

@@ -3,6 +3,8 @@ import { Box, Text } from 'ink';
 import InkSpinner from 'ink-spinner';
 import { colors, icons } from './theme.js';
 import { renderMarkdown } from './markdown.js';
+import { formatTokens, formatCost } from '../../pricing/calculator.js';
+import type { CostEstimate } from '../../pricing/types.js';
 
 // Truncate string with ellipsis
 const truncate = (str: string, maxLen: number) =>
@@ -126,6 +128,11 @@ function formatToolInput(name: string, input: Record<string, unknown>): 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);
+    }
     default:
       return truncate(JSON.stringify(input), 40);
   }
@@ -135,6 +142,25 @@ export function ToolCall({ name, input }: ToolCallProps) {
   // Hide TodoWrite (shown in TodoList component)
   if (name === 'TodoWrite') return null;
 
+  // Special display for AskUserQuestion (Claude Code style with expand hint)
+  if (name === 'AskUserQuestion') {
+    const json = JSON.stringify(input);
+    const displayJson = truncate(json, 70);
+
+    return (
+      <Box marginTop={1} flexDirection="column">
+        <Box>
+          <Text color={colors.tool}>{icons.tool}</Text>
+          <Text> </Text>
+          <Text bold>{name}</Text>
+          <Text color={colors.textMuted}>  </Text>
+          <Text color={colors.textSecondary}>{displayJson}</Text>
+          <Text color={colors.textMuted}>  ctrl+o</Text>
+        </Box>
+      </Box>
+    );
+  }
+
   const displayInput = formatToolInput(name, input);
 
   return (
@@ -162,6 +188,25 @@ export function PendingToolCall({ name, input }: PendingToolCallProps) {
   // Hide TodoWrite (shown in TodoList component)
   if (name === 'TodoWrite') return null;
 
+  // Special display for AskUserQuestion
+  if (name === 'AskUserQuestion') {
+    const json = JSON.stringify(input);
+    const displayJson = truncate(json, 70);
+
+    return (
+      <Box marginTop={1}>
+        <Text color={colors.tool}>
+          <InkSpinner type="dots" />
+        </Text>
+        <Text> </Text>
+        <Text bold>{name}</Text>
+        <Text color={colors.textMuted}>  </Text>
+        <Text color={colors.textSecondary}>{displayJson}</Text>
+        <Text color={colors.textMuted}>  ctrl+o</Text>
+      </Box>
+    );
+  }
+
   const displayInput = formatToolInput(name, input);
 
   return (
@@ -303,16 +348,33 @@ function formatDuration(ms: number): string {
 
 interface CompletionMessageProps {
   durationMs: number;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+  cost?: CostEstimate;
 }
 
-export function CompletionMessage({ durationMs }: CompletionMessageProps) {
+export function CompletionMessage({ durationMs, usage, cost }: CompletionMessageProps) {
   // Pick a random verb (stable per render via useMemo would be better, but keep simple)
   const verb = COMPLETION_VERBS[Math.floor(Math.random() * COMPLETION_VERBS.length)];
+
+  // Build the message parts
+  const parts = [`✻ ${verb} for ${formatDuration(durationMs)}`];
+
+  if (usage) {
+    parts.push(
+      `Tokens: ${formatTokens(usage.inputTokens)} in / ${formatTokens(usage.outputTokens)} out`
+    );
+  }
+
+  if (cost) {
+    parts.push(`(~${formatCost(cost.totalCost)})`);
+  }
+
   return (
     <Box marginTop={1}>
-      <Text color={colors.textMuted}>
-        ✻ {verb} for {formatDuration(durationMs)}
-      </Text>
+      <Text color={colors.textMuted}>{parts.join(' • ')}</Text>
     </Box>
   );
 }