@nemus-cli/nemus 0.2.1

package/src/commands/archive.ts

@@ -0,0 +1,114 @@
+import { Command } from 'commander';
+import { listWorkspaces, archiveWorkspace, unarchiveWorkspace } from '../utils/workspace-meta';
+import { promptMultiWorkspaceSelection } from '../utils/prompts';
+import { logInfo, logSuccess, logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import { getGlobalOpts, parseList } from '../utils/command-helpers';
+
+export function registerArchiveCommand(parent: Command) {
+  parent
+    .command('archive')
+    .alias('a')
+    .description('Archive a workspace (30-day expiry)')
+    .option('-w, --workspace <names>', 'Comma-separated workspace names')
+    .option('--unarchive', 'Unarchive a previously archived workspace')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      await handleArchive({ ...opts, ...globalOpts });
+    });
+}
+
+async function handleArchive(opts: {
+  workspace?: string;
+  unarchive?: boolean;
+  yes: boolean;
+  forceRefresh: boolean;
+}) {
+  const isUnarchive = opts.unarchive ?? false;
+  const title = isUnarchive ? 'Unarchive Workspace' : 'Archive Workspace';
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize(title, 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    if (isUnarchive) {
+      const allWorkspaces = await listWorkspaces(true);
+      const archivedWorkspaces = allWorkspaces.filter(ws => ws.metadata?.archivedAt);
+
+      if (archivedWorkspaces.length === 0) {
+        logInfo('No archived workspaces found');
+        return;
+      }
+
+      let selectedNames: string[];
+
+      if (opts.workspace) {
+        selectedNames = parseList(opts.workspace);
+      } else {
+        selectedNames = await promptMultiWorkspaceSelection(archivedWorkspaces);
+      }
+
+      if (!opts.yes) {
+        const { confirmed } = await inquirer.prompt([{
+          type: 'confirm', name: 'confirmed',
+          message: selectedNames.length === 1
+            ? `Unarchive workspace ${selectedNames[0]}?`
+            : `Unarchive these ${selectedNames.length} workspaces?`,
+          default: true,
+        }]);
+        if (!confirmed) return;
+      }
+
+      for (const name of selectedNames) {
+        try {
+          await unarchiveWorkspace(name);
+          logSuccess(`Unarchived "${colorize(name, 'cyan')}"`);
+        } catch (error) {
+          logError(`Failed to unarchive "${name}"`);
+          if (error instanceof Error) logError(error.message);
+        }
+      }
+    } else {
+      const workspaces = await listWorkspaces(false);
+
+      if (workspaces.length === 0) {
+        logInfo('No active workspaces found');
+        return;
+      }
+
+      let selectedNames: string[];
+
+      if (opts.workspace) {
+        selectedNames = parseList(opts.workspace);
+      } else {
+        selectedNames = await promptMultiWorkspaceSelection(workspaces);
+      }
+
+      if (!opts.yes) {
+        const { confirmed } = await inquirer.prompt([{
+          type: 'confirm', name: 'confirmed',
+          message: selectedNames.length === 1
+            ? `Archive workspace ${selectedNames[0]}? It will be auto-deleted in 30 days.`
+            : `Archive these ${selectedNames.length} workspaces? They will be auto-deleted in 30 days.`,
+          default: true,
+        }]);
+        if (!confirmed) return;
+      }
+
+      for (const name of selectedNames) {
+        try {
+          await archiveWorkspace(name);
+          logSuccess(`Archived "${colorize(name, 'cyan')}" - will be auto-deleted in 30 days`);
+        } catch (error) {
+          logError(`Failed to archive "${name}"`);
+          if (error instanceof Error) logError(error.message);
+        }
+      }
+    }
+  } catch (error) {
+    logError(`Failed to ${isUnarchive ? 'unarchive' : 'archive'} workspace`);
+    if (error instanceof Error) { logError(error.message); }
+    process.exit(1);
+  }
+}

