@creativeintelligence/abbie 0.1.0

package/dist/lib/tmux/bridge.js

@@ -0,0 +1,315 @@
+/**
+ * tmux bridge - core primitives for interacting with tmux.
+ * Provides programmatic access to tmux sessions, windows, and panes.
+ */
+import { spawn } from "node:child_process";
+/**
+ * Execute a tmux command and return stdout.
+ */
+async function tmux(...args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("tmux", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`tmux ${args.join(" ")} failed: ${stderr || `exit code ${code}`}`));
+            }
+        });
+        proc.on("error", reject);
+    });
+}
+/**
+ * Check if tmux server is running.
+ */
+export async function isRunning() {
+    try {
+        await tmux("list-sessions");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List all tmux sessions.
+ */
+export async function listSessions() {
+    try {
+        const output = await tmux("list-sessions", "-F", "#{session_name}\t#{session_windows}\t#{session_attached}\t#{session_created}");
+        if (!output)
+            return [];
+        return output.split("\n").map((line) => {
+            const [name, windows, attached, created] = line.split("\t");
+            return {
+                name,
+                windows: parseInt(windows, 10),
+                attached: attached === "1",
+                created: new Date(parseInt(created, 10) * 1000),
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * List all windows in a session (defaults to current).
+ */
+export async function listWindows(session) {
+    try {
+        const target = session ? ["-t", session] : [];
+        const output = await tmux("list-windows", ...target, "-F", "#{window_id}\t#{window_index}\t#{window_name}\t#{window_active}\t#{window_panes}\t#{window_layout}");
+        if (!output)
+            return [];
+        return output.split("\n").map((line) => {
+            const [id, index, name, active, panes, layout] = line.split("\t");
+            return {
+                id,
+                index: parseInt(index, 10),
+                name,
+                active: active === "1",
+                panes: parseInt(panes, 10),
+                layout,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * List all panes in a window.
+ */
+export async function listPanes(window, session) {
+    try {
+        const target = session ? `${session}:${window}` : `${window}`;
+        const output = await tmux("list-panes", "-t", target, "-F", "#{pane_index}\t#{pane_active}\t#{pane_width}\t#{pane_height}\t#{pane_current_command}\t#{pane_current_path}");
+        if (!output)
+            return [];
+        return output.split("\n").map((line) => {
+            const [index, active, width, height, currentCommand = "", currentPath = ""] = line.split("\t");
+            return {
+                index: parseInt(index, 10),
+                active: active === "1",
+                width: parseInt(width, 10),
+                height: parseInt(height, 10),
+                currentCommand,
+                currentPath,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Capture pane content (plain text, no ANSI).
+ */
+export async function capturePane(window, pane = 0, options = {}) {
+    const { lines = 100, session, startLine } = options;
+    const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+    // -p prints to stdout (no -e for plain text without ANSI)
+    const args = ["capture-pane", "-t", target, "-p"];
+    if (startLine !== undefined) {
+        args.push("-S", String(startLine));
+    }
+    else {
+        args.push("-S", `-${lines}`);
+    }
+    try {
+        return await tmux(...args);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Capture pane content with ANSI escape codes preserved.
+ */
+export async function capturePaneWithAnsi(window, pane = 0, options = {}) {
+    const { lines = 100, session, startLine } = options;
+    const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+    // -e preserves escape sequences (ANSI colors), -p prints to stdout
+    const args = ["capture-pane", "-t", target, "-p", "-e"];
+    if (startLine !== undefined) {
+        args.push("-S", String(startLine));
+    }
+    else {
+        args.push("-S", `-${lines}`);
+    }
+    try {
+        return await tmux(...args);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Send keys to a pane.
+ */
+export async function sendKeys(window, pane, keys, options = {}) {
+    const { session, literal = false } = options;
+    const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+    const args = ["send-keys", "-t", target];
+    if (literal) {
+        args.push("-l");
+    }
+    args.push(keys);
+    await tmux(...args);
+}
+/**
+ * Select a window.
+ */
+export async function selectWindow(window, session) {
+    const target = session ? `${session}:${window}` : `${window}`;
+    await tmux("select-window", "-t", target);
+}
+/**
+ * Select a pane.
+ */
+export async function selectPane(window, pane, session) {
+    const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+    await tmux("select-pane", "-t", target);
+}
+/**
+ * Create a new window.
+ */
+export async function newWindow(options) {
+    const { name, cwd, session, command } = options;
+    const args = ["new-window"];
+    // Trailing colon ensures tmux interprets as session (not window/pane match)
+    if (session)
+        args.push("-t", `${session}:`);
+    if (name)
+        args.push("-n", name);
+    if (cwd)
+        args.push("-c", cwd);
+    if (command)
+        args.push(command);
+    await tmux(...args);
+}
+/**
+ * Kill a window.
+ */
+export async function killWindow(window, session) {
+    const target = session ? `${session}:${window}` : `${window}`;
+    await tmux("kill-window", "-t", target);
+}
+/**
+ * Reorder a window by moving it to a target index.
+ * Uses -r to renumber windows to avoid index collisions.
+ */
+export async function moveWindow(sourceIndex, targetIndex, session) {
+    const source = session ? `${session}:${sourceIndex}` : String(sourceIndex);
+    const target = session ? `${session}:${targetIndex}` : String(targetIndex);
+    await tmux("move-window", "-r", "-s", source, "-t", target);
+}
+/**
+ * Move a window (by id or index string) to a target index.
+ * Prefer window ids (e.g. "@47") because indices change as we reorder.
+ */
+export async function moveWindowToIndex(source, targetIndex, session) {
+    const sourceTarget = source.startsWith("@") ? source : session ? `${session}:${source}` : source;
+    const target = session ? `${session}:${targetIndex}` : String(targetIndex);
+    await tmux("move-window", "-r", "-s", sourceTarget, "-t", target);
+}
+/**
+ * Swap two windows by index.
+ * This is the safest way to reorder within a session because `move-window` cannot
+ * move into an index that's already in use.
+ */
+export async function swapWindows(sourceIndex, targetIndex, session) {
+    const source = session ? `${session}:${sourceIndex}` : String(sourceIndex);
+    const target = session ? `${session}:${targetIndex}` : String(targetIndex);
+    await tmux("swap-window", "-s", source, "-t", target);
+}
+/**
+ * Get the current window name.
+ */
+export async function getCurrentWindow(session) {
+    try {
+        const target = session ? ["-t", session] : [];
+        const output = await tmux("display-message", ...target, "-p", "#{window_name}");
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the current pane's working directory.
+ */
+export async function getPaneCwd(window, pane = 0, session) {
+    try {
+        const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+        const output = await tmux("display-message", "-t", target, "-p", "#{pane_current_path}");
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resize a pane to specific dimensions.
+ * Note: This resizes the pane within the window layout.
+ */
+export async function resizePane(window, pane, cols, rows, session) {
+    const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+    // resize-pane -x sets width, -y sets height
+    await tmux("resize-pane", "-t", target, "-x", String(cols), "-y", String(rows));
+}
+/**
+ * Get the pane ID (unique identifier like %0, %1, etc).
+ * Useful for nvim socket naming: /tmp/nvim-${paneId}.sock
+ */
+export async function getPaneId(window, pane = 0, session) {
+    try {
+        const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+        const output = await tmux("display-message", "-t", target, "-p", "#{pane_id}");
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the pane's TTY path.
+ * Useful for correlating nvim instances to panes.
+ */
+export async function getPaneTty(window, pane = 0, session) {
+    try {
+        const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+        const output = await tmux("display-message", "-t", target, "-p", "#{pane_tty}");
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get pane dimensions (width and height in columns/rows).
+ */
+export async function getPaneDimensions(window, pane = 0, session) {
+    try {
+        const target = session ? `${session}:${window}.${pane}` : `${window}.${pane}`;
+        const output = await tmux("display-message", "-t", target, "-p", "#{pane_width}x#{pane_height}");
+        const match = output?.match(/^(\d+)x(\d+)$/);
+        if (match) {
+            return { cols: parseInt(match[1], 10), rows: parseInt(match[2], 10) };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/tmux/context.d.ts

@@ -0,0 +1,82 @@
+/**
+ * tmux context builder.
+ * Builds a structured snapshot of the tmux workspace for agent injection.
+ */
+import { type FilterConfig, type RedactMode } from "./redaction.js";
+/**
+ * Context options.
+ */
+export interface ContextOptions {
+    /** Maximum bytes in output (default: 200000) */
+    maxBytes?: number;
+    /** Maximum total lines across all panes (default: 4000) */
+    maxTotalLines?: number;
+    /** Maximum sessions to include (default: unlimited) */
+    maxSessions?: number;
+    /** Maximum windows per session (default: unlimited) */
+    maxWindowsPerSession?: number;
+    /** Maximum panes per window (default: unlimited) */
+    maxPanesPerWindow?: number;
+    /** Enable redaction (default: true) */
+    redact?: boolean;
+    /** Redaction mode (default: balanced) */
+    redactMode?: RedactMode;
+    /** Filter configuration */
+    filter?: FilterConfig;
+    /** Include all commands, not just shell+editor (default: false) */
+    includeAllCommands?: boolean;
+}
+/**
+ * Pane context.
+ */
+export interface PaneContext {
+    index: number;
+    active: boolean;
+    cwd: string;
+    cmd: string;
+    size: string;
+    screen: string;
+    redacted: boolean;
+}
+/**
+ * Window context.
+ */
+export interface WindowContext {
+    id: string;
+    index: number;
+    name: string;
+    active: boolean;
+    paneCount: number;
+    panes: PaneContext[];
+}
+/**
+ * Session context.
+ */
+export interface SessionContext {
+    name: string;
+    attached: boolean;
+    windows: WindowContext[];
+}
+/**
+ * Full tmux context.
+ */
+export interface TmuxContext {
+    generatedAt: string;
+    tmuxRunning: boolean;
+    truncated: boolean;
+    truncationReason?: string;
+    sessions: SessionContext[];
+}
+/**
+ * Build a structured tmux context.
+ */
+export declare function buildContext(options?: ContextOptions): Promise<TmuxContext>;
+/**
+ * Serialize context to XML.
+ */
+export declare function toXml(context: TmuxContext): string;
+/**
+ * Serialize context to JSON.
+ */
+export declare function toJson(context: TmuxContext): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/lib/tmux/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/lib/tmux/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,UAAU,EAMhB,MAAM,gBAAgB,CAAC;AAQxB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gDAAgD;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uDAAuD;IACvD,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uCAAuC;IACvC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yCAAyC;IACzC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,WAAW,CAAC,CAqMrF;AAwCD;;GAEG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAsClD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAEnD"}

package/dist/lib/tmux/context.js

@@ -0,0 +1,239 @@
+/**
+ * tmux context builder.
+ * Builds a structured snapshot of the tmux workspace for agent injection.
+ */
+import * as bridge from "./bridge.js";
+import { redactContent, shouldFilterCommand, shouldFilterPath, shouldFilterSession, shouldFilterWindow, } from "./redaction.js";
+/**
+ * Allowed commands for pane capture.
+ * Only capture panes running these commands.
+ */
+const ALLOWED_COMMANDS = new Set(["nvim", "vim", "vi", "zsh", "bash", "fish", "sh"]);
+/**
+ * Build a structured tmux context.
+ */
+export async function buildContext(options = {}) {
+    const { maxBytes = 200000, maxTotalLines = 4000, maxSessions, maxWindowsPerSession, maxPanesPerWindow, redact = true, redactMode = "balanced", filter = {}, includeAllCommands = false, } = options;
+    // Check if tmux is running
+    const tmuxRunning = await bridge.isRunning();
+    if (!tmuxRunning) {
+        return {
+            generatedAt: new Date().toISOString(),
+            tmuxRunning: false,
+            truncated: false,
+            sessions: [],
+        };
+    }
+    // Get all sessions
+    let sessions = await bridge.listSessions();
+    // Apply session filters
+    sessions = sessions.filter((s) => !shouldFilterSession(s.name, filter));
+    // Apply maxSessions limit
+    if (maxSessions !== undefined && sessions.length > maxSessions) {
+        sessions = sessions.slice(0, maxSessions);
+    }
+    const result = {
+        generatedAt: new Date().toISOString(),
+        tmuxRunning: true,
+        truncated: false,
+        sessions: [],
+    };
+    let totalBytes = 0;
+    let totalLines = 0;
+    let truncated = false;
+    let truncationReason;
+    for (const session of sessions) {
+        // Check byte limit
+        if (totalBytes >= maxBytes) {
+            truncated = true;
+            truncationReason = "max-bytes";
+            break;
+        }
+        // Check line limit
+        if (totalLines >= maxTotalLines) {
+            truncated = true;
+            truncationReason = "max-lines";
+            break;
+        }
+        let windows = await bridge.listWindows(session.name);
+        // Apply window filters
+        windows = windows.filter((w) => !shouldFilterWindow(w.name, filter));
+        // Apply maxWindowsPerSession limit
+        if (maxWindowsPerSession !== undefined && windows.length > maxWindowsPerSession) {
+            windows = windows.slice(0, maxWindowsPerSession);
+        }
+        const sessionContext = {
+            name: session.name,
+            attached: session.attached,
+            windows: [],
+        };
+        for (const window of windows) {
+            // Check limits again
+            if (totalBytes >= maxBytes || totalLines >= maxTotalLines) {
+                truncated = true;
+                truncationReason = totalBytes >= maxBytes ? "max-bytes" : "max-lines";
+                break;
+            }
+            let panes = await bridge.listPanes(window.index, session.name);
+            // Filter by allowed commands unless includeAllCommands is true
+            if (!includeAllCommands) {
+                panes = panes.filter((p) => ALLOWED_COMMANDS.has(p.currentCommand));
+            }
+            // Apply path and command filters
+            panes = panes.filter((p) => {
+                if (shouldFilterPath(p.currentPath, filter))
+                    return false;
+                if (shouldFilterCommand(p.currentCommand, filter))
+                    return false;
+                return true;
+            });
+            // Apply maxPanesPerWindow limit
+            if (maxPanesPerWindow !== undefined && panes.length > maxPanesPerWindow) {
+                panes = panes.slice(0, maxPanesPerWindow);
+            }
+            // Skip windows with no eligible panes
+            if (panes.length === 0) {
+                continue;
+            }
+            const windowContext = {
+                id: window.id,
+                index: window.index,
+                name: window.name,
+                active: window.active,
+                paneCount: window.panes,
+                panes: [],
+            };
+            for (const pane of panes) {
+                // Check limits
+                if (totalBytes >= maxBytes || totalLines >= maxTotalLines) {
+                    truncated = true;
+                    truncationReason = totalBytes >= maxBytes ? "max-bytes" : "max-lines";
+                    break;
+                }
+                // Capture the visible screen (based on pane height)
+                const capturedContent = await bridge.capturePane(window.index, pane.index, {
+                    session: session.name,
+                    lines: pane.height,
+                });
+                let screenContent = capturedContent;
+                let wasRedacted = false;
+                // Apply redaction
+                if (redact) {
+                    const redactionResult = redactContent(capturedContent, redactMode);
+                    screenContent = redactionResult.content;
+                    wasRedacted = redactionResult.wasRedacted;
+                }
+                // Calculate bytes and lines
+                const contentBytes = Buffer.byteLength(screenContent, "utf-8");
+                const contentLines = screenContent.split("\n").length;
+                // Check if adding this would exceed limits
+                if (totalBytes + contentBytes > maxBytes) {
+                    // Truncate content to fit
+                    const remainingBytes = maxBytes - totalBytes;
+                    screenContent = truncateToBytes(screenContent, remainingBytes);
+                    truncated = true;
+                    truncationReason = "max-bytes";
+                }
+                if (totalLines + contentLines > maxTotalLines) {
+                    // Truncate lines to fit
+                    const remainingLines = maxTotalLines - totalLines;
+                    const lines = screenContent.split("\n");
+                    screenContent = lines.slice(0, remainingLines).join("\n");
+                    truncated = true;
+                    truncationReason = "max-lines";
+                }
+                totalBytes += Buffer.byteLength(screenContent, "utf-8");
+                totalLines += screenContent.split("\n").length;
+                const paneContext = {
+                    index: pane.index,
+                    active: pane.active,
+                    cwd: pane.currentPath,
+                    cmd: pane.currentCommand,
+                    size: `${pane.width}x${pane.height}`,
+                    screen: screenContent,
+                    redacted: wasRedacted,
+                };
+                windowContext.panes.push(paneContext);
+            }
+            if (windowContext.panes.length > 0) {
+                sessionContext.windows.push(windowContext);
+            }
+        }
+        if (sessionContext.windows.length > 0) {
+            result.sessions.push(sessionContext);
+        }
+    }
+    result.truncated = truncated;
+    if (truncationReason) {
+        result.truncationReason = truncationReason;
+    }
+    return result;
+}
+/**
+ * Truncate a string to a maximum number of bytes.
+ */
+function truncateToBytes(str, maxBytes) {
+    const buf = Buffer.from(str, "utf-8");
+    if (buf.length <= maxBytes) {
+        return str;
+    }
+    // Binary search for the right length
+    let low = 0;
+    let high = str.length;
+    while (low < high) {
+        const mid = Math.ceil((low + high) / 2);
+        const slice = str.slice(0, mid);
+        if (Buffer.byteLength(slice, "utf-8") <= maxBytes) {
+            low = mid;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return str.slice(0, low);
+}
+/**
+ * Escape XML special characters.
+ */
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Serialize context to XML.
+ */
+export function toXml(context) {
+    const lines = [];
+    lines.push(`<tmux_context generated_at="${escapeXml(context.generatedAt)}" tmux_running="${context.tmuxRunning}" truncated="${context.truncated}"${context.truncationReason ? ` truncation_reason="${escapeXml(context.truncationReason)}"` : ""}>`);
+    for (const session of context.sessions) {
+        lines.push(`  <session name="${escapeXml(session.name)}" attached="${session.attached}">`);
+        for (const window of session.windows) {
+            lines.push(`    <window id="${escapeXml(window.id)}" index="${window.index}" name="${escapeXml(window.name)}" active="${window.active}" panes="${window.paneCount}">`);
+            for (const pane of window.panes) {
+                lines.push(`      <pane index="${pane.index}" active="${pane.active}" cwd="${escapeXml(pane.cwd)}" cmd="${escapeXml(pane.cmd)}" size="${pane.size}">`);
+                lines.push(`        <screen redacted="${pane.redacted}">`);
+                // Indent screen content and escape
+                const screenLines = pane.screen.split("\n");
+                for (const screenLine of screenLines) {
+                    lines.push(`          ${escapeXml(screenLine)}`);
+                }
+                lines.push("        </screen>");
+                lines.push("      </pane>");
+            }
+            lines.push("    </window>");
+        }
+        lines.push("  </session>");
+    }
+    lines.push("</tmux_context>");
+    return lines.join("\n");
+}
+/**
+ * Serialize context to JSON.
+ */
+export function toJson(context) {
+    return JSON.stringify(context, null, 2);
+}

package/dist/lib/tmux/context.test.d.ts

@@ -0,0 +1 @@
+export {};