@git.zone/cli 1.16.6 → 1.16.8

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/cli',
-  version: '1.16.6',
+  version: '1.16.8',
   description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 }

package/ts/classes.gitzoneconfig.ts

@@ -40,7 +40,9 @@ export class GitzoneConfig {
   public async readConfigFromCwd() {
     const npmextraInstance = new plugins.npmextra.Npmextra(paths.cwd);
     this.data = npmextraInstance.dataFor<IGitzoneConfigData>('gitzone', {});
-    this.data.npmciOptions = npmextraInstance.dataFor<IGitzoneConfigData['npmciOptions']>('npmci', {
+    this.data.npmciOptions = npmextraInstance.dataFor<
+      IGitzoneConfigData['npmciOptions']
+    >('npmci', {
       npmAccessLevel: 'public',
     });
   }

package/ts/gitzone.cli.ts

@@ -62,23 +62,23 @@ export let run = async () => {
   gitzoneSmartcli.addCommand('format').subscribe(async (argvArg) => {
     const config = GitzoneConfig.fromCwd();
     const modFormat = await import('./mod_format/index.js');
-    
+
     // Handle rollback commands
     if (argvArg.rollback) {
       await modFormat.handleRollback(argvArg.rollback);
       return;
     }
-    
+
     if (argvArg['list-backups']) {
       await modFormat.handleListBackups();
       return;
     }
-    
+
     if (argvArg['clean-backups']) {
       await modFormat.handleCleanBackups();
       return;
     }
-    
+
     // Handle format with options
     await modFormat.run({
       dryRun: argvArg['dry-run'],
@@ -89,7 +89,7 @@ export let run = async () => {
       detailed: argvArg.detailed,
       interactive: argvArg.interactive !== false,
       parallel: argvArg.parallel !== false,
-      verbose: argvArg.verbose
+      verbose: argvArg.verbose,
     });
   });
 

package/ts/gitzone.logging.ts

@@ -5,7 +5,8 @@ import * as plugins from './plugins.js';
 export const logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo);
 
 // Add console destination
-const consoleDestination = new plugins.smartlogDestinationLocal.DestinationLocal();
+const consoleDestination =
+  new plugins.smartlogDestinationLocal.DestinationLocal();
 logger.addLogDestination(consoleDestination);
 
 // Verbose logging helper

package/ts/mod_commit/index.ts

@@ -10,20 +10,22 @@ export const run = async (argvArg: any) => {
     await formatMod.run();
   }
 
-
   logger.log('info', `gathering facts...`);
   const aidoc = new plugins.tsdoc.AiDoc();
   await aidoc.start();
 
   const nextCommitObject = await aidoc.buildNextCommitObject(paths.cwd);
 
-  logger.log('info', `---------
+  logger.log(
+    'info',
+    `---------
     Next recommended commit would be:
     ===========
     -> ${nextCommitObject.recommendedNextVersion}:
     -> ${nextCommitObject.recommendedNextVersionLevel}(${nextCommitObject.recommendedNextVersionScope}): ${nextCommitObject.recommendedNextVersionMessage}
     ===========
-  `);
+  `,
+  );
   const commitInteract = new plugins.smartinteract.SmartInteract();
   commitInteract.addQuestions([
     {
@@ -72,32 +74,55 @@ export const run = async (argvArg: any) => {
   });
 
   logger.log('info', `Baking commitinfo into code ...`);
-  const commitInfo = new plugins.commitinfo.CommitInfo(paths.cwd, commitVersionType);
+  const commitInfo = new plugins.commitinfo.CommitInfo(
+    paths.cwd,
+    commitVersionType,
+  );
   await commitInfo.writeIntoPotentialDirs();
 
   logger.log('info', `Writing changelog.md ...`);
   let changelog = nextCommitObject.changelog;
-  changelog = changelog.replaceAll('{{nextVersion}}', (await commitInfo.getNextPlannedVersion()).versionString);
-  changelog = changelog.replaceAll('{{nextVersionScope}}', `${await answerBucket.getAnswerFor('commitType')}(${await answerBucket.getAnswerFor('commitScope')})`);
-  changelog = changelog.replaceAll('{{nextVersionMessage}}', nextCommitObject.recommendedNextVersionMessage);
+  changelog = changelog.replaceAll(
+    '{{nextVersion}}',
+    (await commitInfo.getNextPlannedVersion()).versionString,
+  );
+  changelog = changelog.replaceAll(
+    '{{nextVersionScope}}',
+    `${await answerBucket.getAnswerFor('commitType')}(${await answerBucket.getAnswerFor('commitScope')})`,
+  );
+  changelog = changelog.replaceAll(
+    '{{nextVersionMessage}}',
+    nextCommitObject.recommendedNextVersionMessage,
+  );
   if (nextCommitObject.recommendedNextVersionDetails?.length > 0) {
-    changelog = changelog.replaceAll('{{nextVersionDetails}}', '- ' + nextCommitObject.recommendedNextVersionDetails.join('\n- '));
+    changelog = changelog.replaceAll(
+      '{{nextVersionDetails}}',
+      '- ' + nextCommitObject.recommendedNextVersionDetails.join('\n- '),
+    );
   } else {
     changelog = changelog.replaceAll('\n{{nextVersionDetails}}', '');
   }
 
-  await plugins.smartfile.memory.toFs(changelog, plugins.path.join(paths.cwd, `changelog.md`));
+  await plugins.smartfile.memory.toFs(
+    changelog,
+    plugins.path.join(paths.cwd, `changelog.md`),
+  );
 
   logger.log('info', `Staging files for commit:`);
   await smartshellInstance.exec(`git add -A`);
   await smartshellInstance.exec(`git commit -m "${commitString}"`);
   await smartshellInstance.exec(`npm version ${commitVersionType}`);
-  if (answerBucket.getAnswerFor('pushToOrigin') && !(process.env.CI === 'true')) {
+  if (
+    answerBucket.getAnswerFor('pushToOrigin') &&
+    !(process.env.CI === 'true')
+  ) {
     await smartshellInstance.exec(`git push origin master --follow-tags`);
   }
 };
 
-const createCommitStringFromAnswerBucket = (answerBucket: plugins.smartinteract.AnswerBucket) => {
+const createCommitStringFromAnswerBucket = (
+  answerBucket: plugins.smartinteract.AnswerBucket,
+) => {
   const commitType = answerBucket.getAnswerFor('commitType');
   const commitScope = answerBucket.getAnswerFor('commitScope');
   const commitDescription = answerBucket.getAnswerFor('commitDescription');

package/ts/mod_deprecate/index.ts

@@ -36,7 +36,10 @@ export const run = async () => {
   const registryUrls = answerBucket.getAnswerFor(`registryUrls`).split(',');
   const oldPackageName = answerBucket.getAnswerFor(`oldPackageName`);
   const newPackageName = answerBucket.getAnswerFor(`newPackageName`);
-  logger.log('info', `Deprecating package ${oldPackageName} in favour of ${newPackageName}`);
+  logger.log(
+    'info',
+    `Deprecating package ${oldPackageName} in favour of ${newPackageName}`,
+  );
   const smartshellInstance = new plugins.smartshell.Smartshell({
     executor: 'bash',
   });

package/ts/mod_format/classes.baseformatter.ts

@@ -2,32 +2,29 @@ import * as plugins from './mod.plugins.js';
 import { FormatContext } from './classes.formatcontext.js';
 import type { IPlannedChange } from './interfaces.format.js';
 import { Project } from '../classes.project.js';
-import { ChangeCache } from './classes.changecache.js';
 
 export abstract class BaseFormatter {
   protected context: FormatContext;
   protected project: Project;
-  protected cache: ChangeCache;
   protected stats: any; // Will be FormatStats from context
-  
+
   constructor(context: FormatContext, project: Project) {
     this.context = context;
     this.project = project;
-    this.cache = context.getChangeCache();
     this.stats = context.getFormatStats();
   }
-  
+
   abstract get name(): string;
   abstract analyze(): Promise<IPlannedChange[]>;
   abstract applyChange(change: IPlannedChange): Promise<void>;
-  
+
   async execute(changes: IPlannedChange[]): Promise<void> {
     const startTime = this.stats.moduleStartTime(this.name);
     this.stats.startModule(this.name);
-    
+
     try {
       await this.preExecute();
-      
+
       for (const change of changes) {
         try {
           await this.applyChange(change);
@@ -37,57 +34,37 @@ export abstract class BaseFormatter {
           throw error;
         }
       }
-      
+
       await this.postExecute();
     } catch (error) {
-      await this.context.rollbackOperation();
+      // Don't rollback here - let the FormatPlanner handle it
       throw error;
     } finally {
       this.stats.endModule(this.name, startTime);
     }
   }
-  
+
   protected async preExecute(): Promise<void> {
     // Override in subclasses if needed
   }
-  
+
   protected async postExecute(): Promise<void> {
     // Override in subclasses if needed
   }
-  
+
   protected async modifyFile(filepath: string, content: string): Promise<void> {
-    await this.context.trackFileChange(filepath);
     await plugins.smartfile.memory.toFs(content, filepath);
-    await this.cache.updateFileCache(filepath);
   }
-  
+
   protected async createFile(filepath: string, content: string): Promise<void> {
     await plugins.smartfile.memory.toFs(content, filepath);
-    await this.cache.updateFileCache(filepath);
   }
-  
+
   protected async deleteFile(filepath: string): Promise<void> {
-    await this.context.trackFileChange(filepath);
     await plugins.smartfile.fs.remove(filepath);
   }
-  
+
   protected async shouldProcessFile(filepath: string): Promise<boolean> {
-    const config = new plugins.npmextra.Npmextra();
-    const useCache = config.dataFor('gitzone.format.cache.enabled', true);
-    
-    if (!useCache) {
-      return true; // Process all files if cache is disabled
-    }
-    
-    const hasChanged = await this.cache.hasFileChanged(filepath);
-    
-    // Record cache statistics
-    if (hasChanged) {
-      this.stats.recordCacheMiss();
-    } else {
-      this.stats.recordCacheHit();
-    }
-    
-    return hasChanged;
+    return true;
   }
-}
+}

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