package/src/commands/branch/create.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import * as path from 'path';
+import { listWorkspaces, loadMetadata } from '../../utils/workspace-meta';
+import { promptWorkspaceSelection } from '../../utils/prompts';
+import { createBranch } from '../../utils/branch-operations';
+import { logError, logInfo, logStep, logSuccess, logWarning } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import { WORKSPACES_DIR } from '../../utils/config';
+import inquirer from 'inquirer';
+
+export interface BranchCreateOpts {
+  workspace?: string;
+  branch?: string;
+  base?: string;
+  force?: boolean;
+}
+
+export const main = async (opts?: BranchCreateOpts) => {
+  try {
+    let workspaceName = opts?.workspace;
+    let branchName = opts?.branch;
+    const baseBranch = opts?.base;
+    const force = opts?.force ?? false;
+
+    // Resolve workspace interactively if needed
+    if (!workspaceName) {
+      if (!process.stdout.isTTY) {
+        logError('Missing required option: --workspace');
+        logError('Usage: w branch create --workspace <name> --branch <branch>');
+        process.exit(1);
+      }
+      const workspaces = await listWorkspaces();
+      workspaceName = await promptWorkspaceSelection(workspaces);
+    }
+
+    // Resolve branch interactively if needed
+    if (!branchName) {
+      if (!process.stdout.isTTY) {
+        logError('Missing required option: --branch');
+        logError('Usage: w branch create --workspace <name> --branch <branch>');
+        process.exit(1);
+      }
+      const { branch } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'branch',
+          message: 'New branch name:',
+          validate: (input: string) => input.trim() ? true : 'Branch name cannot be empty',
+        },
+      ]);
+      branchName = branch;
+    }
+
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName!);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace not found: ${workspaceName}`);
+      process.exit(1);
+    }
+
+    logStep(`Creating branch ${colorize(branchName!, 'cyan')} across all repositories...`);
+
+    const results = [];
+    for (const repo of metadata.repositories) {
+      const repoPath = path.join(workspacePath, repo.directoryName);
+      const result = await createBranch(repoPath, repo.directoryName, branchName!, baseBranch, force);
+      results.push(result);
+
+      if (result.success) {
+        logSuccess(`${repo.directoryName}: ${result.message}`);
+      } else {
+        logWarning(`${repo.directoryName}: ${result.message}`);
+      }
+    }
+
+    const successful = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success).length;
+
+    console.log('');
+    logInfo(`Created branches in ${successful}/${results.length} repositories`);
+    if (failed > 0) {
+      logWarning(`${failed} repositories were skipped or failed`);
+    }
+  } catch (error) {
+    logError('Failed to create branches');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+};
+
+if (require.main === module) main();

package/src/commands/branch/index.ts

@@ -0,0 +1,74 @@
+import { Command } from 'commander';
+import { getGlobalOpts } from '../../utils/command-helpers';
+
+export function registerBranchCommands(parent: Command) {
+  const branch = parent
+    .command('branch')
+    .description('Branch management');
+
+  branch
+    .command('switch')
+    .description('Switch all repos to a specific branch')
+    .option('-w, --workspace <name>', 'Workspace name')
+    .option('-b, --branch <name>', 'Branch name')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      const { main } = await import('./switch');
+      await main({
+        workspace: opts.workspace,
+        branch: opts.branch,
+        yes: globalOpts.yes,
+      });
+    });
+
+  branch
+    .command('create')
+    .description('Create branches across all repos')
+    .argument('[workspace]', 'Workspace name')
+    .argument('[branch]', 'Branch name')
+    .option('-w, --workspace <name>', 'Workspace name (flag alternative)')
+    .option('-b, --branch <name>', 'Branch name (flag alternative)')
+    .option('--base <branch>', 'Base branch')
+    .option('--force', 'Force create')
+    .action(async (workspaceArg, branchArg, opts) => {
+      const { main } = await import('./create');
+      await main({
+        workspace: opts.workspace || workspaceArg,
+        branch: opts.branch || branchArg,
+        base: opts.base,
+        force: opts.force,
+      });
+    });
+
+  branch
+    .command('merge')
+    .description('Merge branches across all repos')
+    .argument('<workspace>', 'Workspace name')
+    .argument('<source>', 'Source branch')
+    .argument('<target>', 'Target branch')
+    .option('--no-ff', 'No fast-forward')
+    .option('--ff-only', 'Fast-forward only')
+    .option('--squash', 'Squash merge')
+    .action(async (workspace, source, target, opts) => {
+      const { main } = await import('./merge');
+      await main({
+        workspace,
+        source,
+        target,
+        // Commander's --no-ff sets opts.ff = false
+        noFf: opts.ff === false,
+        ffOnly: opts.ffOnly,
+        squash: opts.squash,
+      });
+    });
+
+  branch
+    .command('rebase')
+    .description('Rebase branches across all repos')
+    .argument('<workspace>', 'Workspace name')
+    .argument('<base>', 'Base branch')
+    .action(async (workspace, base) => {
+      const { main } = await import('./rebase');
+      await main({ workspace, base });
+    });
+}

package/src/commands/branch/merge.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../../utils/config';
+import { loadMetadata } from '../../utils/workspace-meta';
+import { mergeBranch } from '../../utils/branch-operations';
+import { logError, logInfo, logStep, logSuccess, logWarning } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+
+
+export const main = async (opts?: { workspace?: string; source?: string; target?: string; noFf?: boolean; ffOnly?: boolean; squash?: boolean }) => {
+  try {
+    const workspaceName = opts?.workspace ?? process.argv[2];
+    const sourceBranch = opts?.source ?? process.argv[3];
+    const targetBranch = opts?.target ?? process.argv[4];
+
+    if (!workspaceName || !sourceBranch || !targetBranch) {
+      logError('Usage: workspace branch-merge <workspace> <source-branch> <target-branch> [--no-ff|--ff-only|--squash]');
+      process.exit(1);
+    }
+
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace not found: ${workspaceName}`);
+      process.exit(1);
+    }
+
+    const options = {
+      noFf: opts?.noFf ?? process.argv.includes('--no-ff'),
+      ffOnly: opts?.ffOnly ?? process.argv.includes('--ff-only'),
+      squash: opts?.squash ?? process.argv.includes('--squash'),
+    };
+
+    logStep(`Merging ${colorize(sourceBranch, 'cyan')} into ${colorize(targetBranch, 'cyan')}...`);
+
+    const results = [];
+    for (const repo of metadata.repositories) {
+      const repoPath = path.join(workspacePath, repo.name);
+      const result = await mergeBranch(repoPath, repo.name, sourceBranch, targetBranch, options);
+      results.push(result);
+
+      if (result.success) {
+        logSuccess(`${repo.name}: ${result.message}`);
+      } else {
+        logWarning(`${repo.name}: ${result.message} - ${result.error || ''}`);
+      }
+    }
+
+    const successful = results.filter(r => r.success).length;
+    logInfo(`Merged successfully in ${successful}/${results.length} repositories`);
+  } catch (error) {
+    logError('Failed to merge branches');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+};
+
+if (require.main === module) main();

