@git.zone/cli 1.16.6 → 1.16.8

package/ts/mod_format/formatters/prettier.formatter.ts

@@ -7,21 +7,16 @@ export class PrettierFormatter extends BaseFormatter {
   get name(): string {
     return 'prettier';
   }
-  
+
   async analyze(): Promise<IPlannedChange[]> {
     const changes: IPlannedChange[] = [];
-    
+
     // Define directories to format (TypeScript directories by default)
-    const includeDirs = [
-      'ts',
-      'ts_*',
-      'test',
-      'tests'
-    ];
-    
+    const includeDirs = ['ts', 'ts_*', 'test', 'tests'];
+
     // File extensions to format
     const extensions = '{ts,tsx,js,jsx,json,md,css,scss,html,xml,yaml,yml}';
-    
+
     // Also format root-level config files
     const rootConfigFiles = [
       'package.json',
@@ -36,33 +31,36 @@ export class PrettierFormatter extends BaseFormatter {
       'CHANGELOG.md',
       'license',
       'LICENSE',
-      '*.md'
+      '*.md',
     ];
-    
+
     // Collect all files to format
     const allFiles: string[] = [];
-    
+
     // Add files from TypeScript directories
     for (const dir of includeDirs) {
       const globPattern = `${dir}/**/*.${extensions}`;
-      const dirFiles = await plugins.smartfile.fs.listFileTree('.', globPattern);
+      const dirFiles = await plugins.smartfile.fs.listFileTree(
+        '.',
+        globPattern,
+      );
       allFiles.push(...dirFiles);
     }
-    
+
     // Add root config files
     for (const pattern of rootConfigFiles) {
       const rootFiles = await plugins.smartfile.fs.listFileTree('.', pattern);
       // Only include files at root level (no slashes in path)
-      const rootLevelFiles = rootFiles.filter(f => !f.includes('/'));
+      const rootLevelFiles = rootFiles.filter((f) => !f.includes('/'));
       allFiles.push(...rootLevelFiles);
     }
-    
+
     // Remove duplicates
     const uniqueFiles = [...new Set(allFiles)];
-    
+
     // Get all files that match the pattern
     const files = uniqueFiles;
-    
+
     // Ensure we only process actual files (not directories)
     const validFiles: string[] = [];
     for (const file of files) {
@@ -76,48 +74,52 @@ export class PrettierFormatter extends BaseFormatter {
         logVerbose(`Skipping ${file} - cannot access: ${error.message}`);
       }
     }
-    
+
     // Check which files need formatting
     for (const file of validFiles) {
       // Skip files that haven't changed
-      if (!await this.shouldProcessFile(file)) {
+      if (!(await this.shouldProcessFile(file))) {
         logVerbose(`Skipping ${file} - no changes detected`);
         continue;
       }
-      
+
       changes.push({
         type: 'modify',
         path: file,
         module: this.name,
-        description: 'Format with Prettier'
+        description: 'Format with Prettier',
       });
     }
-    
+
     logger.log('info', `Found ${changes.length} files to format with Prettier`);
     return changes;
   }
-  
+
   async execute(changes: IPlannedChange[]): Promise<void> {
     const startTime = this.stats.moduleStartTime(this.name);
     this.stats.startModule(this.name);
-    
+
     try {
       await this.preExecute();
-      
+
       // Batch process files
       const batchSize = 10; // Process 10 files at a time
       const batches: IPlannedChange[][] = [];
-      
+
       for (let i = 0; i < changes.length; i += batchSize) {
         batches.push(changes.slice(i, i + batchSize));
       }
-      
-      logVerbose(`Processing ${changes.length} files in ${batches.length} batches`);
-      
+
+      logVerbose(
+        `Processing ${changes.length} files in ${batches.length} batches`,
+      );
+
       for (let i = 0; i < batches.length; i++) {
         const batch = batches[i];
-        logVerbose(`Processing batch ${i + 1}/${batches.length} (${batch.length} files)`);
-        
+        logVerbose(
+          `Processing batch ${i + 1}/${batches.length} (${batch.length} files)`,
+        );
+
         // Process batch in parallel
         const promises = batch.map(async (change) => {
           try {
@@ -125,44 +127,45 @@ export class PrettierFormatter extends BaseFormatter {
             this.stats.recordFileOperation(this.name, change.type, true);
           } catch (error) {
             this.stats.recordFileOperation(this.name, change.type, false);
-            logger.log('error', `Failed to format ${change.path}: ${error.message}`);
+            logger.log(
+              'error',
+              `Failed to format ${change.path}: ${error.message}`,
+            );
             // Don't throw - continue with other files
           }
         });
-        
+
         await Promise.all(promises);
       }
-      
+
       await this.postExecute();
     } catch (error) {
-      await this.context.rollbackOperation();
+      // Rollback removed - no longer tracking operations
       throw error;
     } finally {
       this.stats.endModule(this.name, startTime);
     }
   }
-  
+
   async applyChange(change: IPlannedChange): Promise<void> {
     if (change.type !== 'modify') return;
-    
+
     try {
       // Read current content
       const content = plugins.smartfile.fs.toStringSync(change.path);
-      
+
       // Format with prettier
       const prettier = await import('prettier');
       const formatted = await prettier.format(content, {
         filepath: change.path,
-        ...(await this.getPrettierConfig())
+        ...(await this.getPrettierConfig()),
       });
-      
+
       // Only write if content actually changed
       if (formatted !== content) {
         await this.modifyFile(change.path, formatted);
         logVerbose(`Formatted ${change.path}`);
       } else {
-        // Still update cache even if content didn't change
-        await this.cache.updateFileCache(change.path);
         logVerbose(`No formatting changes for ${change.path}`);
       }
     } catch (error) {
@@ -170,7 +173,7 @@ export class PrettierFormatter extends BaseFormatter {
       throw error;
     }
   }
-  
+
   private async getPrettierConfig(): Promise<any> {
     // Try to load prettier config from the project
     const prettierConfig = new plugins.npmextra.Npmextra();
@@ -181,7 +184,7 @@ export class PrettierFormatter extends BaseFormatter {
       printWidth: 80,
       tabWidth: 2,
       semi: true,
-      arrowParens: 'always'
+      arrowParens: 'always',
     });
   }
-}
+}

package/ts/mod_format/formatters/readme.formatter.ts

@@ -6,17 +6,19 @@ export class ReadmeFormatter extends BaseFormatter {
   get name(): string {
     return 'readme';
   }
-  
+
   async analyze(): Promise<IPlannedChange[]> {
-    return [{
-      type: 'modify',
-      path: 'readme.md',
-      module: this.name,
-      description: 'Ensure readme files exist'
-    }];
+    return [
+      {
+        type: 'modify',
+        path: 'readme.md',
+        module: this.name,
+        description: 'Ensure readme files exist',
+      },
+    ];
   }
-  
+
   async applyChange(change: IPlannedChange): Promise<void> {
     await formatReadme.run();
   }
-}
+}

package/ts/mod_format/formatters/templates.formatter.ts

@@ -5,4 +5,4 @@ export class TemplatesFormatter extends LegacyFormatter {
   constructor(context: any, project: any) {
     super(context, project, 'templates', formatTemplates);
   }
-}
+}

