@nemus-cli/nemus 0.2.1

package/dist/utils/ghq-integration.js

@@ -0,0 +1,332 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeCloneError = describeCloneError;
+exports.isGhqInstalled = isGhqInstalled;
+exports.warnIfGhqMissing = warnIfGhqMissing;
+exports.getGhqRoot = getGhqRoot;
+exports.ghqRepoExists = ghqRepoExists;
+exports.getGhqRepoPath = getGhqRepoPath;
+exports.ghqGet = ghqGet;
+exports.ghqList = ghqList;
+exports.displayGhqInfo = displayGhqInfo;
+exports.cloneWithGhq = cloneWithGhq;
+exports.getGhqStatus = getGhqStatus;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
+const colors_1 = require("./colors");
+const config_1 = require("./config");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Turn a raw child-process clone failure (from exec or execFile) into an
+ * actionable message. The child API discards the reason on timeout/buffer kill (you just get "Command
+ * failed: git clone …"), so we inspect killed/signal/code and the captured
+ * stderr to explain what actually happened and how to fix it.
+ */
+function describeCloneError(error, timeoutMs = config_1.CLONE_TIMEOUT_MS) {
+    const e = (error ?? {});
+    const stderr = (e.stderr || '').trim();
+    const tail = stderr ? `\n  git: ${stderr.split('\n').filter(Boolean).slice(-3).join(' ')}` : '';
+    // Check maxBuffer FIRST: Node sets killed=true on a maxBuffer kill too, so
+    // the timeout heuristic below would otherwise shadow this case.
+    if (e.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+        return `Clone output exceeded the buffer limit (very large repo). Install ghq (brew install ghq) for cached clones.${tail}`;
+    }
+    const timedOut = e.killed === true || e.signal === 'SIGTERM' || e.code === 'ETIMEDOUT';
+    if (timedOut) {
+        const mins = Math.round(timeoutMs / 60000);
+        return `Clone timed out after ${mins} min — the repo may be large or the network slow. `
+            + `Fixes: install ghq for fast cached clones (brew install ghq), switch to SSH (w configure), `
+            + `or raise the limit with WORKSPACE_CLONE_TIMEOUT_MS.${tail}`;
+    }
+    return `${e.message || 'Unknown error'}${tail}`;
+}
+/**
+ * Check if ghq is installed
+ */
+async function isGhqInstalled() {
+    try {
+        await execAsync('which ghq');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Verify ghq is installed and, if not, warn with install guidance.
+ * ghq gives fast cached clones (shared across workspaces) and avoids the
+ * clone-timeout failures large repos hit over plain git-over-HTTPS.
+ * Returns true if ghq is available. Non-blocking — clones still work without it.
+ */
+async function warnIfGhqMissing() {
+    if (await isGhqInstalled())
+        return true;
+    (0, logger_1.logWarning)('ghq is not installed — using direct git clone (slower, no shared cache).');
+    (0, logger_1.logInfo)('  ghq caches repos so re-cloning across workspaces is near-instant and large repos avoid clone timeouts.');
+    (0, logger_1.logInfo)(`  Install: ${(0, colors_1.colorize)('brew install ghq', 'cyan')}  (macOS)  —  Linux/Windows: https://github.com/x-motemen/ghq#installation`);
+    return false;
+}
+/**
+ * Get ghq root directory
+ */
+async function getGhqRoot() {
+    try {
+        const { stdout } = await execAsync('ghq root');
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a repository exists in ghq
+ */
+async function ghqRepoExists(repoUrl) {
+    try {
+        const repoPath = await getGhqRepoPath(repoUrl);
+        if (!repoPath)
+            return false;
+        await execAsync(`test -d "${repoPath}"`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the local path for a ghq-managed repository
+ */
+async function getGhqRepoPath(repoUrl) {
+    try {
+        // Extract org/repo from URL
+        // e.g., git@github.com:my-org/my-app.git -> github.com/my-org/my-app
+        const match = repoUrl.match(/github\.com[:/]([^/]+)\/([^.]+)/);
+        if (!match)
+            return null;
+        const [, org, repo] = match;
+        const ghqRoot = await getGhqRoot();
+        if (!ghqRoot)
+            return null;
+        return path.join(ghqRoot, 'github.com', org, repo);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Clone repository using ghq
+ */
+async function ghqGet(repoUrl) {
+    try {
+        (0, logger_1.logInfo)(`Using ghq to clone ${(0, colors_1.colorize)(repoUrl, 'cyan')}...`);
+        await execAsync(`ghq get "${repoUrl}"`, { timeout: config_1.CLONE_TIMEOUT_MS, maxBuffer: config_1.CLONE_MAX_BUFFER });
+        const repoPath = await getGhqRepoPath(repoUrl);
+        if (!repoPath) {
+            return { success: false, error: 'Could not determine ghq path' };
+        }
+        (0, logger_1.logSuccess)(`Repository available in ghq: ${(0, colors_1.colorize)(repoPath, 'gray')}`);
+        return { success: true, path: repoPath };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return { success: false, error: errorMessage };
+    }
+}
+/**
+ * List all repositories managed by ghq
+ */
+async function ghqList() {
+    try {
+        const { stdout } = await execAsync('ghq list');
+        return stdout.trim().split('\n').filter(line => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Display ghq installation instructions
+ */
+function displayGhqInfo() {
+    console.log('\n' + '='.repeat(60));
+    console.log((0, colors_1.colorize)('About ghq', 'bright'));
+    console.log('='.repeat(60));
+    console.log('\nghq is a tool for managing Git repositories in a structured way.');
+    console.log('The workspace manager can use ghq for better repository organization.\n');
+    console.log('Installation:');
+    console.log('  brew install ghq\n');
+    console.log('Benefits:');
+    console.log('  • Centralized repository cache');
+    console.log('  • Consistent directory structure');
+    console.log('  • Faster subsequent clones');
+    console.log('  • Works alongside workspace isolation\n');
+    console.log('After installing ghq, the workspace manager will automatically use it.');
+    console.log('='.repeat(60) + '\n');
+}
+/**
+ * Clone repository with ghq integration
+ * Falls back to direct git clone if ghq is not available
+ */
+async function cloneWithGhq(repoUrl, targetPath) {
+    const hasGhq = await isGhqInstalled();
+    if (hasGhq) {
+        // Check if repo already exists in ghq cache
+        const ghqPath = await getGhqRepoPath(repoUrl);
+        let ghqReady = !!(ghqPath && await ghqRepoExists(repoUrl));
+        if (!ghqReady) {
+            // Not in cache — clone into ghq first (without -u to avoid extra fetch)
+            const ghqResult = await ghqGet(repoUrl);
+            if (ghqResult.success) {
+                ghqReady = true;
+            }
+            else {
+                (0, logger_1.logWarning)(`ghq clone failed: ${ghqResult.error}`);
+            }
+        }
+        // Use git clone --local from ghq cache (hardlinks .git/objects — nearly instant)
+        const sourcePath = ghqPath || (await getGhqRepoPath(repoUrl));
+        if (ghqReady && sourcePath) {
+            try {
+                // Refresh the ghq cache BEFORE clone-local so the workspace gets the
+                // latest content. Without this, an old cache (cloned weeks/months ago)
+                // would serve stale state via hardlinks — user would open a workspace
+                // missing dozens of recent commits.
+                try {
+                    await execAsync(`git -C "${sourcePath}" fetch origin --quiet --prune`, { timeout: 90 * 1000 });
+                }
+                catch {
+                    // Network failure or no upstream — fall through with stale cache,
+                    // we'll log a warning after the local clone if we can't align to HEAD.
+                }
+                await execAsync(`git clone --local "${sourcePath}" "${targetPath}"`, { timeout: 60 * 1000 });
+                // Reset remote to point to the original repo URL (not the local ghq path)
+                await execAsync(`git remote set-url origin "${repoUrl}"`, { cwd: targetPath });
+                // Make sure the working tree is at origin's default-branch tip.
+                // Robust against:
+                //   - cache having a non-default branch checked out
+                //   - fetch above failing (network blip)
+                //   - refs/remotes/origin/HEAD symref not being set (some git/ghq combos)
+                let alignedToHead = false;
+                let alignError = null;
+                try {
+                    await execAsync(`git fetch origin --quiet`, { cwd: targetPath, timeout: 60 * 1000 });
+                    // Explicitly set refs/remotes/origin/HEAD by querying the remote.
+                    // Without this, symbolic-ref may fail if the local symref wasn’t set.
+                    await execAsync(`git remote set-head origin --auto`, { cwd: targetPath, timeout: 30 * 1000 })
+                        .catch(() => { });
+                    let defaultBranch = null;
+                    try {
+                        const headRes = await execAsync(`git symbolic-ref --short refs/remotes/origin/HEAD`, { cwd: targetPath, timeout: 5000 });
+                        defaultBranch = headRes.stdout.trim().replace(/^origin\//, '');
+                    }
+                    catch {
+                        // Fall back to ls-remote query against the actual remote
+                        try {
+                            const lsRes = await execAsync(`git ls-remote --symref origin HEAD`, { cwd: targetPath, timeout: 30 * 1000 });
+                            const match = lsRes.stdout.match(/^ref:\s+refs\/heads\/(\S+)\s+HEAD$/m);
+                            if (match)
+                                defaultBranch = match[1];
+                        }
+                        catch { /* fall through to common-name fallback */ }
+                    }
+                    // Final fallback: try common default branches
+                    if (!defaultBranch) {
+                        for (const candidate of ['main', 'master']) {
+                            const exists = await execAsync(`git rev-parse --verify --quiet origin/${candidate}`, { cwd: targetPath, timeout: 5000 }).then(() => true).catch(() => false);
+                            if (exists) {
+                                defaultBranch = candidate;
+                                break;
+                            }
+                        }
+                    }
+                    if (!defaultBranch) {
+                        throw new Error('could not determine default branch (no origin/HEAD, no main, no master)');
+                    }
+                    await execAsync(`git checkout --quiet "${defaultBranch}"`, { cwd: targetPath, timeout: 10 * 1000 });
+                    await execAsync(`git reset --hard --quiet "origin/${defaultBranch}"`, { cwd: targetPath, timeout: 10 * 1000 });
+                    alignedToHead = true;
+                }
+                catch (error) {
+                    alignError = error instanceof Error ? error.message : String(error);
+                }
+                if (!alignedToHead) {
+                    // LOUD warning — stale content silently is the worst UX. Surface it.
+                    (0, logger_1.logWarning)(`⚠️  Could not align ${repoUrl} to origin/HEAD — workspace may have stale content!`);
+                    if (alignError)
+                        (0, logger_1.logWarning)(`   reason: ${alignError}`);
+                    (0, logger_1.logWarning)(`   manual fix: cd into the repo and run 'git pull --ff-only'`);
+                }
+                return { success: true, usedGhq: true };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                (0, logger_1.logWarning)(`Local clone from ghq failed: ${errorMessage}`);
+                // Clean up partial clone before fallback
+                try {
+                    await execAsync(`rm -rf "${targetPath}"`);
+                }
+                catch { /* ignore */ }
+                // Fall through to direct clone
+            }
+        }
+    }
+    // Fallback to direct git clone
+    try {
+        await execAsync(`git clone "${repoUrl}" "${targetPath}"`, { timeout: config_1.CLONE_TIMEOUT_MS, maxBuffer: config_1.CLONE_MAX_BUFFER });
+        return { success: true, usedGhq: false };
+    }
+    catch (error) {
+        return { success: false, error: describeCloneError(error), usedGhq: false };
+    }
+}
+/**
+ * Show ghq status
+ */
+async function getGhqStatus() {
+    const installed = await isGhqInstalled();
+    if (!installed) {
+        return { installed: false };
+    }
+    const root = await getGhqRoot();
+    const repos = await ghqList();
+    return {
+        installed: true,
+        root: root || undefined,
+        repoCount: repos.length,
+    };
+}

package/dist/utils/git-operations.js

@@ -0,0 +1,237 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCloneResults = exports.cloneRepositories = exports.cloneSingleRepo = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const logger_1 = require("./logger");
+const colors_1 = require("./colors");
+const ghq_integration_1 = require("./ghq-integration");
+const retry_1 = require("./retry");
+const progress_1 = require("./progress");
+const config_1 = require("./config");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const CONCURRENCY_LIMIT = 3;
+const CLONE_TIMEOUT = config_1.CLONE_TIMEOUT_MS;
+const cloneSingleRepo = async (repo, workspacePath, directoryName, useGhq = true, silent = false) => {
+    const repoPath = path.join(workspacePath, directoryName);
+    const cloneUrl = (0, config_1.getCloneUrl)(repo);
+    const displayName = directoryName !== repo.name
+        ? `${(0, colors_1.colorize)(directoryName, 'cyan')} (${repo.name})`
+        : (0, colors_1.colorize)(repo.name, 'cyan');
+    try {
+        if (!silent)
+            (0, logger_1.logInfo)(`Cloning ${displayName}...`);
+        await (0, retry_1.withRetry)(async () => {
+            // Clean up partial clone before retry
+            try {
+                await fs.rm(repoPath, { recursive: true, force: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            if (useGhq) {
+                const result = await (0, ghq_integration_1.cloneWithGhq)(cloneUrl, repoPath);
+                if (!result.success) {
+                    throw new Error(result.error || 'Clone failed');
+                }
+                if (!silent) {
+                    if (result.usedGhq) {
+                        (0, logger_1.logSuccess)(`Cloned ${displayName} ${(0, colors_1.colorize)('(via ghq)', 'gray')}`);
+                    }
+                    else {
+                        (0, logger_1.logSuccess)(`Cloned ${displayName}`);
+                    }
+                }
+            }
+            else {
+                try {
+                    // execFile (no shell) so repo URLs / paths with spaces or shell
+                    // metacharacters can't break or inject into the command.
+                    await execFileAsync('git', ['clone', cloneUrl, repoPath], {
+                        timeout: CLONE_TIMEOUT,
+                        maxBuffer: config_1.CLONE_MAX_BUFFER,
+                    });
+                }
+                catch (err) {
+                    // execFile loses the reason on timeout/buffer kill — explain it.
+                    throw new Error((0, ghq_integration_1.describeCloneError)(err, CLONE_TIMEOUT));
+                }
+                if (!silent)
+                    (0, logger_1.logSuccess)(`Cloned ${displayName}`);
+            }
+        }, undefined, `Clone ${repo.name}`);
+        return {
+            repo,
+            directoryName,
+            status: 'success',
+            clonedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        (0, logger_1.logError)(`Failed to clone ${displayName}: ${errorMessage}`);
+        return {
+            repo,
+            directoryName,
+            status: 'failed',
+            error: errorMessage,
+        };
+    }
+};
+exports.cloneSingleRepo = cloneSingleRepo;
+async function cloneLocal(repo, sourcePath, workspacePath, directoryName) {
+    const targetPath = path.join(workspacePath, directoryName);
+    try {
+        // git clone --local creates hardlinks for .git/objects — nearly instant
+        await execAsync(`git clone --local "${sourcePath}" "${targetPath}"`, {
+            timeout: CLONE_TIMEOUT,
+            maxBuffer: config_1.CLONE_MAX_BUFFER,
+        });
+        // Reset the remote to point to the original repo (not the local source)
+        const remoteUrl = (0, config_1.getCloneUrl)(repo);
+        await execAsync(`git remote set-url origin "${remoteUrl}"`, {
+            cwd: targetPath,
+        });
+        return {
+            repo,
+            directoryName,
+            status: 'success',
+            clonedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            repo,
+            directoryName,
+            status: 'failed',
+            error: errorMessage,
+        };
+    }
+}
+const cloneRepositories = async (repoEntries, workspacePath) => {
+    // Check if ghq is available
+    const hasGhq = await (0, ghq_integration_1.isGhqInstalled)();
+    console.log('\n' + '='.repeat(60));
+    console.log(`Cloning ${repoEntries.length} repositories (${CONCURRENCY_LIMIT} concurrent clones)`);
+    if (hasGhq) {
+        console.log((0, colors_1.colorize)('Using ghq for efficient repository management', 'cyan'));
+    }
+    console.log('='.repeat(60) + '\n');
+    const bar = (0, progress_1.createSimpleProgressBar)(repoEntries.length, 'Cloning');
+    bar.start(repoEntries.length, 0);
+    // Group entries by repo SSH URL to avoid duplicate clones
+    const repoGroups = new Map();
+    for (const entry of repoEntries) {
+        const key = entry.repo.sshUrl;
+        if (!repoGroups.has(key)) {
+            repoGroups.set(key, []);
+        }
+        repoGroups.get(key).push(entry);
+    }
+    const allResults = [];
+    let completed = 0;
+    // Process unique repo groups with concurrency (different repos clone in parallel)
+    const groups = Array.from(repoGroups.values());
+    for (let i = 0; i < groups.length; i += CONCURRENCY_LIMIT) {
+        const chunk = groups.slice(i, i + CONCURRENCY_LIMIT);
+        const chunkPromises = chunk.map(async (entries) => {
+            const groupResults = [];
+            // Clone first instance normally
+            const first = entries[0];
+            const firstResult = await (0, exports.cloneSingleRepo)(first.repo, workspacePath, first.directoryName, hasGhq, true);
+            groupResults.push(firstResult);
+            completed++;
+            bar.update(completed);
+            // Clone remaining instances via --local from the first
+            if (firstResult.status === 'success' && entries.length > 1) {
+                const sourcePath = path.join(workspacePath, first.directoryName);
+                for (const entry of entries.slice(1)) {
+                    const result = await cloneLocal(entry.repo, sourcePath, workspacePath, entry.directoryName);
+                    groupResults.push(result);
+                    completed++;
+                    bar.update(completed);
+                }
+            }
+            else if (firstResult.status === 'failed' && entries.length > 1) {
+                // Mark remaining as failed too
+                for (const entry of entries.slice(1)) {
+                    groupResults.push({
+                        repo: entry.repo,
+                        directoryName: entry.directoryName,
+                        status: 'failed',
+                        error: 'Primary clone failed',
+                    });
+                    completed++;
+                    bar.update(completed);
+                }
+            }
+            return groupResults;
+        });
+        const chunkResults = await Promise.all(chunkPromises);
+        for (const groupResults of chunkResults) {
+            allResults.push(...groupResults);
+        }
+    }
+    bar.stop();
+    console.log('');
+    return allResults;
+};
+exports.cloneRepositories = cloneRepositories;
+const reportCloneResults = (results) => {
+    const successful = results.filter(r => r.status === 'success');
+    const failed = results.filter(r => r.status === 'failed');
+    console.log('\n' + '='.repeat(60));
+    console.log('Clone Results Summary');
+    console.log('='.repeat(60));
+    console.log(`${(0, colors_1.colorize)('✓', 'green')} Successful: ${successful.length}`);
+    console.log(`${(0, colors_1.colorize)('✗', 'red')} Failed: ${failed.length}`);
+    console.log('='.repeat(60));
+    if (failed.length > 0) {
+        console.log('\nFailed repositories:');
+        failed.forEach(result => {
+            const displayName = result.directoryName !== result.repo.name
+                ? `${result.directoryName} (${result.repo.name})`
+                : result.repo.name;
+            console.log(`  ${(0, colors_1.colorize)('✗', 'red')} ${displayName}: ${result.error}`);
+        });
+    }
+    console.log('');
+};
+exports.reportCloneResults = reportCloneResults;