@creativeintelligence/abbie 0.1.0

package/dist/lib/heartbeat.js

@@ -0,0 +1,230 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { createEvent, EventStore } from "./events.js";
+const DEFAULT_CONFIG = {
+    interval_ms: 60000,
+    stale_threshold_ms: 300000,
+    dead_threshold_ms: 900000,
+};
+/**
+ * Session heartbeat manager.
+ */
+export class HeartbeatManager {
+    basePath;
+    config;
+    eventStore;
+    intervalId;
+    constructor(basePath = "~/.abbie/sessions", config = {}, eventStore) {
+        this.basePath = basePath.replace("~", process.env.HOME || "");
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.eventStore = eventStore || new EventStore();
+        if (!existsSync(this.basePath)) {
+            mkdirSync(this.basePath, { recursive: true });
+        }
+    }
+    /**
+     * Get the heartbeat file path for a session.
+     */
+    getHeartbeatPath(sessionId) {
+        const project = this.extractProject(sessionId);
+        const projectDir = join(this.basePath, project);
+        if (!existsSync(projectDir)) {
+            mkdirSync(projectDir, { recursive: true });
+        }
+        return join(projectDir, `${sessionId}.json`);
+    }
+    /**
+     * Register a new session.
+     */
+    register(sessionId, agent, options) {
+        const now = new Date().toISOString();
+        const liveness = {
+            session_id: sessionId,
+            agent,
+            project: options.project,
+            issue: options.issue,
+            worktree: options.worktree,
+            started_at: now,
+            last_heartbeat: now,
+            status: "active",
+            pid: options.pid || process.pid,
+        };
+        writeFileSync(this.getHeartbeatPath(sessionId), JSON.stringify(liveness, null, 2));
+        return liveness;
+    }
+    /**
+     * Send a heartbeat for a session.
+     */
+    heartbeat(sessionId, options = {}) {
+        const path = this.getHeartbeatPath(sessionId);
+        if (!existsSync(path)) {
+            return undefined;
+        }
+        const liveness = JSON.parse(readFileSync(path, "utf-8"));
+        liveness.last_heartbeat = new Date().toISOString();
+        liveness.status = options.status || "active";
+        liveness.current_task = options.current_task;
+        writeFileSync(path, JSON.stringify(liveness, null, 2));
+        // Also log to event store
+        this.eventStore.append(createEvent.heartbeat(sessionId, liveness.agent, {
+            status: liveness.status,
+            current_task: liveness.current_task,
+        }));
+        return liveness;
+    }
+    /**
+     * Get session liveness state.
+     */
+    get(sessionId) {
+        const path = this.getHeartbeatPath(sessionId);
+        if (!existsSync(path)) {
+            return undefined;
+        }
+        const liveness = JSON.parse(readFileSync(path, "utf-8"));
+        return this.updateStatus(liveness);
+    }
+    /**
+     * Update status based on heartbeat age.
+     */
+    updateStatus(liveness) {
+        const lastHeartbeat = new Date(liveness.last_heartbeat).getTime();
+        const now = Date.now();
+        const age = now - lastHeartbeat;
+        if (age > this.config.dead_threshold_ms) {
+            liveness.status = "dead";
+        }
+        else if (age > this.config.stale_threshold_ms) {
+            liveness.status = "stale";
+        }
+        return liveness;
+    }
+    /**
+     * Deregister a session (on clean exit).
+     */
+    deregister(sessionId) {
+        const path = this.getHeartbeatPath(sessionId);
+        if (existsSync(path)) {
+            unlinkSync(path);
+        }
+    }
+    /**
+     * List all sessions for a project.
+     */
+    listSessions(project) {
+        const projectDir = join(this.basePath, project);
+        if (!existsSync(projectDir)) {
+            return [];
+        }
+        return readdirSync(projectDir)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => {
+            const path = join(projectDir, f);
+            const liveness = JSON.parse(readFileSync(path, "utf-8"));
+            return this.updateStatus(liveness);
+        });
+    }
+    /**
+     * List active sessions across all projects.
+     */
+    listActiveSessions() {
+        if (!existsSync(this.basePath)) {
+            return [];
+        }
+        const projects = readdirSync(this.basePath).filter((name) => {
+            const path = join(this.basePath, name);
+            return statSync(path).isDirectory();
+        });
+        const sessions = [];
+        for (const project of projects) {
+            sessions.push(...this.listSessions(project).filter((s) => s.status === "active"));
+        }
+        return sessions;
+    }
+    /**
+     * List stale/dead sessions for cleanup.
+     */
+    listStaleSessions() {
+        if (!existsSync(this.basePath)) {
+            return [];
+        }
+        const projects = readdirSync(this.basePath).filter((name) => {
+            const path = join(this.basePath, name);
+            return statSync(path).isDirectory();
+        });
+        const sessions = [];
+        for (const project of projects) {
+            sessions.push(...this.listSessions(project).filter((s) => s.status === "stale" || s.status === "dead"));
+        }
+        return sessions;
+    }
+    /**
+     * Clean up dead sessions.
+     */
+    cleanup() {
+        const staleSessions = this.listStaleSessions();
+        let cleaned = 0;
+        for (const session of staleSessions) {
+            if (session.status === "dead") {
+                this.deregister(session.session_id);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * Check if a session is alive.
+     */
+    isAlive(sessionId) {
+        const liveness = this.get(sessionId);
+        if (!liveness)
+            return false;
+        return liveness.status === "active" || liveness.status === "idle";
+    }
+    /**
+     * Check if a worktree is in use.
+     */
+    isWorktreeInUse(worktree) {
+        const activeSessions = this.listActiveSessions();
+        return activeSessions.find((s) => s.worktree === worktree);
+    }
+    /**
+     * Start automatic heartbeat for current session.
+     */
+    startAutoHeartbeat(sessionId, getCurrentTask) {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+        }
+        this.intervalId = setInterval(() => {
+            this.heartbeat(sessionId, {
+                status: "active",
+                current_task: getCurrentTask?.(),
+            });
+        }, this.config.interval_ms);
+        // Clean up on process exit
+        const cleanup = () => {
+            if (this.intervalId) {
+                clearInterval(this.intervalId);
+            }
+            this.deregister(sessionId);
+        };
+        process.on("exit", cleanup);
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    }
+    /**
+     * Stop automatic heartbeat.
+     */
+    stopAutoHeartbeat() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    /**
+     * Extract project from session ID.
+     */
+    extractProject(sessionId) {
+        const parts = sessionId.split("-");
+        return parts[0];
+    }
+}

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

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

package/dist/lib/heartbeat.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { HeartbeatManager } from './heartbeat';
+import { EventStore } from './events';
+describe('HeartbeatManager', () => {
+    let tempDir;
+    let eventsDir;
+    let manager;
+    let eventStore;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), 'agents-heartbeat-test-'));
+        eventsDir = mkdtempSync(join(tmpdir(), 'agents-events-test-'));
+        eventStore = new EventStore(eventsDir);
+        // faster thresholds for testing
+        manager = new HeartbeatManager(tempDir, {
+            interval_ms: 100,
+            stale_threshold_ms: 200,
+            dead_threshold_ms: 400
+        }, eventStore);
+    });
+    afterEach(() => {
+        manager.stopAutoHeartbeat();
+        rmSync(tempDir, { recursive: true, force: true });
+        rmSync(eventsDir, { recursive: true, force: true });
+    });
+    it('registers a new session', () => {
+        const session = manager.register('test-project-123', 'claude', {
+            project: 'test-project',
+            issue: 'TEST-1'
+        });
+        expect(session.session_id).toBe('test-project-123');
+        expect(session.status).toBe('active');
+        expect(session.project).toBe('test-project');
+        // Check file exists - extractProject takes first part before hyphen ('test')
+        const projectDir = join(tempDir, 'test');
+        const sessionPath = join(projectDir, 'test-project-123.json');
+        expect(existsSync(sessionPath)).toBe(true);
+        const stored = JSON.parse(readFileSync(sessionPath, 'utf-8'));
+        expect(stored.session_id).toBe('test-project-123');
+    });
+    it('updates heartbeat', async () => {
+        const id = 'test-project-123';
+        const session = manager.register(id, 'claude', { project: 'test-project' });
+        const initialTime = new Date(session.last_heartbeat).getTime();
+        // Wait a bit
+        await new Promise(resolve => setTimeout(resolve, 50));
+        const updated = manager.heartbeat(id, { current_task: 'working' });
+        expect(updated).toBeDefined();
+        expect(new Date(updated.last_heartbeat).getTime()).toBeGreaterThan(initialTime);
+        expect(updated.current_task).toBe('working');
+        // Check event store
+        const events = eventStore.readSession(id);
+        expect(events.some(e => e.type === 'session:heartbeat')).toBe(true);
+    });
+    it('detects stale sessions', async () => {
+        const id = 'test-project-stale';
+        manager.register(id, 'claude', { project: 'test-project' });
+        // Wait for stale threshold
+        await new Promise(resolve => setTimeout(resolve, 250));
+        const session = manager.get(id);
+        expect(session?.status).toBe('stale');
+    });
+    it('detects dead sessions', async () => {
+        const id = 'test-project-dead';
+        manager.register(id, 'claude', { project: 'test-project' });
+        // Wait for dead threshold
+        await new Promise(resolve => setTimeout(resolve, 450));
+        const session = manager.get(id);
+        expect(session?.status).toBe('dead');
+    });
+    it('lists active sessions', () => {
+        manager.register('p1-active', 'claude', { project: 'p1' });
+        manager.register('p2-active', 'codex', { project: 'p2' });
+        // Manually create a dead session file to test filtering
+        const deadSession = {
+            session_id: 'p1-dead',
+            agent: 'claude',
+            project: 'p1',
+            started_at: new Date(Date.now() - 10000).toISOString(),
+            last_heartbeat: new Date(Date.now() - 10000).toISOString(),
+            status: 'active' // Will be computed as dead on read
+        };
+        mkdirSync(join(tempDir, 'p1'), { recursive: true });
+        writeFileSync(join(tempDir, 'p1', 'p1-dead.json'), JSON.stringify(deadSession));
+        const active = manager.listActiveSessions();
+        expect(active).toHaveLength(2);
+        expect(active.map(s => s.session_id).sort()).toEqual(['p1-active', 'p2-active']);
+    });
+    it('cleans up dead sessions', async () => {
+        manager.register('p1-dead', 'claude', { project: 'p1' });
+        // Wait for dead threshold
+        await new Promise(resolve => setTimeout(resolve, 450));
+        const cleaned = manager.cleanup();
+        expect(cleaned).toBe(1);
+        const sessionPath = join(tempDir, 'p1', 'p1-dead.json');
+        expect(existsSync(sessionPath)).toBe(false);
+    });
+    it('deregisters a session', () => {
+        manager.register('p1-done', 'claude', { project: 'p1' });
+        manager.deregister('p1-done');
+        const sessionPath = join(tempDir, 'p1', 'p1-done.json');
+        expect(existsSync(sessionPath)).toBe(false);
+    });
+    it('handles auto heartbeat', async () => {
+        const id = 'p1-auto';
+        manager.register(id, 'claude', { project: 'p1' });
+        let task = 'task 1';
+        manager.startAutoHeartbeat(id, () => task);
+        // Initial state
+        let session = manager.get(id);
+        const time1 = new Date(session.last_heartbeat).getTime();
+        // Wait for interval
+        await new Promise(resolve => setTimeout(resolve, 150));
+        // Update task for next tick
+        task = 'task 2';
+        session = manager.get(id);
+        const time2 = new Date(session.last_heartbeat).getTime();
+        expect(time2).toBeGreaterThan(time1);
+        expect(session.current_task).toBe('task 1'); // Captured from previous tick
+        manager.stopAutoHeartbeat();
+    });
+});

