tmux-ide 1.3.1 → 2.0.0

package/src/ls.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cli = join(__dirname, "..", "bin", "cli.js");
+
+// ls.js uses execSync directly (not our tmux.js layer), so we test via CLI
+// to avoid needing to mock execSync at the module level.
+
+let origLog;
+let logged;
+
+beforeEach(() => {
+  logged = [];
+  origLog = console.log;
+  console.log = (...a) => logged.push(a.join(" "));
+});
+
+afterEach(() => {
+  console.log = origLog;
+});
+
+describe("ls", () => {
+  it("returns sessions array via CLI --json", () => {
+    const result = spawnSync("node", [cli, "ls", "--json"], {
+      encoding: "utf-8",
+      timeout: 10000,
+    });
+    expect(result.status).toBe(0);
+    const output = JSON.parse(result.stdout);
+    expect(Array.isArray(output.sessions)).toBeTruthy();
+  });
+
+  it("parses session list with expected fields", () => {
+    const result = spawnSync("node", [cli, "ls", "--json"], {
+      encoding: "utf-8",
+      timeout: 10000,
+    });
+    const output = JSON.parse(result.stdout);
+    // If there are sessions, each should have name, created, attached fields
+    for (const session of output.sessions) {
+      expect(typeof session.name === "string").toBeTruthy();
+      expect(typeof session.created === "string").toBeTruthy();
+      expect(typeof session.attached === "boolean").toBeTruthy();
+    }
+  });
+
+  it("returns valid JSON structure even if sessions exist", () => {
+    const result = spawnSync("node", [cli, "ls", "--json"], {
+      encoding: "utf-8",
+      timeout: 10000,
+    });
+    expect(result.status).toBe(0);
+    const output = JSON.parse(result.stdout);
+    expect(Object.hasOwn(output, "sessions")).toBeTruthy();
+    expect(Array.isArray(output.sessions)).toBeTruthy();
+    // Each session must have the expected shape
+    for (const s of output.sessions) {
+      expect(typeof s.name === "string" && s.name.length > 0).toBeTruthy();
+      expect(typeof s.created === "string").toBeTruthy();
+      expect(typeof s.attached === "boolean").toBeTruthy();
+    }
+  });
+
+  it("prints human-readable output without --json", () => {
+    // Just verify it doesn't crash and produces output
+    const result = spawnSync("node", [cli, "ls"], {
+      encoding: "utf-8",
+      timeout: 10000,
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.length > 0).toBeTruthy();
+  });
+});

package/src/ls.ts

@@ -0,0 +1,40 @@
+import { execSync } from "node:child_process";
+
+export async function ls({ json }: { json?: boolean } = {}): Promise<void> {
+  let raw: string;
+  try {
+    raw = execSync(
+      'tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}"',
+      { encoding: "utf-8" },
+    ).trim();
+  } catch {
+    if (json) {
+      console.log(JSON.stringify({ sessions: [] }));
+    } else {
+      console.log("No tmux sessions running.");
+    }
+    return;
+  }
+
+  const sessions = raw.split("\n").map((line) => {
+    const [name, created, attached] = line.split("|");
+    return {
+      name,
+      created: new Date(parseInt(created!) * 1000).toISOString(),
+      attached: attached !== "0",
+    };
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ sessions }, null, 2));
+    return;
+  }
+
+  // Table output
+  console.log("SESSION".padEnd(24) + "CREATED".padEnd(22) + "ATTACHED");
+  console.log("─".repeat(54));
+  for (const s of sessions) {
+    const date = new Date(s.created).toLocaleString();
+    console.log(s.name!.padEnd(24) + date.padEnd(22) + (s.attached ? "yes" : "no"));
+  }
+}

package/src/metrics-cli.ts

