@nemus-cli/nemus 0.2.1

package/src/cli/dashboard/DashboardSidebar.tsx

@@ -0,0 +1,291 @@
+import * as React from 'react';
+import { spawnSync } from 'child_process';
+import * as path from 'path';
+import { readAllAgentStates } from '../../utils/agent-state';
+import { AgentState, DASHBOARD_DEFAULTS } from '../../types/dashboard';
+import { InkComponents, Key } from './types';
+import { AgentList } from './AgentList';
+import { HelpFooter } from './HelpFooter';
+import {
+  getAgentPanes,
+  getHiddenPanes,
+  findPaneForAgent,
+  sortAgentsByPaneOrder,
+  sortAgentsByPidOrder,
+  resetLayout,
+  restoreHiddenPanes,
+  zoomPane,
+} from '../../utils/tmux-dashboard';
+
+const { sessionName, pollIntervalMs } = DASHBOARD_DEFAULTS;
+
+export interface DashboardSidebarProps extends InkComponents {
+  useInput: (handler: (input: string, key: Key) => void) => void;
+  useApp: () => { exit: (error?: Error) => void };
+}
+
+export const DashboardSidebar: React.FC<DashboardSidebarProps> = ({ Box, Text, useInput, useApp }) => {
+  const [agents, setAgents] = React.useState<AgentState[]>([]);
+  const [selectedIndex, setSelectedIndex] = React.useState(0);
+  const [isZoomed, setIsZoomed] = React.useState(false);
+  const { exit } = useApp();
+
+  // Refs for always-current values inside the useInput closure
+  const agentsRef = React.useRef<AgentState[]>([]);
+  const selectedIndexRef = React.useRef(0);
+  const isZoomedRef = React.useRef(false);
+  // Store original pane PID order before zoom so we can restore it
+  const originalPaneOrderRef = React.useRef<number[]>([]);
+
+  // Poll agent states every 2s
+  React.useEffect(() => {
+    function refresh() {
+      const visiblePanes = getAgentPanes();
+      const hiddenPanes = getHiddenPanes();
+      const allPanes = [...visiblePanes, ...hiddenPanes];
+      const panePids = new Set(allPanes.map(p => p.pid));
+
+      const allStates = readAllAgentStates().filter(s => {
+        if (s.status === 'stopped') return false;
+        return panePids.has(s.pid);
+      });
+
+      // When zoomed, sort by the original pane order so the sidebar
+      // display stays stable (zoomed pane doesn't jump to the top)
+      const originalOrder = originalPaneOrderRef.current;
+      let sorted: AgentState[];
+      if (originalOrder.length > 0) {
+        sorted = sortAgentsByPidOrder(allStates, originalOrder);
+      } else {
+        sorted = sortAgentsByPaneOrder(allStates, allPanes);
+      }
+
+      agentsRef.current = sorted;
+      setAgents(sorted);
+    }
+    refresh();
+    const timer = setInterval(refresh, pollIntervalMs);
+    return () => clearInterval(timer);
+  }, []);
+
+  // Keep selectedIndex ref in sync
+  React.useEffect(() => {
+    selectedIndexRef.current = selectedIndex;
+  }, [selectedIndex]);
+
+  // Keep isZoomed ref in sync
+  React.useEffect(() => {
+    isZoomedRef.current = isZoomed;
+  }, [isZoomed]);
+
+  // Clamp selection — handles both too-high and negative values
+  const clampedIndex = Math.min(Math.max(selectedIndex, 0), Math.max(0, agents.length - 1));
+  if (clampedIndex !== selectedIndex) {
+    setSelectedIndex(clampedIndex);
+    selectedIndexRef.current = clampedIndex;
+  }
+
+  /**
+   * Apply zoom to a specific agent index.
+   */
+  function applyZoom(agentIndex: number): void {
+    const currentAgents = agentsRef.current;
+    if (agentIndex >= currentAgents.length) return;
+
+    if (isZoomedRef.current) {
+      // Already zoomed — restore panes in original order, then re-zoom
+      restoreHiddenPanes(originalPaneOrderRef.current);
+    } else {
+      // First zoom — capture the current pane order before hiding anything
+      const panes = getAgentPanes();
+      originalPaneOrderRef.current = panes.map(p => p.pid);
+      restoreHiddenPanes(); // no-op if nothing hidden
+    }
+
+    spawnSync('tmux', ['select-layout', '-t', sessionName, 'main-vertical'], { stdio: 'pipe' });
+    spawnSync('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+
+    const panes = getAgentPanes();
+    const pane = findPaneForAgent(currentAgents[agentIndex], panes);
+    if (pane) {
+      zoomPane(pane);
+      setIsZoomed(true);
+      isZoomedRef.current = true;
+    }
+  }
+
+  /**
+   * Unzoom and reset layout, restoring original pane order.
+   */
+  function unzoom(): void {
+    restoreHiddenPanes(originalPaneOrderRef.current);
+    originalPaneOrderRef.current = [];
+    spawnSync('tmux', ['select-layout', '-t', sessionName, 'main-vertical'], { stdio: 'pipe' });
+    spawnSync('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+    spawnSync('tmux', ['select-pane', '-t', `${sessionName}:0.0`], { stdio: 'pipe' });
+    setIsZoomed(false);
+    isZoomedRef.current = false;
+  }
+
+  // Keyboard handling — reads from refs for always-current data
+  useInput((input: string, key: Key) => {
+    const currentAgents = agentsRef.current;
+    const currentIdx = selectedIndexRef.current;
+    const currentZoomed = isZoomedRef.current;
+    const clampedIdx = Math.min(Math.max(currentIdx, 0), Math.max(0, currentAgents.length - 1));
+
+    // q — detach (session stays running in background, agents keep working)
+    if (input === 'q') {
+      restoreHiddenPanes();
+      spawnSync('tmux', ['detach-client', '-s', sessionName], { stdio: 'pipe' });
+      // Do NOT call exit() — the sidebar process must keep running so
+      // the session is alive when the user re-attaches with 'w dash'
+      return;
+    }
+
+    // Q (shift+q) — kill session and all agents
+    if (input === 'Q') {
+      restoreHiddenPanes();
+      spawnSync('tmux', ['kill-session', '-t', sessionName], { stdio: 'pipe' });
+      exit();
+      return;
+    }
+
+    // Navigation
+    if (key.upArrow || input === 'K') {
+      const next = Math.max(0, clampedIdx - 1);
+      setSelectedIndex(next);
+      selectedIndexRef.current = next;
+      return;
+    }
+    if (key.downArrow || input === 'J') {
+      const next = Math.max(0, Math.min(currentAgents.length - 1, clampedIdx + 1));
+      setSelectedIndex(next);
+      selectedIndexRef.current = next;
+      return;
+    }
+
+    // Number keys 1-9
+    if (input >= '1' && input <= '9') {
+      const idx = parseInt(input, 10) - 1;
+      if (idx < currentAgents.length) {
+        setSelectedIndex(idx);
+        selectedIndexRef.current = idx;
+      }
+      return;
+    }
+
+    // Focus — switch to agent pane
+    if (input === 'f' || key.return) {
+      if (clampedIdx < currentAgents.length) {
+        if (currentZoomed) {
+          applyZoom(clampedIdx);
+          const panes = getAgentPanes();
+          const pane = findPaneForAgent(currentAgents[clampedIdx], panes);
+          if (pane) {
+            spawnSync('tmux', ['select-pane', '-t', `${sessionName}:0.${pane.index}`], { stdio: 'pipe' });
+          }
+        } else {
+          const panes = getAgentPanes();
+          const pane = findPaneForAgent(currentAgents[clampedIdx], panes);
+          if (pane) {
+            spawnSync('tmux', ['select-pane', '-t', `${sessionName}:0.${pane.index}`], { stdio: 'pipe' });
+          }
+        }
+      }
+      return;
+    }
+
+    // Zoom toggle
+    if (input === 'z') {
+      if (currentZoomed) {
+        unzoom();
+        isZoomedRef.current = false;
+      } else {
+        applyZoom(clampedIdx);
+      }
+      return;
+    }
+
+    // Reset layout
+    if (input === 'r') {
+      unzoom();
+      isZoomedRef.current = false;
+      return;
+    }
+
+    // New agent
+    if (input === 'n') {
+      if (currentZoomed) {
+        unzoom();
+        isZoomedRef.current = false;
+      }
+      const pickerScript = path.join(__dirname, '..', '..', 'commands', 'dashboard', 'workspace-picker.js');
+      const popupResult = spawnSync('tmux', [
+        'display-popup', '-E', '-w', '60%', '-h', '60%',
+        '-t', sessionName,
+        `node "${pickerScript}"`,
+      ], { stdio: 'pipe' });
+
+      if (popupResult.status !== 0) {
+        spawnSync('tmux', ['split-window', '-t', sessionName, '-v', `node "${pickerScript}"`], { stdio: 'pipe' });
+      }
+      setTimeout(() => resetLayout(), 500);
+      return;
+    }
+
+    // Resume session
+    if (input === 's') {
+      if (currentZoomed) {
+        unzoom();
+        isZoomedRef.current = false;
+      }
+      const sessionPickerScript = path.join(__dirname, '..', '..', 'commands', 'dashboard', 'session-picker.js');
+      const popupResult = spawnSync('tmux', [
+        'display-popup', '-E', '-w', '60%', '-h', '60%',
+        '-t', sessionName,
+        `node "${sessionPickerScript}"`,
+      ], { stdio: 'pipe' });
+
+      if (popupResult.status !== 0) {
+        spawnSync('tmux', ['split-window', '-t', sessionName, '-v', `node "${sessionPickerScript}"`], { stdio: 'pipe' });
+      }
+      setTimeout(() => resetLayout(), 500);
+      return;
+    }
+
+    // Kill / close session
+    if (input === 'x') {
+      if (clampedIdx < currentAgents.length) {
+        if (currentZoomed) {
+          unzoom();
+          isZoomedRef.current = false;
+        }
+        const panes = getAgentPanes();
+        const pane = findPaneForAgent(currentAgents[clampedIdx], panes);
+        if (pane) {
+          spawnSync('tmux', ['kill-pane', '-t', `${sessionName}:0.${pane.index}`], { stdio: 'pipe' });
+          setTimeout(() => resetLayout(), 100);
+        }
+      }
+      return;
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Box marginBottom={1}>
+        <Text bold color="cyan">{'─ Agent Dashboard ─'}</Text>
+        {isZoomed && <Text color="yellow"> [ZOOM]</Text>}
+      </Box>
+      <AgentList
+        agents={agents}
+        selectedIndex={clampedIndex}
+        onSelect={setSelectedIndex}
+        Box={Box}
+        Text={Text}
+      />
+      <HelpFooter isZoomed={isZoomed} Box={Box} Text={Text} />
+    </Box>
+  );
+};

package/src/cli/dashboard/HelpFooter.tsx

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { InkComponents } from './types';
+
+interface HelpFooterProps extends InkComponents {
+  isZoomed: boolean;
+}
+
+export const HelpFooter: React.FC<HelpFooterProps> = ({ isZoomed, Box, Text }) => {
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Text dimColor>───────────────────</Text>
+      <Text><Text color="yellow">↑↓</Text> select  <Text color="yellow">f</Text>/⏎ focus</Text>
+      <Text><Text color="yellow">z</Text>  {isZoomed ? 'unzoom' : 'zoom'}    <Text color="yellow">x</Text>   kill</Text>
+      <Text><Text color="yellow">n</Text>  new     <Text color="yellow">q</Text>   detach</Text>
+      <Text><Text color="yellow">s</Text>  resume  <Text color="yellow">Q</Text>   quit all</Text>
+      <Text><Text color="yellow">r</Text>  reset layout</Text>
+      <Text dimColor>───────────────────</Text>
+      <Text dimColor>From agent pane:</Text>
+      <Text> <Text color="yellow">prefix+M</Text> sidebar/reset</Text>
+    </Box>
+  );
+};

package/src/cli/dashboard/StatusBadge.tsx

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { AgentStatus, InkComponents } from './types';
+
+interface StatusBadgeProps extends InkComponents {
+  status: AgentStatus;
+}
+
+const STATUS_CONFIG: Record<AgentStatus, { icon: string; color: string; label: string }> = {
+  working: { icon: '●', color: 'green', label: 'working' },
+  waiting: { icon: '●', color: 'yellow', label: 'approve' },
+  idle:    { icon: '◌', color: 'gray', label: 'idle' },
+  stopped: { icon: '✕', color: 'red', label: 'stopped' },
+};
+
+export const StatusBadge: React.FC<StatusBadgeProps> = ({ status, Box, Text }) => {
+  const config = STATUS_CONFIG[status] || STATUS_CONFIG.idle;
+  return (
+    <Box gap={1}>
+      <Text color={config.color}>{config.icon}</Text>
+      <Text color={config.color}>{config.label}</Text>
+    </Box>
+  );
+};

package/src/cli/dashboard/index.ts

@@ -0,0 +1,5 @@
+export { DashboardSidebar } from './DashboardSidebar';
+export { AgentList } from './AgentList';
+export { StatusBadge } from './StatusBadge';
+export { HelpFooter } from './HelpFooter';
+export type { InkComponents } from './types';

package/src/cli/dashboard/types.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared types for ink dashboard components.
+ * ink components are passed as props to avoid direct ESM imports
+ * (ink v5 is ESM-only; the project uses CJS).
+ */
+import { FC } from 'react';
+import { BoxProps, TextProps, Key } from 'ink';
+import { AgentState, AgentStatus } from '../../types/dashboard';
+
+/** ink components passed through from the dynamic import bridge */
+export interface InkComponents {
+  Box: FC<BoxProps>;
+  Text: FC<TextProps>;
+}
+
+export type { AgentState, AgentStatus, Key };

package/src/cli/tui.tsx

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// TUI implementation - simplified version without ink for now
+// Full ink-based implementation can be added after dependencies are installed
+
+import { listWorkspaces } from '../utils/workspace-meta';
+import { logError, logInfo } from '../utils/logger';
+import { colorize } from '../utils/colors';
+
+export const main = async () => {
+  try {
+    logInfo('Interactive TUI mode');
+    console.log(colorize('\n╔══════════════════════════════════════════╗', 'cyan'));
+    console.log(colorize('║    Workspace Manager - Interactive UI   ║', 'cyan'));
+    console.log(colorize('╚══════════════════════════════════════════╝\n', 'cyan'));
+
+    const workspaces = await listWorkspaces();
+
+    if (workspaces.length === 0) {
+      logError('No workspaces found');
+      console.log(colorize('Create a workspace with: workspace create', 'gray'));
+      process.exit(1);
+    }
+
+    console.log(colorize('Available Workspaces:', 'bright'));
+    for (let i = 0; i < workspaces.length; i++) {
+      const ws = workspaces[i];
+      const repoCount = ws.metadata?.repositories.length || 0;
+      console.log(`  ${i + 1}. ${colorize(ws.name, 'cyan')} (${repoCount} repos)`);
+    }
+
+    console.log('\n' + colorize('Commands:', 'bright'));
+    console.log('  workspace status <name>    - Check git status');
+    console.log('  workspace doctor <name>    - Run health checks');
+    console.log('  workspace sync <name>      - Pull latest changes');
+    console.log('  wgo <name>                 - Navigate to workspace');
+    console.log('');
+
+    logInfo('Full interactive TUI with ink will be available after running: npm install');
+  } catch (error) {
+    logError('TUI failed');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+};
+
+// Auto-execute only when run directly (not when imported by Commander)
+if (require.main === module) {
+  main();
+}

package/src/cli/workspace-cli.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+import * as path from 'path';
+
+const BIN = path.join(__dirname, '..', '..', 'bin', 'workspace.js');
+
+describe('w CLI entry point', () => {
+  it('--version prints version number', () => {
+    const output = execSync(`node ${BIN} --version 2>/dev/null`).toString().trim();
+    expect(output).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+
+  it('-V prints version number', () => {
+    const output = execSync(`node ${BIN} -V 2>/dev/null`).toString().trim();
+    expect(output).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+
+  it('--version and -V print the same version', () => {
+    const v1 = execSync(`node ${BIN} --version 2>/dev/null`).toString().trim();
+    const v2 = execSync(`node ${BIN} -V 2>/dev/null`).toString().trim();
+    expect(v1).toBe(v2);
+  });
+
+  it('help banner includes version', () => {
+    const output = execSync(`node ${BIN} --help 2>/dev/null`).toString();
+    expect(output).toContain('multi-repo workspaces');
+    // Version should appear in format "vX.Y.Z"
+    expect(output).toMatch(/v\d+\.\d+\.\d+/);
+  });
+});

package/src/commands/ai-prompt.ts

@@ -0,0 +1,21 @@
+import { logError } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import { run } from '../cli/ai-prompt';
+
+/**
+ * Handle the `nemus -- <prompt>` command.
+ * This is called directly from bin/workspace.js before Commander parses,
+ * because Commander treats `--` as end-of-options.
+ */
+export async function handleAiPrompt(prompt: string): Promise<void> {
+  if (!prompt || !prompt.trim()) {
+    logError('No prompt provided');
+    console.log(`\n  Usage: ${colorize('nemus -- <prompt>', 'green')}`);
+    console.log(`  Example: ${colorize('nemus -- create a workspace for the payments team', 'gray')}\n`);
+    process.exit(1);
+    return;
+  }
+
+  const exitCode = await run(prompt.trim());
+  process.exit(exitCode);
+}

package/src/commands/analyze-deps.ts

@@ -0,0 +1,119 @@
+import { Command } from 'commander';
+import * as path from 'path';
+import { WORKSPACES_DIR } from '../utils/config';
+import { loadMetadata, saveMetadata } from '../utils/workspace-meta';
+import {
+  analyzeDependencies,
+  detectCircularDependencies,
+  generateMermaidDiagram,
+  updateWorkspaceMetadata,
+} from '../utils/dependency-analyzer';
+import { logError, logInfo, logStep, logSuccess } from '../utils/logger';
+import { colorize } from '../utils/colors';
+import inquirer from 'inquirer';
+import { resolveWorkspace } from '../utils/command-helpers';
+
+const displayDependencyAnalysis = (analyses: Map<string, any>) => {
+  console.log('\n' + colorize('Dependency Analysis', 'bright'));
+  console.log(colorize('═'.repeat(100), 'gray'));
+
+  for (const [repoName, analysis] of analyses) {
+    console.log(`\n${colorize(repoName, 'cyan')}`);
+    if (analysis.dependencies.length > 0) {
+      console.log(`  ${colorize('Depends on:', 'gray')} ${analysis.dependencies.join(', ')}`);
+    }
+    if (analysis.dependents.length > 0) {
+      console.log(`  ${colorize('Depended by:', 'gray')} ${analysis.dependents.join(', ')}`);
+    }
+    if (analysis.missingDependencies.length > 0) {
+      console.log(`  ${colorize('⚠ Missing deps:', 'yellow')} ${analysis.missingDependencies.join(', ')}`);
+    }
+    if (analysis.dependencies.length === 0 && analysis.dependents.length === 0 && analysis.missingDependencies.length === 0) {
+      console.log(`  ${colorize('No dependencies detected', 'gray')}`);
+    }
+  }
+
+  console.log('\n' + colorize('═'.repeat(100), 'gray'));
+};
+
+export function registerAnalyzeDepsCommand(parent: Command) {
+  parent
+    .command('analyze-deps')
+    .alias('ad')
+    .description('Analyze inter-repo dependencies')
+    .argument('[workspace]', 'Workspace name')
+    .action(async (workspace) => {
+      await handleAnalyzeDeps(workspace);
+    });
+}
+
+async function handleAnalyzeDeps(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(`Analyzing dependencies for workspace: ${colorize(selectedWorkspace, 'cyan')}`);
+    logInfo('Scanning package.json, Dockerfile, and docker-compose.yml files...');
+
+    const repoNames = metadata.repositories.map(r => r.name);
+    const analyses = await analyzeDependencies(workspacePath, repoNames);
+
+    displayDependencyAnalysis(analyses);
+
+    const cycles = detectCircularDependencies(analyses);
+    if (cycles.length > 0) {
+      console.log('\n' + colorize('⚠ Circular Dependencies Detected:', 'yellow'));
+      for (const cycle of cycles) {
+        console.log(`  ${cycle.join(' → ')}`);
+      }
+    }
+
+    const diagram = generateMermaidDiagram(analyses);
+    console.log('\n' + colorize('Dependency Graph (Mermaid):', 'bright'));
+    console.log(diagram);
+
+    const missingDeps = new Set<string>();
+    for (const [, analysis] of analyses) {
+      for (const dep of analysis.missingDependencies) {
+        missingDeps.add(dep);
+      }
+    }
+
+    if (missingDeps.size > 0) {
+      console.log('\n' + colorize('💡 Suggested Missing Repositories:', 'yellow'));
+      for (const dep of missingDeps) {
+        console.log(`  • ${dep}`);
+      }
+      logInfo(`Consider adding these repositories with: workspace update ${selectedWorkspace}`);
+    }
+
+    if (process.stdout.isTTY) {
+      const { saveToMetadata } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'saveToMetadata',
+          message: 'Save dependency analysis to workspace metadata?',
+          default: true,
+        },
+      ]);
+
+      if (saveToMetadata) {
+        const updatedMetadata = updateWorkspaceMetadata(metadata, analyses);
+        await saveMetadata(workspacePath, updatedMetadata);
+        logSuccess('Dependency analysis saved to metadata');
+      }
+    }
+  } catch (error) {
+    logError('Failed to analyze dependencies');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}