tmux-ide 1.3.1 → 2.1.0

package/src/send.ts

@@ -0,0 +1,181 @@
+import { randomUUID } from "node:crypto";
+import { resolve, join } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { getSessionName } from "./lib/yaml-io.ts";
+import { getSessionState } from "./lib/tmux.ts";
+import {
+  listSessionPanes,
+  sendCommand,
+  sendText,
+  getPaneBusyStatus,
+  type PaneInfo,
+  type PaneBusyStatus,
+} from "./widgets/lib/pane-comms.ts";
+import { appendEvent } from "./lib/event-log.ts";
+import { IdeError } from "./lib/errors.ts";
+
+export const LONG_MESSAGE_THRESHOLD = 150;
+
+/**
+ * Write a long message to a dispatch file and return the short trigger command.
+ * Returns null if message is short enough to send directly.
+ */
+export function writeDispatchFile(
+  dir: string,
+  paneId: string,
+  message: string,
+): { filePath: string; triggerCmd: string } | null {
+  if (message.length <= LONG_MESSAGE_THRESHOLD) return null;
+  const dispatchDir = join(dir, ".tasks", "dispatch");
+  if (!existsSync(dispatchDir)) mkdirSync(dispatchDir, { recursive: true });
+  const paneSlug = paneId.replace("%", "");
+  const filename = `send-${paneSlug}-${Date.now()}-${randomUUID().slice(0, 8)}.md`;
+  const filePath = join(dispatchDir, filename);
+  writeFileSync(filePath, message);
+  return { filePath, triggerCmd: `Read and execute: .tasks/dispatch/${filename}` };
+}
+
+interface SendOptions {
+  json?: boolean;
+  to?: string;
+  message?: string;
+  noEnter?: boolean;
+}
+
+/**
+ * Resolve a target string to a pane. Priority:
+ * 1. Exact pane ID (%N)
+ * 2. @ide_name match
+ * 3. Exact title match
+ * 4. Role match (lead, teammate, planner)
+ * 5. Case-insensitive partial title match
+ */
+export function resolvePane(panes: PaneInfo[], target: string): PaneInfo | null {
+  // 1. Exact pane ID
+  if (target.startsWith("%")) {
+    return panes.find((p) => p.id === target) ?? null;
+  }
+
+  // 2. @ide_name match
+  const byName = panes.find((p) => p.name === target);
+  if (byName) return byName;
+
+  // 3. Exact title match
+  const byTitle = panes.find((p) => p.title === target);
+  if (byTitle) return byTitle;
+
+  // 4. Role match
+  const lower = target.toLowerCase();
+  if (["lead", "teammate", "planner"].includes(lower)) {
+    const byRole = panes.find((p) => p.role === lower);
+    if (byRole) return byRole;
+  }
+
+  // 5. Case-insensitive partial title match
+  const byPattern = panes.find((p) => p.title.toLowerCase().includes(lower));
+  if (byPattern) return byPattern;
+
+  return null;
+}
+
+function prepareMessage(message: string, busyStatus: PaneBusyStatus): string {
+  if (busyStatus === "agent") {
+    // Collapse multiline to single line for Claude Code TUI
+    // Prevents paste preview that requires manual Enter
+    return message.replace(/\n+/g, " ").trim();
+  }
+  return message;
+}
+
+export async function send(targetDir: string | undefined, opts: SendOptions): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { name: session } = getSessionName(dir);
+  const { json, to: target, message: rawMessage, noEnter } = opts;
+
+  if (!target) {
+    throw new IdeError("Missing target. Usage: tmux-ide send <target> <message>", {
+      code: "USAGE",
+    });
+  }
+
+  if (!rawMessage) {
+    throw new IdeError("Missing message. Usage: tmux-ide send <target> <message>", {
+      code: "USAGE",
+    });
+  }
+
+  // Verify session is running
+  const state = getSessionState(session);
+  if (!state.running) {
+    throw new IdeError(`Session "${session}" is not running`, {
+      code: "SESSION_NOT_FOUND",
+    });
+  }
+
+  const panes = listSessionPanes(session);
+  const pane = resolvePane(panes, target);
+  if (!pane) {
+    const available = panes
+      .map((p) => {
+        const label = p.name ?? p.title;
+        return `  ${p.id}  ${label}${p.role ? ` (${p.role})` : ""}`;
+      })
+      .join("\n");
+    throw new IdeError(`Pane "${target}" not found.\n\nAvailable panes:\n${available}`, {
+      code: "PANE_NOT_FOUND",
+    });
+  }
+
+  const busyStatus = getPaneBusyStatus(session, pane.id);
+  const message = prepareMessage(rawMessage, busyStatus);
+
+  let sentViaFile = false;
+  if (noEnter) {
+    sendText(session, pane.id, message);
+  } else {
+    const dispatch = writeDispatchFile(dir, pane.id, message);
+    if (dispatch) {
+      sendCommand(session, pane.id, dispatch.triggerCmd);
+      sentViaFile = true;
+    } else {
+      sendCommand(session, pane.id, message);
+    }
+  }
+
+  // Log send event
+  appendEvent(dir, {
+    timestamp: new Date().toISOString(),
+    type: "send",
+    target: pane.name ?? pane.title,
+    paneId: pane.id,
+    message: message.length > 100 ? message.slice(0, 100) + "..." : message,
+  });
+
+  const result = {
+    ok: true,
+    session,
+    target: {
+      paneId: pane.id,
+      name: pane.name,
+      title: pane.title,
+      role: pane.role,
+    },
+    message,
+    busyStatus,
+    sentViaFile,
+    ...(busyStatus === "agent" ? { warning: "agent_busy" } : {}),
+  };
+
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const label = pane.name ?? pane.title;
+  const preview = message.length > 60 ? message.slice(0, 60) + "..." : message;
+  console.log(`Sent to "${label}" (${pane.id}): ${preview}`);
+
+  if (busyStatus === "agent") {
+    console.log("Warning: agent appears busy. Message sent anyway.");
+  }
+}

