@nemus-cli/nemus 0.2.1

package/src/commands/dashboard/session-picker.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Session resume picker for the agent dashboard.
+ * Shows recent sessions sorted by last active, launches
+ * the appropriate agent CLI with --resume <id> --fork in a new dashboard pane.
+ */
+
+import { getWorkspaceSessions, WorkspaceSession } from '../../utils/claude-sessions';
+import { launchAgentPane } from './launcher';
+import { getAgentPaths, getPrimaryAgent, ConcreteAgentType } from '../../utils/agent-config';
+import { colorize } from '../../utils/colors';
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import * as fuzzy from 'fuzzy';
+
+inquirer.registerPrompt('autocomplete', autocompletePrompt);
+
+async function main() {
+  try {
+    const sessions = await getWorkspaceSessions();
+
+    if (sessions.length === 0) {
+      console.log('No sessions found. Launch a new agent with n.');
+      process.exit(1);
+    }
+
+    const items = sessions.map(session => ({
+      session,
+      displayName: session.workspaceName,
+      timeLabel: session.lastActiveLabel,
+    }));
+
+    const { selected } = await inquirer.prompt([{
+      type: 'autocomplete',
+      name: 'selected',
+      message: 'Select session to resume:',
+      source: async (_answersSoFar: any, input: string | undefined) => {
+        const searchInput = input || '';
+        const source = items.map(item => ({
+          name: `${item.displayName}  ${colorize(item.timeLabel, 'dim')}`,
+          value: item,
+        }));
+        if (!searchInput) return source;
+        const results = fuzzy.filter(searchInput, items, { extract: (item) => item.displayName });
+        return results.map(result => ({
+          name: `${result.original.displayName}  ${colorize(result.original.timeLabel, 'dim')}`,
+          value: result.original,
+        }));
+      },
+      pageSize: 15,
+    } as any]);
+
+    const item = selected as { session: WorkspaceSession };
+    const session = item.session;
+    const rawSessionId = session.sessionId;
+    // Sanitize session ID before interpolating into shell command
+    if (!/^[a-zA-Z0-9\-]{1,100}$/.test(rawSessionId)) {
+      console.error('Invalid session ID format — skipping');
+      process.exit(1);
+    }
+    // Use the session's agent type for resume, fall back to primary if missing
+    // (sessions from before the multi-agent upgrade won't have agentType)
+    const agentType = session.agentType || getPrimaryAgent().type;
+    const agent = getAgentPaths(agentType as ConcreteAgentType);
+    launchAgentPane(session.workspacePath, agent.resumeCommand(rawSessionId));
+    console.log(`\nResuming ${agentType} session in ${session.workspaceName}`);
+  } catch (error) {
+    if ((error as any)?.name === 'ExitPromptError') process.exit(0);
+    process.exit(1);
+  }
+}
+
+main();

package/src/commands/dashboard/sidebar.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * Dashboard sidebar entry point.
+ *
+ * This is a plain .js file (not .ts) to preserve the real dynamic import().
+ * TypeScript compiles `await import('ink')` into `require('ink')` in CJS mode,
+ * which fails because ink v5 is ESM-only with top-level await.
+ *
+ * By keeping this as .js, tsc copies it as-is to dist/ and the real
+ * import() call is preserved at runtime.
+ */
+
+async function main() {
+  try {
+    const React = require('react');
+    const path = require('path');
+
+    // Real dynamic ESM import — NOT compiled by tsc
+    const { render, Box, Text, useInput, useApp } = await import('ink');
+
+    // CJS require for our compiled TSX components
+    const { DashboardSidebar } = require(path.join(__dirname, '..', '..', 'cli', 'dashboard'));
+
+    const App = () => React.createElement(DashboardSidebar, {
+      Box,
+      Text,
+      useInput,
+      useApp,
+    });
+
+    render(React.createElement(App), { exitOnCtrlC: false });
+  } catch (error) {
+    console.error('Dashboard sidebar failed to start:', error.message);
+    // Keep the pane alive so user can see the error
+    await new Promise(() => {});
+  }
+}
+
+main();

