@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/lib/nvim/discovery.ts

@@ -1,181 +0,0 @@
-/**
- * Socket discovery for Neovim instances.
- * Finds nvim processes and discovers their RPC server addresses.
- */
-
-import { spawn } from "node:child_process";
-import { findDeepestDescendant, isNvimProcess, type ProcessInfo } from "../process/snapshot.js";
-
-export interface NvimInstance {
-  pid: number;
-  serverAddr: string | null;
-  discoveryMethod: "argv" | "lsof" | null;
-}
-
-/**
- * Execute a command and return stdout.
- */
-async function exec(command: string, args: string[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout);
-      } else {
-        reject(new Error(`${command} failed with code ${code}`));
-      }
-    });
-
-    proc.on("error", reject);
-  });
-}
-
-/**
- * Find the nvim PID running under a pane (prefer deepest nested).
- */
-export function findNvimPidForWindow(
-  panePid: number,
-  snapshot: Map<number, ProcessInfo>,
-  tree: Map<number, number[]>,
-): number | null {
-  return findDeepestDescendant(panePid, tree, snapshot, isNvimProcess);
-}
-
-/**
- * Parse --listen argument from nvim command line.
- * Handles both `--listen <addr>` and `--listen=<addr>` forms.
- */
-function parseListenFromArgs(args: string): string | null {
-  // Match --listen followed by space and address
-  const spaceMatch = args.match(/--listen\s+([^\s]+)/);
-  if (spaceMatch) return spaceMatch[1];
-
-  // Match --listen=address
-  const eqMatch = args.match(/--listen=([^\s]+)/);
-  if (eqMatch) return eqMatch[1];
-
-  return null;
-}
-
-/**
- * Discover nvim server address from process argv.
- * This is the most reliable method when nvim was started with --listen.
- */
-export function discoverFromArgv(
-  nvimPid: number,
-  snapshot: Map<number, ProcessInfo>,
-): string | null {
-  const info = snapshot.get(nvimPid);
-  if (!info) return null;
-
-  return parseListenFromArgs(info.args);
-}
-
-/**
- * Discover nvim server address using lsof to find UNIX sockets.
- * Fallback when --listen wasn't used but nvim created a socket.
- */
-export async function discoverFromLsof(nvimPid: number): Promise<string | null> {
-  try {
-    // lsof -a -p PID -U shows UNIX sockets for the process
-    const output = await exec("lsof", ["-a", "-p", String(nvimPid), "-U", "-F", "n"]);
-
-    // Parse lsof output - lines starting with 'n' contain the socket path
-    const lines = output.split("\n");
-    for (const line of lines) {
-      if (line.startsWith("n")) {
-        const path = line.slice(1); // Remove 'n' prefix
-
-        // Look for nvim-like socket paths
-        // Common patterns:
-        // - /tmp/nvim.USER/XXXXX/nvim.PID.0
-        // - /var/folders/.../nvim.USER/.../nvim.PID.0
-        // - ~/.local/state/nvim/...
-        if (
-          path.includes("nvim") &&
-          (path.startsWith("/tmp/") ||
-            path.startsWith("/var/folders/") ||
-            path.includes(".local/state/nvim") ||
-            path.includes("/run/"))
-        ) {
-          return path;
-        }
-      }
-    }
-  } catch {
-    // lsof failed, return null
-  }
-
-  return null;
-}
-
-/**
- * Discover the server address for an nvim PID.
- * Tries multiple strategies in order of reliability:
- * 1. Parse --listen from argv
- * 2. Find UNIX socket via lsof
- */
-export async function discoverNvimServerAddress(
-  nvimPid: number,
-  snapshot: Map<number, ProcessInfo>,
-): Promise<{ addr: string; method: "argv" | "lsof" } | null> {
-  // Strategy 1: Check argv for --listen
-  const argvAddr = discoverFromArgv(nvimPid, snapshot);
-  if (argvAddr) {
-    return { addr: argvAddr, method: "argv" };
-  }
-
-  // Strategy 2: Find UNIX socket via lsof
-  const lsofAddr = await discoverFromLsof(nvimPid);
-  if (lsofAddr) {
-    return { addr: lsofAddr, method: "lsof" };
-  }
-
-  return null;
-}
-
-/**
- * Get the nvim instance for a window (pane).
- * Combines process discovery and server address discovery.
- */
-export async function getNvimInstanceForWindow(
-  panePid: number,
-  snapshot: Map<number, ProcessInfo>,
-  tree: Map<number, number[]>,
-): Promise<NvimInstance | null> {
-  // Find nvim PID under the pane
-  const nvimPid = findNvimPidForWindow(panePid, snapshot, tree);
-  if (!nvimPid) {
-    return null;
-  }
-
-  // Discover server address
-  const discovery = await discoverNvimServerAddress(nvimPid, snapshot);
-
-  return {
-    pid: nvimPid,
-    serverAddr: discovery?.addr ?? null,
-    discoveryMethod: discovery?.method ?? null,
-  };
-}
-
-/**
- * Find all nvim instances in the process snapshot.
- */
-export function findAllNvimInstances(snapshot: Map<number, ProcessInfo>): number[] {
-  const nvimPids: number[] = [];
-
-  for (const [pid, info] of snapshot) {
-    if (isNvimProcess(info)) {
-      nvimPids.push(pid);
-    }
-  }
-
-  return nvimPids;
-}

