tmux-ide 1.2.1 → 2.0.0

package/src/lib/launch-plan.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "bun:test";
+import { buildPaneCommand, collectPaneStartupPlan } from "./launch-plan.ts";
+import type { Row } from "../types.ts";
+
+describe("buildPaneCommand", () => {
+  it("passes through normal pane commands", () => {
+    expect(buildPaneCommand({ command: "pnpm dev" })).toBe("pnpm dev");
+  });
+
+  it("returns the command unchanged for Claude panes", () => {
+    expect(buildPaneCommand({ command: "claude", role: "lead" })).toBe("claude");
+    expect(buildPaneCommand({ command: "claude", role: "teammate", task: 'Fix "lint"' })).toBe(
+      "claude",
+    );
+  });
+});
+
+describe("collectPaneStartupPlan", () => {
+  it("launches team panes as normal pane commands", () => {
+    const rows = [
+      {
+        panes: [
+          { title: "Lead", command: "claude", role: "lead", focus: true, env: { PORT: 3000 } },
+          { title: "Worker", command: "claude", role: "teammate", task: "Review" },
+        ],
+      },
+      {
+        panes: [{ title: "Shell", dir: "apps/web" }],
+      },
+    ];
+
+    const result = collectPaneStartupPlan(
+      rows,
+      [["%1", "%2"], ["%3"]],
+      new Set(["%1", "%3"]),
+      "/workspace",
+    );
+
+    expect(result.focusPane).toBe("%1");
+    expect(result.paneActions).toEqual([
+      {
+        targetPane: "%1",
+        title: "Lead",
+        chdir: null,
+        exports: [`export 'PORT'='3000'`],
+        command: `claude --name 'Lead'`,
+        widgetType: null,
+        widgetTarget: null,
+        paneRole: "lead",
+        paneType: "agent",
+      },
+      {
+        targetPane: "%2",
+        title: "Worker",
+        chdir: null,
+        exports: [],
+        command: `claude --name 'Worker'`,
+        widgetType: null,
+        widgetTarget: null,
+        paneRole: "teammate",
+        paneType: "agent",
+      },
+      {
+        targetPane: "%3",
+        title: "Shell",
+        chdir: "/workspace/apps/web",
+        exports: [],
+        command: null,
+        widgetType: null,
+        widgetTarget: null,
+        paneRole: "shell",
+        paneType: "shell",
+      },
+    ]);
+  });
+
+  it("widgets:false config produces fewer pane actions when widget panes are stripped", () => {
+    const fullRows: Row[] = [
+      {
+        panes: [
+          { title: "Claude", command: "claude", role: "lead" },
+          { title: "Tasks", type: "tasks" },
+          { title: "Explorer", type: "explorer" },
+        ],
+      },
+      {
+        panes: [{ title: "Shell" }, { title: "War Room", type: "warroom" }],
+      },
+    ];
+
+    // Simulate headless mode: strip widget panes (panes with type set)
+    const headlessRows = fullRows
+      .map((row) => ({ ...row, panes: row.panes.filter((p) => !p.type) }))
+      .filter((row) => row.panes.length > 0);
+
+    const fullResult = collectPaneStartupPlan(
+      fullRows,
+      [
+        ["%1", "%2", "%3"],
+        ["%4", "%5"],
+      ],
+      new Set(["%1", "%4"]),
+      "/workspace",
+    );
+
+    const headlessResult = collectPaneStartupPlan(
+      headlessRows,
+      [["%1"], ["%4"]],
+      new Set(["%1", "%4"]),
+      "/workspace",
+    );
+
+    // Full has 5 pane actions (3 widgets + agent + shell)
+    expect(fullResult.paneActions.length).toBe(5);
+    // Headless has only 2 (agent + shell), 3 widget panes stripped
+    expect(headlessResult.paneActions.length).toBe(2);
+    expect(headlessResult.paneActions.every((a) => a.widgetType === null)).toBeTruthy();
+  });
+});

package/src/lib/launch-plan.ts

