tmux-ide 1.3.1 → 2.0.0

package/src/command-center/discovery.test.ts

@@ -0,0 +1,265 @@
+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 { agentIdentifier } from "../lib/orchestrator.ts";
+import { ensureTasksDir, saveMission, saveTask, loadTask, type Goal } from "../lib/task-store.ts";
+import { _setExecutor, type PaneInfo } from "../widgets/lib/pane-comms.ts";
+import {
+  _setTmuxRunner,
+  discoverSessions,
+  computeStats,
+  computeGoalProgress,
+  buildOverviews,
+  buildProjectDetail,
+  updateTask,
+  type SessionInfo,
+} from "./discovery.ts";
+import { makeTask, makePane } from "../__tests__/support.ts";
+
+let tmpDir: string;
+let restoreTmux: () => void;
+let restoreDiscoveryTmux: () => void;
+let mockPanes: PaneInfo[];
+
+function makeSessionInfo(overrides: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    name: "test-session",
+    dir: tmpDir,
+    mission: null,
+    goals: [],
+    tasks: [],
+    panes: [],
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-cc-test-"));
+  ensureTasksDir(tmpDir);
+  mockPanes = [];
+
+  restoreTmux = _setExecutor((_cmd: string, args: string[]) => {
+    if (args[0] === "list-panes") {
+      return mockPanes
+        .map(
+          (p) =>
+            `${p.id}\t${p.index}\t${p.title}\t${p.currentCommand}\t${p.width}\t${p.height}\t${p.active ? "1" : "0"}\t${p.role ?? ""}\t${p.name ?? ""}\t${p.type ?? ""}`,
+        )
+        .join("\n");
+    }
+    return "";
+  });
+
+  restoreDiscoveryTmux = _setTmuxRunner((args: string[]) => {
+    if (args[0] === "list-sessions") {
+      return "test-session";
+    }
+    if (args[0] === "display-message") {
+      return tmpDir;
+    }
+    return "";
+  });
+});
+
+afterEach(() => {
+  restoreTmux();
+  restoreDiscoveryTmux();
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("discoverSessions", () => {
+  it("discovers sessions with tasks data", () => {
+    saveMission(tmpDir, {
+      title: "Test mission",
+      description: "desc",
+      status: "active",
+      branch: null,
+      milestones: [],
+      created: "2026-01-01T00:00:00Z",
+      updated: "2026-01-01T00:00:00Z",
+    });
+    saveTask(tmpDir, makeTask());
+
+    const sessions = discoverSessions();
+    expect(sessions.length).toBe(1);
+    expect(sessions[0]!.name).toBe("test-session");
+    expect(sessions[0]!.mission?.title).toBe("Test mission");
+    expect(sessions[0]!.tasks.length).toBe(1);
+  });
+
+  it("returns empty when no sessions exist", () => {
+    restoreDiscoveryTmux();
+    restoreDiscoveryTmux = _setTmuxRunner(() => "");
+
+    const sessions = discoverSessions();
+    expect(sessions.length).toBe(0);
+  });
+});
+
+describe("computeStats", () => {
+  it("counts tasks and agents", () => {
+    const info = makeSessionInfo({
+      tasks: [
+        makeTask({ id: "001", status: "done" }),
+        makeTask({ id: "002", status: "in-progress" }),
+        makeTask({ id: "003", status: "todo" }),
+      ],
+      panes: [
+        makePane({ id: "%1", title: "Agent 1", currentCommand: "claude" }),
+        makePane({ id: "%2", title: "Shell", currentCommand: "zsh" }),
+      ],
+    });
+
+    const stats = computeStats(info);
+    expect(stats.totalTasks).toBe(3);
+    expect(stats.doneTasks).toBe(1);
+    expect(stats.agents).toBe(1); // only claude pane
+    expect(stats.activeAgents).toBe(0); // no spinner
+  });
+
+  it("detects active agents with spinner", () => {
+    const info = makeSessionInfo({
+      panes: [makePane({ id: "%1", title: "⠙ Working...", currentCommand: "claude" })],
+    });
+
+    const stats = computeStats(info);
+    expect(stats.agents).toBe(1);
+    expect(stats.activeAgents).toBe(1);
+  });
+});
+
+describe("computeGoalProgress", () => {
+  it("computes progress per goal", () => {
+    const goals: Goal[] = [
+      {
+        id: "01",
+        title: "Goal A",
+        description: "",
+        status: "in-progress",
+        acceptance: "",
+        priority: 1,
+        created: "2026-01-01T00:00:00Z",
+        updated: "2026-01-01T00:00:00Z",
+        assignee: null,
+        specialty: null,
+        milestone: null,
+      },
+    ];
+    const tasks = [
+      makeTask({ id: "001", goal: "01", status: "done" }),
+      makeTask({ id: "002", goal: "01", status: "todo" }),
+      makeTask({ id: "003", goal: "01", status: "done" }),
+      makeTask({ id: "004", goal: null, status: "todo" }),
+    ];
+
+    const progress = computeGoalProgress(goals, tasks);
+    expect(progress.length).toBe(1);
+    expect(progress[0]!.id).toBe("01");
+    expect(progress[0]!.progress).toBe(67); // 2/3
+  });
+
+  it("returns 0 progress for goals with no tasks", () => {
+    const goals: Goal[] = [
+      {
+        id: "01",
+        title: "Empty",
+        description: "",
+        status: "todo",
+        acceptance: "",
+        priority: 1,
+        created: "2026-01-01T00:00:00Z",
+        updated: "2026-01-01T00:00:00Z",
+        assignee: null,
+        specialty: null,
+        milestone: null,
+      },
+    ];
+
+    const progress = computeGoalProgress(goals, []);
+    expect(progress[0]!.progress).toBe(0);
+  });
+});
+
+describe("buildOverviews", () => {
+  it("builds overview with stats for each session", () => {
+    const sessions: SessionInfo[] = [
+      makeSessionInfo({
+        mission: {
+          title: "Ship it",
+          description: "fast",
+          created: "2026-01-01T00:00:00Z",
+          updated: "2026-01-01T00:00:00Z",
+        },
+        tasks: [makeTask({ id: "001", status: "done" }), makeTask({ id: "002", status: "todo" })],
+      }),
+    ];
+
+    const overviews = buildOverviews(sessions);
+    expect(overviews.length).toBe(1);
+    expect(overviews[0]!.mission?.title).toBe("Ship it");
+    expect(overviews[0]!.stats.totalTasks).toBe(2);
+    expect(overviews[0]!.stats.doneTasks).toBe(1);
+  });
+});
+
+describe("buildProjectDetail", () => {
+  it("builds detail with agents matched to tasks", () => {
+    const pane = makePane({ id: "%1", index: 0, title: "Agent 1", currentCommand: "claude" });
+    const name = agentIdentifier(pane);
+    const info = makeSessionInfo({
+      tasks: [
+        makeTask({
+          id: "001",
+          status: "in-progress",
+          assignee: name,
+          updated: new Date().toISOString(),
+        }),
+      ],
+      panes: [pane],
+    });
+
+    const detail = buildProjectDetail(info);
+    expect(detail.agents.length).toBe(1);
+    expect(detail.agents[0]!.paneTitle).toBe(name);
+    expect(detail.agents[0]!.taskTitle).toBe("Test task");
+    expect(detail.agents[0]!.taskId).toBe("001");
+  });
+
+  it("shows idle agent with no task", () => {
+    const info = makeSessionInfo({
+      tasks: [],
+      panes: [makePane({ id: "%1", title: "Agent 1", currentCommand: "claude" })],
+    });
+
+    const detail = buildProjectDetail(info);
+    expect(detail.agents[0]!.taskTitle).toBe(null);
+    expect(detail.agents[0]!.isBusy).toBe(false);
+  });
+});
+
+describe("updateTask", () => {
+  it("updates task status and returns updated task", () => {
+    saveTask(tmpDir, makeTask({ id: "001", status: "todo" }));
+
+    const result = updateTask(tmpDir, "001", { status: "in-progress" });
+    expect(result).toBeTruthy();
+    expect(result.status).toBe("in-progress");
+
+    const loaded = loadTask(tmpDir, "001");
+    expect(loaded?.status).toBe("in-progress");
+  });
+
+  it("updates assignee", () => {
+    saveTask(tmpDir, makeTask({ id: "001" }));
+
+    const result = updateTask(tmpDir, "001", { assignee: "Agent 1" });
+    expect(result).toBeTruthy();
+    expect(result.assignee).toBe("Agent 1");
+  });
+
+  it("returns null for non-existent task", () => {
+    const result = updateTask(tmpDir, "999", { status: "done" });
+    expect(result).toBe(null);
+  });
+});

package/src/command-center/discovery.ts

@@ -0,0 +1,296 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+  loadMission,
+  loadGoals,
+  loadTasks,
+  saveTask,
+  loadTask,
+  type Mission,
+  type Goal,
+  type Task,
+} from "../lib/task-store.ts";
+import { listSessionPanes, type PaneInfo } from "../widgets/lib/pane-comms.ts";
+import { isAgentPane, isAgentBusy, agentIdentifier } from "../lib/orchestrator.ts";
+import { loadValidationState } from "../lib/validation.ts";
+import { loadSkills } from "../lib/skill-registry.ts";
+
+export interface SessionInfo {
+  name: string;
+  dir: string;
+  mission: Mission | null;
+  goals: Goal[];
+  tasks: Task[];
+  panes: PaneInfo[];
+}
+
+export interface SessionStats {
+  totalTasks: number;
+  doneTasks: number;
+  agents: number;
+  activeAgents: number;
+}
+
+export interface SessionOverview {
+  name: string;
+  dir: string;
+  mission: Mission | null;
+  stats: SessionStats;
+  goals: { id: string; title: string; progress: number }[];
+}
+
+export interface AgentDetail {
+  paneTitle: string;
+  paneId: string;
+  isBusy: boolean;
+  taskTitle: string | null;
+  taskId: string | null;
+  elapsed: string;
+}
+
+export interface ValidationSummary {
+  total: number;
+  passing: number;
+  failing: number;
+  pending: number;
+  blocked: number;
+}
+
+export interface SkillSummary {
+  name: string;
+  specialties: string[];
+}
+
+export interface ProjectDetail {
+  session: string;
+  dir: string;
+  mission: Mission | null;
+  goals: Goal[];
+  tasks: Task[];
+  agents: AgentDetail[];
+  milestones: Mission["milestones"];
+  validationSummary: ValidationSummary;
+  skills: SkillSummary[];
+}
+
+type TmuxRunner = (args: string[]) => string;
+
+let _tmuxRunner: TmuxRunner = (args) =>
+  execFileSync("tmux", args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+  }).trim();
+
+export function _setTmuxRunner(fn: TmuxRunner): () => void {
+  const prev = _tmuxRunner;
+  _tmuxRunner = fn;
+  return () => {
+    _tmuxRunner = prev;
+  };
+}
+
+function tmuxSilent(args: string[]): string {
+  try {
+    return _tmuxRunner(args);
+  } catch {
+    return "";
+  }
+}
+
+export function listTmuxSessions(): string[] {
+  const raw = tmuxSilent(["list-sessions", "-F", "#{session_name}"]);
+  if (!raw) return [];
+  return raw.split("\n").filter(Boolean);
+}
+
+export function getSessionCwd(session: string): string {
+  return tmuxSilent(["display-message", "-t", session, "-p", "#{pane_current_path}"]);
+}
+
+function formatElapsed(isoDate: string): string {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const mins = Math.floor(ms / 60000);
+  if (mins < 1) return "<1m";
+  if (mins < 60) return `${mins}m`;
+  return `${Math.floor(mins / 60)}h ${mins % 60}m`;
+}
+
+export function discoverSessions(): SessionInfo[] {
+  const sessionNames = listTmuxSessions();
+  const results: SessionInfo[] = [];
+
+  for (const name of sessionNames) {
+    const dir = getSessionCwd(name);
+    if (!dir) continue;
+
+    const tasksDir = join(dir, ".tasks");
+    const hasTasks = existsSync(tasksDir);
+
+    const mission = hasTasks ? loadMission(dir) : null;
+    const goals = hasTasks ? loadGoals(dir) : [];
+    const tasks = hasTasks ? loadTasks(dir) : [];
+
+    let panes: PaneInfo[] = [];
+    try {
+      panes = listSessionPanes(name);
+    } catch {
+      // session may have vanished
+    }
+
+    results.push({ name, dir, mission, goals, tasks, panes });
+  }
+
+  return results;
+}
+
+export function computeStats(info: SessionInfo): SessionStats {
+  const agentPanes = info.panes.filter((p) => isAgentPane(p));
+  const activeAgents = agentPanes.filter((p) => isAgentBusy(p)).length;
+
+  return {
+    totalTasks: info.tasks.length,
+    doneTasks: info.tasks.filter((t) => t.status === "done").length,
+    agents: agentPanes.length,
+    activeAgents,
+  };
+}
+
+export function computeGoalProgress(
+  goals: Goal[],
+  tasks: Task[],
+): { id: string; title: string; progress: number }[] {
+  return goals.map((g) => {
+    const goalTasks = tasks.filter((t) => t.goal === g.id);
+    const done = goalTasks.filter((t) => t.status === "done").length;
+    const progress = goalTasks.length > 0 ? Math.round((done / goalTasks.length) * 100) : 0;
+    return { id: g.id, title: g.title, progress };
+  });
+}
+
+export function buildOverviews(sessions: SessionInfo[]): SessionOverview[] {
+  return sessions.map((s) => ({
+    name: s.name,
+    dir: s.dir,
+    mission: s.mission,
+    stats: computeStats(s),
+    goals: computeGoalProgress(s.goals, s.tasks),
+  }));
+}
+
+export function buildProjectDetail(info: SessionInfo): ProjectDetail {
+  const agents: AgentDetail[] = info.panes
+    .filter((p) => isAgentPane(p))
+    .map((pane) => {
+      const name = agentIdentifier(pane);
+      const assignedTask = info.tasks.find(
+        (t) => t.assignee === name && t.status === "in-progress",
+      );
+      return {
+        paneTitle: name,
+        paneId: pane.id,
+        isBusy: isAgentBusy(pane),
+        taskTitle: assignedTask?.title ?? null,
+        taskId: assignedTask?.id ?? null,
+        elapsed: assignedTask ? formatElapsed(assignedTask.updated) : "",
+      };
+    });
+
+  const valState = loadValidationState(info.dir);
+  const assertions = valState ? Object.values(valState.assertions) : [];
+  const validationSummary: ValidationSummary = {
+    total: assertions.length,
+    passing: assertions.filter((a) => a.status === "passing").length,
+    failing: assertions.filter((a) => a.status === "failing").length,
+    pending: assertions.filter((a) => a.status === "pending").length,
+    blocked: assertions.filter((a) => a.status === "blocked").length,
+  };
+
+  const skills = loadSkills(info.dir).map((s) => ({
+    name: s.name,
+    specialties: s.specialties,
+  }));
+
+  return {
+    session: info.name,
+    dir: info.dir,
+    mission: info.mission,
+    goals: info.goals,
+    tasks: info.tasks,
+    agents,
+    milestones: info.mission?.milestones ?? [],
+    validationSummary,
+    skills,
+  };
+}
+
+export interface OrchestratorSnapshot {
+  running: boolean;
+  claimedCount: number;
+  agents: AgentDetail[];
+  inProgressCount: number;
+  pendingCount: number;
+}
+
+export function buildOrchestratorSnapshot(info: SessionInfo): OrchestratorSnapshot {
+  const agents: AgentDetail[] = info.panes
+    .filter((p) => isAgentPane(p))
+    .map((pane) => {
+      const name = agentIdentifier(pane);
+      const assignedTask = info.tasks.find(
+        (t) => t.assignee === name && t.status === "in-progress",
+      );
+      return {
+        paneTitle: name,
+        paneId: pane.id,
+        isBusy: isAgentBusy(pane),
+        taskTitle: assignedTask?.title ?? null,
+        taskId: assignedTask?.id ?? null,
+        elapsed: assignedTask ? formatElapsed(assignedTask.updated) : "",
+      };
+    });
+
+  return {
+    running: agents.length > 0,
+    claimedCount: info.tasks.filter((t) => t.status === "in-progress").length,
+    agents,
+    inProgressCount: info.tasks.filter((t) => t.status === "in-progress").length,
+    pendingCount: info.tasks.filter((t) => t.status === "todo").length,
+  };
+}
+
+export function updateTask(
+  dir: string,
+  taskId: string,
+  fields: {
+    status?: string;
+    assignee?: string;
+    title?: string;
+    description?: string;
+    priority?: number;
+  },
+): Task | null {
+  const task = loadTask(dir, taskId);
+  if (!task) return null;
+
+  if (fields.status) {
+    const validStatuses = ["todo", "in-progress", "review", "done"];
+    if (!validStatuses.includes(fields.status)) return null;
+    task.status = fields.status as Task["status"];
+  }
+  if (fields.assignee !== undefined) {
+    task.assignee = fields.assignee || null;
+  }
+  if (fields.title !== undefined) {
+    task.title = fields.title;
+  }
+  if (fields.description !== undefined) {
+    task.description = fields.description;
+  }
+  if (fields.priority !== undefined) {
+    task.priority = fields.priority;
+  }
+  task.updated = new Date().toISOString();
+  saveTask(dir, task);
+  return task;
+}

