@git.zone/cli 1.15.4 → 1.16.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/cli',
-    version: '1.15.4',
+    version: '1.16.0',
     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.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxlQUFlO0lBQ3JCLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSwrTEFBK0w7Q0FDN00sQ0FBQSJ9

package/dist_ts/gitzone.cli.js

@@ -47,7 +47,31 @@ export let run = async () => {
     gitzoneSmartcli.addCommand('format').subscribe(async (argvArg) => {
         const config = GitzoneConfig.fromCwd();
         const modFormat = await import('./mod_format/index.js');
-        await modFormat.run();
+        // 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'],
+            yes: argvArg.yes,
+            planOnly: argvArg['plan-only'],
+            savePlan: argvArg['save-plan'],
+            fromPlan: argvArg['from-plan'],
+            detailed: argvArg.detailed,
+            interactive: argvArg.interactive !== false,
+            parallel: argvArg.parallel !== false,
+            verbose: argvArg.verbose
+        });
     });
     /**
      * run meta commands
@@ -86,4 +110,4 @@ export let run = async () => {
     gitzoneSmartcli.startParse();
     return await done.promise;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/gitzone.logging.d.ts

@@ -1,2 +1,5 @@
 import * as plugins from './plugins.js';
 export declare const logger: plugins.smartlog.Smartlog;
+export declare const setVerboseMode: (verbose: boolean) => void;
+export declare const isVerboseMode: () => boolean;
+export declare const logVerbose: (message: string) => void;

package/dist_ts/gitzone.logging.js

@@ -1,5 +1,23 @@
 import { commitinfo } from '@push.rocks/commitinfo';
 import * as plugins from './plugins.js';
+// Create logger instance
 export const logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo);
-logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2l0em9uZS5sb2dnaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvZ2l0em9uZS5sb2dnaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNwRCxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsbUJBQW1CLENBQUMsVUFBVSxDQUFDLENBQUM7QUFFaEYsTUFBTSxDQUFDLGlCQUFpQixDQUFDLElBQUksT0FBTyxDQUFDLHdCQUF3QixDQUFDLGdCQUFnQixFQUFFLENBQUMsQ0FBQyJ9
+// Add console destination
+const consoleDestination = new plugins.smartlogDestinationLocal.DestinationLocal();
+logger.addLogDestination(consoleDestination);
+// Verbose logging helper
+let verboseMode = false;
+export const setVerboseMode = (verbose) => {
+    verboseMode = verbose;
+    logger.log('info', `Verbose mode ${verbose ? 'enabled' : 'disabled'}`);
+};
+export const isVerboseMode = () => {
+    return verboseMode;
+};
+// Custom log method with verbose support
+export const logVerbose = (message) => {
+    if (verboseMode) {
+        logger.log('info', `[VERBOSE] ${message}`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2l0em9uZS5sb2dnaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvZ2l0em9uZS5sb2dnaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNwRCxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4Qyx5QkFBeUI7QUFDekIsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLG1CQUFtQixDQUFDLFVBQVUsQ0FBQyxDQUFDO0FBRWhGLDBCQUEwQjtBQUMxQixNQUFNLGtCQUFrQixHQUFHLElBQUksT0FBTyxDQUFDLHdCQUF3QixDQUFDLGdCQUFnQixFQUFFLENBQUM7QUFDbkYsTUFBTSxDQUFDLGlCQUFpQixDQUFDLGtCQUFrQixDQUFDLENBQUM7QUFFN0MseUJBQXlCO0FBQ3pCLElBQUksV0FBVyxHQUFHLEtBQUssQ0FBQztBQUV4QixNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FBQyxPQUFnQixFQUFRLEVBQUU7SUFDdkQsV0FBVyxHQUFHLE9BQU8sQ0FBQztJQUN0QixNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxnQkFBZ0IsT0FBTyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUM7QUFDekUsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLEdBQVksRUFBRTtJQUN6QyxPQUFPLFdBQVcsQ0FBQztBQUNyQixDQUFDLENBQUM7QUFFRix5Q0FBeUM7QUFDekMsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLENBQUMsT0FBZSxFQUFRLEVBQUU7SUFDbEQsSUFBSSxXQUFXLEVBQUUsQ0FBQztRQUNoQixNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxhQUFhLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDN0MsQ0FBQztBQUNILENBQUMsQ0FBQyJ9

package/dist_ts/mod_format/classes.baseformatter.d.ts

@@ -0,0 +1,21 @@
+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 declare abstract class BaseFormatter {
+    protected context: FormatContext;
+    protected project: Project;
+    protected cache: ChangeCache;
+    protected stats: any;
+    constructor(context: FormatContext, project: Project);
+    abstract get name(): string;
+    abstract analyze(): Promise<IPlannedChange[]>;
+    abstract applyChange(change: IPlannedChange): Promise<void>;
+    execute(changes: IPlannedChange[]): Promise<void>;
+    protected preExecute(): Promise<void>;
+    protected postExecute(): Promise<void>;
+    protected modifyFile(filepath: string, content: string): Promise<void>;
+    protected createFile(filepath: string, content: string): Promise<void>;
+    protected deleteFile(filepath: string): Promise<void>;
+    protected shouldProcessFile(filepath: string): Promise<boolean>;
+}

package/dist_ts/mod_format/classes.baseformatter.js

@@ -0,0 +1,73 @@
+import * as plugins from './mod.plugins.js';
+import { FormatContext } from './classes.formatcontext.js';
+import { Project } from '../classes.project.js';
+import { ChangeCache } from './classes.changecache.js';
+export class BaseFormatter {
+    constructor(context, project) {
+        this.context = context;
+        this.project = project;
+        this.cache = context.getChangeCache();
+        this.stats = context.getFormatStats();
+    }
+    async execute(changes) {
+        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);
+                    this.stats.recordFileOperation(this.name, change.type, true);
+                }
+                catch (error) {
+                    this.stats.recordFileOperation(this.name, change.type, false);
+                    throw error;
+                }
+            }
+            await this.postExecute();
+        }
+        catch (error) {
+            await this.context.rollbackOperation();
+            throw error;
+        }
+        finally {
+            this.stats.endModule(this.name, startTime);
+        }
+    }
+    async preExecute() {
+        // Override in subclasses if needed
+    }
+    async postExecute() {
+        // Override in subclasses if needed
+    }
+    async modifyFile(filepath, content) {
+        await this.context.trackFileChange(filepath);
+        await plugins.smartfile.memory.toFs(content, filepath);
+        await this.cache.updateFileCache(filepath);
+    }
+    async createFile(filepath, content) {
+        await plugins.smartfile.memory.toFs(content, filepath);
+        await this.cache.updateFileCache(filepath);
+    }
+    async deleteFile(filepath) {
+        await this.context.trackFileChange(filepath);
+        await plugins.smartfile.fs.remove(filepath);
+    }
+    async shouldProcessFile(filepath) {
+        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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_format/classes.changecache.d.ts

@@ -0,0 +1,25 @@
+export interface IFileCache {
+    path: string;
+    checksum: string;
+    modified: number;
+    size: number;
+}
+export interface ICacheManifest {
+    version: string;
+    lastFormat: number;
+    files: IFileCache[];
+}
+export declare class ChangeCache {
+    private cacheDir;
+    private manifestPath;
+    private cacheVersion;
+    constructor();
+    initialize(): Promise<void>;
+    getManifest(): Promise<ICacheManifest>;
+    saveManifest(manifest: ICacheManifest): Promise<void>;
+    hasFileChanged(filePath: string): Promise<boolean>;
+    updateFileCache(filePath: string): Promise<void>;
+    getChangedFiles(filePaths: string[]): Promise<string[]>;
+    clean(): Promise<void>;
+    private calculateChecksum;
+}

package/dist_ts/mod_format/classes.changecache.js

@@ -0,0 +1,105 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+export class ChangeCache {
+    constructor() {
+        this.cacheVersion = '1.0.0';
+        this.cacheDir = plugins.path.join(paths.cwd, '.nogit', 'gitzone-cache');
+        this.manifestPath = plugins.path.join(this.cacheDir, 'manifest.json');
+    }
+    async initialize() {
+        await plugins.smartfile.fs.ensureDir(this.cacheDir);
+    }
+    async getManifest() {
+        const exists = await plugins.smartfile.fs.fileExists(this.manifestPath);
+        if (!exists) {
+            return {
+                version: this.cacheVersion,
+                lastFormat: 0,
+                files: []
+            };
+        }
+        const content = await plugins.smartfile.fs.toStringSync(this.manifestPath);
+        return JSON.parse(content);
+    }
+    async saveManifest(manifest) {
+        await plugins.smartfile.memory.toFs(JSON.stringify(manifest, null, 2), this.manifestPath);
+    }
+    async hasFileChanged(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);
+        const content = await 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);
+        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;
+    }
+    async updateFileCache(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);
+        const content = await 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 cacheEntry = {
+            path: filePath,
+            checksum,
+            modified: stats.mtimeMs,
+            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) {
+        const changedFiles = [];
+        for (const filePath of filePaths) {
+            if (await this.hasFileChanged(filePath)) {
+                changedFiles.push(filePath);
+            }
+        }
+        return changedFiles;
+    }
+    async clean() {
+        const manifest = await this.getManifest();
+        const validFiles = [];
+        // Remove entries for files that no longer exist
+        for (const file of manifest.files) {
+            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);
+    }
+    calculateChecksum(content) {
+        return plugins.crypto.createHash('sha256').update(content).digest('hex');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+import { BaseFormatter } from './classes.baseformatter.js';
+export interface IModuleDependency {
+    module: string;
+    dependencies: Set<string>;
+    dependents: Set<string>;
+}
+export declare class DependencyAnalyzer {
+    private moduleDependencies;
+    constructor();
+    private initializeDependencies;
+    getExecutionGroups(modules: BaseFormatter[]): BaseFormatter[][];
+    canRunInParallel(module1: string, module2: string): boolean;
+}

package/dist_ts/mod_format/classes.dependency-analyzer.js

@@ -0,0 +1,87 @@
+import * as plugins from './mod.plugins.js';
+import { BaseFormatter } from './classes.baseformatter.js';
+export class DependencyAnalyzer {
+    constructor() {
+        this.moduleDependencies = new Map();
+        this.initializeDependencies();
+    }
+    initializeDependencies() {
+        // 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
+        };
+        // Initialize all modules
+        for (const [module, deps] of Object.entries(dependencies)) {
+            this.moduleDependencies.set(module, {
+                module,
+                dependencies: new Set(deps),
+                dependents: new Set()
+            });
+        }
+        // Build reverse dependencies (dependents)
+        for (const [module, deps] of Object.entries(dependencies)) {
+            for (const dep of deps) {
+                const depModule = this.moduleDependencies.get(dep);
+                if (depModule) {
+                    depModule.dependents.add(module);
+                }
+            }
+        }
+    }
+    getExecutionGroups(modules) {
+        const modulesMap = new Map(modules.map(m => [m.name, m]));
+        const executed = new Set();
+        const groups = [];
+        while (executed.size < modules.length) {
+            const currentGroup = [];
+            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));
+                if (allDepsExecuted) {
+                    currentGroup.push(module);
+                }
+            }
+            if (currentGroup.length === 0) {
+                // Circular dependency or error - execute remaining modules
+                for (const module of modules) {
+                    if (!executed.has(module.name)) {
+                        currentGroup.push(module);
+                    }
+                }
+            }
+            currentGroup.forEach(m => executed.add(m.name));
+            groups.push(currentGroup);
+        }
+        return groups;
+    }
+    canRunInParallel(module1, module2) {
+        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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5kZXBlbmRlbmN5LWFuYWx5emVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvbW9kX2Zvcm1hdC9jbGFzc2VzLmRlcGVuZGVuY3ktYW5hbHl6ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUM1QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFRM0QsTUFBTSxPQUFPLGtCQUFrQjtJQUc3QjtRQUZRLHVCQUFrQixHQUFtQyxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBR3JFLElBQUksQ0FBQyxzQkFBc0IsRUFBRSxDQUFDO0lBQ2hDLENBQUM7SUFFTyxzQkFBc0I7UUFDNUIsNkNBQTZDO1FBQzdDLE1BQU0sWUFBWSxHQUFHO1lBQ25CLFNBQVMsRUFBRSxFQUFFLEVBQUcsa0JBQWtCO1lBQ2xDLFVBQVUsRUFBRSxFQUFFLEVBQUcsa0JBQWtCO1lBQ25DLFNBQVMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxFQUFHLGlDQUFpQztZQUMzRCxhQUFhLEVBQUUsQ0FBQyxVQUFVLENBQUMsRUFBRyxpQ0FBaUM7WUFDL0QsV0FBVyxFQUFFLENBQUMsVUFBVSxFQUFFLGFBQWEsQ0FBQyxFQUFHLGtCQUFrQjtZQUM3RCxXQUFXLEVBQUUsQ0FBQyxXQUFXLENBQUMsRUFBRyx1QkFBdUI7WUFDcEQsVUFBVSxFQUFFLENBQUMsYUFBYSxDQUFDLEVBQUcsMEJBQTBCO1lBQ3hELFVBQVUsRUFBRSxDQUFDLFNBQVMsRUFBRSxVQUFVLEVBQUUsYUFBYSxFQUFFLFdBQVcsRUFBRSxXQUFXLEVBQUUsVUFBVSxDQUFDLEVBQUcseUJBQXlCO1lBQ3BILFFBQVEsRUFBRSxDQUFDLFVBQVUsRUFBRSxhQUFhLENBQUMsRUFBRyw4QkFBOEI7WUFDdEUsTUFBTSxFQUFFLENBQUMsVUFBVSxDQUFDLEVBQUcsb0JBQW9CO1NBQzVDLENBQUM7UUFFRix5QkFBeUI7UUFDekIsS0FBSyxNQUFNLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLEVBQUUsQ0FBQztZQUMxRCxJQUFJLENBQUMsa0JBQWtCLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRTtnQkFDbEMsTUFBTTtnQkFDTixZQUFZLEVBQUUsSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDO2dCQUMzQixVQUFVLEVBQUUsSUFBSSxHQUFHLEVBQUU7YUFDdEIsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUVELDBDQUEwQztRQUMxQyxLQUFLLE1BQU0sQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDO1lBQzFELEtBQUssTUFBTSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7Z0JBQ3ZCLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQ25ELElBQUksU0FBUyxFQUFFLENBQUM7b0JBQ2QsU0FBUyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQ25DLENBQUM7WUFDSCxDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFFRCxrQkFBa0IsQ0FBQyxPQUF3QjtRQUN6QyxNQUFNLFVBQVUsR0FBRyxJQUFJLEdBQUcsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUMxRCxNQUFNLFFBQVEsR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFDO1FBQ25DLE1BQU0sTUFBTSxHQUFzQixFQUFFLENBQUM7UUFFckMsT0FBTyxRQUFRLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUN0QyxNQUFNLFlBQVksR0FBb0IsRUFBRSxDQUFDO1lBRXpDLEtBQUssTUFBTSxNQUFNLElBQUksT0FBTyxFQUFFLENBQUM7Z0JBQzdCLElBQUksUUFBUSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDO29CQUFFLFNBQVM7Z0JBRXhDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUM1RCxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7b0JBQ2hCLHVDQUF1QztvQkFDdkMsWUFBWSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztvQkFDMUIsU0FBUztnQkFDWCxDQUFDO2dCQUVELCtDQUErQztnQkFDL0MsTUFBTSxlQUFlLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsWUFBWSxDQUFDO3FCQUN4RCxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUUzRCxJQUFJLGVBQWUsRUFBRSxDQUFDO29CQUNwQixZQUFZLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2dCQUM1QixDQUFDO1lBQ0gsQ0FBQztZQUVELElBQUksWUFBWSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztnQkFDOUIsMkRBQTJEO2dCQUMzRCxLQUFLLE1BQU0sTUFBTSxJQUFJLE9BQU8sRUFBRSxDQUFDO29CQUM3QixJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQzt3QkFDL0IsWUFBWSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztvQkFDNUIsQ0FBQztnQkFDSCxDQUFDO1lBQ0gsQ0FBQztZQUVELFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQ2hELE1BQU0sQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDNUIsQ0FBQztRQUVELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxPQUFlLEVBQUUsT0FBZTtRQUMvQyxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2xELE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFbEQsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLElBQUk7WUFBRSxPQUFPLEtBQUssQ0FBQztRQUVqQyxvREFBb0Q7UUFDcEQsT0FBTyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQztZQUMvQixDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQztZQUMvQixDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQztZQUM3QixDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7Q0FDRiJ9

package/dist_ts/mod_format/classes.diffreporter.d.ts

@@ -0,0 +1,13 @@
+import type { IPlannedChange } from './interfaces.format.js';
+export declare class DiffReporter {
+    private diffs;
+    generateDiff(filePath: string, oldContent: string, newContent: string): Promise<string>;
+    generateDiffForChange(change: IPlannedChange): Promise<string | null>;
+    displayDiff(filePath: string, diff?: string): void;
+    displayAllDiffs(): void;
+    private formatDiffHeader;
+    private colorDiff;
+    saveDiffReport(outputPath: string): Promise<void>;
+    hasAnyDiffs(): boolean;
+    getDiffCount(): number;
+}

package/dist_ts/mod_format/classes.diffreporter.js

@@ -0,0 +1,94 @@
+import * as plugins from './mod.plugins.js';
+import { logger } from '../gitzone.logging.js';
+export class DiffReporter {
+    constructor() {
+        this.diffs = new Map();
+    }
+    async generateDiff(filePath, oldContent, newContent) {
+        const diff = plugins.smartdiff.createDiff(oldContent, newContent);
+        this.diffs.set(filePath, diff);
+        return diff;
+    }
+    async generateDiffForChange(change) {
+        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);
+            // For planned changes, we need the new content
+            if (!change.content) {
+                return null;
+            }
+            return await this.generateDiff(change.path, currentContent, change.content);
+        }
+        catch (error) {
+            logger.log('error', `Failed to generate diff for ${change.path}: ${error.message}`);
+            return null;
+        }
+    }
+    displayDiff(filePath, diff) {
+        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() {
+        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);
+        }
+    }
+    formatDiffHeader(filePath) {
+        return `📄 ${filePath}`;
+    }
+    colorDiff(diff) {
+        const lines = diff.split('\n');
+        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('---')) {
+                return `\x1b[31m${line}\x1b[0m`; // Red for deletions
+            }
+            else if (line.startsWith('@')) {
+                return `\x1b[36m${line}\x1b[0m`; // Cyan for line numbers
+            }
+            else {
+                return line;
+            }
+        });
+        return coloredLines.join('\n');
+    }
+    async saveDiffReport(outputPath) {
+        const report = {
+            timestamp: new Date().toISOString(),
+            totalFiles: this.diffs.size,
+            diffs: Array.from(this.diffs.entries()).map(([path, diff]) => ({
+                path,
+                diff
+            }))
+        };
+        await plugins.smartfile.memory.toFs(JSON.stringify(report, null, 2), outputPath);
+        logger.log('info', `Diff report saved to ${outputPath}`);
+    }
+    hasAnyDiffs() {
+        return this.diffs.size > 0;
+    }
+    getDiffCount() {
+        return this.diffs.size;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_format/classes.formatcontext.d.ts

@@ -0,0 +1,19 @@
+import { RollbackManager } from './classes.rollbackmanager.js';
+import { ChangeCache } from './classes.changecache.js';
+import { FormatStats } from './classes.formatstats.js';
+export declare class FormatContext {
+    private rollbackManager;
+    private currentOperation;
+    private changeCache;
+    private formatStats;
+    constructor();
+    beginOperation(): Promise<void>;
+    trackFileChange(filepath: string): Promise<void>;
+    commitOperation(): Promise<void>;
+    rollbackOperation(): Promise<void>;
+    rollbackTo(operationId: string): Promise<void>;
+    getRollbackManager(): RollbackManager;
+    getChangeCache(): ChangeCache;
+    initializeCache(): Promise<void>;
+    getFormatStats(): FormatStats;
+}

package/dist_ts/mod_format/classes.formatcontext.js

@@ -0,0 +1,51 @@
+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';
+export class FormatContext {
+    constructor() {
+        this.currentOperation = null;
+        this.rollbackManager = new RollbackManager();
+        this.changeCache = new ChangeCache();
+        this.formatStats = new FormatStats();
+    }
+    async beginOperation() {
+        this.currentOperation = await this.rollbackManager.createOperation();
+    }
+    async trackFileChange(filepath) {
+        if (!this.currentOperation) {
+            throw new Error('No operation in progress. Call beginOperation() first.');
+        }
+        await this.rollbackManager.backupFile(filepath, this.currentOperation.id);
+    }
+    async commitOperation() {
+        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() {
+        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) {
+        await this.rollbackManager.rollback(operationId);
+    }
+    getRollbackManager() {
+        return this.rollbackManager;
+    }
+    getChangeCache() {
+        return this.changeCache;
+    }
+    async initializeCache() {
+        await this.changeCache.initialize();
+    }
+    getFormatStats() {
+        return this.formatStats;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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