@@ -0,0 +1,90 @@
+import { resolve } from "node:path";
+import type { Pane, Row, PaneAction } from "../types.ts";
+import { shellEscape } from "./shell.ts";
+
+export function buildPaneCommand(pane: Pane): string | null {
+  if (!pane.command) return null;
+  return pane.command;
+}
+
+export function collectPaneStartupPlan(
+  rows: Row[],
+  paneMap: string[][],
+  firstPanesOfRows: Set<string>,
+  dir: string,
+): { focusPane: string; paneActions: PaneAction[] } {
+  let focusPane = paneMap[0]![0]!;
+  const paneActions: PaneAction[] = [];
+
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const row = rows[rowIdx]!;
+    const panes = row.panes ?? [];
+
+    for (let paneIdx = 0; paneIdx < panes.length; paneIdx++) {
+      const pane = panes[paneIdx]!;
+      const tmuxPane = paneMap[rowIdx]![paneIdx]!;
+      // Derive @ide_role from pane config
+      let paneRole: string;
+      if (pane.role === "lead") {
+        paneRole = "lead";
+      } else if (pane.role === "teammate" || pane.role === "planner") {
+        paneRole = "teammate";
+      } else if (pane.type) {
+        paneRole = "widget";
+      } else {
+        paneRole = "shell";
+      }
+
+      // Derive @ide_type from pane config
+      let paneType: string;
+      if (pane.type) {
+        paneType = pane.type;
+      } else if (pane.command && /claude|codex/i.test(pane.command)) {
+        paneType = "agent";
+      } else {
+        paneType = "shell";
+      }
+
+      const action: PaneAction = {
+        targetPane: tmuxPane,
+        title: pane.title ?? null,
+        chdir: null,
+        exports: [],
+        command: null,
+        widgetType: pane.type ?? null,
+        widgetTarget: pane.target ?? null,
+        paneRole,
+        paneType,
+      };
+
+      if (pane.dir && firstPanesOfRows.has(tmuxPane)) {
+        action.chdir = resolve(dir, pane.dir);
+      }
+
+      if (pane.env && typeof pane.env === "object") {
+        action.exports = Object.entries(pane.env).map(
+          ([key, value]) => `export ${shellEscape(key)}=${shellEscape(String(value))}`,
+        );
+      }
+
+      let command = buildPaneCommand(pane);
+      // Inject --name flag into Claude/Codex commands so the agent
+      // sets its own pane title to match the configured name.
+      // This is agent-agnostic: any CLI that respects --name will work.
+      if (command && pane.title && /claude|codex/i.test(command) && !command.includes("--name")) {
+        command = `${command} --name ${shellEscape(pane.title)}`;
+      }
+      if (command) {
+        action.command = command;
+      }
+
+      if (pane.focus) {
+        focusPane = tmuxPane;
+      }
+
+      paneActions.push(action);
+    }
+  }
+
+  return { focusPane, paneActions };
+}

package/src/lib/log.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "bun:test";
+import { log } from "./log.ts";
+
+function captureConsole(method: "log" | "warn" | "error" | "debug", fn: () => void): unknown[][] {
+  const original = console[method];
+  const calls: unknown[][] = [];
+  (console as Record<string, typeof console.log>)[method] = (...args: unknown[]) => {
+    calls.push(args);
+  };
+  try {
+    fn();
+  } finally {
+    (console as Record<string, typeof console.log>)[method] = original;
+  }
+  return calls;
+}
+
+describe("log", () => {
+  it("log.info forwards to console.log", () => {
+    const calls = captureConsole("log", () => log.info("a", 1, { b: 2 }));
+    expect(calls).toEqual([["a", 1, { b: 2 }]]);
+  });
+
+  it("log.warn forwards to console.warn", () => {
+    const calls = captureConsole("warn", () => log.warn("warn"));
+    expect(calls).toEqual([["warn"]]);
+  });
+
+  it("log.error forwards to console.error", () => {
+    const calls = captureConsole("error", () => log.error(new Error("x")));
+    expect(calls.length).toBe(1);
+    expect(calls[0]![0]).toBeInstanceOf(Error);
+  });
+
+  it("log.debug forwards to console.debug", () => {
+    const calls = captureConsole("debug", () => log.debug("dbg"));
+    expect(calls).toEqual([["dbg"]]);
+  });
+});

package/src/lib/log.ts

