tmux-ide 1.3.1 → 2.0.0

package/src/lib/output.ts

@@ -0,0 +1,76 @@
+import { IdeError } from "./errors.ts";
+import type { IdeConfig } from "../types.ts";
+
+export function printLayout(config: IdeConfig): void {
+  const INNER = 40;
+  const rows = config.rows ?? [];
+  if (rows.length === 0) return;
+
+  for (let r = 0; r < rows.length; r++) {
+    const panes = rows[r]!.panes ?? [];
+    const count = panes.length || 1;
+    const widths: number[] = [];
+    let remaining = INNER;
+    for (let i = 0; i < count; i++) {
+      const w = i < count - 1 ? Math.floor(INNER / count) : remaining;
+      widths.push(w);
+      remaining -= w;
+    }
+
+    // Top border or mid divider
+    if (r === 0) {
+      let top = "  \u250c";
+      for (let i = 0; i < count; i++) {
+        top += "\u2500".repeat(widths[i]!);
+        top += i < count - 1 ? "\u252c" : "\u2510";
+      }
+      console.log(top);
+    } else {
+      console.log("  \u251c" + "\u2500".repeat(INNER + count - 1) + "\u2524");
+    }
+
+    // Content line
+    const sizeLabel = rows[r]!.size ?? "";
+    let line = "  \u2502";
+    for (let i = 0; i < count; i++) {
+      const title = panes[i]?.title ?? "";
+      const w = widths[i]!;
+      const pad = Math.max(0, w - title.length);
+      const left = Math.floor(pad / 2);
+      const right = pad - left;
+      line += " ".repeat(left) + title + " ".repeat(right) + "\u2502";
+    }
+    if (sizeLabel) line += "  " + sizeLabel;
+    console.log(line);
+
+    // Bottom border (last row only)
+    if (r === rows.length - 1) {
+      let bot = "  \u2514";
+      for (let i = 0; i < count; i++) {
+        bot += "\u2500".repeat(widths[i]!);
+        bot += i < count - 1 ? "\u2534" : "\u2518";
+      }
+      console.log(bot);
+    }
+  }
+}
+
+export function outputError(
+  message: string,
+  code: string,
+  { exitCode = 1 }: { exitCode?: number } = {},
+): never {
+  throw new IdeError(message, { code, exitCode });
+}
+
+export function printCommandError(
+  error: IdeError,
+  { json = false }: { json?: boolean } = {},
+): never {
+  if (json) {
+    console.error(JSON.stringify(error.toJSON(), null, 2));
+  } else {
+    console.error(error.message);
+  }
+  process.exit(error.exitCode ?? 1);
+}

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

