@nemus-cli/nemus 0.2.1

package/src/commands/cache/manager.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env ts-node
+
+import { clearCache, getCacheStats } from '../../utils/cache';
+import { fetchOrgRepos, verifyGhAuth, displayAuthInstructions } from '../../utils/github';
+import { logInfo, logSuccess, logError } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import inquirer from 'inquirer';
+import * as fuzzy from 'fuzzy';
+
+export async function cacheInfo() {
+  const stats = await getCacheStats();
+
+  if (stats.exists) {
+    console.log('\n' + colorize('Cache Information:', 'cyan'));
+    console.log(`  Status: ${colorize('Active', 'green')}`);
+    console.log(`  Repositories: ${colorize(String(stats.repoCount), 'cyan')}`);
+    console.log(`  Last updated: ${stats.age}`);
+    console.log(`  Cache size: ${colorize(String(Math.round((stats.size || 0) / 1024)) + ' KB', 'yellow')}`);
+    console.log(`  Location: ${colorize('~/.workspace-manager-cache/repos-cache.json', 'gray')}`);
+  } else {
+    console.log('\n' + colorize('Cache Status:', 'yellow'));
+    console.log('  No cache found. Cache will be created on next repository fetch.\n');
+  }
+}
+
+export async function cacheRefresh() {
+  const isAuthenticated = await verifyGhAuth();
+  if (!isAuthenticated) {
+    logError('GitHub CLI is not authenticated');
+    displayAuthInstructions();
+    process.exit(1);
+  }
+
+  logInfo('Forcing cache refresh...');
+  const repos = await fetchOrgRepos({ forceRefresh: true });
+  logSuccess(`Cache refreshed with ${colorize(String(repos.length), 'cyan')} repositories`);
+}
+
+export async function cacheClear() {
+  await clearCache();
+  logSuccess('Cache cleared successfully');
+}
+
+export async function cacheSearch(query: string, limit: number = 20) {
+  if (!query || query.trim().length === 0) {
+    logError('Usage: w cache search <query>');
+    process.exit(1);
+  }
+
+  const allRepos = await fetchOrgRepos();
+  const results = fuzzy.filter(query, allRepos, {
+    extract: (repo: typeof allRepos[0]) => `${repo.name} ${repo.description || ''}`,
+  });
+
+  const matches = results.slice(0, limit);
+
+  if (matches.length === 0) {
+    logInfo(`No repositories matching '${query}'`);
+    return;
+  }
+
+  console.log('\n' + colorize(`Search results for "${query}" (${matches.length} matches):`, 'cyan') + '\n');
+  for (const match of matches) {
+    const repo = match.original;
+    const visibility = repo.isPrivate ? colorize('private', 'yellow') : colorize('public', 'green');
+    console.log(`  ${colorize(repo.name, 'bright')} [${visibility}]`);
+    if (repo.description) {
+      console.log(`    ${colorize(repo.description, 'gray')}`);
+    }
+    console.log(`    ${colorize(repo.url, 'gray')}`);
+  }
+  console.log('');
+}
+
+export async function cacheList(forceRefresh: boolean = false) {
+  const isAuthenticated = await verifyGhAuth();
+  if (!isAuthenticated) {
+    logError('GitHub CLI is not authenticated');
+    displayAuthInstructions();
+    process.exit(1);
+  }
+
+  if (forceRefresh) {
+    logInfo('Forcing cache refresh...');
+  }
+
+  const repos = await fetchOrgRepos({ forceRefresh });
+
+  if (repos.length === 0) {
+    logInfo('No repositories found');
+    return;
+  }
+
+  console.log('\n' + colorize(`Organization repositories (${repos.length} total):`, 'cyan') + '\n');
+  for (const repo of repos) {
+    const visibility = repo.isPrivate ? colorize('private', 'yellow') : colorize('public', 'green');
+    console.log(`  ${colorize(repo.name, 'bright')} [${visibility}]`);
+    if (repo.description) {
+      console.log(`    ${colorize(repo.description, 'gray')}`);
+    }
+  }
+  console.log('');
+  logInfo(`Showing ${repos.length} repositories. Use 'w cache search <query>' to filter.`);
+}
+
+export async function main() {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Cache Manager', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    // Support direct subcommand invocation (e.g. from cache-router)
+    const action = process.argv[2];
+    if (action === 'info' || action === 'refresh' || action === 'clear') {
+      if (action === 'info') {
+        await cacheInfo();
+      } else if (action === 'refresh') {
+        await cacheRefresh();
+      } else if (action === 'clear') {
+        await cacheClear();
+      }
+      return;
+    }
+
+    // Interactive mode (original behavior)
+    const { selectedAction } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedAction',
+        message: 'Select action:',
+        choices: [
+          { name: 'View cache info', value: 'info' },
+          { name: 'Refresh cache (force fetch from GitHub)', value: 'refresh' },
+          { name: 'Clear cache', value: 'clear' },
+        ],
+      },
+    ]);
+
+    if (selectedAction === 'info') {
+      await cacheInfo();
+    } else if (selectedAction === 'refresh') {
+      await cacheRefresh();
+    } else if (selectedAction === 'clear') {
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: 'Are you sure you want to clear the cache?',
+          default: false,
+        },
+      ]);
+
+      if (confirmed) {
+        await cacheClear();
+      } else {
+        logInfo('Cache clear cancelled');
+      }
+    }
+  } catch (error) {
+    logError('Failed to manage cache');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();

package/src/commands/cleanup.ts

@@ -0,0 +1,132 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata } from '../utils/workspace-meta';
+import { removeNodeModules, removeBuildArtifacts, gitClean } from '../utils/cleanup-operations';
+import { logError, logInfo, logStep, logSuccess } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import { getGlobalOpts, resolveWorkspace } from '../utils/command-helpers';
+
+export function registerCleanupCommand(parent: Command) {
+  parent
+    .command('cleanup')
+    .alias('cl')
+    .description('Remove node_modules and build artifacts')
+    .argument('[workspace]', 'Workspace name')
+    .option('--all', 'Clean everything')
+    .option('--node-modules', 'Clean node_modules')
+    .option('--build', 'Clean build artifacts')
+    .option('--git-clean', 'Git clean (remove untracked files)')
+    .action(async (workspace, opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      await handleCleanup(workspace, { ...opts, ...globalOpts });
+    });
+}
+
+async function handleCleanup(workspaceArg: string | undefined, opts: {
+  all?: boolean;
+  nodeModules?: boolean;
+  build?: boolean;
+  gitClean?: boolean;
+  yes: boolean;
+  forceRefresh: boolean;
+}) {
+  try {
+    const workspaceName = await resolveWorkspace(workspaceArg);
+    const workspacePath = path.join(WORKSPACES_DIR, workspaceName);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace not found: ${workspaceName}`);
+      process.exit(1);
+    }
+
+    const nodeModules = opts.nodeModules || opts.all;
+    const build = opts.build || opts.all;
+    const gitCleanFlag = opts.gitClean || opts.all;
+
+    let operations: string[];
+
+    if (nodeModules || build || gitCleanFlag) {
+      operations = [];
+      if (nodeModules) operations.push('node_modules');
+      if (build) operations.push('build');
+      if (gitCleanFlag) operations.push('git_clean');
+    } else {
+      const result = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'operations',
+          message: 'Select cleanup operations:',
+          choices: [
+            { name: 'Remove node_modules (all repos)', value: 'node_modules' },
+            { name: 'Remove build artifacts (dist, build, .next, coverage)', value: 'build' },
+            { name: 'Git clean (remove untracked files)', value: 'git_clean' },
+          ],
+        },
+      ]);
+      operations = result.operations;
+    }
+
+    if (operations.length === 0) {
+      logInfo('No operations selected');
+      return;
+    }
+
+    if (!opts.yes) {
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: `Proceed with cleanup? This cannot be undone.`,
+          default: false,
+        },
+      ]);
+
+      if (!confirm) {
+        logInfo('Cleanup cancelled');
+        return;
+      }
+    }
+
+    logStep('Running cleanup operations...');
+
+    for (const repo of metadata.repositories) {
+      const repoPath = path.join(workspacePath, repo.directoryName);
+      const displayName = repo.directoryName !== repo.name
+        ? `${repo.directoryName} (${repo.name})`
+        : repo.name;
+      console.log(`\n${colorize(displayName, 'cyan')}:`);
+
+      if (operations.includes('node_modules')) {
+        const result = await removeNodeModules(repoPath);
+        if (result.success) {
+          logSuccess(`  Removed node_modules (${result.spaceFreed})`);
+        }
+      }
+
+      if (operations.includes('build')) {
+        const result = await removeBuildArtifacts(repoPath);
+        if (result.success && result.filesRemoved > 0) {
+          logSuccess(`  Removed ${result.filesRemoved} build artifacts (${result.spaceFreed})`);
+        }
+      }
+
+      if (operations.includes('git_clean')) {
+        const result = await gitClean(repoPath, false);
+        if (result.success && result.filesRemoved > 0) {
+          logSuccess(`  Git clean: removed ${result.filesRemoved} files`);
+        }
+      }
+    }
+
+    logSuccess('\nCleanup completed!');
+  } catch (error) {
+    logError('Cleanup failed');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}

package/src/commands/configure-claude.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import { loadClaudeConfig, saveClaudeConfig } from '../utils/claude-integration';
+import { logSuccess, logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+
+export function registerConfigureClaudeCommand(parent: Command) {
+  parent
+    .command('configure-claude')
+    .alias('cc')
+    .description('Configure Claude Code integration')
+    .action(async () => {
+      await handleConfigureClaude();
+    });
+}
+
+async function handleConfigureClaude() {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Configure Claude Code Integration', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const currentConfig = await loadClaudeConfig();
+
+    console.log('Current settings:');
+    console.log(`  Auto-launch Claude: ${currentConfig.autoLaunch ? colorize('Enabled', 'green') : colorize('Disabled', 'red')}`);
+    console.log(`  Generate context: ${currentConfig.generateContext ? colorize('Enabled', 'green') : colorize('Disabled', 'red')}`);
+    console.log('');
+
+    const answers = await inquirer.prompt([
+      { type: 'confirm', name: 'autoLaunch', message: 'Auto-launch Claude Code after workspace creation?', default: currentConfig.autoLaunch },
+      { type: 'confirm', name: 'generateContext', message: 'Generate CLAUDE.md context file in workspaces?', default: currentConfig.generateContext },
+    ]);
+
+    await saveClaudeConfig(answers);
+
+    console.log('');
+    logSuccess('Claude Code integration configured!');
+    console.log('');
+    console.log('Settings:');
+    console.log(`  ${colorize('✓', 'green')} Auto-launch: ${answers.autoLaunch ? 'Enabled' : 'Disabled'}`);
+    console.log(`  ${colorize('✓', 'green')} Generate context: ${answers.generateContext ? 'Enabled' : 'Disabled'}`);
+
+    if (answers.autoLaunch) {
+      console.log('');
+      console.log(colorize('Note:', 'yellow') + ' Claude Code will automatically launch when you create workspaces.');
+      console.log('Make sure Claude Code CLI is installed: https://claude.ai/download');
+    }
+    console.log('');
+  } catch (error) {
+    logError('Failed to configure Claude integration');
+    if (error instanceof Error) { logError(error.message); }
+    process.exit(1);
+  }
+}

package/src/commands/configure.ts

@@ -0,0 +1,204 @@
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import inquirer from 'inquirer';
+import { getUserConfig, saveUserConfig, UserConfig } from '../utils/config';
+import { clearCache } from '../utils/cache';
+import { logSuccess, logError, logInfo, logWarning } from '../utils/logger';
+import { colorize } from '../utils/colors';
+
+export function registerConfigureCommand(parent: Command) {
+  parent
+    .command('configure')
+    .alias('cfg')
+    .description('Configure workspace manager settings')
+    .action(async () => {
+      await handleConfigure();
+    });
+}
+
+async function handleConfigure() {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Workspace Manager Configuration', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  const current = getUserConfig();
+
+  console.log('Current settings:');
+  console.log(`  Workspaces directory:    ${colorize(current.workspacesDir, 'cyan')}`);
+  console.log(`  GitHub organization:     ${colorize(current.githubOrg, 'cyan')}`);
+  console.log(`  Clone protocol:          ${colorize(current.cloneProtocol, 'cyan')}`);
+  console.log(`  Auto-launch agent:       ${current.autoLaunchClaude ? colorize('Enabled', 'green') : colorize('Disabled', 'red')}`);
+  console.log(`  Generate context file:   ${current.generateClaudeContext ? colorize('Enabled', 'green') : colorize('Disabled', 'red')}`);
+  console.log(`  MCP server:              ${current.installMcp ? colorize('Enabled', 'green') : colorize('Disabled', 'red')}`);
+  console.log(`  AI Agent:                ${colorize(current.aiAgent, 'cyan')}`);
+  console.log(`  Primary agent:           ${colorize(current.primaryAgent, 'cyan')}`);
+  console.log(`  Pi workspace widget:     ${current.piWorkspaceInputStatus !== false ? colorize('Enabled', 'green') : colorize('Disabled', 'red')}`);
+  console.log(`  Claude workspace table:  ${current.claudeWorkspaceStatusLine !== false ? colorize('Enabled', 'green') : colorize('Disabled', 'red')}`);
+  console.log('');
+
+  try {
+    const answers = await inquirer.prompt([
+      { type: 'input', name: 'workspacesDir', message: 'Workspaces directory:', default: current.workspacesDir, validate: (val: string) => val.trim().length > 0 || 'Directory path is required' },
+      { type: 'input', name: 'githubOrg', message: 'GitHub organization:', default: current.githubOrg, validate: (val: string) => /^[a-zA-Z0-9_-]+$/.test(val.trim()) || 'Must be a valid GitHub org name' },
+      { type: 'list', name: 'cloneProtocol', message: 'Clone protocol:', choices: [{ name: 'SSH  (git@github.com:...)', value: 'ssh' }, { name: 'HTTPS (https://github.com/...)', value: 'https' }], default: current.cloneProtocol },
+      { type: 'confirm', name: 'autoLaunchClaude', message: 'Auto-launch AI agent after workspace creation?', default: current.autoLaunchClaude },
+      { type: 'confirm', name: 'generateClaudeContext', message: 'Generate context file in workspaces?', default: current.generateClaudeContext },
+      { type: 'confirm', name: 'installMcp', message: 'Install MCP server (Claude Code only)?', default: current.installMcp },
+      { type: 'list', name: 'aiAgent', message: 'AI Agent(s) to integrate with:', choices: [
+        { name: 'Auto-detect (recommended)', value: 'auto' },
+        { name: 'Claude Code only', value: 'claude' },
+        { name: 'Pi only', value: 'pi' },
+        { name: 'OpenCode only', value: 'opencode' },
+        { name: 'All available', value: 'both' },
+      ], default: current.aiAgent },
+      // Only ask about primary agent when aiAgent is 'both' or 'auto'
+      // (when specific agent chosen, primary is implicitly that agent)
+      { type: 'list', name: 'primaryAgent', message: 'Primary agent (used for launching):', choices: [
+        { name: 'Auto-detect (first available)', value: 'auto' },
+        { name: 'Claude Code', value: 'claude' },
+        { name: 'Pi', value: 'pi' },
+        { name: 'OpenCode', value: 'opencode' },
+      ], default: current.primaryAgent, when: (ans) => ans.aiAgent === 'both' || ans.aiAgent === 'auto' },
+      { type: 'confirm', name: 'piWorkspaceInputStatus',
+        message: 'Show workspace status widget in Pi input area (branch, PRs, CI)?',
+        default: current.piWorkspaceInputStatus !== false,
+        when: (ans) => ans.aiAgent === 'pi' || ans.aiAgent === 'both' || ans.aiAgent === 'auto' },
+      { type: 'confirm', name: 'claudeWorkspaceStatusLine',
+        message: 'Add workspace repo table to Claude Code status line?',
+        default: current.claudeWorkspaceStatusLine !== false,
+        when: (ans) => ans.aiAgent === 'claude' || ans.aiAgent === 'both' || ans.aiAgent === 'auto' },
+      { type: 'confirm', name: 'autoReportBugs',
+        message: 'Auto-file a GitHub issue when a command crashes? (deduped, sanitized)',
+        default: current.autoReportBugs === true },
+    ]);
+
+    // Validate and normalize config
+    let primaryAgent = answers.primaryAgent || 'auto';
+    // If aiAgent is specific, primaryAgent must match
+    if (answers.aiAgent === 'claude') primaryAgent = 'claude';
+    if (answers.aiAgent === 'pi') primaryAgent = 'pi';
+    if (answers.aiAgent === 'opencode') primaryAgent = 'opencode';
+
+    const newConfig: UserConfig = {
+      workspacesDir: answers.workspacesDir.trim(),
+      githubOrg: answers.githubOrg.trim(),
+      cloneProtocol: answers.cloneProtocol,
+      autoLaunchClaude: answers.autoLaunchClaude,
+      generateClaudeContext: answers.generateClaudeContext,
+      installMcp: answers.installMcp,
+      aiAgent: answers.aiAgent,
+      primaryAgent,
+      piWorkspaceInputStatus: answers.piWorkspaceInputStatus ?? current.piWorkspaceInputStatus ?? true,
+      claudeWorkspaceStatusLine: answers.claudeWorkspaceStatusLine ?? current.claudeWorkspaceStatusLine ?? true,
+      autoReportBugs: answers.autoReportBugs ?? current.autoReportBugs ?? false,
+    };
+
+    saveUserConfig(newConfig);
+
+    console.log('');
+    logSuccess('Configuration saved!');
+    console.log('');
+    console.log(`  ${colorize('Workspaces directory:', 'gray')}  ${newConfig.workspacesDir}`);
+    console.log(`  ${colorize('GitHub organization:', 'gray')}   ${newConfig.githubOrg}`);
+    console.log(`  ${colorize('Clone protocol:', 'gray')}        ${newConfig.cloneProtocol}`);
+    console.log(`  ${colorize('Auto-launch agent:', 'gray')}     ${newConfig.autoLaunchClaude ? 'Yes' : 'No'}`);
+    console.log(`  ${colorize('Generate context:', 'gray')}       ${newConfig.generateClaudeContext ? 'Yes' : 'No'}`);
+    console.log(`  ${colorize('MCP server:', 'gray')}            ${newConfig.installMcp ? 'Yes' : 'No'}`);
+    console.log(`  ${colorize('AI Agent:', 'gray')}              ${newConfig.aiAgent}`);
+    console.log(`  ${colorize('Primary agent:', 'gray')}         ${newConfig.primaryAgent}`);
+    console.log('');
+
+    // Install / upgrade shell integration.
+    // Skip if MCP install just ran it (mcp/install always installs shell integration).
+    let mcpInstalled = false;
+    if (newConfig.installMcp && !current.installMcp) {
+      logInfo('Installing MCP server...');
+      try {
+        const mcpInstallScript = path.join(__dirname, '..', '..', 'dist', 'mcp', 'install.js');
+        execSync(`node "${mcpInstallScript}" install`, { stdio: 'inherit' });
+        mcpInstalled = true;
+      } catch { logError('MCP install failed. You can retry later with: w mcp install'); }
+    }
+
+    if (newConfig.githubOrg !== current.githubOrg) {
+      await clearCache();
+      logInfo(`GitHub org changed from "${current.githubOrg}" to "${newConfig.githubOrg}". Repo cache has been cleared.`);
+    }
+
+    // Always install / upgrade the shell integration so the 'w' function
+    // is available. This is especially important on first-time setup where
+    // postinstall may not have run or the user hasn't sourced their RC file.
+    // Skip if mcp install already did it to avoid printing the reminder twice.
+    if (!mcpInstalled) {
+      installShellIntegration();
+    }
+
+  } catch (error) {
+    logError('Failed to save configuration');
+    if (error instanceof Error) { logError(error.message); }
+    process.exit(1);
+  }
+}
+
+/**
+ * Install or upgrade the shell integration (w/workspace shell functions).
+ * Uses an absolute path derived from this file so it works regardless of CWD.
+ * Always prints a prominent "source your RC file" reminder afterwards.
+ */
+function installShellIntegration(): void {
+  // __dirname is dist/commands/ at runtime — script is two levels up at package root
+  const scriptPath = path.join(__dirname, '..', '..', 'install-shell-integration.sh');
+
+  if (!fs.existsSync(scriptPath)) {
+    logWarning('Shell integration script not found — skipping auto-install');
+    printSourceReminder();
+    return;
+  }
+
+  const shell = process.env.SHELL || '';
+  const shellType = shell.endsWith('/zsh') ? 'zsh'
+    : shell.endsWith('/bash') ? 'bash'
+    : '';
+
+  if (!shellType) {
+    logWarning('Unknown shell — skipping shell integration (run install-shell-integration.sh manually)');
+    printSourceReminder();
+    return;
+  }
+
+  try {
+    execSync(`bash "${scriptPath}" ${shellType}`, { stdio: 'inherit' });
+  } catch {
+    logWarning('Shell integration install failed — you can run it manually:');
+    logInfo(`  bash "${scriptPath}" ${shellType}`);
+  }
+
+  printSourceReminder();
+}
+
+/**
+ * Print a loud, impossible-to-miss reminder to source the RC file.
+ * Without this step the 'w' shell function is not available in the
+ * current terminal session even after a successful install.
+ */
+function printSourceReminder(): void {
+  const shell = process.env.SHELL || '';
+  const rcFile = shell.endsWith('/zsh') ? '~/.zshrc'
+    : shell.endsWith('/bash') ? '~/.bashrc'
+    : '~/.profile';
+
+  console.log('');
+  console.log(colorize('  ⚠️  IMPORTANT — activate the shell function in this session:', 'yellow'));
+  console.log('');
+  console.log(`     ${colorize(`source ${rcFile}`, 'cyan')}`);
+  console.log('');
+  console.log(`  Or open a new terminal tab. Until then the ${colorize('nemus', 'cyan')}/${colorize('nem', 'cyan')} shell`);
+  console.log(`  functions (which auto-cd into new workspaces) aren't active yet.`);
+  console.log('');
+  console.log(`  Tip: ${colorize('nemus', 'cyan')} works immediately without sourcing:`);
+  console.log(`       ${colorize('nemus configure', 'cyan')}   ${colorize('# first-time setup', 'gray')}`);
+  console.log(`       ${colorize('nemus list', 'cyan')}        ${colorize('# list workspaces', 'gray')}`);
+  console.log('');
+}