@@ -0,0 +1,71 @@
+/** Minimal structured logger for tmux-ide daemon processes. */
+
+type Level = "debug" | "info" | "warn" | "error";
+
+const LEVEL_RANK: Record<Level, number> = { debug: 0, info: 1, warn: 2, error: 3 };
+
+let minLevel: Level = (process.env.LOG_LEVEL as Level) ?? "info";
+
+export function setLogLevel(level: Level): void {
+  minLevel = level;
+}
+
+function writeStructuredLog(
+  level: Level,
+  component: string,
+  message: string,
+  data?: Record<string, unknown>,
+): void {
+  if (LEVEL_RANK[level] < LEVEL_RANK[minLevel]) return;
+  const entry: Record<string, unknown> = {
+    ts: new Date().toISOString(),
+    level,
+    component,
+    msg: message,
+  };
+  if (data) Object.assign(entry, data);
+  const out = level === "error" ? process.stderr : process.stdout;
+  out.write(JSON.stringify(entry) + "\n");
+}
+
+export const logger = {
+  debug: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("debug", component, msg, data),
+  info: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("info", component, msg, data),
+  warn: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("warn", component, msg, data),
+  error: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("error", component, msg, data),
+};
+
+/**
+ * Thin logger shim compatible with VibeTunnel's module logger API (`createLogger`-style methods).
+ * Wraps `console.*` (distinct from structured JSON `logger` above).
+ */
+export type LogMethod = (...args: unknown[]) => void;
+
+export const log = {
+  /** Alias for `info` / console.log (VibeTunnel `createLogger` compatibility). */
+  log: (...args: unknown[]) => {
+    console.log(...args);
+  },
+  info: (...args: unknown[]) => {
+    console.log(...args);
+  },
+  warn: (...args: unknown[]) => {
+    console.warn(...args);
+  },
+  error: (...args: unknown[]) => {
+    console.error(...args);
+  },
+  debug: (...args: unknown[]) => {
+    console.debug(...args);
+  },
+} satisfies {
+  log: LogMethod;
+  info: LogMethod;
+  warn: LogMethod;
+  error: LogMethod;
+  debug: LogMethod;
+};

package/src/lib/metrics.test.ts