@@ -0,0 +1,177 @@
+import { resolve } from "node:path";
+import { computeMetrics, loadMissionHistory } from "./lib/metrics.ts";
+
+function fmtDuration(ms: number): string {
+  if (ms < 60000) return `${Math.round(ms / 1000)}s`;
+  if (ms < 3600000) return `${Math.round(ms / 60000)}m`;
+  const h = Math.floor(ms / 3600000);
+  const m = Math.round((ms % 3600000) / 60000);
+  return `${h}h ${m}m`;
+}
+
+function fmtPct(n: number): string {
+  return `${Math.round(n * 100)}%`;
+}
+
+export async function metricsCommand(
+  targetDir: string | undefined,
+  {
+    json = false,
+    sub,
+  }: {
+    json?: boolean;
+    sub?: string;
+  },
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+
+  switch (sub) {
+    case "agents": {
+      const metrics = computeMetrics(dir);
+      if (json) {
+        console.log(JSON.stringify(metrics.agents, null, 2));
+        return;
+      }
+      if (metrics.agents.length === 0) {
+        console.log("No agent data yet.");
+        return;
+      }
+      console.log("Agent Performance:");
+      for (const a of metrics.agents) {
+        const specs = a.specialties.length > 0 ? ` [${a.specialties.join(", ")}]` : "";
+        console.log(`  ${a.name}${specs}`);
+        console.log(
+          `    Tasks: ${a.taskCount}  Retries: ${a.retryCount}  Utilization: ${fmtPct(a.utilization)}`,
+        );
+        console.log(
+          `    Active: ${fmtDuration(a.activeTimeMs)}  Idle: ${fmtDuration(a.idleTimeMs)}`,
+        );
+      }
+      break;
+    }
+    case "timeline": {
+      const metrics = computeMetrics(dir);
+      if (json) {
+        console.log(JSON.stringify(metrics.timeline, null, 2));
+        return;
+      }
+      if (metrics.timeline.length === 0) {
+        console.log("No timeline data yet.");
+        return;
+      }
+      console.log("Activity Timeline:");
+      for (const t of metrics.timeline.slice(-20)) {
+        const ts = new Date(t.timestamp).toLocaleTimeString();
+        console.log(
+          `  ${ts}  done:${t.completedTasks} active:${t.activeTasks} busy:${t.busyAgents} idle:${t.idleAgents}`,
+        );
+      }
+      break;
+    }
+    case "eval": {
+      const metrics = computeMetrics(dir);
+      if (json) {
+        const bottlenecks = [...metrics.tasks.byMilestone]
+          .sort((a, b) => b.durationMs - a.durationMs)
+          .slice(0, 3);
+        const highRetryAgents = [...metrics.agents]
+          .filter((a) => a.retryCount > 0)
+          .sort((a, b) => b.retryCount - a.retryCount);
+        const ranking = [...metrics.agents].sort((a, b) => b.utilization - a.utilization);
+        console.log(JSON.stringify({ bottlenecks, highRetryAgents, ranking }, null, 2));
+        return;
+      }
+      console.log("Evaluation:");
+      // Bottleneck milestones
+      const slowest = [...metrics.tasks.byMilestone]
+        .filter((m) => m.durationMs > 0)
+        .sort((a, b) => b.durationMs - a.durationMs);
+      if (slowest.length > 0) {
+        console.log("  Slowest milestones:");
+        for (const m of slowest.slice(0, 3)) {
+          console.log(
+            `    ${m.id} ${m.title}: ${fmtDuration(m.durationMs)} (${m.completedCount}/${m.taskCount} tasks)`,
+          );
+        }
+      }
+      // High-retry agents
+      const retryAgents = metrics.agents.filter((a) => a.retryCount > 0);
+      if (retryAgents.length > 0) {
+        console.log("  High-retry agents:");
+        for (const a of retryAgents.sort((x, y) => y.retryCount - x.retryCount)) {
+          console.log(`    ${a.name}: ${a.retryCount} retries across ${a.taskCount} tasks`);
+        }
+      }
+      // Agent ranking by utilization
+      if (metrics.agents.length > 0) {
+        console.log("  Agent ranking (by utilization):");
+        for (const a of [...metrics.agents].sort((x, y) => y.utilization - x.utilization)) {
+          console.log(`    ${a.name}: ${fmtPct(a.utilization)} util, ${a.taskCount} tasks`);
+        }
+      }
+      break;
+    }
+    case "history": {
+      const history = loadMissionHistory(dir);
+      if (json) {
+        console.log(JSON.stringify(history, null, 2));
+        return;
+      }
+      if (history.length === 0) {
+        console.log("No mission history yet.");
+        return;
+      }
+      console.log("Mission History:");
+      for (const m of history) {
+        console.log(`  ${m.title} [${m.status}]`);
+        console.log(`    Completed: ${m.completedAt}  Duration: ${fmtDuration(m.wallClockMs)}`);
+        console.log(
+          `    Tasks: ${m.taskCount} (${fmtPct(m.completionRate)} done)  Agents: ${m.agentCount}  Milestones: ${m.milestonesCompleted}`,
+        );
+      }
+      break;
+    }
+    case "help":
+      console.log(`Usage: tmux-ide metrics [subcommand] [--json]
+
+  (default)   Session summary — duration, task rates, agent utilization
+  agents      Per-agent table — tasks, time, utilization, specialties
+  timeline    Activity timeline — sampled every 5 minutes
+  eval        Evaluation — bottleneck milestones, high-retry tasks, agent ranking
+  history     Cross-mission comparison from history`);
+      break;
+    default: {
+      // Default: session summary
+      const metrics = computeMetrics(dir);
+      if (json) {
+        console.log(JSON.stringify(metrics, null, 2));
+        return;
+      }
+      console.log("Session Metrics:");
+      console.log(`  Status: ${metrics.session.status}`);
+      console.log(`  Duration: ${fmtDuration(metrics.session.durationMs)}`);
+      console.log(`  Agents: ${metrics.session.agentCount}`);
+      console.log();
+      console.log("Tasks:");
+      console.log(
+        `  Total: ${metrics.tasks.total}  Done: ${metrics.tasks.completed}  Failed: ${metrics.tasks.failed}`,
+      );
+      console.log(
+        `  Completion rate: ${fmtPct(metrics.tasks.completionRate)}  Retry rate: ${fmtPct(metrics.tasks.retryRate)}`,
+      );
+      if (metrics.tasks.avgDurationMs > 0) {
+        console.log(
+          `  Avg duration: ${fmtDuration(metrics.tasks.avgDurationMs)}  Median: ${fmtDuration(metrics.tasks.medianDurationMs)}  P90: ${fmtDuration(metrics.tasks.p90DurationMs)}`,
+        );
+      }
+      if (metrics.mission.title) {
+        console.log();
+        console.log(`Mission: ${metrics.mission.title} [${metrics.mission.status}]`);
+        console.log(`  Milestones: ${metrics.mission.milestonesCompleted} completed`);
+        console.log(`  Validation: ${fmtPct(metrics.mission.validationPassRate)} pass rate`);
+        console.log(`  Wall clock: ${fmtDuration(metrics.mission.wallClockMs)}`);
+      }
+      break;
+    }
+  }
+}

