tmux-ide 1.3.1 → 2.0.0

package/src/widgets/lib/files.ts

@@ -0,0 +1,88 @@
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import ignore, { type Ignore } from "ignore";
+
+const ALWAYS_IGNORE = new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  "coverage",
+  ".nyc_output",
+  "target",
+  "vendor",
+  "bower_components",
+]);
+
+export { type Ignore };
+
+export interface FileEntry {
+  name: string;
+  path: string; // relative to root
+  absolutePath: string;
+  isDir: boolean;
+  ignored: boolean; // gitignored
+}
+
+export function createIgnoreFilter(rootDir: string): Ignore {
+  const ig = ignore();
+  const gitignorePath = join(rootDir, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    ig.add(readFileSync(gitignorePath, "utf-8"));
+  }
+  return ig;
+}
+
+export function readDirectory(
+  dir: string,
+  rootDir: string,
+  ig: Ignore,
+  showHidden: boolean,
+  showIgnored: boolean = false,
+): FileEntry[] {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((e) => {
+      if (ALWAYS_IGNORE.has(e.name)) return false;
+      if (!showHidden && e.name.startsWith(".")) return false;
+      if (showIgnored) return true;
+      const rel = relative(rootDir, join(dir, e.name));
+      try {
+        return !ig.ignores(e.isDirectory() ? rel + "/" : rel);
+      } catch {
+        return true;
+      }
+    })
+    .map((e) => {
+      const rel = relative(rootDir, join(dir, e.name));
+      let isIgnored = false;
+      try {
+        isIgnored = ig.ignores(e.isDirectory() ? rel + "/" : rel);
+      } catch {
+        // ignore malformed paths for ignore rules
+      }
+      return {
+        name: e.name,
+        path: rel,
+        absolutePath: join(dir, e.name),
+        isDir: e.isDirectory(),
+        ignored: isIgnored,
+      };
+    })
+    .sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+}

