nfo-cli 0.0.4-improve-prompting → 0.0.6-a89844d-dev

package/tests/commands/restore.test.ts

@@ -1,126 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { restoreOrchestra } from '../../src/commands/restore.js';
-import { makeTmpRepo, type TmpRepo } from '../helpers/tmp-repo.js';
-import { makeTmpConfig } from '../helpers/tmp-config.js';
-import { ensureOrchestraDir, writeState, readState } from '../../src/state.js';
-import { makeInitialState } from '../../src/state.types.js';
-import { projectKeyFromPath } from '../../src/project-key.js';
-import { sessionExists, killSession, sessionName } from '../../src/tmux.js';
-import { musicianMcpConfigPath } from '../../src/mcp/config.js';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { orchestraDir } from '../../src/config.js';
-import { MUSICIAN_ROLE_PROMPT_V1 } from '../../src/prompts/musician-role.js';
-
-describe('restoreOrchestra', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  const sessionsToKill: string[] = [];
-
-  beforeEach(() => { process.env.NFO_HOME = ''; });
-
-  afterEach(async () => {
-    for (const s of sessionsToKill) {
-      try { await killSession(s); } catch { /* ignore */ }
-    }
-    sessionsToKill.length = 0;
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  it('throws when orchestra is unknown', async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    await expect(restoreOrchestra('nope-doesnt-exist')).rejects.toThrow(/Unknown orchestra/);
-  });
-
-  it('creates a fresh tmux session for an orchestra whose state exists but session is gone', async () => {
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-
-    const orchestraId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchestraId);
-    await writeState(orchestraId, makeInitialState({
-      orchestraId,
-      projectPath: repo.path,
-      permissionLevel: 'supervised',
-    }));
-
-    sessionsToKill.push(sessionName(orchestraId));
-
-    const result = await restoreOrchestra(orchestraId, true);
-    expect(result.action).toBe('restored');
-    expect(result.orchestraId).toBe(orchestraId);
-    expect(await sessionExists(sessionName(orchestraId))).toBe(true);
-    const { execa } = await import('execa');
-    const { stdout: status } = await execa('tmux', [
-      'show-options', '-t', sessionName(orchestraId), 'status',
-    ]);
-    expect(status.trim()).toBe('status off');
-    const { stdout: paneCount } = await execa('tmux', [
-      'list-panes', '-t', `${sessionName(orchestraId)}:0`, '-F', '#{pane_index}',
-    ]);
-    expect(paneCount.trim().split('\n').length).toBe(1);
-    const { stdout: windows } = await execa('tmux', [
-      'list-windows', '-t', sessionName(orchestraId), '-F', '#{window_name}',
-    ]);
-    expect(windows).toContain('nfo-dashboard');
-  });
-
-  it('recreates windows for non-stopped musicians and updates their window id', async () => {
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-
-    const orchestraId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchestraId);
-    const initial = makeInitialState({
-      orchestraId, projectPath: repo.path, permissionLevel: 'supervised',
-    });
-    initial.musicians.push({
-      id: 'mus-001',
-      name: 'tester',
-      task_summary: 't',
-      status: 'working',
-      tmux_window_id: '@stale',
-      claude_session_id: null,
-      worktree_path: null,
-      branch: null,
-      spawned_at: '2026-05-29T10:00:00Z',
-      last_activity: '2026-05-29T10:00:00Z',
-      model: 'haiku',
-    });
-    await writeState(orchestraId, initial);
-
-    sessionsToKill.push(sessionName(orchestraId));
-
-    const result = await restoreOrchestra(orchestraId, true);
-    expect(result.action).toBe('restored');
-
-    const state = await readState(orchestraId);
-    expect(state!.musicians[0].tmux_window_id).not.toBe('@stale');
-    expect(state!.musicians[0].tmux_window_id).toMatch(/^@/);
-    expect(state!.musicians[0].model).toBe('haiku');
-
-    const musicianCfg = JSON.parse(readFileSync(musicianMcpConfigPath(orchestraId, 'mus-001'), 'utf8'));
-    expect(musicianCfg.mcpServers.nfo.args).toEqual([
-      'mcp-server',
-      '--orchestra-id',
-      orchestraId,
-      '--caller-musician-id',
-      'mus-001',
-    ]);
-
-    const musicianPrompt = readFileSync(
-      join(orchestraDir(orchestraId), 'musician-mus-001-prompt.md'),
-      'utf8',
-    );
-    expect(musicianPrompt).toBe(MUSICIAN_ROLE_PROMPT_V1);
-  });
-});