package/src/skill.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadSkills, loadSkill } from "./lib/skill-registry.ts";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-skill-cli-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("skill list", () => {
+  it("returns loaded skills from project directory", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      join(skillsDir, "frontend.md"),
+      `---\nname: frontend\nspecialties: [react, css]\nrole: teammate\ndescription: Frontend dev\n---\nBuild UIs.\n`,
+    );
+    writeFileSync(
+      join(skillsDir, "backend.md"),
+      `---\nname: backend\nspecialties: [api]\nrole: teammate\ndescription: Backend dev\n---\nBuild APIs.\n`,
+    );
+
+    const skills = loadSkills(tmpDir);
+    expect(skills.length).toBe(2);
+    const names = skills.map((s) => s.name).sort();
+    expect(names).toEqual(["backend", "frontend"]);
+  });
+});
+
+describe("skill show", () => {
+  it("returns full skill detail by name", () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      join(skillsDir, "test.md"),
+      `---\nname: my-skill\nspecialties: [testing]\nrole: validator\ndescription: Test validator\n---\nRun all tests.\n`,
+    );
+
+    const skill = loadSkill(tmpDir, "my-skill");
+    expect(skill).not.toBeNull();
+    expect(skill!.name).toBe("my-skill");
+    expect(skill!.role).toBe("validator");
+    expect(skill!.body).toBe("Run all tests.");
+  });
+});
+
+describe("skill create", () => {
+  it("scaffolds a new skill file from template", async () => {
+    const { skillCommand } = await import("./skill.ts");
+    await skillCommand(tmpDir, { sub: "create", args: ["my-agent"], json: true });
+
+    const filePath = join(tmpDir, ".tmux-ide", "skills", "my-agent.md");
+    expect(existsSync(filePath)).toBe(true);
+
+    const content = readFileSync(filePath, "utf-8");
+    expect(content.includes("name: my-agent")).toBe(true);
+  });
+});
+
+describe("skill validate", () => {
+  it("detects unresolved skill references", async () => {
+    // Create ide.yml with a skill reference
+    writeFileSync(
+      join(tmpDir, "ide.yml"),
+      `name: test\nrows:\n  - panes:\n      - title: Agent\n        skill: nonexistent-skill\n`,
+    );
+
+    const { skillCommand } = await import("./skill.ts");
+
+    // Capture console output
+    const logs: string[] = [];
+    const origLog = console.log;
+    console.log = (...args: unknown[]) => logs.push(args.join(" "));
+
+    await skillCommand(tmpDir, { sub: "validate", args: [], json: false });
+
+    console.log = origLog;
+
+    expect(logs.some((l) => l.includes("unresolved"))).toBe(true);
+    expect(logs.some((l) => l.includes("nonexistent-skill"))).toBe(true);
+  });
+
+  it("reports all references resolved when skills exist", async () => {
+    const skillsDir = join(tmpDir, ".tmux-ide", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(
+      join(skillsDir, "worker.md"),
+      `---\nname: worker\nspecialties: []\nrole: teammate\ndescription: Worker\n---\nWork.\n`,
+    );
+    writeFileSync(
+      join(tmpDir, "ide.yml"),
+      `name: test\nrows:\n  - panes:\n      - title: Agent\n        skill: worker\n`,
+    );
+
+    const { skillCommand } = await import("./skill.ts");
+
+    const logs: string[] = [];
+    const origLog = console.log;
+    console.log = (...args: unknown[]) => logs.push(args.join(" "));
+
+    await skillCommand(tmpDir, { sub: "validate", args: [], json: false });
+
+    console.log = origLog;
+
+    expect(logs.some((l) => l.includes("All pane skill references resolve"))).toBe(true);
+  });
+});

package/src/skill.ts

@@ -0,0 +1,138 @@
+import { resolve, join, dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { outputError } from "./lib/output.ts";
+import { loadSkills, loadSkill } from "./lib/skill-registry.ts";
+import { readConfig } from "./lib/yaml-io.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export async function skillCommand(
+  targetDir: string | undefined,
+  {
+    json = false,
+    sub,
+    args = [],
+  }: {
+    json?: boolean;
+    sub?: string;
+    args: string[];
+  },
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+
+  switch (sub) {
+    case "list": {
+      const skills = loadSkills(dir);
+      if (json) {
+        console.log(
+          JSON.stringify(
+            skills.map((s) => ({
+              name: s.name,
+              specialties: s.specialties,
+              role: s.role,
+              description: s.description,
+            })),
+            null,
+            2,
+          ),
+        );
+      } else if (skills.length === 0) {
+        console.log("No skills found. Run: tmux-ide skill create <name>");
+      } else {
+        for (const s of skills) {
+          const specs = s.specialties.length > 0 ? ` [${s.specialties.join(", ")}]` : "";
+          console.log(`  ${s.name}${specs}  (${s.role}) — ${s.description}`);
+        }
+      }
+      break;
+    }
+    case "show": {
+      const name = args[0];
+      if (!name) outputError("Usage: tmux-ide skill show <name>", "USAGE");
+      const skill = loadSkill(dir, name);
+      if (!skill) outputError(`Skill "${name}" not found`, "NOT_FOUND");
+      if (json) {
+        console.log(JSON.stringify(skill, null, 2));
+      } else {
+        console.log(`Skill: ${skill.name}`);
+        console.log(`  Role: ${skill.role}`);
+        console.log(`  Specialties: ${skill.specialties.join(", ") || "none"}`);
+        console.log(`  Description: ${skill.description}`);
+        if (skill.body) {
+          console.log(`\n${skill.body}`);
+        }
+      }
+      break;
+    }
+    case "create": {
+      const name = args[0];
+      if (!name) outputError("Usage: tmux-ide skill create <name>", "USAGE");
+      const skillsDir = join(dir, ".tmux-ide", "skills");
+      const filePath = join(skillsDir, `${name}.md`);
+      if (existsSync(filePath)) {
+        outputError(`Skill "${name}" already exists at ${filePath}`, "EXISTS");
+      }
+      // Copy from general-worker template, replace name
+      const templatePath = resolve(__dirname, "..", "templates", "skills", "general-worker.md");
+      let content: string;
+      if (existsSync(templatePath)) {
+        content = readFileSync(templatePath, "utf-8").replace(/^name: .+/m, `name: ${name}`);
+      } else {
+        content = `---\nname: ${name}\nspecialties: []\nrole: teammate\ndescription: ${name} agent\n---\nYou are a ${name} agent.\n`;
+      }
+      if (!existsSync(skillsDir)) mkdirSync(skillsDir, { recursive: true });
+      writeFileSync(filePath, content);
+      if (json) {
+        console.log(JSON.stringify({ created: true, path: filePath }));
+      } else {
+        console.log(`Created skill "${name}" at ${filePath}`);
+      }
+      break;
+    }
+    case "validate": {
+      let config;
+      try {
+        ({ config } = readConfig(dir));
+      } catch {
+        outputError("Cannot read ide.yml", "READ_ERROR");
+        return;
+      }
+      const skills = loadSkills(dir);
+      const skillNames = new Set(skills.map((s) => s.name));
+      const issues: { pane: string; skill: string }[] = [];
+      for (const row of config.rows) {
+        for (const pane of row.panes) {
+          if (pane.skill && !skillNames.has(pane.skill)) {
+            issues.push({ pane: pane.title ?? "untitled", skill: pane.skill });
+          }
+        }
+      }
+      if (json) {
+        console.log(JSON.stringify({ valid: issues.length === 0, unresolved: issues }, null, 2));
+      } else if (issues.length === 0) {
+        console.log("All pane skill references resolve.");
+      } else {
+        console.log(`${issues.length} unresolved skill reference(s):`);
+        for (const i of issues) {
+          console.log(`  pane "${i.pane}" → skill "${i.skill}" (not found)`);
+        }
+      }
+      break;
+    }
+    case "help":
+    case undefined:
+      console.log(`Usage: tmux-ide skill <list|show|create|validate>
+
+  list                List all skills (project + personal)
+  show <name>         Show full skill detail
+  create <name>       Scaffold a new skill file
+  validate            Check pane skill references resolve`);
+      break;
+    default:
+      outputError(
+        "Usage: tmux-ide skill <list|show|create|validate>\nRun: tmux-ide skill help",
+        "USAGE",
+      );
+  }
+}

package/src/status.ts

@@ -0,0 +1,66 @@
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { getSessionName } from "./lib/yaml-io.ts";
+import {
+  getSessionState,
+  getSessionVariable,
+  getDaemonPort,
+  isDaemonHealthy,
+  isProcessAlive,
+  listPanes,
+} from "./lib/tmux.ts";
+
+export async function status(
+  targetDir: string | undefined,
+  { json }: { json?: boolean } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { name: session } = getSessionName(dir);
+  const configExists = existsSync(resolve(dir, "ide.yml"));
+
+  const state = getSessionState(session);
+  const running = state.running;
+  let panes: ReturnType<typeof listPanes> = [];
+
+  if (running) panes = listPanes(session);
+
+  const monitorPid = running ? getSessionVariable(session, "@monitor_pid") : null;
+  const daemonPort = running ? getDaemonPort(session) : null;
+  const healthy = daemonPort ? await isDaemonHealthy(session) : false;
+
+  const data = {
+    session,
+    running,
+    configExists,
+    panes,
+    daemon: {
+      pid: monitorPid ? parseInt(monitorPid, 10) : null,
+      alive: monitorPid ? isProcessAlive(parseInt(monitorPid, 10)) : false,
+      port: daemonPort,
+      healthy,
+    },
+  };
+
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  console.log(`Session: ${session}`);
+  console.log(`Running: ${running ? "yes" : "no"}`);
+  console.log(`Config:  ${configExists ? "ide.yml found" : "no ide.yml"}`);
+
+  if (running) {
+    console.log(
+      `Daemon:  ${data.daemon.alive ? "running" : "not running"}${data.daemon.port ? ` (port ${data.daemon.port})` : ""}`,
+    );
+  }
+
+  if (panes.length > 0) {
+    console.log(`\nPanes:`);
+    for (const p of panes) {
+      const active = p.active ? " (active)" : "";
+      console.log(`  ${p.index}: ${p.title} [${p.width}x${p.height}]${active}`);
+    }
+  }
+}

package/src/stop.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, beforeEach, afterEach, mock, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { _setExecutor } from "./lib/tmux.ts";
+import { stop } from "./stop.ts";
+
+let mockExec;
+let restoreExec;
+let tmpDir;
+
+beforeEach(() => {
+  mockExec = mock();
+  restoreExec = _setExecutor(mockExec);
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-stop-test-"));
+});
+
+afterEach(() => {
+  restoreExec();
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function writeIdeYml(name) {
+  writeFileSync(join(tmpDir, "ide.yml"), `name: ${name}\n`);
+}
+
+function makeExecError(stderr) {
+  const err = new Error("Command failed");
+  err.stderr = stderr;
+  return err;
+}
+
+describe("stop", () => {
+  it("calls stopSessionMonitor before killSession", async () => {
+    writeIdeYml("my-app");
+    const callLog = [];
+    mockExec.mockImplementation((_cmd, args) => {
+      callLog.push(args[0]);
+      if (args[0] === "show-option") return "\n";
+      return "";
+    });
+
+    const logged = [];
+    const origLog = console.log;
+    console.log = (...a) => logged.push(a.join(" "));
+
+    try {
+      await stop(tmpDir);
+      // show-option (stopSessionMonitor) should come before kill-session
+      const showIdx = callLog.indexOf("show-option");
+      const killIdx = callLog.indexOf("kill-session");
+      expect(showIdx < killIdx).toBeTruthy();
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  it("outputs JSON when --json is passed", async () => {
+    writeIdeYml("test-proj");
+    mockExec.mockImplementation((_cmd, args) => {
+      if (args[0] === "show-option") return "\n";
+      return "";
+    });
+
+    const logged = [];
+    const origLog = console.log;
+    console.log = (...a) => logged.push(a.join(" "));
+
+    try {
+      await stop(tmpDir, { json: true });
+      const output = JSON.parse(logged[0]);
+      expect(output).toEqual({ stopped: "test-proj" });
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  it("outputs human-readable message by default", async () => {
+    writeIdeYml("my-app");
+    mockExec.mockImplementation((_cmd, args) => {
+      if (args[0] === "show-option") return "\n";
+      return "";
+    });
+
+    const logged = [];
+    const origLog = console.log;
+    console.log = (...a) => logged.push(a.join(" "));
+
+    try {
+      await stop(tmpDir);
+      expect(logged[0].includes('Stopped session "my-app"')).toBeTruthy();
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  it("throws IdeError when session not found", async () => {
+    writeIdeYml("missing");
+    mockExec.mockImplementation((_cmd, args) => {
+      if (args[0] === "show-option") {
+        throw makeExecError("can't find session: missing");
+      }
+      if (args[0] === "kill-session") {
+        throw makeExecError("can't find session: missing");
+      }
+      return "";
+    });
+
+    await expect(stop(tmpDir)).rejects.toThrow("No active session");
+  });
+
+  it("falls back to dir basename when ide.yml has no name", async () => {
+    // Write minimal YAML without a name field
+    writeFileSync(join(tmpDir, "ide.yml"), "rows:\n  - panes:\n      - title: Shell\n");
+    mockExec.mockImplementation((_cmd, args) => {
+      if (args[0] === "show-option") return "\n";
+      return "";
+    });
+
+    const logged = [];
+    const origLog = console.log;
+    console.log = (...a) => logged.push(a.join(" "));
+
+    try {
+      await stop(tmpDir);
+      // Session name should be the basename of the temp dir
+      expect(logged[0].includes("Stopped session")).toBeTruthy();
+    } finally {
+      console.log = origLog;
+    }
+  });
+
+  it("falls back to dir basename when no ide.yml exists", async () => {
+    // No ide.yml written
+    mockExec.mockImplementation((_cmd, args) => {
+      if (args[0] === "show-option") return "\n";
+      return "";
+    });
+
+    const logged = [];
+    const origLog = console.log;
+    console.log = (...a) => logged.push(a.join(" "));
+
+    try {
+      await stop(tmpDir);
+      expect(logged[0].includes("Stopped session")).toBeTruthy();
+    } finally {
+      console.log = origLog;
+    }
+  });
+});

package/src/stop.ts

@@ -0,0 +1,28 @@
+import { resolve } from "node:path";
+import { getSessionName } from "./lib/yaml-io.ts";
+import { outputError } from "./lib/output.ts";
+import { killSession, stopSessionMonitor } from "./lib/tmux.ts";
+
+export async function stop(
+  targetDir: string | undefined,
+  { json }: { json?: boolean } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { name: session } = getSessionName(dir);
+
+  // Stop the session monitor before killing the session
+  stopSessionMonitor(session);
+
+  const result = killSession(session);
+
+  if (result.stopped) {
+    if (json) {
+      console.log(JSON.stringify({ stopped: session }));
+    } else {
+      console.log(`Stopped session "${session}"`);
+    }
+    return;
+  }
+
+  outputError(`No active session "${session}" found`, "NOT_RUNNING");
+}