@nemus-cli/nemus 0.2.1

package/src/commands/suite/use.ts

@@ -0,0 +1,232 @@
+#!/usr/bin/env ts-node
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../../utils/config';
+import { fetchOrgRepos, verifyGhAuth, displayAuthInstructions } from '../../utils/github';
+import { promptWorkspaceName, confirmWorkspaceCreation } from '../../utils/prompts';
+import { cloneRepositories, reportCloneResults } from '../../utils/git-operations';
+import { createMetadata, saveMetadata } from '../../utils/workspace-meta';
+import { generateClaudeContext } from '../../utils/claude-integration';
+import { logInfo, logSuccess, logError, logStep } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import { listSuites } from '../../utils/suite';
+import { runPostCloneHooks } from '../../utils/hooks';
+import { GitHubRepo } from '../../types';
+import inquirer from 'inquirer';
+import { validateWorkspaceName, checkWorkspaceExists, sanitizeWorkspaceName, resolveWorkspaceNameConflict } from '../../utils/validation';
+
+export interface SuiteUseOpts {
+  suite?: string;
+  workspace?: string;
+  yes?: boolean;
+  forceRefresh?: boolean;
+}
+
+export async function main(opts?: SuiteUseOpts) {
+  console.log('\n' + '='.repeat(60));
+  console.log(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
+    logStep(1, 7, 'Loading suites...');
+    const suites = await listSuites();
+
+    if (suites.length === 0) {
+      logError('No suites found. Create one first with: workspace suite-create');
+      process.exit(1);
+    }
+
+    logSuccess(`Found ${suites.length} suite(s)`);
+
+    // Step 2: Select suite
+    logStep(2, 7, 'Select suite...');
+    if (!suiteFlag && nonInteractive) {
+      logError("Missing required option: --suite"); logError("Usage: w suite use --suite <name> --workspace <name>");
+      process.exit(1);
+    }
+
+    let selectedSuite: typeof suites[0];
+
+    if (suiteFlag) {
+      const found = suites.find(s => s.name === suiteFlag);
+      if (!found) {
+        logError(`Suite not found: ${suiteFlag}`);
+        logError(`Available suites: ${suites.map(s => s.name).join(', ')}`);
+        process.exit(1);
+      }
+      selectedSuite = found;
+    } else {
+      const { suite } = await inquirer.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${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
+    logStep(3, 7, 'Verifying GitHub CLI authentication...');
+    const isAuthenticated = await verifyGhAuth();
+
+    if (!isAuthenticated) {
+      logError('GitHub CLI is not authenticated');
+      displayAuthInstructions();
+      process.exit(1);
+    }
+
+    logSuccess('GitHub CLI authenticated');
+
+    // Step 4: Fetch repos and resolve suite entries
+    logStep(4, 7, 'Fetching repositories...');
+    const forceRefresh = opts?.forceRefresh ?? false;
+    const allRepos = await fetchOrgRepos({ forceRefresh });
+    const repoMap = new Map(allRepos.map(repo => [repo.name, repo]));
+
+    const resolvedEntries: Array<{ repo: GitHubRepo; directoryName: string }> = [];
+    const missing: string[] = [];
+
+    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) {
+      logInfo(`${missing.length} repositories from suite not found or not accessible:`);
+      missing.forEach(name => console.log(`  - ${colorize(name, 'yellow')}`));
+      console.log('');
+    }
+
+    if (resolvedEntries.length === 0) {
+      logError('No repositories from the suite are available');
+      process.exit(1);
+    }
+
+    logInfo(`${resolvedEntries.length} repositories will be cloned`);
+
+    // Step 5: Workspace name
+    logStep(5, 7, 'Enter workspace name...');
+    if (!workspaceFlag && nonInteractive) {
+      logError("Missing required option: --workspace"); logError("Usage: w suite use --suite <name> --workspace <name>");
+      process.exit(1);
+    }
+
+    let workspaceName: string;
+
+    if (workspaceFlag) {
+      workspaceName = sanitizeWorkspaceName(workspaceFlag);
+      const validation = validateWorkspaceName(workspaceName);
+      if (validation !== true) {
+        logError(typeof validation === 'string' ? validation : 'Invalid workspace name');
+        process.exit(1);
+      }
+      const exists = await checkWorkspaceExists(workspaceName);
+      if (exists) {
+        const repoNames = selectedSuite.entries.map(e => e.repoName);
+        const resolved = await resolveWorkspaceNameConflict(workspaceName, repoNames);
+        logInfo(`Workspace "${workspaceName}" already exists — using "${colorize(resolved, 'cyan')}" instead.`);
+        workspaceName = resolved;
+      }
+    } else {
+      workspaceName = await promptWorkspaceName();
+      // Auto-resolve conflict in case the interactively chosen name already exists
+      const interactiveExists = await checkWorkspaceExists(workspaceName);
+      if (interactiveExists) {
+        const repoNames = selectedSuite.entries.map(e => e.repoName);
+        const resolved = await resolveWorkspaceNameConflict(workspaceName, repoNames);
+        logInfo(`Workspace "${workspaceName}" already exists — using "${colorize(resolved, 'cyan')}" instead.`);
+        workspaceName = resolved;
+      }
+    }
+
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName!);
+
+    // Step 6: Confirm creation
+    logStep(6, 7, 'Confirm workspace creation...');
+    if (!yes) {
+      const confirmed = await confirmWorkspaceCreation(
+        workspaceName!,
+        resolvedEntries.length,
+        workspacePath
+      );
+
+      if (!confirmed) {
+        logInfo('Workspace creation cancelled');
+        process.exit(0);
+      }
+    }
+
+    // Step 7: Create workspace and clone repositories
+    logStep(7, 7, 'Creating workspace from suite...');
+
+    await fs.mkdir(workspacePath, { recursive: true });
+    logSuccess(`Created workspace directory: ${workspacePath}`);
+
+    const cloneResults = await cloneRepositories(resolvedEntries, workspacePath);
+
+    const metadata = createMetadata(workspaceName!, cloneResults);
+    await saveMetadata(workspacePath, metadata);
+
+    reportCloneResults(cloneResults);
+
+    if (selectedSuite.postCloneHooks?.length) {
+      await 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) {
+      logInfo('Setting up Claude Code integration...');
+      await 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
+    }
+
+    logSuccess('Workspace created from suite successfully!');
+  } catch (error) {
+    logError('Failed to create workspace from suite');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();

package/src/commands/sync.ts

@@ -0,0 +1,97 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata } from '../utils/workspace-meta';
+import { logInfo, logSuccess, logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { createSimpleProgressBar } from '../utils/progress';
+import { syncRepository, SyncResult } from '../utils/sync-operations';
+import { resolveWorkspace } from '../utils/command-helpers';
+
+export function registerSyncCommand(parent: Command) {
+  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?: string) {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Sync Workspace', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const workspaceName = await resolveWorkspace(workspaceArg);
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+
+    logInfo(`Syncing workspace: ${colorize(workspaceName, 'cyan')}`);
+
+    const metadata = await loadMetadata(workspacePath);
+    if (!metadata) {
+      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: SyncResult[] = [];
+    const bar = 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 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(`${colorize('✓', 'green')} Updated: ${successful.length}`);
+    console.log(`${colorize('✗', 'red')} Failed: ${failed.length}`);
+    console.log(`${colorize('○', 'yellow')} Skipped: ${skipped.length}`);
+    console.log('='.repeat(60));
+
+    if (failed.length > 0) {
+      console.log('\nFailed repositories:');
+      failed.forEach(result => {
+        console.log(`  ${colorize('✗', 'red')} ${result.repo}: ${result.message}`);
+      });
+    }
+
+    if (skipped.length > 0) {
+      console.log('\nSkipped repositories:');
+      skipped.forEach(result => {
+        console.log(`  ${colorize('○', 'yellow')} ${result.repo}: ${result.message}`);
+      });
+    }
+
+    console.log('');
+    logSuccess('Workspace sync complete!');
+
+  } catch (error) {
+    logError('Failed to sync workspace');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/update.ts

@@ -0,0 +1,197 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR, getCloneUrl } from '../utils/config';
+import { verifyGhAuth, fetchOrgRepos, displayAuthInstructions } from '../utils/github';
+import { promptRepositorySelection, promptWorkspaceSelection } from '../utils/prompts';
+import { cloneRepositories, reportCloneResults } from '../utils/git-operations';
+import { warnIfGhqMissing } from '../utils/ghq-integration';
+import { loadMetadata, saveMetadata, listWorkspaces } from '../utils/workspace-meta';
+import { generateClaudeContext } from '../utils/claude-integration';
+import { logInfo, logSuccess, logError, logStep, logWarning } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { getGlobalOpts, resolveWorkspace, parseList } from '../utils/command-helpers';
+import { resolveRepoSpecs } from '../utils/repo-resolver';
+
+export function registerUpdateCommand(parent: Command) {
+  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 = getGlobalOpts(cmd);
+      await handleUpdate({ ...opts, ...globalOpts });
+    });
+}
+
+async function handleUpdate(opts: {
+  workspace?: string;
+  repos?: string;
+  forceRefresh: boolean;
+  yes: boolean;
+}) {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Update Workspace', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    // Step 1: Verify gh CLI authentication
+    logStep(1, 5, 'Verifying GitHub CLI authentication...');
+    const isAuthenticated = await verifyGhAuth();
+
+    if (!isAuthenticated) {
+      logError('GitHub CLI is not authenticated');
+      displayAuthInstructions();
+      process.exit(1);
+    }
+
+    logSuccess('GitHub CLI authenticated');
+
+    // Step 2: List and select workspace
+    logStep(2, 5, 'Select workspace to update...');
+    const workspaceName = await resolveWorkspace(opts.workspace);
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+
+    logInfo(`Selected workspace: ${colorize(workspaceName, 'cyan')}`);
+
+    // Load existing metadata
+    const metadata = await 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
+    logStep(3, 5, 'Fetching repositories...');
+    const allRepos = await fetchOrgRepos({ forceRefresh: opts.forceRefresh });
+
+    if (allRepos.length === 0) {
+      logError('No repositories found');
+      process.exit(1);
+    }
+
+    // Step 4: Select new repositories to add
+    logStep(4, 5, 'Select additional repositories to clone...');
+
+    let selectedEntries;
+
+    if (opts.repos) {
+      const repoSpecs = parseList(opts.repos);
+      const { resolved, notFound, invalidSuffix } = resolveRepoSpecs(repoSpecs, allRepos);
+
+      if (invalidSuffix.length > 0) {
+        logError(`Invalid instance suffix in: ${invalidSuffix.join(', ')}`);
+        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) 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) {
+        logWarning(`Skipping entries whose directory already exists: ${duplicates.map(r => r.directoryName).join(', ')}`);
+      }
+      if (notFound.length > 0) {
+        logError(`Repositories not found: ${notFound.join(', ')}`);
+        process.exit(1);
+      }
+    } else {
+      console.log(`\n${allRepos.length} repositories available to add\n`);
+      selectedEntries = await promptRepositorySelection(allRepos, existingDirectoryNames);
+    }
+
+    if (selectedEntries.length === 0) {
+      logInfo('No new repositories selected');
+      process.exit(0);
+    }
+
+    logInfo(`Selected ${selectedEntries.length} new repositories to add`);
+
+    // Step 5: Clone new repositories
+    logStep(5, 5, 'Cloning new repositories...');
+
+    await warnIfGhqMissing();
+    const cloneResults = await 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: getCloneUrl(result.repo),
+      status: result.status as 'success' | 'failed',
+      error: result.error,
+    }));
+
+    let finalMetadata;
+    if (metadata) {
+      metadata.repositories.push(...newRepoMetadata);
+      metadata.lastModified = new Date().toISOString();
+      await 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 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 is NonNullable<typeof 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 generateClaudeContext(workspacePath, workspaceName, repoObjects, finalMetadata);
+      }
+    } catch { /* context regen is best-effort */ }
+
+    // Report results
+    reportCloneResults(cloneResults);
+
+    const totalRepos = existingDirectoryNames.length + cloneResults.filter(r => r.status === 'success').length;
+    console.log(`Workspace now has ${colorize(String(totalRepos), 'cyan')} repositories\n`);
+
+    logSuccess('Workspace updated successfully!');
+
+  } catch (error) {
+    logError('Failed to update workspace');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}