@nemus-cli/nemus 0.2.1

package/src/utils/pi-extensions.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { installPiExtensions, uninstallPiExtensions, getPiExtensionStatus } from './pi-extensions';
+
+describe('Pi extensions', () => {
+  let tmpDir: string;
+  let extensionsDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-ext-test-'));
+    extensionsDir = path.join(tmpDir, '.pi', 'agent', 'extensions');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('installPiExtensions', () => {
+    it('creates the extensions directory if it does not exist', () => {
+      expect(fs.existsSync(extensionsDir)).toBe(false);
+      installPiExtensions(extensionsDir);
+      expect(fs.existsSync(extensionsDir)).toBe(true);
+    });
+
+    it('installs all managed extensions', () => {
+      installPiExtensions(extensionsDir);
+
+      const files = fs.readdirSync(extensionsDir);
+      expect(files).toContain('ws-permission-sync.ts');
+      expect(files).toContain('ws-review-reminder.ts');
+      expect(files).toContain('ws-permissions-gate.ts');
+    });
+
+    it('installed extensions contain the managed marker', () => {
+      installPiExtensions(extensionsDir);
+
+      for (const file of fs.readdirSync(extensionsDir)) {
+        const content = fs.readFileSync(path.join(extensionsDir, file), 'utf-8');
+        expect(content).toContain('auto-generated by workspace-manager');
+      }
+    });
+
+    it('permission-sync extension has the script path replaced', () => {
+      installPiExtensions(extensionsDir);
+
+      const content = fs.readFileSync(
+        path.join(extensionsDir, 'ws-permission-sync.ts'),
+        'utf-8'
+      );
+      // Should not contain the placeholder
+      expect(content).not.toContain('__SYNC_PERMISSIONS_SCRIPT__');
+      // Should contain an actual path
+      expect(content).toContain('sync-permissions.sh');
+    });
+
+    it('review-reminder extension references cache directory', () => {
+      installPiExtensions(extensionsDir);
+
+      const content = fs.readFileSync(
+        path.join(extensionsDir, 'ws-review-reminder.ts'),
+        'utf-8'
+      );
+      expect(content).toContain('.workspace-manager-cache');
+      expect(content).toContain('last-permission-review');
+    });
+
+    it('permissions-gate extension has dangerous patterns', () => {
+      installPiExtensions(extensionsDir);
+
+      const content = fs.readFileSync(
+        path.join(extensionsDir, 'ws-permissions-gate.ts'),
+        'utf-8'
+      );
+      expect(content).toContain('rm\\s+-rf');
+      expect(content).toContain('isToolCallEventType');
+    });
+
+    it('is idempotent — installing twice overwrites cleanly', () => {
+      installPiExtensions(extensionsDir);
+      const firstFiles = fs.readdirSync(extensionsDir).sort();
+
+      installPiExtensions(extensionsDir);
+      const secondFiles = fs.readdirSync(extensionsDir).sort();
+
+      expect(firstFiles).toEqual(secondFiles);
+    });
+
+    it('does not touch non-managed files', () => {
+      fs.mkdirSync(extensionsDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(extensionsDir, 'my-custom-extension.ts'),
+        '// custom'
+      );
+
+      installPiExtensions(extensionsDir);
+
+      expect(
+        fs.readFileSync(path.join(extensionsDir, 'my-custom-extension.ts'), 'utf-8')
+      ).toBe('// custom');
+    });
+  });
+
+  describe('uninstallPiExtensions', () => {
+    it('removes all managed extensions', () => {
+      installPiExtensions(extensionsDir);
+      expect(fs.readdirSync(extensionsDir).length).toBeGreaterThan(0);
+
+      uninstallPiExtensions(extensionsDir);
+
+      expect(fs.readdirSync(extensionsDir).length).toBe(0);
+    });
+
+    it('does not remove non-managed extensions', () => {
+      installPiExtensions(extensionsDir);
+      fs.writeFileSync(
+        path.join(extensionsDir, 'my-custom-extension.ts'),
+        '// custom extension'
+      );
+
+      uninstallPiExtensions(extensionsDir);
+
+      const remaining = fs.readdirSync(extensionsDir);
+      expect(remaining).toEqual(['my-custom-extension.ts']);
+    });
+
+    it('removes files with managed marker even if renamed', () => {
+      installPiExtensions(extensionsDir);
+
+      // Rename a managed extension
+      fs.renameSync(
+        path.join(extensionsDir, 'ws-permission-sync.ts'),
+        path.join(extensionsDir, 'renamed-sync.ts')
+      );
+
+      uninstallPiExtensions(extensionsDir);
+
+      // renamed file should also be removed (has marker)
+      expect(fs.readdirSync(extensionsDir).length).toBe(0);
+    });
+
+    it('handles non-existent directory gracefully', () => {
+      expect(() => uninstallPiExtensions('/nonexistent/path')).not.toThrow();
+    });
+  });
+
+  describe('getPiExtensionStatus', () => {
+    it('reports all missing when nothing is installed', () => {
+      fs.mkdirSync(extensionsDir, { recursive: true });
+
+      const status = getPiExtensionStatus(extensionsDir);
+      expect(status.installed).toHaveLength(0);
+      expect(status.missing.length).toBeGreaterThan(0);
+      expect(status.missing).toContain('ws-permission-sync.ts');
+      expect(status.missing).toContain('ws-review-reminder.ts');
+      expect(status.missing).toContain('ws-permissions-gate.ts');
+    });
+
+    it('reports all installed after installation', () => {
+      installPiExtensions(extensionsDir);
+
+      const status = getPiExtensionStatus(extensionsDir);
+      expect(status.missing).toHaveLength(0);
+      expect(status.installed).toContain('ws-permission-sync.ts');
+      expect(status.installed).toContain('ws-review-reminder.ts');
+      expect(status.installed).toContain('ws-permissions-gate.ts');
+    });
+
+    it('reports partial when some are missing', () => {
+      installPiExtensions(extensionsDir);
+
+      // Delete one
+      fs.unlinkSync(path.join(extensionsDir, 'ws-review-reminder.ts'));
+
+      const status = getPiExtensionStatus(extensionsDir);
+      expect(status.installed).not.toContain('ws-review-reminder.ts');
+      expect(status.missing).toContain('ws-review-reminder.ts');
+      expect(status.installed.length + status.missing.length).toBe(5);
+    });
+  });
+});