package/ts/mod_format/formatters/tsconfig.formatter.ts

@@ -5,4 +5,4 @@ export class TsconfigFormatter extends LegacyFormatter {
   constructor(context: any, project: any) {
     super(context, project, 'tsconfig', formatTsconfig);
   }
-}
+}

package/ts/mod_format/index.ts

@@ -16,27 +16,29 @@ import { PrettierFormatter } from './formatters/prettier.formatter.js';
 import { ReadmeFormatter } from './formatters/readme.formatter.js';
 import { CopyFormatter } from './formatters/copy.formatter.js';
 
-export let run = async (options: {
-  dryRun?: boolean;
-  yes?: boolean;
-  planOnly?: boolean;
-  savePlan?: string;
-  fromPlan?: string;
-  detailed?: boolean;
-  interactive?: boolean;
-  parallel?: boolean;
-  verbose?: boolean;
-} = {}): Promise<any> => {
+export let run = async (
+  options: {
+    dryRun?: boolean;
+    yes?: boolean;
+    planOnly?: boolean;
+    savePlan?: string;
+    fromPlan?: string;
+    detailed?: boolean;
+    interactive?: boolean;
+    parallel?: boolean;
+    verbose?: boolean;
+  } = {},
+): Promise<any> => {
   // Set verbose mode if requested
   if (options.verbose) {
     setVerboseMode(true);
   }
-  
+
   const project = await Project.fromCwd();
   const context = new FormatContext();
-  await context.initializeCache();  // Initialize the cache system
+  // Cache system removed - no longer needed
   const planner = new FormatPlanner();
-  
+
   // Get configuration from npmextra
   const npmextraConfig = new plugins.npmextra.Npmextra();
   const formatConfig = npmextraConfig.dataFor<any>('gitzone.format', {
@@ -49,30 +51,27 @@ export let run = async (options: {
       autoRollbackOnError: true,
       backupRetentionDays: 7,
       maxBackupSize: '100MB',
-      excludePatterns: ['node_modules/**', '.git/**']
+      excludePatterns: ['node_modules/**', '.git/**'],
     },
     modules: {
       skip: [],
       only: [],
-      order: []
+      order: [],
     },
     parallel: true,
     cache: {
       enabled: true,
-      clean: true  // Clean invalid entries from cache
-    }
+      clean: true, // Clean invalid entries from cache
+    },
   });
-  
-  // Clean cache if configured
-  if (formatConfig.cache.clean) {
-    await context.getChangeCache().clean();
-  }
-  
+
+  // Cache cleaning removed - no longer using cache system
+
   // Override config with command options
   const interactive = options.interactive ?? formatConfig.interactive;
   const autoApprove = options.yes ?? formatConfig.autoApprove;
   const parallel = options.parallel ?? formatConfig.parallel;
-  
+
   try {
     // Initialize formatters
     const formatters = [
@@ -87,9 +86,9 @@ export let run = async (options: {
       new ReadmeFormatter(context, project),
       new CopyFormatter(context, project),
     ];
-    
+
     // Filter formatters based on configuration
-    const activeFormatters = formatters.filter(formatter => {
+    const activeFormatters = formatters.filter((formatter) => {
       if (formatConfig.modules.only.length > 0) {
         return formatConfig.modules.only.includes(formatter.name);
       }
@@ -98,33 +97,36 @@ export let run = async (options: {
       }
       return true;
     });
-    
+
     // Plan phase
     logger.log('info', 'Analyzing project for format operations...');
     let plan = options.fromPlan
       ? JSON.parse(await plugins.smartfile.fs.toStringSync(options.fromPlan))
       : await planner.planFormat(activeFormatters);
-    
+
     // Display plan
     await planner.displayPlan(plan, options.detailed);
-    
+
     // Save plan if requested
     if (options.savePlan) {
-      await plugins.smartfile.memory.toFs(JSON.stringify(plan, null, 2), options.savePlan);
+      await plugins.smartfile.memory.toFs(
+        JSON.stringify(plan, null, 2),
+        options.savePlan,
+      );
       logger.log('info', `Plan saved to ${options.savePlan}`);
     }
-    
+
     // Exit if plan-only mode
     if (options.planOnly) {
       return;
     }
-    
+
     // Dry-run mode
     if (options.dryRun) {
       logger.log('info', 'Dry-run mode - no changes will be made');
       return;
     }
-    
+
     // Interactive confirmation
     if (interactive && !autoApprove) {
       const interactInstance = new plugins.smartinteract.SmartInteract();
@@ -132,117 +134,56 @@ export let run = async (options: {
         type: 'confirm',
         name: 'proceed',
         message: 'Proceed with formatting?',
-        default: true
+        default: true,
       });
-      
+
       if (!(response as any).value) {
         logger.log('info', 'Format operation cancelled by user');
         return;
       }
     }
-    
+
     // Execute phase
-    logger.log('info', `Executing format operations${parallel ? ' in parallel' : ' sequentially'}...`);
+    logger.log(
+      'info',
+      `Executing format operations${parallel ? ' in parallel' : ' sequentially'}...`,
+    );
     await planner.executePlan(plan, activeFormatters, context, parallel);
-    
+
     // Finish statistics tracking
     context.getFormatStats().finish();
-    
+
     // Display statistics
     const showStats = npmextraConfig.dataFor('gitzone.format.showStats', true);
     if (showStats) {
       context.getFormatStats().displayStats();
     }
-    
+
     // Save stats if requested
     if (options.detailed) {
       const statsPath = `.nogit/format-stats-${Date.now()}.json`;
       await context.getFormatStats().saveReport(statsPath);
     }
-    
+
     logger.log('success', 'Format operations completed successfully!');
-    
   } catch (error) {
     logger.log('error', `Format operation failed: ${error.message}`);
-    
-    // Automatic rollback if enabled
-    if (formatConfig.rollback.enabled && formatConfig.rollback.autoRollbackOnError) {
-      logger.log('info', 'Attempting automatic rollback...');
-      try {
-        await context.rollbackOperation();
-        logger.log('success', 'Rollback completed successfully');
-      } catch (rollbackError) {
-        logger.log('error', `Rollback failed: ${rollbackError.message}`);
-      }
-    }
-    
+
+    // Rollback system has been removed for stability
+
     throw error;
   }
 };
 
 // Export CLI command handlers
 export const handleRollback = async (operationId?: string): Promise<void> => {
-  const context = new FormatContext();
-  const rollbackManager = context.getRollbackManager();
-  
-  if (!operationId) {
-    // Rollback to last operation
-    const backups = await rollbackManager.listBackups();
-    const lastOperation = backups
-      .filter(op => op.status !== 'rolled-back')
-      .sort((a, b) => b.timestamp - a.timestamp)[0];
-    
-    if (!lastOperation) {
-      logger.log('warn', 'No operations available for rollback');
-      return;
-    }
-    
-    operationId = lastOperation.id;
-  }
-  
-  try {
-    await rollbackManager.rollback(operationId);
-    logger.log('success', `Successfully rolled back operation ${operationId}`);
-  } catch (error) {
-    logger.log('error', `Rollback failed: ${error.message}`);
-    throw error;
-  }
+  logger.log('info', 'Rollback system has been disabled for stability');
 };
 
 export const handleListBackups = async (): Promise<void> => {
-  const context = new FormatContext();
-  const rollbackManager = context.getRollbackManager();
-  const backups = await rollbackManager.listBackups();
-  
-  if (backups.length === 0) {
-    logger.log('info', 'No backup operations found');
-    return;
-  }
-  
-  console.log('\nAvailable backups:');
-  console.log('━'.repeat(50));
-  
-  for (const backup of backups) {
-    const date = new Date(backup.timestamp).toLocaleString();
-    const status = backup.status;
-    const filesCount = backup.files.length;
-    
-    console.log(`ID: ${backup.id}`);
-    console.log(`Date: ${date}`);
-    console.log(`Status: ${status}`);
-    console.log(`Files: ${filesCount}`);
-    console.log('─'.repeat(50));
-  }
+  logger.log('info', 'Backup system has been disabled for stability');
 };
 
 export const handleCleanBackups = async (): Promise<void> => {
-  const context = new FormatContext();
-  const rollbackManager = context.getRollbackManager();
-  
-  // Get retention days from config
-  const npmextraConfig = new plugins.npmextra.Npmextra();
-  const retentionDays = npmextraConfig.dataFor<any>('gitzone.format.rollback.backupRetentionDays', 7);
-  
-  await rollbackManager.cleanOldBackups(retentionDays);
-  logger.log('success', `Cleaned backups older than ${retentionDays} days`);
-};
+  logger.log('info', 'Backup cleaning has been disabled - backup system removed');
+};

package/ts/mod_format/interfaces.format.ts

@@ -9,7 +9,7 @@ export type IFormatOperation = {
   }>;
   status: 'pending' | 'in-progress' | 'completed' | 'failed' | 'rolled-back';
   error?: Error;
-}
+};
 
 export type IFormatPlan = {
   summary: {
@@ -32,7 +32,7 @@ export type IFormatPlan = {
     message: string;
     module: string;
   }>;
-}
+};
 
 export type IPlannedChange = {
   type: 'create' | 'modify' | 'delete';
@@ -42,4 +42,4 @@ export type IPlannedChange = {
   content?: string; // For create/modify operations
   diff?: string;
   size?: number;
-}
+};