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

package/src/commands/tui.tsx

@@ -1,22 +0,0 @@
-import { render } from "ink";
-import { App } from "../tui/components/App.js";
-import { readState } from "../state.js";
-
-export interface RunTuiOptions {
-  orchestraId: string;
-  version: string;
-}
-
-export async function runTui(opts: RunTuiOptions): Promise<void> {
-  const state = await readState(opts.orchestraId);
-  if (!state) {
-    throw new Error(`Unknown orchestra: ${opts.orchestraId}`);
-  }
-  const instance = render(
-    <App orchestraId={opts.orchestraId} version={opts.version} />,
-    {
-      exitOnCtrlC: false,
-    },
-  );
-  await instance.waitUntilExit();
-}

package/src/config.ts

@@ -1,44 +0,0 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-export const STATE_VERSION = 1;
-export const STATE_FILENAME = 'state.json';
-export const NOTES_DIRNAME = 'notes';
-export const LOGS_DIRNAME = 'logs';
-export const MESSAGE_LOGS_DIRNAME = 'messages';
-export const WORKTREES_DIRNAME = 'worktrees';
-export const ARCHIVE_DIRNAME = 'archive';
-
-export const getNFOHome = (): string =>
-  (process.env.NFO_HOME && process.env.NFO_HOME !== '')
-    ? process.env.NFO_HOME
-    : join(homedir(), '.config', 'nfo');
-
-export const getProjectsDir = (): string => join(getNFOHome(), 'projects');
-export const getGlobalConfigFile = (): string => join(getNFOHome(), 'config.json');
-
-// Keep backward-compatible aliases (resolved at call time)
-export const NFO_HOME = getNFOHome();
-export const PROJECTS_DIR = getProjectsDir();
-export const GLOBAL_CONFIG_FILE = getGlobalConfigFile();
-
-export const orchestraDir = (projectKey: string): string =>
-  join(getProjectsDir(), projectKey);
-
-export const stateFile = (projectKey: string): string =>
-  join(orchestraDir(projectKey), STATE_FILENAME);
-
-export const notesDir = (projectKey: string): string =>
-  join(orchestraDir(projectKey), NOTES_DIRNAME);
-
-export const logsDir = (projectKey: string): string =>
-  join(orchestraDir(projectKey), LOGS_DIRNAME);
-
-export const messageLogsDir = (projectKey: string): string =>
-  join(orchestraDir(projectKey), MESSAGE_LOGS_DIRNAME);
-
-export const worktreesDir = (projectKey: string): string =>
-  join(orchestraDir(projectKey), WORKTREES_DIRNAME);
-
-export const archiveDir = (projectKey: string): string =>
-  join(orchestraDir(projectKey), ARCHIVE_DIRNAME);

package/src/dashboard.ts

@@ -1 +0,0 @@
-export const DASHBOARD_WINDOW_NAME = 'nfo-dashboard';

package/src/mcp/config.ts

@@ -1,39 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { orchestraDir } from '../config.js';
-
-export function orchestratorMcpConfigPath(orchestraId: string): string {
-  return join(orchestraDir(orchestraId), 'mcp-config.json');
-}
-
-export function musicianMcpConfigPath(orchestraId: string, musicianId: string): string {
-  return join(orchestraDir(orchestraId), `mcp-${musicianId}.json`);
-}
-
-export async function writeOrchestratorMcpConfig(orchestraId: string): Promise<string> {
-  const path = orchestratorMcpConfigPath(orchestraId);
-  await writeMcpConfig(path, orchestraId);
-  return path;
-}
-
-export async function writeMusicianMcpConfig(orchestraId: string, musicianId: string): Promise<string> {
-  const path = musicianMcpConfigPath(orchestraId, musicianId);
-  await writeMcpConfig(path, orchestraId, musicianId);
-  return path;
-}
-
-async function writeMcpConfig(path: string, orchestraId: string, callerMusicianId?: string): Promise<void> {
-  const args = ['mcp-server', '--orchestra-id', orchestraId];
-  if (callerMusicianId) {
-    args.push('--caller-musician-id', callerMusicianId);
-  }
-
-  await writeFile(path, JSON.stringify({
-    mcpServers: {
-      nfo: {
-        command: 'nfo',
-        args,
-      },
-    },
-  }, null, 2), 'utf8');
-}