package/src/commands/dashboard/workspace-picker.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * Workspace picker for the agent dashboard.
+ * Runs inside a tmux popup — lets the user select a workspace,
+ * then spawns a fresh claude agent pane in the dashboard session.
+ */
+
+import { listWorkspaces } from '../../utils/workspace-meta';
+import { launchAgentPane } from './launcher';
+import { getPrimaryAgent } from '../../utils/agent-config';
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import * as fuzzy from 'fuzzy';
+
+inquirer.registerPrompt('autocomplete', autocompletePrompt);
+
+async function main() {
+  try {
+    const workspaces = await listWorkspaces();
+
+    if (workspaces.length === 0) {
+      console.log('No workspaces found. Create one with: workspace create');
+      process.exit(1);
+    }
+
+    const items = workspaces.map(ws => ({
+      name: ws.name,
+      path: ws.path,
+      repoCount: ws.metadata?.repositories?.length ?? 0,
+    }));
+
+    const { selected } = await inquirer.prompt([{
+      type: 'autocomplete',
+      name: 'selected',
+      message: 'Select workspace to launch agent in:',
+      source: async (_answersSoFar: any, input: string | undefined) => {
+        const searchInput = input || '';
+        const source = items.map(item => ({
+          name: `${item.name}  (${item.repoCount} repos)`,
+          value: item,
+        }));
+        if (!searchInput) return source;
+        const results = fuzzy.filter(searchInput, items, { extract: (item) => item.name });
+        return results.map(result => ({
+          name: `${result.original.name}  (${result.original.repoCount} repos)`,
+          value: result.original,
+        }));
+      },
+      pageSize: 15,
+    } as any]);
+
+    const workspace = selected as { name: string; path: string };
+    const agent = getPrimaryAgent();
+    launchAgentPane(workspace.path, agent.launchCommand);
+    console.log(`\nLaunched agent in ${workspace.name}`);
+  } catch (error) {
+    if ((error as any)?.name === 'ExitPromptError') process.exit(0);
+    process.exit(1);
+  }
+}
+
+main();

