gencode-ai 0.1.3 → 0.2.0

package/src/checkpointing/checkpoint-manager.ts

@@ -0,0 +1,327 @@
+/**
+ * Checkpoint Manager - Core checkpointing logic
+ *
+ * Tracks file changes and provides rewind capabilities.
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type {
+  FileCheckpoint,
+  CheckpointSession,
+  RewindOptions,
+  RewindResult,
+  CheckpointSummary,
+  RecordChangeInput,
+} from './types.js';
+
+/**
+ * Generates a unique ID for checkpoints
+ */
+function generateId(): string {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/**
+ * CheckpointManager manages file change tracking and rewind operations.
+ *
+ * Usage:
+ *   const manager = new CheckpointManager('session-123');
+ *   manager.recordChange({ path: '/path/to/file', changeType: 'modify', ... });
+ *   await manager.rewind({ all: true });
+ */
+export class CheckpointManager {
+  private session: CheckpointSession;
+
+  constructor(sessionId: string = 'default') {
+    this.session = {
+      sessionId,
+      checkpoints: [],
+      createdAt: new Date(),
+    };
+  }
+
+  /**
+   * Get the session ID
+   */
+  getSessionId(): string {
+    return this.session.sessionId;
+  }
+
+  /**
+   * Record a file change as a checkpoint
+   */
+  recordChange(input: RecordChangeInput): FileCheckpoint {
+    const checkpoint: FileCheckpoint = {
+      id: generateId(),
+      path: input.path,
+      changeType: input.changeType,
+      timestamp: new Date(),
+      previousContent: input.previousContent,
+      newContent: input.newContent,
+      toolName: input.toolName,
+    };
+
+    this.session.checkpoints.push(checkpoint);
+    return checkpoint;
+  }
+
+  /**
+   * Get all checkpoints
+   */
+  getCheckpoints(): FileCheckpoint[] {
+    return [...this.session.checkpoints];
+  }
+
+  /**
+   * Get checkpoints for a specific file
+   */
+  getFileHistory(filePath: string): FileCheckpoint[] {
+    return this.session.checkpoints.filter((cp) => cp.path === filePath);
+  }
+
+  /**
+   * Get a summary of all changes
+   */
+  getSummary(): CheckpointSummary {
+    const summary: CheckpointSummary = {
+      created: 0,
+      modified: 0,
+      deleted: 0,
+      total: this.session.checkpoints.length,
+    };
+
+    for (const cp of this.session.checkpoints) {
+      switch (cp.changeType) {
+        case 'create':
+          summary.created++;
+          break;
+        case 'modify':
+          summary.modified++;
+          break;
+        case 'delete':
+          summary.deleted++;
+          break;
+      }
+    }
+
+    return summary;
+  }
+
+  /**
+   * Check if there are any checkpoints
+   */
+  hasCheckpoints(): boolean {
+    return this.session.checkpoints.length > 0;
+  }
+
+  /**
+   * Get the number of checkpoints
+   */
+  getCheckpointCount(): number {
+    return this.session.checkpoints.length;
+  }
+
+  /**
+   * Rewind changes based on options
+   */
+  async rewind(options: RewindOptions): Promise<RewindResult> {
+    const result: RewindResult = {
+      success: true,
+      revertedFiles: [],
+      errors: [],
+    };
+
+    // Determine which checkpoints to rewind
+    let checkpointsToRewind: FileCheckpoint[] = [];
+
+    if (options.checkpointId) {
+      // Rewind specific checkpoint
+      const cp = this.session.checkpoints.find((c) => c.id === options.checkpointId);
+      if (cp) {
+        checkpointsToRewind = [cp];
+      }
+    } else if (options.path) {
+      // Rewind all changes to a specific file (in reverse order)
+      checkpointsToRewind = this.session.checkpoints
+        .filter((c) => c.path === options.path)
+        .reverse();
+    } else if (options.count) {
+      // Rewind last N changes (in reverse order)
+      checkpointsToRewind = this.session.checkpoints.slice(-options.count).reverse();
+    } else if (options.all) {
+      // Rewind all changes (in reverse order)
+      checkpointsToRewind = [...this.session.checkpoints].reverse();
+    }
+
+    // Apply reverts
+    for (const checkpoint of checkpointsToRewind) {
+      try {
+        await this.revertCheckpoint(checkpoint);
+        result.revertedFiles.push({
+          path: checkpoint.path,
+          action: this.getRevertAction(checkpoint),
+        });
+
+        // Remove the checkpoint from session
+        const index = this.session.checkpoints.findIndex((c) => c.id === checkpoint.id);
+        if (index !== -1) {
+          this.session.checkpoints.splice(index, 1);
+        }
+      } catch (error) {
+        result.success = false;
+        result.errors.push({
+          path: checkpoint.path,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Revert a single checkpoint
+   */
+  private async revertCheckpoint(checkpoint: FileCheckpoint): Promise<void> {
+    switch (checkpoint.changeType) {
+      case 'create':
+        // File was created, delete it to revert
+        await fs.unlink(checkpoint.path);
+        break;
+
+      case 'modify':
+        // File was modified, restore previous content
+        if (checkpoint.previousContent !== null) {
+          await fs.writeFile(checkpoint.path, checkpoint.previousContent, 'utf-8');
+        }
+        break;
+
+      case 'delete':
+        // File was deleted, recreate it with previous content
+        if (checkpoint.previousContent !== null) {
+          await fs.mkdir(path.dirname(checkpoint.path), { recursive: true });
+          await fs.writeFile(checkpoint.path, checkpoint.previousContent, 'utf-8');
+        }
+        break;
+    }
+  }
+
+  /**
+   * Get the action that will be taken to revert a checkpoint
+   */
+  private getRevertAction(checkpoint: FileCheckpoint): 'restored' | 'deleted' | 'recreated' {
+    switch (checkpoint.changeType) {
+      case 'create':
+        return 'deleted';
+      case 'modify':
+        return 'restored';
+      case 'delete':
+        return 'recreated';
+    }
+  }
+
+  /**
+   * Clear all checkpoints
+   */
+  clearCheckpoints(): void {
+    this.session.checkpoints = [];
+  }
+
+  /**
+   * Format checkpoints for display
+   */
+  formatCheckpointList(includeUsage: boolean = false): string {
+    if (this.session.checkpoints.length === 0) {
+      return 'No file changes in this session.';
+    }
+
+    const lines: string[] = [];
+
+    this.session.checkpoints.forEach((cp, index) => {
+      const timeAgo = this.formatTimeAgo(cp.timestamp);
+      const action = this.formatChangeType(cp.changeType);
+      const fileName = cp.path.split('/').pop() || cp.path;
+      lines.push(`  [${index + 1}] ${timeAgo.padEnd(8)} ${fileName.padEnd(30)} (${action})`);
+    });
+
+    const summary = this.getSummary();
+    lines.push('');
+    lines.push(
+      `Total: ${summary.created} created, ${summary.modified} modified, ${summary.deleted} deleted`
+    );
+
+    if (includeUsage) {
+      lines.push('');
+      lines.push('Usage: /rewind [n] to revert change #n, /rewind all to revert all');
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format a change type for display
+   */
+  private formatChangeType(changeType: string): string {
+    switch (changeType) {
+      case 'create':
+        return 'created';
+      case 'modify':
+        return 'modified';
+      case 'delete':
+        return 'deleted';
+      default:
+        return changeType;
+    }
+  }
+
+  /**
+   * Format a timestamp as relative time
+   */
+  private formatTimeAgo(date: Date): string {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+
+    if (seconds < 60) {
+      return `${seconds}s ago`;
+    }
+
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) {
+      return `${minutes}m ago`;
+    }
+
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ago`;
+  }
+}
+
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+
+let globalCheckpointManager: CheckpointManager | null = null;
+
+/**
+ * Get the global checkpoint manager instance
+ */
+export function getCheckpointManager(): CheckpointManager {
+  if (!globalCheckpointManager) {
+    globalCheckpointManager = new CheckpointManager();
+  }
+  return globalCheckpointManager;
+}
+
+/**
+ * Initialize checkpoint manager with a session ID
+ */
+export function initCheckpointManager(sessionId: string): CheckpointManager {
+  globalCheckpointManager = new CheckpointManager(sessionId);
+  return globalCheckpointManager;
+}
+
+/**
+ * Reset the global checkpoint manager (for testing)
+ */
+export function resetCheckpointManager(): void {
+  globalCheckpointManager = null;
+}

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;
+}