@eldrforge/kodrdriv 0.0.41 → 0.0.43

package/dist/commands/commit-tree.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+import path from 'path';
+import fs from 'fs/promises';
+import { getLogger } from '../logging.js';
+import { create } from '../util/storage.js';
+import { run } from '../util/child.js';
+import { execute as execute$1 } from './commit.js';
+import { safeJsonParse, validatePackageJson } from '../util/validation.js';
+
+// Create a package-scoped logger that prefixes all messages
+const createPackageLogger = (packageName, sequenceNumber, totalCount, isDryRun = false)=>{
+    const baseLogger = getLogger();
+    const prefix = `[${sequenceNumber}/${totalCount}] ${packageName}:`;
+    const dryRunPrefix = isDryRun ? 'DRY RUN: ' : '';
+    return {
+        info: (message, ...args)=>baseLogger.info(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        warn: (message, ...args)=>baseLogger.warn(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        error: (message, ...args)=>baseLogger.error(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        debug: (message, ...args)=>baseLogger.debug(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        verbose: (message, ...args)=>baseLogger.verbose(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        silly: (message, ...args)=>baseLogger.silly(`${dryRunPrefix}${prefix} ${message}`, ...args)
+    };
+};
+// Execute an operation with package context logging for nested operations
+const withPackageContext = async (packageName, sequenceNumber, totalCount, isDryRun, operation)=>{
+    const packageLogger = createPackageLogger(packageName, sequenceNumber, totalCount, isDryRun);
+    try {
+        packageLogger.verbose(`Starting nested operation...`);
+        const result = await operation();
+        packageLogger.verbose(`Nested operation completed`);
+        return result;
+    } catch (error) {
+        packageLogger.error(`Nested operation failed: ${error.message}`);
+        throw error;
+    }
+};
+// Helper function to format subproject error output
+const formatSubprojectError = (packageName, error)=>{
+    const lines = [];
+    lines.push(`❌ Command failed in package ${packageName}:`);
+    // Format the main error message with indentation
+    if (error.message) {
+        const indentedMessage = error.message.split('\n').map((line)=>`    ${line}`).join('\n');
+        lines.push(indentedMessage);
+    }
+    // If there's stderr output, show it indented as well
+    if (error.stderr && error.stderr.trim()) {
+        lines.push('    STDERR:');
+        const indentedStderr = error.stderr.split('\n').filter((line)=>line.trim()).map((line)=>`      ${line}`).join('\n');
+        lines.push(indentedStderr);
+    }
+    // If there's stdout output, show it indented as well
+    if (error.stdout && error.stdout.trim()) {
+        lines.push('    STDOUT:');
+        const indentedStdout = error.stdout.split('\n').filter((line)=>line.trim()).map((line)=>`      ${line}`).join('\n');
+        lines.push(indentedStdout);
+    }
+    return lines.join('\n');
+};
+const matchesPattern = (filePath, pattern)=>{
+    // Convert simple glob patterns to regex
+    const regexPattern = pattern.replace(/\\/g, '\\\\') // Escape backslashes
+    .replace(/\*\*/g, '.*') // ** matches any path segments
+    .replace(/\*/g, '[^/]*') // * matches any characters except path separator
+    .replace(/\?/g, '.') // ? matches any single character
+    .replace(/\./g, '\\.'); // Escape literal dots
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(filePath) || regex.test(path.basename(filePath));
+};
+const shouldExclude = (packageJsonPath, excludedPatterns)=>{
+    if (!excludedPatterns || excludedPatterns.length === 0) {
+        return false;
+    }
+    // Check both the full path and relative path patterns
+    const relativePath = path.relative(process.cwd(), packageJsonPath);
+    return excludedPatterns.some((pattern)=>matchesPattern(packageJsonPath, pattern) || matchesPattern(relativePath, pattern) || matchesPattern(path.dirname(packageJsonPath), pattern) || matchesPattern(path.dirname(relativePath), pattern));
+};
+const scanForPackageJsonFiles = async (directory, excludedPatterns = [])=>{
+    const logger = getLogger();
+    const packageJsonPaths = [];
+    try {
+        const entries = await fs.readdir(directory, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isDirectory()) {
+                const subDirPath = path.join(directory, entry.name);
+                const packageJsonPath = path.join(subDirPath, 'package.json');
+                try {
+                    await fs.access(packageJsonPath);
+                    // Check if this package should be excluded
+                    if (shouldExclude(packageJsonPath, excludedPatterns)) {
+                        logger.verbose(`Excluding package.json at: ${packageJsonPath} (matches exclusion pattern)`);
+                        continue;
+                    }
+                    packageJsonPaths.push(packageJsonPath);
+                    logger.verbose(`Found package.json at: ${packageJsonPath}`);
+                } catch  {
+                // No package.json in this directory, continue
+                }
+            }
+        }
+    } catch (error) {
+        logger.error(`Failed to scan directory ${directory}: ${error}`);
+        throw error;
+    }
+    return packageJsonPaths;
+};
+const parsePackageJson = async (packageJsonPath)=>{
+    const logger = getLogger();
+    const storage = create({
+        log: logger.info
+    });
+    try {
+        const content = await storage.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(content, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        if (!packageJson.name) {
+            throw new Error(`Package at ${packageJsonPath} has no name field`);
+        }
+        const dependencies = new Set();
+        // Collect all types of dependencies
+        const depTypes = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies'
+        ];
+        for (const depType of depTypes){
+            if (packageJson[depType]) {
+                Object.keys(packageJson[depType]).forEach((dep)=>dependencies.add(dep));
+            }
+        }
+        return {
+            name: packageJson.name,
+            version: packageJson.version || '0.0.0',
+            path: path.dirname(packageJsonPath),
+            dependencies,
+            localDependencies: new Set() // Will be populated later
+        };
+    } catch (error) {
+        logger.error(`Failed to parse package.json at ${packageJsonPath}: ${error}`);
+        throw error;
+    }
+};
+const buildDependencyGraph = async (packageJsonPaths)=>{
+    const logger = getLogger();
+    const packages = new Map();
+    const edges = new Map();
+    // First pass: parse all package.json files
+    for (const packageJsonPath of packageJsonPaths){
+        const packageInfo = await parsePackageJson(packageJsonPath);
+        packages.set(packageInfo.name, packageInfo);
+        logger.verbose(`Parsed package: ${packageInfo.name} at ${packageInfo.path}`);
+    }
+    // Second pass: identify local dependencies and build edges
+    for (const [packageName, packageInfo] of packages){
+        const localDeps = new Set();
+        const edges_set = new Set();
+        for (const dep of packageInfo.dependencies){
+            if (packages.has(dep)) {
+                localDeps.add(dep);
+                edges_set.add(dep);
+                logger.verbose(`${packageName} depends on local package: ${dep}`);
+            }
+        }
+        packageInfo.localDependencies = localDeps;
+        edges.set(packageName, edges_set);
+    }
+    return {
+        packages,
+        edges
+    };
+};
+const topologicalSort = (graph)=>{
+    const logger = getLogger();
+    const { packages, edges } = graph;
+    const visited = new Set();
+    const visiting = new Set();
+    const result = [];
+    const visit = (packageName)=>{
+        if (visited.has(packageName)) {
+            return;
+        }
+        if (visiting.has(packageName)) {
+            throw new Error(`Circular dependency detected involving package: ${packageName}`);
+        }
+        visiting.add(packageName);
+        // Visit all dependencies first
+        const deps = edges.get(packageName) || new Set();
+        for (const dep of deps){
+            visit(dep);
+        }
+        visiting.delete(packageName);
+        visited.add(packageName);
+        result.push(packageName);
+    };
+    // Visit all packages
+    for (const packageName of packages.keys()){
+        if (!visited.has(packageName)) {
+            visit(packageName);
+        }
+    }
+    logger.verbose(`Topological sort completed. Build order determined for ${result.length} packages.`);
+    return result;
+};
+// Group packages into dependency levels for parallel execution
+const groupPackagesByDependencyLevels = (graph, buildOrder)=>{
+    const logger = getLogger();
+    const { edges } = graph;
+    const levels = [];
+    const packageLevels = new Map();
+    // Calculate the dependency level for each package
+    const calculateLevel = (packageName)=>{
+        if (packageLevels.has(packageName)) {
+            return packageLevels.get(packageName);
+        }
+        const deps = edges.get(packageName) || new Set();
+        if (deps.size === 0) {
+            // No dependencies - this is level 0
+            packageLevels.set(packageName, 0);
+            return 0;
+        }
+        // Level is 1 + max level of dependencies
+        let maxDepLevel = -1;
+        for (const dep of deps){
+            const depLevel = calculateLevel(dep);
+            maxDepLevel = Math.max(maxDepLevel, depLevel);
+        }
+        const level = maxDepLevel + 1;
+        packageLevels.set(packageName, level);
+        return level;
+    };
+    // Calculate levels for all packages
+    for (const packageName of buildOrder){
+        calculateLevel(packageName);
+    }
+    // Group packages by their levels
+    for (const packageName of buildOrder){
+        const level = packageLevels.get(packageName);
+        while(levels.length <= level){
+            levels.push([]);
+        }
+        levels[level].push(packageName);
+    }
+    logger.verbose(`Packages grouped into ${levels.length} dependency levels for parallel execution`);
+    for(let i = 0; i < levels.length; i++){
+        logger.verbose(`  Level ${i}: ${levels[i].join(', ')}`);
+    }
+    return levels;
+};
+// Execute commit operations for a single package
+const executeCommitForPackage = async (packageName, packageInfo, runConfig, isDryRun, index, total)=>{
+    const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
+    const packageDir = packageInfo.path;
+    packageLogger.info(`Starting commit operations...`);
+    packageLogger.verbose(`Working directory: ${packageDir}`);
+    try {
+        if (isDryRun) {
+            packageLogger.info(`Would execute: git add -A`);
+            packageLogger.info(`Would execute: kodrdriv commit`);
+            packageLogger.info(`In directory: ${packageDir}`);
+        } else {
+            // Change to the package directory and run the commands
+            const originalCwd = process.cwd();
+            try {
+                process.chdir(packageDir);
+                packageLogger.verbose(`Changed to directory: ${packageDir}`);
+                // Step 1: Add all changes
+                packageLogger.info(`Adding all changes to git...`);
+                await withPackageContext(packageName, index + 1, total, isDryRun, async ()=>{
+                    await run('git add -A');
+                });
+                packageLogger.verbose(`Git add completed`);
+                // Step 2: Run commit command
+                packageLogger.info(`Running commit command...`);
+                await withPackageContext(packageName, index + 1, total, isDryRun, async ()=>{
+                    await execute$1(runConfig);
+                });
+                packageLogger.info(`Commit completed successfully`);
+                packageLogger.info(`✅ All commit operations completed successfully`);
+            } finally{
+                process.chdir(originalCwd);
+                packageLogger.verbose(`Restored working directory to: ${originalCwd}`);
+            }
+        }
+        return {
+            success: true
+        };
+    } catch (error) {
+        packageLogger.error(`❌ Commit operations failed: ${error.message}`);
+        return {
+            success: false,
+            error
+        };
+    }
+};
+const execute = async (runConfig)=>{
+    var _runConfig_commitTree;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    // Determine the target directory - either specified or current working directory
+    const targetDirectory = ((_runConfig_commitTree = runConfig.commitTree) === null || _runConfig_commitTree === void 0 ? void 0 : _runConfig_commitTree.directory) || process.cwd();
+    logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspace for commit operations at: ${targetDirectory}`);
+    try {
+        var _runConfig_commitTree1, _runConfig_commitTree2, _runConfig_commitTree3;
+        // Get exclusion patterns from config, fallback to empty array
+        const excludedPatterns = ((_runConfig_commitTree1 = runConfig.commitTree) === null || _runConfig_commitTree1 === void 0 ? void 0 : _runConfig_commitTree1.excludedPatterns) || [];
+        if (excludedPatterns.length > 0) {
+            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
+        }
+        // Scan for package.json files
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Scanning for package.json files...`);
+        const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+        if (packageJsonPaths.length === 0) {
+            const message = `No package.json files found in subdirectories of ${targetDirectory}`;
+            logger.warn(message);
+            return message;
+        }
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Found ${packageJsonPaths.length} package.json files`);
+        // Build dependency graph
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Building dependency graph...`);
+        const dependencyGraph = await buildDependencyGraph(packageJsonPaths);
+        // Perform topological sort to determine build order
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Determining build order...`);
+        let buildOrder = topologicalSort(dependencyGraph);
+        // Handle start-from functionality if specified
+        const startFrom = (_runConfig_commitTree2 = runConfig.commitTree) === null || _runConfig_commitTree2 === void 0 ? void 0 : _runConfig_commitTree2.startFrom;
+        if (startFrom) {
+            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for start package: ${startFrom}`);
+            // Find the package that matches the startFrom directory name
+            const startIndex = buildOrder.findIndex((packageName)=>{
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const dirName = path.basename(packageInfo.path);
+                return dirName === startFrom || packageName === startFrom;
+            });
+            if (startIndex === -1) {
+                const availablePackages = buildOrder.map((name)=>{
+                    const packageInfo = dependencyGraph.packages.get(name);
+                    return `${path.basename(packageInfo.path)} (${name})`;
+                }).join(', ');
+                throw new Error(`Package directory '${startFrom}' not found. Available packages: ${availablePackages}`);
+            }
+            const skippedCount = startIndex;
+            buildOrder = buildOrder.slice(startIndex);
+            if (skippedCount > 0) {
+                logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Resuming from '${startFrom}' - skipping ${skippedCount} package${skippedCount === 1 ? '' : 's'}`);
+            }
+        }
+        // Display results
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Build order determined for commit operations:`);
+        let output = `\nCommit Order for ${buildOrder.length} packages${startFrom ? ` (starting from ${startFrom})` : ''}:\n`;
+        output += '======================================\n\n';
+        buildOrder.forEach((packageName, index)=>{
+            const packageInfo = dependencyGraph.packages.get(packageName);
+            const localDeps = Array.from(packageInfo.localDependencies);
+            output += `${index + 1}. ${packageName} (${packageInfo.version})\n`;
+            output += `   Path: ${packageInfo.path}\n`;
+            if (localDeps.length > 0) {
+                output += `   Local Dependencies: ${localDeps.join(', ')}\n`;
+            } else {
+                output += `   Local Dependencies: none\n`;
+            }
+            output += '\n';
+            // Log each step
+            if (localDeps.length > 0) {
+                logger.info(`${index + 1}. ${packageName} (depends on: ${localDeps.join(', ')})`);
+            } else {
+                logger.info(`${index + 1}. ${packageName} (no local dependencies)`);
+            }
+        });
+        // Execute commit operations
+        const useParallel = ((_runConfig_commitTree3 = runConfig.commitTree) === null || _runConfig_commitTree3 === void 0 ? void 0 : _runConfig_commitTree3.parallel) || false;
+        const parallelInfo = useParallel ? ' (with parallel execution)' : '';
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running commit operations (git add -A + kodrdriv commit) in ${buildOrder.length} packages${parallelInfo}...`);
+        let successCount = 0;
+        let failedPackage = null;
+        if (useParallel) {
+            // Parallel execution: group packages by dependency levels
+            const dependencyLevels = groupPackagesByDependencyLevels(dependencyGraph, buildOrder);
+            for(let levelIndex = 0; levelIndex < dependencyLevels.length; levelIndex++){
+                const currentLevel = dependencyLevels[levelIndex];
+                if (currentLevel.length === 1) {
+                    const packageName = currentLevel[0];
+                    logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Level ${levelIndex + 1}: Executing commit operations for ${packageName}...`);
+                } else {
+                    logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Level ${levelIndex + 1}: Executing commit operations for ${currentLevel.length} packages in parallel: ${currentLevel.join(', ')}...`);
+                }
+                // Execute all packages in this level in parallel
+                const levelPromises = currentLevel.map((packageName)=>{
+                    const packageInfo = dependencyGraph.packages.get(packageName);
+                    const globalIndex = buildOrder.indexOf(packageName);
+                    return executeCommitForPackage(packageName, packageInfo, runConfig, isDryRun, globalIndex, buildOrder.length);
+                });
+                // Wait for all packages in this level to complete
+                const results = await Promise.allSettled(levelPromises);
+                // Check results and handle errors
+                for(let i = 0; i < results.length; i++){
+                    const result = results[i];
+                    const packageName = currentLevel[i];
+                    const globalIndex = buildOrder.indexOf(packageName);
+                    const packageLogger = createPackageLogger(packageName, globalIndex + 1, buildOrder.length, isDryRun);
+                    if (result.status === 'fulfilled') {
+                        if (result.value.success) {
+                            successCount++;
+                        } else {
+                            // Package failed
+                            failedPackage = packageName;
+                            const formattedError = formatSubprojectError(packageName, result.value.error);
+                            if (!isDryRun) {
+                                packageLogger.error(`Commit operations failed`);
+                                logger.error(formattedError);
+                                logger.error(`Failed after ${successCount} successful packages.`);
+                                const packageDir = dependencyGraph.packages.get(packageName).path;
+                                const packageDirName = path.basename(packageDir);
+                                logger.error(`To resume from this package, run:`);
+                                logger.error(`    kodrdriv commit-tree --start-from ${packageDirName}`);
+                                throw new Error(`Commit operations failed in package ${packageName}`);
+                            }
+                            break;
+                        }
+                    } else {
+                        // Promise was rejected
+                        failedPackage = packageName;
+                        if (!isDryRun) {
+                            packageLogger.error(`Unexpected error: ${result.reason}`);
+                            logger.error(`Failed after ${successCount} successful packages.`);
+                            const packageDir = dependencyGraph.packages.get(packageName).path;
+                            const packageDirName = path.basename(packageDir);
+                            logger.error(`To resume from this package, run:`);
+                            logger.error(`    kodrdriv commit-tree --start-from ${packageDirName}`);
+                            throw new Error(`Unexpected error in package ${packageName}`);
+                        }
+                        break;
+                    }
+                }
+                // If any package failed, stop execution
+                if (failedPackage) {
+                    break;
+                }
+                if (currentLevel.length > 1) {
+                    logger.info(`✅ Level ${levelIndex + 1} completed: all ${currentLevel.length} packages finished successfully`);
+                } else if (currentLevel.length === 1 && successCount > 0) {
+                    const packageName = currentLevel[0];
+                    const globalIndex = buildOrder.indexOf(packageName);
+                    const packageLogger = createPackageLogger(packageName, globalIndex + 1, buildOrder.length, isDryRun);
+                    packageLogger.info(`✅ Level ${levelIndex + 1} completed successfully`);
+                }
+            }
+        } else {
+            // Sequential execution
+            for(let i = 0; i < buildOrder.length; i++){
+                const packageName = buildOrder[i];
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const packageLogger = createPackageLogger(packageName, i + 1, buildOrder.length, isDryRun);
+                const result = await executeCommitForPackage(packageName, packageInfo, runConfig, isDryRun, i, buildOrder.length);
+                if (result.success) {
+                    successCount++;
+                } else {
+                    failedPackage = packageName;
+                    const formattedError = formatSubprojectError(packageName, result.error);
+                    if (!isDryRun) {
+                        packageLogger.error(`Commit operations failed`);
+                        logger.error(formattedError);
+                        logger.error(`Failed after ${successCount} successful packages.`);
+                        const packageDir = packageInfo.path;
+                        const packageDirName = path.basename(packageDir);
+                        logger.error(`To resume from this package, run:`);
+                        logger.error(`    kodrdriv commit-tree --start-from ${packageDirName}`);
+                        throw new Error(`Commit operations failed in package ${packageName}`);
+                    }
+                    break;
+                }
+            }
+        }
+        if (!failedPackage) {
+            const summary = `${isDryRun ? 'DRY RUN: ' : ''}All ${buildOrder.length} packages completed commit operations successfully! 🎉`;
+            logger.info(summary);
+            return output + `\n${summary}\n`;
+        }
+        return output;
+    } catch (error) {
+        const errorMessage = `Failed to execute commit-tree: ${error.message}`;
+        logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+};
+
+export { execute };
+//# sourceMappingURL=commit-tree.js.map