@git.zone/cli 1.15.5 → 1.16.1

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

@@ -0,0 +1,13 @@
+import { FormatContext } from './classes.formatcontext.js';
+import { BaseFormatter } from './classes.baseformatter.js';
+import type { IFormatPlan } from './interfaces.format.js';
+export declare class FormatPlanner {
+    private plannedChanges;
+    private dependencyAnalyzer;
+    private diffReporter;
+    planFormat(modules: BaseFormatter[]): Promise<IFormatPlan>;
+    executePlan(plan: IFormatPlan, modules: BaseFormatter[], context: FormatContext, parallel?: boolean): Promise<void>;
+    displayPlan(plan: IFormatPlan, detailed?: boolean): Promise<void>;
+    private getModuleIcon;
+    private getChangeIcon;
+}

package/dist_ts/mod_format/classes.formatplanner.js

@@ -0,0 +1,164 @@
+import * as plugins from './mod.plugins.js';
+import { FormatContext } from './classes.formatcontext.js';
+import { BaseFormatter } from './classes.baseformatter.js';
+import { logger } from '../gitzone.logging.js';
+import { DependencyAnalyzer } from './classes.dependency-analyzer.js';
+import { DiffReporter } from './classes.diffreporter.js';
+export class FormatPlanner {
+    constructor() {
+        this.plannedChanges = new Map();
+        this.dependencyAnalyzer = new DependencyAnalyzer();
+        this.diffReporter = new DiffReporter();
+    }
+    async planFormat(modules) {
+        const plan = {
+            summary: {
+                totalFiles: 0,
+                filesAdded: 0,
+                filesModified: 0,
+                filesRemoved: 0,
+                estimatedTime: 0
+            },
+            changes: [],
+            warnings: []
+        };
+        for (const module of modules) {
+            try {
+                const changes = await module.analyze();
+                this.plannedChanges.set(module.name, changes);
+                for (const change of changes) {
+                    plan.changes.push(change);
+                    // Update summary
+                    switch (change.type) {
+                        case 'create':
+                            plan.summary.filesAdded++;
+                            break;
+                        case 'modify':
+                            plan.summary.filesModified++;
+                            break;
+                        case 'delete':
+                            plan.summary.filesRemoved++;
+                            break;
+                    }
+                }
+            }
+            catch (error) {
+                plan.warnings.push({
+                    level: 'error',
+                    message: `Failed to analyze module ${module.name}: ${error.message}`,
+                    module: module.name
+                });
+            }
+        }
+        plan.summary.totalFiles = plan.summary.filesAdded + plan.summary.filesModified + plan.summary.filesRemoved;
+        plan.summary.estimatedTime = plan.summary.totalFiles * 100; // 100ms per file estimate
+        return plan;
+    }
+    async executePlan(plan, modules, context, parallel = true) {
+        await context.beginOperation();
+        const startTime = Date.now();
+        try {
+            if (parallel) {
+                // Get execution groups based on dependencies
+                const executionGroups = this.dependencyAnalyzer.getExecutionGroups(modules);
+                logger.log('info', `Executing formatters in ${executionGroups.length} groups...`);
+                for (let i = 0; i < executionGroups.length; i++) {
+                    const group = executionGroups[i];
+                    logger.log('info', `Executing group ${i + 1}: ${group.map(m => m.name).join(', ')}`);
+                    // Execute modules in this group in parallel
+                    const promises = group.map(async (module) => {
+                        const changes = this.plannedChanges.get(module.name) || [];
+                        if (changes.length > 0) {
+                            logger.log('info', `Executing ${module.name} formatter...`);
+                            await module.execute(changes);
+                        }
+                    });
+                    await Promise.all(promises);
+                }
+            }
+            else {
+                // Sequential execution (original implementation)
+                for (const module of modules) {
+                    const changes = this.plannedChanges.get(module.name) || [];
+                    if (changes.length > 0) {
+                        logger.log('info', `Executing ${module.name} formatter...`);
+                        await module.execute(changes);
+                    }
+                }
+            }
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            logger.log('info', `Format operations completed in ${duration}ms`);
+            await context.commitOperation();
+        }
+        catch (error) {
+            await context.rollbackOperation();
+            throw error;
+        }
+    }
+    async displayPlan(plan, detailed = false) {
+        console.log('\nFormat Plan:');
+        console.log('━'.repeat(50));
+        console.log(`Summary: ${plan.summary.totalFiles} files will be changed`);
+        console.log(`  • ${plan.summary.filesAdded} new files`);
+        console.log(`  • ${plan.summary.filesModified} modified files`);
+        console.log(`  • ${plan.summary.filesRemoved} deleted files`);
+        console.log('');
+        console.log('Changes by module:');
+        // Group changes by module
+        const changesByModule = new Map();
+        for (const change of plan.changes) {
+            const moduleChanges = changesByModule.get(change.module) || [];
+            moduleChanges.push(change);
+            changesByModule.set(change.module, moduleChanges);
+        }
+        for (const [module, changes] of changesByModule) {
+            console.log(`\n${this.getModuleIcon(module)} ${module} (${changes.length} ${changes.length === 1 ? 'file' : 'files'})`);
+            for (const change of changes) {
+                const icon = this.getChangeIcon(change.type);
+                console.log(`  ${icon} ${change.path} - ${change.description}`);
+                // Show diff for modified files if detailed view is requested
+                if (detailed && change.type === 'modify') {
+                    const diff = await this.diffReporter.generateDiffForChange(change);
+                    if (diff) {
+                        this.diffReporter.displayDiff(change.path, diff);
+                    }
+                }
+            }
+        }
+        if (plan.warnings.length > 0) {
+            console.log('\nWarnings:');
+            for (const warning of plan.warnings) {
+                const icon = warning.level === 'error' ? '❌' : '⚠️';
+                console.log(`  ${icon} ${warning.message}`);
+            }
+        }
+        console.log('\n' + '━'.repeat(50));
+    }
+    getModuleIcon(module) {
+        const icons = {
+            'packagejson': '📦',
+            'license': '📝',
+            'tsconfig': '🔧',
+            'cleanup': '🚮',
+            'gitignore': '🔒',
+            'prettier': '✨',
+            'readme': '📖',
+            'templates': '📄',
+            'npmextra': '⚙️',
+            'copy': '📋'
+        };
+        return icons[module] || '📁';
+    }
+    getChangeIcon(type) {
+        switch (type) {
+            case 'create':
+                return '✅';
+            case 'modify':
+                return '✏️';
+            case 'delete':
+                return '❌';
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.formatplanner.js","sourceRoot":"","sources":["../../ts/mod_format/classes.formatplanner.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,40 @@
+export interface IModuleStats {
+    name: string;
+    filesProcessed: number;
+    executionTime: number;
+    errors: number;
+    successes: number;
+    filesCreated: number;
+    filesModified: number;
+    filesDeleted: number;
+}
+export interface IFormatStats {
+    totalExecutionTime: number;
+    startTime: number;
+    endTime: number;
+    moduleStats: Map<string, IModuleStats>;
+    overallStats: {
+        totalFiles: number;
+        totalCreated: number;
+        totalModified: number;
+        totalDeleted: number;
+        totalErrors: number;
+        cacheHits: number;
+        cacheMisses: number;
+    };
+}
+export declare class FormatStats {
+    private stats;
+    constructor();
+    startModule(moduleName: string): void;
+    moduleStartTime(moduleName: string): number;
+    endModule(moduleName: string, startTime: number): void;
+    recordFileOperation(moduleName: string, operation: 'create' | 'modify' | 'delete', success?: boolean): void;
+    recordCacheHit(): void;
+    recordCacheMiss(): void;
+    finish(): void;
+    displayStats(): void;
+    saveReport(outputPath: string): Promise<void>;
+    private formatDuration;
+    private getModuleIcon;
+}

package/dist_ts/mod_format/classes.formatstats.js

@@ -0,0 +1,161 @@
+import * as plugins from './mod.plugins.js';
+import { logger } from '../gitzone.logging.js';
+export class FormatStats {
+    constructor() {
+        this.stats = {
+            totalExecutionTime: 0,
+            startTime: Date.now(),
+            endTime: 0,
+            moduleStats: new Map(),
+            overallStats: {
+                totalFiles: 0,
+                totalCreated: 0,
+                totalModified: 0,
+                totalDeleted: 0,
+                totalErrors: 0,
+                cacheHits: 0,
+                cacheMisses: 0
+            }
+        };
+    }
+    startModule(moduleName) {
+        this.stats.moduleStats.set(moduleName, {
+            name: moduleName,
+            filesProcessed: 0,
+            executionTime: 0,
+            errors: 0,
+            successes: 0,
+            filesCreated: 0,
+            filesModified: 0,
+            filesDeleted: 0
+        });
+    }
+    moduleStartTime(moduleName) {
+        return Date.now();
+    }
+    endModule(moduleName, startTime) {
+        const moduleStats = this.stats.moduleStats.get(moduleName);
+        if (moduleStats) {
+            moduleStats.executionTime = Date.now() - startTime;
+        }
+    }
+    recordFileOperation(moduleName, operation, success = true) {
+        const moduleStats = this.stats.moduleStats.get(moduleName);
+        if (!moduleStats)
+            return;
+        moduleStats.filesProcessed++;
+        if (success) {
+            moduleStats.successes++;
+            this.stats.overallStats.totalFiles++;
+            switch (operation) {
+                case 'create':
+                    moduleStats.filesCreated++;
+                    this.stats.overallStats.totalCreated++;
+                    break;
+                case 'modify':
+                    moduleStats.filesModified++;
+                    this.stats.overallStats.totalModified++;
+                    break;
+                case 'delete':
+                    moduleStats.filesDeleted++;
+                    this.stats.overallStats.totalDeleted++;
+                    break;
+            }
+        }
+        else {
+            moduleStats.errors++;
+            this.stats.overallStats.totalErrors++;
+        }
+    }
+    recordCacheHit() {
+        this.stats.overallStats.cacheHits++;
+    }
+    recordCacheMiss() {
+        this.stats.overallStats.cacheMisses++;
+    }
+    finish() {
+        this.stats.endTime = Date.now();
+        this.stats.totalExecutionTime = this.stats.endTime - this.stats.startTime;
+    }
+    displayStats() {
+        console.log('\n📊 Format Operation Statistics:');
+        console.log('═'.repeat(50));
+        // Overall stats
+        console.log('\nOverall Summary:');
+        console.log(`  Total Execution Time: ${this.formatDuration(this.stats.totalExecutionTime)}`);
+        console.log(`  Files Processed: ${this.stats.overallStats.totalFiles}`);
+        console.log(`    • Created: ${this.stats.overallStats.totalCreated}`);
+        console.log(`    • Modified: ${this.stats.overallStats.totalModified}`);
+        console.log(`    • Deleted: ${this.stats.overallStats.totalDeleted}`);
+        console.log(`  Errors: ${this.stats.overallStats.totalErrors}`);
+        if (this.stats.overallStats.cacheHits > 0 || this.stats.overallStats.cacheMisses > 0) {
+            const cacheHitRate = this.stats.overallStats.cacheHits /
+                (this.stats.overallStats.cacheHits + this.stats.overallStats.cacheMisses) * 100;
+            console.log(`  Cache Hit Rate: ${cacheHitRate.toFixed(1)}%`);
+            console.log(`    • Hits: ${this.stats.overallStats.cacheHits}`);
+            console.log(`    • Misses: ${this.stats.overallStats.cacheMisses}`);
+        }
+        // Module stats
+        console.log('\nModule Breakdown:');
+        console.log('─'.repeat(50));
+        const sortedModules = Array.from(this.stats.moduleStats.values())
+            .sort((a, b) => b.filesProcessed - a.filesProcessed);
+        for (const moduleStats of sortedModules) {
+            console.log(`\n${this.getModuleIcon(moduleStats.name)} ${moduleStats.name}:`);
+            console.log(`  Execution Time: ${this.formatDuration(moduleStats.executionTime)}`);
+            console.log(`  Files Processed: ${moduleStats.filesProcessed}`);
+            if (moduleStats.filesCreated > 0) {
+                console.log(`    • Created: ${moduleStats.filesCreated}`);
+            }
+            if (moduleStats.filesModified > 0) {
+                console.log(`    • Modified: ${moduleStats.filesModified}`);
+            }
+            if (moduleStats.filesDeleted > 0) {
+                console.log(`    • Deleted: ${moduleStats.filesDeleted}`);
+            }
+            if (moduleStats.errors > 0) {
+                console.log(`  ❌ Errors: ${moduleStats.errors}`);
+            }
+        }
+        console.log('\n' + '═'.repeat(50));
+    }
+    async saveReport(outputPath) {
+        const report = {
+            timestamp: new Date().toISOString(),
+            executionTime: this.stats.totalExecutionTime,
+            overallStats: this.stats.overallStats,
+            moduleStats: Array.from(this.stats.moduleStats.values())
+        };
+        await plugins.smartfile.memory.toFs(JSON.stringify(report, null, 2), outputPath);
+        logger.log('info', `Statistics report saved to ${outputPath}`);
+    }
+    formatDuration(ms) {
+        if (ms < 1000) {
+            return `${ms}ms`;
+        }
+        else if (ms < 60000) {
+            return `${(ms / 1000).toFixed(1)}s`;
+        }
+        else {
+            const minutes = Math.floor(ms / 60000);
+            const seconds = Math.floor((ms % 60000) / 1000);
+            return `${minutes}m ${seconds}s`;
+        }
+    }
+    getModuleIcon(module) {
+        const icons = {
+            'packagejson': '📦',
+            'license': '📝',
+            'tsconfig': '🔧',
+            'cleanup': '🚮',
+            'gitignore': '🔒',
+            'prettier': '✨',
+            'readme': '📖',
+            'templates': '📄',
+            'npmextra': '⚙️',
+            'copy': '📋'
+        };
+        return icons[module] || '📁';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+import type { IFormatOperation } from './interfaces.format.js';
+export declare class RollbackManager {
+    private backupDir;
+    private manifestPath;
+    constructor();
+    createOperation(): Promise<IFormatOperation>;
+    backupFile(filepath: string, operationId: string): Promise<void>;
+    rollback(operationId: string): Promise<void>;
+    markComplete(operationId: string): Promise<void>;
+    cleanOldBackups(retentionDays: number): Promise<void>;
+    verifyBackup(operationId: string): Promise<boolean>;
+    listBackups(): Promise<IFormatOperation[]>;
+    private ensureBackupDir;
+    private generateOperationId;
+    private getBackupPath;
+    private calculateChecksum;
+    private getManifest;
+    private saveManifest;
+    private getOperation;
+    private updateManifest;
+}

package/dist_ts/mod_format/classes.rollbackmanager.js

@@ -0,0 +1,170 @@
+import * as plugins from './mod.plugins.js';
+import * as paths from '../paths.js';
+export class RollbackManager {
+    constructor() {
+        this.backupDir = plugins.path.join(paths.cwd, '.nogit', 'gitzone-backups');
+        this.manifestPath = plugins.path.join(this.backupDir, 'manifest.json');
+    }
+    async createOperation() {
+        await this.ensureBackupDir();
+        const operation = {
+            id: this.generateOperationId(),
+            timestamp: Date.now(),
+            files: [],
+            status: 'pending'
+        };
+        await this.updateManifest(operation);
+        return operation;
+    }
+    async backupFile(filepath, operationId) {
+        const operation = await this.getOperation(operationId);
+        if (!operation) {
+            throw new Error(`Operation ${operationId} not found`);
+        }
+        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 = await 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)
+        });
+        await this.updateManifest(operation);
+    }
+    async rollback(operationId) {
+        const operation = await this.getOperation(operationId);
+        if (!operation) {
+            throw new Error(`Operation ${operationId} not found`);
+        }
+        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
+                : plugins.path.join(paths.cwd, file.path);
+            // Verify backup integrity
+            const backupPath = this.getBackupPath(operationId, file.path);
+            const backupContent = await 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) {
+        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) {
+        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');
+        for (const operation of operationsToDelete) {
+            // Remove backup files
+            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);
+        }
+        await this.saveManifest(manifest);
+    }
+    async verifyBackup(operationId) {
+        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 = await plugins.smartfile.fs.toStringSync(backupPath);
+            const checksum = this.calculateChecksum(content);
+            if (checksum !== file.checksum) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async listBackups() {
+        const manifest = await this.getManifest();
+        return manifest.operations;
+    }
+    async ensureBackupDir() {
+        await plugins.smartfile.fs.ensureDir(this.backupDir);
+        await plugins.smartfile.fs.ensureDir(plugins.path.join(this.backupDir, 'operations'));
+    }
+    generateOperationId() {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const random = Math.random().toString(36).substring(2, 8);
+        return `${timestamp}-${random}`;
+    }
+    getBackupPath(operationId, filepath) {
+        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`);
+    }
+    calculateChecksum(content) {
+        return plugins.crypto.createHash('sha256').update(content).digest('hex');
+    }
+    async getManifest() {
+        const exists = await plugins.smartfile.fs.fileExists(this.manifestPath);
+        if (!exists) {
+            return { operations: [] };
+        }
+        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 getOperation(operationId) {
+        const manifest = await this.getManifest();
+        return manifest.operations.find(op => op.id === operationId) || null;
+    }
+    async updateManifest(operation) {
+        const manifest = await this.getManifest();
+        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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rollbackmanager.js","sourceRoot":"","sources":["../../ts/mod_format/classes.rollbackmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_format/format.copy.d.ts

@@ -1,2 +1,24 @@
 import type { Project } from '../classes.project.js';
 export declare const run: (projectArg: Project) => Promise<void>;
+/**
+ * Example npmextra.json configuration:
+ * {
+ *   "gitzone": {
+ *     "format": {
+ *       "copy": {
+ *         "patterns": [
+ *           {
+ *             "from": "src/assets/*",
+ *             "to": "dist/assets/",
+ *             "preservePath": true
+ *           },
+ *           {
+ *             "from": "config/*.json",
+ *             "to": "dist/"
+ *           }
+ *         ]
+ *       }
+ *     }
+ *   }
+ * }
+ */