@creativeintelligence/abbie 0.1.0

package/dist/lib/hooks/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Unified hook type definitions for multi-agent hook management.
+ *
+ * AgentPlatform tracks agents with hook support (native or bridged).
+ * Claude/Codex/Copilot/Gemini have native hooks.
+ * Pi bridges extension events to the unified bash hooks.
+ * opencode/droid can use the bash hooks when spawned via abbie.
+ */
+import type { AgentType } from "../types.js";
+/**
+ * Agent platforms with hook support (native or bridged).
+ * Using AgentType directly — all agents can go through the unified hooks.
+ */
+export type AgentPlatform = AgentType;
+/** All agent platforms with hook support */
+export { AGENTS as HOOK_PLATFORMS } from "../types.js";
+/** Hook event types (normalized across platforms) */
+export type HookEventType = "stop" | "start" | "turn-complete" | "tool-call" | "error" | "custom";
+/** Normalized hook definition */
+export interface Hook {
+    /** Unique identifier (platform:path or platform:name) */
+    id: string;
+    /** Which platform this hook is for */
+    platform: AgentPlatform;
+    /** Event type that triggers this hook */
+    event: HookEventType;
+    /** Path to the hook script/file */
+    path: string;
+    /** Display name */
+    name: string;
+    /** Whether the hook is currently enabled */
+    enabled: boolean;
+    /** Timeout in seconds (if applicable) */
+    timeout?: number;
+    /** Additional platform-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Hook registry - all discovered hooks */
+export interface HookRegistry {
+    /** Hooks grouped by platform */
+    platforms: Record<AgentPlatform, Hook[]>;
+    /** Total hook count */
+    totalCount: number;
+    /** Discovery timestamp */
+    discoveredAt: string;
+    /** Any errors during discovery */
+    errors: HookDiscoveryError[];
+}
+/** Error during hook discovery */
+export interface HookDiscoveryError {
+    platform: AgentPlatform;
+    message: string;
+    path?: string;
+}
+/** Hook test result */
+export interface HookTestResult {
+    hook: Hook;
+    success: boolean;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    durationMs: number;
+    error?: string;
+}
+/** Platform adapter interface */
+export interface HookAdapter {
+    /** Platform identifier */
+    platform: AgentPlatform;
+    /** Discover hooks from platform config */
+    discoverHooks(): Promise<Hook[]>;
+    /** Check if platform config exists */
+    configExists(): boolean;
+    /** Get platform config path */
+    getConfigPath(): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/hooks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/hooks/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC;AAEtC,4CAA4C;AAC5C,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AAEvD,qDAAqD;AACrD,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,OAAO,GACP,eAAe,GACf,WAAW,GACX,OAAO,GACP,QAAQ,CAAC;AAEb,iCAAiC;AACjC,MAAM,WAAW,IAAI;IACnB,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,QAAQ,EAAE,aAAa,CAAC;IACxB,yCAAyC;IACzC,KAAK,EAAE,aAAa,CAAC;IACrB,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,OAAO,EAAE,OAAO,CAAC;IACjB,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;IACzC,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAC9B;AAED,kCAAkC;AAClC,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,uBAAuB;AACvB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,iCAAiC;AACjC,MAAM,WAAW,WAAW;IAC1B,0BAA0B;IAC1B,QAAQ,EAAE,aAAa,CAAC;IACxB,0CAA0C;IAC1C,aAAa,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACjC,sCAAsC;IACtC,YAAY,IAAI,OAAO,CAAC;IACxB,+BAA+B;IAC/B,aAAa,IAAI,MAAM,CAAC;CACzB"}

package/dist/lib/hooks/types.js

@@ -0,0 +1,2 @@
+/** All agent platforms with hook support */
+export { AGENTS as HOOK_PLATFORMS } from "../types.js";

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

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

package/dist/lib/index.test.js

@@ -0,0 +1,334 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, spyOn } from 'bun:test';
+import { mkdirSync, writeFileSync, mkdtempSync, rmSync, utimesSync } from 'fs';
+import { dirname, join } from 'path';
+import * as os from 'os';
+const testHome = mkdtempSync(join(os.tmpdir(), 'agents-home-'));
+let mod;
+let homedirSpy;
+const writeJson = (filePath, data) => {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(data, null, 2));
+};
+const writeJsonl = (filePath, lines) => {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, lines.map((line) => JSON.stringify(line)).join('\n') + '\n');
+};
+const cleanHome = () => {
+    rmSync(join(testHome, '.claude'), { recursive: true, force: true });
+    rmSync(join(testHome, '.codex'), { recursive: true, force: true });
+    rmSync(join(testHome, '.copilot'), { recursive: true, force: true });
+};
+beforeAll(async () => {
+    homedirSpy = spyOn(os, 'homedir').mockReturnValue(testHome);
+    mod = await import('./agent-sessions');
+});
+afterAll(() => {
+    homedirSpy?.mockRestore();
+    cleanHome();
+    rmSync(testHome, { recursive: true, force: true });
+});
+beforeEach(() => {
+    cleanHome();
+});
+describe('agent-sessions', () => {
+    it('returns empty list when no sessions exist', () => {
+        const miner = new mod.AgentSessionMiner();
+        expect(miner.mineAll()).toEqual([]);
+    });
+    it('parses claude session files', () => {
+        const sessionPath = join(testHome, '.claude', 'sessions', 'session-1.json');
+        writeJson(sessionPath, {
+            created_at: '2024-01-01T00:00:00.000Z',
+            updated_at: '2024-01-01T01:00:00.000Z',
+            project: 'arbor',
+            summary: 'work done',
+            files_modified: ['src/a.ts'],
+            issue: 'ARBOR-1',
+        });
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineClaude();
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].agent).toBe('claude');
+        expect(sessions[0].project).toBe('arbor');
+        expect(sessions[0].summary).toBe('work done');
+        expect(sessions[0].files_modified).toEqual(['src/a.ts']);
+        expect(sessions[0].issue).toBe('ARBOR-1');
+    });
+    it('skips malformed claude session files', () => {
+        const badPath = join(testHome, '.claude', 'sessions', 'bad.json');
+        mkdirSync(dirname(badPath), { recursive: true });
+        writeFileSync(badPath, '{bad json');
+        const okPath = join(testHome, '.claude', 'sessions', 'ok.json');
+        writeJson(okPath, { created_at: '2024-01-01T00:00:00.000Z' });
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineClaude();
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].id).toBe('ok');
+    });
+    it('extracts issue from claude messages', () => {
+        const sessionPath = join(testHome, '.claude', 'sessions', 'with-msg.json');
+        writeJson(sessionPath, {
+            created_at: '2024-01-01T00:00:00.000Z',
+            messages: [{ content: 'working on arbor-123' }],
+        });
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineClaude();
+        expect(sessions[0].issue).toBe('ARBOR-123');
+    });
+    it('filters claude sessions by since date', () => {
+        const sessionPath = join(testHome, '.claude', 'sessions', 'old.json');
+        writeJson(sessionPath, { created_at: '2023-01-01T00:00:00.000Z' });
+        const oldDate = new Date('2023-01-01T00:00:00.000Z');
+        utimesSync(sessionPath, oldDate, oldDate);
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineClaude({ since: new Date('2024-01-01T00:00:00.000Z') });
+        expect(sessions).toHaveLength(0);
+    });
+    it('filters claude sessions by project', () => {
+        writeJson(join(testHome, '.claude', 'sessions', 'alpha.json'), {
+            created_at: '2024-01-01T00:00:00.000Z',
+            project: 'alpha',
+        });
+        writeJson(join(testHome, '.claude', 'sessions', 'beta.json'), {
+            created_at: '2024-01-01T00:00:00.000Z',
+            project: 'beta',
+        });
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineClaude({ project: 'alpha' });
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].project).toBe('alpha');
+    });
+    it('parses claude project sessions with project scoping', () => {
+        const sessionPath = join(testHome, '.claude', 'projects', 'koto', 's-1.json');
+        writeJson(sessionPath, {
+            created_at: '2024-02-01T00:00:00.000Z',
+            summary: 'project summary',
+        });
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineClaude({ project: 'koto' });
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].project).toBe('koto');
+        expect(sessions[0].id).toContain('koto-');
+    });
+    it('extracts issue from codex prompt when issue is missing', () => {
+        const sessionPath = join(testHome, '.codex', 'history', 'codex-issue.jsonl');
+        writeJsonl(sessionPath, [
+            { timestamp: '2024-03-02T00:00:00.000Z', cwd: '/Users/luke/Developer/webs/webs-xyz' },
+            { prompt: 'work on webs-12', timestamp: '2024-03-02T01:00:00.000Z' },
+        ]);
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineCodex();
+        expect(sessions[0].issue).toBe('WEBS-12');
+    });
+    it('skips malformed codex lines but still parses sessions', () => {
+        const sessionPath = join(testHome, '.codex', 'history', 'codex-bad.jsonl');
+        const lines = [
+            JSON.stringify({ timestamp: '2024-03-03T00:00:00.000Z', cwd: '/Users/luke/Developer/arbor/arbor-xyz' }),
+            '{bad json',
+            JSON.stringify({ timestamp: '2024-03-03T02:00:00.000Z', type: 'completion', summary: 'ok' }),
+        ];
+        mkdirSync(dirname(sessionPath), { recursive: true });
+        writeFileSync(sessionPath, lines.join('\n') + '\n');
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineCodex();
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].summary).toBe('ok');
+    });
+    it('ignores empty codex history files', () => {
+        const sessionPath = join(testHome, '.codex', 'history', 'empty.jsonl');
+        mkdirSync(dirname(sessionPath), { recursive: true });
+        writeFileSync(sessionPath, '');
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineCodex();
+        expect(sessions).toHaveLength(0);
+    });
+    it('parses codex jsonl sessions with summary, files, commits, and issue', () => {
+        const sessionPath = join(testHome, '.codex', 'history', 'codex-1.jsonl');
+        writeJsonl(sessionPath, [
+            { timestamp: '2024-03-01T00:00:00.000Z', cwd: '/Users/luke/Developer/arbor/arbor-xyz' },
+            { file: 'src/index.ts' },
+            { files: ['README.md'] },
+            { type: 'commit', hash: 'abc123' },
+            { issue: 'ARBOR-123' },
+            { timestamp: '2024-03-01T02:00:00.000Z', type: 'completion', summary: 'done' },
+        ]);
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineCodex();
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].project).toBe('arbor-xyz');
+        expect(sessions[0].summary).toBe('done');
+        expect(sessions[0].files_modified).toEqual(['src/index.ts', 'README.md']);
+        expect(sessions[0].commits).toEqual(['abc123']);
+        expect(sessions[0].issue).toBe('ARBOR-123');
+    });
+    it('parses copilot session state', () => {
+        const sessionId = 'copilot-1';
+        const sessionDir = join(testHome, '.copilot', 'session-state', sessionId);
+        mkdirSync(sessionDir, { recursive: true });
+        // workspace.yaml for metadata
+        writeFileSync(join(sessionDir, 'workspace.yaml'), [
+            `id: ${sessionId}`,
+            'cwd: /Users/luke/Developer/webs/webs-xyz',
+            'created_at: 2024-04-01T00:00:00.000Z',
+            'updated_at: 2024-04-01T01:00:00.000Z',
+            '',
+        ].join('\n'));
+        // events.jsonl for actual summary and issue extraction
+        writeFileSync(join(sessionDir, 'events.jsonl'), [
+            JSON.stringify({ type: 'session.start', data: { context: { branch: 'feat/WEBS-1-auth' } } }),
+            JSON.stringify({ type: 'assistant.message', data: { content: '{"summary": "fixed auth", "status": "success"}' } }),
+        ].join('\n'));
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineCopilot();
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].agent).toBe('copilot');
+        expect(sessions[0].project).toBe('webs-xyz');
+        expect(sessions[0].issue).toBe('WEBS-1');
+        expect(sessions[0].summary).toBe('fixed auth');
+    });
+    it('filters copilot sessions by project', () => {
+        const p1 = join(testHome, '.copilot', 'session-state', 's1', 'workspace.yaml');
+        mkdirSync(dirname(p1), { recursive: true });
+        writeFileSync(p1, [
+            'id: s1',
+            'cwd: /Users/luke/Developer/webs/webs-xyz',
+            'updated_at: 2024-04-01T01:00:00.000Z',
+            '',
+        ].join('\n'));
+        const p2 = join(testHome, '.copilot', 'session-state', 's2', 'workspace.yaml');
+        mkdirSync(dirname(p2), { recursive: true });
+        writeFileSync(p2, [
+            'id: s2',
+            'cwd: /Users/luke/Developer/arbor/arbor-xyz',
+            'updated_at: 2024-04-01T01:00:00.000Z',
+            '',
+        ].join('\n'));
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineCopilot({ project: 'webs-xyz' });
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].project).toBe('webs-xyz');
+    });
+    it('filters copilot sessions by since date', () => {
+        const workspacePath = join(testHome, '.copilot', 'session-state', 'old', 'workspace.yaml');
+        mkdirSync(dirname(workspacePath), { recursive: true });
+        writeFileSync(workspacePath, [
+            'id: old',
+            'cwd: /Users/luke/Developer/webs/webs-xyz',
+            'updated_at: 2023-01-01T00:00:00.000Z',
+            '',
+        ].join('\n'));
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineCopilot({ since: new Date('2024-01-01T00:00:00.000Z') });
+        expect(sessions).toHaveLength(0);
+    });
+    it('mineAll sorts by last activity descending', () => {
+        writeJson(join(testHome, '.claude', 'sessions', 'c1.json'), {
+            updated_at: '2024-01-01T01:00:00.000Z',
+            project: 'alpha',
+        });
+        writeJsonl(join(testHome, '.codex', 'history', 'x1.jsonl'), [
+            { timestamp: '2024-01-01T02:00:00.000Z', cwd: '/Users/luke/Developer/webs/webs-xyz' },
+        ]);
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineAll();
+        expect(sessions).toHaveLength(2);
+        expect(sessions[0].agent).toBe('codex');
+    });
+    it('mineAll includes all agent types when present', () => {
+        writeJson(join(testHome, '.claude', 'sessions', 'c1.json'), {
+            updated_at: '2024-01-01T01:00:00.000Z',
+            project: 'alpha',
+        });
+        writeJsonl(join(testHome, '.codex', 'history', 'x1.jsonl'), [
+            { timestamp: '2024-01-01T02:00:00.000Z', cwd: '/Users/luke/Developer/webs/webs-xyz' },
+        ]);
+        const workspacePath = join(testHome, '.copilot', 'session-state', 'copilot-1', 'workspace.yaml');
+        mkdirSync(dirname(workspacePath), { recursive: true });
+        writeFileSync(workspacePath, [
+            'id: copilot-1',
+            'cwd: /Users/luke/Developer/webs/webs-xyz',
+            'updated_at: 2024-04-01T01:00:00.000Z',
+            '',
+        ].join('\n'));
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.mineAll();
+        const agents = new Set(sessions.map((s) => s.agent));
+        expect(agents.has('claude')).toBe(true);
+        expect(agents.has('codex')).toBe(true);
+        expect(agents.has('copilot')).toBe(true);
+    });
+    it('getSessionsByIssue filters matching issues', () => {
+        writeJson(join(testHome, '.claude', 'sessions', 'c2.json'), {
+            updated_at: '2024-01-01T01:00:00.000Z',
+            project: 'alpha',
+            issue: 'ARBOR-999',
+        });
+        const sessionDir = join(testHome, '.copilot', 'session-state', 'c3');
+        mkdirSync(sessionDir, { recursive: true });
+        writeFileSync(join(sessionDir, 'workspace.yaml'), [
+            'id: c3',
+            'cwd: /Users/luke/Developer/alpha/alpha',
+            'updated_at: 2024-01-01T02:00:00.000Z',
+            '',
+        ].join('\n'));
+        // events.jsonl with issue reference
+        writeFileSync(join(sessionDir, 'events.jsonl'), [
+            JSON.stringify({ type: 'session.start', data: { context: { branch: 'feat/WEBS-1' } } }),
+            JSON.stringify({ type: 'assistant.message', data: { content: '{"summary": "done"}' } }),
+        ].join('\n'));
+        const miner = new mod.AgentSessionMiner();
+        const sessions = miner.getSessionsByIssue('WEBS-1');
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].issue).toBe('WEBS-1');
+    });
+    it('correlateSessions attaches commits when issue matches', () => {
+        const miner = new mod.AgentSessionMiner();
+        const mineAllSpy = spyOn(miner, 'mineAll').mockReturnValue([
+            {
+                id: 's-1',
+                agent: 'claude',
+                project: 'arbor',
+                started_at: '2024-01-01T00:00:00.000Z',
+                last_activity: '2024-01-01T01:00:00.000Z',
+                path: '/tmp/session.json',
+                issue: 'ARBOR-123',
+            },
+        ]);
+        const getRecentCommitsSpy = spyOn(miner, 'getRecentCommits').mockReturnValue([
+            'abc123 ARBOR-123 test commit',
+        ]);
+        const sessions = miner.correlateSessions('/tmp/repo');
+        expect(sessions[0].commits).toContain('abc123');
+        mineAllSpy.mockRestore();
+        getRecentCommitsSpy.mockRestore();
+    });
+    it('getRecentCommits returns empty array when git fails', () => {
+        const miner = new mod.AgentSessionMiner();
+        expect(miner.getRecentCommits('/path/does-not-exist')).toEqual([]);
+    });
+    it('getRecentSessions passes project to mineAll', () => {
+        const miner = new mod.AgentSessionMiner();
+        const mineAllSpy = spyOn(miner, 'mineAll').mockReturnValue([]);
+        miner.getRecentSessions('webs');
+        expect(mineAllSpy).toHaveBeenCalledTimes(1);
+        const args = mineAllSpy.mock.calls[0][0];
+        expect(args.project).toBe('webs');
+        expect(args.since).toBeInstanceOf(Date);
+        mineAllSpy.mockRestore();
+    });
+    it('getTodaySessions passes project to mineAll', () => {
+        const miner = new mod.AgentSessionMiner();
+        const mineAllSpy = spyOn(miner, 'mineAll').mockReturnValue([]);
+        miner.getTodaySessions('roles');
+        expect(mineAllSpy).toHaveBeenCalledTimes(1);
+        const args = mineAllSpy.mock.calls[0][0];
+        expect(args.project).toBe('roles');
+        expect(args.since).toBeInstanceOf(Date);
+        mineAllSpy.mockRestore();
+    });
+    it('getSessionMiner returns a singleton instance', () => {
+        const first = mod.getSessionMiner();
+        const second = mod.getSessionMiner();
+        expect(first).toBe(second);
+    });
+});

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

