@creativeintelligence/abbie 0.1.6 → 0.1.8

package/dist/cli/commands/windows/show.js

@@ -1,165 +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";
-function abbreviateHome(path) {
-    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) {
-    return `${window.session}:${window.window}.${window.pane}`;
-}
-function formatPathForDisplay(path, cwd) {
-    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) {
-    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 summary = "Show detailed window state";
-    static hidden = false;
-    static examples = [
-        "$ abbie windows show",
-        "$ abbie windows show %3",
-        "$ abbie windows show work:0.0",
-        "$ abbie windows show --with-buffers",
-        "$ abbie windows show --json",
-    ];
-    static args = {
-        ref: Args.string({
-            description: "Pane ID (e.g. %3) or session:window.pane (e.g. work:0.0)",
-            required: false,
-        }),
-    };
-    static flags = {
-        ...BaseCommand.baseFlags,
-        "with-buffers": Flags.boolean({
-            description: "Include all buffers (expensive)",
-            default: false,
-        }),
-    };
-    async execute() {
-        const { args, flags } = await this.parse(WindowsShowCommand);
-        this.parsedFlags = flags;
-        const tmuxRunning = await isRunning();
-        if (!tmuxRunning) {
-            const result = { 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 = { tmuxRunning: true, window: enriched };
-        if (!this.jsonEnabled?.()) {
-            this.printText(result, flags);
-        }
-        return result;
-    }
-    printText(result, flags) {
-        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/dist/cli/commands/windows/watch.d.ts

@@ -1,19 +0,0 @@
-import { BaseCommand } from "../../base-command.js";
-export default class WindowsWatchCommand extends BaseCommand {
-    static summary: string;
-    static hidden: boolean;
-    static examples: string[];
-    static flags: {
-        session: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        active: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "with-nvim": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "with-agent": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "debounce-ms": import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
-        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    execute(): Promise<unknown>;
-}
-//# sourceMappingURL=watch.d.ts.map

package/dist/cli/commands/windows/watch.js

@@ -1,241 +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) {
-    return `${window.session}:${window.window}.${window.pane}`;
-}
-function stableWindowId(state) {
-    return state.window.paneId || paneRef(state.window);
-}
-function sortWindows(states) {
-    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) {
-    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) {
-    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 summary = "Watch workspace windows (tmux panes) and stream updates";
-    static hidden = false;
-    static examples = [
-        "$ abbie windows watch --ndjson --quiet",
-        "$ abbie windows watch --ndjson --quiet --debounce-ms 100",
-        "$ abbie windows watch --ndjson --quiet --no-with-nvim",
-    ];
-    static 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() {
-        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 = null;
-        let pendingTimer = null;
-        let lastReason = "tmux";
-        let stopped = false;
-        const emitInventory = async (reason) => {
-            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) => {
-            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) => {
-            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",
-                });
-            });
-        });
-    }
-}

package/dist/lib/managed-session.d.ts

@@ -1,27 +0,0 @@
-/**
- * Managed abbie tmux session utilities.
- *
- * Abbie owns a dedicated tmux session where it manages project windows.
- * This module provides the shared primitives for creating, querying,
- * and managing that session.
- */
-/**
- * Get the managed session name (from env or default).
- */
-export declare function getManagedSessionName(): string;
-/**
- * Ensure the managed abbie tmux session exists.
- * Creates it (detached) if it doesn't exist yet.
- * Returns the session name.
- */
-export declare function ensureManagedSession(): Promise<string>;
-/**
- * List windows in the managed session.
- * Returns empty array if session doesn't exist.
- */
-export declare function listManagedWindows(): Promise<import("./tmux/bridge.js").TmuxWindow[]>;
-/**
- * Check if a project window already exists in the managed session.
- */
-export declare function hasProjectWindow(name: string): Promise<boolean>;
-//# sourceMappingURL=managed-session.d.ts.map

package/dist/lib/managed-session.js

