@nemus-cli/nemus 0.2.1

package/src/commands/save-context.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('save-context', () => {
+  let tempDir: string;
+  let handleSaveContext: typeof import('../mcp/tools').handleSaveContext;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-save-ctx-'));
+    process.env.WORKSPACE_MANAGER_DIR = tempDir;
+    process.env.WORKSPACE_MANAGER_CACHE_DIR = path.join(tempDir, '.cache');
+    vi.resetModules();
+    const mod = await import('../mcp/tools');
+    handleSaveContext = mod.handleSaveContext;
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+    delete process.env.WORKSPACE_MANAGER_DIR;
+    delete process.env.WORKSPACE_MANAGER_CACHE_DIR;
+  });
+
+  async function createWorkspace(name: string, opts?: { prompt?: string }) {
+    const wsPath = path.join(tempDir, name);
+    await fs.mkdir(wsPath, { recursive: true });
+    await fs.writeFile(path.join(wsPath, '.workspace-meta.json'), JSON.stringify({
+      workspaceName: name,
+      createdAt: '2024-01-01T00:00:00Z',
+      repositories: [],
+      ...(opts?.prompt ? { prompt: opts.prompt } : {}),
+    }));
+    return wsPath;
+  }
+
+  describe('handleSaveContext (MCP tool)', () => {
+    it('creates CONTEXT.md with content', async () => {
+      const wsPath = await createWorkspace('my-ws');
+      const result = await handleSaveContext('my-ws', 'Completed auth refactor');
+      expect(result.saved).toBe(true);
+      expect(result.workspace).toBe('my-ws');
+
+      const content = await fs.readFile(path.join(wsPath, 'CONTEXT.md'), 'utf-8');
+      expect(content).toContain('Completed auth refactor');
+      expect(content).toContain('Workspace Context: my-ws');
+    });
+
+    it('replaces content by default', async () => {
+      const wsPath = await createWorkspace('my-ws');
+      await handleSaveContext('my-ws', 'First version');
+      await handleSaveContext('my-ws', 'Second version');
+
+      const content = await fs.readFile(path.join(wsPath, 'CONTEXT.md'), 'utf-8');
+      expect(content).toContain('Second version');
+      expect(content).not.toContain('First version');
+    });
+
+    it('appends when append=true', async () => {
+      const wsPath = await createWorkspace('my-ws');
+      await handleSaveContext('my-ws', 'First version');
+      await handleSaveContext('my-ws', 'Additional notes', true);
+
+      const content = await fs.readFile(path.join(wsPath, 'CONTEXT.md'), 'utf-8');
+      expect(content).toContain('First version');
+      expect(content).toContain('Additional notes');
+      expect(content).toContain('---'); // separator
+    });
+
+    it('creates fresh file when appending to non-existent', async () => {
+      const wsPath = await createWorkspace('my-ws');
+      await handleSaveContext('my-ws', 'Fresh content', true);
+
+      const content = await fs.readFile(path.join(wsPath, 'CONTEXT.md'), 'utf-8');
+      expect(content).toContain('Fresh content');
+      expect(content).toContain('Workspace Context: my-ws');
+    });
+
+    it('throws for non-existent workspace', async () => {
+      await expect(handleSaveContext('nope', 'content')).rejects.toThrow('Workspace not found');
+    });
+
+    it('throws for empty content', async () => {
+      await createWorkspace('my-ws');
+      await expect(handleSaveContext('my-ws', '')).rejects.toThrow('Content is required');
+    });
+
+    it('throws for empty workspace name', async () => {
+      await expect(handleSaveContext('', 'content')).rejects.toThrow('Workspace name is required');
+    });
+  });
+});
+
+describe('createMetadata with prompt', () => {
+  it('includes prompt in metadata when provided', async () => {
+    vi.resetModules();
+    process.env.WORKSPACE_MANAGER_DIR = '/tmp/test-ws';
+    const { createMetadata } = await import('../utils/workspace-meta');
+
+    const metadata = createMetadata('test-ws', [], { prompt: 'build a payment service' });
+    expect(metadata.prompt).toBe('build a payment service');
+    expect(metadata.workspaceName).toBe('test-ws');
+  });
+
+  it('omits prompt field when not provided', async () => {
+    vi.resetModules();
+    process.env.WORKSPACE_MANAGER_DIR = '/tmp/test-ws';
+    const { createMetadata } = await import('../utils/workspace-meta');
+
+    const metadata = createMetadata('test-ws', []);
+    expect(metadata.prompt).toBeUndefined();
+  });
+});

