@creativeintelligence/abbie 0.1.4 → 0.1.6

package/src/cli/commands/windows/search.ts

@@ -1,219 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { capturePane } from "../../../lib/tmux/bridge.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import { redactLine } from "../../../lib/tmux/redaction.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface SearchMatch {
-  lineNo: number;
-  line: string;
-  context?: string[];
-}
-
-interface WindowMatch {
-  paneId: string;
-  ref: string;
-  session: string;
-  windowName: string;
-  cwd: string;
-  matches: SearchMatch[];
-}
-
-interface SearchResult {
-  tmuxRunning: boolean;
-  query: string;
-  totalMatches: number;
-  windows: WindowMatch[];
-}
-
-function abbreviateHome(path: string): string {
-  const home = process.env.HOME;
-  if (!home) return path;
-  if (path === home) return "~";
-  if (path.startsWith(`${home}/`)) return `~/${path.slice(home.length + 1)}`;
-  return path;
-}
-
-function paneRef(window: windows.WindowInfo): string {
-  return `${window.session}:${window.window}.${window.pane}`;
-}
-
-export default class WindowsSearchCommand extends BaseCommand {
-  static override summary = "Search scrollback content across all tmux panes";
-  static hidden = false;
-
-  static override description =
-    "Searches terminal scrollback across all tmux panes for a pattern. " +
-    "Uses tmux capture-pane to read scrollback history (up to 10,000 lines per pane).";
-
-  static override examples = [
-    '$ abbie windows search "spatial"',
-    '$ abbie windows search "TODO" --context 3',
-    '$ abbie windows search "error" --session 2 --lines 5000',
-    '$ abbie windows search "ARBOR-123" --json',
-  ];
-
-  static override args = {
-    query: Args.string({
-      description: "Search pattern (case-insensitive regex)",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      char: "s",
-      description: "Filter to specific tmux session",
-    }),
-    context: Flags.integer({
-      char: "C",
-      description: "Lines of context around each match",
-      default: 1,
-    }),
-    lines: Flags.integer({
-      char: "n",
-      description: "Maximum scrollback lines to search per pane",
-      default: 10000,
-    }),
-    redact: Flags.boolean({
-      description: "Enable redaction of sensitive content",
-      default: true,
-      allowNo: true,
-    }),
-    limit: Flags.integer({
-      char: "l",
-      description: "Maximum matches per pane",
-      default: 20,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(WindowsSearchCommand);
-    this.parsedFlags = flags;
-
-    const query = args.query;
-    const contextLines = Math.max(0, flags.context);
-    const maxLines = Math.max(100, flags.lines);
-    const maxMatchesPerPane = Math.max(1, flags.limit);
-
-    const tmuxRunning = await isRunning();
-    if (!tmuxRunning) {
-      const result: SearchResult = { tmuxRunning: false, query, totalMatches: 0, windows: [] };
-      if (!this.jsonEnabled?.()) {
-        this.log("tmux is not running");
-      }
-      return result;
-    }
-
-    // Get all panes
-    const states = await windows.inventory({
-      session: flags.session,
-      includeNvim: false,
-      includeAgent: false,
-      includeBuffers: false,
-    });
-
-    let pattern: RegExp;
-    try {
-      pattern = new RegExp(query, "i");
-    } catch {
-      this.error(`Invalid regex pattern: ${query}`);
-    }
-
-    const windowMatches: WindowMatch[] = [];
-    let totalMatches = 0;
-
-    // Search each pane's scrollback
-    for (const state of states) {
-      const w = state.window;
-      const ref = paneRef(w);
-
-      // Capture scrollback via tmux (works for all panes, nvim or not)
-      const content = await capturePane(w.window, w.pane, {
-        lines: maxLines,
-        session: w.session,
-      });
-
-      if (!content) continue;
-
-      const lines = content.split("\n");
-      const matches: SearchMatch[] = [];
-
-      for (let i = 0; i < lines.length; i++) {
-        if (matches.length >= maxMatchesPerPane) break;
-
-        const line = lines[i];
-        if (!pattern.test(line)) continue;
-
-        const displayLine = flags.redact ? redactLine(line) : line;
-
-        // Gather context lines
-        const ctx: string[] = [];
-        if (contextLines > 0) {
-          const start = Math.max(0, i - contextLines);
-          const end = Math.min(lines.length - 1, i + contextLines);
-          for (let j = start; j <= end; j++) {
-            if (j === i) continue;
-            const ctxLine = flags.redact ? redactLine(lines[j]) : lines[j];
-            ctx.push(ctxLine);
-          }
-        }
-
-        matches.push({
-          lineNo: i + 1,
-          line: displayLine,
-          context: ctx.length > 0 ? ctx : undefined,
-        });
-      }
-
-      if (matches.length > 0) {
-        totalMatches += matches.length;
-        windowMatches.push({
-          paneId: w.paneId || ref,
-          ref,
-          session: w.session,
-          windowName: w.windowName,
-          cwd: abbreviateHome(w.cwd),
-          matches,
-        });
-      }
-    }
-
-    const result: SearchResult = {
-      tmuxRunning: true,
-      query,
-      totalMatches,
-      windows: windowMatches,
-    };
-
-    if (!this.jsonEnabled?.()) {
-      this.printText(result);
-    }
-
-    return result;
-  }
-
-  private printText(result: SearchResult): void {
-    if (result.totalMatches === 0) {
-      this.log(`No matches for "${result.query}"`);
-      return;
-    }
-
-    this.log(
-      `${result.totalMatches} match${result.totalMatches === 1 ? "" : "es"} across ${result.windows.length} window${result.windows.length === 1 ? "" : "s"}`,
-    );
-    this.log("");
-
-    for (const w of result.windows) {
-      this.log(`── ${w.paneId} (${w.windowName}) ${w.cwd} ──`);
-
-      for (const m of w.matches) {
-        this.log(`  ${String(m.lineNo).padStart(6)} │ ${m.line}`);
-      }
-
-      this.log("");
-    }
-  }
-}

package/src/cli/commands/windows/show.ts

@@ -1,188 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { getCurrentBufferInfo } from "../../../lib/nvim/remote.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface ShowResult {
-  tmuxRunning: boolean;
-  window: windows.WindowState | null;
-}
-
-function abbreviateHome(path: string): string {
-  const home = process.env.HOME;
-  if (!home) return path;
-  if (path === home) return "~";
-  if (path.startsWith(`${home}/`)) return `~/${path.slice(home.length + 1)}`;
-  return path;
-}
-
-function paneRef(window: windows.WindowInfo): string {
-  return `${window.session}:${window.window}.${window.pane}`;
-}
-
-function formatPathForDisplay(path: string, cwd: string): string {
-  if (!path) return path;
-  const normalizedCwd = cwd.endsWith("/") ? cwd : `${cwd}/`;
-  if (path.startsWith(normalizedCwd)) {
-    return path.slice(normalizedCwd.length);
-  }
-  return abbreviateHome(path);
-}
-
-function toBufferInfo(
-  buf: Awaited<ReturnType<typeof getCurrentBufferInfo>>,
-): windows.BufferInfo | null {
-  if (!buf) return null;
-  return {
-    name: buf.name,
-    path: buf.name,
-    modified: buf.modified,
-    filetype: buf.filetype,
-    lineCount: 0,
-    cursor: buf.cursor,
-  };
-}
-
-export default class WindowsShowCommand extends BaseCommand {
-  static override summary = "Show detailed window state";
-  static hidden = false;
-
-  static override examples = [
-    "$ abbie windows show",
-    "$ abbie windows show %3",
-    "$ abbie windows show work:0.0",
-    "$ abbie windows show --with-buffers",
-    "$ abbie windows show --json",
-  ];
-
-  static override args = {
-    ref: Args.string({
-      description: "Pane ID (e.g. %3) or session:window.pane (e.g. work:0.0)",
-      required: false,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "with-buffers": Flags.boolean({
-      description: "Include all buffers (expensive)",
-      default: false,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(WindowsShowCommand);
-    this.parsedFlags = flags;
-
-    const tmuxRunning = await isRunning();
-    if (!tmuxRunning) {
-      const result: ShowResult = { tmuxRunning: false, window: null };
-      if (!this.jsonEnabled?.()) {
-        this.log("tmux is not running");
-      }
-      return result;
-    }
-
-    const state = args.ref
-      ? await windows.getWindowState(args.ref, {
-          includeNvim: true,
-          includeAgent: true,
-          includeBuffers: flags["with-buffers"],
-        })
-      : await windows.getFocusedWindow({
-          includeNvim: true,
-          includeAgent: true,
-          includeBuffers: flags["with-buffers"],
-        });
-
-    let enriched = state;
-    if (enriched?.nvim?.available && enriched.nvim.serverAddr && !enriched.nvim.currentBuffer) {
-      const buf = await getCurrentBufferInfo(enriched.nvim.serverAddr);
-      const converted = toBufferInfo(buf);
-      if (converted) {
-        enriched = {
-          ...enriched,
-          nvim: {
-            ...enriched.nvim,
-            currentBuffer: converted,
-          },
-        };
-      }
-    }
-
-    const result: ShowResult = { tmuxRunning: true, window: enriched };
-
-    if (!this.jsonEnabled?.()) {
-      this.printText(result, flags);
-    }
-
-    return result;
-  }
-
-  private printText(result: ShowResult, flags: { "with-buffers": boolean }): void {
-    const state = result.window;
-    if (!state) {
-      this.log("Window not found");
-      return;
-    }
-
-    const id = state.window.paneId || paneRef(state.window);
-    const ref = paneRef(state.window);
-
-    this.log(`WINDOW ${id} (${ref})`);
-    this.log(`Session:  ${state.window.session}`);
-    this.log(`Window:   ${state.window.window} (${state.window.windowName})`);
-    this.log(`Pane:     ${state.window.pane} (${state.window.active ? "active" : "inactive"})`);
-    this.log(`CWD:      ${abbreviateHome(state.window.cwd)}`);
-    this.log(`CMD:      ${state.window.title}`);
-    this.log(`Size:     ${state.window.size.cols}x${state.window.size.rows}`);
-
-    this.log("");
-    this.log("NVIM");
-    if (state.nvim?.available) {
-      this.log(`PID:      ${state.nvim.pid ?? "-"}`);
-      this.log(
-        `Server:   ${state.nvim.serverAddr ?? "-"}${state.nvim.discoveryMethod ? ` (${state.nvim.discoveryMethod})` : ""}`,
-      );
-
-      const buf = state.nvim.currentBuffer;
-      if (buf) {
-        const cursor = buf.cursor ? `${buf.cursor.line}:${buf.cursor.col}` : "-";
-        const displayPath = formatPathForDisplay(buf.path, state.window.cwd);
-        const mod = buf.modified ? " [modified]" : "";
-        this.log(`Buffer:   ${displayPath} (${buf.filetype || "unknown"})${mod}`);
-        this.log(`Cursor:   ${cursor}`);
-      } else {
-        this.log("Buffer:   -");
-      }
-
-      if (flags["with-buffers"] && state.buffers.length > 0) {
-        this.log("");
-        this.log("BUFFERS");
-        for (const b of state.buffers) {
-          const displayPath = formatPathForDisplay(b.path, state.window.cwd);
-          const mod = b.modified ? " [modified]" : "";
-          this.log(`- ${displayPath} (${b.filetype || "unknown"})${mod}`);
-        }
-      }
-    } else {
-      this.log("Not available");
-    }
-
-    this.log("");
-    this.log("AGENT");
-    if (state.agent) {
-      this.log(`Type:     ${state.agent.type}`);
-      this.log(`PID:      ${state.agent.pid}`);
-      if (state.agent.sessionId) {
-        this.log(`Session:  ${state.agent.sessionId}`);
-      }
-      if (state.agent.issue) {
-        this.log(`Issue:    ${state.agent.issue}`);
-      }
-    } else {
-      this.log("None");
-    }
-  }
-}

package/src/cli/commands/windows/watch.ts

@@ -1,262 +0,0 @@
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { Flags } from "@oclif/core";
-import { isRunning } from "../../../lib/tmux/index.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-function paneRef(window: windows.WindowInfo): string {
-  return `${window.session}:${window.window}.${window.pane}`;
-}
-
-function stableWindowId(state: windows.WindowState): string {
-  return state.window.paneId || paneRef(state.window);
-}
-
-function sortWindows(states: windows.WindowState[]): windows.WindowState[] {
-  return [...states].sort((a, b) => {
-    if (a.window.session !== b.window.session)
-      return a.window.session.localeCompare(b.window.session);
-    if (a.window.window !== b.window.window) return a.window.window - b.window.window;
-    return a.window.pane - b.window.pane;
-  });
-}
-
-function hashWindows(states: windows.WindowState[]): string {
-  const stable = states.map((s) => ({
-    id: stableWindowId(s),
-    session: s.window.session,
-    window: s.window.window,
-    windowName: s.window.windowName,
-    pane: s.window.pane,
-    cwd: s.window.cwd,
-    title: s.window.title,
-    active: s.window.active,
-    cols: s.window.size.cols,
-    rows: s.window.size.rows,
-    hasNvim: s.nvim?.available ?? false,
-    nvimPid: s.nvim?.pid ?? null,
-    agentType: s.agent?.type ?? null,
-    agentPid: s.agent?.pid ?? null,
-  }));
-
-  return createHash("sha1").update(JSON.stringify(stable)).digest("hex");
-}
-
-function isControlModeNotification(line: string): boolean {
-  if (!line.startsWith("%")) return false;
-  if (line.startsWith("%begin")) return false;
-  if (line.startsWith("%end")) return false;
-  if (line.startsWith("%error")) return false;
-  return true;
-}
-
-export default class WindowsWatchCommand extends BaseCommand {
-  static override summary = "Watch workspace windows (tmux panes) and stream updates";
-  static hidden = false;
-
-  static override examples = [
-    "$ abbie windows watch --ndjson --quiet",
-    "$ abbie windows watch --ndjson --quiet --debounce-ms 100",
-    "$ abbie windows watch --ndjson --quiet --no-with-nvim",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      char: "s",
-      description: "Filter to specific tmux session",
-    }),
-    active: Flags.boolean({
-      description: "Only show active panes",
-      default: false,
-    }),
-    "with-nvim": Flags.boolean({
-      description: "Include nvim state",
-      default: true,
-      allowNo: true,
-    }),
-    "with-agent": Flags.boolean({
-      description: "Include agent detection",
-      default: true,
-      allowNo: true,
-    }),
-    "debounce-ms": Flags.integer({
-      description: "Debounce inventory refresh triggered by tmux notifications (ms)",
-      default: 75,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { flags } = await this.parse(WindowsWatchCommand);
-    this.parsedFlags = flags;
-
-    if (!this.ndjsonEnabled()) {
-      this.error("windows watch is a streaming command; run with --ndjson (and usually --quiet)");
-    }
-
-    const tmuxRunning = await isRunning();
-    if (!tmuxRunning) {
-      const evt = {
-        type: "windows.status",
-        at: new Date().toISOString(),
-        reason: "initial",
-        tmuxRunning: false,
-        message: "tmux is not running",
-      };
-      this.outputNdjson([evt]);
-      return evt;
-    }
-
-    const includeNvim = flags["with-nvim"];
-    const includeAgent = flags["with-agent"];
-    const onlyActive = flags.active;
-    const debounceMs = Math.max(0, flags["debounce-ms"]);
-
-    let lastHash: string | null = null;
-    let pendingTimer: NodeJS.Timeout | null = null;
-    let lastReason = "tmux";
-    let stopped = false;
-
-    const emitInventory = async (reason: string) => {
-      if (stopped) return;
-
-      const states = await windows.inventory({
-        session: flags.session,
-        includeNvim,
-        includeAgent,
-        includeBuffers: false,
-      });
-
-      const filtered = onlyActive ? states.filter((s) => s.window.active) : states;
-      const sorted = sortWindows(filtered);
-      const hash = hashWindows(sorted);
-
-      if (reason !== "initial" && lastHash === hash) return;
-      lastHash = hash;
-
-      const evt = {
-        type: "windows.update",
-        at: new Date().toISOString(),
-        reason,
-        tmuxRunning: true,
-        windows: sorted,
-        hash,
-      };
-
-      this.outputNdjson([evt]);
-    };
-
-    const scheduleInventory = (reason: string) => {
-      lastReason = reason;
-      if (pendingTimer) return;
-      pendingTimer = setTimeout(async () => {
-        pendingTimer = null;
-        try {
-          await emitInventory(lastReason);
-        } catch (err) {
-          // Streaming command: emit a status event rather than crashing the process.
-          const message = err instanceof Error ? err.message : String(err);
-          const evt = {
-            type: "windows.status",
-            at: new Date().toISOString(),
-            reason: "tmux",
-            tmuxRunning: true,
-            message,
-          };
-          this.outputNdjson([evt]);
-        }
-      }, debounceMs);
-    };
-
-    // Initial inventory
-    await emitInventory("initial");
-
-    // tmux control-mode client: uses notifications to trigger refresh without polling.
-    const tmux = spawn("tmux", ["-C"], { stdio: ["pipe", "pipe", "pipe"] });
-
-    // Kick control-mode to ensure it's alive; output is ignored by our notification filter.
-    try {
-      tmux.stdin.write("refresh-client -S\n");
-    } catch {
-      // ignore
-    }
-
-    const stop = (reason: string) => {
-      if (stopped) return;
-      stopped = true;
-
-      if (pendingTimer) {
-        clearTimeout(pendingTimer);
-        pendingTimer = null;
-      }
-
-      try {
-        tmux.kill("SIGTERM");
-      } catch {
-        // ignore
-      }
-
-      const evt = {
-        type: "windows.status",
-        at: new Date().toISOString(),
-        reason,
-        tmuxRunning: false,
-        message: "stopped",
-      };
-      this.outputNdjson([evt]);
-    };
-
-    const onSigint = () => stop("tmux-exit");
-    const onSigterm = () => stop("tmux-exit");
-    process.on("SIGINT", onSigint);
-    process.on("SIGTERM", onSigterm);
-
-    return await new Promise((resolve) => {
-      let buffer = "";
-
-      tmux.stdout.on("data", (data) => {
-        buffer += data.toString();
-
-        for (;;) {
-          const idx = buffer.indexOf("\n");
-          if (idx === -1) break;
-
-          const line = buffer.slice(0, idx).trimEnd();
-          buffer = buffer.slice(idx + 1);
-
-          if (!line) continue;
-          if (isControlModeNotification(line)) {
-            scheduleInventory("tmux");
-          }
-        }
-      });
-
-      tmux.stderr.on("data", (data) => {
-        const message = data.toString().trim();
-        if (!message) return;
-        const evt = {
-          type: "windows.status",
-          at: new Date().toISOString(),
-          reason: "tmux",
-          tmuxRunning: true,
-          message,
-        };
-        this.outputNdjson([evt]);
-      });
-
-      tmux.on("exit", () => {
-        stop("tmux-exit");
-        process.off("SIGINT", onSigint);
-        process.off("SIGTERM", onSigterm);
-        resolve({
-          type: "windows.status",
-          at: new Date().toISOString(),
-          reason: "tmux-exit",
-          tmuxRunning: false,
-          message: "tmux exited",
-        });
-      });
-    });
-  }
-}