@@ -0,0 +1,148 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadPlans, listPlans, markPlanDone, getPlan } from "./plan-store.ts";
+
+let tmpDir: string;
+
+function writePlan(name: string, content: string) {
+  const dir = join(tmpDir, "plans");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${name}.md`), content);
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-plans-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("loadPlans", () => {
+  it("returns empty when plans/ does not exist", () => {
+    expect(loadPlans(tmpDir)).toEqual([]);
+  });
+
+  it("loads plans and parses status", () => {
+    writePlan(
+      "01-mouse-support",
+      "# Plan 01: Mouse Support\n\n**Status:** `done`\n**Effort:** Low\n",
+    );
+    writePlan(
+      "70-hierarchical-agents",
+      "# Plan 70: Hierarchical Agents\n\n**Status:** `in-progress`\n**Effort:** High\n**Gate:** agents work\n",
+    );
+
+    const plans = loadPlans(tmpDir);
+    expect(plans.length).toBe(2);
+    expect(plans[0]!.name).toBe("01-mouse-support");
+    expect(plans[0]!.status).toBe("done");
+    expect(plans[0]!.effort).toBe("Low");
+    expect(plans[1]!.name).toBe("70-hierarchical-agents");
+    expect(plans[1]!.status).toBe("in-progress");
+    expect(plans[1]!.gate).toBe("agents work");
+  });
+
+  it("skips ROADMAP.md", () => {
+    writePlan("ROADMAP", "# Roadmap\n");
+    writePlan("01-test", "# Test\n\n**Status:** `pending`\n");
+
+    const plans = loadPlans(tmpDir);
+    expect(plans.length).toBe(1);
+    expect(plans[0]!.name).toBe("01-test");
+  });
+
+  it("defaults to pending when no status found", () => {
+    writePlan("99-no-status", "# No Status Plan\n\nJust content.\n");
+    const plans = loadPlans(tmpDir);
+    expect(plans[0]!.status).toBe("pending");
+  });
+});
+
+describe("listPlans", () => {
+  it("filters by status", () => {
+    writePlan("01-done", "# Done\n\n**Status:** `done`\n");
+    writePlan("02-pending", "# Pending\n\n**Status:** `pending`\n");
+    writePlan("03-active", "# Active\n\n**Status:** `in-progress`\n");
+
+    const done = listPlans(tmpDir, { status: "done" });
+    expect(done.length).toBe(1);
+    expect(done[0]!.name).toBe("01-done");
+
+    const active = listPlans(tmpDir, { status: "in-progress" });
+    expect(active.length).toBe(1);
+    expect(active[0]!.name).toBe("03-active");
+  });
+
+  it("returns all when no filter", () => {
+    writePlan("01-a", "# A\n\n**Status:** `done`\n");
+    writePlan("02-b", "# B\n\n**Status:** `pending`\n");
+
+    expect(listPlans(tmpDir).length).toBe(2);
+  });
+});
+
+describe("markPlanDone", () => {
+  it("updates status to done and adds completed date", () => {
+    writePlan(
+      "50-task-cli",
+      "# Plan 50: Task CLI\n\n**Status:** `in-progress`\n**Effort:** Medium\n",
+    );
+
+    const result = markPlanDone(tmpDir, "50");
+    expect(result).toBeTruthy();
+    expect(result!.status).toBe("done");
+    expect(result!.completed).toBeTruthy();
+
+    // Verify file was updated
+    const content = readFileSync(join(tmpDir, "plans", "50-task-cli.md"), "utf-8");
+    expect(content.includes("**Status:** `done`")).toBeTruthy();
+    expect(content.includes("**Completed:**")).toBeTruthy();
+  });
+
+  it("matches by full name", () => {
+    writePlan("my-plan", "# My Plan\n\n**Status:** `pending`\n");
+    const result = markPlanDone(tmpDir, "my-plan");
+    expect(result).toBeTruthy();
+    expect(result!.status).toBe("done");
+  });
+
+  it("matches by number prefix", () => {
+    writePlan("70-hierarchical-agents", "# Plan 70\n\n**Status:** `in-progress`\n");
+    const result = markPlanDone(tmpDir, "70");
+    expect(result).toBeTruthy();
+  });
+
+  it("returns null for non-existent plan", () => {
+    expect(markPlanDone(tmpDir, "nonexistent")).toBe(null);
+  });
+
+  it("preserves existing completed date format on re-mark", () => {
+    writePlan("01-test", "# Test\n\n**Status:** `done`\n**Completed:** 2026-01-01\n");
+    const result = markPlanDone(tmpDir, "01");
+    expect(result).toBeTruthy();
+    // Should update the date
+    expect(result!.completed).not.toBe("2026-01-01");
+  });
+});
+
+describe("getPlan", () => {
+  it("finds by name", () => {
+    writePlan("50-task-cli", "# Plan 50\n\n**Status:** `done`\n");
+    const plan = getPlan(tmpDir, "50-task-cli");
+    expect(plan).toBeTruthy();
+    expect(plan!.name).toBe("50-task-cli");
+  });
+
+  it("finds by number prefix", () => {
+    writePlan("50-task-cli", "# Plan 50\n\n**Status:** `done`\n");
+    const plan = getPlan(tmpDir, "50");
+    expect(plan).toBeTruthy();
+  });
+
+  it("returns null when not found", () => {
+    expect(getPlan(tmpDir, "99")).toBe(null);
+  });
+});

package/src/lib/plan-store.ts

@@ -0,0 +1,131 @@
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+export type PlanStatus = "pending" | "in-progress" | "done" | "archived";
+
+export interface PlanMeta {
+  name: string; // filename without .md
+  path: string; // relative path from project root
+  title: string; // first # heading
+  status: PlanStatus;
+  effort?: string;
+  gate?: string;
+  completed?: string; // ISO date when marked done
+}
+
+/**
+ * Parse plan status from the **Status:** `xxx` pattern used in plan files.
+ */
+function parseInlineStatus(content: string): PlanStatus {
+  const match = content.match(/\*\*Status:\*\*\s*`([^`]+)`/);
+  if (!match) return "pending";
+  const raw = match[1]!.toLowerCase().trim();
+  if (raw === "done" || raw === "completed") return "done";
+  if (raw === "in-progress" || raw === "in progress" || raw === "active") return "in-progress";
+  if (raw === "archived") return "archived";
+  return "pending";
+}
+
+function parseInlineField(content: string, field: string): string | undefined {
+  const re = new RegExp(`\\*\\*${field}:\\*\\*\\s*(.+?)\\s*$`, "m");
+  const match = content.match(re);
+  return match ? match[1]!.replace(/^`|`$/g, "").trim() : undefined;
+}
+
+function parseTitle(content: string): string {
+  const match = content.match(/^#\s+(.+)/m);
+  return match ? match[1]!.trim() : "(untitled)";
+}
+
+/**
+ * Load all plan files from plans/ directory.
+ */
+export function loadPlans(dir: string): PlanMeta[] {
+  const plansDir = join(dir, "plans");
+  if (!existsSync(plansDir)) return [];
+
+  return readdirSync(plansDir)
+    .filter((f) => f.endsWith(".md") && f !== "ROADMAP.md")
+    .sort()
+    .map((f) => {
+      const content = readFileSync(join(plansDir, f), "utf-8");
+      return {
+        name: f.replace(/\.md$/, ""),
+        path: `plans/${f}`,
+        title: parseTitle(content),
+        status: parseInlineStatus(content),
+        effort: parseInlineField(content, "Effort"),
+        gate: parseInlineField(content, "Gate"),
+        completed: parseInlineField(content, "Completed"),
+      };
+    });
+}
+
+/**
+ * List plans filtered by status.
+ */
+export function listPlans(dir: string, filter?: { status?: PlanStatus }): PlanMeta[] {
+  const plans = loadPlans(dir);
+  if (filter?.status) {
+    return plans.filter((p) => p.status === filter.status);
+  }
+  return plans;
+}
+
+/**
+ * Mark a plan as done. Updates the **Status:** line and adds **Completed:** date.
+ */
+export function markPlanDone(dir: string, nameOrNumber: string): PlanMeta | null {
+  const plansDir = join(dir, "plans");
+  if (!existsSync(plansDir)) return null;
+
+  // Find the plan file — match by name, number prefix, or full filename
+  const files = readdirSync(plansDir).filter((f) => f.endsWith(".md"));
+  const target = files.find(
+    (f) =>
+      f === `${nameOrNumber}.md` ||
+      f.replace(/\.md$/, "") === nameOrNumber ||
+      f.startsWith(`${nameOrNumber}-`),
+  );
+
+  if (!target) return null;
+
+  const filePath = join(plansDir, target);
+  let content = readFileSync(filePath, "utf-8");
+  const today = new Date().toISOString().split("T")[0]!;
+
+  // Update status
+  if (content.match(/\*\*Status:\*\*\s*`[^`]+`/)) {
+    content = content.replace(/\*\*Status:\*\*\s*`[^`]+`/, "**Status:** `done`");
+  }
+
+  // Add or update completed date
+  if (content.match(/\*\*Completed:\*\*/)) {
+    content = content.replace(/\*\*Completed:\*\*\s*.+/, `**Completed:** ${today}`);
+  } else {
+    // Insert after the Status line
+    content = content.replace(/(\*\*Status:\*\*\s*`done`)/, `$1\n**Completed:** ${today}`);
+  }
+
+  writeFileSync(filePath, content);
+
+  return {
+    name: target.replace(/\.md$/, ""),
+    path: `plans/${target}`,
+    title: parseTitle(content),
+    status: "done",
+    effort: parseInlineField(content, "Effort"),
+    gate: parseInlineField(content, "Gate"),
+    completed: today,
+  };
+}
+
+/**
+ * Get a single plan by name or number.
+ */
+export function getPlan(dir: string, nameOrNumber: string): PlanMeta | null {
+  const plans = loadPlans(dir);
+  return (
+    plans.find((p) => p.name === nameOrNumber || p.name.startsWith(`${nameOrNumber}-`)) ?? null
+  );
+}

package/src/lib/research.test.ts

@@ -0,0 +1,208 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  makeMission,
+  makeOrchestratorConfig,
+  makeOrchestratorState,
+  makePane,
+  makeTask,
+} from "../__tests__/support.ts";
+import { _setExecutor, type PaneInfo } from "../widgets/lib/pane-comms.ts";
+import { saveMission, loadTasks, ensureTasksDir } from "./task-store.ts";
+import {
+  buildResearchPrompt,
+  dispatchResearch,
+  evaluateTriggers,
+  loadResearchState,
+  type ResearchState,
+} from "./research.ts";
+
+let tmpDir: string;
+let restoreTmux: () => void;
+let tmuxCalls: { args: string[] }[];
+let mockPanes: PaneInfo[];
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-research-test-"));
+  ensureTasksDir(tmpDir);
+  tmuxCalls = [];
+  mockPanes = [];
+  restoreTmux = _setExecutor((_cmd: string, args: string[]) => {
+    tmuxCalls.push({ args });
+    if (args[0] === "list-panes") {
+      return mockPanes
+        .map(
+          (pane) =>
+            `${pane.id}\t${pane.index}\t${pane.title}\t${pane.currentCommand}\t${pane.width}\t${pane.height}\t${pane.active ? "1" : "0"}\t${pane.role ?? ""}\t${pane.name ?? ""}\t${pane.type ?? ""}`,
+        )
+        .join("\n");
+    }
+    return "";
+  });
+});
+
+afterEach(() => {
+  restoreTmux();
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function makeResearchState(overrides: Partial<ResearchState> = {}): ResearchState {
+  return {
+    lastResearchAt: {},
+    missionStartAnalyzed: false,
+    milestoneTaskCounts: {},
+    activeResearchTaskId: null,
+    retryWindow: [],
+    ...overrides,
+  };
+}
+
+describe("evaluateTriggers", () => {
+  it("fires mission_start only once", () => {
+    saveMission(tmpDir, makeMission({ status: "active" }));
+    const config = {
+      ...makeOrchestratorConfig(tmpDir, { dispatchMode: "missions" }),
+      research: { enabled: true, triggers: { mission_start: true } },
+    };
+    const state = makeOrchestratorState();
+    const researchState = makeResearchState();
+
+    const first = evaluateTriggers(config, state, researchState, [], []);
+    const second = evaluateTriggers(config, state, researchState, [], []);
+
+    expect(first).toHaveLength(1);
+    expect(first[0]?.type).toBe("mission_start");
+    expect(second).toEqual([]);
+  });
+
+  it("fires milestone_progress after N completed tasks", () => {
+    saveMission(
+      tmpDir,
+      makeMission({
+        milestones: [
+          {
+            id: "M1",
+            title: "Phase 1",
+            description: "",
+            status: "active",
+            order: 1,
+            created: "2026-01-01T00:00:00Z",
+            updated: "2026-01-01T00:00:00Z",
+          },
+        ],
+      }),
+    );
+    const config = {
+      ...makeOrchestratorConfig(tmpDir, { dispatchMode: "missions" }),
+      research: { enabled: true, triggers: { milestone_progress: 2 } },
+    };
+    const state = makeOrchestratorState();
+    const researchState = makeResearchState({ milestoneTaskCounts: { M1: 1 } });
+    const tasks = [
+      makeTask({ id: "001", milestone: "M1", status: "done" }),
+      makeTask({ id: "002", milestone: "M1", status: "done" }),
+    ];
+
+    const triggers = evaluateTriggers(config, state, researchState, tasks, []);
+
+    expect(triggers).toHaveLength(1);
+    expect(triggers[0]?.type).toBe("milestone_progress");
+    expect(researchState.milestoneTaskCounts.M1).toBe(2);
+  });
+
+  it("respects periodic cooldowns", () => {
+    const config = {
+      ...makeOrchestratorConfig(tmpDir, { dispatchMode: "missions" }),
+      research: { enabled: true, triggers: { periodic_minutes: 10 } },
+    };
+    const state = makeOrchestratorState();
+    const researchState = makeResearchState({
+      lastResearchAt: { periodic: new Date().toISOString() },
+    });
+
+    const triggers = evaluateTriggers(config, state, researchState, [], []);
+    expect(triggers).toEqual([]);
+  });
+
+  it("skips triggers when a research agent is already busy", () => {
+    saveMission(tmpDir, makeMission({ status: "active" }));
+    const config = {
+      ...makeOrchestratorConfig(tmpDir, { dispatchMode: "missions" }),
+      research: { enabled: true, triggers: { mission_start: true } },
+    };
+    const state = makeOrchestratorState();
+    const researchState = makeResearchState({ activeResearchTaskId: "099" });
+
+    const triggers = evaluateTriggers(config, state, researchState, [], []);
+    expect(triggers).toEqual([]);
+  });
+});
+
+describe("buildResearchPrompt", () => {
+  it("includes mission context", () => {
+    saveMission(
+      tmpDir,
+      makeMission({ title: "Ship v2.0", description: "Audit the mission system" }),
+    );
+
+    const prompt = buildResearchPrompt(tmpDir, "mission_start", {
+      taskId: "099",
+      reason: "Mission just started",
+    });
+
+    expect(prompt).toContain("Mission: Ship v2.0");
+    expect(prompt).toContain("Audit the mission system");
+    expect(prompt).toContain("tmux-ide task done 099");
+  });
+});
+
+describe("dispatchResearch", () => {
+  it("dispatches when a researcher pane is available", () => {
+    saveMission(tmpDir, makeMission({ status: "active" }));
+    const config = {
+      ...makeOrchestratorConfig(tmpDir, { dispatchMode: "missions", maxConcurrentAgents: 4 }),
+      research: { enabled: true, triggers: { mission_start: true } },
+    };
+    const state = makeOrchestratorState();
+    const researchState = makeResearchState();
+    const pane = makePane({
+      id: "%2",
+      index: 1,
+      title: "Researcher",
+      role: "researcher",
+      currentCommand: "zsh",
+    });
+    mockPanes = [pane];
+
+    const task = dispatchResearch(config, state, researchState, [], [pane], {
+      type: "mission_start",
+      reason: "Mission started",
+    });
+
+    expect(task).not.toBeNull();
+    expect(task?.tags).toEqual(["research", "mission_start"]);
+    expect(task?.specialty).toBe("researcher");
+    expect(researchState.activeResearchTaskId).toBe(task?.id ?? null);
+    expect(existsSync(join(tmpDir, ".tasks", "dispatch", `research-${task?.id}.md`))).toBe(true);
+    expect(loadTasks(tmpDir).some((saved) => saved.id === task?.id)).toBe(true);
+    expect(tmuxCalls.some((call) => call.args.includes("send-keys"))).toBe(true);
+  });
+
+  it("does not dispatch without a researcher or fallback pane", () => {
+    const config = {
+      ...makeOrchestratorConfig(tmpDir, { dispatchMode: "missions", maxConcurrentAgents: 4 }),
+      research: { enabled: true, triggers: { periodic_minutes: 1 } },
+    };
+    const state = makeOrchestratorState();
+    const researchState = loadResearchState(tmpDir);
+
+    const task = dispatchResearch(config, state, researchState, [], [], {
+      type: "periodic",
+      reason: "Periodic interval elapsed",
+    });
+
+    expect(task).toBeNull();
+  });
+});