gencode-ai 0.1.3 → 0.3.0

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,
@@ -35,6 +37,11 @@ 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 {
@@ -56,6 +63,14 @@ interface QuestionState {
   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;
@@ -108,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'],
@@ -115,8 +133,10 @@ function HelpPanel() {
     ['/new', 'New session'],
     ['/save', 'Save session'],
     ['/clear', 'Clear chat'],
-    ['/init', 'Generate AGENT.md'],
+    ['/init', 'Generate GEN.md'],
     ['/memory', 'Show memory files'],
+    ['/changes', 'List file changes'],
+    ['/rewind [n|all]', 'Undo file changes'],
   ];
 
   return (
@@ -246,12 +266,23 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
   const [showModelSelector, setShowModelSelector] = useState(false);
   const [showProviderManager, setShowProviderManager] = useState(false);
   const [currentModel, setCurrentModel] = useState(config.model);
+  const [currentProvider, setCurrentProvider] = useState(config.provider);
   const [cmdSuggestionIndex, setCmdSuggestionIndex] = useState(0);
   const [inputKey, setInputKey] = useState(0); // Force cursor to end after autocomplete
   const [pendingTool, setPendingTool] = useState<{ name: string; input: Record<string, unknown> } | null>(null);
   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) : [];
@@ -274,6 +305,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,
@@ -345,9 +381,14 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
   };
 
   // Handle model selection
-  const handleModelSelect = async (model: string, providerId?: ProviderName) => {
-    agent.setModel(model);
+  const handleModelSelect = async (model: string, providerId?: ProviderName, authMethod?: string) => {
+    agent.setModel(model, providerId, authMethod);
     setCurrentModel(model);
+
+    // Update provider state to keep UI in sync
+    const newProvider = agent.getProvider();
+    setCurrentProvider(newProvider);
+
     setShowModelSelector(false);
 
     if (providerId) {
@@ -442,6 +483,7 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
           // Direct model switch: /model gpt-4o
           agent.setModel(arg);
           setCurrentModel(arg);
+          setCurrentProvider(agent.getProvider());
           addHistory({ type: 'info', content: `Model: ${arg}` });
         } else {
           // Show interactive model selector
@@ -505,13 +547,13 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
       }
 
       case 'init': {
-        // Gather context files and generate AGENT.md
+        // Gather context files and generate GEN.md
         addHistory({ type: 'info', content: 'Analyzing codebase...' });
 
         const contextFiles = await gatherContextFiles(cwd);
         addHistory({ type: 'info', content: getContextSummary(contextFiles) });
 
-        // Check if AGENT.md already exists
+        // Check if GEN.md already exists
         const memoryManager = agent.getMemoryManager();
         const existingPath = await memoryManager.getExistingProjectMemoryPath(cwd);
         let existingContent: string | undefined;
@@ -531,7 +573,7 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
 
         // Build init prompt and run through agent
         const initPrompt = buildInitPrompt(contextFiles, existingContent);
-        addHistory({ type: 'info', content: 'Generating AGENT.md...' });
+        addHistory({ type: 'info', content: 'Generating GEN.md...' });
         addHistory({ type: 'user', content: '/init' });
         await runAgent(initPrompt);
         return true;
@@ -565,6 +607,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;
     }
@@ -661,9 +807,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;
         }
@@ -707,8 +857,8 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
     }
 
     // Handle # prefix for quick memory adds
-    // ## note -> user memory (~/.gencode/AGENT.md)
-    // # note -> project memory (./AGENT.md)
+    // ## note -> user memory (~/.gen/GEN.md)
+    // # note -> project memory (./GEN.md)
     if (trimmed.startsWith('#') && !trimmed.startsWith('#!/')) {
       const memoryManager = agent.getMemoryManager();
       let level: 'user' | 'project';
@@ -774,9 +924,33 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
       // 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) {
@@ -853,7 +1027,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:
@@ -862,7 +1042,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>
@@ -889,10 +1069,27 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
         />
       )}
 
+      {/* 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
             currentModel={currentModel}
+            currentProvider={currentProvider}
             onSelect={handleModelSelect}
             onCancel={handleModelCancel}
             listModels={() => agent.listModels()}
@@ -907,6 +1104,7 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
             onProviderChange={(providerId, model) => {
               agent.setModel(model);
               setCurrentModel(model);
+              setCurrentProvider(agent.getProvider());
               addHistory({ type: 'info', content: `Switched to ${providerId}: ${model}` });
             }}
           />
@@ -914,7 +1112,7 @@ export function App({ config, settingsManager, resumeLatest, permissionSettings
       )}
 
       {!confirmState && !questionState && !showModelSelector && !showProviderManager && (
-        <Box flexDirection="column" marginTop={1}>
+        <Box flexDirection="column" marginTop={2}>
           <PromptInput
             key={inputKey}
             value={input}
@@ -924,6 +1122,16 @@ 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>
       )}
 

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) =>
@@ -286,7 +288,7 @@ export function InfoMessage({ text, type = 'info' }: InfoMessageProps) {
   const { color, icon } = config[type];
 
   return (
-    <Box>
+    <Box marginTop={1}>
       <Text color={color}>{icon} </Text>
       <Text color={colors.textSecondary}>{text}</Text>
     </Box>
@@ -346,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>
   );
 }