package/src/mcp/handlers.ts

@@ -1,141 +0,0 @@
-import { createMusician } from "../musicians/spawn.js";
-import {
-  drainQueuedMusicianMessages,
-  messageMusician,
-} from "../musicians/message.js";
-import { queryMusician } from "../musicians/query.js";
-import { dismissMusician } from "../musicians/dismiss.js";
-import { noteRead, noteWrite, noteList } from "../notes.js";
-import { readState } from "../state.js";
-import {
-  setMusicianLatestReport,
-  setMusicianStatus,
-} from "../state-updaters.js";
-import { findMusicianStrict } from "../musicians/lookup.js";
-import { notifyOrchestratorOfDoneReport } from "../orchestrator/report-back.js";
-
-export interface DispatchOptions {
-  dryRun?: boolean;
-  callerMusicianId?: string;
-}
-
-export async function dispatch(
-  orchestraId: string,
-  toolName: string,
-  args: Record<string, unknown>,
-  opts: DispatchOptions = {},
-): Promise<Record<string, unknown>> {
-  switch (toolName) {
-    case "spawn_musician": {
-      const r = await createMusician({
-        orchestraId,
-        name: String(args.name),
-        task: String(args.task),
-        worktree:
-          typeof args.worktree === "boolean" ? args.worktree : undefined,
-        branchFrom:
-          typeof args.branch_from === "string" ? args.branch_from : undefined,
-        model:
-          typeof args.model === "string"
-            ? (args.model as "sonnet" | "haiku")
-            : "sonnet",
-        dryRun: opts.dryRun,
-      });
-      return r;
-    }
-    case "message_musician": {
-      const result = await messageMusician({
-        orchestraId,
-        musicianId: String(args.musician_id),
-        message: String(args.message),
-      });
-      return { ...result };
-    }
-    case "query_musician": {
-      const text = await queryMusician({
-        orchestraId,
-        musicianId: String(args.musician_id),
-        lines: typeof args.lines === "number" ? args.lines : undefined,
-      });
-      return { content: text };
-    }
-    case "list_musicians": {
-      const state = await readState(orchestraId);
-      if (!state) {
-        throw new Error(`Unknown orchestra: ${orchestraId}`);
-      }
-      return { musicians: state.musicians };
-    }
-    case "dismiss_musician": {
-      await dismissMusician({
-        orchestraId,
-        musicianId: String(args.musician_id),
-        archiveWorktree:
-          typeof args.archive_worktree === "boolean"
-            ? args.archive_worktree
-            : undefined,
-        summary: typeof args.summary === "string" ? args.summary : null,
-      });
-      return { ok: true };
-    }
-    case "report_done": {
-      const state = await readState(orchestraId);
-      if (!state) {
-        throw new Error(`Unknown orchestra: ${orchestraId}`);
-      }
-      const summary = typeof args.summary === "string" ? args.summary : "";
-      const nextSteps =
-        typeof args.next_steps === "string" ? args.next_steps : null;
-      const callerId =
-        typeof args._from_musician_id === "string"
-          ? args._from_musician_id
-          : opts.callerMusicianId;
-      if (!callerId) {
-        throw new Error("report_done: no caller musician id");
-      }
-      const musician = findMusicianStrict(state, callerId);
-      const reportedAt = new Date().toISOString();
-      await setMusicianLatestReport(orchestraId, callerId, {
-        summary,
-        next_steps: nextSteps,
-        reported_at: reportedAt,
-      });
-      await setMusicianStatus(orchestraId, callerId, "idle");
-      const deliveredMessages = await drainQueuedMusicianMessages(
-        orchestraId,
-        callerId,
-      );
-      if (deliveredMessages > 0) {
-        await setMusicianStatus(orchestraId, callerId, "working");
-      } else {
-        await notifyOrchestratorOfDoneReport(orchestraId, {
-          musicianId: callerId,
-          musicianName: musician.name,
-          summary,
-          nextSteps,
-        });
-      }
-      return {
-        ok: true,
-        recorded: summary,
-        delivered_messages: deliveredMessages,
-        notified_orchestrator: deliveredMessages === 0,
-      };
-    }
-    case "note_write": {
-      await noteWrite(orchestraId, String(args.filename), String(args.content));
-      return { ok: true };
-    }
-    case "note_read": {
-      const content = await noteRead(orchestraId, String(args.filename));
-      return { content };
-    }
-    case "note_list": {
-      const files = await noteList(orchestraId);
-      return { files };
-    }
-    default: {
-      throw new Error(`Unknown tool: ${toolName}`);
-    }
-  }
-}

