@creativeintelligence/abbie 0.1.0

package/dist/lib/tmux/context.test.js

@@ -0,0 +1,215 @@
+import { describe, expect, test } from 'bun:test';
+import { toXml, toJson } from './context.js';
+// Helper to create test context
+function createTestContext(overrides = {}) {
+    return {
+        generatedAt: '2025-01-26T12:00:00.000Z',
+        tmuxRunning: true,
+        truncated: false,
+        sessions: [],
+        ...overrides,
+    };
+}
+function createTestSession(name, windows = []) {
+    return {
+        name,
+        attached: true,
+        windows,
+    };
+}
+describe('toXml', () => {
+    test('generates valid XML for empty context', () => {
+        const context = createTestContext({ tmuxRunning: false });
+        const xml = toXml(context);
+        expect(xml).toContain('<tmux_context');
+        expect(xml).toContain('generated_at="2025-01-26T12:00:00.000Z"');
+        expect(xml).toContain('tmux_running="false"');
+        expect(xml).toContain('truncated="false"');
+        expect(xml).toContain('</tmux_context>');
+    });
+    test('includes truncation reason when truncated', () => {
+        const context = createTestContext({
+            truncated: true,
+            truncationReason: 'max-bytes',
+        });
+        const xml = toXml(context);
+        expect(xml).toContain('truncated="true"');
+        expect(xml).toContain('truncation_reason="max-bytes"');
+    });
+    test('generates XML for session with windows and panes', () => {
+        const context = createTestContext({
+            sessions: [
+                createTestSession('work', [
+                    {
+                        id: '@1',
+                        index: 1,
+                        name: 'editor',
+                        active: true,
+                        paneCount: 2,
+                        panes: [
+                            {
+                                index: 0,
+                                active: true,
+                                cwd: '/home/user/project',
+                                cmd: 'nvim',
+                                size: '120x40',
+                                screen: 'vim content here',
+                                redacted: false,
+                            },
+                        ],
+                    },
+                ]),
+            ],
+        });
+        const xml = toXml(context);
+        expect(xml).toContain('<session name="work" attached="true">');
+        expect(xml).toContain('<window id="@1" index="1" name="editor" active="true" panes="2">');
+        expect(xml).toContain('<pane index="0" active="true" cwd="/home/user/project" cmd="nvim" size="120x40">');
+        expect(xml).toContain('<screen redacted="false">');
+        expect(xml).toContain('vim content here');
+    });
+    test('escapes special XML characters', () => {
+        const context = createTestContext({
+            sessions: [
+                createTestSession('test&session', [
+                    {
+                        id: '@1',
+                        index: 1,
+                        name: 'window<>name',
+                        active: true,
+                        paneCount: 1,
+                        panes: [
+                            {
+                                index: 0,
+                                active: true,
+                                cwd: '/path/with"quotes',
+                                cmd: "cmd'test",
+                                size: '80x24',
+                                screen: 'content with <tags> & "quotes"',
+                                redacted: false,
+                            },
+                        ],
+                    },
+                ]),
+            ],
+        });
+        const xml = toXml(context);
+        expect(xml).toContain('name="test&amp;session"');
+        expect(xml).toContain('name="window&lt;&gt;name"');
+        expect(xml).toContain('cwd="/path/with&quot;quotes"');
+        expect(xml).toContain("cmd=\"cmd&apos;test\"");
+        expect(xml).toContain('content with &lt;tags&gt; &amp; &quot;quotes&quot;');
+    });
+    test('handles multiline screen content', () => {
+        const context = createTestContext({
+            sessions: [
+                createTestSession('test', [
+                    {
+                        id: '@1',
+                        index: 1,
+                        name: 'shell',
+                        active: true,
+                        paneCount: 1,
+                        panes: [
+                            {
+                                index: 0,
+                                active: true,
+                                cwd: '/home',
+                                cmd: 'zsh',
+                                size: '80x24',
+                                screen: 'line1\nline2\nline3',
+                                redacted: false,
+                            },
+                        ],
+                    },
+                ]),
+            ],
+        });
+        const xml = toXml(context);
+        expect(xml).toContain('line1');
+        expect(xml).toContain('line2');
+        expect(xml).toContain('line3');
+    });
+    test('indicates redacted panes', () => {
+        const context = createTestContext({
+            sessions: [
+                createTestSession('test', [
+                    {
+                        id: '@1',
+                        index: 1,
+                        name: 'shell',
+                        active: true,
+                        paneCount: 1,
+                        panes: [
+                            {
+                                index: 0,
+                                active: true,
+                                cwd: '/home',
+                                cmd: 'zsh',
+                                size: '80x24',
+                                screen: 'content with ***REDACTED***',
+                                redacted: true,
+                            },
+                        ],
+                    },
+                ]),
+            ],
+        });
+        const xml = toXml(context);
+        expect(xml).toContain('<screen redacted="true">');
+    });
+});
+describe('toJson', () => {
+    test('generates valid JSON', () => {
+        const context = createTestContext();
+        const json = toJson(context);
+        const parsed = JSON.parse(json);
+        expect(parsed.generatedAt).toBe('2025-01-26T12:00:00.000Z');
+        expect(parsed.tmuxRunning).toBe(true);
+        expect(parsed.truncated).toBe(false);
+        expect(parsed.sessions).toEqual([]);
+    });
+    test('includes all session data', () => {
+        const context = createTestContext({
+            sessions: [
+                createTestSession('work', [
+                    {
+                        id: '@1',
+                        index: 1,
+                        name: 'editor',
+                        active: true,
+                        paneCount: 1,
+                        panes: [
+                            {
+                                index: 0,
+                                active: true,
+                                cwd: '/project',
+                                cmd: 'nvim',
+                                size: '120x40',
+                                screen: 'content',
+                                redacted: false,
+                            },
+                        ],
+                    },
+                ]),
+            ],
+        });
+        const json = toJson(context);
+        const parsed = JSON.parse(json);
+        expect(parsed.sessions).toHaveLength(1);
+        expect(parsed.sessions[0].name).toBe('work');
+        expect(parsed.sessions[0].windows).toHaveLength(1);
+        expect(parsed.sessions[0].windows[0].panes).toHaveLength(1);
+        expect(parsed.sessions[0].windows[0].panes[0].screen).toBe('content');
+    });
+    test('preserves truncation info', () => {
+        const context = createTestContext({
+            truncated: true,
+            truncationReason: 'max-lines',
+        });
+        const json = toJson(context);
+        const parsed = JSON.parse(json);
+        expect(parsed.truncated).toBe(true);
+        expect(parsed.truncationReason).toBe('max-lines');
+    });
+});

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

