@nemus-cli/nemus 0.2.1

package/src/commands/list.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const {
+  mockListWorkspaces,
+  mockGetWorkspaceSessions,
+  mockPrompt,
+  mockWriteFile,
+} = vi.hoisted(() => ({
+  mockListWorkspaces: vi.fn(),
+  mockGetWorkspaceSessions: vi.fn(),
+  mockPrompt: vi.fn(),
+  mockWriteFile: vi.fn(),
+}));
+
+vi.mock('../utils/workspace-meta', () => ({
+  listWorkspaces: mockListWorkspaces,
+}));
+
+vi.mock('../utils/claude-sessions', () => ({
+  getWorkspaceSessions: mockGetWorkspaceSessions,
+}));
+
+vi.mock('../utils/logger', () => ({
+  logInfo: vi.fn(),
+  logError: vi.fn(),
+}));
+
+vi.mock('../utils/colors', () => ({
+  colorize: (text: string) => text,
+}));
+
+vi.mock('fs/promises', () => ({
+  writeFile: mockWriteFile,
+}));
+
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: mockPrompt,
+    registerPrompt: vi.fn(),
+  },
+}));
+
+vi.mock('inquirer-autocomplete-prompt', () => ({
+  default: vi.fn(),
+}));
+
+vi.mock('fuzzy', () => ({
+  filter: vi.fn(),
+}));
+
+import { main } from './list';
+import { logInfo } from '../utils/logger';
+
+function makeWorkspaceList(...names: string[]) {
+  return names.map(name => ({
+    name,
+    path: `/test-workspaces/${name}`,
+    metadata: {
+      repositories: [{ name: 'repo-a', directoryName: 'repo-a', status: 'success' }],
+      createdAt: '2025-01-01T00:00:00.000Z',
+    },
+  }));
+}
+
+function makeArchivedWorkspaceList(...names: string[]) {
+  return names.map(name => ({
+    name,
+    path: `/test-workspaces/${name}`,
+    metadata: {
+      repositories: [{ name: 'repo-a', directoryName: 'repo-a', status: 'success' }],
+      createdAt: '2025-01-01T00:00:00.000Z',
+      archivedAt: new Date().toISOString(),
+    },
+  }));
+}
+
+describe('list-workspaces main', () => {
+  const originalArgv = process.argv;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.argv = ['node', 'list-workspaces.js'];
+    mockWriteFile.mockResolvedValue(undefined);
+    mockGetWorkspaceSessions.mockResolvedValue([]);
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+  });
+
+  it('lists workspaces and prompts for selection', async () => {
+    mockListWorkspaces.mockResolvedValueOnce(makeWorkspaceList('ws-a', 'ws-b'));
+    mockPrompt.mockResolvedValueOnce({ selected: 'ws-a' });
+
+    await main();
+
+    expect(mockPrompt).toHaveBeenCalledTimes(1);
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      expect.stringContaining('.workspace-last-go'),
+      '/test-workspaces/ws-a',
+      'utf-8',
+    );
+  });
+
+  it('does not prompt when no workspaces exist', async () => {
+    mockListWorkspaces.mockResolvedValueOnce([]);
+
+    await main();
+
+    expect(logInfo).toHaveBeenCalledWith('No workspaces found');
+    expect(mockPrompt).not.toHaveBeenCalled();
+  });
+
+  it('does not prompt when no archived workspaces exist', async () => {
+    process.argv = ['node', 'list-workspaces.js', '--archived'];
+    mockListWorkspaces.mockResolvedValueOnce([]);
+
+    await main();
+
+    expect(logInfo).toHaveBeenCalledWith('No archived workspaces found');
+    expect(mockPrompt).not.toHaveBeenCalled();
+  });
+
+  it('writes temp file on selection', async () => {
+    mockListWorkspaces.mockResolvedValueOnce(makeWorkspaceList('my-workspace'));
+    mockPrompt.mockResolvedValueOnce({ selected: 'my-workspace' });
+
+    await main();
+
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      expect.stringContaining('.workspace-last-go'),
+      '/test-workspaces/my-workspace',
+      'utf-8',
+    );
+  });
+
+  it('writes resume flag when workspace has an existing session', async () => {
+    mockListWorkspaces.mockResolvedValueOnce(makeWorkspaceList('my-workspace'));
+    mockGetWorkspaceSessions.mockResolvedValueOnce([{
+      workspaceName: 'my-workspace',
+      workspacePath: '/test-workspaces/my-workspace',
+      sessionId: 'session-123',
+      lastActiveAt: new Date(),
+      lastActiveLabel: '2m ago',
+      agentType: 'pi',
+    }]);
+    mockPrompt.mockResolvedValueOnce({ selected: 'my-workspace' });
+
+    await main();
+
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      expect.stringContaining('.workspace-resume-session'),
+      JSON.stringify({ sessionId: 'session-123', agentType: 'pi' }),
+      'utf-8',
+    );
+  });
+
+  it('does not write resume flag when workspace has no session', async () => {
+    mockListWorkspaces.mockResolvedValueOnce(makeWorkspaceList('my-workspace'));
+    mockGetWorkspaceSessions.mockResolvedValueOnce([]);
+    mockPrompt.mockResolvedValueOnce({ selected: 'my-workspace' });
+
+    await main();
+
+    const resumeCalls = mockWriteFile.mock.calls.filter(
+      (c: any[]) => typeof c[0] === 'string' && c[0].includes('.workspace-resume-session')
+    );
+    expect(resumeCalls).toHaveLength(0);
+  });
+
+  it('lists archived workspaces with --archived flag and prompts for selection', async () => {
+    process.argv = ['node', 'list-workspaces.js', '--archived'];
+    const archived = makeArchivedWorkspaceList('old-ws');
+    mockListWorkspaces.mockResolvedValueOnce(archived);
+    mockPrompt.mockResolvedValueOnce({ selected: 'old-ws' });
+
+    await main();
+
+    expect(mockPrompt).toHaveBeenCalledTimes(1);
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      expect.stringContaining('.workspace-last-go'),
+      '/test-workspaces/old-ws',
+      'utf-8',
+    );
+  });
+
+  it('displays workspace name in the list output', async () => {
+    const logSpy = vi.spyOn(console, 'log');
+    mockListWorkspaces.mockResolvedValueOnce(makeWorkspaceList('ws-a'));
+    mockPrompt.mockResolvedValueOnce({ selected: 'ws-a' });
+
+    await main();
+
+    const messages = logSpy.mock.calls.map(c => c[0]);
+    expect(messages).toContainEqual(expect.stringContaining('ws-a'));
+  });
+
+  it('sorts workspaces with sessions before those without', async () => {
+    mockListWorkspaces.mockResolvedValueOnce(makeWorkspaceList('no-session', 'has-session'));
+    mockGetWorkspaceSessions.mockResolvedValueOnce([{
+      workspaceName: 'has-session',
+      workspacePath: '/test-workspaces/has-session',
+      sessionId: 'session-456',
+      lastActiveAt: new Date(),
+      lastActiveLabel: '5m ago',
+    }]);
+    mockPrompt.mockResolvedValueOnce({ selected: 'has-session' });
+
+    await main();
+
+    // The prompt source function should show has-session first
+    const promptCall = mockPrompt.mock.calls[0][0][0];
+    const source = promptCall.source;
+    const items = await source(null, '');
+    expect(items[0].value).toBe('has-session');
+    expect(items[1].value).toBe('no-session');
+  });
+});

