@git.zone/cli 1.16.6 → 1.16.8

package/ts/mod_format/classes.formatstats.ts

@@ -30,7 +30,7 @@ export interface IFormatStats {
 
 export class FormatStats {
   private stats: IFormatStats;
-  
+
   constructor() {
     this.stats = {
       totalExecutionTime: 0,
@@ -44,11 +44,11 @@ export class FormatStats {
         totalDeleted: 0,
         totalErrors: 0,
         cacheHits: 0,
-        cacheMisses: 0
-      }
+        cacheMisses: 0,
+      },
     };
   }
-  
+
   startModule(moduleName: string): void {
     this.stats.moduleStats.set(moduleName, {
       name: moduleName,
@@ -58,31 +58,35 @@ export class FormatStats {
       successes: 0,
       filesCreated: 0,
       filesModified: 0,
-      filesDeleted: 0
+      filesDeleted: 0,
     });
   }
-  
+
   moduleStartTime(moduleName: string): number {
     return Date.now();
   }
-  
+
   endModule(moduleName: string, startTime: number): void {
     const moduleStats = this.stats.moduleStats.get(moduleName);
     if (moduleStats) {
       moduleStats.executionTime = Date.now() - startTime;
     }
   }
-  
-  recordFileOperation(moduleName: string, operation: 'create' | 'modify' | 'delete', success: boolean = true): void {
+
+  recordFileOperation(
+    moduleName: string,
+    operation: 'create' | 'modify' | 'delete',
+    success: boolean = true,
+  ): void {
     const moduleStats = this.stats.moduleStats.get(moduleName);
     if (!moduleStats) return;
-    
+
     moduleStats.filesProcessed++;
-    
+
     if (success) {
       moduleStats.successes++;
       this.stats.overallStats.totalFiles++;
-      
+
       switch (operation) {
         case 'create':
           moduleStats.filesCreated++;
@@ -102,53 +106,66 @@ export class FormatStats {
       this.stats.overallStats.totalErrors++;
     }
   }
-  
+
   recordCacheHit(): void {
     this.stats.overallStats.cacheHits++;
   }
-  
+
   recordCacheMiss(): void {
     this.stats.overallStats.cacheMisses++;
   }
-  
+
   finish(): void {
     this.stats.endTime = Date.now();
     this.stats.totalExecutionTime = this.stats.endTime - this.stats.startTime;
   }
-  
+
   displayStats(): void {
     console.log('\n📊 Format Operation Statistics:');
     console.log('═'.repeat(50));
-    
+
     // Overall stats
     console.log('\nOverall Summary:');
-    console.log(`  Total Execution Time: ${this.formatDuration(this.stats.totalExecutionTime)}`);
+    console.log(
+      `  Total Execution Time: ${this.formatDuration(this.stats.totalExecutionTime)}`,
+    );
     console.log(`  Files Processed: ${this.stats.overallStats.totalFiles}`);
     console.log(`    • Created: ${this.stats.overallStats.totalCreated}`);
     console.log(`    • Modified: ${this.stats.overallStats.totalModified}`);
     console.log(`    • Deleted: ${this.stats.overallStats.totalDeleted}`);
     console.log(`  Errors: ${this.stats.overallStats.totalErrors}`);
-    
-    if (this.stats.overallStats.cacheHits > 0 || this.stats.overallStats.cacheMisses > 0) {
-      const cacheHitRate = this.stats.overallStats.cacheHits / 
-        (this.stats.overallStats.cacheHits + this.stats.overallStats.cacheMisses) * 100;
+
+    if (
+      this.stats.overallStats.cacheHits > 0 ||
+      this.stats.overallStats.cacheMisses > 0
+    ) {
+      const cacheHitRate =
+        (this.stats.overallStats.cacheHits /
+          (this.stats.overallStats.cacheHits +
+            this.stats.overallStats.cacheMisses)) *
+        100;
       console.log(`  Cache Hit Rate: ${cacheHitRate.toFixed(1)}%`);
       console.log(`    • Hits: ${this.stats.overallStats.cacheHits}`);
       console.log(`    • Misses: ${this.stats.overallStats.cacheMisses}`);
     }
-    
+
     // Module stats
     console.log('\nModule Breakdown:');
     console.log('─'.repeat(50));
-    
-    const sortedModules = Array.from(this.stats.moduleStats.values())
-      .sort((a, b) => b.filesProcessed - a.filesProcessed);
-    
+
+    const sortedModules = Array.from(this.stats.moduleStats.values()).sort(
+      (a, b) => b.filesProcessed - a.filesProcessed,
+    );
+
     for (const moduleStats of sortedModules) {
-      console.log(`\n${this.getModuleIcon(moduleStats.name)} ${moduleStats.name}:`);
-      console.log(`  Execution Time: ${this.formatDuration(moduleStats.executionTime)}`);
+      console.log(
+        `\n${this.getModuleIcon(moduleStats.name)} ${moduleStats.name}:`,
+      );
+      console.log(
+        `  Execution Time: ${this.formatDuration(moduleStats.executionTime)}`,
+      );
       console.log(`  Files Processed: ${moduleStats.filesProcessed}`);
-      
+
       if (moduleStats.filesCreated > 0) {
         console.log(`    • Created: ${moduleStats.filesCreated}`);
       }
@@ -158,27 +175,30 @@ export class FormatStats {
       if (moduleStats.filesDeleted > 0) {
         console.log(`    • Deleted: ${moduleStats.filesDeleted}`);
       }
-      
+
       if (moduleStats.errors > 0) {
         console.log(`  ❌ Errors: ${moduleStats.errors}`);
       }
     }
-    
+
     console.log('\n' + '═'.repeat(50));
   }
-  
+
   async saveReport(outputPath: string): Promise<void> {
     const report = {
       timestamp: new Date().toISOString(),
       executionTime: this.stats.totalExecutionTime,
       overallStats: this.stats.overallStats,
-      moduleStats: Array.from(this.stats.moduleStats.values())
+      moduleStats: Array.from(this.stats.moduleStats.values()),
     };
-    
-    await plugins.smartfile.memory.toFs(JSON.stringify(report, null, 2), outputPath);
+
+    await plugins.smartfile.memory.toFs(
+      JSON.stringify(report, null, 2),
+      outputPath,
+    );
     logger.log('info', `Statistics report saved to ${outputPath}`);
   }
-  
+
   private formatDuration(ms: number): string {
     if (ms < 1000) {
       return `${ms}ms`;
@@ -190,20 +210,20 @@ export class FormatStats {
       return `${minutes}m ${seconds}s`;
     }
   }
-  
+
   private getModuleIcon(module: string): string {
     const icons: Record<string, string> = {
-      'packagejson': '📦',
-      'license': '📝',
-      'tsconfig': '🔧',
-      'cleanup': '🚮',
-      'gitignore': '🔒',
-      'prettier': '✨',
-      'readme': '📖',
-      'templates': '📄',
-      'npmextra': '⚙️',
-      'copy': '📋'
+      packagejson: '📦',
+      license: '📝',
+      tsconfig: '🔧',
+      cleanup: '🚮',
+      gitignore: '🔒',
+      prettier: '✨',
+      readme: '📖',
+      templates: '📄',
+      npmextra: '⚙️',
+      copy: '📋',
     };
     return icons[module] || '📁';
   }
-}
+}

package/ts/mod_format/classes.rollbackmanager.ts

@@ -5,214 +5,314 @@ import type { IFormatOperation } from './interfaces.format.js';
 export class RollbackManager {
   private backupDir: string;
   private manifestPath: string;
-  
+
   constructor() {
     this.backupDir = plugins.path.join(paths.cwd, '.nogit', 'gitzone-backups');
     this.manifestPath = plugins.path.join(this.backupDir, 'manifest.json');
   }
-  
+
   async createOperation(): Promise<IFormatOperation> {
     await this.ensureBackupDir();
-    
+
     const operation: IFormatOperation = {
       id: this.generateOperationId(),
       timestamp: Date.now(),
       files: [],
-      status: 'pending'
+      status: 'pending',
     };
-    
+
     await this.updateManifest(operation);
     return operation;
   }
-  
+
   async backupFile(filepath: string, operationId: string): Promise<void> {
     const operation = await this.getOperation(operationId);
     if (!operation) {
       throw new Error(`Operation ${operationId} not found`);
     }
-    
-    const absolutePath = plugins.path.isAbsolute(filepath) 
-      ? filepath 
+
+    const absolutePath = plugins.path.isAbsolute(filepath)
+      ? filepath
       : plugins.path.join(paths.cwd, filepath);
-    
+
     // Check if file exists
     const exists = await plugins.smartfile.fs.fileExists(absolutePath);
     if (!exists) {
       // File doesn't exist yet (will be created), so we skip backup
       return;
     }
-    
+
     // Read file content and metadata
-    const content = await plugins.smartfile.fs.toStringSync(absolutePath);
+    const content = plugins.smartfile.fs.toStringSync(absolutePath);
     const stats = await plugins.smartfile.fs.stat(absolutePath);
     const checksum = this.calculateChecksum(content);
-    
+
     // Create backup
     const backupPath = this.getBackupPath(operationId, filepath);
     await plugins.smartfile.fs.ensureDir(plugins.path.dirname(backupPath));
     await plugins.smartfile.memory.toFs(content, backupPath);
-    
+
     // Update operation
     operation.files.push({
       path: filepath,
       originalContent: content,
       checksum,
-      permissions: stats.mode.toString(8)
+      permissions: stats.mode.toString(8),
     });
-    
+
     await this.updateManifest(operation);
   }
-  
+
   async rollback(operationId: string): Promise<void> {
     const operation = await this.getOperation(operationId);
     if (!operation) {
-      throw new Error(`Operation ${operationId} not found`);
+      // Operation doesn't exist, might have already been rolled back or never created
+      console.warn(`Operation ${operationId} not found for rollback, skipping`);
+      return;
     }
-    
+
     if (operation.status === 'rolled-back') {
       throw new Error(`Operation ${operationId} has already been rolled back`);
     }
-    
+
     // Restore files in reverse order
     for (let i = operation.files.length - 1; i >= 0; i--) {
       const file = operation.files[i];
-      const absolutePath = plugins.path.isAbsolute(file.path) 
-        ? file.path 
+      const absolutePath = plugins.path.isAbsolute(file.path)
+        ? file.path
         : plugins.path.join(paths.cwd, file.path);
-      
+
       // Verify backup integrity
       const backupPath = this.getBackupPath(operationId, file.path);
-      const backupContent = await plugins.smartfile.fs.toStringSync(backupPath);
+      const backupContent = plugins.smartfile.fs.toStringSync(backupPath);
       const backupChecksum = this.calculateChecksum(backupContent);
-      
+
       if (backupChecksum !== file.checksum) {
         throw new Error(`Backup integrity check failed for ${file.path}`);
       }
-      
+
       // Restore file
       await plugins.smartfile.memory.toFs(file.originalContent, absolutePath);
-      
+
       // Restore permissions
       const mode = parseInt(file.permissions, 8);
       // Note: Permissions restoration may not work on all platforms
     }
-    
+
     // Update operation status
     operation.status = 'rolled-back';
     await this.updateManifest(operation);
   }
-  
+
   async markComplete(operationId: string): Promise<void> {
     const operation = await this.getOperation(operationId);
     if (!operation) {
       throw new Error(`Operation ${operationId} not found`);
     }
-    
+
     operation.status = 'completed';
     await this.updateManifest(operation);
   }
-  
+
   async cleanOldBackups(retentionDays: number): Promise<void> {
     const manifest = await this.getManifest();
-    const cutoffTime = Date.now() - (retentionDays * 24 * 60 * 60 * 1000);
-    
-    const operationsToDelete = manifest.operations.filter(op => 
-      op.timestamp < cutoffTime && op.status === 'completed'
+    const cutoffTime = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+
+    const operationsToDelete = manifest.operations.filter(
+      (op) => op.timestamp < cutoffTime && op.status === 'completed',
     );
-    
+
     for (const operation of operationsToDelete) {
       // Remove backup files
-      const operationDir = plugins.path.join(this.backupDir, 'operations', operation.id);
+      const operationDir = plugins.path.join(
+        this.backupDir,
+        'operations',
+        operation.id,
+      );
       await plugins.smartfile.fs.remove(operationDir);
-      
+
       // Remove from manifest
-      manifest.operations = manifest.operations.filter(op => op.id !== operation.id);
+      manifest.operations = manifest.operations.filter(
+        (op) => op.id !== operation.id,
+      );
     }
-    
+
     await this.saveManifest(manifest);
   }
-  
+
   async verifyBackup(operationId: string): Promise<boolean> {
     const operation = await this.getOperation(operationId);
     if (!operation) {
       return false;
     }
-    
+
     for (const file of operation.files) {
       const backupPath = this.getBackupPath(operationId, file.path);
       const exists = await plugins.smartfile.fs.fileExists(backupPath);
-      
+
       if (!exists) {
         return false;
       }
-      
-      const content = await plugins.smartfile.fs.toStringSync(backupPath);
+
+      const content = plugins.smartfile.fs.toStringSync(backupPath);
       const checksum = this.calculateChecksum(content);
-      
+
       if (checksum !== file.checksum) {
         return false;
       }
     }
-    
+
     return true;
   }
-  
+
   async listBackups(): Promise<IFormatOperation[]> {
     const manifest = await this.getManifest();
     return manifest.operations;
   }
-  
+
   private async ensureBackupDir(): Promise<void> {
     await plugins.smartfile.fs.ensureDir(this.backupDir);
-    await plugins.smartfile.fs.ensureDir(plugins.path.join(this.backupDir, 'operations'));
+    await plugins.smartfile.fs.ensureDir(
+      plugins.path.join(this.backupDir, 'operations'),
+    );
   }
-  
+
   private generateOperationId(): string {
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const random = Math.random().toString(36).substring(2, 8);
     return `${timestamp}-${random}`;
   }
-  
+
   private getBackupPath(operationId: string, filepath: string): string {
     const filename = plugins.path.basename(filepath);
     const dir = plugins.path.dirname(filepath);
     const safeDir = dir.replace(/[/\\]/g, '__');
-    return plugins.path.join(this.backupDir, 'operations', operationId, 'files', safeDir, `${filename}.backup`);
+    return plugins.path.join(
+      this.backupDir,
+      'operations',
+      operationId,
+      'files',
+      safeDir,
+      `${filename}.backup`,
+    );
   }
-  
+
   private calculateChecksum(content: string | Buffer): string {
     return plugins.crypto.createHash('sha256').update(content).digest('hex');
   }
-  
+
   private async getManifest(): Promise<{ operations: IFormatOperation[] }> {
+    const defaultManifest = { operations: [] };
+
     const exists = await plugins.smartfile.fs.fileExists(this.manifestPath);
     if (!exists) {
-      return { operations: [] };
+      return defaultManifest;
+    }
+
+    try {
+      const content = plugins.smartfile.fs.toStringSync(this.manifestPath);
+      const manifest = JSON.parse(content);
+
+      // Validate the manifest structure
+      if (this.isValidManifest(manifest)) {
+        return manifest;
+      } else {
+        console.warn(
+          'Invalid rollback manifest structure, returning default manifest',
+        );
+        return defaultManifest;
+      }
+    } catch (error) {
+      console.warn(
+        `Failed to read rollback manifest: ${error.message}, returning default manifest`,
+      );
+      // Try to delete the corrupted file
+      try {
+        await plugins.smartfile.fs.remove(this.manifestPath);
+      } catch (removeError) {
+        // Ignore removal errors
+      }
+      return defaultManifest;
     }
-    
-    const content = await plugins.smartfile.fs.toStringSync(this.manifestPath);
-    return JSON.parse(content);
   }
-  
-  private async saveManifest(manifest: { operations: IFormatOperation[] }): Promise<void> {
-    await plugins.smartfile.memory.toFs(JSON.stringify(manifest, null, 2), this.manifestPath);
+
+  private async saveManifest(manifest: {
+    operations: IFormatOperation[];
+  }): Promise<void> {
+    // Validate before saving
+    if (!this.isValidManifest(manifest)) {
+      throw new Error('Invalid rollback manifest structure, cannot save');
+    }
+
+    // Ensure directory exists
+    await this.ensureBackupDir();
+
+    // Write directly with proper JSON stringification
+    const jsonContent = JSON.stringify(manifest, null, 2);
+    await plugins.smartfile.memory.toFs(jsonContent, this.manifestPath);
   }
-  
-  private async getOperation(operationId: string): Promise<IFormatOperation | null> {
+
+  private async getOperation(
+    operationId: string,
+  ): Promise<IFormatOperation | null> {
     const manifest = await this.getManifest();
-    return manifest.operations.find(op => op.id === operationId) || null;
+    return manifest.operations.find((op) => op.id === operationId) || null;
   }
-  
+
   private async updateManifest(operation: IFormatOperation): Promise<void> {
     const manifest = await this.getManifest();
-    const existingIndex = manifest.operations.findIndex(op => op.id === operation.id);
-    
+    const existingIndex = manifest.operations.findIndex(
+      (op) => op.id === operation.id,
+    );
+
     if (existingIndex !== -1) {
       manifest.operations[existingIndex] = operation;
     } else {
       manifest.operations.push(operation);
     }
-    
+
     await this.saveManifest(manifest);
   }
-}
+
+  private isValidManifest(
+    manifest: any,
+  ): manifest is { operations: IFormatOperation[] } {
+    // Check if manifest has the required structure
+    if (!manifest || typeof manifest !== 'object') {
+      return false;
+    }
+
+    // Check required fields
+    if (!Array.isArray(manifest.operations)) {
+      return false;
+    }
+
+    // Check each operation entry
+    for (const operation of manifest.operations) {
+      if (
+        !operation ||
+        typeof operation !== 'object' ||
+        typeof operation.id !== 'string' ||
+        typeof operation.timestamp !== 'number' ||
+        typeof operation.status !== 'string' ||
+        !Array.isArray(operation.files)
+      ) {
+        return false;
+      }
+
+      // Check each file in the operation
+      for (const file of operation.files) {
+        if (
+          !file ||
+          typeof file !== 'object' ||
+          typeof file.path !== 'string' ||
+          typeof file.checksum !== 'string'
+        ) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+}

package/ts/mod_format/format.cleanup.ts

@@ -4,14 +4,21 @@ import * as paths from '../paths.js';
 import { logger } from '../gitzone.logging.js';
 import { Project } from '../classes.project.js';
 
-const filesToDelete = ['defaults.yml', 'yarn.lock', 'package-lock.json', 'tslint.json'];
+const filesToDelete = [
+  'defaults.yml',
+  'yarn.lock',
+  'package-lock.json',
+  'tslint.json',
+];
 
 export const run = async (projectArg: Project) => {
   for (const relativeFilePath of filesToDelete) {
     const fileExists = plugins.smartfile.fs.fileExistsSync(relativeFilePath);
     if (fileExists) {
       logger.log('info', `Found ${relativeFilePath}! Removing it!`);
-      plugins.smartfile.fs.removeSync(plugins.path.join(paths.cwd, relativeFilePath));
+      plugins.smartfile.fs.removeSync(
+        plugins.path.join(paths.cwd, relativeFilePath),
+      );
     } else {
       logger.log('info', `Project is free of ${relativeFilePath}`);
     }