tmux-ide 1.3.1 → 2.1.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);
+  });
+});