package/src/lib/nvim/index.ts

@@ -1,28 +0,0 @@
-/**
- * Neovim integration module.
- * Provides RPC communication and socket discovery.
- */
-
-// Socket discovery
-export {
-  discoverFromArgv,
-  discoverFromLsof,
-  discoverNvimServerAddress,
-  findAllNvimInstances,
-  findNvimPidForWindow,
-  getNvimInstanceForWindow,
-  type NvimInstance,
-} from "./discovery.js";
-// RPC layer
-export {
-  getBufferLines,
-  getCurrentBuffer,
-  getCurrentBufferInfo,
-  getVisibleRange,
-  isServerReachable,
-  listBuffers,
-  type NvimBufferInfo,
-  remoteExpr,
-  remoteExprJson,
-  type WindowRange,
-} from "./remote.js";

package/src/lib/nvim/remote.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { isServerReachable } from "./remote.js";
-
-// Note: Full mocking of spawn is complex in bun:test.
-// These tests focus on integration behavior with actual nvim when available,
-// or graceful degradation when not.
-
-describe("nvim remote", () => {
-  describe("isServerReachable", () => {
-    it("returns false for non-existent server", async () => {
-      // Non-existent socket should return false
-      const result = await isServerReachable("/tmp/nonexistent-nvim-socket-12345.sock");
-      expect(result).toBe(false);
-    });
-
-    it("returns false for invalid address", async () => {
-      const result = await isServerReachable("");
-      expect(result).toBe(false);
-    });
-  });
-});

package/src/lib/nvim/remote.ts

