@quark-hq/quark-scripts 0.0.1

package/dist/scripts/release.js

@@ -0,0 +1,833 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const prompts_1 = __importDefault(require("prompts"));
+const semver = __importStar(require("semver"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const chalk_1 = __importDefault(require("chalk"));
+const drawRepoStatus_1 = require("../utils/drawRepoStatus");
+const metrics_1 = require("../utils/metrics");
+const commit_1 = require("../utils/commit");
+dotenv_1.default.config({ quiet: true });
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const MAP_FILE = path.resolve(process.cwd(), '.release/map.json');
+class Release {
+    constructor(verbose) {
+        this.adjList = {};
+        this.invertedAdjList = {};
+        this.filesChanged = [];
+        this.changedPackages = new Map();
+        this.packageJsonCache = new Map();
+        this.mainBranchMapJson = null;
+        this.packagePathCache = new Map();
+        this.nxGraph = null;
+        this.repoRoot = null;
+        this.frozenPackages = new Set();
+        this.excludedPackages = [];
+        this.quarkConfig = null;
+        this.pendingPackageJsonWrites = new Map();
+        if (verbose) {
+            console.log(chalk_1.default.gray("🔍 Verbose mode enabled"));
+            process.env.VERBOSE = "true";
+        }
+        this.metrics = {
+            startTime: Date.now(),
+            phases: {}
+        };
+    }
+    /** Async utility: read JSON file with intelligent caching */
+    async readJsonCached(filePath) {
+        if (!this.packageJsonCache.has(filePath)) {
+            try {
+                const content = await fs_1.promises.readFile(filePath, 'utf-8');
+                const json = JSON.parse(content);
+                this.packageJsonCache.set(filePath, json);
+                // Prevent memory bloat - limit cache size
+                if (this.packageJsonCache.size > 1000) {
+                    const firstKey = this.packageJsonCache.keys().next().value;
+                    if (firstKey) {
+                        this.packageJsonCache.delete(firstKey);
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.warn(`Warning: Failed to read ${filePath}: ${errorMessage}`);
+                return null;
+            }
+        }
+        return this.packageJsonCache.get(filePath) || null;
+    }
+    async readConfig() {
+        (0, metrics_1.startPhase)('Reading Config', this.metrics);
+        try {
+            const config = await fs_1.promises.readFile(path.resolve(process.cwd(), 'quark.config.json'), 'utf-8');
+            this.quarkConfig = JSON.parse(config);
+            if (this.quarkConfig?.release?.excludePackages) {
+                this.excludedPackages = this.quarkConfig.release.excludePackages;
+            }
+        }
+        catch {
+            console.log(chalk_1.default.yellow('No quark.config.json found, using default config'));
+            this.quarkConfig = {
+                release: {
+                    masterBranch: 'main',
+                    excludePackages: [],
+                    autoCommit: false,
+                    autoBump: true,
+                    freeze: false
+                }
+            };
+        }
+        (0, metrics_1.endPhase)('Reading Config', this.metrics);
+    }
+    async initializeRepository() {
+        (0, metrics_1.startPhase)('Repository Initialization', this.metrics);
+        const checks = [];
+        try {
+            // Run all independent git operations in parallel
+            const [repoRootResult, currentBranchResult, fetchResult] = await Promise.allSettled([
+                execAsync('git rev-parse --show-toplevel'),
+                execAsync('git rev-parse --abbrev-ref HEAD'),
+                execAsync(`git fetch origin ${this.quarkConfig?.release?.masterBranch}`)
+            ]);
+            // Process repository root
+            if (repoRootResult.status === 'fulfilled') {
+                this.repoRoot = repoRootResult.value.stdout.trim();
+                checks.push({
+                    label: 'Repository Root',
+                    status: '✓',
+                    message: this.repoRoot
+                });
+            }
+            else {
+                checks.push({
+                    label: 'Repository Root',
+                    status: '✗',
+                    message: 'Failed to get repository root'
+                });
+                throw new Error('Failed to get repository root');
+            }
+            // Process current branch
+            let currentBranch = '';
+            if (currentBranchResult.status === 'fulfilled') {
+                currentBranch = currentBranchResult.value.stdout.trim();
+                checks.push({
+                    label: 'Current Branch',
+                    status: '✓',
+                    message: currentBranch
+                });
+            }
+            else {
+                checks.push({
+                    label: 'Current Branch',
+                    status: '✗',
+                    message: 'Failed to get current branch'
+                });
+            }
+            // Process fetch status
+            if (fetchResult.status === 'rejected') {
+                checks.push({
+                    label: `Fetch origin/${this.quarkConfig?.release?.masterBranch}`,
+                    status: '⚠',
+                    message: 'Failed to fetch, continuing with local data'
+                });
+            }
+            else {
+                checks.push({
+                    label: `Fetch origin/${this.quarkConfig?.release?.masterBranch}`,
+                    status: '✓',
+                    message: 'Successfully fetched latest changes'
+                });
+            }
+            // Check if branch is up-to-date with origin/masterBranch
+            if (currentBranch) {
+                try {
+                    const { stdout } = await execAsync(`git rev-list --count HEAD..origin/${this.quarkConfig?.release?.masterBranch}`);
+                    const missingCount = parseInt(stdout.trim(), 10);
+                    if (isNaN(missingCount)) {
+                        checks.push({
+                            label: 'Branch Sync Status',
+                            status: '⚠',
+                            message: 'Could not determine sync status'
+                        });
+                    }
+                    else if (missingCount > 0) {
+                        checks.push({
+                            label: 'Branch Sync Status',
+                            status: '✗',
+                            message: `${missingCount} commits behind origin/${this.quarkConfig?.release?.masterBranch}`
+                        });
+                        (0, drawRepoStatus_1.drawRepoStatusTable)(checks);
+                        console.error(chalk_1.default.red(`\n❌ Branch is behind origin/${this.quarkConfig?.release?.masterBranch}. Please pull/rebase before continuing.`));
+                        process.exit(1);
+                    }
+                    else {
+                        checks.push({
+                            label: 'Branch Sync Status',
+                            status: '✓',
+                            message: `Up to date with origin/${this.quarkConfig?.release?.masterBranch}`
+                        });
+                    }
+                }
+                catch (error) {
+                    checks.push({
+                        label: 'Branch Sync Status',
+                        status: '⚠',
+                        message: `Could not compare with origin/${this.quarkConfig?.release?.masterBranch}`
+                    });
+                }
+            }
+            // Load map.json from master branch (separate from sync check)
+            try {
+                const mapContent = await execAsync(`git show origin/${this.quarkConfig?.release?.masterBranch}:.release/map.json`);
+                this.mainBranchMapJson = JSON.parse(mapContent.stdout);
+                checks.push({
+                    label: 'Map.json',
+                    status: '✓',
+                    message: `Loaded ${Object.keys(this.mainBranchMapJson).length} package entries from ${this.quarkConfig?.release?.masterBranch}`
+                });
+            }
+            catch {
+                this.mainBranchMapJson = {};
+                checks.push({
+                    label: 'Map.json',
+                    status: '⚠',
+                    message: `No map.json found on origin/${this.quarkConfig?.release?.masterBranch} (first release?)`
+                });
+            }
+            // Draw the status table
+            (0, drawRepoStatus_1.drawRepoStatusTable)(checks);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Draw table with error if we have any checks
+            if (checks.length > 0) {
+                (0, drawRepoStatus_1.drawRepoStatusTable)(checks);
+            }
+            console.error(chalk_1.default.red('\n❌ Repository initialization failed:'), errorMessage);
+            process.exit(1);
+        }
+        (0, metrics_1.endPhase)('Repository Initialization', this.metrics);
+    }
+    /** Optimized file change detection with parallel processing */
+    async detectChangedFiles() {
+        (0, metrics_1.startPhase)('Change Detection', this.metrics);
+        try {
+            // Run git diff operations in parallel
+            const [trackedResult, untrackedResult] = await Promise.allSettled([
+                execAsync(`git diff --name-only origin/${this.quarkConfig?.release?.masterBranch}`),
+                execAsync('git ls-files --others --exclude-standard')
+            ]);
+            const trackedFiles = trackedResult.status === 'fulfilled'
+                ? trackedResult.value.stdout.split('\n').filter(f => f.trim())
+                : [];
+            const untrackedFiles = untrackedResult.status === 'fulfilled'
+                ? untrackedResult.value.stdout.split('\n').filter(f => f.trim())
+                : [];
+            // Filter files that are in packages/
+            this.filesChanged = [...trackedFiles, ...untrackedFiles];
+            console.log(chalk_1.default.blue(`Found ${this.filesChanged.length} changed files`));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(chalk_1.default.red('Change detection failed:'), errorMessage);
+            this.filesChanged = [];
+        }
+        (0, metrics_1.endPhase)('Change Detection', this.metrics);
+    }
+    /** Highly optimized package.json path resolution with caching */
+    async getPackageJsonPath(filePath) {
+        // Check cache first
+        if (this.packagePathCache.has(filePath)) {
+            return this.packagePathCache.get(filePath) || null;
+        }
+        if (!this.repoRoot) {
+            return null;
+        }
+        let currentDir = path.resolve(this.repoRoot, filePath);
+        try {
+            const stat = await fs_1.promises.stat(currentDir);
+            if (stat.isFile()) {
+                currentDir = path.dirname(currentDir);
+            }
+        }
+        catch {
+            // File might not exist, try directory path
+            currentDir = path.dirname(currentDir);
+        }
+        // Traverse up to find package.json, but stop BEFORE repo root
+        // to avoid resolving to the monorepo root package.json
+        while (currentDir !== this.repoRoot && currentDir.startsWith(this.repoRoot)) {
+            const packageJsonPath = path.join(currentDir, 'package.json');
+            try {
+                await fs_1.promises.access(packageJsonPath);
+                // Cache the result for future lookups
+                this.packagePathCache.set(filePath, packageJsonPath);
+                return packageJsonPath;
+            }
+            catch {
+                // Continue up the directory tree
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        // Cache negative result too
+        this.packagePathCache.set(filePath, null);
+        return null;
+    }
+    /** Parallel Nx graph loading and processing */
+    async loadAndProcessNxGraph() {
+        (0, metrics_1.startPhase)('Nx Graph Processing', this.metrics);
+        try {
+            // Run Nx graph and force JSON output to stdout
+            const { stdout } = await execAsync('npx nx graph --file=stdout', { maxBuffer: 10 * 1024 * 1024 });
+            // Parse JSON directly from stdout
+            this.nxGraph = JSON.parse(stdout);
+            // Build adjacency list
+            this.createAdjacencyList();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('❌ Nx graph processing failed:', errorMessage);
+            throw error;
+        }
+        (0, metrics_1.endPhase)('Nx Graph Processing', this.metrics);
+    }
+    /** Build adjacency list and inverted adjacency list in a single pass */
+    createAdjacencyList() {
+        const adjList = {};
+        const invertedAdjList = {};
+        const dependencies = this.nxGraph?.graph.dependencies || {};
+        Object.keys(dependencies).forEach(source => {
+            if (!adjList[source]) {
+                adjList[source] = [];
+            }
+            const deps = dependencies[source] || [];
+            deps.forEach(dep => {
+                adjList[source].push(dep.target);
+                if (!invertedAdjList[dep.target]) {
+                    invertedAdjList[dep.target] = [];
+                }
+                invertedAdjList[dep.target].push(source);
+            });
+        });
+        this.adjList = adjList;
+        this.invertedAdjList = invertedAdjList;
+    }
+    /** Optimized package change evaluation with parallel processing */
+    async evaluateChangedPackages() {
+        (0, metrics_1.startPhase)('Package Evaluation', this.metrics);
+        // Process files in parallel batches
+        const batchSize = 20;
+        const batches = [];
+        for (let i = 0; i < this.filesChanged.length; i += batchSize) {
+            batches.push(this.filesChanged.slice(i, i + batchSize));
+        }
+        for (const batch of batches) {
+            const promises = batch.map(async (file) => {
+                const pkgJsonPath = await this.getPackageJsonPath(file);
+                if (!pkgJsonPath)
+                    return;
+                const localPkg = await this.readJsonCached(pkgJsonPath);
+                if (!localPkg)
+                    return;
+                this.changedPackages.set(localPkg.name, pkgJsonPath);
+            });
+            await Promise.allSettled(promises);
+        }
+        console.log(`📊 Found ${this.changedPackages.size} changed packages`);
+        (0, metrics_1.endPhase)('Package Evaluation', this.metrics);
+    }
+    async checkFrozenPackages(packageName) {
+        (0, metrics_1.startPhase)('Checking Frozen Packages', this.metrics);
+        // Check if the package is frozen in the mainBranchMapJson
+        if (this.mainBranchMapJson &&
+            this.mainBranchMapJson[packageName] &&
+            this.mainBranchMapJson[packageName].frozen === true) {
+            // Load local map.json (bumpMap)
+            let localMapJson = {};
+            try {
+                const bumpMapRaw = await fs_1.promises.readFile(MAP_FILE, 'utf-8');
+                localMapJson = JSON.parse(bumpMapRaw);
+            }
+            catch {
+                // If file not found or error, treat as empty
+                localMapJson = {};
+            }
+            // Check if locally set as frozen
+            if (localMapJson[packageName] &&
+                localMapJson[packageName].frozen === true) {
+                // Locally also frozen
+                (0, metrics_1.endPhase)('Checking Frozen Packages', this.metrics);
+                return true;
+            }
+            else {
+                // Not locally frozen, check pinned dependency versions
+                // 1. Find package.json for `packageName`
+                let pkgPath = null;
+                if (this.nxGraph?.graph?.nodes?.[packageName]?.data?.root) {
+                    pkgPath = this.nxGraph.graph.nodes[packageName].data.root + '/package.json';
+                    pkgPath = await this.getPackageJsonPath(pkgPath);
+                }
+                if (!pkgPath)
+                    return false;
+                const pkg = await this.readJsonCached(pkgPath);
+                if (!pkg) {
+                    (0, metrics_1.endPhase)('Checking Frozen Packages', this.metrics);
+                    return false;
+                }
+                // Get all dependencies for this package that are also present in the graph
+                const depFields = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+                let atLeastOnePinned = false;
+                for (const field of depFields) {
+                    const deps = pkg[field];
+                    if (deps && typeof deps === 'object') {
+                        for (const depName of Object.keys(deps)) {
+                            // Only interested in dependencies that exist in the nxGraph
+                            if (!this.nxGraph?.graph?.nodes?.hasOwnProperty(depName))
+                                continue;
+                            const version = deps[depName];
+                            // Check if version is a specific version OR workspace:* OR workspace:^
+                            if (typeof version === 'string' && (version.startsWith('workspace:*') ||
+                                version.startsWith('workspace:^') ||
+                                // matches exact semver pin: i.e. does not contain ^ or ~ or x or *, and does not start with 'workspace:'
+                                (/^\d+\.\d+\.\d+(-[A-Za-z0-9.+]+)?$/.test(version.trim())))) {
+                                atLeastOnePinned = true;
+                                break; // Only need one to satisfy the "else return true"
+                            }
+                        }
+                        if (atLeastOnePinned)
+                            break;
+                    }
+                }
+                if (!atLeastOnePinned) {
+                    (0, metrics_1.endPhase)('Checking Frozen Packages', this.metrics);
+                    return false;
+                }
+                else {
+                    (0, metrics_1.endPhase)('Checking Frozen Packages', this.metrics);
+                    return true;
+                }
+            }
+        }
+        else {
+            // Not frozen in main branch
+            (0, metrics_1.endPhase)('Checking Frozen Packages', this.metrics);
+            return false;
+        }
+    }
+    /** Optimized version bumping */
+    bumpVersion(version, bumpType) {
+        return semver.inc(version, bumpType) || version;
+    }
+    /** DFS for dependent packages using pre-built inverted adjacency list */
+    getAllDependentPackages(node) {
+        const visited = new Set();
+        const dfs = (current) => {
+            if (visited.has(current))
+                return;
+            visited.add(current);
+            const dependents = this.invertedAdjList[current] || [];
+            for (const dependent of dependents) {
+                dfs(dependent);
+            }
+        };
+        dfs(node);
+        return visited;
+    }
+    /** Optimized topological sort */
+    topologicalSort() {
+        const visited = new Set();
+        const temp = new Set();
+        const result = [];
+        const visit = (node) => {
+            if (visited.has(node))
+                return;
+            if (temp.has(node))
+                throw new Error(`Cycle detected involving ${node}`);
+            temp.add(node);
+            const neighbors = this.adjList[node] || [];
+            for (const neighbor of neighbors) {
+                visit(neighbor);
+            }
+            temp.delete(node);
+            visited.add(node);
+            result.push(node);
+        };
+        // Sort keys for deterministic behavior
+        const sortedKeys = Object.keys(this.adjList);
+        for (const node of sortedKeys) {
+            if (!visited.has(node)) {
+                visit(node);
+            }
+        }
+        return result;
+    }
+    /** Optimized user interaction with background processing */
+    async askForChanges() {
+        (0, metrics_1.startPhase)('User Interaction', this.metrics);
+        let bumpMap = {};
+        try {
+            const content = await fs_1.promises.readFile(MAP_FILE, 'utf-8');
+            bumpMap = JSON.parse(content);
+        }
+        catch {
+            console.log('📝 Creating new bump map');
+        }
+        const bumped = new Set();
+        const topoSorted = this.topologicalSort();
+        const packagesToProcess = topoSorted.filter(pkg => this.changedPackages.has(pkg));
+        console.log(`🎯 Processing ${packagesToProcess.length} changed packages...`);
+        for (let i = 0; i < packagesToProcess.length; i++) {
+            const pkgName = packagesToProcess[i];
+            const progress = `[${i + 1}/${packagesToProcess.length}]`;
+            if (bumped.has(pkgName) || this.excludedPackages.includes(pkgName) || this.frozenPackages.has(pkgName)) {
+                continue;
+            }
+            const pkgPath = this.changedPackages.get(pkgName);
+            const localPkg = await this.readJsonCached(pkgPath);
+            const baseVersion = this.mainBranchMapJson?.[pkgName]?.newVersion || "1.0.0";
+            const res = await (0, prompts_1.default)([
+                {
+                    type: "select",
+                    name: "bumpType",
+                    message: `${progress} 📦 Bump type for ${pkgName} (${baseVersion})?`,
+                    choices: [
+                        { title: "New", value: "new" },
+                        { title: "Patch", value: "patch" },
+                        { title: "Minor", value: "minor" },
+                        { title: "Major", value: "major" },
+                        { title: "Skip", value: null },
+                        { title: "❌ Cancel", value: "__exit" }
+                    ]
+                },
+                {
+                    type: (prev) => (!prev || prev === "__exit") ? null : "text",
+                    name: "changeLog",
+                    message: "📝 Describe the change:"
+                }
+            ]);
+            if (res.bumpType === "__exit") {
+                console.log('👋 Cancelled by user');
+                process.exit(1);
+            }
+            if (!res.bumpType) {
+                console.log(`${progress} ⏩ Skipped: ${pkgName}`);
+                continue;
+            }
+            let newVersion = this.bumpVersion(baseVersion, res.bumpType);
+            if (res.bumpType === "new") {
+                if (this.mainBranchMapJson?.[pkgName]) {
+                    console.log(chalk_1.default.red(`Package ${pkgName} already exists can't create a new package with the same name`));
+                    process.exit(1);
+                }
+                if (semver.gt(baseVersion, "1.0.0")) {
+                    console.log(chalk_1.default.red("Cannot create a new package with a version greater than 1.0.0"));
+                    process.exit(1);
+                }
+                newVersion = "1.0.0";
+            }
+            else {
+                if (semver.lt(baseVersion, "1.0.0")) {
+                    console.log(chalk_1.default.red("I think you are creating a new package please select new instead"));
+                    process.exit(1);
+                }
+                if (await this.checkFrozenPackages(pkgName) === true && res.bumpType !== "major") {
+                    console.log(chalk_1.default.red("Package is frozen can't bump a major version Please unfreeze it using quark unfreeze <packageName>"));
+                    process.exit(1);
+                }
+                newVersion = this.bumpVersion(baseVersion, res.bumpType);
+            }
+            // Accumulate package.json update (deep clone to avoid polluting the cache)
+            if (localPkg) {
+                const cloned = JSON.parse(JSON.stringify(localPkg));
+                cloned.version = newVersion;
+                this.pendingPackageJsonWrites.set(pkgPath, JSON.stringify(cloned, null, 2));
+            }
+            bumpMap[pkgName] = {
+                bumpType: res.bumpType,
+                baseVersion,
+                newVersion,
+                changeLog: res.changeLog,
+                frozen: false
+            };
+            bumped.add(pkgName);
+            console.log(`${progress} ✅ Updated ${pkgName}: ${baseVersion} → ${newVersion}`);
+            // Handle major version cascading
+            if (res.bumpType === "major") {
+                await this.handleMajorVersionBump(pkgName, bumpMap, bumped);
+            }
+        }
+        // Flush all accumulated package.json writes atomically alongside map.json
+        await this.flushPendingPackageJsonWrites();
+        await fs_1.promises.writeFile(MAP_FILE, JSON.stringify(bumpMap, null, 2));
+        (0, metrics_1.endPhase)('User Interaction', this.metrics);
+    }
+    /** Write all accumulated package.json changes to disk at once */
+    async flushPendingPackageJsonWrites() {
+        if (this.pendingPackageJsonWrites.size === 0)
+            return;
+        console.log(`\n💾 Writing ${this.pendingPackageJsonWrites.size} package.json file(s)...`);
+        const writePromises = Array.from(this.pendingPackageJsonWrites.entries()).map(async ([filePath, content]) => {
+            await fs_1.promises.writeFile(filePath, content);
+        });
+        await Promise.all(writePromises);
+        this.pendingPackageJsonWrites.clear();
+        console.log(`✅ All package.json files updated successfully.`);
+    }
+    async handleMajorVersionBump(pkgName, bumpMap, bumped) {
+        console.log(`🔄 Processing major version bump for ${pkgName}...`);
+        let choise = "none";
+        if (this.quarkConfig?.release?.freeze) {
+            const response = await (0, prompts_1.default)({
+                type: "select",
+                name: "dependencies",
+                message: "Select the dependencies to freeze",
+                choices: [
+                    { title: "All", value: "all" },
+                    { title: "None", value: "none" },
+                    { title: "Selective", value: "selective" }
+                ]
+            });
+            choise = response.dependencies;
+        }
+        const dependents = this.getAllDependentPackages(pkgName);
+        dependents.delete(pkgName);
+        switch (choise) {
+            case "all":
+                await this.handleFrozenDependents(pkgName, bumpMap, bumped, dependents);
+                break;
+            case "none":
+                await this.handleMajorVersionCascade(pkgName, bumpMap, bumped, dependents);
+                break;
+            case "selective":
+                await this.handleSelectiveMajorVersionBump(pkgName, bumpMap, bumped, dependents);
+                break;
+        }
+    }
+    async handleSelectiveMajorVersionBump(pkgName, bumpMap, bumped, dependents) {
+        console.log(`🔄 Processing selective major version bump for ${pkgName}...`);
+        let previouslyFrozenDependents = new Set();
+        dependents.forEach(async (dep) => {
+            const isFrozen = await this.checkFrozenPackages(dep);
+            if (isFrozen) {
+                previouslyFrozenDependents.add(dep);
+                dependents.delete(dep);
+            }
+        });
+        if (previouslyFrozenDependents.size > 0) {
+            console.log(chalk_1.default.yellow(`Previously frozen dependents: ${Array.from(previouslyFrozenDependents).join(', ')}`));
+            console.log(chalk_1.default.yellow(`If you want to create a bump of any of the above please unfreeze them using quark unfreeze <packageName>`));
+            const continueResponse = await (0, prompts_1.default)({
+                type: "confirm",
+                name: "continue",
+                message: "Do you want to continue?",
+                initial: true
+            });
+            if (!continueResponse) {
+                console.log('👋 Cancelled by user');
+                process.exit(1);
+            }
+        }
+        const response = await (0, prompts_1.default)({
+            type: "multiselect",
+            name: "dependencies",
+            message: "Select the dependencies to freeze",
+            choices: Array.from(dependents).map(dep => ({ title: dep, value: dep }))
+        });
+        const frozenDependents = new Set();
+        const unfrozenDependents = new Set();
+        dependents.forEach((value) => {
+            if (response.dependencies.includes(value)) {
+                frozenDependents.add(value);
+            }
+            else {
+                unfrozenDependents.add(value);
+            }
+        });
+        await this.handleMajorVersionCascade(pkgName, bumpMap, bumped, unfrozenDependents);
+        await this.handleFrozenDependents(pkgName, bumpMap, bumped, frozenDependents);
+    }
+    async handleFrozenDependents(pkgName, bumpMap, bumped, dependents) {
+        for (const dep of dependents) {
+            try {
+                if (this.excludedPackages.includes(dep))
+                    continue;
+                // Get package.json path for the dependent
+                const depPath = await this.getPackageJsonPath(this.nxGraph?.graph?.nodes?.[dep]?.data?.root + '/package.json');
+                if (!depPath)
+                    continue;
+                // Read local version of package.json
+                const depLocalPkg = await this.readJsonCached(depPath);
+                if (!depLocalPkg || !this.mainBranchMapJson?.[dep]?.newVersion)
+                    continue;
+                // Deep clone to avoid polluting the cache
+                const clonedPkg = JSON.parse(JSON.stringify(depLocalPkg));
+                // For all dependency fields that are objects in package.json, set all versions to what is in main branch
+                const depFields = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+                for (const field of depFields) {
+                    if (clonedPkg[field] && typeof clonedPkg[field] === 'object') {
+                        for (const depKey of Object.keys(clonedPkg[field])) {
+                            if (this.mainBranchMapJson?.[depKey]?.newVersion) {
+                                clonedPkg[field][depKey] = this.mainBranchMapJson[depKey].newVersion;
+                            }
+                        }
+                    }
+                }
+                const depBaseVersion = this.mainBranchMapJson[dep].newVersion;
+                clonedPkg.version = depBaseVersion;
+                // Accumulate the frozen package.json write (deferred until all processing completes)
+                this.pendingPackageJsonWrites.set(depPath, JSON.stringify(clonedPkg, null, 2));
+                // Mark in bumpMap that this dependent is frozen
+                bumpMap[dep] = {
+                    ...(bumpMap[dep] || {}),
+                    baseVersion: this.mainBranchMapJson?.[dep]?.newVersion || "1.0.0",
+                    newVersion: this.mainBranchMapJson?.[dep]?.newVersion || "1.0.0",
+                    bumpType: this.mainBranchMapJson?.[dep]?.bumpType || "new",
+                    changeLog: `Dependency version frozen due to major version bump of ${pkgName}`,
+                    frozen: true
+                };
+                bumped.add(dep);
+                this.frozenPackages.add(dep);
+                console.log(`  ├─ ❄️  Frozen ${dep} at version ${this.mainBranchMapJson?.[dep]?.newVersion || "1.0.0"}`);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.warn(`  ├─ ⚠️  Warning: Failed to freeze ${dep}: ${errorMessage}`);
+                continue;
+            }
+        }
+    }
+    /** Sequential major version cascade handling to avoid race conditions */
+    async handleMajorVersionCascade(pkgName, bumpMap, bumped, dependents) {
+        console.log(`🔄 Processing major version cascade for ${pkgName}...`);
+        let successful = 0;
+        for (const dep of dependents) {
+            if (bumped.has(dep))
+                continue;
+            try {
+                if (this.excludedPackages.includes(dep))
+                    continue;
+                const depPath = await this.getPackageJsonPath(this.nxGraph?.graph?.nodes?.[dep]?.data?.root + '/package.json');
+                if (!depPath)
+                    continue;
+                const depLocalPkg = await this.readJsonCached(depPath);
+                if (!depLocalPkg)
+                    continue;
+                const depBaseVersion = this.mainBranchMapJson?.[dep]?.newVersion || "1.0.0";
+                const depNewVersion = this.bumpVersion(depBaseVersion, "major");
+                // Deep clone to avoid polluting the cache
+                const clonedPkg = JSON.parse(JSON.stringify(depLocalPkg));
+                clonedPkg.version = depNewVersion;
+                // Accumulate the write (deferred until all processing completes)
+                this.pendingPackageJsonWrites.set(depPath, JSON.stringify(clonedPkg, null, 2));
+                bumpMap[dep] = {
+                    bumpType: "major",
+                    baseVersion: depBaseVersion,
+                    newVersion: depNewVersion,
+                    changeLog: `Auto-bumped due to ${pkgName} major release`,
+                    frozen: false
+                };
+                bumped.add(dep);
+                successful++;
+                console.log(`  ├─ 📈 Auto-bumped ${dep}: ${depBaseVersion} → ${depNewVersion}`);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.warn(`  ├─ ⚠️  Warning: Failed to cascade to ${dep}: ${errorMessage}`);
+            }
+        }
+        console.log(`🔄 Cascaded major version to ${successful} dependent packages`);
+    }
+    /** Performance summary */
+    printPerformanceSummary() {
+        const totalTime = Date.now() - this.metrics.startTime;
+        console.log('\n📊 Performance Summary:');
+        console.log(`⏱️  Total time: ${totalTime}ms`);
+        Object.entries(this.metrics.phases).forEach(([phase, data]) => {
+            if (data.duration) {
+                const percentage = ((data.duration / totalTime) * 100).toFixed(1);
+                console.log(`  ├─ ${phase}: ${data.duration}ms (${percentage}%)`);
+            }
+        });
+        const memUsage = process.memoryUsage();
+        console.log(`💾 Peak memory: ${(memUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`);
+    }
+    async commitChanges() {
+        const bumpMap = await fs_1.promises.readFile(MAP_FILE, 'utf-8');
+        const commitMessage = (0, commit_1.generateMarkdownCommitMessageFromMapJson)(JSON.parse(bumpMap));
+        console.log(commitMessage);
+        await execAsync('git add .');
+        await execAsync(`git commit -m "${commitMessage}"`);
+        console.log('🔄 Changes committed');
+    }
+    /** Main execution method */
+    // This is a Promise because the run() method performs asynchronous operations using 'await'.
+    async run() {
+        try {
+            await this.readConfig();
+            await this.initializeRepository();
+            await this.detectChangedFiles();
+            if (this.filesChanged.length === 0) {
+                console.log(chalk_1.default.yellow('No changes detected in packages/'));
+                return;
+            }
+            await this.loadAndProcessNxGraph();
+            await this.evaluateChangedPackages();
+            await this.askForChanges();
+            if (this.quarkConfig?.release?.autoCommit) {
+                await this.commitChanges();
+            }
+            console.log('\n🎉 Release process completed successfully!');
+            this.printPerformanceSummary();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('\n❌ Release process failed:', errorMessage);
+            if (process.env.DEBUG && error instanceof Error) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    }
+}
+exports.default = Release;