package/dist/lib/hooks/adapters/claude.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Claude Code hook adapter.
+ *
+ * Reads hooks from ~/.claude/settings.json
+ *
+ * Format:
+ * {
+ *   "hooks": {
+ *     "Stop": [{
+ *       "hooks": [{
+ *         "type": "command",
+ *         "command": "~/.claude/hooks/notify-stop.sh",
+ *         "timeout": 30
+ *       }]
+ *     }]
+ *   }
+ * }
+ */
+import type { Hook, HookAdapter } from "../types.js";
+export declare class ClaudeAdapter implements HookAdapter {
+    readonly platform: "claude";
+    private configPath;
+    constructor();
+    configExists(): boolean;
+    getConfigPath(): string;
+    discoverHooks(): Promise<Hook[]>;
+}
+//# sourceMappingURL=claude.d.ts.map

package/dist/lib/hooks/adapters/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../../../src/lib/hooks/adapters/claude.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAiB,MAAM,aAAa,CAAC;AAwBpE,qBAAa,aAAc,YAAW,WAAW;IAC/C,QAAQ,CAAC,QAAQ,EAAG,QAAQ,CAAU;IAEtC,OAAO,CAAC,UAAU,CAAS;;IAO3B,YAAY,IAAI,OAAO;IAIvB,aAAa,IAAI,MAAM;IAIjB,aAAa,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;CAmDvC"}

