tmux-ide 1.2.1 → 2.0.0

package/src/__tests__/support.ts

@@ -0,0 +1,186 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Task, Goal, Mission } from "../lib/task-store.ts";
+import type { PaneInfo } from "../widgets/lib/pane-comms.ts";
+import type { OrchestratorConfig, OrchestratorState } from "../lib/orchestrator.ts";
+import type { Mark, MarkKind, MarkRange } from "../lib/authorship.ts";
+import { ensureTasksDir, saveTask, saveGoal } from "../lib/task-store.ts";
+
+// ---------------------------------------------------------------------------
+// Factory: Task
+// ---------------------------------------------------------------------------
+
+export function makeTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "001",
+    title: "Test task",
+    description: "",
+    goal: null,
+    status: "todo",
+    assignee: null,
+    priority: 1,
+    created: "2026-01-01T00:00:00Z",
+    updated: "2026-01-01T00:00:00Z",
+    tags: [],
+    proof: null,
+    retryCount: 0,
+    maxRetries: 5,
+    lastError: null,
+    nextRetryAt: null,
+    depends_on: [],
+    milestone: null,
+    specialty: null,
+    fulfills: [],
+    discoveredIssues: [],
+    salientSummary: null,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory: Goal
+// ---------------------------------------------------------------------------
+
+export function makeGoal(overrides: Partial<Goal> = {}): Goal {
+  return {
+    id: "01",
+    title: "Test goal",
+    description: "",
+    status: "todo",
+    acceptance: "",
+    priority: 1,
+    created: "2026-01-01T00:00:00Z",
+    updated: "2026-01-01T00:00:00Z",
+    assignee: null,
+    specialty: null,
+    milestone: null,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory: Mission
+// ---------------------------------------------------------------------------
+
+export function makeMission(overrides: Partial<Mission> = {}): Mission {
+  return {
+    title: "Test mission",
+    description: "",
+    status: "active",
+    branch: null,
+    milestones: [],
+    created: "2026-01-01T00:00:00Z",
+    updated: "2026-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory: PaneInfo
+// ---------------------------------------------------------------------------
+
+export function makePane(overrides: Partial<PaneInfo> = {}): PaneInfo {
+  return {
+    id: "%1",
+    index: 0,
+    title: "Agent 1",
+    currentCommand: "zsh",
+    width: 80,
+    height: 24,
+    active: false,
+    role: null,
+    name: null,
+    type: null,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory: OrchestratorConfig
+// ---------------------------------------------------------------------------
+
+export function makeOrchestratorConfig(
+  dir: string,
+  overrides: Partial<OrchestratorConfig> = {},
+): OrchestratorConfig {
+  return {
+    session: "test",
+    dir,
+    autoDispatch: true,
+    stallTimeout: 300000,
+    pollInterval: 5000,
+    masterPane: "Master",
+    beforeRun: null,
+    afterRun: null,
+    maxConcurrentAgents: 10,
+    dispatchMode: "tasks",
+    paneSpecialties: new Map(),
+    services: {},
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory: OrchestratorState
+// ---------------------------------------------------------------------------
+
+export function makeOrchestratorState(
+  overrides: Partial<OrchestratorState> = {},
+): OrchestratorState {
+  return {
+    lastActivity: new Map(),
+    previousTasks: new Map(),
+    claimedTasks: new Set(),
+    taskClaimTimes: new Map(),
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory: Mark
+// ---------------------------------------------------------------------------
+
+export function makeMark(overrides: Partial<Mark> = {}): Mark {
+  return {
+    id: "m1",
+    kind: "authored" as MarkKind,
+    by: "ai:test",
+    at: "2026-01-01T00:00:00Z",
+    range: { from: 0, to: 10 } as MarkRange,
+    quote: "test quote",
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// TestProject: temp directory with .tasks scaffolding
+// ---------------------------------------------------------------------------
+
+export class TestProject {
+  readonly dir: string;
+
+  constructor() {
+    this.dir = mkdtempSync(join(tmpdir(), "tmux-ide-test-"));
+  }
+
+  cleanup(): void {
+    rmSync(this.dir, { recursive: true, force: true });
+  }
+
+  initTasks(): void {
+    ensureTasksDir(this.dir);
+  }
+
+  addTask(overrides: Partial<Task> = {}): Task {
+    const task = makeTask(overrides);
+    saveTask(this.dir, task);
+    return task;
+  }
+
+  addGoal(overrides: Partial<Goal> = {}): Goal {
+    const goal = makeGoal(overrides);
+    saveGoal(this.dir, goal);
+    return goal;
+  }
+}

package/src/{attach.js → attach.ts}

@@ -1,9 +1,12 @@
 import { resolve } from "node:path";
-import { getSessionName } from "./lib/yaml-io.js";
-import { outputError } from "./lib/output.js";
-import { attachSession, getSessionState } from "./lib/tmux.js";
+import { getSessionName } from "./lib/yaml-io.ts";
+import { outputError } from "./lib/output.ts";
+import { attachSession, getSessionState } from "./lib/tmux.ts";
 
-export async function attach(targetDir, { json: _json } = {}) {
+export async function attach(
+  targetDir: string | undefined,
+  { json: _json }: { json?: boolean } = {},
+): Promise<void> {
   const dir = resolve(targetDir ?? ".");
   const { name: session } = getSessionName(dir);
   const state = getSessionState(session);

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