package/src/commands/branch/rebase.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../../utils/config';
+import { loadMetadata } from '../../utils/workspace-meta';
+import { rebaseBranch } from '../../utils/branch-operations';
+import { logError, logInfo, logStep, logSuccess, logWarning } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+
+
+export const main = async (opts?: { workspace?: string; base?: string }) => {
+  try {
+    const workspaceName = opts?.workspace ?? process.argv[2];
+    const targetBranch = opts?.base ?? process.argv[3];
+
+    if (!workspaceName || !targetBranch) {
+      logError('Usage: workspace branch-rebase <workspace> <target-branch>');
+      process.exit(1);
+    }
+
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace not found: ${workspaceName}`);
+      process.exit(1);
+    }
+
+    logStep(`Rebasing onto ${colorize(targetBranch, 'cyan')}...`);
+
+    const results = [];
+    for (const repo of metadata.repositories) {
+      const repoPath = path.join(workspacePath, repo.name);
+      const result = await rebaseBranch(repoPath, repo.name, targetBranch);
+      results.push(result);
+
+      if (result.success) {
+        logSuccess(`${repo.name}: ${result.message}`);
+      } else {
+        logWarning(`${repo.name}: ${result.message} - ${result.error || ''}`);
+      }
+    }
+
+    const successful = results.filter(r => r.success).length;
+    logInfo(`Rebased successfully in ${successful}/${results.length} repositories`);
+  } catch (error) {
+    logError('Failed to rebase branches');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+};
+
+if (require.main === module) main();

package/src/commands/branch/switch.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env ts-node
+
+import { WORKSPACES_DIR } from '../../utils/config';
+import * as path from 'path';
+import { listWorkspaces, loadMetadata } from '../../utils/workspace-meta';
+import { promptWorkspaceSelection } from '../../utils/prompts';
+import { logInfo, logSuccess, logError, logWarning } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import { switchBranch, BranchSwitchResult } from '../../utils/branch-operations';
+import inquirer from 'inquirer';
+
+export interface BranchSwitchOpts {
+  workspace?: string;
+  branch?: string;
+  yes?: boolean;
+}
+
+export async function main(opts?: BranchSwitchOpts) {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Bulk Branch Switch', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  const yes = opts?.yes ?? false;
+
+  try {
+    // Select workspace
+    let workspaceName: string;
+
+    if (opts?.workspace) {
+      workspaceName = opts.workspace;
+    } else {
+      if (!process.stdout.isTTY) {
+        logError('Missing required option: --workspace');
+        logError('Usage: w branch switch --workspace <name> --branch <branch>');
+        process.exit(1);
+      }
+      const workspaces = await listWorkspaces();
+      workspaceName = await promptWorkspaceSelection(workspaces);
+    }
+
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    logInfo(`Selected 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\n`);
+
+    // Determine target branch
+    let targetBranch: string;
+
+    if (opts?.branch) {
+      targetBranch = opts.branch;
+    } else {
+      if (!process.stdout.isTTY) {
+        logError('Missing required option: --branch');
+        logError('Usage: w branch switch --workspace <name> --branch <branch>');
+        process.exit(1);
+      }
+      const { branch } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'branch',
+          message: 'Target branch name:',
+          default: 'main',
+          validate: (input: string) => {
+            if (!input || input.trim().length === 0) {
+              return 'Branch name cannot be empty';
+            }
+            return true;
+          },
+        },
+      ]);
+      targetBranch = branch;
+    }
+
+    logWarning(`This will switch all repositories to branch: ${colorize(targetBranch, 'cyan')}`);
+
+    // Skip confirmation when --yes flag is provided
+    if (!yes && process.stdout.isTTY) {
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: 'Proceed with bulk branch switch?',
+          default: true,
+        },
+      ]);
+
+      if (!confirmed) {
+        logInfo('Branch switch cancelled');
+        process.exit(0);
+      }
+    }
+
+    console.log('');
+    const results: BranchSwitchResult[] = [];
+    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 switchBranch(repoPath, displayName, targetBranch);
+      results.push(result);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log('Branch Switch 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')} Switched: ${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('Bulk branch switch complete!');
+
+  } catch (error) {
+    logError('Failed to switch branches');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();

package/src/commands/cache/index.ts

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import { getGlobalOpts } from '../../utils/command-helpers';
+
+export function registerCacheCommands(parent: Command) {
+  const cache = parent
+    .command('cache')
+    .description('Cache management');
+
+  cache
+    .command('info')
+    .description('View cache statistics')
+    .action(async () => {
+      const { cacheInfo } = await import('./manager');
+      await cacheInfo();
+    });
+
+  cache
+    .command('refresh')
+    .description('Force refresh from GitHub')
+    .action(async () => {
+      const { cacheRefresh } = await import('./manager');
+      await cacheRefresh();
+    });
+
+  cache
+    .command('clear')
+    .description('Clear the cache')
+    .action(async () => {
+      const { cacheClear } = await import('./manager');
+      await cacheClear();
+    });
+
+  cache
+    .command('search')
+    .description('Search org repos by name or description')
+    .argument('<query>', 'Search query')
+    .option('--limit <n>', 'Max results', '20')
+    .action(async (query, opts) => {
+      const { cacheSearch } = await import('./manager');
+      await cacheSearch(query, parseInt(opts.limit) || 20);
+    });
+
+  cache
+    .command('list')
+    .description('List all org repos')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      const { cacheList } = await import('./manager');
+      await cacheList(globalOpts.forceRefresh);
+    });
+}