@@ -0,0 +1,8 @@
+/**
+ * tmux module - bridge and context building for agent prompts.
+ */
+export * from "./bridge.js";
+export { buildContext, type ContextOptions, type PaneContext, type SessionContext, type TmuxContext, toJson, toXml, type WindowContext, } from "./context.js";
+export { type AgentPaneMapping, correlateAgentsToPanes, detectAgentType, extractProjectFromPath, getAllPanes, getFocusedPane, isAgentProcess, type MapResult, type PaneLocation, pathsMatch, type UnmappedPane, } from "./map.js";
+export { type FilterConfig, isSensitiveCommand, type RedactMode, redactContent, redactLine, redactTokens, shouldFilterCommand, shouldFilterPath, shouldFilterSession, shouldFilterWindow, shouldRedactLine, } from "./redaction.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/tmux/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,cAAc,aAAa,CAAC;AAG5B,OAAO,EACL,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,MAAM,EACN,KAAK,EACL,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,cAAc,EACd,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,UAAU,EACV,KAAK,YAAY,GAClB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,UAAU,EACf,aAAa,EACb,UAAU,EACV,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC"}

package/dist/lib/tmux/index.js

@@ -0,0 +1,11 @@
+/**
+ * tmux module - bridge and context building for agent prompts.
+ */
+// Core bridge primitives
+export * from "./bridge.js";
+// Context building
+export { buildContext, toJson, toXml, } from "./context.js";
+// Agent ↔ pane mapping
+export { correlateAgentsToPanes, detectAgentType, extractProjectFromPath, getAllPanes, getFocusedPane, isAgentProcess, pathsMatch, } from "./map.js";
+// Redaction utilities
+export { isSensitiveCommand, redactContent, redactLine, redactTokens, shouldFilterCommand, shouldFilterPath, shouldFilterSession, shouldFilterWindow, shouldRedactLine, } from "./redaction.js";

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