@@ -0,0 +1,27 @@
+/**
+ * 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-session.d.ts","sourceRoot":"","sources":["../../src/lib/managed-session.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAgC5D;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,qDAUvC;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGrE"}

package/dist/lib/managed-session.js

@@ -0,0 +1,105 @@
+/**
+ * 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/math.d.ts

@@ -0,0 +1,21 @@
+export declare const add: (a: number, b: number) => number;
+export declare const subtract: (a: number, b: number) => number;
+export declare const multiply: (a: number, b: number) => number;
+export declare const divide: (a: number, b: number) => number;
+export declare const modulo: (a: number, b: number) => number;
+export declare const power: (base: number, exponent: number) => number;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const lerp: (start: number, end: number, t: number) => number;
+export declare const roundTo: (value: number, decimals: number) => number;
+export declare const sum: (...numbers: number[]) => number;
+export declare const average: (...numbers: number[]) => number;
+export declare const fibonacci: (n: number) => number;
+export declare const gcd: (a: number, b: number) => number;
+export declare const lcm: (a: number, b: number) => number;
+export declare const isPrime: (n: number) => boolean;
+export declare const factorial: (n: number) => number;
+export declare const degreesToRadians: (degrees: number) => number;
+export declare const radiansToDegrees: (radians: number) => number;
+export declare const randomRange: (min: number, max: number) => number;
+export declare const randomInt: (min: number, max: number) => number;
+//# sourceMappingURL=math.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../src/lib/math.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAAe,CAAC;AAE3D,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAAe,CAAC;AAEhE,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAAe,CAAC;AAEhE,eAAO,MAAM,MAAM,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAK7C,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAK7C,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,EAAE,UAAU,MAAM,KAAG,MAYtD,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAE/D,CAAC;AAEF,eAAO,MAAM,IAAI,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,MAAM,KAAG,MAG5D,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,EAAE,UAAU,MAAM,KAAG,MAGzD,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,GAAG,SAAS,MAAM,EAAE,KAAG,MAE1C,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,GAAG,SAAS,MAAM,EAAE,KAAG,MAK9C,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,GAAG,MAAM,KAAG,MAWrC,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAO1C,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAG1C,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,OASnC,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,GAAG,MAAM,KAAG,MAUrC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAAmC,CAAC;AAEvF,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAAmC,CAAC;AAEvF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAEtD,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAEpD,CAAC"}