package/src/commands/delete.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const {
+  mockRm,
+  mockListWorkspaces,
+  mockPromptMultiWorkspaceSelection,
+  mockPrompt,
+} = vi.hoisted(() => ({
+  mockRm: vi.fn(),
+  mockListWorkspaces: vi.fn(),
+  mockPromptMultiWorkspaceSelection: vi.fn(),
+  mockPrompt: vi.fn(),
+}));
+
+vi.mock('fs/promises', () => ({
+  rm: mockRm,
+}));
+
+vi.mock('../utils/config', () => ({
+  WORKSPACES_DIR: '/test-workspaces',
+}));
+
+vi.mock('../utils/workspace-meta', () => ({
+  listWorkspaces: mockListWorkspaces,
+}));
+
+vi.mock('../utils/prompts', () => ({
+  promptMultiWorkspaceSelection: mockPromptMultiWorkspaceSelection,
+}));
+
+vi.mock('../utils/logger', () => ({
+  logInfo: vi.fn(),
+  logSuccess: vi.fn(),
+  logError: vi.fn(),
+  logWarning: vi.fn(),
+}));
+
+vi.mock('../utils/colors', () => ({
+  colorize: (text: string) => text,
+}));
+
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: mockPrompt,
+  },
+}));
+
+import { main } from './delete';
+import { logInfo, logSuccess, logError } from '../utils/logger';
+
+function makeWorkspaceList(...names: string[]) {
+  return names.map(name => ({
+    name,
+    path: `/test-workspaces/${name}`,
+    metadata: {
+      repositories: [{ name: 'repo-a' }],
+      createdAt: '2025-01-01T00:00:00.000Z',
+    },
+  }));
+}
+
+describe('delete-workspace main', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockRm.mockResolvedValue(undefined);
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  it('exits immediately when no workspaces exist', async () => {
+    mockListWorkspaces.mockResolvedValueOnce([]);
+
+    await main();
+
+    expect(logInfo).toHaveBeenCalledWith('No more workspaces remaining');
+    expect(mockPromptMultiWorkspaceSelection).not.toHaveBeenCalled();
+  });
+
+  it('deletes selected workspaces and exits when user declines "delete more"', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a', 'ws-b'))  // initial fetch
+      .mockResolvedValueOnce(makeWorkspaceList('ws-b'));          // after deletion check
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-a']);
+
+    mockPrompt
+      .mockResolvedValueOnce({ confirmed: true })   // confirm deletion
+      .mockResolvedValueOnce({ deleteMore: false }); // don't delete more
+
+    await main();
+
+    expect(mockRm).toHaveBeenCalledWith('/test-workspaces/ws-a', { recursive: true, force: true });
+    expect(logSuccess).toHaveBeenCalledWith(expect.stringContaining('ws-a'));
+  });
+
+  it('deletes multiple workspaces in one batch', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a', 'ws-b', 'ws-c'))
+      .mockResolvedValueOnce(makeWorkspaceList('ws-c'));
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-a', 'ws-b']);
+
+    mockPrompt
+      .mockResolvedValueOnce({ confirmed: true })
+      .mockResolvedValueOnce({ deleteMore: false });
+
+    await main();
+
+    expect(mockRm).toHaveBeenCalledTimes(2);
+    expect(mockRm).toHaveBeenCalledWith('/test-workspaces/ws-a', { recursive: true, force: true });
+    expect(mockRm).toHaveBeenCalledWith('/test-workspaces/ws-b', { recursive: true, force: true });
+  });
+
+  it('skips deletion when user cancels confirmation', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a'))
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a'));
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-a']);
+
+    mockPrompt
+      .mockResolvedValueOnce({ confirmed: false })   // cancel deletion
+      .mockResolvedValueOnce({ deleteMore: false });  // don't delete more
+
+    await main();
+
+    expect(mockRm).not.toHaveBeenCalled();
+    // Should still ask "delete more?" — not exit immediately
+    expect(mockPrompt).toHaveBeenCalledTimes(2);
+  });
+
+  it('loops when user wants to delete more', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a', 'ws-b'))  // 1st iteration
+      .mockResolvedValueOnce(makeWorkspaceList('ws-b'))           // after 1st deletion
+      .mockResolvedValueOnce(makeWorkspaceList('ws-b'))           // 2nd iteration
+      .mockResolvedValueOnce([]);                                  // after 2nd deletion
+
+    mockPromptMultiWorkspaceSelection
+      .mockResolvedValueOnce(['ws-a'])
+      .mockResolvedValueOnce(['ws-b']);
+
+    mockPrompt
+      .mockResolvedValueOnce({ confirmed: true })    // confirm 1st deletion
+      .mockResolvedValueOnce({ deleteMore: true })   // delete more
+      .mockResolvedValueOnce({ confirmed: true });   // confirm 2nd deletion
+
+    await main();
+
+    expect(mockRm).toHaveBeenCalledTimes(2);
+    expect(mockRm).toHaveBeenCalledWith('/test-workspaces/ws-a', { recursive: true, force: true });
+    expect(mockRm).toHaveBeenCalledWith('/test-workspaces/ws-b', { recursive: true, force: true });
+    // Should see "no more workspaces remaining" after all deleted
+    expect(logInfo).toHaveBeenCalledWith('No more workspaces remaining');
+  });
+
+  it('breaks out of loop when no workspaces remain after deletion', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-only'))
+      .mockResolvedValueOnce([]);  // none left after deletion
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-only']);
+    mockPrompt.mockResolvedValueOnce({ confirmed: true });
+
+    await main();
+
+    expect(mockRm).toHaveBeenCalledTimes(1);
+    expect(logInfo).toHaveBeenCalledWith('No more workspaces remaining');
+    // Should NOT have asked "delete more?" since there are none left
+    expect(mockPrompt).toHaveBeenCalledTimes(1); // only the confirm prompt
+  });
+
+  it('handles individual deletion failure without stopping others', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a', 'ws-b', 'ws-c'))
+      .mockResolvedValueOnce(makeWorkspaceList('ws-c'));
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-a', 'ws-b']);
+
+    mockRm
+      .mockRejectedValueOnce(new Error('permission denied'))  // ws-a fails
+      .mockResolvedValueOnce(undefined);                       // ws-b succeeds
+
+    mockPrompt
+      .mockResolvedValueOnce({ confirmed: true })
+      .mockResolvedValueOnce({ deleteMore: false });
+
+    await main();
+
+    expect(mockRm).toHaveBeenCalledTimes(2);
+    expect(logError).toHaveBeenCalledWith(expect.stringContaining('ws-a'));
+    expect(logSuccess).toHaveBeenCalledWith(expect.stringContaining('ws-b'));
+  });
+
+  it('uses singular message for single workspace confirmation', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-alpha'))
+      .mockResolvedValueOnce([]);
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-alpha']);
+    mockPrompt.mockResolvedValueOnce({ confirmed: true });
+
+    await main();
+
+    expect(mockPrompt).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message: 'Delete workspace ws-alpha?',
+          default: true,
+        }),
+      ])
+    );
+  });
+
+  it('uses plural message for multiple workspace confirmation', async () => {
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a', 'ws-b', 'ws-c'))
+      .mockResolvedValueOnce([]);
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-a', 'ws-b', 'ws-c']);
+    mockPrompt.mockResolvedValueOnce({ confirmed: true });
+
+    await main();
+
+    expect(mockPrompt).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          message: 'Delete these 3 workspaces?',
+          default: true,
+        }),
+      ])
+    );
+  });
+
+  it('shows workspace details including repo count and creation date', async () => {
+    const logSpy = vi.spyOn(console, 'log');
+
+    mockListWorkspaces
+      .mockResolvedValueOnce(makeWorkspaceList('ws-a'))
+      .mockResolvedValueOnce([]);
+
+    mockPromptMultiWorkspaceSelection.mockResolvedValueOnce(['ws-a']);
+    mockPrompt.mockResolvedValueOnce({ confirmed: true });
+
+    await main();
+
+    const messages = logSpy.mock.calls.map(c => c[0]);
+    expect(messages).toContainEqual(expect.stringContaining('Repositories: 1'));
+    expect(messages).toContainEqual(expect.stringContaining('/test-workspaces/ws-a'));
+  });
+});