package/dist/lib/hooks/adapters/claude.js

@@ -0,0 +1,85 @@
+/**
+ * Claude Code hook adapter.
+ *
+ * Reads hooks from ~/.claude/settings.json
+ *
+ * Format:
+ * {
+ *   "hooks": {
+ *     "Stop": [{
+ *       "hooks": [{
+ *         "type": "command",
+ *         "command": "~/.claude/hooks/notify-stop.sh",
+ *         "timeout": 30
+ *       }]
+ *     }]
+ *   }
+ * }
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Claude Code hook event mapping */
+const EVENT_MAP = {
+    Stop: "stop",
+    Start: "start",
+    // Add more as Claude Code adds them
+};
+export class ClaudeAdapter {
+    platform = "claude";
+    configPath;
+    constructor() {
+        const home = process.env.HOME || "~";
+        this.configPath = join(home, ".claude", "settings.json");
+    }
+    configExists() {
+        return existsSync(this.configPath);
+    }
+    getConfigPath() {
+        return this.configPath;
+    }
+    async discoverHooks() {
+        if (!this.configExists()) {
+            return [];
+        }
+        try {
+            const content = readFileSync(this.configPath, "utf-8");
+            const settings = JSON.parse(content);
+            if (!settings.hooks) {
+                return [];
+            }
+            const hooks = [];
+            for (const [eventKey, groups] of Object.entries(settings.hooks)) {
+                const eventType = EVENT_MAP[eventKey] || "custom";
+                for (const group of groups) {
+                    if (!group.hooks)
+                        continue;
+                    for (const hookEntry of group.hooks) {
+                        if (hookEntry.type !== "command" || !hookEntry.command)
+                            continue;
+                        // Expand ~ in path
+                        const path = hookEntry.command.replace(/^~/, process.env.HOME || "~");
+                        const name = path.split("/").pop() || hookEntry.command;
+                        hooks.push({
+                            id: `claude:${hookEntry.command}`,
+                            platform: "claude",
+                            event: eventType,
+                            path,
+                            name,
+                            enabled: true,
+                            timeout: hookEntry.timeout,
+                            metadata: {
+                                originalEvent: eventKey,
+                                type: hookEntry.type,
+                            },
+                        });
+                    }
+                }
+            }
+            return hooks;
+        }
+        catch (_error) {
+            // Return empty on parse errors - registry will capture the error
+            return [];
+        }
+    }
+}