package/src/commands/save-context.ts

@@ -0,0 +1,141 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { WORKSPACES_DIR, META_FILENAME } from '../utils/config';
+import { logInfo, logSuccess, logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { loadMetadata, saveMetadata, listWorkspaces } from '../utils/workspace-meta';
+import { formatContextFile, appendToContextFile } from '../utils/context-file';
+import inquirer from 'inquirer';
+
+const CONTEXT_FILENAME = 'CONTEXT.md';
+
+export function registerSaveContextCommand(parent: Command) {
+  parent
+    .command('save-context')
+    .alias('ctx')
+    .description('Save a progress summary to the workspace (persists across /clear)')
+    .option('-w, --workspace <name>', 'Workspace name (default: current directory)')
+    .option('-m, --message <text>', 'Summary text to save')
+    .option('-f, --file <path>', 'Read summary from a file')
+    .option('--append', 'Append to existing context instead of replacing')
+    .action(async (opts) => {
+      await handleSaveContext(opts);
+    });
+}
+
+async function resolveWorkspacePath(workspaceName?: string): Promise<{ name: string; path: string } | null> {
+  // Try current directory first
+  if (!workspaceName) {
+    const cwd = process.cwd();
+    const metaPath = path.join(cwd, META_FILENAME);
+    try {
+      await fs.access(metaPath);
+      const meta = JSON.parse(await fs.readFile(metaPath, 'utf-8'));
+      return { name: meta.workspaceName || path.basename(cwd), path: cwd };
+    } catch {
+      // Not in a workspace directory — check if we're inside a workspace subdirectory
+      const parentDir = path.dirname(cwd);
+      const parentMeta = path.join(parentDir, META_FILENAME);
+      try {
+        await fs.access(parentMeta);
+        const meta = JSON.parse(await fs.readFile(parentMeta, 'utf-8'));
+        return { name: meta.workspaceName || path.basename(parentDir), path: parentDir };
+      } catch {
+        // Not in any workspace
+      }
+    }
+  }
+
+  // Use provided workspace name
+  if (workspaceName) {
+    const wsPath = path.join(WORKSPACES_DIR, workspaceName);
+    try {
+      await fs.access(path.join(wsPath, META_FILENAME));
+      return { name: workspaceName, path: wsPath };
+    } catch {
+      logError(`Workspace not found: ${workspaceName}`);
+      return null;
+    }
+  }
+
+  // Interactive selection
+  if (process.stdout.isTTY) {
+    const workspaces = await listWorkspaces(false);
+    if (workspaces.length === 0) {
+      logError('No workspaces found');
+      return null;
+    }
+    const { selected } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selected',
+      message: 'Select workspace:',
+      choices: workspaces.map(w => ({ name: w.name, value: w.name })),
+    }]);
+    return { name: selected, path: path.join(WORKSPACES_DIR, selected) };
+  }
+
+  logError('Could not determine workspace. Use --workspace <name> or run from within a workspace.');
+  return null;
+}
+
+async function handleSaveContext(opts: {
+  workspace?: string;
+  message?: string;
+  file?: string;
+  append?: boolean;
+}) {
+  const ws = await resolveWorkspacePath(opts.workspace);
+  if (!ws) return;
+
+  // Get content from message, file, or stdin
+  let content: string;
+  if (opts.message) {
+    content = opts.message;
+  } else if (opts.file) {
+    try {
+      content = await fs.readFile(opts.file, 'utf-8');
+    } catch (err) {
+      logError(`Failed to read file: ${opts.file}`);
+      return;
+    }
+  } else if (!process.stdin.isTTY) {
+    // Read from stdin (piped input)
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    content = Buffer.concat(chunks).toString('utf-8').trim();
+  } else {
+    logError('No content provided. Use --message, --file, or pipe content via stdin.');
+    console.log(`\n  Usage:`);
+    console.log(`    ${colorize('w save-context -m "Completed auth refactor, moved to payments"', 'green')}`);
+    console.log(`    ${colorize('w save-context -f summary.md', 'green')}`);
+    console.log(`    ${colorize('echo "progress notes" | w save-context', 'green')}`);
+    return;
+  }
+
+  if (!content.trim()) {
+    logError('Empty content — nothing to save.');
+    return;
+  }
+
+  const contextPath = path.join(ws.path, CONTEXT_FILENAME);
+
+  if (opts.append) {
+    let existing: string | null = null;
+    try {
+      existing = await fs.readFile(contextPath, 'utf-8');
+    } catch {
+      // File doesn't exist yet
+    }
+    content = appendToContextFile(existing, ws.name, content);
+  } else {
+    content = formatContextFile(ws.name, content);
+  }
+
+  await fs.writeFile(contextPath, content, 'utf-8');
+  logSuccess(`Context saved to ${colorize(CONTEXT_FILENAME, 'cyan')} in ${ws.name}`);
+  logInfo('This file persists across /clear and session restarts.');
+}
+