package/src/notify.ts

@@ -0,0 +1,85 @@
+import { resolve } from "node:path";
+import { getSessionName } from "./lib/yaml-io.ts";
+import { getSessionState } from "./lib/tmux.ts";
+import { listSessionPanes, sendCommand } from "./widgets/lib/pane-comms.ts";
+import { appendEvent } from "./lib/event-log.ts";
+import { IdeError } from "./lib/errors.ts";
+
+interface NotifyOptions {
+  message?: string;
+  json?: boolean;
+}
+
+/**
+ * Send a short notification message to the lead/master pane.
+ *
+ * This is the counterpart to `tmux-ide dispatch` — dispatch sends tasks
+ * TO agents, notify sends completion messages BACK to the master.
+ *
+ * The message is always kept under 200 chars to avoid triggering the
+ * paste preview in Claude Code's TUI.
+ */
+export async function notify(
+  targetDir: string | null | undefined,
+  opts: NotifyOptions,
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { message, json } = opts;
+  const { name: session } = getSessionName(dir);
+
+  if (!message) {
+    throw new IdeError("Missing message. Usage: tmux-ide notify <message>", {
+      code: "USAGE",
+    });
+  }
+
+  const state = getSessionState(session);
+  if (!state.running) {
+    throw new IdeError(`Session "${session}" is not running`, {
+      code: "SESSION_NOT_FOUND",
+    });
+  }
+
+  const panes = listSessionPanes(session);
+  const leadPane = panes.find((p) => p.role === "lead") ?? panes[0];
+
+  if (!leadPane) {
+    throw new IdeError("No panes found in session", {
+      code: "PANE_NOT_FOUND",
+    });
+  }
+
+  // Keep message under 200 chars to avoid paste preview
+  const short = message.length > 180 ? message.slice(0, 177) + "..." : message;
+
+  sendCommand(session, leadPane.id, short);
+
+  // Log notify event
+  appendEvent(dir, {
+    timestamp: new Date().toISOString(),
+    type: "notify",
+    target: leadPane.name ?? leadPane.title,
+    paneId: leadPane.id,
+    message: short,
+  });
+
+  if (json) {
+    console.log(
+      JSON.stringify({
+        ok: true,
+        session,
+        target: {
+          paneId: leadPane.id,
+          name: leadPane.name,
+          title: leadPane.title,
+          role: leadPane.role,
+        },
+        message: short,
+      }),
+    );
+    return;
+  }
+
+  const label = leadPane.name ?? leadPane.title;
+  console.log(`Notified "${label}" (${leadPane.id}): ${short}`);
+}

package/src/orchestrator-status.ts