@@ -1,184 +0,0 @@
-/**
- * Neovim RPC layer using nvim CLI (no msgpack dependency).
- * Uses `nvim --server <addr> --remote-expr <expr>` for communication.
- */
-
-import { spawn } from "node:child_process";
-
-/**
- * Execute a command and return stdout.
- */
-async function exec(
-  command: string,
-  args: string[],
-  options?: { timeout?: number },
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-  const { timeout = 5000 } = options || {};
-
-  return new Promise((resolve) => {
-    const proc = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    let killed = false;
-
-    const timer = setTimeout(() => {
-      killed = true;
-      proc.kill("SIGTERM");
-    }, timeout);
-
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      resolve({
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: killed ? -1 : (code ?? 1),
-      });
-    });
-
-    proc.on("error", () => {
-      clearTimeout(timer);
-      resolve({ stdout: "", stderr: "spawn error", exitCode: 1 });
-    });
-  });
-}
-
-/**
- * Execute a Vim expression on a remote nvim server.
- *
- * @param serverAddr - The nvim server address (socket path or host:port)
- * @param expr - The Vim expression to evaluate
- * @returns The result as a string, or null on error
- */
-export async function remoteExpr(serverAddr: string, expr: string): Promise<string | null> {
-  const result = await exec("nvim", ["--server", serverAddr, "--remote-expr", expr], {
-    timeout: 5000,
-  });
-
-  if (result.exitCode !== 0) {
-    return null;
-  }
-
-  return result.stdout;
-}
-
-/**
- * Send keystrokes to a remote nvim server.
- * Uses `nvim --server <addr> --remote-send <keys>`.
- */
-export async function remoteSend(serverAddr: string, keys: string): Promise<boolean> {
-  const result = await exec("nvim", ["--server", serverAddr, "--remote-send", keys], {
-    timeout: 5000,
-  });
-
-  return result.exitCode === 0;
-}
-
-/**
- * Execute a Vim expression and parse the result as JSON.
- *
- * The expression should use json_encode() to return JSON, e.g.:
- * `json_encode(nvim_list_bufs())`
- *
- * @param serverAddr - The nvim server address
- * @param expr - The Vim expression (should return JSON via json_encode)
- * @returns The parsed JSON, or null on error
- */
-export async function remoteExprJson<T>(serverAddr: string, expr: string): Promise<T | null> {
-  const result = await remoteExpr(serverAddr, expr);
-  if (result === null) return null;
-
-  try {
-    return JSON.parse(result) as T;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check if an nvim server is reachable.
- */
-export async function isServerReachable(serverAddr: string): Promise<boolean> {
-  const result = await remoteExpr(serverAddr, "1+1");
-  return result === "2";
-}
-
-/**
- * Get the current buffer info from nvim.
- */
-export interface NvimBufferInfo {
-  bufnr: number;
-  name: string;
-  filetype: string;
-  modified: boolean;
-  loaded: boolean;
-  listed: boolean;
-  cursor?: { line: number; col: number };
-}
-
-/**
- * List all buffers in the nvim instance.
- */
-export async function listBuffers(serverAddr: string): Promise<NvimBufferInfo[] | null> {
-  const expr = `json_encode(map(filter(getbufinfo(), 'v:val.listed'), {_, b -> {'bufnr': b.bufnr, 'name': b.name, 'loaded': b.loaded, 'listed': b.listed, 'modified': b.changed}}))`;
-  return remoteExprJson<NvimBufferInfo[]>(serverAddr, expr);
-}
-
-/**
- * Get the current buffer number.
- */
-export async function getCurrentBuffer(serverAddr: string): Promise<number | null> {
-  const result = await remoteExpr(serverAddr, "bufnr()");
-  if (result === null) return null;
-  const num = parseInt(result, 10);
-  return Number.isNaN(num) ? null : num;
-}
-
-/**
- * Get buffer content for a specific buffer.
- *
- * @param serverAddr - The nvim server address
- * @param bufnr - Buffer number (use 0 or omit for current buffer)
- * @param startLine - Start line (1-indexed, inclusive)
- * @param endLine - End line (1-indexed, inclusive, use '$' for last)
- */
-export async function getBufferLines(
-  serverAddr: string,
-  bufnr = 0,
-  startLine = 1,
-  endLine: number | "$" = "$",
-): Promise<string[] | null> {
-  const bufnrExpr = bufnr === 0 ? "bufnr()" : String(bufnr);
-  const endExpr = endLine === "$" ? `line('$', bufwinid(${bufnrExpr}))` : String(endLine);
-  const expr = `json_encode(getbufline(${bufnrExpr}, ${startLine}, ${endExpr}))`;
-  return remoteExprJson<string[]>(serverAddr, expr);
-}
-
-/**
- * Get visible window range for a buffer.
- */
-export interface WindowRange {
-  topLine: number;
-  bottomLine: number;
-  cursor: { line: number; col: number };
-}
-
-export async function getVisibleRange(serverAddr: string, bufnr = 0): Promise<WindowRange | null> {
-  const bufnrExpr = bufnr === 0 ? "bufnr()" : String(bufnr);
-  const expr = `json_encode({'topLine': line('w0', bufwinid(${bufnrExpr})), 'bottomLine': line('w$', bufwinid(${bufnrExpr})), 'cursor': {'line': line('.', bufwinid(${bufnrExpr})), 'col': col('.', bufwinid(${bufnrExpr}))}})`;
-  return remoteExprJson<WindowRange>(serverAddr, expr);
-}
-
-/**
- * Get current buffer info including name, filetype, and cursor position.
- */
-export async function getCurrentBufferInfo(serverAddr: string): Promise<NvimBufferInfo | null> {
-  const expr = `json_encode({'bufnr': bufnr(), 'name': expand('%:p'), 'filetype': &filetype, 'modified': &modified, 'loaded': 1, 'listed': 1, 'cursor': {'line': line('.'), 'col': col('.')}})`;
-  return remoteExprJson<NvimBufferInfo>(serverAddr, expr);
-}

package/src/lib/panes/README.md

@@ -1,20 +0,0 @@
-# Panes Broker (Local Fanout)
-
-This directory defines the **local panes broker protocol** used to stream tmux pane output to multiple clients (TUI, tools, etc.) without each client mutating tmux.
-
-## Transport
-
-- Unix domain socket
-- Newline-delimited JSON (NDJSON)
-- Default path: `~/.abbie/run/panes-broker.sock` (or `$XDG_RUNTIME_DIR/abbie-panes-broker.sock`)
-
-## Model
-
-- A **single owner process** (typically `abbie daemon`) owns tmux integration and any `tmux pipe-pane` lifecycle.
-- Clients connect and send `panes.subscribe` / `panes.unsubscribe`.
-- Server emits `panes.snapshot` (initial) and `panes.delta` (stream).
-
-## Security
-
-For cross-device mirroring (Convex), use `redaction=default` (redacted-by-default). Local TUI can request `redaction=raw`.
-

package/src/lib/panes/broker.ts

@@ -1,261 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import { createConnection, type Socket } from "node:net";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-/**
- * Panes broker protocol (local fanout).
- *
- * Transport: Unix domain socket (newline-delimited JSON).
- * - Client → server: control messages (subscribe/unsubscribe, ping)
- * - Server → client: pane snapshots + deltas + status
- *
- * Goal: enable multiple clients (TUI + tools) to subscribe without each
- * attaching to tmux / mutating pane state.
- *
- * This file defines the protocol + a minimal client helper. The daemon/broker
- * implementation lives elsewhere and can be integrated later.
- */
-
-export type PanesBrokerRedactionMode = "raw" | "default";
-export type PanesBrokerContentEncoding = "text" | "ansi";
-
-export type PanesBrokerPaneTarget =
-  | { paneId: string; ref?: string }
-  | { ref: string; paneId?: string };
-
-export type PanesBrokerSubscribeOptions = {
-  requestId?: string;
-  target: PanesBrokerPaneTarget;
-  redaction?: PanesBrokerRedactionMode;
-  encoding?: PanesBrokerContentEncoding;
-  history?: { lines: number };
-  follow?: boolean;
-};
-
-export type PanesBrokerClientHello = {
-  type: "client.hello";
-  at: string;
-  clientId: string;
-  version: 1;
-  pid: number;
-};
-
-export type PanesBrokerSubscribe = {
-  type: "panes.subscribe";
-  at: string;
-  requestId: string;
-  target: PanesBrokerPaneTarget;
-  redaction: PanesBrokerRedactionMode;
-  encoding: PanesBrokerContentEncoding;
-  history?: { lines: number };
-  follow: boolean;
-};
-
-export type PanesBrokerUnsubscribe = {
-  type: "panes.unsubscribe";
-  at: string;
-  requestId: string;
-};
-
-export type PanesBrokerPing = {
-  type: "client.ping";
-  at: string;
-  nonce: string;
-};
-
-export type PanesBrokerClientMessage =
-  | PanesBrokerClientHello
-  | PanesBrokerSubscribe
-  | PanesBrokerUnsubscribe
-  | PanesBrokerPing;
-
-export type PanesBrokerServerHello = {
-  type: "broker.hello";
-  at: string;
-  version: 1;
-  pid: number;
-};
-
-export type PanesBrokerPong = {
-  type: "broker.pong";
-  at: string;
-  nonce: string;
-};
-
-export type PanesBrokerPanesSnapshot = {
-  type: "panes.snapshot";
-  at: string;
-  requestId: string;
-  paneId: string;
-  ref?: string;
-  encoding: PanesBrokerContentEncoding;
-  redaction: PanesBrokerRedactionMode;
-  cols?: number;
-  rows?: number;
-  truncated?: boolean;
-  content: string;
-};
-
-export type PanesBrokerPanesDelta = {
-  type: "panes.delta";
-  at: string;
-  requestId: string;
-  paneId: string;
-  ref?: string;
-  encoding: PanesBrokerContentEncoding;
-  redaction: PanesBrokerRedactionMode;
-  chunk: string;
-};
-
-export type PanesBrokerPanesStatus = {
-  type: "panes.status";
-  at: string;
-  requestId?: string;
-  paneId?: string;
-  level: "info" | "warn" | "error";
-  message: string;
-};
-
-export type PanesBrokerServerMessage =
-  | PanesBrokerServerHello
-  | PanesBrokerPong
-  | PanesBrokerPanesSnapshot
-  | PanesBrokerPanesDelta
-  | PanesBrokerPanesStatus;
-
-export type PanesBrokerConnectOptions = {
-  socketPath?: string;
-};
-
-export function getDefaultPanesBrokerSocketPath(): string {
-  const runtimeDir = process.env.XDG_RUNTIME_DIR;
-  if (runtimeDir) return join(runtimeDir, "abbie-panes-broker.sock");
-
-  const home = homedir() || process.env.HOME || "~";
-  return join(home, ".abbie", "run", "panes-broker.sock");
-}
-
-function ensureSocketDir(path: string): void {
-  const dir = dirname(path);
-  mkdirSync(dir, { recursive: true });
-}
-
-function nowIso(): string {
-  return new Date().toISOString();
-}
-
-export type LineParser<T> = {
-  pushChunk: (chunk: Buffer | string) => void;
-  onMessage: (fn: (msg: T) => void) => void;
-  onError: (fn: (err: Error) => void) => void;
-};
-
-export function createNdjsonLineParser<T>(): LineParser<T> {
-  let buf = "";
-  let onMessageFn: ((msg: T) => void) | null = null;
-  let onErrorFn: ((err: Error) => void) | null = null;
-
-  return {
-    pushChunk(chunk) {
-      buf += chunk.toString();
-      for (;;) {
-        const idx = buf.indexOf("\n");
-        if (idx === -1) break;
-        const line = buf.slice(0, idx).trimEnd();
-        buf = buf.slice(idx + 1);
-        if (!line) continue;
-        try {
-          const msg = JSON.parse(line) as T;
-          onMessageFn?.(msg);
-        } catch (err) {
-          onErrorFn?.(
-            new Error(err instanceof Error ? err.message : "Failed to parse NDJSON line"),
-          );
-        }
-      }
-    },
-    onMessage(fn) {
-      onMessageFn = fn;
-    },
-    onError(fn) {
-      onErrorFn = fn;
-    },
-  };
-}
-
-export type PanesBrokerClient = {
-  socket: Socket;
-  clientId: string;
-  send: (msg: PanesBrokerClientMessage) => void;
-  subscribe: (opts: PanesBrokerSubscribeOptions) => string;
-  unsubscribe: (requestId: string) => void;
-  ping: () => string;
-};
-
-export function connectPanesBroker(
-  opts: PanesBrokerConnectOptions = {},
-  handlers?: {
-    onMessage?: (msg: PanesBrokerServerMessage) => void;
-    onError?: (err: Error) => void;
-    onClose?: () => void;
-  },
-): PanesBrokerClient {
-  const socketPath = opts.socketPath ?? getDefaultPanesBrokerSocketPath();
-  ensureSocketDir(socketPath);
-
-  const socket = createConnection({ path: socketPath });
-  const parser = createNdjsonLineParser<PanesBrokerServerMessage>();
-
-  parser.onMessage((msg) => handlers?.onMessage?.(msg));
-  parser.onError((err) => handlers?.onError?.(err));
-
-  socket.on("data", (chunk) => parser.pushChunk(chunk));
-  socket.on("error", (err) =>
-    handlers?.onError?.(err instanceof Error ? err : new Error(String(err))),
-  );
-  socket.on("close", () => handlers?.onClose?.());
-
-  const clientId = randomUUID();
-
-  const send = (msg: PanesBrokerClientMessage) => {
-    socket.write(`${JSON.stringify(msg)}\n`);
-  };
-
-  // Send hello immediately; server can ignore if not required.
-  send({
-    type: "client.hello",
-    at: nowIso(),
-    clientId,
-    version: 1,
-    pid: process.pid,
-  });
-
-  const subscribe = (sub: PanesBrokerSubscribeOptions): string => {
-    const requestId = sub.requestId ?? randomUUID();
-    send({
-      type: "panes.subscribe",
-      at: nowIso(),
-      requestId,
-      target: sub.target,
-      redaction: sub.redaction ?? "raw",
-      encoding: sub.encoding ?? "text",
-      history: sub.history,
-      follow: sub.follow ?? true,
-    });
-    return requestId;
-  };
-
-  const unsubscribe = (requestId: string) => {
-    send({ type: "panes.unsubscribe", at: nowIso(), requestId });
-  };
-
-  const ping = (): string => {
-    const nonce = randomUUID();
-    send({ type: "client.ping", at: nowIso(), nonce });
-    return nonce;
-  };
-
-  return { socket, clientId, send, subscribe, unsubscribe, ping };
-}

package/src/lib/panes/index.ts

@@ -1 +0,0 @@
-export * from "./broker.js";