@nemus-cli/nemus 0.2.1

package/dist/utils/git-status.js

@@ -0,0 +1,187 @@
+"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.isGitRepository = exports.hasUncommittedChanges = exports.getAllReposStatus = exports.getAheadBehindCounts = exports.getUncommittedChanges = exports.getCurrentBranch = exports.getGitStatus = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path = __importStar(require("path"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const GIT_TIMEOUT = 10000; // 10 seconds per git operation
+const getGitStatus = async (repoPath, repoName) => {
+    try {
+        const results = await Promise.allSettled([
+            (0, exports.getCurrentBranch)(repoPath),
+            (0, exports.getUncommittedChanges)(repoPath),
+            (0, exports.getAheadBehindCounts)(repoPath),
+        ]);
+        const branch = results[0].status === 'fulfilled' ? results[0].value : 'unknown';
+        const changes = results[1].status === 'fulfilled' ? results[1].value : { clean: false, modifiedFiles: 0, untrackedFiles: 0 };
+        const tracking = results[2].status === 'fulfilled' ? results[2].value : { ahead: 0, behind: 0, hasRemote: false };
+        return {
+            repo: repoName,
+            branch,
+            clean: changes.clean,
+            ahead: tracking.ahead,
+            behind: tracking.behind,
+            modifiedFiles: changes.modifiedFiles,
+            untrackedFiles: changes.untrackedFiles,
+            hasRemote: tracking.hasRemote,
+            detachedHead: branch.startsWith('HEAD detached'),
+        };
+    }
+    catch (error) {
+        // Return error state
+        return {
+            repo: repoName,
+            branch: 'unknown',
+            clean: false,
+            ahead: 0,
+            behind: 0,
+            modifiedFiles: 0,
+            untrackedFiles: 0,
+            hasRemote: false,
+            detachedHead: false,
+        };
+    }
+};
+exports.getGitStatus = getGitStatus;
+const getCurrentBranch = async (repoPath) => {
+    try {
+        const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        const branch = stdout.trim();
+        // Check for detached HEAD
+        if (branch === 'HEAD') {
+            const { stdout: commitHash } = await execAsync('git rev-parse --short HEAD', {
+                cwd: repoPath,
+                timeout: GIT_TIMEOUT,
+            });
+            return `HEAD detached at ${commitHash.trim()}`;
+        }
+        return branch;
+    }
+    catch (error) {
+        return 'unknown';
+    }
+};
+exports.getCurrentBranch = getCurrentBranch;
+const getUncommittedChanges = async (repoPath) => {
+    try {
+        const { stdout } = await execAsync('git status --porcelain', {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        if (!stdout.trim()) {
+            return { clean: true, modifiedFiles: 0, untrackedFiles: 0 };
+        }
+        const lines = stdout.trim().split('\n');
+        let modifiedFiles = 0;
+        let untrackedFiles = 0;
+        for (const line of lines) {
+            const status = line.substring(0, 2);
+            if (status.includes('?')) {
+                untrackedFiles++;
+            }
+            else {
+                modifiedFiles++;
+            }
+        }
+        return { clean: false, modifiedFiles, untrackedFiles };
+    }
+    catch (error) {
+        return { clean: false, modifiedFiles: 0, untrackedFiles: 0 };
+    }
+};
+exports.getUncommittedChanges = getUncommittedChanges;
+const getAheadBehindCounts = async (repoPath) => {
+    try {
+        // First check if there's a remote tracking branch
+        const { stdout: upstreamBranch } = await execAsync('git rev-parse --abbrev-ref @{upstream}', {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        if (!upstreamBranch.trim()) {
+            return { ahead: 0, behind: 0, hasRemote: false };
+        }
+        // Get ahead/behind counts
+        const { stdout } = await execAsync('git rev-list --count --left-right @{upstream}...HEAD', {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        const counts = stdout.trim().split('\t');
+        const behind = parseInt(counts[0], 10) || 0;
+        const ahead = parseInt(counts[1], 10) || 0;
+        return { ahead, behind, hasRemote: true };
+    }
+    catch (error) {
+        // No remote tracking branch
+        return { ahead: 0, behind: 0, hasRemote: false };
+    }
+};
+exports.getAheadBehindCounts = getAheadBehindCounts;
+const getAllReposStatus = async (workspacePath, repoNames, concurrency = 3) => {
+    const results = [];
+    // Process in chunks for controlled parallelism
+    for (let i = 0; i < repoNames.length; i += concurrency) {
+        const chunk = repoNames.slice(i, i + concurrency);
+        const chunkResults = await Promise.all(chunk.map(repoName => {
+            const repoPath = path.join(workspacePath, repoName);
+            return (0, exports.getGitStatus)(repoPath, repoName);
+        }));
+        results.push(...chunkResults);
+    }
+    return results;
+};
+exports.getAllReposStatus = getAllReposStatus;
+const hasUncommittedChanges = async (repoPath) => {
+    const { clean } = await (0, exports.getUncommittedChanges)(repoPath);
+    return !clean;
+};
+exports.hasUncommittedChanges = hasUncommittedChanges;
+const isGitRepository = async (repoPath) => {
+    try {
+        await execAsync('git rev-parse --git-dir', {
+            cwd: repoPath,
+            timeout: GIT_TIMEOUT,
+        });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.isGitRepository = isGitRepository;

package/dist/utils/github.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayAuthInstructions = exports.fetchOrgRepos = exports.verifyGhAuth = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const logger_1 = require("./logger");
+const cache_1 = require("./cache");
+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 verifyGhAuth = async () => {
+    try {
+        const { stdout } = await execAsync('gh auth status');
+        return stdout.includes('Logged in') || stdout.includes('✓');
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.verifyGhAuth = verifyGhAuth;
+const fetchOrgRepos = async (options = {}) => {
+    const { forceRefresh = false } = options;
+    try {
+        const { githubOrg } = (0, config_1.getUserConfig)();
+        // Try to get cached repos first
+        if (!forceRefresh) {
+            const cachedRepos = await (0, cache_1.getCachedRepos)({ org: githubOrg });
+            if (cachedRepos) {
+                return cachedRepos.sort((a, b) => a.name.localeCompare(b.name));
+            }
+        }
+        (0, logger_1.logInfo)(githubOrg
+            ? `Fetching ${githubOrg} repositories from GitHub...`
+            : 'Fetching your GitHub repositories... (set an org with `nemus configure` to list an organization)');
+        // With no configured org, `gh repo list` (no positional) lists the
+        // authenticated user's own repos. With an org, it lists that org's repos.
+        const args = [
+            'repo', 'list',
+            ...(githubOrg ? [githubOrg] : []),
+            '--limit', '1000',
+            '--json', 'name,url,sshUrl,owner,description,isPrivate',
+        ];
+        const { stdout } = await execFileAsync('gh', args);
+        const repos = JSON.parse(stdout);
+        (0, logger_1.logInfo)(`Found ${repos.length} repositories`);
+        // Cache the results (24 hour TTL)
+        await (0, cache_1.setCachedRepos)(repos, 86400000, githubOrg);
+        return repos.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to fetch repositories from GitHub');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        throw new Error('Unable to fetch repositories. Please ensure gh CLI is authenticated.');
+    }
+};
+exports.fetchOrgRepos = fetchOrgRepos;
+const displayAuthInstructions = () => {
+    console.log('\n' + '='.repeat(60));
+    console.log('GitHub CLI Authentication Required');
+    console.log('='.repeat(60));
+    console.log('\nPlease authenticate with GitHub CLI by running:');
+    console.log('\n  gh auth login\n');
+    console.log('Then try running this command again.');
+    console.log('='.repeat(60) + '\n');
+};
+exports.displayAuthInstructions = displayAuthInstructions;

package/dist/utils/health-checks.js

@@ -0,0 +1,345 @@
+"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.calculateHealthScore = exports.runAllHealthChecks = exports.checkGhqInstalled = exports.checkMetadataIntegrity = exports.checkDiskSpace = exports.checkDependencies = exports.checkAuthentication = exports.checkUncommittedChanges = exports.checkGitHealth = exports.checkMissingRepositories = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const git_status_1 = require("./git-status");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const checkMissingRepositories = async (workspacePath, metadata) => {
+    const missingRepos = [];
+    for (const repo of metadata.repositories) {
+        const repoPath = path.join(workspacePath, repo.directoryName);
+        try {
+            await fs.access(repoPath);
+        }
+        catch {
+            missingRepos.push(repo.directoryName);
+        }
+    }
+    if (missingRepos.length === 0) {
+        return {
+            category: 'Missing Repositories',
+            status: 'healthy',
+            message: 'All repositories are present',
+        };
+    }
+    return {
+        category: 'Missing Repositories',
+        status: 'error',
+        message: `${missingRepos.length} repository(ies) missing`,
+        details: missingRepos.join(', '),
+        actionable: `Run 'workspace sync ${metadata.workspaceName}' to clone missing repositories`,
+    };
+};
+exports.checkMissingRepositories = checkMissingRepositories;
+const checkGitHealth = async (workspacePath, repoNames) => {
+    const issues = [];
+    for (const repoName of repoNames) {
+        const repoPath = path.join(workspacePath, repoName);
+        try {
+            await fs.access(repoPath);
+        }
+        catch {
+            continue; // Skip missing repos (handled by checkMissingRepositories)
+        }
+        const isRepo = await (0, git_status_1.isGitRepository)(repoPath);
+        if (!isRepo) {
+            issues.push(`${repoName}: not a git repository`);
+            continue;
+        }
+        // Check for corrupted repo
+        try {
+            await execAsync('git fsck --no-progress', {
+                cwd: repoPath,
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            issues.push(`${repoName}: repository may be corrupted`);
+        }
+    }
+    if (issues.length === 0) {
+        return {
+            category: 'Git Health',
+            status: 'healthy',
+            message: 'All repositories are healthy',
+        };
+    }
+    return {
+        category: 'Git Health',
+        status: 'error',
+        message: `${issues.length} repository(ies) have issues`,
+        details: issues.join('\n'),
+        actionable: 'Check repository integrity and consider re-cloning problematic repos',
+    };
+};
+exports.checkGitHealth = checkGitHealth;
+const checkUncommittedChanges = async (workspacePath, repoNames) => {
+    const dirtyRepos = [];
+    for (const repoName of repoNames) {
+        const repoPath = path.join(workspacePath, repoName);
+        try {
+            await fs.access(repoPath);
+        }
+        catch {
+            continue;
+        }
+        const hasChanges = await (0, git_status_1.hasUncommittedChanges)(repoPath);
+        if (hasChanges) {
+            dirtyRepos.push(repoName);
+        }
+    }
+    if (dirtyRepos.length === 0) {
+        return {
+            category: 'Uncommitted Changes',
+            status: 'healthy',
+            message: 'No uncommitted changes',
+        };
+    }
+    return {
+        category: 'Uncommitted Changes',
+        status: 'warning',
+        message: `${dirtyRepos.length} repository(ies) have uncommitted changes`,
+        details: dirtyRepos.join(', '),
+        actionable: `Review and commit or stash changes before switching branches`,
+    };
+};
+exports.checkUncommittedChanges = checkUncommittedChanges;
+const checkAuthentication = async () => {
+    const issues = [];
+    // Check GitHub CLI
+    try {
+        await execAsync('gh auth status', { timeout: 5000 });
+    }
+    catch {
+        issues.push('GitHub CLI (gh) not authenticated');
+    }
+    // Check SSH keys
+    try {
+        await execAsync('ssh -T git@github.com', { timeout: 5000 });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : '';
+        if (!errorMessage.includes('successfully authenticated')) {
+            issues.push('SSH key not configured for GitHub');
+        }
+    }
+    if (issues.length === 0) {
+        return {
+            category: 'Authentication',
+            status: 'healthy',
+            message: 'Authentication configured correctly',
+        };
+    }
+    return {
+        category: 'Authentication',
+        status: 'warning',
+        message: 'Authentication issues detected',
+        details: issues.join('\n'),
+        actionable: 'Run "gh auth login" or configure SSH keys',
+    };
+};
+exports.checkAuthentication = checkAuthentication;
+const checkDependencies = async (workspacePath, repoNames) => {
+    const missingDeps = [];
+    for (const repoName of repoNames) {
+        const repoPath = path.join(workspacePath, repoName);
+        try {
+            await fs.access(repoPath);
+        }
+        catch {
+            continue;
+        }
+        // Check for package.json
+        const packageJsonPath = path.join(repoPath, 'package.json');
+        try {
+            await fs.access(packageJsonPath);
+            // Check if node_modules exists
+            const nodeModulesPath = path.join(repoPath, 'node_modules');
+            try {
+                await fs.access(nodeModulesPath);
+            }
+            catch {
+                missingDeps.push(`${repoName}: missing node_modules`);
+            }
+        }
+        catch {
+            // No package.json, skip
+        }
+    }
+    if (missingDeps.length === 0) {
+        return {
+            category: 'Dependencies',
+            status: 'healthy',
+            message: 'All dependencies installed',
+        };
+    }
+    return {
+        category: 'Dependencies',
+        status: 'warning',
+        message: `${missingDeps.length} repository(ies) missing dependencies`,
+        details: missingDeps.join('\n'),
+        actionable: 'Run "npm install" or "yarn install" in affected repositories',
+    };
+};
+exports.checkDependencies = checkDependencies;
+const checkDiskSpace = async (workspacePath) => {
+    try {
+        // Get disk usage for workspace
+        const { stdout } = await execAsync(`du -sh "${workspacePath}"`, { timeout: 30000 });
+        const sizeStr = stdout.trim().split('\t')[0];
+        // Parse size (rough check for > 10GB)
+        const sizeValue = parseFloat(sizeStr);
+        const unit = sizeStr.replace(/[0-9.]/g, '').trim();
+        const isLarge = (unit === 'G' && sizeValue > 10) || unit === 'T';
+        if (isLarge) {
+            return {
+                category: 'Disk Space',
+                status: 'warning',
+                message: `Workspace is large (${sizeStr})`,
+                actionable: 'Consider running "workspace cleanup" to free up space',
+            };
+        }
+        return {
+            category: 'Disk Space',
+            status: 'healthy',
+            message: `Workspace size: ${sizeStr}`,
+        };
+    }
+    catch (error) {
+        return {
+            category: 'Disk Space',
+            status: 'warning',
+            message: 'Could not calculate disk usage',
+        };
+    }
+};
+exports.checkDiskSpace = checkDiskSpace;
+const checkMetadataIntegrity = async (workspacePath, metadata) => {
+    const issues = [];
+    // Check required fields
+    if (!metadata.workspaceName) {
+        issues.push('Missing workspace name');
+    }
+    if (!metadata.createdAt) {
+        issues.push('Missing creation timestamp');
+    }
+    if (!metadata.repositories || metadata.repositories.length === 0) {
+        issues.push('No repositories in metadata');
+    }
+    // Check for duplicate directory names
+    const dirNames = metadata.repositories.map(r => r.directoryName);
+    const uniqueDirNames = new Set(dirNames);
+    if (dirNames.length !== uniqueDirNames.size) {
+        issues.push('Duplicate directory names in metadata');
+    }
+    // Check for extra directories not in metadata
+    try {
+        const entries = await fs.readdir(workspacePath, { withFileTypes: true });
+        const directories = entries.filter(e => e.isDirectory()).map(e => e.name);
+        const metadataDirNames = new Set(dirNames);
+        const extraDirs = directories.filter(dir => !metadataDirNames.has(dir) && !dir.startsWith('.'));
+        if (extraDirs.length > 0) {
+            issues.push(`${extraDirs.length} directories not tracked in metadata: ${extraDirs.join(', ')}`);
+        }
+    }
+    catch (error) {
+        // Ignore read errors
+    }
+    if (issues.length === 0) {
+        return {
+            category: 'Metadata Integrity',
+            status: 'healthy',
+            message: 'Metadata is valid',
+        };
+    }
+    return {
+        category: 'Metadata Integrity',
+        status: 'warning',
+        message: 'Metadata issues detected',
+        details: issues.join('\n'),
+        actionable: 'Review workspace metadata file',
+    };
+};
+exports.checkMetadataIntegrity = checkMetadataIntegrity;
+const checkGhqInstalled = async () => {
+    try {
+        await execAsync('which ghq', { timeout: 5000 });
+        return {
+            category: 'ghq',
+            status: 'healthy',
+            message: 'ghq is installed (fast cached clones enabled)',
+        };
+    }
+    catch {
+        return {
+            category: 'ghq',
+            status: 'warning',
+            message: 'ghq is not installed',
+            details: 'Without ghq, repos are cloned directly with git — slower, no shared cache, and large repos can hit clone timeouts.',
+            actionable: 'Install ghq: brew install ghq (macOS) — https://github.com/x-motemen/ghq#installation',
+        };
+    }
+};
+exports.checkGhqInstalled = checkGhqInstalled;
+const runAllHealthChecks = async (workspacePath, metadata) => {
+    const repoNames = metadata.repositories.map(r => r.directoryName);
+    const checks = await Promise.all([
+        (0, exports.checkMissingRepositories)(workspacePath, metadata),
+        (0, exports.checkGitHealth)(workspacePath, repoNames),
+        (0, exports.checkUncommittedChanges)(workspacePath, repoNames),
+        (0, exports.checkAuthentication)(),
+        (0, exports.checkGhqInstalled)(),
+        (0, exports.checkDependencies)(workspacePath, repoNames),
+        (0, exports.checkDiskSpace)(workspacePath),
+        (0, exports.checkMetadataIntegrity)(workspacePath, metadata),
+    ]);
+    return checks;
+};
+exports.runAllHealthChecks = runAllHealthChecks;
+const calculateHealthScore = (results) => {
+    const weights = {
+        healthy: 100,
+        warning: 60,
+        error: 0,
+    };
+    const totalWeight = results.reduce((sum, result) => sum + weights[result.status], 0);
+    const maxWeight = results.length * 100;
+    return Math.round((totalWeight / maxWeight) * 100);
+};
+exports.calculateHealthScore = calculateHealthScore;