package/src/widgets/lib/git.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, unlinkSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import {
+  getGitBranch,
+  getGitFileStatuses,
+  getGitStatusMap,
+  getFileDiff,
+  isGitRepo,
+} from "./git.ts";
+
+let tmpDir: string;
+
+function git(...args: string[]) {
+  execFileSync("git", args, { cwd: tmpDir, stdio: "ignore" });
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-git-test-"));
+  git("init", "-b", "main");
+  git("config", "user.email", "test@test.com");
+  git("config", "user.name", "Test");
+  writeFileSync(join(tmpDir, "initial.txt"), "hello\n");
+  git("add", ".");
+  git("commit", "-m", "initial");
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("getGitBranch", () => {
+  it("returns the current branch name", () => {
+    expect(getGitBranch(tmpDir)).toBe("main");
+  });
+
+  it("returns null for a non-git directory", () => {
+    const nonGit = mkdtempSync(join(tmpdir(), "tmux-ide-nongit-"));
+    try {
+      expect(getGitBranch(nonGit)).toBe(null);
+    } finally {
+      rmSync(nonGit, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("isGitRepo", () => {
+  it("returns true for a git directory", () => {
+    expect(isGitRepo(tmpDir)).toBe(true);
+  });
+
+  it("returns false for a non-git directory", () => {
+    const nonGit = mkdtempSync(join(tmpdir(), "tmux-ide-nongit-"));
+    try {
+      expect(isGitRepo(nonGit)).toBe(false);
+    } finally {
+      rmSync(nonGit, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("getGitFileStatuses", () => {
+  it("returns empty array for a clean working tree", () => {
+    const statuses = getGitFileStatuses(tmpDir);
+    expect(statuses).toEqual([]);
+  });
+
+  it("detects modified files with line counts", () => {
+    writeFileSync(join(tmpDir, "initial.txt"), "hello\nworld\n");
+    const statuses = getGitFileStatuses(tmpDir);
+    const modified = statuses.find((s) => s.path === "initial.txt");
+    expect(modified).toBeTruthy();
+    expect(modified.status).toBe("M");
+    expect(modified.additions).toBe(1);
+    expect(modified.deletions).toBe(0);
+  });
+
+  it("detects untracked files", () => {
+    writeFileSync(join(tmpDir, "new-file.txt"), "content\n");
+    const statuses = getGitFileStatuses(tmpDir);
+    const untracked = statuses.find((s) => s.path === "new-file.txt");
+    expect(untracked).toBeTruthy();
+    expect(untracked.status).toBe("?");
+  });
+
+  it("detects deleted files", () => {
+    unlinkSync(join(tmpDir, "initial.txt"));
+    const statuses = getGitFileStatuses(tmpDir);
+    const deleted = statuses.find((s) => s.path === "initial.txt");
+    expect(deleted).toBeTruthy();
+    expect(deleted.status).toBe("D");
+  });
+
+  it("detects files in subdirectories", () => {
+    mkdirSync(join(tmpDir, "subdir"));
+    writeFileSync(join(tmpDir, "subdir", "nested.txt"), "nested\n");
+    const statuses = getGitFileStatuses(tmpDir);
+    const nested = statuses.find((s) => s.path === "subdir/nested.txt");
+    expect(nested).toBeTruthy();
+    expect(nested.status).toBe("?");
+  });
+
+  it("returns empty array for a non-git directory", () => {
+    const nonGit = mkdtempSync(join(tmpdir(), "tmux-ide-nongit-"));
+    try {
+      expect(getGitFileStatuses(nonGit)).toEqual([]);
+    } finally {
+      rmSync(nonGit, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("getGitStatusMap", () => {
+  it("propagates status to parent directories", () => {
+    mkdirSync(join(tmpDir, "src"));
+    mkdirSync(join(tmpDir, "src", "lib"));
+    writeFileSync(join(tmpDir, "src", "lib", "deep.txt"), "deep\n");
+    const map = getGitStatusMap(tmpDir);
+    expect(map.get("src/lib/deep.txt")).toBe("?");
+    expect(map.get("src/lib")).toBe("?");
+    expect(map.get("src")).toBe("?");
+  });
+
+  it("returns empty map for clean working tree", () => {
+    const map = getGitStatusMap(tmpDir);
+    expect(map.size).toBe(0);
+  });
+
+  it("includes both modified and untracked files", () => {
+    writeFileSync(join(tmpDir, "initial.txt"), "changed\n");
+    writeFileSync(join(tmpDir, "new.txt"), "new\n");
+    const map = getGitStatusMap(tmpDir);
+    expect(map.get("initial.txt")).toBe("M");
+    expect(map.get("new.txt")).toBe("?");
+  });
+});
+
+describe("getFileDiff", () => {
+  it("returns a diff for modified files", () => {
+    writeFileSync(join(tmpDir, "initial.txt"), "hello\nworld\n");
+    const diff = getFileDiff(tmpDir, "initial.txt", false);
+    expect(diff.includes("+world")).toBeTruthy();
+  });
+
+  it("returns empty string for unmodified files", () => {
+    const diff = getFileDiff(tmpDir, "initial.txt", false);
+    expect(diff).toBe("");
+  });
+});

package/src/widgets/lib/git.ts

@@ -0,0 +1,88 @@
+import { execFileSync } from "node:child_process";
+
+export interface GitFileStatus {
+  path: string;
+  status: "M" | "A" | "D" | "R" | "?";
+  additions: number;
+  deletions: number;
+}
+
+function execGit(dir: string, args: string[]): string {
+  try {
+    return execFileSync(
+      "git",
+      ["-c", "core.fsmonitor=false", "-c", "core.quotepath=false", ...args],
+      { cwd: dir, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] },
+    );
+  } catch {
+    return "";
+  }
+}
+
+export function getGitBranch(dir: string): string | null {
+  const result = execGit(dir, ["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+  return result || null;
+}
+
+export function getGitFileStatuses(dir: string): GitFileStatus[] {
+  const results: GitFileStatus[] = [];
+
+  // 1. Identify deleted files first so we can tag them correctly in numstat
+  const deleted = execGit(dir, ["diff", "--name-only", "--diff-filter=D", "HEAD"]);
+  const deletedPaths = new Set(deleted.split("\n").filter(Boolean));
+
+  // 2. Modified/deleted files with line counts
+  const numstat = execGit(dir, ["diff", "--numstat", "HEAD"]);
+  for (const line of numstat.split("\n").filter(Boolean)) {
+    const parts = line.split("\t");
+    if (parts.length < 3) continue;
+    const [added, removed, ...pathParts] = parts;
+    const filepath = pathParts.join("\t");
+    if (added === "-") continue; // binary file
+    results.push({
+      path: filepath,
+      status: deletedPaths.has(filepath) ? "D" : "M",
+      additions: parseInt(added!, 10) || 0,
+      deletions: parseInt(removed!, 10) || 0,
+    });
+  }
+
+  // 3. Deleted files not in numstat (shouldn't happen, but be safe)
+  const numstatPaths = new Set(results.map((r) => r.path));
+  for (const filepath of deletedPaths) {
+    if (!numstatPaths.has(filepath)) {
+      results.push({ path: filepath, status: "D", additions: 0, deletions: 0 });
+    }
+  }
+
+  // 4. Untracked files
+  const untracked = execGit(dir, ["ls-files", "--others", "--exclude-standard"]);
+  for (const filepath of untracked.split("\n").filter(Boolean)) {
+    results.push({ path: filepath, status: "?", additions: 0, deletions: 0 });
+  }
+
+  return results;
+}
+
+export function getGitStatusMap(dir: string): Map<string, string> {
+  const map = new Map<string, string>();
+  for (const file of getGitFileStatuses(dir)) {
+    map.set(file.path, file.status);
+    // Propagate to parent directories
+    let parent = file.path;
+    while (parent.includes("/")) {
+      parent = parent.substring(0, parent.lastIndexOf("/"));
+      if (!map.has(parent)) map.set(parent, file.status);
+    }
+  }
+  return map;
+}
+
+export function getFileDiff(dir: string, path: string, staged: boolean): string {
+  const args = staged ? ["diff", "--cached", "--", path] : ["diff", "--", path];
+  return execGit(dir, args);
+}
+
+export function isGitRepo(dir: string): boolean {
+  return execGit(dir, ["rev-parse", "--is-inside-work-tree"]).trim() === "true";
+}

package/src/widgets/lib/pane-comms.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import {
+  _setExecutor,
+  listSessionPanes,
+  findPaneByTitle,
+  findPaneByPattern,
+  findAdjacentPane,
+  isPaneBusy,
+  getPaneBusyStatus,
+  resolveTarget,
+} from "./pane-comms.ts";
+
+let restoreExec: () => void;
+let mockOutput: string;
+let tmuxCalls: string[][];
+
+beforeEach(() => {
+  mockOutput = "";
+  tmuxCalls = [];
+  restoreExec = _setExecutor((_cmd: string, args: string[]) => {
+    tmuxCalls.push(args);
+    return mockOutput;
+  });
+});
+
+afterEach(() => {
+  restoreExec();
+});
+
+function setMockPanes(output: string) {
+  mockOutput = output;
+}
+
+const TWO_PANES = ["%0\t0\tFiles\tzsh\t80\t24\t0", "%1\t1\tClaude\tclaude\t80\t24\t1"].join("\n");
+
+const THREE_PANES = [
+  "%0\t0\tFiles\tzsh\t80\t24\t0",
+  "%1\t1\tClaude\tclaude\t80\t24\t1",
+  "%2\t2\tShell\tzsh\t80\t24\t0",
+].join("\n");
+
+describe("listSessionPanes", () => {
+  it("parses tmux list-panes output correctly", () => {
+    setMockPanes(TWO_PANES);
+    const panes = listSessionPanes("test-session");
+    expect(panes.length).toBe(2);
+    expect(panes[0]!.id).toBe("%0");
+    expect(panes[0]!.title).toBe("Files");
+    expect(panes[0]!.currentCommand).toBe("zsh");
+    expect(panes[0]!.active).toBe(false);
+    expect(panes[1]!.id).toBe("%1");
+    expect(panes[1]!.title).toBe("Claude");
+    expect(panes[1]!.active).toBe(true);
+  });
+
+  it("returns empty array when no output", () => {
+    setMockPanes("");
+    const panes = listSessionPanes("test-session");
+    expect(panes).toEqual([]);
+  });
+});
+
+describe("findPaneByTitle", () => {
+  it("finds pane by exact title match", () => {
+    setMockPanes(TWO_PANES);
+    expect(findPaneByTitle("s", "Claude")).toBe("%1");
+  });
+
+  it("returns null when title not found", () => {
+    setMockPanes(TWO_PANES);
+    expect(findPaneByTitle("s", "Shell")).toBe(null);
+  });
+});
+
+describe("findPaneByPattern", () => {
+  it("finds pane by case-insensitive substring", () => {
+    setMockPanes(TWO_PANES);
+    expect(findPaneByPattern("s", "claude")).toBe("%1");
+  });
+
+  it("returns null when pattern not found", () => {
+    setMockPanes(TWO_PANES);
+    expect(findPaneByPattern("s", "editor")).toBe(null);
+  });
+});
+
+describe("findAdjacentPane", () => {
+  it("returns the next pane", () => {
+    setMockPanes(TWO_PANES);
+    expect(findAdjacentPane("s", "%0")).toBe("%1");
+  });
+
+  it("wraps around to the first pane", () => {
+    setMockPanes(TWO_PANES);
+    expect(findAdjacentPane("s", "%1")).toBe("%0");
+  });
+
+  it("returns null when only one pane", () => {
+    setMockPanes("%0\t0\tFiles\tzsh\t80\t24\t1");
+    expect(findAdjacentPane("s", "%0")).toBe(null);
+  });
+
+  it("returns null when pane not found", () => {
+    setMockPanes(TWO_PANES);
+    expect(findAdjacentPane("s", "%99")).toBe(null);
+  });
+});
+
+describe("isPaneBusy", () => {
+  it("returns false for shell panes", () => {
+    setMockPanes("%0\t0\tShell\tzsh\t80\t24\t0");
+    expect(isPaneBusy("s", "%0")).toBe(false);
+  });
+
+  it("returns true for vim", () => {
+    setMockPanes("%0\t0\tEditor\tvim\t80\t24\t0");
+    expect(isPaneBusy("s", "%0")).toBe(true);
+  });
+
+  it("returns true for unknown pane", () => {
+    setMockPanes(TWO_PANES);
+    expect(isPaneBusy("s", "%99")).toBe(true);
+  });
+});
+
+describe("getPaneBusyStatus", () => {
+  it("returns agent for claude panes", () => {
+    setMockPanes("%0\t0\tClaude\tclaude\t80\t24\t1");
+    expect(getPaneBusyStatus("s", "%0")).toBe("agent");
+  });
+
+  it("returns idle for shell panes", () => {
+    setMockPanes("%0\t0\tShell\tbash\t80\t24\t0");
+    expect(getPaneBusyStatus("s", "%0")).toBe("idle");
+  });
+
+  it("returns busy for vim", () => {
+    setMockPanes("%0\t0\tEditor\tvim\t80\t24\t0");
+    expect(getPaneBusyStatus("s", "%0")).toBe("busy");
+  });
+
+  it("returns busy for unknown pane", () => {
+    setMockPanes(TWO_PANES);
+    expect(getPaneBusyStatus("s", "%99")).toBe("busy");
+  });
+});
+
+describe("resolveTarget", () => {
+  it("returns explicit paneId first", () => {
+    setMockPanes(THREE_PANES);
+    expect(resolveTarget("s", { paneId: "%2" })).toBe("%2");
+  });
+
+  it("finds by title", () => {
+    setMockPanes(THREE_PANES);
+    expect(resolveTarget("s", { title: "Shell" })).toBe("%2");
+  });
+
+  it("finds by title pattern", () => {
+    setMockPanes(THREE_PANES);
+    expect(resolveTarget("s", { titlePattern: "claude" })).toBe("%1");
+  });
+
+  it("falls back to adjacent pane", () => {
+    setMockPanes(THREE_PANES);
+    expect(resolveTarget("s", { selfPaneId: "%0" })).toBe("%1");
+  });
+
+  it("prefers title over adjacency", () => {
+    setMockPanes(THREE_PANES);
+    expect(resolveTarget("s", { title: "Shell", selfPaneId: "%0" })).toBe("%2");
+  });
+
+  it("returns null when nothing matches", () => {
+    setMockPanes(THREE_PANES);
+    expect(resolveTarget("s", {})).toBe(null);
+  });
+});

package/src/widgets/lib/pane-comms.ts

@@ -0,0 +1,192 @@
+import { execFileSync } from "node:child_process";
+
+export interface PaneInfo {
+  id: string;
+  index: number;
+  title: string;
+  currentCommand: string;
+  width: number;
+  height: number;
+  active: boolean;
+  role: "lead" | "teammate" | "planner" | "validator" | "researcher" | "widget" | "shell" | null;
+  name: string | null;
+  type: string | null;
+}
+
+type TmuxExecutor = (cmd: string, args: string[], options?: object) => string;
+
+let _executor: TmuxExecutor = (cmd, args, options) =>
+  execFileSync(cmd, args, { encoding: "utf-8", ...options }).toString();
+
+export function _setExecutor(fn: TmuxExecutor): () => void {
+  const prev = _executor;
+  _executor = fn;
+  return () => {
+    _executor = prev;
+  };
+}
+
+function tmux(...args: string[]): string {
+  try {
+    return _executor("tmux", args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch (error) {
+    const stderr = (error as { stderr?: Buffer | string })?.stderr?.toString() ?? "";
+    if (stderr.includes("no server running") || stderr.includes("can't find session")) {
+      return "";
+    }
+    throw error;
+  }
+}
+
+export function listSessionPanes(session: string): PaneInfo[] {
+  const format = [
+    "#{pane_id}",
+    "#{pane_index}",
+    "#{pane_title}",
+    "#{pane_current_command}",
+    "#{pane_width}",
+    "#{pane_height}",
+    "#{pane_active}",
+    "#{@ide_role}",
+    "#{@ide_name}",
+    "#{@ide_type}",
+  ].join("\t");
+
+  const output = tmux("list-panes", "-t", session, "-F", format);
+  if (!output) return [];
+
+  return output
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [id, index, title, cmd, width, height, active, role, name, type] = line.split("\t");
+      return {
+        id: id!,
+        index: parseInt(index!, 10),
+        title: title!,
+        currentCommand: cmd!,
+        width: parseInt(width!, 10),
+        height: parseInt(height!, 10),
+        active: active === "1",
+        role: (role || null) as PaneInfo["role"],
+        name: name || null,
+        type: type || null,
+      };
+    });
+}
+
+export function findPaneByTitle(session: string, title: string): string | null {
+  const panes = listSessionPanes(session);
+  const match = panes.find((p) => p.title === title);
+  return match?.id ?? null;
+}
+
+export function findPaneByPattern(session: string, pattern: string): string | null {
+  const panes = listSessionPanes(session);
+  const lower = pattern.toLowerCase();
+  const match = panes.find((p) => p.title.toLowerCase().includes(lower));
+  return match?.id ?? null;
+}
+
+export function findAdjacentPane(session: string, currentPaneId: string): string | null {
+  const panes = listSessionPanes(session);
+  const currentIdx = panes.findIndex((p) => p.id === currentPaneId);
+  if (currentIdx === -1 || panes.length < 2) return null;
+  const nextIdx = (currentIdx + 1) % panes.length;
+  return panes[nextIdx]!.id;
+}
+
+const BUSY_COMMANDS = new Set([
+  "claude",
+  "codex",
+  "vim",
+  "nvim",
+  "vi",
+  "nano",
+  "emacs",
+  "less",
+  "more",
+  "top",
+  "htop",
+  "man",
+]);
+
+const SHELL_COMMANDS = new Set(["zsh", "bash", "sh", "fish"]);
+
+export type PaneBusyStatus = "idle" | "busy" | "agent";
+
+export function isPaneBusy(session: string, paneId: string): boolean {
+  const panes = listSessionPanes(session);
+  const pane = panes.find((p) => p.id === paneId);
+  if (!pane) return true;
+  const cmd = pane.currentCommand.toLowerCase();
+  if (SHELL_COMMANDS.has(cmd)) return false;
+  if (BUSY_COMMANDS.has(cmd)) return true;
+  return true; // unknown command — assume busy
+}
+
+export function getPaneBusyStatus(session: string, paneId: string): PaneBusyStatus {
+  const panes = listSessionPanes(session);
+  const pane = panes.find((p) => p.id === paneId);
+  if (!pane) return "busy";
+  const cmd = pane.currentCommand.toLowerCase();
+  if (cmd.startsWith("claude") || cmd.startsWith("codex")) return "agent";
+  if (SHELL_COMMANDS.has(cmd)) return "idle";
+  return "busy";
+}
+
+export function sendText(session: string, paneId: string, text: string): void {
+  tmux("send-keys", "-t", paneId, "-l", "--", text);
+}
+
+function sleepMs(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+export function sendCommand(session: string, paneId: string, command: string): boolean {
+  const status = getPaneBusyStatus(session, paneId);
+  try {
+    tmux("send-keys", "-t", paneId, "-l", "--", command);
+  } catch {
+    return false;
+  }
+  if (status === "agent") {
+    // Claude Code shows a [Pasted text] preview for long input (roughly >200 chars).
+    // Short commands land directly in the prompt — just need a brief delay for the
+    // TUI to register the input. Long commands trigger the paste preview which needs
+    // two Enters: one to confirm the preview, one to submit the prompt.
+    if (command.length < 200) {
+      sleepMs(150);
+    } else {
+      sleepMs(5000);
+      tmux("send-keys", "-t", paneId, "Enter");
+      sleepMs(2000);
+    }
+    tmux("send-keys", "-t", paneId, "Enter");
+    return true;
+  }
+  tmux("send-keys", "-t", paneId, "Enter");
+  return true;
+}
+
+export function openFileInEditor(session: string, paneId: string, filePath: string): void {
+  const editor = process.env.EDITOR ?? "vim";
+  sendCommand(session, paneId, `${editor} ${filePath}`);
+}
+
+export interface TargetOptions {
+  title?: string;
+  titlePattern?: string;
+  paneId?: string;
+  selfPaneId?: string;
+}
+
+export function resolveTarget(session: string, opts: TargetOptions): string | null {
+  if (opts.paneId) return opts.paneId;
+  if (opts.title) return findPaneByTitle(session, opts.title);
+  if (opts.titlePattern) return findPaneByPattern(session, opts.titlePattern);
+  if (opts.selfPaneId) return findAdjacentPane(session, opts.selfPaneId);
+  return null;
+}