@@ -0,0 +1,57 @@
+/**
+ * Agent ↔ tmux pane correlation.
+ * Maps active agent sessions to their tmux panes.
+ */
+import { type ActiveSession } from "../active-sessions.js";
+export interface PaneLocation {
+    sessionName: string;
+    windowId: string;
+    windowIndex: number;
+    windowName: string;
+    paneIndex: number;
+    target: string;
+    cmd: string;
+    cwd: string;
+}
+export interface AgentPaneMapping {
+    session: ActiveSession;
+    pane: PaneLocation | null;
+    matchType: "process" | "cwd" | "none";
+}
+export interface UnmappedPane extends PaneLocation {
+    active: boolean;
+}
+export interface MapResult {
+    mappings: AgentPaneMapping[];
+    unmappedPanes: UnmappedPane[];
+}
+/**
+ * Get all panes across all tmux sessions.
+ */
+export declare function getAllPanes(): Promise<PaneLocation[]>;
+/**
+ * Check if a pane is running an agent CLI.
+ */
+export declare function isAgentProcess(cmd: string): boolean;
+/**
+ * Detect which agent type a process is.
+ */
+export declare function detectAgentType(cmd: string): string | null;
+/**
+ * Check if two paths match (handles trailing slashes, ~).
+ */
+export declare function pathsMatch(path1: string, path2: string): boolean;
+/**
+ * Correlate active agent sessions with tmux panes.
+ */
+export declare function correlateAgentsToPanes(): Promise<MapResult>;
+/**
+ * Get the currently focused tmux pane.
+ */
+export declare function getFocusedPane(): Promise<PaneLocation | null>;
+/**
+ * Extract project name from a path.
+ * Matches ~/Developer/apps/{project} or ~/Developer/utils/{project} patterns.
+ */
+export declare function extractProjectFromPath(path: string): string | null;
+//# sourceMappingURL=map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/lib/tmux/map.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,aAAa,EAA2B,MAAM,uBAAuB,CAAC;AAcpF,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;CACvC;AAED,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,aAAa,EAAE,YAAY,EAAE,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CA0B3D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM1D;AAeD;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;GAEG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,SAAS,CAAC,CAsEjE;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA6BnE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuBlE"}

package/dist/lib/tmux/map.js

