@git.zone/cli 1.16.7 → 1.16.8

package/ts/mod_format/format.prettier.ts

@@ -16,7 +16,12 @@ const prettierDefaultMarkdownConfig: prettier.Options = {
   parser: 'markdown',
 };
 
-const filesToFormat = [`ts/**/*.ts`, `test/**/*.ts`, `readme.md`, `docs/**/*.md`];
+const filesToFormat = [
+  `ts/**/*.ts`,
+  `test/**/*.ts`,
+  `readme.md`,
+  `docs/**/*.md`,
+];
 
 const choosePrettierConfig = (fileArg: plugins.smartfile.SmartFile) => {
   switch (fileArg.parsedPath.ext) {
@@ -39,7 +44,10 @@ const prettierTypeScriptPipestop = plugins.through2.obj(
       cb(null);
     } else {
       logger.log('info', `${fileArg.path} is being reformated!`);
-      const formatedFileString = await prettier.format(fileString, chosenConfig);
+      const formatedFileString = await prettier.format(
+        fileString,
+        chosenConfig,
+      );
       fileArg.setContentsFromString(formatedFileString);
       cb(null, fileArg);
     }

package/ts/mod_format/format.readme.ts

@@ -18,7 +18,8 @@ export const run = async () => {
   }
 
   // Check and initialize readme.hints.md if it doesn't exist
-  const readmeHintsExists = await plugins.smartfile.fs.fileExists(readmeHintsPath);
+  const readmeHintsExists =
+    await plugins.smartfile.fs.fileExists(readmeHintsPath);
   if (!readmeHintsExists) {
     await plugins.smartfile.fs.toFs(
       '# Project Readme Hints\n\nThis is the initial readme hints file.',

package/ts/mod_format/format.templates.ts

@@ -26,10 +26,12 @@ export const run = async (project: Project) => {
     case 'npm':
     case 'wcc':
       if (project.gitzoneConfig.data.npmciOptions.npmAccessLevel === 'public') {
-        const ciTemplateDefault = await templateModule.getTemplate('ci_default');
+        const ciTemplateDefault =
+          await templateModule.getTemplate('ci_default');
         ciTemplateDefault.writeToDisk(paths.cwd);
       } else {
-        const ciTemplateDefault = await templateModule.getTemplate('ci_default_private');
+        const ciTemplateDefault =
+          await templateModule.getTemplate('ci_default_private');
         ciTemplateDefault.writeToDisk(paths.cwd);
       }
       logger.log('info', 'Updated .gitlabci.yml!');
@@ -41,7 +43,8 @@ export const run = async (project: Project) => {
       logger.log('info', 'Updated CI/CD config files!');
 
       // lets care about docker
-      const dockerTemplate = await templateModule.getTemplate('dockerfile_service');
+      const dockerTemplate =
+        await templateModule.getTemplate('dockerfile_service');
       dockerTemplate.writeToDisk(paths.cwd);
       logger.log('info', 'Updated Dockerfile!');
 
@@ -56,17 +59,22 @@ export const run = async (project: Project) => {
 
   // update html
   if (project.gitzoneConfig.data.projectType === 'website') {
-    const websiteUpdateTemplate = await templateModule.getTemplate('website_update');
-    const variables ={
+    const websiteUpdateTemplate =
+      await templateModule.getTemplate('website_update');
+    const variables = {
       assetbrokerUrl: project.gitzoneConfig.data.module.assetbrokerUrl,
       legalUrl: project.gitzoneConfig.data.module.legalUrl,
     };
-    console.log('updating website template with variables\n', JSON.stringify(variables, null, 2));
+    console.log(
+      'updating website template with variables\n',
+      JSON.stringify(variables, null, 2),
+    );
     websiteUpdateTemplate.supplyVariables(variables);
     await websiteUpdateTemplate.writeToDisk(paths.cwd);
     logger.log('info', `Updated html for website!`);
   } else if (project.gitzoneConfig.data.projectType === 'service') {
-    const websiteUpdateTemplate = await templateModule.getTemplate('service_update');
+    const websiteUpdateTemplate =
+      await templateModule.getTemplate('service_update');
     await websiteUpdateTemplate.writeToDisk(paths.cwd);
     logger.log('info', `Updated html for element template!`);
   } else if (project.gitzoneConfig.data.projectType === 'wcc') {

package/ts/mod_format/format.tsconfig.ts

@@ -19,8 +19,12 @@ export const run = async (projectArg: Project) => {
   const publishModules = await tsPublishInstance.getModuleSubDirs(paths.cwd);
   for (const publishModule of Object.keys(publishModules)) {
     const publishConfig = publishModules[publishModule];
-    tsconfigObject.compilerOptions.paths[`${publishConfig.name}`] = [`./${publishModule}/index.js`];
+    tsconfigObject.compilerOptions.paths[`${publishConfig.name}`] = [
+      `./${publishModule}/index.js`,
+    ];
   }
-  tsconfigSmartfile.setContentsFromString(JSON.stringify(tsconfigObject, null, 2));
+  tsconfigSmartfile.setContentsFromString(
+    JSON.stringify(tsconfigObject, null, 2),
+  );
   await tsconfigSmartfile.write();
 };

package/ts/mod_format/formatters/cleanup.formatter.ts

@@ -7,13 +7,18 @@ export class CleanupFormatter extends BaseFormatter {
   get name(): string {
     return 'cleanup';
   }
-  
+
   async analyze(): Promise<IPlannedChange[]> {
     const changes: IPlannedChange[] = [];
-    
+
     // List of files to remove
-    const filesToRemove = ['yarn.lock', 'package-lock.json', 'tslint.json', 'defaults.yml'];
-    
+    const filesToRemove = [
+      'yarn.lock',
+      'package-lock.json',
+      'tslint.json',
+      'defaults.yml',
+    ];
+
     for (const file of filesToRemove) {
       const exists = await plugins.smartfile.fs.fileExists(file);
       if (exists) {
@@ -21,14 +26,14 @@ export class CleanupFormatter extends BaseFormatter {
           type: 'delete',
           path: file,
           module: this.name,
-          description: `Remove obsolete file`
+          description: `Remove obsolete file`,
         });
       }
     }
-    
+
     return changes;
   }
-  
+
   async applyChange(change: IPlannedChange): Promise<void> {
     switch (change.type) {
       case 'delete':
@@ -36,4 +41,4 @@ export class CleanupFormatter extends BaseFormatter {
         break;
     }
   }
-}
+}

package/ts/mod_format/formatters/copy.formatter.ts

@@ -5,4 +5,4 @@ export class CopyFormatter extends LegacyFormatter {
   constructor(context: any, project: any) {
     super(context, project, 'copy', formatCopy);
   }
-}
+}

package/ts/mod_format/formatters/gitignore.formatter.ts

@@ -5,4 +5,4 @@ export class GitignoreFormatter extends LegacyFormatter {
   constructor(context: any, project: any) {
     super(context, project, 'gitignore', formatGitignore);
   }
-}
+}

package/ts/mod_format/formatters/legacy.formatter.ts

@@ -7,30 +7,37 @@ import * as plugins from '../mod.plugins.js';
 export class LegacyFormatter extends BaseFormatter {
   private moduleName: string;
   private formatModule: any;
-  
-  constructor(context: any, project: Project, moduleName: string, formatModule: any) {
+
+  constructor(
+    context: any,
+    project: Project,
+    moduleName: string,
+    formatModule: any,
+  ) {
     super(context, project);
     this.moduleName = moduleName;
     this.formatModule = formatModule;
   }
-  
+
   get name(): string {
     return this.moduleName;
   }
-  
+
   async analyze(): Promise<IPlannedChange[]> {
     // For legacy modules, we can't easily predict changes
     // So we'll return a generic change that indicates the module will run
-    return [{
-      type: 'modify',
-      path: '<various files>',
-      module: this.name,
-      description: `Run ${this.name} formatter`
-    }];
+    return [
+      {
+        type: 'modify',
+        path: '<various files>',
+        module: this.name,
+        description: `Run ${this.name} formatter`,
+      },
+    ];
   }
-  
+
   async applyChange(change: IPlannedChange): Promise<void> {
     // Run the legacy format module
     await this.formatModule.run(this.project);
   }
-}
+}

package/ts/mod_format/formatters/license.formatter.ts

@@ -5,4 +5,4 @@ export class LicenseFormatter extends LegacyFormatter {
   constructor(context: any, project: any) {
     super(context, project, 'license', formatLicense);
   }
-}
+}

package/ts/mod_format/formatters/npmextra.formatter.ts

@@ -5,4 +5,4 @@ export class NpmextraFormatter extends LegacyFormatter {
   constructor(context: any, project: any) {
     super(context, project, 'npmextra', formatNpmextra);
   }
-}
+}

package/ts/mod_format/formatters/packagejson.formatter.ts

@@ -5,4 +5,4 @@ export class PackageJsonFormatter extends LegacyFormatter {
   constructor(context: any, project: any) {
     super(context, project, 'packagejson', formatPackageJson);
   }
-}
+}

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);
   }
-}
+}