@git.zone/cli 1.16.7 → 1.16.8

package/ts/mod_format/classes.changecache.ts

@@ -18,32 +18,32 @@ export class ChangeCache {
   private cacheDir: string;
   private manifestPath: string;
   private cacheVersion = '1.0.0';
-  
+
   constructor() {
     this.cacheDir = plugins.path.join(paths.cwd, '.nogit', 'gitzone-cache');
     this.manifestPath = plugins.path.join(this.cacheDir, 'manifest.json');
   }
-  
+
   async initialize(): Promise<void> {
     await plugins.smartfile.fs.ensureDir(this.cacheDir);
   }
-  
+
   async getManifest(): Promise<ICacheManifest> {
     const defaultManifest: ICacheManifest = {
       version: this.cacheVersion,
       lastFormat: 0,
-      files: []
+      files: [],
     };
-    
+
     const exists = await plugins.smartfile.fs.fileExists(this.manifestPath);
     if (!exists) {
       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;
@@ -52,7 +52,9 @@ export class ChangeCache {
         return defaultManifest;
       }
     } catch (error) {
-      console.warn(`Failed to read cache manifest: ${error.message}, returning default manifest`);
+      console.warn(
+        `Failed to read cache manifest: ${error.message}, returning default manifest`,
+      );
       // Try to delete the corrupted file
       try {
         await plugins.smartfile.fs.remove(this.manifestPath);
@@ -62,168 +64,160 @@ export class ChangeCache {
       return defaultManifest;
     }
   }
-  
+
   async saveManifest(manifest: ICacheManifest): Promise<void> {
     // Validate before saving
     if (!this.isValidManifest(manifest)) {
       throw new Error('Invalid manifest structure, cannot save');
     }
-    
-    // Use atomic write: write to temp file, then move it
-    const tempPath = `${this.manifestPath}.tmp`;
-    
-    try {
-      // Write to temporary file
-      const jsonContent = JSON.stringify(manifest, null, 2);
-      await plugins.smartfile.memory.toFs(jsonContent, tempPath);
-      
-      // Move temp file to actual manifest (atomic-like operation)
-      // Since smartfile doesn't have rename, we copy and delete
-      await plugins.smartfile.fs.copy(tempPath, this.manifestPath);
-      await plugins.smartfile.fs.remove(tempPath);
-    } catch (error) {
-      // Clean up temp file if it exists
-      try {
-        await plugins.smartfile.fs.remove(tempPath);
-      } catch (removeError) {
-        // Ignore removal errors
-      }
-      throw error;
-    }
+
+    // Ensure directory exists
+    await plugins.smartfile.fs.ensureDir(this.cacheDir);
+
+    // Write directly with proper JSON stringification
+    const jsonContent = JSON.stringify(manifest, null, 2);
+    await plugins.smartfile.memory.toFs(jsonContent, this.manifestPath);
   }
-  
+
   async hasFileChanged(filePath: string): Promise<boolean> {
-    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) {
       return true; // File doesn't exist, so it's "changed" (will be created)
     }
-    
+
     // Get current file stats
     const stats = await plugins.smartfile.fs.stat(absolutePath);
-    
+
     // Skip directories
     if (stats.isDirectory()) {
       return false; // Directories are not processed
     }
-    
+
     const content = plugins.smartfile.fs.toStringSync(absolutePath);
     const currentChecksum = this.calculateChecksum(content);
-    
+
     // Get cached info
     const manifest = await this.getManifest();
-    const cachedFile = manifest.files.find(f => f.path === filePath);
-    
+    const cachedFile = manifest.files.find((f) => f.path === filePath);
+
     if (!cachedFile) {
       return true; // Not in cache, so it's changed
     }
-    
+
     // Compare checksums
-    return cachedFile.checksum !== currentChecksum || 
-           cachedFile.size !== stats.size ||
-           cachedFile.modified !== stats.mtimeMs;
+    return (
+      cachedFile.checksum !== currentChecksum ||
+      cachedFile.size !== stats.size ||
+      cachedFile.modified !== stats.mtimeMs
+    );
   }
-  
+
   async updateFileCache(filePath: string): Promise<void> {
-    const absolutePath = plugins.path.isAbsolute(filePath) 
-      ? filePath 
+    const absolutePath = plugins.path.isAbsolute(filePath)
+      ? filePath
       : plugins.path.join(paths.cwd, filePath);
-    
+
     // Get current file stats
     const stats = await plugins.smartfile.fs.stat(absolutePath);
-    
+
     // Skip directories
     if (stats.isDirectory()) {
       return; // Don't cache directories
     }
-    
+
     const content = plugins.smartfile.fs.toStringSync(absolutePath);
     const checksum = this.calculateChecksum(content);
-    
+
     // Update manifest
     const manifest = await this.getManifest();
-    const existingIndex = manifest.files.findIndex(f => f.path === filePath);
-    
+    const existingIndex = manifest.files.findIndex((f) => f.path === filePath);
+
     const cacheEntry: IFileCache = {
       path: filePath,
       checksum,
       modified: stats.mtimeMs,
-      size: stats.size
+      size: stats.size,
     };
-    
+
     if (existingIndex !== -1) {
       manifest.files[existingIndex] = cacheEntry;
     } else {
       manifest.files.push(cacheEntry);
     }
-    
+
     manifest.lastFormat = Date.now();
     await this.saveManifest(manifest);
   }
-  
+
   async getChangedFiles(filePaths: string[]): Promise<string[]> {
     const changedFiles: string[] = [];
-    
+
     for (const filePath of filePaths) {
       if (await this.hasFileChanged(filePath)) {
         changedFiles.push(filePath);
       }
     }
-    
+
     return changedFiles;
   }
-  
+
   async clean(): Promise<void> {
     const manifest = await this.getManifest();
     const validFiles: IFileCache[] = [];
-    
+
     // Remove entries for files that no longer exist
     for (const file of manifest.files) {
-      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);
-      
+
       if (await plugins.smartfile.fs.fileExists(absolutePath)) {
         validFiles.push(file);
       }
     }
-    
+
     manifest.files = validFiles;
     await this.saveManifest(manifest);
   }
-  
+
   private calculateChecksum(content: string | Buffer): string {
     return plugins.crypto.createHash('sha256').update(content).digest('hex');
   }
-  
+
   private isValidManifest(manifest: any): manifest is ICacheManifest {
     // Check if manifest has the required structure
     if (!manifest || typeof manifest !== 'object') {
       return false;
     }
-    
+
     // Check required fields
-    if (typeof manifest.version !== 'string' ||
-        typeof manifest.lastFormat !== 'number' ||
-        !Array.isArray(manifest.files)) {
+    if (
+      typeof manifest.version !== 'string' ||
+      typeof manifest.lastFormat !== 'number' ||
+      !Array.isArray(manifest.files)
+    ) {
       return false;
     }
-    
+
     // Check each file entry
     for (const file of manifest.files) {
-      if (!file || typeof file !== 'object' ||
-          typeof file.path !== 'string' ||
-          typeof file.checksum !== 'string' ||
-          typeof file.modified !== 'number' ||
-          typeof file.size !== 'number') {
+      if (
+        !file ||
+        typeof file !== 'object' ||
+        typeof file.path !== 'string' ||
+        typeof file.checksum !== 'string' ||
+        typeof file.modified !== 'number' ||
+        typeof file.size !== 'number'
+      ) {
         return false;
       }
     }
-    
+
     return true;
   }
-}
+}

package/ts/mod_format/classes.dependency-analyzer.ts

@@ -9,35 +9,42 @@ export interface IModuleDependency {
 
 export class DependencyAnalyzer {
   private moduleDependencies: Map<string, IModuleDependency> = new Map();
-  
+
   constructor() {
     this.initializeDependencies();
   }
-  
+
   private initializeDependencies(): void {
     // Define dependencies between format modules
     const dependencies = {
-      'cleanup': [],  // No dependencies
-      'npmextra': [],  // No dependencies
-      'license': ['npmextra'],  // Depends on npmextra for config
-      'packagejson': ['npmextra'],  // Depends on npmextra for config
-      'templates': ['npmextra', 'packagejson'],  // Depends on both
-      'gitignore': ['templates'],  // Depends on templates
-      'tsconfig': ['packagejson'],  // Depends on package.json
-      'prettier': ['cleanup', 'npmextra', 'packagejson', 'templates', 'gitignore', 'tsconfig'],  // Runs after most others
-      'readme': ['npmextra', 'packagejson'],  // Depends on project metadata
-      'copy': ['npmextra'],  // Depends on config
+      cleanup: [], // No dependencies
+      npmextra: [], // No dependencies
+      license: ['npmextra'], // Depends on npmextra for config
+      packagejson: ['npmextra'], // Depends on npmextra for config
+      templates: ['npmextra', 'packagejson'], // Depends on both
+      gitignore: ['templates'], // Depends on templates
+      tsconfig: ['packagejson'], // Depends on package.json
+      prettier: [
+        'cleanup',
+        'npmextra',
+        'packagejson',
+        'templates',
+        'gitignore',
+        'tsconfig',
+      ], // Runs after most others
+      readme: ['npmextra', 'packagejson'], // Depends on project metadata
+      copy: ['npmextra'], // Depends on config
     };
-    
+
     // Initialize all modules
     for (const [module, deps] of Object.entries(dependencies)) {
       this.moduleDependencies.set(module, {
         module,
         dependencies: new Set(deps),
-        dependents: new Set()
+        dependents: new Set(),
       });
     }
-    
+
     // Build reverse dependencies (dependents)
     for (const [module, deps] of Object.entries(dependencies)) {
       for (const dep of deps) {
@@ -48,34 +55,35 @@ export class DependencyAnalyzer {
       }
     }
   }
-  
+
   getExecutionGroups(modules: BaseFormatter[]): BaseFormatter[][] {
-    const modulesMap = new Map(modules.map(m => [m.name, m]));
+    const modulesMap = new Map(modules.map((m) => [m.name, m]));
     const executed = new Set<string>();
     const groups: BaseFormatter[][] = [];
-    
+
     while (executed.size < modules.length) {
       const currentGroup: BaseFormatter[] = [];
-      
+
       for (const module of modules) {
         if (executed.has(module.name)) continue;
-        
+
         const dependency = this.moduleDependencies.get(module.name);
         if (!dependency) {
           // Unknown module, execute in isolation
           currentGroup.push(module);
           continue;
         }
-        
+
         // Check if all dependencies have been executed
-        const allDepsExecuted = Array.from(dependency.dependencies)
-          .every(dep => executed.has(dep) || !modulesMap.has(dep));
-        
+        const allDepsExecuted = Array.from(dependency.dependencies).every(
+          (dep) => executed.has(dep) || !modulesMap.has(dep),
+        );
+
         if (allDepsExecuted) {
           currentGroup.push(module);
         }
       }
-      
+
       if (currentGroup.length === 0) {
         // Circular dependency or error - execute remaining modules
         for (const module of modules) {
@@ -84,24 +92,26 @@ export class DependencyAnalyzer {
           }
         }
       }
-      
-      currentGroup.forEach(m => executed.add(m.name));
+
+      currentGroup.forEach((m) => executed.add(m.name));
       groups.push(currentGroup);
     }
-    
+
     return groups;
   }
-  
+
   canRunInParallel(module1: string, module2: string): boolean {
     const dep1 = this.moduleDependencies.get(module1);
     const dep2 = this.moduleDependencies.get(module2);
-    
+
     if (!dep1 || !dep2) return false;
-    
+
     // Check if module1 depends on module2 or vice versa
-    return !dep1.dependencies.has(module2) && 
-           !dep2.dependencies.has(module1) &&
-           !dep1.dependents.has(module2) &&
-           !dep2.dependents.has(module1);
+    return (
+      !dep1.dependencies.has(module2) &&
+      !dep2.dependencies.has(module1) &&
+      !dep1.dependents.has(module2) &&
+      !dep2.dependents.has(module1)
+    );
   }
-}
+}

package/ts/mod_format/classes.diffreporter.ts

@@ -4,72 +4,85 @@ import { logger } from '../gitzone.logging.js';
 
 export class DiffReporter {
   private diffs: Map<string, string> = new Map();
-  
-  async generateDiff(filePath: string, oldContent: string, newContent: string): Promise<string> {
+
+  async generateDiff(
+    filePath: string,
+    oldContent: string,
+    newContent: string,
+  ): Promise<string> {
     const diff = plugins.smartdiff.createDiff(oldContent, newContent);
     this.diffs.set(filePath, diff);
     return diff;
   }
-  
+
   async generateDiffForChange(change: IPlannedChange): Promise<string | null> {
     if (change.type !== 'modify') {
       return null;
     }
-    
+
     try {
       const exists = await plugins.smartfile.fs.fileExists(change.path);
       if (!exists) {
         return null;
       }
-      
-      const currentContent = await plugins.smartfile.fs.toStringSync(change.path);
-      
+
+      const currentContent = await plugins.smartfile.fs.toStringSync(
+        change.path,
+      );
+
       // For planned changes, we need the new content
       if (!change.content) {
         return null;
       }
-      
-      return await this.generateDiff(change.path, currentContent, change.content);
+
+      return await this.generateDiff(
+        change.path,
+        currentContent,
+        change.content,
+      );
     } catch (error) {
-      logger.log('error', `Failed to generate diff for ${change.path}: ${error.message}`);
+      logger.log(
+        'error',
+        `Failed to generate diff for ${change.path}: ${error.message}`,
+      );
       return null;
     }
   }
-  
+
   displayDiff(filePath: string, diff?: string): void {
     const diffToShow = diff || this.diffs.get(filePath);
-    
+
     if (!diffToShow) {
       logger.log('warn', `No diff available for ${filePath}`);
       return;
     }
-    
+
     console.log(`\n${this.formatDiffHeader(filePath)}`);
     console.log(this.colorDiff(diffToShow));
     console.log('━'.repeat(50));
   }
-  
+
   displayAllDiffs(): void {
     if (this.diffs.size === 0) {
       logger.log('info', 'No diffs to display');
       return;
     }
-    
+
     console.log('\nFile Changes:');
     console.log('═'.repeat(50));
-    
+
     for (const [filePath, diff] of this.diffs) {
       this.displayDiff(filePath, diff);
     }
   }
-  
+
   private formatDiffHeader(filePath: string): string {
     return `📄 ${filePath}`;
   }
-  
+
   private colorDiff(diff: string): string {
     const lines = diff.split('\n');
-    const coloredLines = lines.map(line => {
+    const coloredLines = lines.map((line) => {
       if (line.startsWith('+') && !line.startsWith('+++')) {
         return `\x1b[32m${line}\x1b[0m`; // Green for additions
       } else if (line.startsWith('-') && !line.startsWith('---')) {
@@ -80,29 +93,32 @@ export class DiffReporter {
         return line;
       }
     });
-    
+
     return coloredLines.join('\n');
   }
-  
+
   async saveDiffReport(outputPath: string): Promise<void> {
     const report = {
       timestamp: new Date().toISOString(),
       totalFiles: this.diffs.size,
       diffs: Array.from(this.diffs.entries()).map(([path, diff]) => ({
         path,
-        diff
-      }))
+        diff,
+      })),
     };
-    
-    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', `Diff report saved to ${outputPath}`);
   }
-  
+
   hasAnyDiffs(): boolean {
     return this.diffs.size > 0;
   }
-  
+
   getDiffCount(): number {
     return this.diffs.size;
   }
-}
+}

package/ts/mod_format/classes.formatcontext.ts

@@ -1,65 +1,14 @@
 import * as plugins from './mod.plugins.js';
-import { RollbackManager } from './classes.rollbackmanager.js';
-import { ChangeCache } from './classes.changecache.js';
 import { FormatStats } from './classes.formatstats.js';
-import type { IFormatOperation, IFormatPlan } from './interfaces.format.js';
 
 export class FormatContext {
-  private rollbackManager: RollbackManager;
-  private currentOperation: IFormatOperation | null = null;
-  private changeCache: ChangeCache;
   private formatStats: FormatStats;
-  
+
   constructor() {
-    this.rollbackManager = new RollbackManager();
-    this.changeCache = new ChangeCache();
     this.formatStats = new FormatStats();
   }
-  
-  async beginOperation(): Promise<void> {
-    this.currentOperation = await this.rollbackManager.createOperation();
-  }
-  
-  async trackFileChange(filepath: string): Promise<void> {
-    if (!this.currentOperation) {
-      throw new Error('No operation in progress. Call beginOperation() first.');
-    }
-    await this.rollbackManager.backupFile(filepath, this.currentOperation.id);
-  }
-  
-  async commitOperation(): Promise<void> {
-    if (!this.currentOperation) {
-      throw new Error('No operation in progress. Call beginOperation() first.');
-    }
-    await this.rollbackManager.markComplete(this.currentOperation.id);
-    this.currentOperation = null;
-  }
-  
-  async rollbackOperation(): Promise<void> {
-    if (!this.currentOperation) {
-      throw new Error('No operation in progress. Call beginOperation() first.');
-    }
-    await this.rollbackManager.rollback(this.currentOperation.id);
-    this.currentOperation = null;
-  }
-  
-  async rollbackTo(operationId: string): Promise<void> {
-    await this.rollbackManager.rollback(operationId);
-  }
-  
-  getRollbackManager(): RollbackManager {
-    return this.rollbackManager;
-  }
-  
-  getChangeCache(): ChangeCache {
-    return this.changeCache;
-  }
-  
-  async initializeCache(): Promise<void> {
-    await this.changeCache.initialize();
-  }
-  
+
   getFormatStats(): FormatStats {
     return this.formatStats;
   }
-}
+}