@@ -0,0 +1,198 @@
+/**
+ * Agent ↔ tmux pane correlation.
+ * Maps active agent sessions to their tmux panes.
+ */
+import { getActiveSessionManager } from "../active-sessions.js";
+import * as bridge from "./bridge.js";
+/** Agent CLI process names to detect */
+const AGENT_PROCESSES = new Set([
+    "claude",
+    "codex",
+    "copilot",
+    "gemini",
+    "pi",
+    "opencode",
+    "droid",
+]);
+/**
+ * Get all panes across all tmux sessions.
+ */
+export async function getAllPanes() {
+    const panes = [];
+    const sessions = await bridge.listSessions();
+    for (const session of sessions) {
+        const windows = await bridge.listWindows(session.name);
+        for (const window of windows) {
+            const windowPanes = await bridge.listPanes(window.index, session.name);
+            for (const pane of windowPanes) {
+                panes.push({
+                    sessionName: session.name,
+                    windowId: window.id,
+                    windowIndex: window.index,
+                    windowName: window.name,
+                    paneIndex: pane.index,
+                    target: `${session.name}:${window.id}.${pane.index}`,
+                    cmd: pane.currentCommand,
+                    cwd: pane.currentPath,
+                });
+            }
+        }
+    }
+    return panes;
+}
+/**
+ * Check if a pane is running an agent CLI.
+ */
+export function isAgentProcess(cmd) {
+    const lowerCmd = cmd.toLowerCase();
+    return AGENT_PROCESSES.has(lowerCmd);
+}
+/**
+ * Detect which agent type a process is.
+ */
+export function detectAgentType(cmd) {
+    const lowerCmd = cmd.toLowerCase();
+    if (AGENT_PROCESSES.has(lowerCmd)) {
+        return lowerCmd;
+    }
+    return null;
+}
+/**
+ * Normalize a path for comparison.
+ */
+function normalizePath(path) {
+    // Remove trailing slashes, resolve ~ to home
+    let normalized = path.replace(/\/+$/, "");
+    if (normalized.startsWith("~")) {
+        const home = process.env.HOME || "/Users/luke";
+        normalized = normalized.replace(/^~/, home);
+    }
+    return normalized;
+}
+/**
+ * Check if two paths match (handles trailing slashes, ~).
+ */
+export function pathsMatch(path1, path2) {
+    return normalizePath(path1) === normalizePath(path2);
+}
+/**
+ * Correlate active agent sessions with tmux panes.
+ */
+export async function correlateAgentsToPanes() {
+    const manager = getActiveSessionManager();
+    const activeSessions = await manager.listAsync({ status: "running" });
+    const allPanes = await getAllPanes();
+    const mappings = [];
+    const mappedPaneTargets = new Set();
+    for (const session of activeSessions) {
+        let matchedPane = null;
+        let matchType = "none";
+        // Strategy 1: Find pane running the agent CLI with matching cwd
+        for (const pane of allPanes) {
+            if (isAgentProcess(pane.cmd) && session.cwd && pathsMatch(pane.cwd, session.cwd)) {
+                matchedPane = pane;
+                matchType = "process";
+                break;
+            }
+        }
+        // Strategy 2: If no process match, try cwd match only
+        if (!matchedPane && session.cwd) {
+            for (const pane of allPanes) {
+                if (pathsMatch(pane.cwd, session.cwd)) {
+                    matchedPane = pane;
+                    matchType = "cwd";
+                    break;
+                }
+            }
+        }
+        mappings.push({
+            session,
+            pane: matchedPane,
+            matchType,
+        });
+        if (matchedPane) {
+            mappedPaneTargets.add(matchedPane.target);
+        }
+    }
+    // Find unmapped panes (excluding agent processes that weren't matched)
+    const unmappedPanes = [];
+    for (const pane of allPanes) {
+        if (!mappedPaneTargets.has(pane.target)) {
+            // Get active status
+            const sessions = await bridge.listSessions();
+            const tmuxSession = sessions.find((s) => s.name === pane.sessionName);
+            let isActive = false;
+            if (tmuxSession) {
+                const windows = await bridge.listWindows(pane.sessionName);
+                const window = windows.find((w) => w.id === pane.windowId);
+                if (window) {
+                    const panes = await bridge.listPanes(window.index, pane.sessionName);
+                    const p = panes.find((pp) => pp.index === pane.paneIndex);
+                    isActive = p?.active ?? false;
+                }
+            }
+            unmappedPanes.push({
+                ...pane,
+                active: isActive,
+            });
+        }
+    }
+    return { mappings, unmappedPanes };
+}
+/**
+ * Get the currently focused tmux pane.
+ */
+export async function getFocusedPane() {
+    const running = await bridge.isRunning();
+    if (!running)
+        return null;
+    // Get all sessions and find the attached one
+    const sessions = await bridge.listSessions();
+    const attachedSession = sessions.find((s) => s.attached);
+    if (!attachedSession)
+        return null;
+    // Get windows and find the active one
+    const windows = await bridge.listWindows(attachedSession.name);
+    const activeWindow = windows.find((w) => w.active);
+    if (!activeWindow)
+        return null;
+    // Get panes and find the active one
+    const panes = await bridge.listPanes(activeWindow.index, attachedSession.name);
+    const activePane = panes.find((p) => p.active);
+    if (!activePane)
+        return null;
+    return {
+        sessionName: attachedSession.name,
+        windowId: activeWindow.id,
+        windowIndex: activeWindow.index,
+        windowName: activeWindow.name,
+        paneIndex: activePane.index,
+        target: `${attachedSession.name}:${activeWindow.id}.${activePane.index}`,
+        cmd: activePane.currentCommand,
+        cwd: activePane.currentPath,
+    };
+}
+/**
+ * Extract project name from a path.
+ * Matches ~/Developer/apps/{project} or ~/Developer/utils/{project} patterns.
+ */
+export function extractProjectFromPath(path) {
+    const normalized = normalizePath(path);
+    const home = process.env.HOME || "/Users/luke";
+    // Pattern: ~/Developer/apps/{project}/...
+    const appsMatch = normalized.match(new RegExp(`^${home}/Developer/apps/([^/]+)`));
+    if (appsMatch) {
+        return appsMatch[1];
+    }
+    // Pattern: ~/Developer/utils/{project}/...
+    const utilsMatch = normalized.match(new RegExp(`^${home}/Developer/utils/([^/]+)`));
+    if (utilsMatch) {
+        return utilsMatch[1];
+    }
+    // Pattern: ~/Developer/{project}/...
+    const devMatch = normalized.match(new RegExp(`^${home}/Developer/([^/]+)`));
+    if (devMatch) {
+        return devMatch[1];
+    }
+    return null;
+}

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

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

package/dist/lib/tmux/map.test.js