package/src/commands/delete.ts

@@ -0,0 +1,171 @@
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
+import { WORKSPACES_DIR } from '../utils/config';
+import * as path from 'path';
+import { listWorkspaces } from '../utils/workspace-meta';
+import { promptMultiWorkspaceSelection } from '../utils/prompts';
+import { logInfo, logSuccess, logError, logWarning } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import { getGlobalOpts, parseList } from '../utils/command-helpers';
+
+export function registerDeleteCommand(parent: Command) {
+  parent
+    .command('delete')
+    .aliases(['d', 'del'])
+    .description('Delete a workspace')
+    .option('-w, --workspace <names>', 'Comma-separated workspace names')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      await handleDelete({ ...opts, ...globalOpts });
+    });
+}
+
+async function handleDelete(opts: {
+  workspace?: string;
+  yes: boolean;
+  forceRefresh: boolean;
+}) {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Delete Workspace', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    // Non-interactive path: workspace names provided via flag
+    if (opts.workspace) {
+      const selectedNames = parseList(opts.workspace);
+      const workspaces = await listWorkspaces();
+
+      for (const name of selectedNames) {
+        const workspace = workspaces.find(ws => ws.name === name);
+        const workspacePath = path.join(WORKSPACES_DIR, name);
+        if (workspace?.metadata) {
+          console.log(`${colorize(name, 'cyan')}`);
+          console.log(`  Repositories: ${workspace.metadata.repositories.length}`);
+          console.log(`  Path: ${workspacePath}`);
+        } else {
+          console.log(`${colorize(name, 'cyan')}: ${workspacePath}`);
+        }
+      }
+      console.log('');
+
+      logWarning('This will permanently delete all cloned repositories in the selected workspaces!');
+
+      if (!opts.yes) {
+        const { confirmed } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            message: selectedNames.length === 1
+              ? `Delete workspace ${selectedNames[0]}?`
+              : `Delete these ${selectedNames.length} workspaces?`,
+            default: true,
+          },
+        ]);
+        if (!confirmed) {
+          logInfo('Deletion cancelled');
+          process.exit(0);
+        }
+      }
+
+      for (const name of selectedNames) {
+        const workspacePath = path.join(WORKSPACES_DIR, name);
+        try {
+          await fs.rm(workspacePath, { recursive: true, force: true });
+          logSuccess(`Deleted "${colorize(name, 'cyan')}"`);
+        } catch (error) {
+          logError(`Failed to delete "${name}"`);
+          if (error instanceof Error) logError(error.message);
+        }
+      }
+      return;
+    }
+
+    // Interactive path
+    while (true) {
+      const workspaces = await listWorkspaces();
+
+      if (workspaces.length === 0) {
+        logInfo('No more workspaces remaining');
+        break;
+      }
+
+      const selectedNames = await promptMultiWorkspaceSelection(workspaces);
+
+      for (const name of selectedNames) {
+        const workspace = workspaces.find(ws => ws.name === name);
+        const workspacePath = path.join(WORKSPACES_DIR, name);
+        if (workspace?.metadata) {
+          console.log(`${colorize(name, 'cyan')}`);
+          console.log(`  Repositories: ${workspace.metadata.repositories.length}`);
+          console.log(`  Created: ${new Date(workspace.metadata.createdAt).toLocaleString()}`);
+          console.log(`  Path: ${workspacePath}`);
+        } else {
+          console.log(`${colorize(name, 'cyan')}`);
+          console.log(`  Path: ${workspacePath}`);
+        }
+      }
+      console.log('');
+
+      logWarning('This will permanently delete all cloned repositories in the selected workspaces!');
+
+      const confirmMessage = selectedNames.length === 1
+        ? `Delete workspace ${selectedNames[0]}?`
+        : `Delete these ${selectedNames.length} workspaces?`;
+
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: confirmMessage,
+          default: true,
+        },
+      ]);
+
+      if (confirmed) {
+        for (const name of selectedNames) {
+          const workspacePath = path.join(WORKSPACES_DIR, name);
+          try {
+            await fs.rm(workspacePath, { recursive: true, force: true });
+            logSuccess(`Deleted "${colorize(name, 'cyan')}"`);
+          } catch (error) {
+            logError(`Failed to delete "${name}"`);
+            if (error instanceof Error) logError(error.message);
+          }
+        }
+      }
+
+      const remaining = await listWorkspaces();
+      if (remaining.length === 0) {
+        logInfo('No more workspaces remaining');
+        break;
+      }
+
+      const { deleteMore } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'deleteMore',
+          message: 'Delete more workspaces?',
+          default: false,
+        },
+      ]);
+
+      if (!deleteMore) {
+        break;
+      }
+    }
+  } catch (error) {
+    logError('Failed to delete workspace');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Legacy main() for backward compatibility with tests.
+ */
+export async function main() {
+  await handleDelete({ yes: false, forceRefresh: false });
+}

package/src/commands/deprecated-aliases.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+
+interface DeprecatedAlias {
+  name: string;
+  target: [string, string]; // [group, subcommand]
+}
+
+const DEPRECATED_SHORT_ALIASES: DeprecatedAlias[] = [
+  { name: 'sc', target: ['suite', 'create'] },
+  { name: 'sls', target: ['suite', 'list'] },
+  { name: 'sd', target: ['suite', 'delete'] },
+  { name: 'se', target: ['suite', 'export'] },
+  { name: 'si', target: ['suite', 'import'] },
+  { name: 'fs', target: ['suite', 'use'] },
+  { name: 'sb', target: ['branch', 'switch'] },
+  { name: 'bc', target: ['branch', 'create'] },
+  { name: 'bm', target: ['branch', 'merge'] },
+  { name: 'br', target: ['branch', 'rebase'] },
+  { name: 'uc', target: ['cache', 'refresh'] },
+];
+
+const DEPRECATED_FLAT_COMMANDS: DeprecatedAlias[] = [
+  { name: 'suite-create', target: ['suite', 'create'] },
+  { name: 'suite-list', target: ['suite', 'list'] },
+  { name: 'suite-delete', target: ['suite', 'delete'] },
+  { name: 'suite-export', target: ['suite', 'export'] },
+  { name: 'suite-import', target: ['suite', 'import'] },
+  { name: 'from-suite', target: ['suite', 'use'] },
+  { name: 'switch-branch', target: ['branch', 'switch'] },
+  { name: 'branch-create', target: ['branch', 'create'] },
+  { name: 'branch-merge', target: ['branch', 'merge'] },
+  { name: 'branch-rebase', target: ['branch', 'rebase'] },
+  { name: 'update-cache', target: ['cache', 'refresh'] },
+];
+
+export function registerDeprecatedAliases(program: Command) {
+  const all = [...DEPRECATED_SHORT_ALIASES, ...DEPRECATED_FLAT_COMMANDS];
+
+  for (const alias of all) {
+    program
+      .command(alias.name, { hidden: true })
+      .allowUnknownOption()
+      .allowExcessArguments()
+      .action(async () => {
+        const [group, sub] = alias.target;
+        process.stderr.write(
+          `[nemus] "w ${alias.name}" is deprecated, use "w ${group} ${sub}" instead\n`
+        );
+        // Re-parse with the correct group + subcommand
+        await program.parseAsync(
+          [process.argv[0], process.argv[1], group, sub, ...process.argv.slice(3)]
+        );
+      });
+  }
+}