@xagent-ai/cli 1.0.1

package/src/cancellation.ts

@@ -0,0 +1,176 @@
+import { EventEmitter } from 'events';
+import readline from 'readline';
+import { getLogger } from './logger.js';
+
+const logger = getLogger();
+
+export class CancellationManager extends EventEmitter {
+  private isCancelled: boolean = false;
+  private operationId: string | null = null;
+  private keyPressHandler: ((str: string, key: readline.Key) => void) | null = null;
+  private sigintHandler: (() => void) | null = null;
+
+  constructor() {
+    super();
+    this.setupKeyHandler();
+  }
+
+  /**
+   * Set up key handler to listen for ESC key
+   */
+  private setupKeyHandler(): void {
+    if (process.stdin.isTTY) {
+      // Use readline's keypress handling
+      readline.emitKeypressEvents(process.stdin);
+
+      this.keyPressHandler = (str: string, key: readline.Key) => {
+        logger.debug(`[CancellationManager] Key pressed: str='${str}', name='${key.name}'`);
+        if (str === '\u001B' || key.name === 'escape') {
+          logger.debug(`[CancellationManager] ESC key detected!`);
+          this.cancel();
+        }
+      };
+
+      process.stdin.on('keypress', this.keyPressHandler);
+
+      process.stdin.on('error', (error) => {
+        logger.error(`Error in stdin handler: ${error}`);
+      });
+
+      // Also listen for SIGINT (Ctrl+C)
+      this.sigintHandler = () => {
+        logger.debug('[CancellationManager] SIGINT received!');
+        this.cancel();
+      };
+      process.on('SIGINT', this.sigintHandler);
+    } else {
+      logger.debug('[CancellationManager] stdin is not a TTY, ESC cancellation disabled');
+    }
+  }
+
+  /**
+   * Start a new operation
+   */
+  startOperation(operationId: string): void {
+    this.operationId = operationId;
+    this.isCancelled = false;
+    this.emit('operationStarted', operationId);
+  }
+
+  /**
+   * Cancel current operation
+   */
+  cancel(): void {
+    if (!this.isCancelled) {
+      this.isCancelled = true;
+      this.emit('cancelled', this.operationId);
+    }
+  }
+
+  /**
+   * Check if current operation is cancelled
+   */
+  isOperationCancelled(): boolean {
+    return this.isCancelled;
+  }
+
+  /**
+   * Complete current operation
+   */
+  completeOperation(): void {
+    if (this.operationId) {
+      this.emit('operationCompleted', this.operationId);
+    }
+    this.operationId = null;
+    this.isCancelled = false;
+  }
+
+  /**
+   * Get current operation ID
+   */
+  getCurrentOperationId(): string | null {
+    return this.operationId;
+  }
+
+  /**
+   * Reset cancellation state
+   */
+  reset(): void {
+    this.isCancelled = false;
+    this.operationId = null;
+  }
+
+  /**
+   * Clean up resources
+   */
+  cleanup(): void {
+    if (process.stdin.isTTY && this.keyPressHandler) {
+      process.stdin.removeListener('keypress', this.keyPressHandler);
+      this.keyPressHandler = null;
+    }
+    if (this.sigintHandler) {
+      process.off('SIGINT', this.sigintHandler);
+      this.sigintHandler = null;
+    }
+    process.stdin.removeAllListeners('error');
+    this.removeAllListeners();
+  }
+
+  /**
+   * Create a cancellable Promise wrapper
+   */
+  async withCancellation<T>(
+    promise: Promise<T>,
+    operationId: string
+  ): Promise<T> {
+    logger.debug(`[CancellationManager] withCancellation started: ${operationId}`);
+    this.startOperation(operationId);
+
+    // Create a promise that can be rejected externally
+    let rejectCancellation: ((reason?: any) => void) | null = null;
+    const cancelPromise = new Promise((_, reject) => {
+      rejectCancellation = reject;
+    });
+
+    // Listen for cancellation event
+    const onCancelled = () => {
+      logger.debug(`[CancellationManager] 'cancelled' event received: ${operationId}`);
+      if (rejectCancellation) {
+        rejectCancellation(new Error('Operation cancelled by user'));
+      }
+    };
+
+    this.on('cancelled', onCancelled);
+
+    // Race between the original promise and cancellation
+    try {
+      const result = await Promise.race([
+        promise,
+        cancelPromise
+      ]);
+
+      this.off('cancelled', onCancelled);
+      this.completeOperation();
+      logger.debug(`[CancellationManager] Operation completed: ${operationId}`);
+      return result as T;
+    } catch (error: any) {
+      this.off('cancelled', onCancelled);
+      if (error.message === 'Operation cancelled by user') {
+        this.completeOperation();
+        logger.debug(`[CancellationManager] Operation cancelled: ${operationId}`);
+      } else {
+        this.completeOperation();
+      }
+      throw error;
+    }
+  }
+}
+
+let cancellationManagerInstance: CancellationManager | null = null;
+
+export function getCancellationManager(): CancellationManager {
+  if (!cancellationManagerInstance) {
+    cancellationManagerInstance = new CancellationManager();
+  }
+  return cancellationManagerInstance;
+}

