@nemus-cli/nemus 0.2.1

package/src/utils/suite.test.ts

@@ -0,0 +1,256 @@
+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('validateSuiteName', () => {
+  let validateSuiteName: typeof import('./suite').validateSuiteName;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    const mod = await import('./suite');
+    validateSuiteName = mod.validateSuiteName;
+  });
+
+  it('returns true for valid names', () => {
+    expect(validateSuiteName('my-suite')).toBe(true);
+    expect(validateSuiteName('test_suite')).toBe(true);
+    expect(validateSuiteName('suite123')).toBe(true);
+    expect(validateSuiteName('ab')).toBe(true);
+  });
+
+  it('rejects empty names', () => {
+    expect(validateSuiteName('')).toContain('empty');
+    expect(validateSuiteName('   ')).toContain('empty');
+  });
+
+  it('rejects names with invalid characters', () => {
+    expect(validateSuiteName('my suite')).toContain('alphanumeric');
+    expect(validateSuiteName('my@suite')).toContain('alphanumeric');
+    expect(validateSuiteName('my.suite')).toContain('alphanumeric');
+  });
+
+  it('rejects names that are too short', () => {
+    expect(validateSuiteName('a')).toContain('at least 2');
+  });
+
+  it('rejects names that are too long', () => {
+    const longName = 'a'.repeat(51);
+    expect(validateSuiteName(longName)).toContain('50');
+  });
+});
+
+describe('suite CRUD operations', () => {
+  let tempDir: string;
+  let saveSuite: typeof import('./suite').saveSuite;
+  let getSuite: typeof import('./suite').getSuite;
+  let listSuites: typeof import('./suite').listSuites;
+  let deleteSuite: typeof import('./suite').deleteSuite;
+  let exportSuite: typeof import('./suite').exportSuite;
+  let exportAllSuites: typeof import('./suite').exportAllSuites;
+  let importSuites: typeof import('./suite').importSuites;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-suite-test-'));
+    process.env.WORKSPACE_MANAGER_CACHE_DIR = tempDir;
+
+    vi.resetModules();
+    const mod = await import('./suite');
+    saveSuite = mod.saveSuite;
+    getSuite = mod.getSuite;
+    listSuites = mod.listSuites;
+    deleteSuite = mod.deleteSuite;
+    exportSuite = mod.exportSuite;
+    exportAllSuites = mod.exportAllSuites;
+    importSuites = mod.importSuites;
+  });
+
+  afterEach(async () => {
+    delete process.env.WORKSPACE_MANAGER_CACHE_DIR;
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('saveSuite creates and getSuite retrieves a suite', async () => {
+    const suite = {
+      name: 'test-suite',
+      description: 'A test suite',
+      entries: [{ repoName: 'repo1', directoryName: 'repo1' }],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    };
+
+    await saveSuite(suite);
+    const retrieved = await getSuite('test-suite');
+
+    expect(retrieved).toBeDefined();
+    expect(retrieved!.name).toBe('test-suite');
+    expect(retrieved!.description).toBe('A test suite');
+    expect(retrieved!.entries).toHaveLength(1);
+  });
+
+  it('listSuites returns suites sorted by name', async () => {
+    await saveSuite({
+      name: 'z-suite',
+      description: '',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+    await saveSuite({
+      name: 'a-suite',
+      description: '',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+
+    const suites = await listSuites();
+    expect(suites).toHaveLength(2);
+    expect(suites[0].name).toBe('a-suite');
+    expect(suites[1].name).toBe('z-suite');
+  });
+
+  it('saveSuite upserts existing suites', async () => {
+    const suite = {
+      name: 'test-suite',
+      description: 'original',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    };
+
+    await saveSuite(suite);
+    await saveSuite({ ...suite, description: 'updated' });
+
+    const suites = await listSuites();
+    expect(suites).toHaveLength(1);
+    expect(suites[0].description).toBe('updated');
+  });
+
+  it('deleteSuite removes an existing suite', async () => {
+    await saveSuite({
+      name: 'to-delete',
+      description: '',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+
+    const result = await deleteSuite('to-delete');
+    expect(result).toBe(true);
+
+    const retrieved = await getSuite('to-delete');
+    expect(retrieved).toBeUndefined();
+  });
+
+  it('deleteSuite returns false for non-existent suite', async () => {
+    const result = await deleteSuite('non-existent');
+    expect(result).toBe(false);
+  });
+
+  it('exportSuite exports a single suite', async () => {
+    await saveSuite({
+      name: 'export-me',
+      description: 'test',
+      entries: [{ repoName: 'r1', directoryName: 'r1' }],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+
+    const exported = await exportSuite('export-me');
+    expect(exported).toBeDefined();
+    expect(exported!.version).toBe(1);
+    expect(exported!.suites).toHaveLength(1);
+    expect(exported!.suites[0].name).toBe('export-me');
+  });
+
+  it('exportAllSuites exports all suites', async () => {
+    await saveSuite({
+      name: 'suite-a',
+      description: '',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+    await saveSuite({
+      name: 'suite-b',
+      description: '',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+
+    const exported = await exportAllSuites();
+    expect(exported.version).toBe(1);
+    expect(exported.suites).toHaveLength(2);
+  });
+
+  it('importSuites imports with overwrite=true', async () => {
+    await saveSuite({
+      name: 'existing',
+      description: 'old',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+
+    const result = await importSuites({
+      version: 1,
+      suites: [{
+        name: 'existing',
+        description: 'new',
+        entries: [{ repoName: 'r', directoryName: 'r' }],
+        createdAt: '2024-02-01T00:00:00Z',
+        updatedAt: '2024-02-01T00:00:00Z',
+      }],
+    }, true);
+
+    expect(result.imported).toContain('existing');
+    expect(result.skipped).toHaveLength(0);
+
+    const retrieved = await getSuite('existing');
+    expect(retrieved!.description).toBe('new');
+  });
+
+  it('importSuites skips with overwrite=false', async () => {
+    await saveSuite({
+      name: 'existing',
+      description: 'old',
+      entries: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    });
+
+    const result = await importSuites({
+      version: 1,
+      suites: [{
+        name: 'existing',
+        description: 'new',
+        entries: [],
+        createdAt: '2024-02-01T00:00:00Z',
+        updatedAt: '2024-02-01T00:00:00Z',
+      }],
+    }, false);
+
+    expect(result.skipped).toContain('existing');
+
+    const retrieved = await getSuite('existing');
+    expect(retrieved!.description).toBe('old');
+  });
+
+  it('importSuites reports validation errors', async () => {
+    const result = await importSuites({
+      version: 1,
+      suites: [{
+        name: '',
+        description: '',
+        entries: [],
+        createdAt: '2024-01-01T00:00:00Z',
+        updatedAt: '2024-01-01T00:00:00Z',
+      }],
+    }, true);
+
+    expect(result.errors).toHaveLength(1);
+    expect(result.imported).toHaveLength(0);
+  });
+});

package/src/utils/suite.ts

@@ -0,0 +1,144 @@
+import * as fs from 'fs/promises';
+import { WorkspaceSuite, SuitesStore } from '../types';
+import { CACHE_DIR, SUITES_FILE } from './config';
+import { logWarning } from './logger';
+
+const SUITE_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+
+async function ensureCacheDir(): Promise<void> {
+  try {
+    await fs.mkdir(CACHE_DIR, { recursive: true });
+  } catch {
+    logWarning('Failed to create cache directory');
+  }
+}
+
+export async function loadSuitesStore(): Promise<SuitesStore> {
+  try {
+    const content = await fs.readFile(SUITES_FILE, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, suites: [] };
+  }
+}
+
+export async function saveSuitesStore(store: SuitesStore): Promise<void> {
+  await ensureCacheDir();
+  await fs.writeFile(SUITES_FILE, JSON.stringify(store, null, 2), 'utf-8');
+}
+
+export async function listSuites(): Promise<WorkspaceSuite[]> {
+  const store = await loadSuitesStore();
+  return store.suites.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export async function getSuite(name: string): Promise<WorkspaceSuite | undefined> {
+  const store = await loadSuitesStore();
+  return store.suites.find(s => s.name === name);
+}
+
+export async function saveSuite(suite: WorkspaceSuite): Promise<void> {
+  const store = await loadSuitesStore();
+  const existingIndex = store.suites.findIndex(s => s.name === suite.name);
+
+  if (existingIndex >= 0) {
+    store.suites[existingIndex] = suite;
+  } else {
+    store.suites.push(suite);
+  }
+
+  await saveSuitesStore(store);
+}
+
+export async function deleteSuite(name: string): Promise<boolean> {
+  const store = await loadSuitesStore();
+  const index = store.suites.findIndex(s => s.name === name);
+
+  if (index < 0) {
+    return false;
+  }
+
+  store.suites.splice(index, 1);
+  await saveSuitesStore(store);
+  return true;
+}
+
+export async function exportSuite(name: string): Promise<SuitesStore | null> {
+  const suite = await getSuite(name);
+  if (!suite) {
+    return null;
+  }
+  return { version: 1, suites: [suite] };
+}
+
+export async function exportAllSuites(): Promise<SuitesStore> {
+  const store = await loadSuitesStore();
+  return { version: 1, suites: store.suites };
+}
+
+export async function importSuites(
+  data: SuitesStore,
+  overwrite: boolean
+): Promise<{ imported: string[]; skipped: string[]; errors: string[] }> {
+  const result = { imported: [] as string[], skipped: [] as string[], errors: [] as string[] };
+  const store = await loadSuitesStore();
+
+  for (const suite of data.suites) {
+    const nameValidation = validateSuiteName(suite.name);
+    if (nameValidation !== true) {
+      result.errors.push(`${suite.name}: ${nameValidation}`);
+      continue;
+    }
+
+    if (!Array.isArray(suite.entries)) {
+      result.errors.push(`${suite.name}: missing or invalid entries`);
+      continue;
+    }
+
+    const hasInvalidEntries = suite.entries.some(
+      e => !e.repoName || typeof e.repoName !== 'string' || !e.directoryName || typeof e.directoryName !== 'string'
+    );
+    if (hasInvalidEntries) {
+      result.errors.push(`${suite.name}: entries contain invalid repoName or directoryName values`);
+      continue;
+    }
+
+    const existingIndex = store.suites.findIndex(s => s.name === suite.name);
+
+    if (existingIndex >= 0 && !overwrite) {
+      result.skipped.push(suite.name);
+      continue;
+    }
+
+    if (existingIndex >= 0) {
+      store.suites[existingIndex] = suite;
+    } else {
+      store.suites.push(suite);
+    }
+
+    result.imported.push(suite.name);
+  }
+
+  await saveSuitesStore(store);
+  return result;
+}
+
+export function validateSuiteName(name: string): true | string {
+  if (!name || name.trim().length === 0) {
+    return 'Suite name cannot be empty';
+  }
+
+  if (!SUITE_NAME_REGEX.test(name)) {
+    return 'Suite name must contain only alphanumeric characters, hyphens, and underscores';
+  }
+
+  if (name.length < 2) {
+    return 'Suite name must be at least 2 characters long';
+  }
+
+  if (name.length > 50) {
+    return 'Suite name must be 50 characters or less';
+  }
+
+  return true;
+}

package/src/utils/sync-operations.ts

@@ -0,0 +1,87 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs/promises';
+import { logInfo, logSuccess, logError } from './logger';
+import { colorize } from './colors';
+import { withRetry } from './retry';
+
+const execAsync = promisify(exec);
+
+export interface SyncResult {
+  repo: string;
+  status: 'success' | 'failed' | 'skipped';
+  message?: string;
+}
+
+export async function syncRepository(repoPath: string, repoName: string, silent: boolean = false): Promise<SyncResult> {
+  try {
+    // Check if directory exists
+    try {
+      await fs.access(repoPath);
+    } catch {
+      return {
+        repo: repoName,
+        status: 'skipped',
+        message: 'Directory not found',
+      };
+    }
+
+    // Check if it's a git repository
+    try {
+      await execAsync('git rev-parse --git-dir', { cwd: repoPath });
+    } catch {
+      return {
+        repo: repoName,
+        status: 'skipped',
+        message: 'Not a git repository',
+      };
+    }
+
+    // Check for uncommitted changes
+    const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: repoPath });
+    if (statusOutput.trim().length > 0) {
+      return {
+        repo: repoName,
+        status: 'skipped',
+        message: 'Uncommitted changes',
+      };
+    }
+
+    // Get current branch
+    const { stdout: branchOutput } = await execAsync('git branch --show-current', { cwd: repoPath });
+    const currentBranch = branchOutput.trim();
+
+    if (!currentBranch) {
+      return {
+        repo: repoName,
+        status: 'skipped',
+        message: 'Detached HEAD state',
+      };
+    }
+
+    if (!silent) logInfo(`Pulling ${colorize(repoName, 'cyan')} (${currentBranch})...`);
+
+    // Git pull with retry
+    await withRetry(
+      () => execAsync('git pull', { cwd: repoPath, timeout: 60000 }),
+      undefined,
+      `Pull ${repoName}`
+    );
+
+    if (!silent) logSuccess(`Updated ${colorize(repoName, 'cyan')}`);
+
+    return {
+      repo: repoName,
+      status: 'success',
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    logError(`Failed to sync ${colorize(repoName, 'cyan')}: ${errorMessage}`);
+
+    return {
+      repo: repoName,
+      status: 'failed',
+      message: errorMessage,
+    };
+  }
+}

package/src/utils/tmux-dashboard.ts

@@ -0,0 +1,193 @@
+import { spawnSync } from 'child_process';
+import { AgentState, DASHBOARD_DEFAULTS } from '../types/dashboard';
+
+const { sessionName } = DASHBOARD_DEFAULTS;
+
+export const HIDDEN_WINDOW = `${sessionName}:1`;
+
+export interface PaneInfo {
+  index: string;
+  pid: number;
+}
+
+/**
+ * Get agent panes in the main dashboard window (excludes sidebar pane 0).
+ */
+export function getAgentPanes(): PaneInfo[] {
+  const result = spawnSync('tmux', [
+    'list-panes', '-t', sessionName, '-F',
+    '#{pane_index} #{pane_pid}',
+  ], { stdio: 'pipe' });
+
+  if (!result.stdout) return [];
+  return result.stdout.toString().trim().split('\n')
+    .filter(l => l.trim())
+    .map(line => {
+      const [index, pid] = line.split(' ');
+      return { index, pid: parseInt(pid, 10) || 0 };
+    })
+    .filter(p => p.index !== '0');
+}
+
+/**
+ * Get panes from the hidden window (window 1) used during zoom.
+ */
+export function getHiddenPanes(): PaneInfo[] {
+  const result = spawnSync('tmux', [
+    'list-panes', '-t', HIDDEN_WINDOW, '-F',
+    '#{pane_index} #{pane_pid}',
+  ], { stdio: 'pipe' });
+
+  if (!result.stdout) return [];
+  return result.stdout.toString().trim().split('\n')
+    .filter(l => l.trim())
+    .map(line => {
+      const [index, pid] = line.split(' ');
+      return { index, pid: parseInt(pid, 10) || 0 };
+    });
+}
+
+/**
+ * Find the tmux pane matching an agent by PID (direct match only).
+ */
+export function findPaneForAgent(agent: AgentState, panes: PaneInfo[]): PaneInfo | null {
+  return panes.find(p => p.pid === agent.pid) ?? null;
+}
+
+/**
+ * Sort agents to match tmux pane order (top-to-bottom) by PID.
+ */
+export function sortAgentsByPaneOrder(agents: AgentState[], panes: PaneInfo[]): AgentState[] {
+  const pidToIndex = new Map<number, number>();
+  panes.forEach((p, i) => pidToIndex.set(p.pid, i));
+  return [...agents].sort((a, b) => {
+    const aIdx = pidToIndex.get(a.pid) ?? 999;
+    const bIdx = pidToIndex.get(b.pid) ?? 999;
+    return aIdx - bIdx;
+  });
+}
+
+/**
+ * Sort agents by an explicit PID order array (used during zoom to
+ * preserve the original order regardless of current pane positions).
+ */
+export function sortAgentsByPidOrder(agents: AgentState[], pidOrder: number[]): AgentState[] {
+  const pidToIndex = new Map<number, number>();
+  pidOrder.forEach((pid, i) => pidToIndex.set(pid, i));
+  return [...agents].sort((a, b) => {
+    const aIdx = pidToIndex.get(a.pid) ?? 999;
+    const bIdx = pidToIndex.get(b.pid) ?? 999;
+    return aIdx - bIdx;
+  });
+}
+
+/**
+ * Restore all panes from the hidden window back to the main window,
+ * then reorder them to match the given original PID order.
+ */
+export function restoreHiddenPanes(originalPidOrder?: number[]): void {
+  // First, bring all hidden panes back (order may be wrong)
+  for (let i = 0; i < 20; i++) {
+    const winCheck = spawnSync('tmux', [
+      'list-windows', '-t', sessionName, '-F', '#{window_index}',
+    ], { stdio: 'pipe' });
+    if (!winCheck.stdout || !winCheck.stdout.toString().split('\n').some(l => l.trim() === '1')) break;
+
+    const hidden = getHiddenPanes();
+    if (hidden.length === 0) break;
+
+    const result = spawnSync('tmux', [
+      'join-pane', '-d',
+      '-s', `${HIDDEN_WINDOW}.${hidden[0].index}`,
+      '-t', `${sessionName}:0`,
+    ], { stdio: 'pipe' });
+
+    if (result.status !== 0) break;
+  }
+
+  // If we have a desired order, reorder panes by swapping them into place
+  if (originalPidOrder && originalPidOrder.length > 0) {
+    reorderPanesByPid(originalPidOrder);
+  }
+}
+
+/**
+ * Reorder agent panes to match the given PID order using swap-pane.
+ * Uses a simple selection sort: for each position, find the pane with
+ * the correct PID and swap it into place.
+ */
+function reorderPanesByPid(desiredPidOrder: number[]): void {
+  for (let i = 0; i < desiredPidOrder.length; i++) {
+    const targetPid = desiredPidOrder[i];
+    const currentPanes = getAgentPanes();
+
+    // Find the current index of the pane with the desired PID
+    const currentIdx = currentPanes.findIndex(p => p.pid === targetPid);
+    if (currentIdx === -1) continue; // pane not found (maybe died)
+
+    // The pane that should be at position i
+    const shouldBeAt = currentPanes[i];
+    if (!shouldBeAt) continue;
+
+    // If already in the right position, skip
+    if (currentPanes[currentIdx].index === shouldBeAt.index) continue;
+
+    // Swap the pane at position i with the pane that has the correct PID
+    spawnSync('tmux', [
+      'swap-pane',
+      '-s', `${sessionName}:0.${currentPanes[currentIdx].index}`,
+      '-t', `${sessionName}:0.${shouldBeAt.index}`,
+    ], { stdio: 'pipe' });
+  }
+}
+
+/**
+ * Reset to normal layout: restore hidden panes + rebalance.
+ */
+export function resetLayout(): void {
+  restoreHiddenPanes();
+  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' });
+}
+
+/**
+ * Zoom: hide all other agent panes to a hidden window.
+ * First pane: break-pane (creates window 1).
+ * Subsequent panes: join-pane into existing window 1.
+ */
+export function zoomPane(targetPane: PaneInfo): void {
+  const targetPid = targetPane.pid;
+  let hiddenWindowExists = false;
+
+  const winCheck = spawnSync('tmux', [
+    'list-windows', '-t', sessionName, '-F', '#{window_index}',
+  ], { stdio: 'pipe' });
+  if (winCheck.stdout && winCheck.stdout.toString().split('\n').some(l => l.trim() === '1')) {
+    hiddenWindowExists = true;
+  }
+
+  for (let i = 0; i < 20; i++) {
+    const currentPanes = getAgentPanes();
+    const toHide = currentPanes.find(p => p.pid !== targetPid);
+    if (!toHide) break;
+
+    if (!hiddenWindowExists) {
+      spawnSync('tmux', [
+        'break-pane', '-d',
+        '-s', `${sessionName}:0.${toHide.index}`,
+      ], { stdio: 'pipe' });
+      hiddenWindowExists = true;
+    } else {
+      spawnSync('tmux', [
+        'join-pane', '-d',
+        '-s', `${sessionName}:0.${toHide.index}`,
+        '-t', HIDDEN_WINDOW,
+      ], { stdio: 'pipe' });
+    }
+  }
+
+  spawnSync('tmux', ['select-layout', '-t', `${sessionName}:0`, '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' });
+}