@creativeintelligence/abbie 0.1.0

package/dist/lib/ngrok.js

@@ -0,0 +1,339 @@
+import { execSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { createEvent, EventStore } from "./events.js";
+/**
+ * ngrok local API base URL.
+ * The agent exposes this API with no authentication.
+ * @see https://ngrok.com/docs/agent/api
+ */
+const NGROK_API_BASE = "http://127.0.0.1:4040/api";
+/**
+ * Check if ngrok agent is running.
+ * Uses the status endpoint for lightweight health check.
+ */
+export async function isAgentRunning() {
+    try {
+        const response = await fetch(`${NGROK_API_BASE}/status`);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get ngrok agent status.
+ */
+export async function getAgentStatus() {
+    try {
+        const response = await fetch(`${NGROK_API_BASE}/status`);
+        if (!response.ok)
+            return undefined;
+        return (await response.json());
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * List all active tunnels via ngrok API.
+ * @see GET /api/tunnels
+ */
+export async function listTunnels() {
+    try {
+        const response = await fetch(`${NGROK_API_BASE}/tunnels`);
+        if (!response.ok)
+            return [];
+        const data = (await response.json());
+        return data.tunnels || [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get a specific tunnel by name.
+ * @see GET /api/tunnels/:name
+ */
+export async function getTunnel(name) {
+    try {
+        const response = await fetch(`${NGROK_API_BASE}/tunnels/${encodeURIComponent(name)}`);
+        if (!response.ok)
+            return undefined;
+        return (await response.json());
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Start a new tunnel via ngrok API.
+ * Requires ngrok agent to be running.
+ * @see POST /api/tunnels
+ */
+export async function startTunnel(port, name) {
+    const tunnelName = name || `port-${port}`;
+    try {
+        const response = await fetch(`${NGROK_API_BASE}/tunnels`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                name: tunnelName,
+                addr: port.toString(),
+                proto: "http",
+            }),
+        });
+        if (response.status === 201 || response.ok) {
+            return (await response.json());
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Stop a tunnel by name.
+ * @see DELETE /api/tunnels/:name
+ */
+export async function stopTunnel(name) {
+    try {
+        const response = await fetch(`${NGROK_API_BASE}/tunnels/${encodeURIComponent(name)}`, {
+            method: "DELETE",
+        });
+        return response.status === 204 || response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Start ngrok agent in background if not running.
+ * This starts the agent without any tunnels - tunnels are created via API.
+ */
+export async function ensureAgentRunning() {
+    if (await isAgentRunning()) {
+        return true;
+    }
+    // Start ngrok agent with no tunnels (just the API)
+    const ngrok = spawn("ngrok", ["start", "--none"], {
+        detached: true,
+        stdio: "ignore",
+    });
+    ngrok.unref();
+    // Wait for agent to be ready (up to 10s)
+    for (let i = 0; i < 20; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        if (await isAgentRunning()) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Find tunnel by port number.
+ */
+export async function findTunnelByPort(port) {
+    const tunnels = await listTunnels();
+    return tunnels.find((t) => {
+        const addr = t.config?.addr || "";
+        return addr === port.toString() || addr.endsWith(`:${port}`);
+    });
+}
+/**
+ * Get public URL for a port, creating tunnel if needed.
+ * This is the main high-level function for getting a public URL.
+ */
+export async function getPublicUrl(port) {
+    // Ensure agent is running
+    if (!(await ensureAgentRunning())) {
+        return undefined;
+    }
+    // Check for existing tunnel
+    const existing = await findTunnelByPort(port);
+    if (existing) {
+        return existing.public_url;
+    }
+    // Create new tunnel
+    const tunnel = await startTunnel(port);
+    return tunnel?.public_url;
+}
+/**
+ * Kill all ngrok processes.
+ */
+export function killNgrok() {
+    try {
+        execSync('pkill -f "ngrok"', { stdio: "ignore" });
+    }
+    catch {
+        // No processes to kill
+    }
+}
+/**
+ * NgrokManager - higher-level manager with session tracking and events.
+ */
+export class NgrokManager {
+    basePath;
+    eventStore;
+    constructor(basePath = "~/.abbie/ngrok", eventStore) {
+        this.basePath = basePath.replace("~", process.env.HOME || "");
+        this.eventStore = eventStore || new EventStore();
+        if (!existsSync(this.basePath)) {
+            mkdirSync(this.basePath, { recursive: true });
+        }
+    }
+    /**
+     * Get stored tunnel metadata path.
+     */
+    getMetadataPath(name) {
+        return join(this.basePath, `${name}.json`);
+    }
+    /**
+     * Store tunnel metadata.
+     */
+    storeMetadata(tunnel) {
+        writeFileSync(this.getMetadataPath(tunnel.name), JSON.stringify(tunnel, null, 2));
+    }
+    /**
+     * Load tunnel metadata.
+     */
+    loadMetadata(name) {
+        const path = this.getMetadataPath(name);
+        if (!existsSync(path))
+            return undefined;
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    /**
+     * Remove tunnel metadata.
+     */
+    removeMetadata(name) {
+        const path = this.getMetadataPath(name);
+        if (existsSync(path)) {
+            unlinkSync(path);
+        }
+    }
+    /**
+     * Start a tunnel with session tracking.
+     */
+    async start(port, sessionId, name) {
+        // Ensure agent is running
+        if (!(await ensureAgentRunning())) {
+            return undefined;
+        }
+        const tunnelName = name || `${sessionId.split("-")[0]}-${port}`;
+        // Check for existing tunnel on this port
+        const existing = await findTunnelByPort(port);
+        if (existing) {
+            return { tunnel: existing, public_url: existing.public_url };
+        }
+        // Create tunnel via API
+        const tunnel = await startTunnel(port, tunnelName);
+        if (!tunnel) {
+            return undefined;
+        }
+        // Store metadata
+        this.storeMetadata({
+            name: tunnel.name,
+            session_id: sessionId,
+            port,
+            created_at: new Date().toISOString(),
+        });
+        // Log event
+        this.eventStore.append(createEvent.previewCreated(sessionId, "system", {
+            url: tunnel.public_url,
+            port,
+            subdomain: tunnel.name,
+        }));
+        return { tunnel, public_url: tunnel.public_url };
+    }
+    /**
+     * Stop a tunnel by name.
+     */
+    async stop(name) {
+        const stopped = await stopTunnel(name);
+        if (stopped) {
+            this.removeMetadata(name);
+        }
+        return stopped;
+    }
+    /**
+     * Stop all tunnels for a session.
+     */
+    async stopSession(sessionId) {
+        const files = existsSync(this.basePath) ? readdirSync(this.basePath) : [];
+        let stopped = 0;
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            const name = file.replace(".json", "");
+            const metadata = this.loadMetadata(name);
+            if (metadata?.session_id === sessionId) {
+                if (await this.stop(name)) {
+                    stopped++;
+                }
+            }
+        }
+        return stopped;
+    }
+    /**
+     * List all tunnels with metadata.
+     */
+    async list() {
+        const tunnels = await listTunnels();
+        return tunnels.map((tunnel) => ({
+            ...tunnel,
+            metadata: this.loadMetadata(tunnel.name),
+        }));
+    }
+    /**
+     * Cleanup stale metadata (tunnels that no longer exist).
+     */
+    async cleanup() {
+        if (!existsSync(this.basePath))
+            return 0;
+        const files = readdirSync(this.basePath);
+        const activeTunnels = await listTunnels();
+        const activeNames = new Set(activeTunnels.map((t) => t.name));
+        let cleaned = 0;
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            const name = file.replace(".json", "");
+            if (!activeNames.has(name)) {
+                this.removeMetadata(name);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+}
+/**
+ * Create an NgrokManager with default path.
+ */
+export function createNgrokManager(eventStore) {
+    return new NgrokManager("~/.abbie/ngrok", eventStore);
+}
+// Unix pipe helpers - these output to stdout for piping
+/**
+ * Print public URL to stdout.
+ * Usage: abbie tunnel url 3000 | xargs open
+ */
+export async function printPublicUrl(port) {
+    const url = await getPublicUrl(port);
+    if (url) {
+        process.stdout.write(`${url}\n`);
+    }
+    else {
+        process.exit(1);
+    }
+}
+/**
+ * Print all tunnel URLs to stdout.
+ * Usage: abbie tunnel urls | xargs -I{} curl {}
+ */
+export async function printAllUrls() {
+    const tunnels = await listTunnels();
+    for (const tunnel of tunnels) {
+        process.stdout.write(`${tunnel.public_url}\n`);
+    }
+}

package/dist/lib/nvim/discovery.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Socket discovery for Neovim instances.
+ * Finds nvim processes and discovers their RPC server addresses.
+ */
+import { type ProcessInfo } from "../process/snapshot.js";
+export interface NvimInstance {
+    pid: number;
+    serverAddr: string | null;
+    discoveryMethod: "argv" | "lsof" | null;
+}
+/**
+ * Find the nvim PID running under a pane (prefer deepest nested).
+ */
+export declare function findNvimPidForWindow(panePid: number, snapshot: Map<number, ProcessInfo>, tree: Map<number, number[]>): number | null;
+/**
+ * Discover nvim server address from process argv.
+ * This is the most reliable method when nvim was started with --listen.
+ */
+export declare function discoverFromArgv(nvimPid: number, snapshot: Map<number, ProcessInfo>): string | null;
+/**
+ * Discover nvim server address using lsof to find UNIX sockets.
+ * Fallback when --listen wasn't used but nvim created a socket.
+ */
+export declare function discoverFromLsof(nvimPid: number): Promise<string | 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 declare function discoverNvimServerAddress(nvimPid: number, snapshot: Map<number, ProcessInfo>): Promise<{
+    addr: string;
+    method: "argv" | "lsof";
+} | null>;
+/**
+ * Get the nvim instance for a window (pane).
+ * Combines process discovery and server address discovery.
+ */
+export declare function getNvimInstanceForWindow(panePid: number, snapshot: Map<number, ProcessInfo>, tree: Map<number, number[]>): Promise<NvimInstance | null>;
+/**
+ * Find all nvim instances in the process snapshot.
+ */
+export declare function findAllNvimInstances(snapshot: Map<number, ProcessInfo>): number[];
+//# sourceMappingURL=discovery.d.ts.map

package/dist/lib/nvim/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/lib/nvim/discovery.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAwC,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAEhG,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACzC;AA0BD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAC1B,MAAM,GAAG,IAAI,CAEf;AAkBD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GACjC,MAAM,GAAG,IAAI,CAKf;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgC9E;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GACjC,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAc3D;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAC1B,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAe9B;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,MAAM,EAAE,CAUjF"}

package/dist/lib/nvim/discovery.js

@@ -0,0 +1,140 @@
+/**
+ * Socket discovery for Neovim instances.
+ * Finds nvim processes and discovers their RPC server addresses.
+ */
+import { spawn } from "node:child_process";
+import { findDeepestDescendant, isNvimProcess } from "../process/snapshot.js";
+/**
+ * Execute a command and return stdout.
+ */
+async function exec(command, args) {
+    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, snapshot, tree) {
+    return findDeepestDescendant(panePid, tree, snapshot, isNvimProcess);
+}
+/**
+ * Parse --listen argument from nvim command line.
+ * Handles both `--listen <addr>` and `--listen=<addr>` forms.
+ */
+function parseListenFromArgs(args) {
+    // 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, snapshot) {
+    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) {
+    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, snapshot) {
+    // 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, snapshot, tree) {
+    // 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) {
+    const nvimPids = [];
+    for (const [pid, info] of snapshot) {
+        if (isNvimProcess(info)) {
+            nvimPids.push(pid);
+        }
+    }
+    return nvimPids;
+}

package/dist/lib/nvim/discovery.test.d.ts

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

package/dist/lib/nvim/discovery.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect } from 'bun:test';
+import { buildProcessTree } from '../process/snapshot.js';
+import { findNvimPidForWindow, discoverFromArgv, discoverNvimServerAddress, findAllNvimInstances, } from './discovery.js';
+// Mock process snapshot for testing pure functions
+function createMockSnapshot() {
+    const snapshot = new Map();
+    // tmux(100) → zsh(200) → nvim(300) with --listen
+    snapshot.set(100, { pid: 100, ppid: 1, tty: '??', cmd: 'tmux', args: 'tmux new -s work' });
+    snapshot.set(200, {
+        pid: 200,
+        ppid: 100,
+        tty: 'ttys001',
+        cmd: 'zsh',
+        args: '-zsh',
+    });
+    snapshot.set(300, {
+        pid: 300,
+        ppid: 200,
+        tty: 'ttys001',
+        cmd: 'nvim',
+        args: 'nvim --listen /tmp/nvim.300.sock src/app.ts',
+    });
+    // Another pane: zsh(250) → nvim(350) without --listen
+    snapshot.set(250, {
+        pid: 250,
+        ppid: 100,
+        tty: 'ttys002',
+        cmd: 'zsh',
+        args: '-zsh',
+    });
+    snapshot.set(350, {
+        pid: 350,
+        ppid: 250,
+        tty: 'ttys002',
+        cmd: 'nvim',
+        args: 'nvim src/other.ts',
+    });
+    // Nested nvim: zsh(400) → nvim(410) → nvim(420)
+    snapshot.set(400, {
+        pid: 400,
+        ppid: 100,
+        tty: 'ttys003',
+        cmd: 'zsh',
+        args: '-zsh',
+    });
+    snapshot.set(410, {
+        pid: 410,
+        ppid: 400,
+        tty: 'ttys003',
+        cmd: 'nvim',
+        args: 'nvim outer.ts',
+    });
+    snapshot.set(420, {
+        pid: 420,
+        ppid: 410,
+        tty: 'ttys003',
+        cmd: 'nvim',
+        args: 'nvim --listen=/tmp/nested.sock inner.ts',
+    });
+    return snapshot;
+}
+describe('nvim discovery', () => {
+    describe('findNvimPidForWindow', () => {
+        it('finds nvim under pane', () => {
+            const snapshot = createMockSnapshot();
+            const tree = buildProcessTree(snapshot);
+            const nvimPid = findNvimPidForWindow(200, snapshot, tree);
+            expect(nvimPid).toBe(300);
+        });
+        it('prefers deepest nested nvim', () => {
+            const snapshot = createMockSnapshot();
+            const tree = buildProcessTree(snapshot);
+            // Starting from zsh(400), should find the nested nvim(420), not outer nvim(410)
+            const nvimPid = findNvimPidForWindow(400, snapshot, tree);
+            expect(nvimPid).toBe(420);
+        });
+        it('returns null when no nvim found', () => {
+            const snapshot = createMockSnapshot();
+            const tree = buildProcessTree(snapshot);
+            // tmux(100) has no direct nvim child (nvim is under zsh)
+            // but findDeepestDescendant searches all descendants
+            const nvimPid = findNvimPidForWindow(100, snapshot, tree);
+            // Should find one of the nvims under tmux
+            expect(nvimPid).not.toBeNull();
+        });
+    });
+    describe('discoverFromArgv', () => {
+        it('parses --listen with space', () => {
+            const snapshot = createMockSnapshot();
+            const addr = discoverFromArgv(300, snapshot);
+            expect(addr).toBe('/tmp/nvim.300.sock');
+        });
+        it('parses --listen= form', () => {
+            const snapshot = createMockSnapshot();
+            const addr = discoverFromArgv(420, snapshot);
+            expect(addr).toBe('/tmp/nested.sock');
+        });
+        it('returns null when no --listen', () => {
+            const snapshot = createMockSnapshot();
+            const addr = discoverFromArgv(350, snapshot);
+            expect(addr).toBeNull();
+        });
+        it('returns null for unknown PID', () => {
+            const snapshot = createMockSnapshot();
+            const addr = discoverFromArgv(9999, snapshot);
+            expect(addr).toBeNull();
+        });
+    });
+    describe('discoverNvimServerAddress', () => {
+        it('uses argv when --listen present', async () => {
+            const snapshot = createMockSnapshot();
+            const result = await discoverNvimServerAddress(300, snapshot);
+            expect(result).toEqual({ addr: '/tmp/nvim.300.sock', method: 'argv' });
+        });
+        // Note: lsof fallback tests require actual system state or dependency injection.
+        // These are integration tests that would need a real nvim process.
+        // For unit testing the lsof path, we'd need to refactor discovery.ts
+        // to accept an executor function as a parameter.
+    });
+    describe('findAllNvimInstances', () => {
+        it('finds all nvim PIDs', () => {
+            const snapshot = createMockSnapshot();
+            const nvimPids = findAllNvimInstances(snapshot);
+            expect(nvimPids).toContain(300);
+            expect(nvimPids).toContain(350);
+            expect(nvimPids).toContain(410);
+            expect(nvimPids).toContain(420);
+            expect(nvimPids).toHaveLength(4);
+        });
+    });
+});

package/dist/lib/nvim/index.d.ts

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

package/dist/lib/nvim/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/nvim/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,KAAK,YAAY,GAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,KAAK,cAAc,EACnB,UAAU,EACV,cAAc,EACd,KAAK,WAAW,GACjB,MAAM,aAAa,CAAC"}

package/dist/lib/nvim/index.js

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