tmux-ide 1.3.1 → 2.1.0

package/src/cli.test.ts

@@ -0,0 +1,314 @@
+import { describe, it, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+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");
+
+function makeProject(config = "name: test-session\nrows:\n  - panes:\n      - title: Shell\n") {
+  const dir = mkdtempSync(join(tmpdir(), "tmux-ide-cli-test-"));
+  writeFileSync(join(dir, "ide.yml"), config);
+  return dir;
+}
+
+function runCli(args, { cwd, env } = {}) {
+  const mergedEnv = { ...process.env };
+  for (const [key, value] of Object.entries(env ?? {})) {
+    if (value === undefined) {
+      delete mergedEnv[key];
+    } else {
+      mergedEnv[key] = value;
+    }
+  }
+
+  return spawnSync("node", [cli, ...args], {
+    cwd,
+    env: mergedEnv,
+    encoding: "utf-8",
+  });
+}
+
+describe("cli contract regressions", () => {
+  it("treats an unknown first positional as a start target path", () => {
+    const missingDir = join(tmpdir(), "tmux-ide-missing-project");
+    const result = runCli([missingDir]);
+
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toMatch(/No ide\.yml found in/);
+    expect(result.stderr).not.toMatch(/Unknown command:/);
+  });
+
+  it("returns a structured start json error when ide.yml is missing", () => {
+    const missingDir = join(tmpdir(), "tmux-ide-missing-project-json");
+    const result = runCli([missingDir, "--json"]);
+
+    expect(result.status).not.toBe(0);
+    const payload = JSON.parse(result.stderr);
+    expect(payload.code).toBe("CONFIG_NOT_FOUND");
+    expect(payload.error).toMatch(/No ide\.yml found in/);
+    expect(payload.error).toMatch(/tmux-ide init/);
+    expect(payload.error).toMatch(/tmux-ide detect --write/);
+  });
+
+  it("prints help for --help without trying to launch tmux", () => {
+    const result = runCli(["--help"]);
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toMatch(/Usage:/);
+    expect(result.stdout).toMatch(/tmux-ide <path>/);
+    expect(result.stderr).not.toMatch(/tmux new-session/);
+  });
+
+  it("includes inspect in the CLI help output", () => {
+    const result = runCli(["--help"]);
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toMatch(/tmux-ide inspect/);
+  });
+
+  it("returns the full non-running status json shape", () => {
+    const dir = makeProject();
+
+    try {
+      const result = runCli(["status", "--json"], { cwd: dir });
+
+      expect(result.status).toBe(0);
+      const output = JSON.parse(result.stdout);
+      expect(output.session).toBe("test-session");
+      expect(output.running).toBe(false);
+      expect(output.configExists).toBe(true);
+      expect(output.panes).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns the detect json envelope with reasoning", () => {
+    const dir = mkdtempSync(join(tmpdir(), "tmux-ide-detect-json-test-"));
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "demo",
+        scripts: { dev: "vite" },
+        dependencies: { vite: "^5.0.0" },
+      }),
+    );
+
+    try {
+      const result = runCli(["detect", "--json"], { cwd: dir });
+
+      expect(result.status).toBe(0);
+      const payload = JSON.parse(result.stdout);
+      expect(Object.keys(payload).sort()).toEqual(["detected", "suggestedConfig"]);
+      expect(Array.isArray(payload.detected.reasons)).toBeTruthy();
+      expect(Array.isArray(payload.suggestedConfig.rows)).toBeTruthy();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a clean attach error without throwing a TypeError", () => {
+    const dir = makeProject();
+
+    try {
+      const result = runCli(["attach"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/Session "test-session" is not running/);
+      expect(result.stderr).not.toMatch(/ERR_INVALID_ARG_TYPE/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a clean init error when ide.yml already exists", () => {
+    const dir = makeProject();
+
+    try {
+      const result = runCli(["init"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/ide\.yml already exists/i);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a structured init json error when ide.yml already exists", () => {
+    const dir = makeProject();
+
+    try {
+      const result = runCli(["init", "--json"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(JSON.parse(result.stderr)).toEqual({
+        error: "ide.yml already exists in this directory",
+        code: "EXISTS",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a structured init json error for an unknown template", () => {
+    const dir = mkdtempSync(join(tmpdir(), "tmux-ide-cli-init-test-"));
+
+    try {
+      const result = runCli(["init", "--template", "missing-template", "--json"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(JSON.parse(result.stderr)).toEqual({
+        error: 'Template "missing-template" not found',
+        code: "NOT_FOUND",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a clean start error for invalid config", () => {
+    const dir = makeProject("name: broken\nrows: []\n");
+
+    try {
+      const result = runCli([], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/Invalid ide\.yml/);
+      expect(result.stderr).toMatch(/tmux-ide validate/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a structured start json error for invalid config", () => {
+    const dir = makeProject("name: broken\nrows: []\n");
+
+    try {
+      const result = runCli(["--json"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      const payload = JSON.parse(result.stderr);
+      expect(payload.code).toBe("INVALID_CONFIG");
+      expect(payload.error).toMatch(/Invalid ide\.yml/);
+      expect(payload.error).toMatch(/tmux-ide validate/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a structured restart json error for invalid config", () => {
+    const dir = makeProject("name: broken\nrows: []\n");
+
+    try {
+      const result = runCli(["restart", "--json"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      const payload = JSON.parse(result.stderr);
+      expect(payload.code).toBe("INVALID_CONFIG");
+      expect(payload.error).toMatch(/Invalid ide\.yml/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a clean launch error when the before hook fails", () => {
+    const dir = makeProject(
+      'name: before-fails\nbefore: node -e "process.exit(3)"\nrows:\n  - panes:\n      - title: Shell\n',
+    );
+
+    try {
+      const result = runCli([], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/before.*hook failed/i);
+      expect(result.stderr).toMatch(/node -e/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a structured start json error when the before hook fails", () => {
+    const dir = makeProject(
+      'name: before-fails\nbefore: node -e "process.exit(3)"\nrows:\n  - panes:\n      - title: Shell\n',
+    );
+
+    try {
+      const result = runCli(["--json"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      const payload = JSON.parse(result.stderr);
+      expect(payload.code).toBe("BEFORE_HOOK_FAILED");
+      expect(payload.error).toMatch(/before.*hook/i);
+      expect(payload.error).toMatch(/node -e/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a structured attach json error with a non-zero exit code", () => {
+    const dir = makeProject();
+
+    try {
+      const result = runCli(["attach", "--json"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(JSON.parse(result.stderr)).toEqual({
+        error: 'Session "test-session" is not running. Start it with: tmux-ide',
+        code: "NOT_RUNNING",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a non-zero exit code when stop cannot find the session", () => {
+    const dir = makeProject();
+
+    try {
+      const result = runCli(["stop"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/No active session "test-session" found/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns a structured stop json error with a non-zero exit code", () => {
+    const dir = makeProject();
+
+    try {
+      const result = runCli(["stop", "--json"], { cwd: dir });
+
+      expect(result.status).not.toBe(0);
+      expect(JSON.parse(result.stderr)).toEqual({
+        error: 'No active session "test-session" found',
+        code: "NOT_RUNNING",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps doctor human and json success semantics aligned for optional checks", () => {
+    const dir = makeProject();
+
+    try {
+      const human = runCli(["doctor"], {
+        cwd: dir,
+        env: { CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: undefined },
+      });
+      const json = runCli(["doctor", "--json"], {
+        cwd: dir,
+        env: { CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: undefined },
+      });
+
+      expect(human.status === 0).toBe(JSON.parse(json.stdout).ok);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

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);
+  });
+});