package/dist/lib/hooks/adapters/codex.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Codex hook adapter.
+ *
+ * Reads hooks from ~/.codex/config.toml
+ *
+ * Format:
+ * notify = ["python3", "/path/to/script.py"]
+ *
+ * Codex passes JSON as CLI argument (not stdin like Claude)
+ */
+import type { Hook, HookAdapter } from "../types.js";
+export declare class CodexAdapter implements HookAdapter {
+    readonly platform: "codex";
+    private configPath;
+    constructor();
+    configExists(): boolean;
+    getConfigPath(): string;
+    discoverHooks(): Promise<Hook[]>;
+}
+//# sourceMappingURL=codex.d.ts.map

package/dist/lib/hooks/adapters/codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../../src/lib/hooks/adapters/codex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAuBrD,qBAAa,YAAa,YAAW,WAAW;IAC9C,QAAQ,CAAC,QAAQ,EAAG,OAAO,CAAU;IAErC,OAAO,CAAC,UAAU,CAAS;;IAO3B,YAAY,IAAI,OAAO;IAIvB,aAAa,IAAI,MAAM;IAIjB,aAAa,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;CAqCvC"}

package/dist/lib/hooks/adapters/codex.js

@@ -0,0 +1,77 @@
+/**
+ * Codex hook adapter.
+ *
+ * Reads hooks from ~/.codex/config.toml
+ *
+ * Format:
+ * notify = ["python3", "/path/to/script.py"]
+ *
+ * Codex passes JSON as CLI argument (not stdin like Claude)
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Simple TOML parser for the notify array */
+function parseNotifyFromToml(content) {
+    // Look for notify = [...] pattern
+    const match = content.match(/^notify\s*=\s*\[(.*?)\]/ms);
+    if (!match)
+        return null;
+    // Extract array contents and parse
+    const arrayContent = match[1];
+    const items = [];
+    // Match quoted strings
+    const stringPattern = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'/g;
+    let stringMatch = stringPattern.exec(arrayContent);
+    while (stringMatch !== null) {
+        items.push(stringMatch[1] || stringMatch[2]);
+        stringMatch = stringPattern.exec(arrayContent);
+    }
+    return items.length > 0 ? items : null;
+}
+export class CodexAdapter {
+    platform = "codex";
+    configPath;
+    constructor() {
+        const home = process.env.HOME || "~";
+        this.configPath = join(home, ".codex", "config.toml");
+    }
+    configExists() {
+        return existsSync(this.configPath);
+    }
+    getConfigPath() {
+        return this.configPath;
+    }
+    async discoverHooks() {
+        if (!this.configExists()) {
+            return [];
+        }
+        try {
+            const content = readFileSync(this.configPath, "utf-8");
+            const notifyCmd = parseNotifyFromToml(content);
+            if (!notifyCmd || notifyCmd.length === 0) {
+                return [];
+            }
+            // notify is a command array like ["python3", "/path/to/script.py"]
+            // The script path is typically the last element
+            const scriptPath = notifyCmd[notifyCmd.length - 1];
+            const expandedPath = scriptPath.replace(/^~/, process.env.HOME || "~");
+            const name = expandedPath.split("/").pop() || scriptPath;
+            const hook = {
+                id: `codex:${scriptPath}`,
+                platform: "codex",
+                event: "turn-complete", // Codex notify fires on agent-turn-complete
+                path: expandedPath,
+                name,
+                enabled: true,
+                metadata: {
+                    command: notifyCmd,
+                    invocationStyle: "cli-arg", // Codex passes JSON as CLI arg
+                },
+            };
+            return [hook];
+        }
+        catch (_error) {
+            return [];
+        }
+    }
+}