@@ -0,0 +1,228 @@
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getSessionName, readConfig } from "./lib/yaml-io.ts";
+import { getSessionState } from "./lib/tmux.ts";
+import { loadTasks, loadMission } from "./lib/task-store.ts";
+import { readEvents } from "./lib/event-log.ts";
+import { listSessionPanes } from "./widgets/lib/pane-comms.ts";
+import { isAgentPane, isAgentBusy, agentIdentifier } from "./lib/orchestrator.ts";
+
+function formatElapsed(ms: number): string {
+  if (ms < 60000) return `${Math.round(ms / 1000)}s`;
+  if (ms < 3600000) return `${Math.round(ms / 60000)}m`;
+  return `${(ms / 3600000).toFixed(1)}h`;
+}
+
+function formatRelative(iso: string): string {
+  const ms = Date.now() - new Date(iso).getTime();
+  if (ms < 60000) return `${Math.round(ms / 1000)}s ago`;
+  if (ms < 3600000) return `${Math.round(ms / 60000)}m ago`;
+  return `${(ms / 3600000).toFixed(1)}h ago`;
+}
+
+export async function orchestratorStatus(
+  targetDir: string | undefined,
+  { json }: { json?: boolean } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { name: session } = getSessionName(dir);
+
+  // Read config
+  let orchConfig: {
+    autoDispatch: boolean;
+    dispatchMode: string;
+    pollInterval: number;
+    stallTimeout: number;
+    maxConcurrentAgents: number;
+    masterPane: string | null;
+  } | null = null;
+
+  try {
+    const { config } = readConfig(dir);
+    const orch = config.orchestrator;
+    if (orch) {
+      orchConfig = {
+        autoDispatch: orch.auto_dispatch ?? true,
+        dispatchMode: orch.dispatch_mode ?? "tasks",
+        pollInterval: orch.poll_interval ?? 5000,
+        stallTimeout: orch.stall_timeout ?? 300000,
+        maxConcurrentAgents: orch.max_concurrent_agents ?? 10,
+        masterPane: orch.master_pane ?? null,
+      };
+    }
+  } catch {
+    // No config or unreadable
+  }
+
+  // Check if session is running
+  const state = getSessionState(session);
+  const running = state.running && orchConfig?.autoDispatch !== undefined;
+
+  // Read persisted orchestrator state
+  const statePath = join(dir, ".tasks", "orchestrator-state.json");
+  let claimedTasks: string[] = [];
+  let taskClaimTimes: Record<string, number> = {};
+
+  if (existsSync(statePath)) {
+    try {
+      const data = JSON.parse(readFileSync(statePath, "utf-8"));
+      claimedTasks = data.claimedTasks ?? [];
+      taskClaimTimes = data.taskClaimTimes ?? {};
+    } catch {
+      // Corrupted state
+    }
+  }
+
+  // Load tasks, panes
+  const tasks = loadTasks(dir);
+  const mission = loadMission(dir);
+
+  // Agent info from tmux panes
+  const agents: Array<{
+    name: string;
+    paneId: string;
+    state: "busy" | "idle";
+    currentTask: { id: string; title: string; elapsed: string } | null;
+  }> = [];
+
+  if (state.running) {
+    const panes = listSessionPanes(session);
+    const agentPanes = panes.filter((p) => isAgentPane(p));
+
+    for (const pane of agentPanes) {
+      const name = agentIdentifier(pane);
+      const busy = isAgentBusy(pane);
+      const assignedTask = tasks.find((t) => t.status === "in-progress" && t.assignee === name);
+
+      let currentTask: { id: string; title: string; elapsed: string } | null = null;
+      if (assignedTask) {
+        const claimTime = taskClaimTimes[assignedTask.id];
+        const elapsed = claimTime
+          ? formatElapsed(Date.now() - claimTime)
+          : formatElapsed(Date.now() - new Date(assignedTask.updated).getTime());
+        currentTask = { id: assignedTask.id, title: assignedTask.title, elapsed };
+      }
+
+      agents.push({
+        name,
+        paneId: pane.id,
+        state: busy ? "busy" : "idle",
+        currentTask,
+      });
+    }
+  }
+
+  // Categorize tasks
+  const inProgressTasks = tasks
+    .filter((t) => t.status === "in-progress")
+    .map((t) => {
+      const claimTime = taskClaimTimes[t.id];
+      const elapsed = claimTime
+        ? formatElapsed(Date.now() - claimTime)
+        : formatElapsed(Date.now() - new Date(t.updated).getTime());
+      return { id: t.id, title: t.title, assignee: t.assignee ?? "unassigned", elapsed };
+    });
+
+  const doneTaskIds = new Set(tasks.filter((t) => t.status === "done").map((t) => t.id));
+  const pendingTasks = tasks
+    .filter((t) => t.status === "todo")
+    .sort((a, b) => a.priority - b.priority)
+    .map((t) => {
+      const blockedBy = t.depends_on.filter((dep) => !doneTaskIds.has(dep));
+      return {
+        id: t.id,
+        title: t.title,
+        priority: t.priority,
+        blocked: blockedBy.length > 0,
+        blockedBy: blockedBy.length > 0 ? blockedBy : undefined,
+      };
+    });
+
+  const recentlyDone = tasks
+    .filter((t) => t.status === "done")
+    .sort((a, b) => new Date(b.updated).getTime() - new Date(a.updated).getTime())
+    .slice(0, 5)
+    .map((t) => ({ id: t.id, title: t.title, completedAt: t.updated }));
+
+  // Recent events
+  const allEvents = readEvents(dir);
+  const recentEvents = allEvents.slice(-10).reverse();
+
+  const data = {
+    running,
+    config: orchConfig,
+    agents,
+    tasks: { inProgress: inProgressTasks, pending: pendingTasks, recentlyDone },
+    claims: { count: claimedTasks.length, taskIds: claimedTasks },
+    recentEvents,
+  };
+
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  // Human-readable output
+  const noColor = "NO_COLOR" in process.env;
+  const bold = (s: string) => (noColor ? s : `\x1b[1m${s}\x1b[22m`);
+  const dim = (s: string) => (noColor ? s : `\x1b[2m${s}\x1b[22m`);
+  const green = (s: string) => (noColor ? s : `\x1b[32m${s}\x1b[39m`);
+  const yellow = (s: string) => (noColor ? s : `\x1b[33m${s}\x1b[39m`);
+
+  console.log(`${bold("Orchestrator:")} ${running ? green("running") : dim("stopped")}`);
+
+  if (orchConfig) {
+    const stallMin = Math.round(orchConfig.stallTimeout / 60000);
+    console.log(
+      `  Poll: ${orchConfig.pollInterval}ms | Stall: ${stallMin}m | Mode: ${orchConfig.dispatchMode} | Auto-dispatch: ${orchConfig.autoDispatch ? "on" : "off"}`,
+    );
+    console.log(`  Max concurrent: ${orchConfig.maxConcurrentAgents}`);
+  }
+
+  if (mission) {
+    console.log(`\n${bold("Mission:")} ${mission.title}`);
+  }
+
+  // Agents
+  const busyCount = agents.filter((a) => a.state === "busy").length;
+  console.log(`\n${bold("Agents")} (${busyCount} busy / ${agents.length} total):`);
+  if (agents.length === 0) {
+    console.log(`  ${dim("No agents detected")}`);
+  }
+  for (const agent of agents) {
+    const stateLabel = agent.state === "busy" ? yellow("busy") : green("idle");
+    const taskLabel = agent.currentTask
+      ? ` -> ${agent.currentTask.id} "${agent.currentTask.title}" (${agent.currentTask.elapsed})`
+      : "";
+    console.log(`  ${agent.name.padEnd(12)} ${agent.paneId.padEnd(5)} ${stateLabel}${taskLabel}`);
+  }
+
+  // In-progress
+  if (inProgressTasks.length > 0) {
+    console.log(`\n${bold("In-progress")} (${inProgressTasks.length}):`);
+    for (const t of inProgressTasks) {
+      console.log(`  ${t.id}  "${t.title}"  @${t.assignee}  ${dim(t.elapsed)}`);
+    }
+  }
+
+  // Pending
+  if (pendingTasks.length > 0) {
+    console.log(`\n${bold("Pending")} (${pendingTasks.length}):`);
+    for (const t of pendingTasks.slice(0, 10)) {
+      const blocked = t.blocked ? dim(` (blocked by ${t.blockedBy!.join(", ")})`) : "";
+      console.log(`  ${t.id}  "${t.title}"  P${t.priority}${blocked}`);
+    }
+    if (pendingTasks.length > 10) {
+      console.log(`  ${dim(`... and ${pendingTasks.length - 10} more`)}`);
+    }
+  }
+
+  // Recent events
+  if (recentEvents.length > 0) {
+    console.log(`\n${bold("Recent Events")}:`);
+    for (const evt of recentEvents) {
+      console.log(`  ${dim(formatRelative(evt.timestamp))}  ${evt.type.padEnd(15)} ${evt.message}`);
+    }
+  }
+}