package/tests/helpers/tmp-config.ts

@@ -1,16 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-export interface TmpConfig {
-  path: string;
-  cleanup: () => Promise<void>;
-}
-
-export async function makeTmpConfig(): Promise<TmpConfig> {
-  const path = await mkdtemp(join(tmpdir(), 'nfo-test-config-'));
-  return {
-    path,
-    cleanup: () => rm(path, { recursive: true, force: true }),
-  };
-}

package/tests/helpers/tmp-repo.ts

@@ -1,29 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { execa } from 'execa';
-
-export interface TmpRepo {
-  path: string;
-  cleanup: () => Promise<void>;
-}
-
-export async function makeTmpRepo(): Promise<TmpRepo> {
-  const path = await mkdtemp(join(tmpdir(), 'nfo-test-repo-'));
-  await execa('git', ['init', '-q'], { cwd: path });
-  await execa('git', ['config', 'user.email', 'test@test.local'], { cwd: path });
-  await execa('git', ['config', 'user.name', 'Test'], { cwd: path });
-  await execa('git', ['commit', '--allow-empty', '-m', 'init'], { cwd: path });
-  return {
-    path,
-    cleanup: () => rm(path, { recursive: true, force: true }),
-  };
-}
-
-export async function makeTmpNonRepo(): Promise<TmpRepo> {
-  const path = await mkdtemp(join(tmpdir(), 'nfo-test-norepo-'));
-  return {
-    path,
-    cleanup: () => rm(path, { recursive: true, force: true }),
-  };
-}

package/tests/integration/orchestrator-spawn.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { spawn } from 'node:child_process';
-import { resolve } from 'node:path';
-import { existsSync } from 'node:fs';
-import { makeTmpRepo, type TmpRepo } from '../helpers/tmp-repo.js';
-import { makeTmpConfig } from '../helpers/tmp-config.js';
-import { ensureOrchestraDir, writeState, readState } from '../../src/state.js';
-import { makeInitialState } from '../../src/state.types.js';
-import { projectKeyFromPath } from '../../src/project-key.js';
-import { createDetachedSession, sessionName, killSession } from '../../src/tmux.js';
-
-const CLI = resolve(process.cwd(), 'dist/cli.js');
-
-describe('NFO MCP server (e2e)', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  const sessionsToKill: string[] = [];
-
-  beforeEach(async () => {
-    process.env.NFO_HOME = '';
-    if (!existsSync(CLI)) {
-      throw new Error(`dist/cli.js missing; run \`npm run build\` first`);
-    }
-  });
-
-  afterEach(async () => {
-    for (const s of sessionsToKill) {
-      try { await killSession(s); } catch { /* ignore */ }
-    }
-    sessionsToKill.length = 0;
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  it('lists 9 tools and dispatches spawn_musician via JSON-RPC', async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-    const orchId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchId);
-    await writeState(orchId, makeInitialState({
-      orchestraId: orchId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-    sessionsToKill.push(sessionName(orchId));
-    await createDetachedSession(sessionName(orchId), repo.path, 220, 50);
-
-    const proc = spawn(
-      process.execPath,
-      [CLI, 'mcp-server', '--orchestra-id', orchId],
-      { env: { ...process.env, NFO_HOME: cfg.path } },
-    );
-
-    const responses: Array<Record<string, unknown>> = [];
-    let stdoutBuf = '';
-    proc.stdout.on('data', (chunk: Buffer) => {
-      stdoutBuf += chunk.toString();
-      let idx: number;
-      while ((idx = stdoutBuf.indexOf('\n')) !== -1) {
-        const line = stdoutBuf.slice(0, idx).trim();
-        stdoutBuf = stdoutBuf.slice(idx + 1);
-        if (line.length > 0) responses.push(JSON.parse(line));
-      }
-    });
-
-    function send(msg: Record<string, unknown>) {
-      proc.stdin.write(JSON.stringify(msg) + '\n');
-    }
-
-    send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {
-      protocolVersion: '2024-11-05',
-      capabilities: {},
-      clientInfo: { name: 'test', version: '0' },
-    }});
-
-    await waitFor(() => responses.some(r => r.id === 1));
-
-    send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
-    await waitFor(() => responses.some(r => r.id === 2));
-    const listResp = responses.find(r => r.id === 2) as any;
-    expect(listResp.result.tools.length).toBe(9);
-
-    send({
-      jsonrpc: '2.0', id: 3, method: 'tools/call',
-      params: {
-        name: 'spawn_musician',
-        arguments: { name: 'tester', task: 'echo it', worktree: false, model: 'haiku' },
-      },
-    });
-    await waitFor(() => responses.some(r => r.id === 3));
-
-    proc.kill();
-
-    const state = await readState(orchId);
-    expect(state!.musicians).toHaveLength(1);
-    expect(state!.musicians[0].name).toBe('tester');
-    expect(state!.musicians[0].model).toBe('haiku');
-  }, 15000);
-});
-
-async function waitFor(predicate: () => boolean, timeoutMs = 5000): Promise<void> {
-  const start = Date.now();
-  while (!predicate()) {
-    if (Date.now() - start > timeoutMs) throw new Error('Timed out waiting');
-    await new Promise(r => setTimeout(r, 25));
-  }
-}

