@git.zone/cli 1.16.7 → 1.16.8

package/ts/mod_format/classes.rollbackmanager.ts

@@ -5,206 +5,227 @@ 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 = 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 = 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 = 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 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');
+        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`);
+      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);
@@ -214,85 +235,84 @@ export class RollbackManager {
       return defaultManifest;
     }
   }
-  
-  private async saveManifest(manifest: { operations: IFormatOperation[] }): Promise<void> {
+
+  private async saveManifest(manifest: {
+    operations: IFormatOperation[];
+  }): Promise<void> {
     // Validate before saving
     if (!this.isValidManifest(manifest)) {
       throw new Error('Invalid rollback 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 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[] } {
+
+  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)) {
+      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') {
+        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}`);
     }

package/ts/mod_format/format.copy.ts

@@ -4,56 +4,59 @@ import { logger } from '../gitzone.logging.js';
 
 export const run = async (projectArg: Project) => {
   const gitzoneConfig = await projectArg.gitzoneConfig;
-  
+
   // Get copy configuration from npmextra.json
   const npmextraConfig = new plugins.npmextra.Npmextra();
   const copyConfig = npmextraConfig.dataFor<any>('gitzone.format.copy', {
-    patterns: []
+    patterns: [],
   });
-  
+
   if (!copyConfig.patterns || copyConfig.patterns.length === 0) {
     logger.log('info', 'No copy patterns configured in npmextra.json');
     return;
   }
-  
+
   for (const pattern of copyConfig.patterns) {
     if (!pattern.from || !pattern.to) {
       logger.log('warn', 'Invalid copy pattern - missing "from" or "to" field');
       continue;
     }
-    
+
     try {
       // Handle glob patterns
       const files = await plugins.smartfile.fs.listFileTree('.', pattern.from);
-      
+
       for (const file of files) {
         const sourcePath = file;
         let destPath = pattern.to;
-        
+
         // If destination is a directory, preserve filename
         if (pattern.to.endsWith('/')) {
           const filename = plugins.path.basename(file);
           destPath = plugins.path.join(pattern.to, filename);
         }
-        
+
         // Handle template variables in destination path
         if (pattern.preservePath) {
           const relativePath = plugins.path.relative(
-            plugins.path.dirname(pattern.from.replace(/\*/g, '')), 
-            file
+            plugins.path.dirname(pattern.from.replace(/\*/g, '')),
+            file,
           );
           destPath = plugins.path.join(pattern.to, relativePath);
         }
-        
+
         // Ensure destination directory exists
         await plugins.smartfile.fs.ensureDir(plugins.path.dirname(destPath));
-        
+
         // Copy file
         await plugins.smartfile.fs.copy(sourcePath, destPath);
         logger.log('info', `Copied ${sourcePath} to ${destPath}`);
       }
     } catch (error) {
-      logger.log('error', `Failed to copy pattern ${pattern.from}: ${error.message}`);
+      logger.log(
+        'error',
+        `Failed to copy pattern ${pattern.from}: ${error.message}`,
+      );
     }
   }
 };
@@ -79,4 +82,4 @@ export const run = async (projectArg: Project) => {
  *     }
  *   }
  * }
- */
+ */

package/ts/mod_format/format.gitignore.ts

@@ -12,7 +12,8 @@ export const run = async (projectArg: Project) => {
   const ciTemplate = await templateModule.getTemplate('gitignore');
   if (gitignoreExists) {
     // lets get the existing gitignore file
-    const existingGitIgnoreString = plugins.smartfile.fs.toStringSync(gitignorePath);
+    const existingGitIgnoreString =
+      plugins.smartfile.fs.toStringSync(gitignorePath);
     let customPart = existingGitIgnoreString.split('# custom\n')[1];
     customPart ? null : (customPart = '');
   }

package/ts/mod_format/format.license.ts

@@ -24,7 +24,9 @@ export const run = async (projectArg: Project) => {
   } else {
     logger.log('error', 'Error -> licenses failed. Here is why:');
     for (const failedModule of licenseCheckResult.failingModules) {
-      console.log(`${failedModule.name} fails with license ${failedModule.license}`);
+      console.log(
+        `${failedModule.name} fails with license ${failedModule.license}`,
+      );
     }
   }
 };

package/ts/mod_format/format.npmextra.ts