package/src/mcp/server.ts

@@ -1,50 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { NFO_TOOLS } from "./tool-defs.js";
-import { dispatch } from "./handlers.js";
-
-export interface RunServerOptions {
-  orchestraId: string;
-  callerMusicianId?: string;
-}
-
-export async function runServer(opts: RunServerOptions): Promise<void> {
-  const server = new Server(
-    { name: "nfo-mcp", version: "0.0.0" },
-    { capabilities: { tools: {} } },
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return { tools: NFO_TOOLS };
-  });
-
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-      const result = await dispatch(
-        opts.orchestraId,
-        name,
-        (args ?? {}) as Record<string, unknown>,
-        {
-          callerMusicianId: opts.callerMusicianId,
-        },
-      );
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return {
-        content: [{ type: "text", text: `Error: ${msg}` }],
-        isError: true,
-      };
-    }
-  });
-
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}

package/src/mcp/tool-defs.ts

@@ -1,151 +0,0 @@
-export interface NfoToolDef {
-  name: string;
-  description: string;
-  inputSchema: {
-    type: "object";
-    properties: Record<string, unknown>;
-    required?: string[];
-    additionalProperties?: boolean;
-  };
-}
-
-export const NFO_TOOLS: NfoToolDef[] = [
-  {
-    name: "spawn_musician",
-    description:
-      "Spawn a new Musician (a Claude Code subagent) to work on a task in an isolated git worktree. Use this for delegation instead of describing work in chat. Returns the musician_id. Haiku is perfect for trivial tasks while Sonnett is better for complex ones; both are strong at code. If you don't know which to choose, sonnet is a good default.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: {
-          type: "string",
-          description: 'Human-friendly identifier (e.g. "test-writer")',
-        },
-        task: {
-          type: "string",
-          description: "Initial task prompt sent as the first message",
-        },
-        worktree: {
-          type: "boolean",
-          description:
-            "Default true. Pass false for trivially-isolated work that does not need a worktree.",
-        },
-        branch_from: {
-          type: "string",
-          description: "Optional base ref (defaults to HEAD).",
-        },
-        model: {
-          type: "string",
-          enum: ["sonnet", "haiku"],
-          description: "Optional subagent model (defaults to sonnet).",
-        },
-      },
-      required: ["name", "task"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "message_musician",
-    description:
-      "Send a message to a Musician. Use this for iteration/follow-up instead of plain chat. If they are idle it is delivered now; otherwise it is queued and auto-delivered on the next idle boundary.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        musician_id: { type: "string" },
-        message: { type: "string" },
-      },
-      required: ["musician_id", "message"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "query_musician",
-    description:
-      "Read the most recent visible output from a Musician's tmux pane. Returns the captured text.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        musician_id: { type: "string" },
-        lines: { type: "integer", description: "Default 80." },
-      },
-      required: ["musician_id"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "list_musicians",
-    description:
-      "List all currently-active Musicians with their status and metadata.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "dismiss_musician",
-    description:
-      "Tear down a Musician. Use this to accept and close out work rather than saying the Musician is done in prose. Archives the worktree by default (branch preserved); pass archive_worktree=false to drop everything.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        musician_id: { type: "string" },
-        archive_worktree: { type: "boolean" },
-        summary: { type: "string" },
-      },
-      required: ["musician_id"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "report_done",
-    description:
-      "Called by a Musician to hand work back to the Orchestrator and mark itself as idle/done. Musicians must use this instead of plain-text completion messages. Queued follow-up messages are delivered automatically; otherwise the completion report is pushed back to the Orchestrator for dismiss-vs-iterate triage.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        summary: { type: "string" },
-        next_steps: { type: "string" },
-      },
-      required: ["summary"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "note_write",
-    description:
-      "Write (or replace) a note file under the orchestra's notes/ directory.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filename: {
-          type: "string",
-          description: 'Filename with no path separators, e.g. "overview.md".',
-        },
-        content: { type: "string" },
-      },
-      required: ["filename", "content"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "note_read",
-    description:
-      "Read a note file from the orchestra's notes/ directory. Returns the contents, or empty string if missing.",
-    inputSchema: {
-      type: "object",
-      properties: { filename: { type: "string" } },
-      required: ["filename"],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "note_list",
-    description: "List all files in the orchestra's notes/ directory.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-      additionalProperties: false,
-    },
-  },
-];