package/tests/mcp/handlers.test.ts

@@ -1,163 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { dispatch } from '../../src/mcp/handlers.js';
-import { makeTmpRepo, type TmpRepo } from '../helpers/tmp-repo.js';
-import { makeTmpConfig } from '../helpers/tmp-config.js';
-import { ensureOrchestraDir, writeState, readState } from '../../src/state.js';
-import { makeInitialState } from '../../src/state.types.js';
-import { projectKeyFromPath } from '../../src/project-key.js';
-import { createDetachedSession, sessionName, killSession } from '../../src/tmux.js';
-
-describe('MCP handlers dispatch', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  const sessionsToKill: string[] = [];
-
-  beforeEach(() => { process.env.NFO_HOME = ''; });
-
-  afterEach(async () => {
-    for (const s of sessionsToKill) {
-      try { await killSession(s); } catch { /* ignore */ }
-    }
-    sessionsToKill.length = 0;
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  async function setup(): Promise<{orchId: string; repoPath: string}> {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-    const orchId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchId);
-    await writeState(orchId, makeInitialState({
-      orchestraId: orchId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-    sessionsToKill.push(sessionName(orchId));
-    await createDetachedSession(sessionName(orchId), repo.path, 220, 50);
-    return { orchId, repoPath: repo.path };
-  }
-
-  it('spawn_musician returns a musician_id', async () => {
-    const { orchId } = await setup();
-    const result = await dispatch(orchId, 'spawn_musician', {
-      name: 'tester', task: 'do work', worktree: false, model: 'haiku',
-    }, { dryRun: true });
-    expect(result.musician_id).toMatch(/^mus-\d{3}$/);
-    const state = await readState(orchId);
-    expect(state!.musicians[0].model).toBe('haiku');
-  });
-
-  it('spawn_musician defaults to sonnet when model is omitted', async () => {
-    const { orchId } = await setup();
-    await dispatch(orchId, 'spawn_musician', {
-      name: 'tester', task: 'do work', worktree: false,
-    }, { dryRun: true });
-    const state = await readState(orchId);
-    expect(state!.musicians[0].model).toBe('sonnet');
-  });
-
-  it('list_musicians returns the live roster', async () => {
-    const { orchId } = await setup();
-    await dispatch(orchId, 'spawn_musician', { name: 'one', task: 't', worktree: false }, { dryRun: true });
-    await dispatch(orchId, 'spawn_musician', { name: 'two', task: 't', worktree: false }, { dryRun: true });
-    const result = await dispatch(orchId, 'list_musicians', {});
-    expect(result.musicians).toHaveLength(2);
-  });
-
-  it('note_write / note_read round-trip', async () => {
-    const { orchId } = await setup();
-    await dispatch(orchId, 'note_write', { filename: 'overview.md', content: '# hi' });
-    const result = await dispatch(orchId, 'note_read', { filename: 'overview.md' });
-    expect(result.content).toBe('# hi');
-  });
-
-  it('report_done sets status to idle and records summary', async () => {
-    const { orchId } = await setup();
-    const { musician_id } = await dispatch(orchId, 'spawn_musician', {
-      name: 'r', task: 't', worktree: false,
-    }, { dryRun: true });
-    const result = await dispatch(orchId, 'report_done', {
-      summary: 'all green', _from_musician_id: musician_id,
-    });
-    expect(result.notified_orchestrator).toBe(true);
-    const state = await readState(orchId);
-    expect(state!.musicians[0].status).toBe('idle');
-    expect(state!.musicians[0].latest_report).toMatchObject({
-      summary: 'all green',
-      next_steps: null,
-    });
-  });
-
-  it('report_done drains queued follow-up work onto the musician', async () => {
-    const { orchId, repoPath } = await setup();
-    const name = sessionName(orchId);
-    const { execa } = await import('execa');
-    const { stdout: winId } = await execa('tmux', [
-      'new-window', '-t', name, '-n', 'mus-001-r', '-c', repoPath, '-d',
-      '-P', '-F', '#{window_id}',
-    ]);
-
-    const { addMusician } = await import('../../src/state-updaters.js');
-    const { capturePane } = await import('../../src/tmux.js');
-    await addMusician(orchId, {
-      id: 'mus-001',
-      name: 'r',
-      task_summary: 't',
-      status: 'working',
-      tmux_window_id: winId.trim(),
-      claude_session_id: null,
-      worktree_path: null,
-      branch: null,
-      spawned_at: '2026-05-29T10:00:00Z',
-      last_activity: '2026-05-29T10:00:00Z',
-    });
-
-    const queued = await dispatch(orchId, 'message_musician', {
-      musician_id: 'mus-001',
-      message: 'echo queued-follow-up',
-    });
-    expect(queued.delivery).toBe('queued');
-
-    const result = await dispatch(orchId, 'report_done', {
-      summary: 'finished first task',
-      _from_musician_id: 'mus-001',
-    });
-    expect(result.delivered_messages).toBe(1);
-    expect(result.notified_orchestrator).toBe(false);
-
-    await new Promise(r => setTimeout(r, 250));
-    const out = await capturePane(`${name}:${winId.trim()}`, 20);
-    expect(out).toContain('queued-follow-up');
-
-    const state = await readState(orchId);
-    expect(state!.musicians[0].status).toBe('working');
-  });
-
-  it('report_done pushes the completion summary back to the orchestrator pane', async () => {
-    const { orchId } = await setup();
-    const { capturePane } = await import('../../src/tmux.js');
-    const { musician_id } = await dispatch(orchId, 'spawn_musician', {
-      name: 'reviewer', task: 't', worktree: false,
-    }, { dryRun: true });
-
-    await dispatch(orchId, 'report_done', {
-      summary: 'Implemented the requested change',
-      next_steps: 'If needed, ask me to tighten the tests.',
-      _from_musician_id: musician_id,
-    });
-
-    await new Promise(r => setTimeout(r, 250));
-    const out = await capturePane(`${sessionName(orchId)}:0`, 80);
-    expect(out).toContain(`Musician ${musician_id} (reviewer) reported done and is now idle.`);
-    expect(out).toContain('Implemented the requested change');
-    expect(out).toContain('dismiss_musician');
-    expect(out).toContain('message_musician');
-  });
-
-  it('throws on unknown tool', async () => {
-    const { orchId } = await setup();
-    await expect(dispatch(orchId, 'totally_made_up', {})).rejects.toThrow(/Unknown tool/);
-  });
-});

package/tests/mcp/tool-defs.test.ts

@@ -1,35 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { NFO_TOOLS } from '../../src/mcp/tool-defs.js';
-
-describe('NFO MCP tool definitions', () => {
-  it('exposes the expected tool names', () => {
-    const names = NFO_TOOLS.map(t => t.name).sort();
-    expect(names).toEqual([
-      'dismiss_musician',
-      'list_musicians',
-      'message_musician',
-      'note_list',
-      'note_read',
-      'note_write',
-      'query_musician',
-      'report_done',
-      'spawn_musician',
-    ]);
-  });
-
-  it('every tool has a non-empty description and inputSchema with type "object"', () => {
-    for (const tool of NFO_TOOLS) {
-      expect(tool.description.length).toBeGreaterThan(0);
-      expect(tool.inputSchema.type).toBe('object');
-    }
-  });
-
-  it('spawn_musician exposes the optional model choice', () => {
-    const spawnTool = NFO_TOOLS.find((tool) => tool.name === 'spawn_musician');
-    expect(spawnTool?.inputSchema.properties.model).toEqual({
-      type: 'string',
-      enum: ['sonnet', 'haiku'],
-      description: 'Optional subagent model (defaults to sonnet).',
-    });
-  });
-});

package/tests/musicians/dismiss.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { dismissMusician } from '../../src/musicians/dismiss.js';
-import { createMusician } from '../../src/musicians/spawn.js';
-import { makeTmpRepo, type TmpRepo } from '../helpers/tmp-repo.js';
-import { makeTmpConfig } from '../helpers/tmp-config.js';
-import { ensureOrchestraDir, writeState, readState } from '../../src/state.js';
-import { makeInitialState } from '../../src/state.types.js';
-import { projectKeyFromPath } from '../../src/project-key.js';
-import { createDetachedSession, sessionName, killSession } from '../../src/tmux.js';
-import { existsSync } from 'node:fs';
-
-describe('dismissMusician', () => {
-  const cleanups: Array<() => Promise<void>> = [];
-  const sessionsToKill: string[] = [];
-
-  beforeEach(() => { process.env.NFO_HOME = ''; });
-
-  afterEach(async () => {
-    for (const s of sessionsToKill) {
-      try { await killSession(s); } catch { /* ignore */ }
-    }
-    sessionsToKill.length = 0;
-    for (const c of cleanups) await c();
-    cleanups.length = 0;
-    delete process.env.NFO_HOME;
-  });
-
-  it('moves musician to archived_musicians and removes worktree (archive=false drops branch)', async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-
-    const orchId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchId);
-    await writeState(orchId, makeInitialState({
-      orchestraId: orchId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-    const sess = sessionName(orchId);
-    sessionsToKill.push(sess);
-    await createDetachedSession(sess, repo.path, 220, 50);
-
-    const spawn = await createMusician({
-      orchestraId: orchId, name: 'tester', task: 'do stuff', dryRun: true,
-    });
-    expect(spawn.worktree_path).not.toBeNull();
-    expect(existsSync(spawn.worktree_path!)).toBe(true);
-
-    await dismissMusician({
-      orchestraId: orchId,
-      musicianId: spawn.musician_id,
-      archiveWorktree: false,
-      summary: 'rejected',
-    });
-
-    const state = await readState(orchId);
-    expect(state!.musicians).toHaveLength(0);
-    expect(state!.archived_musicians).toHaveLength(1);
-    expect(state!.archived_musicians[0].summary).toBe('rejected');
-    expect(existsSync(spawn.worktree_path!)).toBe(false);
-  });
-
-  it('defaults the archived summary from the latest idle report', async () => {
-    const cfg = await makeTmpConfig();
-    cleanups.push(cfg.cleanup);
-    process.env.NFO_HOME = cfg.path;
-    const repo: TmpRepo = await makeTmpRepo();
-    cleanups.push(repo.cleanup);
-
-    const orchId = projectKeyFromPath(repo.path);
-    await ensureOrchestraDir(orchId);
-    await writeState(orchId, makeInitialState({
-      orchestraId: orchId, projectPath: repo.path, permissionLevel: 'supervised',
-    }));
-    const sess = sessionName(orchId);
-    sessionsToKill.push(sess);
-    await createDetachedSession(sess, repo.path, 220, 50);
-
-    const spawn = await createMusician({
-      orchestraId: orchId, name: 'tester', task: 'do stuff', dryRun: true,
-    });
-
-    const stateBefore = await readState(orchId);
-    stateBefore!.musicians[0].status = 'idle';
-    stateBefore!.musicians[0].latest_report = {
-      summary: 'ready to merge',
-      next_steps: null,
-      reported_at: '2026-05-29T11:00:00Z',
-    };
-    await writeState(orchId, stateBefore!);
-
-    await dismissMusician({
-      orchestraId: orchId,
-      musicianId: spawn.musician_id,
-      archiveWorktree: false,
-    });
-
-    const state = await readState(orchId);
-    expect(state!.archived_musicians[0].summary).toBe('ready to merge');
-  });
-});