pi-teams 0.5.2 → 0.7.3

package/src/adapters/iterm2-adapter.ts

@@ -0,0 +1,158 @@
+/**
+ * iTerm2 Terminal Adapter
+ * 
+ * Implements the TerminalAdapter interface for iTerm2 terminal emulator.
+ * Uses AppleScript for all operations.
+ */
+
+import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
+
+/**
+ * Context needed for iTerm2 spawning (tracks last pane for layout)
+ */
+export interface Iterm2SpawnContext {
+  /** ID of the last spawned session, used for layout decisions */
+  lastSessionId?: string;
+}
+
+export class Iterm2Adapter implements TerminalAdapter {
+  readonly name = "iTerm2";
+  private spawnContext: Iterm2SpawnContext = {};
+
+  detect(): boolean {
+    // iTerm2 is available if TERM_PROGRAM is iTerm.app and not in tmux/zellij
+    return process.env.TERM_PROGRAM === "iTerm.app" && !process.env.TMUX && !process.env.ZELLIJ;
+  }
+
+  spawn(options: SpawnOptions): string {
+    const envStr = Object.entries(options.env)
+      .filter(([k]) => k.startsWith("PI_"))
+      .map(([k, v]) => `${k}=${v}`)
+      .join(" ");
+    
+    const itermCmd = `cd '${options.cwd}' && ${envStr} ${options.command}`;
+    const escapedCmd = itermCmd.replace(/"/g, '\\"');
+
+    let script: string;
+    
+    if (!this.spawnContext.lastSessionId) {
+      // First teammate: split current session vertically (side-by-side)
+      script = `tell application "iTerm2"
+  tell current session of current window
+    set newSession to split vertically with default profile
+    tell newSession
+      write text "${escapedCmd}"
+      return id
+    end tell
+  end tell
+end tell`;
+    } else {
+      // Subsequent teammate: split the last teammate's session horizontally (stacking)
+      script = `tell application "iTerm2"
+  repeat with aWindow in windows
+    repeat with aTab in tabs of aWindow
+      repeat with aSession in sessions of aTab
+        if id of aSession is "${this.spawnContext.lastSessionId}" then
+          tell aSession
+            set newSession to split horizontally with default profile
+            tell newSession
+              write text "${escapedCmd}"
+              return id
+            end tell
+          end tell
+        end if
+      end repeat
+    end repeat
+  end repeat
+end tell`;
+    }
+
+    const result = execCommand("osascript", ["-e", script]);
+    
+    if (result.status !== 0) {
+      throw new Error(`osascript failed with status ${result.status}: ${result.stderr}`);
+    }
+
+    const sessionId = result.stdout.toString().trim();
+    this.spawnContext.lastSessionId = sessionId;
+    
+    return `iterm_${sessionId}`;
+  }
+
+  kill(paneId: string): void {
+    if (!paneId || !paneId.startsWith("iterm_")) {
+      return; // Not an iTerm2 pane
+    }
+
+    const itermId = paneId.replace("iterm_", "");
+    const script = `tell application "iTerm2"
+  repeat with aWindow in windows
+    repeat with aTab in tabs of aWindow
+      repeat with aSession in sessions of aTab
+        if id of aSession is "${itermId}" then
+          close aSession
+          return "Closed"
+        end if
+      end repeat
+    end repeat
+  end repeat
+end tell`;
+
+    try {
+      execCommand("osascript", ["-e", script]);
+    } catch {
+      // Ignore errors - session may already be closed
+    }
+  }
+
+  isAlive(paneId: string): boolean {
+    if (!paneId || !paneId.startsWith("iterm_")) {
+      return false; // Not an iTerm2 pane
+    }
+
+    const itermId = paneId.replace("iterm_", "");
+    const script = `tell application "iTerm2"
+  repeat with aWindow in windows
+    repeat with aTab in tabs of aWindow
+      repeat with aSession in sessions of aTab
+        if id of aSession is "${itermId}" then
+          return "Alive"
+        end if
+      end repeat
+    end repeat
+  end repeat
+end tell`;
+
+    try {
+      const result = execCommand("osascript", ["-e", script]);
+      return result.stdout.includes("Alive");
+    } catch {
+      return false;
+    }
+  }
+
+  setTitle(title: string): void {
+    try {
+      execCommand("osascript", [
+        "-e",
+        `tell application "iTerm2" to tell current session of current window to set name to "${title}"`
+      ]);
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  /**
+   * Set the spawn context (used to restore state when needed)
+   */
+  setSpawnContext(context: Iterm2SpawnContext): void {
+    this.spawnContext = context;
+  }
+
+  /**
+   * Get current spawn context (useful for persisting state)
+   */
+  getSpawnContext(): Iterm2SpawnContext {
+    return { ...this.spawnContext };
+  }
+}

package/src/adapters/terminal-registry.ts

@@ -0,0 +1,92 @@
+/**
+ * Terminal Registry
+ * 
+ * Manages terminal adapters and provides automatic selection based on
+ * the current environment.
+ */
+
+import { TerminalAdapter } from "../utils/terminal-adapter";
+import { TmuxAdapter } from "./tmux-adapter";
+import { Iterm2Adapter } from "./iterm2-adapter";
+import { ZellijAdapter } from "./zellij-adapter";
+
+/**
+ * Available terminal adapters, ordered by priority
+ */
+const adapters: TerminalAdapter[] = [
+  new TmuxAdapter(),
+  new Iterm2Adapter(),
+  new ZellijAdapter(),
+];
+
+/**
+ * Cached detected adapter
+ */
+let cachedAdapter: TerminalAdapter | null = null;
+
+/**
+ * Detect and return the appropriate terminal adapter for the current environment.
+ * 
+ * Detection order (first match wins):
+ * 1. tmux - if TMUX env is set
+ * 2. iTerm2 - if TERM_PROGRAM=iTerm.app and not in tmux/zellij
+ * 3. Zellij - if ZELLIJ env is set and not in tmux
+ * 
+ * @returns The detected terminal adapter, or null if none detected
+ */
+export function getTerminalAdapter(): TerminalAdapter | null {
+  if (cachedAdapter) {
+    return cachedAdapter;
+  }
+
+  for (const adapter of adapters) {
+    if (adapter.detect()) {
+      cachedAdapter = adapter;
+      return adapter;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get a specific terminal adapter by name.
+ * 
+ * @param name - The adapter name (e.g., "tmux", "iTerm2", "zellij")
+ * @returns The adapter instance, or undefined if not found
+ */
+export function getAdapterByName(name: string): TerminalAdapter | undefined {
+  return adapters.find(a => a.name === name);
+}
+
+/**
+ * Get all available adapters.
+ * 
+ * @returns Array of all registered adapters
+ */
+export function getAllAdapters(): TerminalAdapter[] {
+  return [...adapters];
+}
+
+/**
+ * Clear the cached adapter (useful for testing or environment changes)
+ */
+export function clearAdapterCache(): void {
+  cachedAdapter = null;
+}
+
+/**
+ * Set a specific adapter (useful for testing or forced selection)
+ */
+export function setAdapter(adapter: TerminalAdapter): void {
+  cachedAdapter = adapter;
+}
+
+/**
+ * Check if any terminal adapter is available.
+ * 
+ * @returns true if a terminal adapter was detected
+ */
+export function hasTerminalAdapter(): boolean {
+  return getTerminalAdapter() !== null;
+}

package/src/adapters/tmux-adapter.ts

@@ -0,0 +1,77 @@
+/**
+ * Tmux Terminal Adapter
+ * 
+ * Implements the TerminalAdapter interface for tmux terminal multiplexer.
+ */
+
+import { execSync } from "node:child_process";
+import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
+
+export class TmuxAdapter implements TerminalAdapter {
+  readonly name = "tmux";
+
+  detect(): boolean {
+    // tmux is available if TMUX environment variable is set
+    return !!process.env.TMUX;
+  }
+
+  spawn(options: SpawnOptions): string {
+    const envArgs = Object.entries(options.env)
+      .filter(([k]) => k.startsWith("PI_"))
+      .map(([k, v]) => `${k}=${v}`);
+
+    const tmuxArgs = [
+      "split-window",
+      "-h", "-dP",
+      "-F", "#{pane_id}",
+      "-c", options.cwd,
+      "env", ...envArgs,
+      "sh", "-c", options.command
+    ];
+
+    const result = execCommand("tmux", tmuxArgs);
+    
+    if (result.status !== 0) {
+      throw new Error(`tmux spawn failed with status ${result.status}: ${result.stderr}`);
+    }
+
+    // Apply layout after spawning
+    execCommand("tmux", ["set-window-option", "main-pane-width", "60%"]);
+    execCommand("tmux", ["select-layout", "main-vertical"]);
+
+    return result.stdout.trim();
+  }
+
+  kill(paneId: string): void {
+    if (!paneId || paneId.startsWith("iterm_") || paneId.startsWith("zellij_")) {
+      return; // Not a tmux pane
+    }
+    
+    try {
+      execCommand("tmux", ["kill-pane", "-t", paneId.trim()]);
+    } catch {
+      // Ignore errors - pane may already be dead
+    }
+  }
+
+  isAlive(paneId: string): boolean {
+    if (!paneId || paneId.startsWith("iterm_") || paneId.startsWith("zellij_")) {
+      return false; // Not a tmux pane
+    }
+
+    try {
+      execSync(`tmux has-session -t ${paneId}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  setTitle(title: string): void {
+    try {
+      execCommand("tmux", ["select-pane", "-T", title]);
+    } catch {
+      // Ignore errors
+    }
+  }
+}

package/src/adapters/zellij-adapter.ts

@@ -0,0 +1,62 @@
+/**
+ * Zellij Terminal Adapter
+ * 
+ * Implements the TerminalAdapter interface for Zellij terminal multiplexer.
+ * Note: Zellij uses --close-on-exit, so explicit kill is not needed.
+ */
+
+import { TerminalAdapter, SpawnOptions, execCommand } from "../utils/terminal-adapter";
+
+export class ZellijAdapter implements TerminalAdapter {
+  readonly name = "zellij";
+
+  detect(): boolean {
+    // Zellij is available if ZELLIJ env is set and not in tmux
+    return !!process.env.ZELLIJ && !process.env.TMUX;
+  }
+
+  spawn(options: SpawnOptions): string {
+    const zellijArgs = [
+      "run",
+      "--name", options.name,
+      "--cwd", options.cwd,
+      "--close-on-exit",
+      "--",
+      "env",
+      ...Object.entries(options.env)
+        .filter(([k]) => k.startsWith("PI_"))
+        .map(([k, v]) => `${k}=${v}`),
+      "sh", "-c", options.command
+    ];
+
+    const result = execCommand("zellij", zellijArgs);
+    
+    if (result.status !== 0) {
+      throw new Error(`zellij spawn failed with status ${result.status}: ${result.stderr}`);
+    }
+
+    // Zellij doesn't return a pane ID, so we create a synthetic one
+    return `zellij_${options.name}`;
+  }
+
+  kill(_paneId: string): void {
+    // Zellij uses --close-on-exit, so panes close automatically
+    // when the process exits. No explicit kill needed.
+  }
+
+  isAlive(paneId: string): boolean {
+    // Zellij doesn't have a straightforward way to check if a pane is alive
+    // For now, we assume alive if it's a zellij pane ID
+    if (!paneId || !paneId.startsWith("zellij_")) {
+      return false;
+    }
+    
+    // Could potentially use `zellij list-sessions` or similar in the future
+    return true;
+  }
+
+  setTitle(_title: string): void {
+    // Zellij pane titles are set via --name at spawn time
+    // No runtime title changing supported
+  }
+}

package/src/utils/hooks.test.ts

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import { runHook } from "./hooks";
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+
+describe("runHook", () => {
+  const hooksDir = path.join(process.cwd(), ".pi", "team-hooks");
+
+  beforeAll(() => {
+    if (!fs.existsSync(hooksDir)) {
+      fs.mkdirSync(hooksDir, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    // Optional: Clean up created scripts
+    const files = ["success_hook.sh", "fail_hook.sh"];
+    files.forEach(f => {
+      const p = path.join(hooksDir, f);
+      if (fs.existsSync(p)) fs.unlinkSync(p);
+    });
+  });
+
+  it("should return true if hook script does not exist", async () => {
+    const result = await runHook("test_team", "non_existent_hook", { data: "test" });
+    expect(result).toBe(true);
+  });
+
+  it("should return true if hook script succeeds", async () => {
+    const hookName = "success_hook";
+    const scriptPath = path.join(hooksDir, `${hookName}.sh`);
+    
+    // Create a simple script that exits with 0
+    fs.writeFileSync(scriptPath, "#!/bin/bash\nexit 0", { mode: 0o755 });
+
+    const result = await runHook("test_team", hookName, { data: "test" });
+    expect(result).toBe(true);
+  });
+
+  it("should return false if hook script fails", async () => {
+    const hookName = "fail_hook";
+    const scriptPath = path.join(hooksDir, `${hookName}.sh`);
+    
+    // Create a simple script that exits with 1
+    fs.writeFileSync(scriptPath, "#!/bin/bash\nexit 1", { mode: 0o755 });
+
+    // Mock console.error to avoid noise in test output
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const result = await runHook("test_team", hookName, { data: "test" });
+    expect(result).toBe(false);
+
+    consoleSpy.mockRestore();
+  });
+
+  it("should pass the payload to the hook script", async () => {
+    const hookName = "payload_hook";
+    const scriptPath = path.join(hooksDir, `${hookName}.sh`);
+    const outputFile = path.join(hooksDir, "payload_output.txt");
+
+    // Create a script that writes its first argument to a file
+    fs.writeFileSync(scriptPath, `#!/bin/bash\necho "$1" > "${outputFile}"`, { mode: 0o755 });
+
+    const payload = { key: "value", "special'char": true };
+    const result = await runHook("test_team", hookName, payload);
+
+    expect(result).toBe(true);
+    const output = fs.readFileSync(outputFile, "utf-8").trim();
+    expect(JSON.parse(output)).toEqual(payload);
+
+    // Clean up
+    fs.unlinkSync(scriptPath);
+    if (fs.existsSync(outputFile)) fs.unlinkSync(outputFile);
+  });
+});

package/src/utils/hooks.ts

@@ -0,0 +1,35 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs";
+import path from "node:path";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Runs a hook script asynchronously if it exists.
+ * Hooks are located in .pi/team-hooks/{hookName}.sh relative to the CWD.
+ *
+ * @param teamName The name of the team.
+ * @param hookName The name of the hook to run (e.g., 'task_completed').
+ * @param payload The payload to pass to the hook script as the first argument.
+ * @returns true if the hook doesn't exist or executes successfully; false otherwise.
+ */
+export async function runHook(teamName: string, hookName: string, payload: any): Promise<boolean> {
+  const hookPath = path.join(process.cwd(), ".pi", "team-hooks", `${hookName}.sh`);
+
+  if (!fs.existsSync(hookPath)) {
+    return true;
+  }
+
+  try {
+    const payloadStr = JSON.stringify(payload);
+    // Use execFile: More secure (no shell interpolation) and asynchronous
+    await execFileAsync(hookPath, [payloadStr], {
+      env: { ...process.env, PI_TEAM: teamName },
+    });
+    return true;
+  } catch (error) {
+    console.error(`Hook ${hookName} failed:`, error);
+    return false;
+  }
+}

package/src/utils/lock.test.ts

@@ -1,3 +1,4 @@
+// Project: pi-teams
 import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
 import fs from "node:fs";
 import path from "node:path";

package/src/utils/lock.ts

@@ -1,10 +1,12 @@
+// Project: pi-teams
 import fs from "node:fs";
 import path from "node:path";
 
+const LOCK_TIMEOUT = 5000; // 5 seconds of retrying
+const STALE_LOCK_TIMEOUT = 30000; // 30 seconds for a lock to be considered stale
+
 export async function withLock<T>(lockPath: string, fn: () => Promise<T>, retries: number = 50): Promise<T> {
   const lockFile = `${lockPath}.lock`;
-  const LOCK_TIMEOUT = 5000; // 5 seconds of retrying
-  const STALE_LOCK_TIMEOUT = 30000; // 30 seconds for a lock to be considered stale
   
   while (retries > 0) {
     try {

package/src/utils/messaging.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { appendMessage, readInbox, sendPlainMessage } from "./messaging";
+import { appendMessage, readInbox, sendPlainMessage, broadcastMessage } from "./messaging";
 import * as paths from "./paths";
 
 // Mock the paths to use a temporary directory
@@ -18,6 +18,9 @@ describe("Messaging Utilities", () => {
       return path.join(testDir, "inboxes", `${agentName}.json`);
     });
     vi.spyOn(paths, "teamDir").mockReturnValue(testDir);
+    vi.spyOn(paths, "configPath").mockImplementation((teamName) => {
+      return path.join(testDir, "config.json");
+    });
   });
 
   afterEach(() => {
@@ -66,4 +69,36 @@ describe("Messaging Utilities", () => {
     expect(all.length).toBe(2);
     expect(all.every(m => m.read)).toBe(true);
   });
+
+  it("should broadcast message to all members except the sender", async () => {
+    // Setup team config
+    const config = {
+      name: "test-team",
+      members: [
+        { name: "sender" },
+        { name: "member1" },
+        { name: "member2" }
+      ]
+    };
+    const configFilePath = path.join(testDir, "config.json");
+    fs.writeFileSync(configFilePath, JSON.stringify(config));
+    
+    await broadcastMessage("test-team", "sender", "broadcast text", "summary");
+
+    // Check member1's inbox
+    const inbox1 = await readInbox("test-team", "member1", false, false);
+    expect(inbox1.length).toBe(1);
+    expect(inbox1[0].text).toBe("broadcast text");
+    expect(inbox1[0].from).toBe("sender");
+
+    // Check member2's inbox
+    const inbox2 = await readInbox("test-team", "member2", false, false);
+    expect(inbox2.length).toBe(1);
+    expect(inbox2[0].text).toBe("broadcast text");
+    expect(inbox2[0].from).toBe("sender");
+
+    // Check sender's inbox (should be empty)
+    const inboxSender = await readInbox("test-team", "sender", false, false);
+    expect(inboxSender.length).toBe(0);
+  });
 });

package/src/utils/messaging.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 import { InboxMessage } from "./models";
 import { withLock } from "./lock";
 import { inboxPath } from "./paths";
+import { readConfig } from "./teams";
 
 export function nowIso(): string {
   return new Date().toISOString();
@@ -71,3 +72,37 @@ export async function sendPlainMessage(
   };
   await appendMessage(teamName, toName, msg);
 }
+
+/**
+ * Broadcasts a message to all team members except the sender.
+ * @param teamName The name of the team
+ * @param fromName The name of the sender
+ * @param text The message text
+ * @param summary A short summary of the message
+ * @param color An optional color for the message
+ */
+export async function broadcastMessage(
+  teamName: string,
+  fromName: string,
+  text: string,
+  summary: string,
+  color?: string
+) {
+  const config = await readConfig(teamName);
+
+  // Create an array of delivery promises for all members except the sender
+  const deliveryPromises = config.members
+    .filter((member) => member.name !== fromName)
+    .map((member) => sendPlainMessage(teamName, fromName, member.name, text, summary, color));
+
+  // Execute deliveries in parallel and wait for all to settle
+  const results = await Promise.allSettled(deliveryPromises);
+
+  // Log failures for diagnostics
+  const failures = results.filter((r): r is PromiseRejectedResult => r.status === "rejected");
+  if (failures.length > 0) {
+    console.error(`Broadcast partially failed: ${failures.length} messages could not be delivered.`);
+    // Optionally log individual errors
+    failures.forEach((f) => console.error(`- Delivery error:`, f.reason));
+  }
+}

package/src/utils/models.ts

@@ -9,6 +9,7 @@ export interface Member {
   subscriptions: any[];
   prompt?: string;
   color?: string;
+  thinking?: "off" | "minimal" | "low" | "medium" | "high";
   planModeRequired?: boolean;
   backendType?: string;
   isActive?: boolean;
@@ -29,7 +30,9 @@ export interface TaskFile {
   subject: string;
   description: string;
   activeForm?: string;
-  status: "pending" | "in_progress" | "completed" | "deleted";
+  status: "pending" | "planning" | "in_progress" | "completed" | "deleted";
+  plan?: string;
+  planFeedback?: string;
   blocks: string[];
   blockedBy: string[];
   owner?: string;