package/src/utils/pi-extensions.ts

@@ -0,0 +1,226 @@
+/**
+ * Pi extension management — install/uninstall Pi extensions that replicate
+ * Claude Code hooks and MCP functionality.
+ *
+ * Pi uses TypeScript extensions instead of:
+ *   - settings.json hooks (Stop, SessionStart, PostToolUse)
+ *   - .mcp.json / `claude mcp add` (MCP servers)
+ *
+ * This module generates and installs extensions from bundled templates.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { logSuccess, logInfo, logWarning } from './logger';
+
+const PI_EXTENSIONS_DIR = path.join(os.homedir(), '.pi', 'agent', 'extensions');
+
+/** Marker comment that identifies workspace-manager managed extensions */
+const MANAGED_MARKER = '(auto-generated by workspace-manager)';
+
+/**
+ * Extension template definitions.
+ * Each maps a template file to the installed extension filename,
+ * with optional placeholder replacements.
+ */
+interface ExtensionTemplate {
+  /** Template filename (relative to pi-extensions/ dir) */
+  templateFile: string;
+  /** Installed filename under ~/.pi/agent/extensions/ */
+  installedName: string;
+  /** Placeholder replacements: key => value */
+  replacements?: Record<string, string>;
+}
+
+function getTemplatesDir(): string {
+  // When compiled: dist/utils/ -> dist/pi-extensions/
+  const distPath = path.resolve(__dirname, '..', 'pi-extensions');
+  // When running from source: src/utils/ -> src/pi-extensions/
+  const srcPath = path.resolve(__dirname, '..', '..', 'src', 'pi-extensions');
+
+  if (fs.existsSync(distPath)) return distPath;
+  if (fs.existsSync(srcPath)) return srcPath;
+
+  throw new Error('Could not find pi-extensions/ directory.');
+}
+
+function getSyncPermissionsScript(): string {
+  const scriptPath = path.resolve(__dirname, '..', '..', 'sync-permissions.sh');
+  if (fs.existsSync(scriptPath)) return scriptPath;
+  throw new Error('Could not find sync-permissions.sh');
+}
+
+function getExtensionTemplates(options: { workspaceInputStatus?: boolean } = {}): ExtensionTemplate[] {
+  let syncScript: string;
+  try {
+    syncScript = getSyncPermissionsScript();
+  } catch {
+    logWarning('Could not locate sync-permissions.sh — permission-sync extension will need manual path configuration');
+    syncScript = ''; // Empty placeholder — user must configure manually
+  }
+
+  const templates: ExtensionTemplate[] = [
+    {
+      templateFile: 'permission-sync.ts.template',
+      installedName: 'ws-permission-sync.ts',
+      replacements: syncScript ? { '__SYNC_PERMISSIONS_SCRIPT__': syncScript } : {},
+    },
+    {
+      templateFile: 'review-reminder.ts.template',
+      installedName: 'ws-review-reminder.ts',
+    },
+    {
+      templateFile: 'permissions-gate.ts.template',
+      installedName: 'ws-permissions-gate.ts',
+    },
+    {
+      templateFile: 'pr-fix-trigger.ts.template',
+      installedName: 'ws-pr-fix-trigger.ts',
+    },
+  ];
+
+  // Workspace input-status widget — enabled by default, opt-out via config
+  if (options.workspaceInputStatus !== false) {
+    templates.push({
+      templateFile: 'workspace-input-status.ts.template',
+      installedName: 'ws-workspace-input-status.ts',
+    });
+  }
+
+  return templates;
+}
+
+/**
+ * Install all workspace-manager Pi extensions.
+ * Idempotent — overwrites existing managed extensions with latest templates.
+ *
+ * @param extensionsDir Override the extensions directory (for testing).
+ */
+export function installPiExtensions(extensionsDir?: string, options: { workspaceInputStatus?: boolean } = {}): void {
+  const targetDir = extensionsDir ?? PI_EXTENSIONS_DIR;
+
+  let templatesDir: string;
+  try {
+    templatesDir = getTemplatesDir();
+  } catch {
+    logWarning('Could not find Pi extension templates — skipping');
+    return;
+  }
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const templates = getExtensionTemplates(options);
+  let installed = 0;
+
+  for (const tpl of templates) {
+    const templatePath = path.join(templatesDir, tpl.templateFile);
+    if (!fs.existsSync(templatePath)) {
+      logWarning(`Template not found: ${tpl.templateFile} — skipping`);
+      continue;
+    }
+
+    let content = fs.readFileSync(templatePath, 'utf-8');
+
+    // Apply replacements
+    if (tpl.replacements) {
+      for (const [placeholder, value] of Object.entries(tpl.replacements)) {
+        content = content.replace(new RegExp(escapeRegex(placeholder), 'g'), value);
+      }
+    }
+
+    const targetPath = path.join(targetDir, tpl.installedName);
+    fs.writeFileSync(targetPath, content, 'utf-8');
+    installed++;
+  }
+
+  if (installed > 0) {
+    logSuccess(`Installed ${installed} Pi extension(s) in ${targetDir}`);
+  }
+}
+
+/**
+ * Uninstall workspace-manager managed Pi extensions.
+ * Only removes extensions that contain the managed marker or match
+ * known installed names.
+ *
+ * @param extensionsDir Override the extensions directory (for testing).
+ */
+/**
+ * Uninstall workspace-manager managed Pi extensions.
+ * Pass `onlyNames` to remove only specific extension files (for opt-out).
+ *
+ * @param extensionsDir Override the extensions directory (for testing).
+ * @param options.onlyNames If set, only remove files in this list.
+ */
+export function uninstallPiExtensions(
+  extensionsDir?: string,
+  options?: { onlyNames?: string[] },
+): void {
+  const targetDir = extensionsDir ?? PI_EXTENSIONS_DIR;
+
+  if (!fs.existsSync(targetDir)) return;
+
+  const templates = getExtensionTemplates({ workspaceInputStatus: true });
+  const knownNames = new Set(templates.map(t => t.installedName));
+  const onlyNames = options?.onlyNames ? new Set(options.onlyNames) : null;
+  let removed = 0;
+
+  for (const file of fs.readdirSync(targetDir)) {
+    if (!file.endsWith('.ts')) continue;
+
+    // When onlyNames is set, skip files not in that list
+    if (onlyNames && !onlyNames.has(file)) continue;
+
+    const filePath = path.join(targetDir, file);
+
+    // Remove if it matches a known managed name
+    if (knownNames.has(file)) {
+      fs.unlinkSync(filePath);
+      removed++;
+      continue;
+    }
+
+    // Also remove if it contains the managed marker (for renamed files)
+    if (!onlyNames) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (content.includes(MANAGED_MARKER)) {
+          fs.unlinkSync(filePath);
+          removed++;
+        }
+      } catch { /* ignore read errors */ }
+    }
+  }
+
+  if (removed > 0) {
+    logSuccess(`Removed ${removed} Pi extension(s) from ${targetDir}`);
+  }
+}
+
+/**
+ * Check which managed Pi extensions are installed.
+ */
+export function getPiExtensionStatus(extensionsDir?: string): { installed: string[]; missing: string[] } {
+  const targetDir = extensionsDir ?? PI_EXTENSIONS_DIR;
+  const templates = getExtensionTemplates({ workspaceInputStatus: true });
+  const installed: string[] = [];
+  const missing: string[] = [];
+
+  for (const tpl of templates) {
+    const targetPath = path.join(targetDir, tpl.installedName);
+    if (fs.existsSync(targetPath)) {
+      installed.push(tpl.installedName);
+    } else {
+      missing.push(tpl.installedName);
+    }
+  }
+
+  return { installed, missing };
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/utils/progress.ts

@@ -0,0 +1,73 @@
+import * as cliProgress from 'cli-progress';
+
+export class ProgressTracker {
+  private multibar: cliProgress.MultiBar;
+  private bars: Map<string, cliProgress.SingleBar>;
+  private startTimes: Map<string, number>;
+
+  constructor() {
+    this.multibar = new cliProgress.MultiBar(
+      {
+        clearOnComplete: false,
+        hideCursor: true,
+        format: ' {bar} | {percentage}% | {value}/{total} | {task} | {duration}',
+      },
+      cliProgress.Presets.shades_classic
+    );
+    this.bars = new Map();
+    this.startTimes = new Map();
+  }
+
+  addTask(taskId: string, total: number, taskName: string): void {
+    const bar = this.multibar.create(total, 0, { task: taskName, duration: '0s' });
+    this.bars.set(taskId, bar);
+    this.startTimes.set(taskId, Date.now());
+  }
+
+  updateTask(taskId: string, current: number, taskName?: string): void {
+    const bar = this.bars.get(taskId);
+    const startTime = this.startTimes.get(taskId);
+
+    if (bar && startTime) {
+      const elapsed = Math.floor((Date.now() - startTime) / 1000);
+      const duration = this.formatDuration(elapsed);
+
+      bar.update(current, {
+        task: taskName || 'Processing',
+        duration,
+      });
+    }
+  }
+
+  completeTask(taskId: string): void {
+    const bar = this.bars.get(taskId);
+    if (bar) {
+      bar.stop();
+      this.bars.delete(taskId);
+      this.startTimes.delete(taskId);
+    }
+  }
+
+  stop(): void {
+    this.multibar.stop();
+  }
+
+  private formatDuration(seconds: number): string {
+    if (seconds < 60) {
+      return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+}
+
+export const createSimpleProgressBar = (total: number, taskName: string): cliProgress.SingleBar => {
+  return new cliProgress.SingleBar(
+    {
+      format: ` ${taskName} | {bar} | {percentage}% | {value}/{total} | {duration}`,
+      hideCursor: true,
+    },
+    cliProgress.Presets.shades_classic
+  );
+};

package/src/utils/prompts.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockPrompt } = vi.hoisted(() => ({
+  mockPrompt: vi.fn(),
+}));
+
+// Mock inquirer before imports
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: mockPrompt,
+    registerPrompt: vi.fn(),
+  },
+}));
+
+vi.mock('inquirer-autocomplete-prompt', () => ({
+  default: {},
+}));
+
+vi.mock('fuzzy', () => ({
+  filter: (input: string, list: string[]) => {
+    const lower = input.toLowerCase();
+    return list
+      .filter(item => item.toLowerCase().includes(lower))
+      .map(item => ({ original: item, string: item }));
+  },
+}));
+
+vi.mock('./colors', () => ({
+  colorize: (text: string) => text,
+}));
+
+vi.mock('./validation', () => ({
+  validateWorkspaceName: vi.fn().mockReturnValue(true),
+  checkWorkspaceExists: vi.fn().mockResolvedValue(false),
+  sanitizeWorkspaceName: vi.fn((input: string) => input),
+}));
+
+import { promptMultiWorkspaceSelection } from './prompts';
+
+const makeWorkspaces = (...names: string[]) =>
+  names.map(name => ({
+    name,
+    path: `/workspaces/${name}`,
+    metadata: { repositories: [], createdAt: new Date().toISOString() },
+  }));
+
+describe('promptMultiWorkspaceSelection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  it('returns selected workspace names', async () => {
+    mockPrompt
+      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
+      .mockResolvedValueOnce({ workspaceName: 'ws-beta' })
+      .mockResolvedValueOnce({ workspaceName: 'done' });
+
+    const result = await promptMultiWorkspaceSelection(
+      makeWorkspaces('ws-alpha', 'ws-beta', 'ws-gamma')
+    );
+
+    expect(result).toEqual(['ws-alpha', 'ws-beta']);
+  });
+
+  it('requires at least one selection before accepting done', async () => {
+    // First "done" should be rejected, then select one, then done
+    mockPrompt
+      .mockResolvedValueOnce({ workspaceName: 'done' })
+      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
+      .mockResolvedValueOnce({ workspaceName: 'done' });
+
+    const result = await promptMultiWorkspaceSelection(
+      makeWorkspaces('ws-alpha', 'ws-beta')
+    );
+
+    expect(result).toEqual(['ws-alpha']);
+    // Should have prompted 3 times (done rejected, select, done accepted)
+    expect(mockPrompt).toHaveBeenCalledTimes(3);
+  });
+
+  it('auto-completes when all workspaces are selected', async () => {
+    mockPrompt
+      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
+      .mockResolvedValueOnce({ workspaceName: 'ws-beta' });
+
+    const result = await promptMultiWorkspaceSelection(
+      makeWorkspaces('ws-alpha', 'ws-beta')
+    );
+
+    expect(result).toEqual(['ws-alpha', 'ws-beta']);
+    // Only 2 prompts needed - loop breaks when no available names left
+    expect(mockPrompt).toHaveBeenCalledTimes(2);
+  });
+
+  it('returns single workspace selection', async () => {
+    mockPrompt
+      .mockResolvedValueOnce({ workspaceName: 'ws-only' })
+      .mockResolvedValueOnce({ workspaceName: 'done' });
+
+    const result = await promptMultiWorkspaceSelection(
+      makeWorkspaces('ws-only', 'ws-other')
+    );
+
+    expect(result).toEqual(['ws-only']);
+  });
+
+  it('exits process on Ctrl+C', async () => {
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit');
+    });
+
+    mockPrompt.mockRejectedValueOnce(new Error('User force closed'));
+
+    await expect(
+      promptMultiWorkspaceSelection(makeWorkspaces('ws-alpha'))
+    ).rejects.toThrow('process.exit');
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+    mockExit.mockRestore();
+  });
+
+  it('prints summary with correct singular form', async () => {
+    const logSpy = vi.spyOn(console, 'log');
+    mockPrompt
+      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
+      .mockResolvedValueOnce({ workspaceName: 'done' });
+
+    await promptMultiWorkspaceSelection(makeWorkspaces('ws-alpha', 'ws-beta'));
+
+    const summaryCalls = logSpy.mock.calls.map(c => c[0]);
+    expect(summaryCalls).toContainEqual(
+      expect.stringContaining('Selected 1 workspace:')
+    );
+  });
+
+  it('prints summary with correct plural form', async () => {
+    const logSpy = vi.spyOn(console, 'log');
+    mockPrompt
+      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
+      .mockResolvedValueOnce({ workspaceName: 'ws-beta' })
+      .mockResolvedValueOnce({ workspaceName: 'done' });
+
+    await promptMultiWorkspaceSelection(
+      makeWorkspaces('ws-alpha', 'ws-beta', 'ws-gamma')
+    );
+
+    const summaryCalls = logSpy.mock.calls.map(c => c[0]);
+    expect(summaryCalls).toContainEqual(
+      expect.stringContaining('Selected 2 workspaces:')
+    );
+  });
+
+  it('prints green confirmation after each selection', async () => {
+    const logSpy = vi.spyOn(console, 'log');
+    mockPrompt
+      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
+      .mockResolvedValueOnce({ workspaceName: 'ws-beta' })
+      .mockResolvedValueOnce({ workspaceName: 'done' });
+
+    await promptMultiWorkspaceSelection(
+      makeWorkspaces('ws-alpha', 'ws-beta', 'ws-gamma')
+    );
+
+    const loggedMessages = logSpy.mock.calls.map(c => c[0]);
+    expect(loggedMessages).toContainEqual(expect.stringContaining('Added: ws-alpha'));
+    expect(loggedMessages).toContainEqual(expect.stringContaining('Added: ws-beta'));
+  });
+});