package/src/commands/list.ts

@@ -0,0 +1,176 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as os from 'os';
+import * as fsPromises from 'fs/promises';
+import { listWorkspaces } from '../utils/workspace-meta';
+import { getWorkspaceSessions } from '../utils/claude-sessions';
+import { logInfo, logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import * as fuzzy from 'fuzzy';
+
+inquirer.registerPrompt('autocomplete', autocompletePrompt);
+
+const TEMP_FILE = path.join(os.homedir(), '.workspace-last-go');
+const RESUME_FLAG_FILE = path.join(os.homedir(), '.workspace-resume-session');
+
+interface WorkspaceItem {
+  name: string;
+  wsPath: string;
+  repoCount: number;
+  createdAt: string;
+  lastActiveLabel: string | null;
+  lastActiveAt: number;
+  hasSession: boolean;
+}
+
+export function registerListCommand(parent: Command) {
+  parent
+    .command('list')
+    .alias('l')
+    .description('List workspaces and navigate to one')
+    .option('-a, --archived', 'Show archived workspaces')
+    .action(async (opts) => {
+      await handleList(opts);
+    });
+}
+
+async function handleList(opts: { archived?: boolean }) {
+  const showArchived = opts.archived ?? false;
+  const title = showArchived ? 'Archived Workspaces' : 'Existing Workspaces';
+
+  try {
+    const [workspaces, sessions] = await Promise.all([
+      showArchived
+        ? listWorkspaces(true).then(ws => ws.filter(w => w.metadata?.archivedAt))
+        : listWorkspaces(false),
+      getWorkspaceSessions(),
+    ]);
+
+    if (workspaces.length === 0) {
+      console.log('\n' + '='.repeat(60));
+      console.log(colorize(title, 'bright'));
+      console.log('='.repeat(60) + '\n');
+      if (showArchived) {
+        logInfo('No archived workspaces found');
+      } else {
+        logInfo('No workspaces found');
+        console.log('\nCreate a new workspace with:');
+        console.log('  workspace create\n');
+      }
+      return;
+    }
+
+    const sessionMap = new Map(sessions.map(s => [s.workspaceName, s]));
+
+    const items: WorkspaceItem[] = workspaces.map(ws => {
+      const session = sessionMap.get(ws.name);
+      const repoCount = ws.metadata?.repositories?.length ?? 0;
+      return {
+        name: ws.name,
+        wsPath: ws.path,
+        repoCount,
+        createdAt: ws.metadata?.createdAt ?? '',
+        lastActiveLabel: session?.lastActiveLabel ?? null,
+        lastActiveAt: session?.lastActiveAt.getTime() ?? 0,
+        hasSession: !!session,
+      };
+    });
+
+    items.sort((a, b) => {
+      if (a.hasSession && b.hasSession) return b.lastActiveAt - a.lastActiveAt;
+      if (a.hasSession) return -1;
+      if (b.hasSession) return 1;
+      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+    });
+
+    console.log('');
+    console.log(colorize('  ' + title, 'bright') + colorize('  (sorted by last active)', 'dim'));
+    console.log(colorize('  ' + '─'.repeat(54), 'dim'));
+
+    const maxNameLen = Math.max(...items.map(i => i.name.length));
+
+    for (const item of items) {
+      const name = item.name.padEnd(maxNameLen);
+      const active = item.lastActiveLabel
+        ? colorize(item.lastActiveLabel, 'yellow')
+        : colorize('no session', 'dim');
+      const repos = colorize(`${item.repoCount} repos`, 'dim');
+
+      if (showArchived) {
+        const ws = workspaces.find(w => w.name === item.name);
+        if (ws?.metadata?.archivedAt) {
+          const daysSinceArchive = (Date.now() - new Date(ws.metadata.archivedAt).getTime()) / (1000 * 60 * 60 * 24);
+          const daysRemaining = Math.max(0, Math.ceil(30 - daysSinceArchive));
+          const archiveLabel = colorize(`${daysRemaining}d left`, 'red');
+          console.log(`  ${colorize(name, 'cyan')}  ${active}  ${repos}  ${archiveLabel}`);
+        }
+      } else {
+        console.log(`  ${colorize(name, 'cyan')}  ${active}  ${repos}`);
+      }
+    }
+    console.log('');
+
+    if (items.length > 0 && (process.stdout.isTTY || process.env.VITEST === 'true')) {
+      const { selected } = await inquirer.prompt([
+        {
+          type: 'autocomplete',
+          name: 'selected',
+          message: 'Select workspace to open:',
+          source: async (_answersSoFar: any, input: string | undefined) => {
+            const searchInput = input || '';
+
+            const source = items.map(item => ({
+              name: `${item.name}  ${item.lastActiveLabel ? colorize(item.lastActiveLabel, 'dim') : colorize('no session', 'dim')}  ${colorize(`${item.repoCount} repos`, 'dim')}`,
+              value: item.name,
+            }));
+
+            if (!searchInput) return source;
+
+            const results = fuzzy.filter(searchInput, items, {
+              extract: (item) => item.name,
+            });
+
+            return results.map(result => ({
+              name: `${result.original.name}  ${result.original.lastActiveLabel ? colorize(result.original.lastActiveLabel, 'dim') : colorize('no session', 'dim')}  ${colorize(`${result.original.repoCount} repos`, 'dim')}`,
+              value: result.original.name,
+            }));
+          },
+          pageSize: 15,
+        } as any,
+      ]);
+
+      const selectedItem = items.find(i => i.name === selected);
+      if (selectedItem) {
+        await fsPromises.writeFile(TEMP_FILE, selectedItem.wsPath, 'utf-8');
+        if (selectedItem.hasSession) {
+          const session = sessionMap.get(selectedItem.name);
+          if (session) {
+            await fsPromises.writeFile(RESUME_FLAG_FILE, JSON.stringify({
+              sessionId: session.sessionId,
+              agentType: session.agentType,
+            }), 'utf-8');
+          }
+        }
+      }
+    }
+
+  } catch (error) {
+    logError('Failed to list workspaces');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Legacy main() for backward compatibility with tests.
+ * Reads process.argv to determine options.
+ */
+export async function main() {
+  const args = process.argv.slice(2);
+  const archived = args.includes('--archived') || args.includes('-a');
+  await handleList({ archived });
+}

package/src/commands/mcp/index.ts

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+
+export function registerMcpCommands(parent: Command) {
+  const mcp = parent
+    .command('mcp')
+    .description('MCP server management');
+
+  mcp
+    .command('install')
+    .description('Register MCP server with Claude Code')
+    .action(async () => {
+      const { main } = await import('../../mcp/install');
+      await main('install');
+    });
+
+  mcp
+    .command('uninstall')
+    .description('Unregister the MCP server')
+    .action(async () => {
+      const { main } = await import('../../mcp/install');
+      await main('uninstall');
+    });
+
+  mcp
+    .command('upgrade')
+    .description('Update hooks and skills (no MCP re-register)')
+    .action(async () => {
+      const { main } = await import('../../mcp/install');
+      await main('upgrade');
+    });
+
+  mcp
+    .command('status')
+    .description('Check MCP server registration')
+    .action(async () => {
+      const { main } = await import('../../mcp/install');
+      await main('status');
+    });
+}