@nemus-cli/nemus 0.2.1

package/dist/commands/suite/use.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env ts-node
+"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 });
+exports.main = main;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const config_1 = require("../../utils/config");
+const github_1 = require("../../utils/github");
+const prompts_1 = require("../../utils/prompts");
+const git_operations_1 = require("../../utils/git-operations");
+const workspace_meta_1 = require("../../utils/workspace-meta");
+const claude_integration_1 = require("../../utils/claude-integration");
+const logger_1 = require("../../utils/logger");
+const colors_1 = require("../../utils/colors");
+const suite_1 = require("../../utils/suite");
+const hooks_1 = require("../../utils/hooks");
+const inquirer_1 = __importDefault(require("inquirer"));
+const validation_1 = require("../../utils/validation");
+async function main(opts) {
+    console.log('\n' + '='.repeat(60));
+    console.log((0, colors_1.colorize)('Create Workspace from Suite', 'bright'));
+    console.log('='.repeat(60) + '\n');
+    // Read from opts (Commander) or fall back to process.argv (legacy/direct)
+    const suiteFlag = opts?.suite;
+    const workspaceFlag = opts?.workspace;
+    const yes = opts?.yes ?? false;
+    const nonInteractive = !process.stdout.isTTY;
+    try {
+        // Step 1: Load suites
+        (0, logger_1.logStep)(1, 7, 'Loading suites...');
+        const suites = await (0, suite_1.listSuites)();
+        if (suites.length === 0) {
+            (0, logger_1.logError)('No suites found. Create one first with: workspace suite-create');
+            process.exit(1);
+        }
+        (0, logger_1.logSuccess)(`Found ${suites.length} suite(s)`);
+        // Step 2: Select suite
+        (0, logger_1.logStep)(2, 7, 'Select suite...');
+        if (!suiteFlag && nonInteractive) {
+            (0, logger_1.logError)("Missing required option: --suite");
+            (0, logger_1.logError)("Usage: w suite use --suite <name> --workspace <name>");
+            process.exit(1);
+        }
+        let selectedSuite;
+        if (suiteFlag) {
+            const found = suites.find(s => s.name === suiteFlag);
+            if (!found) {
+                (0, logger_1.logError)(`Suite not found: ${suiteFlag}`);
+                (0, logger_1.logError)(`Available suites: ${suites.map(s => s.name).join(', ')}`);
+                process.exit(1);
+            }
+            selectedSuite = found;
+        }
+        else {
+            const { suite } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'suite',
+                    message: 'Select a suite:',
+                    choices: suites.map(s => ({
+                        name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
+                        value: s,
+                        short: s.name,
+                    })),
+                    pageSize: 15,
+                },
+            ]);
+            selectedSuite = suite;
+        }
+        console.log(`\n${(0, colors_1.colorize)('Suite repositories:', 'cyan')} ${selectedSuite.entries.length}`);
+        for (const entry of selectedSuite.entries) {
+            const alias = entry.directoryName !== entry.repoName ? ` (${entry.repoName})` : '';
+            console.log(`  - ${entry.directoryName}${alias}`);
+        }
+        console.log('');
+        // Step 3: Verify gh CLI authentication
+        (0, logger_1.logStep)(3, 7, 'Verifying GitHub CLI authentication...');
+        const isAuthenticated = await (0, github_1.verifyGhAuth)();
+        if (!isAuthenticated) {
+            (0, logger_1.logError)('GitHub CLI is not authenticated');
+            (0, github_1.displayAuthInstructions)();
+            process.exit(1);
+        }
+        (0, logger_1.logSuccess)('GitHub CLI authenticated');
+        // Step 4: Fetch repos and resolve suite entries
+        (0, logger_1.logStep)(4, 7, 'Fetching repositories...');
+        const forceRefresh = opts?.forceRefresh ?? false;
+        const allRepos = await (0, github_1.fetchOrgRepos)({ forceRefresh });
+        const repoMap = new Map(allRepos.map(repo => [repo.name, repo]));
+        const resolvedEntries = [];
+        const missing = [];
+        for (const entry of selectedSuite.entries) {
+            const repo = repoMap.get(entry.repoName);
+            if (repo) {
+                resolvedEntries.push({ repo, directoryName: entry.directoryName });
+            }
+            else {
+                missing.push(entry.repoName);
+            }
+        }
+        if (missing.length > 0) {
+            (0, logger_1.logInfo)(`${missing.length} repositories from suite not found or not accessible:`);
+            missing.forEach(name => console.log(`  - ${(0, colors_1.colorize)(name, 'yellow')}`));
+            console.log('');
+        }
+        if (resolvedEntries.length === 0) {
+            (0, logger_1.logError)('No repositories from the suite are available');
+            process.exit(1);
+        }
+        (0, logger_1.logInfo)(`${resolvedEntries.length} repositories will be cloned`);
+        // Step 5: Workspace name
+        (0, logger_1.logStep)(5, 7, 'Enter workspace name...');
+        if (!workspaceFlag && nonInteractive) {
+            (0, logger_1.logError)("Missing required option: --workspace");
+            (0, logger_1.logError)("Usage: w suite use --suite <name> --workspace <name>");
+            process.exit(1);
+        }
+        let workspaceName;
+        if (workspaceFlag) {
+            workspaceName = (0, validation_1.sanitizeWorkspaceName)(workspaceFlag);
+            const validation = (0, validation_1.validateWorkspaceName)(workspaceName);
+            if (validation !== true) {
+                (0, logger_1.logError)(typeof validation === 'string' ? validation : 'Invalid workspace name');
+                process.exit(1);
+            }
+            const exists = await (0, validation_1.checkWorkspaceExists)(workspaceName);
+            if (exists) {
+                const repoNames = selectedSuite.entries.map(e => e.repoName);
+                const resolved = await (0, validation_1.resolveWorkspaceNameConflict)(workspaceName, repoNames);
+                (0, logger_1.logInfo)(`Workspace "${workspaceName}" already exists — using "${(0, colors_1.colorize)(resolved, 'cyan')}" instead.`);
+                workspaceName = resolved;
+            }
+        }
+        else {
+            workspaceName = await (0, prompts_1.promptWorkspaceName)();
+            // Auto-resolve conflict in case the interactively chosen name already exists
+            const interactiveExists = await (0, validation_1.checkWorkspaceExists)(workspaceName);
+            if (interactiveExists) {
+                const repoNames = selectedSuite.entries.map(e => e.repoName);
+                const resolved = await (0, validation_1.resolveWorkspaceNameConflict)(workspaceName, repoNames);
+                (0, logger_1.logInfo)(`Workspace "${workspaceName}" already exists — using "${(0, colors_1.colorize)(resolved, 'cyan')}" instead.`);
+                workspaceName = resolved;
+            }
+        }
+        const workspacePath = path.join(config_1.WORKSPACES_DIR, workspaceName);
+        // Step 6: Confirm creation
+        (0, logger_1.logStep)(6, 7, 'Confirm workspace creation...');
+        if (!yes) {
+            const confirmed = await (0, prompts_1.confirmWorkspaceCreation)(workspaceName, resolvedEntries.length, workspacePath);
+            if (!confirmed) {
+                (0, logger_1.logInfo)('Workspace creation cancelled');
+                process.exit(0);
+            }
+        }
+        // Step 7: Create workspace and clone repositories
+        (0, logger_1.logStep)(7, 7, 'Creating workspace from suite...');
+        await fs.mkdir(workspacePath, { recursive: true });
+        (0, logger_1.logSuccess)(`Created workspace directory: ${workspacePath}`);
+        const cloneResults = await (0, git_operations_1.cloneRepositories)(resolvedEntries, workspacePath);
+        const metadata = (0, workspace_meta_1.createMetadata)(workspaceName, cloneResults);
+        await (0, workspace_meta_1.saveMetadata)(workspacePath, metadata);
+        (0, git_operations_1.reportCloneResults)(cloneResults);
+        if (selectedSuite.postCloneHooks?.length) {
+            await (0, hooks_1.runPostCloneHooks)(workspacePath, metadata.repositories.filter(r => r.status === 'success'), selectedSuite.postCloneHooks);
+        }
+        const successfulRepos = cloneResults
+            .filter(r => r.status === 'success')
+            .map(r => r.repo);
+        if (successfulRepos.length > 0) {
+            (0, logger_1.logInfo)('Setting up Claude Code integration...');
+            await (0, claude_integration_1.generateClaudeContext)(workspacePath, workspaceName, successfulRepos, metadata);
+        }
+        const tempFile = path.join(process.env.HOME || '~', '.workspace-last-created');
+        try {
+            await fs.writeFile(tempFile, workspacePath, 'utf-8');
+        }
+        catch {
+            // Ignore errors writing temp file
+        }
+        (0, logger_1.logSuccess)('Workspace created from suite successfully!');
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to create workspace from suite');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+}
+if (require.main === module)
+    main();