package/src/command-center/index.ts

@@ -0,0 +1,31 @@
+import { createServer, type Server } from "node:http";
+import { getRequestListener } from "@hono/node-server";
+import { createApp, type CreateAppOptions } from "./server.ts";
+import { AuthService } from "../lib/auth/auth-service.ts";
+import type { AuthConfig } from "../lib/auth/types.ts";
+
+export interface CommandCenterOptions {
+  port?: number;
+  hostname?: string;
+  authService?: AuthService;
+  authConfig?: AuthConfig;
+}
+
+export async function startCommandCenter(options: CommandCenterOptions = {}): Promise<Server> {
+  const port = options.port ?? 6060;
+  const hostname = options.hostname ?? "0.0.0.0";
+  const appOpts: CreateAppOptions = {};
+  if (options.authService) appOpts.authService = options.authService;
+  if (options.authConfig) appOpts.authConfig = options.authConfig;
+  const app = createApp(appOpts);
+
+  const listener = getRequestListener(app.fetch);
+  const server = createServer(listener);
+
+  return new Promise((resolve) => {
+    server.listen(port, hostname, () => {
+      console.log(`Command Center API on http://${hostname}:${port}`);
+      resolve(server);
+    });
+  });
+}

package/src/command-center/schemas.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+
+export const updateTaskSchema = z.object({
+  status: z.enum(["todo", "in-progress", "review", "done"]).optional(),
+  assignee: z.string().optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  priority: z.number().optional(),
+});
+
+export const createTaskSchema = z.object({
+  title: z.string().trim().min(1, "Title is required"),
+  description: z.string().optional(),
+  priority: z.number().optional(),
+  goal: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+export const savePlanSchema = z.object({
+  content: z.string(),
+});
+
+export const sendCommandSchema = z.object({
+  target: z.string().min(1, "Target pane is required"),
+  message: z.string().min(1, "Message is required"),
+  noEnter: z.boolean().optional(),
+});
+
+export const createMilestoneSchema = z.object({
+  title: z.string().trim().min(1, "Title is required"),
+  sequence: z.number().int().positive(),
+  description: z.string().optional(),
+});
+
+export const updateMilestoneSchema = z.object({
+  status: z.enum(["locked", "active", "done", "validating"]).optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+});
+
+export const updateAssertionSchema = z.object({
+  status: z.enum(["pending", "passing", "failing", "blocked"]),
+  evidence: z.string().optional(),
+  verifiedBy: z.string().optional(),
+});
+
+export const triggerResearchSchema = z.object({
+  type: z.string().trim().min(1, "Research type is required"),
+});
+
+export const launchSchema = z
+  .object({
+    attach: z.boolean().optional(),
+  })
+  .optional();
+
+export const stopSchema = z.object({}).optional();