package/dist/lib/hooks/adapters/copilot.d.ts

@@ -0,0 +1,29 @@
+/**
+ * GitHub Copilot hook adapter.
+ *
+ * Reads hooks from .github/hooks/hooks.json in the current working directory.
+ * Also checks ~/.abbie/templates/github-hooks/hooks.json for global template.
+ *
+ * Format:
+ * {
+ *   "version": 1,
+ *   "hooks": {
+ *     "sessionStart": [{ "type": "command", "bash": "...", "timeoutSec": 30 }],
+ *     "sessionEnd": [...],
+ *     "preToolUse": [...],
+ *     "postToolUse": [...],
+ *     "errorOccurred": [...]
+ *   }
+ * }
+ */
+import type { Hook, HookAdapter } from "../types.js";
+export declare class CopilotAdapter implements HookAdapter {
+    readonly platform: "copilot";
+    private configPath;
+    private globalTemplatePath;
+    constructor();
+    configExists(): boolean;
+    getConfigPath(): string;
+    discoverHooks(): Promise<Hook[]>;
+}
+//# sourceMappingURL=copilot.d.ts.map

package/dist/lib/hooks/adapters/copilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot.d.ts","sourceRoot":"","sources":["../../../../src/lib/hooks/adapters/copilot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAiB,MAAM,aAAa,CAAC;AA4BpE,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,QAAQ,EAAG,SAAS,CAAU;IAEvC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,kBAAkB,CAAS;;IAUnC,YAAY,IAAI,OAAO;IAIvB,aAAa,IAAI,MAAM;IAgBjB,aAAa,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;CAyDvC"}