package/dist/commands/sync.js

@@ -0,0 +1,117 @@
+"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.registerSyncCommand = registerSyncCommand;
+const path = __importStar(require("path"));
+const config_1 = require("../utils/config");
+const workspace_meta_1 = require("../utils/workspace-meta");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const progress_1 = require("../utils/progress");
+const sync_operations_1 = require("../utils/sync-operations");
+const command_helpers_1 = require("../utils/command-helpers");
+function registerSyncCommand(parent) {
+    parent
+        .command('sync')
+        .alias('s')
+        .description('Git pull all repos in a workspace')
+        .argument('[workspace]', 'Workspace name')
+        .option('-w, --workspace <name>', 'Workspace name (alternative to positional)')
+        .action(async (workspaceArg, opts) => {
+        await handleSync(opts.workspace || workspaceArg);
+    });
+}
+async function handleSync(workspaceArg) {
+    console.log('\n' + '='.repeat(60));
+    console.log((0, colors_1.colorize)('Sync Workspace', 'bright'));
+    console.log('='.repeat(60) + '\n');
+    try {
+        const workspaceName = await (0, command_helpers_1.resolveWorkspace)(workspaceArg);
+        const workspacePath = path.join(config_1.WORKSPACES_DIR, workspaceName);
+        (0, logger_1.logInfo)(`Syncing workspace: ${(0, colors_1.colorize)(workspaceName, 'cyan')}`);
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        if (!metadata) {
+            (0, logger_1.logError)('No metadata found for this workspace');
+            process.exit(1);
+        }
+        const repos = metadata.repositories.filter(r => r.status === 'success');
+        console.log(`\nFound ${repos.length} repositories to sync\n`);
+        const results = [];
+        const bar = (0, progress_1.createSimpleProgressBar)(repos.length, 'Syncing');
+        bar.start(repos.length, 0);
+        for (const repo of repos) {
+            const repoPath = path.join(workspacePath, repo.directoryName);
+            const displayName = repo.directoryName !== repo.name
+                ? `${repo.directoryName} (${repo.name})`
+                : repo.name;
+            const result = await (0, sync_operations_1.syncRepository)(repoPath, displayName, true);
+            results.push(result);
+            bar.update(results.length);
+        }
+        bar.stop();
+        console.log('');
+        console.log('\n' + '='.repeat(60));
+        console.log('Sync Results Summary');
+        console.log('='.repeat(60));
+        const successful = results.filter(r => r.status === 'success');
+        const failed = results.filter(r => r.status === 'failed');
+        const skipped = results.filter(r => r.status === 'skipped');
+        console.log(`${(0, colors_1.colorize)('✓', 'green')} Updated: ${successful.length}`);
+        console.log(`${(0, colors_1.colorize)('✗', 'red')} Failed: ${failed.length}`);
+        console.log(`${(0, colors_1.colorize)('○', 'yellow')} Skipped: ${skipped.length}`);
+        console.log('='.repeat(60));
+        if (failed.length > 0) {
+            console.log('\nFailed repositories:');
+            failed.forEach(result => {
+                console.log(`  ${(0, colors_1.colorize)('✗', 'red')} ${result.repo}: ${result.message}`);
+            });
+        }
+        if (skipped.length > 0) {
+            console.log('\nSkipped repositories:');
+            skipped.forEach(result => {
+                console.log(`  ${(0, colors_1.colorize)('○', 'yellow')} ${result.repo}: ${result.message}`);
+            });
+        }
+        console.log('');
+        (0, logger_1.logSuccess)('Workspace sync complete!');
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to sync workspace');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/update.js

@@ -0,0 +1,203 @@
+"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.registerUpdateCommand = registerUpdateCommand;
+const path = __importStar(require("path"));
+const config_1 = require("../utils/config");
+const github_1 = require("../utils/github");
+const prompts_1 = require("../utils/prompts");
+const git_operations_1 = require("../utils/git-operations");
+const ghq_integration_1 = require("../utils/ghq-integration");
+const workspace_meta_1 = require("../utils/workspace-meta");
+const claude_integration_1 = require("../utils/claude-integration");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const command_helpers_1 = require("../utils/command-helpers");
+const repo_resolver_1 = require("../utils/repo-resolver");
+function registerUpdateCommand(parent) {
+    parent
+        .command('update')
+        .alias('u')
+        .description('Add repositories to an existing workspace')
+        .option('-w, --workspace <name>', 'Workspace name')
+        .option('-r, --repos <repos>', 'Comma-separated repository names. Add a suffix to clone the same repo again under a separate folder, e.g. casper:cas-101 -> casper-cas-101')
+        .action(async (opts, cmd) => {
+        const globalOpts = (0, command_helpers_1.getGlobalOpts)(cmd);
+        await handleUpdate({ ...opts, ...globalOpts });
+    });
+}
+async function handleUpdate(opts) {
+    console.log('\n' + '='.repeat(60));
+    console.log((0, colors_1.colorize)('Update Workspace', 'bright'));
+    console.log('='.repeat(60) + '\n');
+    try {
+        // Step 1: Verify gh CLI authentication
+        (0, logger_1.logStep)(1, 5, 'Verifying GitHub CLI authentication...');
+        const isAuthenticated = await (0, github_1.verifyGhAuth)();
+        if (!isAuthenticated) {
+            (0, logger_1.logError)('GitHub CLI is not authenticated');
+            (0, github_1.displayAuthInstructions)();
+            process.exit(1);
+        }
+        (0, logger_1.logSuccess)('GitHub CLI authenticated');
+        // Step 2: List and select workspace
+        (0, logger_1.logStep)(2, 5, 'Select workspace to update...');
+        const workspaceName = await (0, command_helpers_1.resolveWorkspace)(opts.workspace);
+        const workspacePath = path.join(config_1.WORKSPACES_DIR, workspaceName);
+        (0, logger_1.logInfo)(`Selected workspace: ${(0, colors_1.colorize)(workspaceName, 'cyan')}`);
+        // Load existing metadata
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        const existingDirectoryNames = metadata?.repositories.map(r => r.directoryName) || [];
+        // Duplicate detection is by directory name (the actual folder). The same
+        // repo CAN be added again under a different suffix (e.g. casper:cas-101 ->
+        // casper-cas-101), so we must NOT block on the canonical repo name.
+        const existingDirSet = new Set(existingDirectoryNames);
+        console.log(`\nCurrent repositories: ${existingDirectoryNames.length}`);
+        metadata?.repositories.forEach(r => {
+            const displayName = r.directoryName !== r.name
+                ? `${r.directoryName} (${r.name})`
+                : r.name;
+            console.log(`  - ${displayName}`);
+        });
+        console.log('');
+        // Step 3: Fetch all available repos
+        (0, logger_1.logStep)(3, 5, 'Fetching repositories...');
+        const allRepos = await (0, github_1.fetchOrgRepos)({ forceRefresh: opts.forceRefresh });
+        if (allRepos.length === 0) {
+            (0, logger_1.logError)('No repositories found');
+            process.exit(1);
+        }
+        // Step 4: Select new repositories to add
+        (0, logger_1.logStep)(4, 5, 'Select additional repositories to clone...');
+        let selectedEntries;
+        if (opts.repos) {
+            const repoSpecs = (0, command_helpers_1.parseList)(opts.repos);
+            const { resolved, notFound, invalidSuffix } = (0, repo_resolver_1.resolveRepoSpecs)(repoSpecs, allRepos);
+            if (invalidSuffix.length > 0) {
+                (0, logger_1.logError)(`Invalid instance suffix in: ${invalidSuffix.join(', ')}`);
+                (0, logger_1.logInfo)('Use repo:suffix (e.g. casper:cas-101). Suffix may contain letters, numbers, hyphens, underscores.');
+                process.exit(1);
+            }
+            // Warn about fuzzy-resolved names
+            for (const r of resolved) {
+                if (!r.exact)
+                    (0, logger_1.logWarning)(`Repo "${r.input}" not found exactly — using "${r.repo.name}" (best match)`);
+            }
+            const duplicates = resolved.filter(r => existingDirSet.has(r.directoryName));
+            selectedEntries = resolved
+                .filter(r => !existingDirSet.has(r.directoryName))
+                .map(r => ({ repo: r.repo, directoryName: r.directoryName }));
+            if (duplicates.length > 0) {
+                (0, logger_1.logWarning)(`Skipping entries whose directory already exists: ${duplicates.map(r => r.directoryName).join(', ')}`);
+            }
+            if (notFound.length > 0) {
+                (0, logger_1.logError)(`Repositories not found: ${notFound.join(', ')}`);
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(`\n${allRepos.length} repositories available to add\n`);
+            selectedEntries = await (0, prompts_1.promptRepositorySelection)(allRepos, existingDirectoryNames);
+        }
+        if (selectedEntries.length === 0) {
+            (0, logger_1.logInfo)('No new repositories selected');
+            process.exit(0);
+        }
+        (0, logger_1.logInfo)(`Selected ${selectedEntries.length} new repositories to add`);
+        // Step 5: Clone new repositories
+        (0, logger_1.logStep)(5, 5, 'Cloning new repositories...');
+        await (0, ghq_integration_1.warnIfGhqMissing)();
+        const cloneResults = await (0, git_operations_1.cloneRepositories)(selectedEntries, workspacePath);
+        // Update metadata — create from scratch if the workspace had none
+        const newRepoMetadata = cloneResults.map(result => ({
+            name: result.repo.name,
+            directoryName: result.directoryName,
+            owner: result.repo.owner.login,
+            clonedAt: result.clonedAt || new Date().toISOString(),
+            cloneUrl: (0, config_1.getCloneUrl)(result.repo),
+            status: result.status,
+            error: result.error,
+        }));
+        let finalMetadata;
+        if (metadata) {
+            metadata.repositories.push(...newRepoMetadata);
+            metadata.lastModified = new Date().toISOString();
+            await (0, workspace_meta_1.saveMetadata)(workspacePath, metadata);
+            finalMetadata = metadata;
+        }
+        else {
+            // Workspace had no metadata file — create one now
+            const fresh = {
+                workspaceName,
+                createdAt: new Date().toISOString(),
+                lastModified: new Date().toISOString(),
+                repositories: newRepoMetadata,
+            };
+            await (0, workspace_meta_1.saveMetadata)(workspacePath, fresh);
+            finalMetadata = fresh;
+        }
+        // Regenerate the agent context (CLAUDE.md/AGENTS.md) + .mcp.json so the
+        // newly added repos actually surface — otherwise an investigate-first
+        // workspace keeps saying "0 repositories" and its context stays stale.
+        // Resolve the FULL remaining set (existing + new) to catalog objects so
+        // pre-existing repos keep their descriptions/URLs on regenerate (matches
+        // the remove-repo path). Best-effort: never fail the update over this.
+        const repoObjects = finalMetadata.repositories
+            .filter(r => r.status === 'success')
+            .map(r => allRepos.find(ar => ar.name === r.name))
+            .filter((r) => r != null);
+        // Only regenerate when this update actually added a repo — a failure-only
+        // update must not rewrite (and clobber) the existing context.
+        const addedNewRepo = cloneResults.some(r => r.status === 'success');
+        try {
+            if (addedNewRepo && repoObjects.length > 0) {
+                await (0, claude_integration_1.generateClaudeContext)(workspacePath, workspaceName, repoObjects, finalMetadata);
+            }
+        }
+        catch { /* context regen is best-effort */ }
+        // Report results
+        (0, git_operations_1.reportCloneResults)(cloneResults);
+        const totalRepos = existingDirectoryNames.length + cloneResults.filter(r => r.status === 'success').length;
+        console.log(`Workspace now has ${(0, colors_1.colorize)(String(totalRepos), 'cyan')} repositories\n`);
+        (0, logger_1.logSuccess)('Workspace updated successfully!');
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to update workspace');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+}