package/src/commands/sessions.ts

@@ -0,0 +1,99 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs/promises';
+import { getWorkspaceSessions, WorkspaceSession } from '../utils/claude-sessions';
+import { listWorkspaces } from '../utils/workspace-meta';
+import { logError, logInfo } 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');
+
+export function registerSessionsCommand(parent: Command) {
+  parent
+    .command('sessions')
+    .alias('ses')
+    .description('Resume a Claude session in a workspace')
+    .action(async () => {
+      await handleSessions();
+    });
+}
+
+async function handleSessions() {
+  try {
+    const sessions = await getWorkspaceSessions();
+
+    if (sessions.length === 0) {
+      logInfo('No workspace sessions found.');
+      console.log('\nYou can create a workspace with: nemus create');
+      console.log('Or navigate to one with: w go');
+      return;
+    }
+
+    const workspaces = await listWorkspaces(false);
+    const workspaceMap = new Map(workspaces.map(ws => [ws.name, ws]));
+
+    const items = sessions.map(session => {
+      const ws = workspaceMap.get(session.workspaceName);
+      const repoCount = ws?.metadata?.repositories?.length ?? 0;
+      const repoLabel = repoCount > 0 ? `${repoCount} repos` : 'no repos';
+      return { session, repoLabel };
+    });
+
+    const maxNameLen = Math.max(...items.map(i => i.session.workspaceName.length));
+
+    console.log('');
+    console.log(colorize('  Workspace Sessions', 'bright') + colorize('  (sorted by last active)', 'dim'));
+    console.log(colorize('  ' + '─'.repeat(50), 'dim'));
+
+    for (const item of items.slice(0, 10)) {
+      const name = item.session.workspaceName.padEnd(maxNameLen);
+      const time = item.session.lastActiveLabel;
+      console.log(`  ${colorize(name, 'cyan')}  ${colorize(time, 'yellow')}  ${colorize(item.repoLabel, 'dim')}`);
+    }
+    if (items.length > 10) {
+      console.log(colorize(`  ... and ${items.length - 10} more`, 'dim'));
+    }
+    console.log('');
+
+    const { selected } = await inquirer.prompt([{
+      type: 'autocomplete', name: 'selected',
+      message: 'Select workspace to resume:',
+      source: async (_answersSoFar: any, input: string | undefined) => {
+        const searchInput = input || '';
+        const source = items.map(item => ({
+          name: `${item.session.workspaceName}  ${colorize(item.session.lastActiveLabel, 'dim')}  ${colorize(item.repoLabel, 'dim')}`,
+          value: item.session,
+        }));
+        if (!searchInput) return source;
+        const results = fuzzy.filter(searchInput, items, { extract: (item) => item.session.workspaceName });
+        return results.map(result => ({
+          name: `${result.original.session.workspaceName}  ${colorize(result.original.session.lastActiveLabel, 'dim')}  ${colorize(result.original.repoLabel, 'dim')}`,
+          value: result.original.session,
+        }));
+      },
+      pageSize: 15,
+    } as any]);
+
+    const session = selected as WorkspaceSession;
+    await fs.writeFile(TEMP_FILE, session.workspacePath, 'utf-8');
+    // Write JSON with session ID and agent type for correct resume
+    await fs.writeFile(RESUME_FLAG_FILE, JSON.stringify({
+      sessionId: session.sessionId,
+      agentType: session.agentType,
+    }), 'utf-8');
+
+    console.log(`\n${colorize('Resuming:', 'green')} ${session.workspaceName} (last active ${session.lastActiveLabel})`);
+  } catch (error) {
+    if ((error as any)?.name === 'ExitPromptError') return;
+    logError('Failed to list sessions');
+    if (error instanceof Error) { logError(error.message); }
+    process.exit(1);
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,111 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata } from '../utils/workspace-meta';
+import { getAllReposStatus } from '../utils/git-status';
+import { logError, logInfo, logStep } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { resolveWorkspace } from '../utils/command-helpers';
+
+const displayStatusTable = (statuses: Array<{ repo: string; branch: string; clean: boolean; ahead: number; behind: number; modifiedFiles: number; untrackedFiles: number; hasRemote: boolean; detachedHead: boolean }>) => {
+  console.log('\n' + colorize('═'.repeat(100), 'gray'));
+  console.log(
+    colorize('Repo', 'bright').padEnd(30) +
+    colorize('Branch', 'bright').padEnd(25) +
+    colorize('Status', 'bright').padEnd(15) +
+    colorize('Ahead/Behind', 'bright').padEnd(15) +
+    colorize('Modified', 'bright')
+  );
+  console.log(colorize('─'.repeat(100), 'gray'));
+
+  for (const status of statuses) {
+    const repoName = status.repo.padEnd(20);
+    let branchDisplay = status.branch.padEnd(15);
+    if (status.detachedHead) {
+      branchDisplay = colorize(branchDisplay, 'yellow');
+    }
+
+    let statusDisplay = '';
+    if (status.clean) {
+      statusDisplay = colorize('✓ Clean', 'green').padEnd(15);
+    } else {
+      const changes = [];
+      if (status.modifiedFiles > 0) changes.push(`${status.modifiedFiles} modified`);
+      if (status.untrackedFiles > 0) changes.push(`${status.untrackedFiles} untracked`);
+      statusDisplay = colorize(`⚠ ${changes.join(', ')}`, 'yellow').padEnd(15);
+    }
+
+    let trackingDisplay = '';
+    if (!status.hasRemote) {
+      trackingDisplay = colorize('No remote', 'gray').padEnd(15);
+    } else if (status.ahead === 0 && status.behind === 0) {
+      trackingDisplay = colorize('Up to date', 'green').padEnd(15);
+    } else {
+      const parts = [];
+      if (status.ahead > 0) parts.push(colorize(`↑${status.ahead}`, 'cyan'));
+      if (status.behind > 0) parts.push(colorize(`↓${status.behind}`, 'red'));
+      trackingDisplay = parts.join(' ').padEnd(15);
+    }
+
+    const modifiedDisplay = status.clean ? '-' : `${status.modifiedFiles + status.untrackedFiles} files`;
+    console.log(`${repoName} ${branchDisplay} ${statusDisplay} ${trackingDisplay} ${modifiedDisplay}`);
+  }
+
+  console.log(colorize('═'.repeat(100), 'gray'));
+
+  const cleanRepos = statuses.filter(s => s.clean).length;
+  const dirtyRepos = statuses.filter(s => !s.clean).length;
+  const needsPush = statuses.filter(s => s.ahead > 0).length;
+  const needsPull = statuses.filter(s => s.behind > 0).length;
+
+  console.log('\n' + colorize('Summary:', 'bright'));
+  console.log(`  ${colorize('✓', 'green')} ${cleanRepos} clean repositories`);
+  if (dirtyRepos > 0) {
+    console.log(`  ${colorize('⚠', 'yellow')} ${dirtyRepos} repositories with uncommitted changes`);
+  }
+  if (needsPush > 0) {
+    console.log(`  ${colorize('↑', 'cyan')} ${needsPush} repositories ahead of remote`);
+  }
+  if (needsPull > 0) {
+    console.log(`  ${colorize('↓', 'red')} ${needsPull} repositories behind remote`);
+  }
+  console.log('');
+};
+
+export function registerStatusCommand(parent: Command) {
+  parent
+    .command('status')
+    .alias('st')
+    .description('Show git status across all repos')
+    .argument('[workspace]', 'Workspace name')
+    .action(async (workspace) => {
+      await handleStatus(workspace);
+    });
+}
+
+async function handleStatus(workspaceArg?: string) {
+  try {
+    const selectedWorkspace = await resolveWorkspace(workspaceArg);
+    const workspacePath = path.join(WORKSPACES_DIR, selectedWorkspace);
+    const metadata = await loadMetadata(workspacePath);
+
+    if (!metadata) {
+      logError(`Workspace metadata not found for: ${selectedWorkspace}`);
+      process.exit(1);
+    }
+
+    logStep(`Checking status for workspace: ${colorize(selectedWorkspace, 'cyan')}`);
+    logInfo(`Found ${metadata.repositories.length} repositories`);
+
+    const repoDirectoryNames = metadata.repositories.map(r => r.directoryName);
+    const statuses = await getAllReposStatus(workspacePath, repoDirectoryNames, 3);
+
+    displayStatusTable(statuses);
+  } catch (error) {
+    logError('Failed to check workspace status');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}