package/src/musicians/dismiss.ts

@@ -1,60 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { execa } from 'execa';
-import { archiveMusician } from '../state-updaters.js';
-import { readState } from '../state.js';
-import { findMusicianStrict } from './lookup.js';
-import { archiveDir } from '../config.js';
-import { sessionName } from '../tmux.js';
-import { removeWorktree, deleteBranch } from '../worktree.js';
-
-export interface DismissMusicianOptions {
-  orchestraId: string;
-  musicianId: string;
-  archiveWorktree?: boolean;     // default true
-  summary?: string | null;
-}
-
-export async function dismissMusician(opts: DismissMusicianOptions): Promise<void> {
-  const state = await readState(opts.orchestraId);
-  if (!state) {
-    throw new Error(`Unknown orchestra: ${opts.orchestraId}`);
-  }
-  const musician = findMusicianStrict(state, opts.musicianId);
-  const archivedSummary = opts.summary !== undefined
-    ? opts.summary
-    : (musician.status === 'idle' ? musician.latest_report?.summary ?? null : null);
-
-  const archive = opts.archiveWorktree !== false;
-
-  // 1. Best-effort graceful shutdown of claude, then kill the window.
-  const target = `${sessionName(opts.orchestraId)}:${musician.tmux_window_id}`;
-  await execa('tmux', ['send-keys', '-l', '-t', target, '--', '/quit'], { reject: false });
-  await execa('tmux', ['send-keys', '-t', target, 'Enter'], { reject: false });
-  await new Promise((r) => { setTimeout(r, 200); });
-  await execa('tmux', ['kill-window', '-t', target], { reject: false });
-
-  // 2. Worktree handling.
-  if (musician.worktree_path) {
-    if (archive) {
-      const dest = join(archiveDir(opts.orchestraId), opts.musicianId, 'worktree');
-      await mkdir(dirname(dest), { recursive: true });
-      const moved = await execa('git', ['worktree', 'move', musician.worktree_path, dest], {
-        cwd: state.project_path, reject: false,
-      });
-      if (moved.exitCode !== 0) {
-        await removeWorktree({ repoRoot: state.project_path, path: musician.worktree_path, force: true });
-      }
-    } else {
-      await removeWorktree({ repoRoot: state.project_path, path: musician.worktree_path, force: true });
-      if (musician.branch) {
-        await deleteBranch(state.project_path, musician.branch);
-      }
-    }
-  }
-
-  // 3. Move state row.
-  await archiveMusician(opts.orchestraId, opts.musicianId, {
-    summary: archivedSummary,
-  });
-}

package/src/musicians/ids.ts

@@ -1,21 +0,0 @@
-import type { OrchestraState } from '../state.types.js';
-
-/**
- * Generate the next musician id. Format: `mus-NNN` where NNN is zero-padded
- * to 3 digits and counts active + archived musicians. Never reuses an id even
- * after a musician is archived (avoids confusion in logs).
- */
-export function nextMusicianId(state: OrchestraState): string {
-  const used = new Set<string>();
-  for (const m of state.musicians) {
-    used.add(m.id);
-  }
-  for (const m of state.archived_musicians) {
-    used.add(m.id);
-  }
-  let n = used.size + 1;
-  while (used.has(`mus-${String(n).padStart(3, '0')}`)) {
-    n++;
-  }
-  return `mus-${String(n).padStart(3, '0')}`;
-}

package/src/musicians/lookup.ts

@@ -1,13 +0,0 @@
-import type { Musician, OrchestraState } from '../state.types.js';
-
-export function findMusician(state: OrchestraState, id: string): Musician | undefined {
-  return state.musicians.find((m) => { return m.id === id; });
-}
-
-export function findMusicianStrict(state: OrchestraState, id: string): Musician {
-  const m = findMusician(state, id);
-  if (!m) {
-    throw new Error(`Unknown musician: ${id}`);
-  }
-  return m;
-}