@@ -0,0 +1,80 @@
+import { describe, expect, test } from 'bun:test';
+import { isAgentProcess, detectAgentType, pathsMatch, extractProjectFromPath, } from './map.js';
+describe('isAgentProcess', () => {
+    test('detects claude', () => {
+        expect(isAgentProcess('claude')).toBe(true);
+        expect(isAgentProcess('Claude')).toBe(true);
+    });
+    test('detects codex', () => {
+        expect(isAgentProcess('codex')).toBe(true);
+        expect(isAgentProcess('Codex')).toBe(true);
+    });
+    test('detects copilot', () => {
+        expect(isAgentProcess('copilot')).toBe(true);
+    });
+    test('detects gemini', () => {
+        expect(isAgentProcess('gemini')).toBe(true);
+    });
+    test('rejects non-agent processes', () => {
+        expect(isAgentProcess('nvim')).toBe(false);
+        expect(isAgentProcess('zsh')).toBe(false);
+        expect(isAgentProcess('bash')).toBe(false);
+        expect(isAgentProcess('node')).toBe(false);
+    });
+});
+describe('detectAgentType', () => {
+    test('returns agent type for agent processes', () => {
+        expect(detectAgentType('claude')).toBe('claude');
+        expect(detectAgentType('codex')).toBe('codex');
+        expect(detectAgentType('copilot')).toBe('copilot');
+        expect(detectAgentType('gemini')).toBe('gemini');
+    });
+    test('returns null for non-agent processes', () => {
+        expect(detectAgentType('nvim')).toBe(null);
+        expect(detectAgentType('zsh')).toBe(null);
+    });
+});
+describe('pathsMatch', () => {
+    test('matches identical paths', () => {
+        expect(pathsMatch('/Users/luke/project', '/Users/luke/project')).toBe(true);
+    });
+    test('handles trailing slashes', () => {
+        expect(pathsMatch('/Users/luke/project/', '/Users/luke/project')).toBe(true);
+        expect(pathsMatch('/Users/luke/project', '/Users/luke/project/')).toBe(true);
+        expect(pathsMatch('/Users/luke/project/', '/Users/luke/project/')).toBe(true);
+    });
+    test('expands ~ to home', () => {
+        const home = process.env.HOME || '/Users/luke';
+        expect(pathsMatch('~/project', `${home}/project`)).toBe(true);
+        expect(pathsMatch(`${home}/project`, '~/project')).toBe(true);
+    });
+    test('rejects different paths', () => {
+        expect(pathsMatch('/Users/luke/project1', '/Users/luke/project2')).toBe(false);
+        expect(pathsMatch('/Users/luke', '/Users/luke/project')).toBe(false);
+    });
+});
+describe('extractProjectFromPath', () => {
+    const home = process.env.HOME || '/Users/luke';
+    test('extracts from ~/Developer/apps/{project}', () => {
+        expect(extractProjectFromPath(`${home}/Developer/apps/arbor`)).toBe('arbor');
+        expect(extractProjectFromPath(`${home}/Developer/apps/arbor/src`)).toBe('arbor');
+        expect(extractProjectFromPath(`${home}/Developer/apps/koto-xyz/packages/design`)).toBe('koto-xyz');
+    });
+    test('extracts from ~/Developer/utils/{project}', () => {
+        expect(extractProjectFromPath(`${home}/Developer/utils/agents`)).toBe('agents');
+        expect(extractProjectFromPath(`${home}/Developer/utils/outline/src`)).toBe('outline');
+    });
+    test('extracts from ~/Developer/{project}', () => {
+        expect(extractProjectFromPath(`${home}/Developer/config`)).toBe('config');
+        expect(extractProjectFromPath(`${home}/Developer/forks/pi-mono`)).toBe('forks');
+    });
+    test('returns null for non-matching paths', () => {
+        expect(extractProjectFromPath('/tmp/project')).toBe(null);
+        expect(extractProjectFromPath('/var/log')).toBe(null);
+        expect(extractProjectFromPath(`${home}/Documents/project`)).toBe(null);
+    });
+    test('handles ~ prefix', () => {
+        expect(extractProjectFromPath('~/Developer/apps/arbor')).toBe('arbor');
+        expect(extractProjectFromPath('~/Developer/utils/agents')).toBe('agents');
+    });
+});

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

@@ -0,0 +1,27 @@
+export type PaneMetrics = {
+    paneId: string;
+    cols: number;
+    rows: number;
+    cursorX: number;
+    cursorY: number;
+    cursorFlag: number;
+    title: string;
+};
+export declare function getPaneMetrics(paneId: string): Promise<PaneMetrics | null>;
+export declare function capturePaneScreen(paneId: string, opts: {
+    ansi: boolean;
+    rows: number;
+    cursor?: {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+}): Promise<string>;
+export declare function ensurePipePane(paneId: string, shellCommand: string, opts: {
+    onlyIfUnset: boolean;
+    bidirectional: boolean;
+}): Promise<{
+    attached: boolean;
+    error?: string;
+}>;
+//# sourceMappingURL=panes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panes.d.ts","sourceRoot":"","sources":["../../../src/lib/tmux/panes.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA2FF,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAwBhF;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,GACzF,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE;IAAE,WAAW,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,GACrD,OAAO,CAAC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAahD"}