@@ -29,7 +29,12 @@ export const run = async (projectArg: Project) => {
 
       const interactInstance = new plugins.smartinteract.SmartInteract();
       for (const expectedRepoInformationItem of expectedRepoInformation) {
-        if (!plugins.smartobject.smartGet(npmextraJson.gitzone, expectedRepoInformationItem)) {
+        if (
+          !plugins.smartobject.smartGet(
+            npmextraJson.gitzone,
+            expectedRepoInformationItem,
+          )
+        ) {
           interactInstance.addQuestions([
             {
               message: `What is the value of ${expectedRepoInformationItem}`,
@@ -43,7 +48,9 @@ export const run = async (projectArg: Project) => {
 
       const answerbucket = await interactInstance.runQueue();
       for (const expectedRepoInformationItem of expectedRepoInformation) {
-        const cliProvidedValue = answerbucket.getAnswerFor(expectedRepoInformationItem);
+        const cliProvidedValue = answerbucket.getAnswerFor(
+          expectedRepoInformationItem,
+        );
         if (cliProvidedValue) {
           plugins.smartobject.smartAdd(
             npmextraJson.gitzone,

package/ts/mod_format/format.packagejson.ts

@@ -19,7 +19,7 @@ const ensureDependency = async (
     : [dependencyArg, 'latest'];
 
   const targetSections: string[] = [];
-  
+
   switch (position) {
     case 'dep':
       targetSections.push('dependencies');
@@ -43,7 +43,8 @@ const ensureDependency = async (
         break;
       case 'include':
         if (!packageJsonObjectArg[section][packageName]) {
-          packageJsonObjectArg[section][packageName] = version === 'latest' ? '^1.0.0' : version;
+          packageJsonObjectArg[section][packageName] =
+            version === 'latest' ? '^1.0.0' : version;
         }
         break;
       case 'latest':
@@ -54,9 +55,13 @@ const ensureDependency = async (
           const latestVersion = packageInfo['dist-tags'].latest;
           packageJsonObjectArg[section][packageName] = `^${latestVersion}`;
         } catch (error) {
-          logger.log('warn', `Could not fetch latest version for ${packageName}, using existing or default`);
+          logger.log(
+            'warn',
+            `Could not fetch latest version for ${packageName}, using existing or default`,
+          );
           if (!packageJsonObjectArg[section][packageName]) {
-            packageJsonObjectArg[section][packageName] = version === 'latest' ? '^1.0.0' : version;
+            packageJsonObjectArg[section][packageName] =
+              version === 'latest' ? '^1.0.0' : version;
           }
         }
         break;
@@ -91,9 +96,15 @@ export const run = async (projectArg: Project) => {
 
       // Check for private or public
       if (packageJson.private !== undefined) {
-        logger.log('info', 'Success -> found private/public info in package.json!');
+        logger.log(
+          'info',
+          'Success -> found private/public info in package.json!',
+        );
       } else {
-        logger.log('error', 'found no private boolean! Setting it to private for now!');
+        logger.log(
+          'error',
+          'found no private boolean! Setting it to private for now!',
+        );
         packageJson.private = true;
       }
 
@@ -101,7 +112,10 @@ export const run = async (projectArg: Project) => {
       if (packageJson.license) {
         logger.log('info', 'Success -> found license in package.json!');
       } else {
-        logger.log('error', 'found no license! Setting it to UNLICENSED for now!');
+        logger.log(
+          'error',
+          'found no license! Setting it to UNLICENSED for now!',
+        );
         packageJson.license = 'UNLICENSED';
       }
 
@@ -109,13 +123,19 @@ export const run = async (projectArg: Project) => {
       if (packageJson.scripts.build) {
         logger.log('info', 'Success -> found build script in package.json!');
       } else {
-        logger.log('error', 'found no build script! Putting a placeholder there for now!');
+        logger.log(
+          'error',
+          'found no build script! Putting a placeholder there for now!',
+        );
         packageJson.scripts.build = `echo "Not needed for now"`;
       }
 
       // Check for buildDocs script
       if (!packageJson.scripts.buildDocs) {
-        logger.log('info', 'found no buildDocs script! Putting tsdoc script there now.');
+        logger.log(
+          'info',
+          'found no buildDocs script! Putting tsdoc script there now.',
+        );
         packageJson.scripts.buildDocs = `tsdoc`;
       }
 
@@ -134,9 +154,24 @@ export const run = async (projectArg: Project) => {
       ];
 
       // check for dependencies
-      await ensureDependency(packageJson, 'devDep', 'latest', '@push.rocks/tapbundle');
-      await ensureDependency(packageJson, 'devDep', 'latest', '@git.zone/tstest');
-      await ensureDependency(packageJson, 'devDep', 'latest', '@git.zone/tsbuild');
+      await ensureDependency(
+        packageJson,
+        'devDep',
+        'latest',
+        '@push.rocks/tapbundle',
+      );
+      await ensureDependency(
+        packageJson,
+        'devDep',
+        'latest',
+        '@git.zone/tstest',
+      );
+      await ensureDependency(
+        packageJson,
+        'devDep',
+        'latest',
+        '@git.zone/tsbuild',
+      );
 
       // set overrides
       const overrides = plugins.smartfile.fs.toObjectSync(