@@ -0,0 +1,213 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  computeMetrics,
+  loadMetrics,
+  saveMetrics,
+  appendMissionHistory,
+  loadMissionHistory,
+  type MetricsSnapshot,
+} from "./metrics.ts";
+import { ensureTasksDir, saveTask, saveMission } from "./task-store.ts";
+import { appendEvent } from "./event-log.ts";
+import { makeTask, makeMission } from "../__tests__/support.ts";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-metrics-test-"));
+  ensureTasksDir(tmpDir);
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("computeMetrics", () => {
+  it("calculates task completion rate", () => {
+    saveTask(tmpDir, makeTask({ id: "001", status: "done", assignee: "Agent 1" }));
+    saveTask(tmpDir, makeTask({ id: "002", status: "done", assignee: "Agent 1" }));
+    saveTask(tmpDir, makeTask({ id: "003", status: "todo" }));
+
+    const metrics = computeMetrics(tmpDir);
+    expect(metrics.tasks.total).toBe(3);
+    expect(metrics.tasks.completed).toBe(2);
+    expect(metrics.tasks.completionRate).toBeCloseTo(0.67, 1);
+  });
+
+  it("calculates retry rate", () => {
+    saveTask(tmpDir, makeTask({ id: "001", status: "done", retryCount: 2 }));
+    saveTask(tmpDir, makeTask({ id: "002", status: "done", retryCount: 0 }));
+
+    const metrics = computeMetrics(tmpDir);
+    expect(metrics.tasks.retried).toBe(1);
+    expect(metrics.tasks.retryRate).toBe(0.5);
+  });
+
+  it("computes agent utilization from heartbeat events", () => {
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:00:00Z",
+      type: "agent_heartbeat",
+      message: "agents: Alice=busy, Bob=idle",
+    });
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:05:00Z",
+      type: "agent_heartbeat",
+      message: "agents: Alice=busy, Bob=busy",
+    });
+    appendEvent(tmpDir, {
+      timestamp: "2026-01-01T00:10:00Z",
+      type: "agent_heartbeat",
+      message: "agents: Alice=idle, Bob=idle",
+    });
+
+    const metrics = computeMetrics(tmpDir);
+    const alice = metrics.agents.find((a) => a.name === "Alice");
+    const bob = metrics.agents.find((a) => a.name === "Bob");
+
+    expect(alice).toBeTruthy();
+    expect(alice!.utilization).toBeCloseTo(0.67, 1); // 2/3 busy
+    expect(bob).toBeTruthy();
+    expect(bob!.utilization).toBeCloseTo(0.33, 1); // 1/3 busy
+  });
+
+  it("includes milestone metrics", () => {
+    saveMission(
+      tmpDir,
+      makeMission({
+        milestones: [
+          {
+            id: "M1",
+            title: "Phase 1",
+            description: "",
+            status: "done",
+            order: 1,
+            created: "2026-01-01T00:00:00Z",
+            updated: "2026-01-01T01:00:00Z",
+          },
+          {
+            id: "M2",
+            title: "Phase 2",
+            description: "",
+            status: "active",
+            order: 2,
+            created: "2026-01-01T00:00:00Z",
+            updated: "2026-01-01T00:00:00Z",
+          },
+        ],
+      }),
+    );
+    saveTask(tmpDir, makeTask({ id: "001", milestone: "M1", status: "done" }));
+    saveTask(tmpDir, makeTask({ id: "002", milestone: "M2", status: "todo" }));
+
+    const metrics = computeMetrics(tmpDir);
+    expect(metrics.tasks.byMilestone.length).toBe(2);
+    expect(metrics.tasks.byMilestone[0]!.id).toBe("M1");
+    expect(metrics.tasks.byMilestone[0]!.completedCount).toBe(1);
+    expect(metrics.mission.milestonesCompleted).toBe(1);
+  });
+
+  it("handles empty project", () => {
+    const metrics = computeMetrics(tmpDir);
+    expect(metrics.tasks.total).toBe(0);
+    expect(metrics.tasks.completionRate).toBe(0);
+    expect(metrics.agents.length).toBe(0);
+    expect(metrics.timeline.length).toBe(0);
+  });
+
+  it("generates timeline from events", () => {
+    const baseTime = new Date("2026-01-01T00:00:00Z").getTime();
+    appendEvent(tmpDir, {
+      timestamp: new Date(baseTime).toISOString(),
+      type: "dispatch",
+      taskId: "001",
+      agent: "Agent 1",
+      message: "Dispatched",
+    });
+    appendEvent(tmpDir, {
+      timestamp: new Date(baseTime + 10 * 60 * 1000).toISOString(),
+      type: "completion",
+      taskId: "001",
+      agent: "Agent 1",
+      message: "Completed",
+    });
+
+    const metrics = computeMetrics(tmpDir);
+    expect(metrics.timeline.length).toBeGreaterThan(0);
+  });
+});
+
+describe("saveMetrics / loadMetrics", () => {
+  it("round-trips metrics snapshot", () => {
+    const snapshot: MetricsSnapshot = {
+      session: {
+        startedAt: "2026-01-01T00:00:00Z",
+        durationMs: 60000,
+        status: "active",
+        agentCount: 2,
+      },
+      tasks: {
+        total: 5,
+        completed: 3,
+        failed: 0,
+        retried: 1,
+        completionRate: 0.6,
+        retryRate: 0.2,
+        avgDurationMs: 5000,
+        medianDurationMs: 4000,
+        p90DurationMs: 8000,
+        byMilestone: [],
+      },
+      agents: [],
+      mission: {
+        title: "Test",
+        status: "active",
+        milestonesCompleted: 1,
+        validationPassRate: 1,
+        wallClockMs: 60000,
+      },
+      timeline: [],
+    };
+    saveMetrics(tmpDir, snapshot);
+    const loaded = loadMetrics(tmpDir);
+    expect(loaded).toEqual(snapshot);
+  });
+
+  it("returns null when no file", () => {
+    expect(loadMetrics(tmpDir)).toBeNull();
+  });
+});
+
+describe("appendMissionHistory / loadMissionHistory", () => {
+  it("appends and loads mission summaries", () => {
+    const mission = makeMission({ title: "Mission A", status: "complete" });
+    const tasks = [
+      makeTask({ id: "001", status: "done", assignee: "Agent 1" }),
+      makeTask({ id: "002", status: "done", assignee: "Agent 2" }),
+    ];
+
+    appendMissionHistory(tmpDir, mission, tasks);
+
+    const history = loadMissionHistory(tmpDir);
+    expect(history.length).toBe(1);
+    expect(history[0]!.title).toBe("Mission A");
+    expect(history[0]!.taskCount).toBe(2);
+    expect(history[0]!.agentCount).toBe(2);
+  });
+
+  it("appends multiple missions", () => {
+    appendMissionHistory(tmpDir, makeMission({ title: "M1" }), []);
+    appendMissionHistory(tmpDir, makeMission({ title: "M2" }), [makeTask()]);
+
+    const history = loadMissionHistory(tmpDir);
+    expect(history.length).toBe(2);
+    expect(history[0]!.title).toBe("M1");
+    expect(history[1]!.title).toBe("M2");
+  });
+
+  it("returns empty array when no history", () => {
+    expect(loadMissionHistory(tmpDir)).toEqual([]);
+  });
+});