package/src/checkpoint.ts

@@ -0,0 +1,219 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import crypto from 'crypto';
+import { Checkpoint, ChatMessage, ToolCall } from './types.js';
+
+const execAsync = promisify(exec);
+
+export class CheckpointManager {
+  private snapshotsDir: string;
+  private checkpointsDir: string;
+  private projectHash: string;
+  private checkpoints: Map<string, Checkpoint> = new Map();
+  private enabled: boolean;
+  private maxCheckpoints: number;
+
+  constructor(projectRoot: string, enabled: boolean = false, maxCheckpoints: number = 10) {
+    this.projectHash = this.generateProjectHash(projectRoot);
+    this.snapshotsDir = path.join(os.homedir(), '.xagent', 'snapshots', this.projectHash);
+    this.checkpointsDir = path.join(os.homedir(), '.xagent', 'cache', this.projectHash, 'checkpoints');
+    this.enabled = enabled;
+    this.maxCheckpoints = maxCheckpoints;
+  }
+
+  private generateProjectHash(projectRoot: string): string {
+    return crypto.createHash('md5').update(projectRoot).digest('hex').substring(0, 16);
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.enabled) {
+      return;
+    }
+
+    await fs.mkdir(this.snapshotsDir, { recursive: true });
+    await fs.mkdir(this.checkpointsDir, { recursive: true });
+
+    await this.initializeShadowGit();
+    await this.loadExistingCheckpoints();
+  }
+
+  private async initializeShadowGit(): Promise<void> {
+    const gitDir = path.join(this.snapshotsDir, '.git');
+
+    try {
+      await fs.access(gitDir);
+    } catch {
+      console.log('Initializing shadow Git repository for checkpoints...');
+      await execAsync('git init', { cwd: this.snapshotsDir });
+      await execAsync('git config user.email "xagent@checkpoint.local"', { cwd: this.snapshotsDir });
+      await execAsync('git config user.name "xAgent Checkpoint"', { cwd: this.snapshotsDir });
+    }
+  }
+
+  private async loadExistingCheckpoints(): Promise<void> {
+    try {
+      const files = await fs.readdir(this.checkpointsDir);
+      
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const filePath = path.join(this.checkpointsDir, file);
+          const content = await fs.readFile(filePath, 'utf-8');
+          const checkpoint: Checkpoint = JSON.parse(content);
+          this.checkpoints.set(checkpoint.id, checkpoint);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to load existing checkpoints:', error);
+    }
+  }
+
+  async createCheckpoint(description: string, conversation: ChatMessage[], toolCalls: ToolCall[]): Promise<Checkpoint> {
+    if (!this.enabled) {
+      throw new Error('Checkpointing is not enabled');
+    }
+
+    const checkpointId = `checkpoint_${Date.now()}`;
+    const timestamp = Date.now();
+
+    const checkpoint: Checkpoint = {
+      id: checkpointId,
+      timestamp,
+      description,
+      conversationSnapshot: conversation,
+      toolCalls
+    };
+
+    await this.createGitSnapshot(checkpointId);
+    await this.saveCheckpointMetadata(checkpoint);
+
+    this.checkpoints.set(checkpointId, checkpoint);
+    await this.cleanupOldCheckpoints();
+
+    console.log(`✅ Checkpoint created: ${checkpointId}`);
+    return checkpoint;
+  }
+
+  private async createGitSnapshot(checkpointId: string): Promise<void> {
+    try {
+      await execAsync('git add -A', { cwd: this.snapshotsDir });
+      await execAsync(`git commit -m "Checkpoint: ${checkpointId}"`, { cwd: this.snapshotsDir });
+      await execAsync(`git tag ${checkpointId}`, { cwd: this.snapshotsDir });
+    } catch (error) {
+      console.error('Failed to create Git snapshot:', error);
+    }
+  }
+
+  private async saveCheckpointMetadata(checkpoint: Checkpoint): Promise<void> {
+    const filePath = path.join(this.checkpointsDir, `${checkpoint.id}.json`);
+    await fs.writeFile(filePath, JSON.stringify(checkpoint, null, 2), 'utf-8');
+  }
+
+  async restoreCheckpoint(checkpointId: string): Promise<void> {
+    const checkpoint = this.checkpoints.get(checkpointId);
+    
+    if (!checkpoint) {
+      throw new Error(`Checkpoint not found: ${checkpointId}`);
+    }
+
+    console.log(`Restoring checkpoint: ${checkpointId}`);
+    console.log(`Description: ${checkpoint.description}`);
+    console.log(`Created: ${new Date(checkpoint.timestamp).toLocaleString()}`);
+
+    await this.restoreGitSnapshot(checkpointId);
+
+    console.log('✅ Checkpoint restored successfully');
+  }
+
+  private async restoreGitSnapshot(checkpointId: string): Promise<void> {
+    try {
+      await execAsync(`git checkout ${checkpointId}`, { cwd: this.snapshotsDir });
+    } catch (error) {
+      console.error('Failed to restore Git snapshot:', error);
+      throw new Error(`Failed to restore checkpoint: ${error}`);
+    }
+  }
+
+  listCheckpoints(): Checkpoint[] {
+    return Array.from(this.checkpoints.values())
+      .sort((a, b) => b.timestamp - a.timestamp);
+  }
+
+  getCheckpoint(checkpointId: string): Checkpoint | undefined {
+    return this.checkpoints.get(checkpointId);
+  }
+
+  async deleteCheckpoint(checkpointId: string): Promise<void> {
+    const checkpoint = this.checkpoints.get(checkpointId);
+    
+    if (!checkpoint) {
+      throw new Error(`Checkpoint not found: ${checkpointId}`);
+    }
+
+    try {
+      const metadataPath = path.join(this.checkpointsDir, `${checkpointId}.json`);
+      await fs.unlink(metadataPath);
+
+      try {
+        await execAsync(`git tag -d ${checkpointId}`, { cwd: this.snapshotsDir });
+      } catch (error) {
+        console.warn('Failed to delete Git tag:', error);
+      }
+
+      this.checkpoints.delete(checkpointId);
+      console.log(`✅ Checkpoint deleted: ${checkpointId}`);
+    } catch (error) {
+      console.error('Failed to delete checkpoint:', error);
+      throw error;
+    }
+  }
+
+  private async cleanupOldCheckpoints(): Promise<void> {
+    const checkpoints = this.listCheckpoints();
+    
+    if (checkpoints.length <= this.maxCheckpoints) {
+      return;
+    }
+
+    const toDelete = checkpoints.slice(this.maxCheckpoints);
+    
+    for (const checkpoint of toDelete) {
+      try {
+        await this.deleteCheckpoint(checkpoint.id);
+      } catch (error) {
+        console.error(`Failed to delete old checkpoint ${checkpoint.id}:`, error);
+      }
+    }
+  }
+
+  isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  setEnabled(enabled: boolean): void {
+    this.enabled = enabled;
+  }
+
+  async cleanup(): Promise<void> {
+    try {
+      await fs.rm(this.snapshotsDir, { recursive: true, force: true });
+      await fs.rm(this.checkpointsDir, { recursive: true, force: true });
+      this.checkpoints.clear();
+      console.log('✅ Checkpoint data cleaned up');
+    } catch (error) {
+      console.error('Failed to cleanup checkpoint data:', error);
+    }
+  }
+}
+
+let checkpointManagerInstance: CheckpointManager | null = null;
+
+export function getCheckpointManager(projectRoot?: string, enabled?: boolean, maxCheckpoints?: number): CheckpointManager {
+  if (!checkpointManagerInstance && projectRoot) {
+    checkpointManagerInstance = new CheckpointManager(projectRoot, enabled, maxCheckpoints);
+    checkpointManagerInstance.initialize();
+  }
+  return checkpointManagerInstance!;
+}