@@ -1,105 +0,0 @@
-/**
- * Managed abbie tmux session utilities.
- *
- * Abbie owns a dedicated tmux session where it manages project windows.
- * This module provides the shared primitives for creating, querying,
- * and managing that session.
- */
-import { spawn as spawnCmd } from "node:child_process";
-import { homedir } from "node:os";
-const DEFAULT_SESSION_NAME = "abbie";
-const INTERNAL_WINDOW_NAME = "_abbie";
-const LEGACY_SHELL_WINDOWS = new Set(["zsh", "bash", "fish", "sh"]);
-/**
- * Get the managed session name (from env or default).
- */
-export function getManagedSessionName() {
-    return process.env.ABBIE_TMUX_SESSION ?? DEFAULT_SESSION_NAME;
-}
-/**
- * Ensure the managed abbie tmux session exists.
- * Creates it (detached) if it doesn't exist yet.
- * Returns the session name.
- */
-export async function ensureManagedSession() {
-    const { isRunning, listSessions, listWindows } = await import("./tmux/bridge.js");
-    const session = getManagedSessionName();
-    const running = await isRunning();
-    if (!running) {
-        // No tmux server at all — create session (this also starts the server)
-        await createDetachedSession(session);
-        return session;
-    }
-    const sessions = await listSessions();
-    const exists = sessions.some((s) => s.name === session);
-    if (!exists) {
-        await createDetachedSession(session);
-        return session;
-    }
-    // Normalize legacy bootstrap windows created by older versions (e.g. `zsh` window at index 0)
-    // so users don’t see a confusing "zsh" project when attaching to the managed session.
-    try {
-        const windows = await listWindows(session);
-        const hasInternal = windows.some((w) => w.name === INTERNAL_WINDOW_NAME);
-        const legacyBootstrap = windows.find((w) => w.index === 0 && LEGACY_SHELL_WINDOWS.has(w.name));
-        if (!hasInternal && legacyBootstrap) {
-            await renameWindow(session, legacyBootstrap.index, INTERNAL_WINDOW_NAME);
-        }
-    }
-    catch {
-        // Best-effort only
-    }
-    return session;
-}
-/**
- * List windows in the managed session.
- * Returns empty array if session doesn't exist.
- */
-export async function listManagedWindows() {
-    const { isRunning, listSessions, listWindows } = await import("./tmux/bridge.js");
-    const session = getManagedSessionName();
-    if (!(await isRunning()))
-        return [];
-    const sessions = await listSessions();
-    if (!sessions.some((s) => s.name === session))
-        return [];
-    return listWindows(session);
-}
-/**
- * Check if a project window already exists in the managed session.
- */
-export async function hasProjectWindow(name) {
-    const windows = await listManagedWindows();
-    return windows.some((w) => w.name === name);
-}
-/**
- * Create a detached tmux session.
- */
-async function createDetachedSession(name) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnCmd("tmux", ["new-session", "-d", "-s", name, "-n", INTERNAL_WINDOW_NAME, "-c", homedir()], {
-            stdio: ["ignore", "ignore", "ignore"],
-        });
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`Failed to create tmux session: ${name}`));
-        });
-        proc.on("error", reject);
-    });
-}
-async function renameWindow(session, index, name) {
-    await new Promise((resolve, reject) => {
-        const proc = spawnCmd("tmux", ["rename-window", "-t", `${session}:${index}`, name], {
-            stdio: ["ignore", "ignore", "ignore"],
-        });
-        proc.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`Failed to rename window ${session}:${index} → ${name}`));
-        });
-        proc.on("error", reject);
-    });
-}

package/dist/lib/panes/broker.d.ts

@@ -1,130 +0,0 @@
-import { type Socket } from "node:net";
-/**
- * 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 declare function getDefaultPanesBrokerSocketPath(): string;
-export type LineParser<T> = {
-    pushChunk: (chunk: Buffer | string) => void;
-    onMessage: (fn: (msg: T) => void) => void;
-    onError: (fn: (err: Error) => void) => void;
-};
-export declare function createNdjsonLineParser<T>(): LineParser<T>;
-export type PanesBrokerClient = {
-    socket: Socket;
-    clientId: string;
-    send: (msg: PanesBrokerClientMessage) => void;
-    subscribe: (opts: PanesBrokerSubscribeOptions) => string;
-    unsubscribe: (requestId: string) => void;
-    ping: () => string;
-};
-export declare function connectPanesBroker(opts?: PanesBrokerConnectOptions, handlers?: {
-    onMessage?: (msg: PanesBrokerServerMessage) => void;
-    onError?: (err: Error) => void;
-    onClose?: () => void;
-}): PanesBrokerClient;
-//# sourceMappingURL=broker.d.ts.map