@gguf/coder 0.3.0 → 0.3.1

package/source/services/checkpoint-manager.ts

@@ -0,0 +1,466 @@
+import {existsSync} from 'fs';
+import * as path from 'path';
+import {TRUNCATION_DESCRIPTION_LENGTH} from '@/constants';
+import type {
+	CheckpointConversation,
+	CheckpointData,
+	CheckpointListItem,
+	CheckpointMetadata,
+	CheckpointRestoreOptions,
+	CheckpointValidationResult,
+} from '@/types/checkpoint';
+import type {Message} from '@/types/core';
+import {validateCheckpointName} from '@/utils/checkpoint-utils';
+import {logWarning} from '@/utils/message-queue';
+import * as fs from 'fs/promises';
+import {FileSnapshotService} from './file-snapshot';
+
+/**
+ * Service for managing conversation checkpoints.
+ * Checkpoints are stored in .coder/checkpoints/ within the workspace root.
+ */
+export class CheckpointManager {
+	private readonly checkpointsDir: string;
+	private readonly fileSnapshotService: FileSnapshotService;
+
+	constructor(workspaceRoot: string = process.cwd()) {
+		// nosemgrep
+		this.checkpointsDir = path.join(workspaceRoot, '.coder', 'checkpoints'); // nosemgrep
+		this.fileSnapshotService = new FileSnapshotService(workspaceRoot);
+	}
+
+	/**
+	 * Initialize the checkpoints directory
+	 */
+	private async ensureCheckpointsDir(): Promise<void> {
+		if (!existsSync(this.checkpointsDir)) {
+			await fs.mkdir(this.checkpointsDir, {recursive: true});
+		}
+	}
+
+	/**
+	 * Generate a checkpoint name based on timestamp
+	 */
+	private generateCheckpointName(): string {
+		const now = new Date();
+		const timestamp = now
+			.toISOString()
+			.replace(/[:.]/g, '-')
+			.replace('T', '-')
+			.split('.')[0];
+		return `checkpoint-${timestamp}`;
+	}
+
+	/**
+	 * Get the directory path for a specific checkpoint
+	 */
+	// nosemgrep
+	private getCheckpointDir(name: string): string {
+		return path.join(this.checkpointsDir, name); // nosemgrep
+	}
+
+	/**
+	 * Validate checkpoint name using shared utility
+	 */
+	private validateName(name: string): void {
+		const result = validateCheckpointName(name);
+		if (!result.valid) {
+			throw new Error(result.error || 'Invalid checkpoint name');
+		}
+	}
+
+	/**
+	 * Generate metadata description from messages
+	 */
+	private generateDescription(messages: Message[]): string {
+		const userMessages = messages.filter(m => m.role === 'user');
+		if (userMessages.length === 0) {
+			return 'Empty conversation';
+		}
+
+		const firstMessage = userMessages[0].content;
+		// Take first characters and add ellipsis if longer
+		return firstMessage.length > TRUNCATION_DESCRIPTION_LENGTH
+			? `${firstMessage.substring(0, TRUNCATION_DESCRIPTION_LENGTH)}...`
+			: firstMessage;
+	}
+
+	/**
+	 * Save a checkpoint
+	 */
+	async saveCheckpoint(
+		name: string | undefined,
+		messages: Message[],
+		provider: string,
+		model: string,
+		modifiedFiles?: string[],
+	): Promise<CheckpointMetadata> {
+		await this.ensureCheckpointsDir();
+
+		// Generate name if not provided
+		const checkpointName = name || this.generateCheckpointName();
+		this.validateName(checkpointName);
+
+		const checkpointDir = this.getCheckpointDir(checkpointName);
+
+		// Check if checkpoint already exists
+		if (existsSync(checkpointDir)) {
+			throw new Error(`Checkpoint '${checkpointName}' already exists`);
+		}
+
+		// Get modified files if not provided
+		const filesToSnapshot =
+			modifiedFiles || this.fileSnapshotService.getModifiedFiles();
+
+		// Capture file snapshots
+		const fileSnapshots =
+			await this.fileSnapshotService.captureFiles(filesToSnapshot);
+
+		// Create metadata
+		const metadata: CheckpointMetadata = {
+			name: checkpointName,
+			timestamp: new Date().toISOString(),
+			messageCount: messages.length,
+			filesChanged: Array.from(fileSnapshots.keys()),
+			provider: {name: provider, model},
+			description: this.generateDescription(messages),
+		};
+
+		// Create conversation data
+		const conversation: CheckpointConversation = {
+			messages: messages.map(msg => ({...msg})), // Deep copy
+		};
+
+		// Create checkpoint directory and files
+		await fs.mkdir(checkpointDir, {recursive: true});
+
+		// nosemgrep
+		// Save metadata
+		await fs.writeFile(
+			path.join(checkpointDir, 'metadata.json'), // nosemgrep
+			JSON.stringify(metadata, null, 2),
+			'utf-8',
+		);
+
+		// nosemgrep
+		// Save conversation
+		await fs.writeFile(
+			path.join(checkpointDir, 'conversation.json'), // nosemgrep
+			JSON.stringify(conversation, null, 2),
+			'utf-8',
+		);
+
+		// nosemgrep
+		// Save file snapshots
+		if (fileSnapshots.size > 0) {
+			const filesDir = path.join(checkpointDir, 'files'); // nosemgrep
+			await fs.mkdir(filesDir, {recursive: true});
+
+			for (const [relativePath, content] of fileSnapshots) {
+				const filePath = path.join(filesDir, relativePath); // nosemgrep
+				const fileDir = path.dirname(filePath);
+				await fs.mkdir(fileDir, {recursive: true});
+				await fs.writeFile(filePath, content, 'utf-8');
+			}
+		}
+
+		return metadata;
+	}
+
+	/**
+	 * Load a checkpoint
+	 */
+	async loadCheckpoint(
+		name: string,
+		options: CheckpointRestoreOptions = {},
+	): Promise<CheckpointData> {
+		const checkpointDir = this.getCheckpointDir(name);
+
+		if (!existsSync(checkpointDir)) {
+			throw new Error(`Checkpoint '${name}' does not exist`);
+		}
+
+		// Validate checkpoint if requested
+		if (options.validateIntegrity) {
+			const validation = await this.validateCheckpoint(name);
+			if (!validation.valid) {
+				throw new Error(
+					`Checkpoint validation failed: ${validation.errors.join(', ')}`,
+				);
+			}
+		}
+
+		// nosemgrep
+		// Load metadata
+		const metadataPath = path.join(checkpointDir, 'metadata.json'); // nosemgrep
+		const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+		const metadata = JSON.parse(metadataContent) as CheckpointMetadata;
+
+		// nosemgrep
+		// Load conversation
+		const conversationPath = path.join(checkpointDir, 'conversation.json'); // nosemgrep
+		const conversationContent = await fs.readFile(conversationPath, 'utf-8');
+		const conversation = JSON.parse(
+			conversationContent,
+		) as CheckpointConversation;
+
+		// nosemgrep
+		// Load file snapshots
+		const fileSnapshots = new Map<string, string>();
+		const filesDir = path.join(checkpointDir, 'files'); // nosemgrep
+
+		if (existsSync(filesDir)) {
+			for (const relativePath of metadata.filesChanged) {
+				try {
+					const filePath = path.join(filesDir, relativePath); // nosemgrep
+					const content = await fs.readFile(filePath, 'utf-8');
+					fileSnapshots.set(relativePath, content);
+				} catch (error) {
+					logWarning('Could not load file snapshot', true, {
+						context: {
+							relativePath,
+							error: error instanceof Error ? error.message : 'Unknown error',
+						},
+					});
+				}
+			}
+		}
+
+		return {
+			metadata,
+			conversation,
+			fileSnapshots,
+		};
+	}
+
+	/**
+	 * List all available checkpoints
+	 */
+	async listCheckpoints(): Promise<CheckpointListItem[]> {
+		await this.ensureCheckpointsDir();
+
+		try {
+			const entries = await fs.readdir(this.checkpointsDir);
+			const checkpoints: CheckpointListItem[] = [];
+
+			for (const entry of entries) {
+				try {
+					const checkpointDir = path.join(this.checkpointsDir, entry); // nosemgrep
+					const stat = await fs.stat(checkpointDir);
+
+					if (stat.isDirectory()) {
+						const metadataPath = path.join(checkpointDir, 'metadata.json'); // nosemgrep
+						if (existsSync(metadataPath)) {
+							const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+							const metadata = JSON.parse(
+								metadataContent,
+							) as CheckpointMetadata;
+
+							// Calculate directory size
+							const sizeBytes =
+								await this.calculateDirectorySize(checkpointDir);
+
+							checkpoints.push({
+								name: entry,
+								metadata,
+								sizeBytes,
+							});
+						}
+					}
+				} catch (error) {
+					logWarning('Could not read checkpoint', true, {
+						context: {
+							checkpointName: entry,
+							error: error instanceof Error ? error.message : 'Unknown error',
+						},
+					});
+				}
+			}
+
+			// Sort by timestamp (newest first)
+			checkpoints.sort(
+				(a, b) =>
+					new Date(b.metadata.timestamp).getTime() -
+					new Date(a.metadata.timestamp).getTime(),
+			);
+
+			return checkpoints;
+		} catch (error) {
+			throw new Error(
+				`Failed to list checkpoints: ${
+					error instanceof Error ? error.message : 'Unknown error'
+				}`,
+			);
+		}
+	}
+
+	/**
+	 * Delete a checkpoint
+	 */
+	async deleteCheckpoint(name: string): Promise<void> {
+		const checkpointDir = this.getCheckpointDir(name);
+
+		if (!existsSync(checkpointDir)) {
+			throw new Error(`Checkpoint '${name}' does not exist`);
+		}
+
+		try {
+			await fs.rm(checkpointDir, {recursive: true, force: true});
+		} catch (error) {
+			throw new Error(
+				`Failed to delete checkpoint '${name}': ${
+					error instanceof Error ? error.message : 'Unknown error'
+				}`,
+			);
+		}
+	}
+
+	/**
+	 * Validate checkpoint integrity
+	 */
+	async validateCheckpoint(name: string): Promise<CheckpointValidationResult> {
+		const checkpointDir = this.getCheckpointDir(name);
+		const errors: string[] = [];
+		const warnings: string[] = [];
+
+		// Check if checkpoint directory exists
+		if (!existsSync(checkpointDir)) {
+			errors.push('Checkpoint directory does not exist');
+			return {valid: false, errors, warnings};
+		}
+
+		// Check metadata file
+		const metadataPath = path.join(checkpointDir, 'metadata.json'); // nosemgrep
+		if (!existsSync(metadataPath)) {
+			errors.push('Missing metadata.json file');
+		} else {
+			try {
+				const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+				const metadata = JSON.parse(metadataContent) as CheckpointMetadata;
+
+				// Validate metadata structure
+				if (
+					!metadata.name ||
+					!metadata.timestamp ||
+					typeof metadata.messageCount !== 'number'
+				) {
+					errors.push('Invalid metadata structure');
+				}
+			} catch (error) {
+				errors.push(
+					`Invalid metadata.json: ${
+						error instanceof Error ? error.message : 'Unknown error'
+					}`,
+				);
+			}
+		}
+
+		// Check conversation file
+		const conversationPath = path.join(checkpointDir, 'conversation.json'); // nosemgrep
+		if (!existsSync(conversationPath)) {
+			errors.push('Missing conversation.json file');
+		} else {
+			try {
+				const conversationContent = await fs.readFile(
+					conversationPath,
+					'utf-8',
+				);
+				const conversation = JSON.parse(
+					conversationContent,
+				) as CheckpointConversation;
+
+				// Validate conversation structure
+				if (!Array.isArray(conversation.messages)) {
+					errors.push('Invalid conversation structure');
+				}
+			} catch (error) {
+				errors.push(
+					`Invalid conversation.json: ${
+						error instanceof Error ? error.message : 'Unknown error'
+					}`,
+				);
+			}
+		}
+
+		return {
+			valid: errors.length === 0,
+			errors,
+			warnings,
+		};
+	}
+
+	/**
+	 * Restore files from a checkpoint
+	 */
+	async restoreFiles(checkpointData: CheckpointData): Promise<void> {
+		if (checkpointData.fileSnapshots.size === 0) {
+			return; // No files to restore
+		}
+
+		// Validate restore paths
+		const validation = await this.fileSnapshotService.validateRestorePath(
+			checkpointData.fileSnapshots,
+		);
+		if (!validation.valid) {
+			throw new Error(`Cannot restore files: ${validation.errors.join(', ')}`);
+		}
+
+		// Restore files
+		await this.fileSnapshotService.restoreFiles(checkpointData.fileSnapshots);
+	}
+
+	/**
+	 * Calculate the total size of a directory
+	 */
+	private async calculateDirectorySize(dirPath: string): Promise<number> {
+		let totalSize = 0;
+
+		try {
+			const entries = await fs.readdir(dirPath, {withFileTypes: true});
+
+			for (const entry of entries) {
+				const fullPath = path.join(dirPath, entry.name); // nosemgrep
+
+				if (entry.isDirectory()) {
+					totalSize += await this.calculateDirectorySize(fullPath);
+				} else {
+					const stat = await fs.stat(fullPath);
+					totalSize += stat.size;
+				}
+			}
+		} catch (error) {
+			// If we can't read the directory, just return 0
+			logWarning('Could not calculate directory size', true, {
+				context: {
+					dirPath,
+					error: error instanceof Error ? error.message : 'Unknown error',
+				},
+			});
+		}
+
+		return totalSize;
+	}
+
+	/**
+	 * Check if a checkpoint exists
+	 */
+	checkpointExists(name: string): boolean {
+		const checkpointDir = this.getCheckpointDir(name);
+		return existsSync(checkpointDir);
+	}
+
+	/**
+	 * Get checkpoint metadata without loading full data
+	 */
+	async getCheckpointMetadata(name: string): Promise<CheckpointMetadata> {
+		const checkpointDir = this.getCheckpointDir(name);
+
+		if (!existsSync(checkpointDir)) {
+			throw new Error(`Checkpoint '${name}' does not exist`);
+		}
+
+		const metadataPath = path.join(checkpointDir, 'metadata.json'); // nosemgrep
+		const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+		return JSON.parse(metadataContent) as CheckpointMetadata;
+	}
+}