@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/events.ts

@@ -1,479 +0,0 @@
-import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-
-/**
- * Event types for session lifecycle.
- */
-export type EventType =
-  | "session:start"
-  | "session:heartbeat"
-  | "session:checkpoint"
-  | "session:complete"
-  | "session:blocked"
-  | "session:failed"
-  | "task:start"
-  | "task:complete"
-  | "task:blocked"
-  | "preview:created"
-  | "preview:shared"
-  | "resource:acquired"
-  | "resource:released"
-  | "notification:sent";
-
-/**
- * Base event structure.
- */
-export interface BaseEvent {
-  id: string;
-  type: EventType;
-  timestamp: string;
-  session_id: string;
-  agent: string;
-}
-
-/**
- * Session start event.
- */
-export interface SessionStartEvent extends BaseEvent {
-  type: "session:start";
-  data: {
-    project: string;
-    issue?: string;
-    worktree?: string;
-    config_path?: string;
-  };
-}
-
-/**
- * Session heartbeat event.
- */
-export interface SessionHeartbeatEvent extends BaseEvent {
-  type: "session:heartbeat";
-  data: {
-    status: "active" | "idle";
-    current_task?: string;
-  };
-}
-
-/**
- * Session checkpoint event.
- */
-export interface SessionCheckpointEvent extends BaseEvent {
-  type: "session:checkpoint";
-  data: {
-    progress: number; // 0-100
-    summary: string;
-    files_changed?: string[];
-    commits?: string[];
-  };
-}
-
-/**
- * Session complete event.
- */
-export interface SessionCompleteEvent extends BaseEvent {
-  type: "session:complete";
-  data: {
-    summary: string;
-    artifacts: Array<{
-      type: "commit" | "pr" | "file" | "preview";
-      ref: string;
-      url?: string;
-    }>;
-    duration_ms: number;
-  };
-}
-
-/**
- * Session blocked event.
- */
-export interface SessionBlockedEvent extends BaseEvent {
-  type: "session:blocked";
-  data: {
-    reason: string;
-    blocker_type: "hil" | "error" | "dependency" | "resource";
-    context?: Record<string, unknown>;
-  };
-}
-
-/**
- * Task start event.
- */
-export interface TaskStartEvent extends BaseEvent {
-  type: "task:start";
-  data: {
-    task_id: string;
-    description: string;
-    issue?: string;
-  };
-}
-
-/**
- * Task complete event.
- */
-export interface TaskCompleteEvent extends BaseEvent {
-  type: "task:complete";
-  data: {
-    task_id: string;
-    summary: string;
-    confidence: number;
-  };
-}
-
-/**
- * Preview created event.
- */
-export interface PreviewCreatedEvent extends BaseEvent {
-  type: "preview:created";
-  data: {
-    url: string;
-    port: number;
-    subdomain: string;
-    issue?: string;
-  };
-}
-
-/**
- * Resource acquired event.
- */
-export interface ResourceAcquiredEvent extends BaseEvent {
-  type: "resource:acquired";
-  data: {
-    resource: string;
-    lease_id: string;
-    expires_at: string;
-  };
-}
-
-/**
- * Resource released event.
- */
-export interface ResourceReleasedEvent extends BaseEvent {
-  type: "resource:released";
-  data: {
-    resource: string;
-    lease_id: string;
-  };
-}
-
-/**
- * Union of all event types.
- */
-export type SessionEvent =
-  | SessionStartEvent
-  | SessionHeartbeatEvent
-  | SessionCheckpointEvent
-  | SessionCompleteEvent
-  | SessionBlockedEvent
-  | TaskStartEvent
-  | TaskCompleteEvent
-  | PreviewCreatedEvent
-  | ResourceAcquiredEvent
-  | ResourceReleasedEvent
-  | (BaseEvent & { data?: Record<string, unknown> });
-
-/**
- * Generate a unique event ID.
- */
-function generateEventId(): string {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).slice(2, 8);
-  return `${timestamp}-${random}`;
-}
-
-/**
- * Event store for append-only session events.
- */
-export class EventStore {
-  private basePath: string;
-
-  constructor(basePath: string = "~/.abbie/events") {
-    this.basePath = basePath.replace("~", process.env.HOME || "");
-    if (!existsSync(this.basePath)) {
-      mkdirSync(this.basePath, { recursive: true });
-    }
-  }
-
-  /**
-   * Get the event log path for a project.
-   */
-  private getLogPath(project: string): string {
-    const projectDir = join(this.basePath, project);
-    if (!existsSync(projectDir)) {
-      mkdirSync(projectDir, { recursive: true });
-    }
-    return join(projectDir, "events.jsonl");
-  }
-
-  /**
-   * Append an event to the log.
-   */
-  append(event: Omit<SessionEvent, "id" | "timestamp">): SessionEvent {
-    const fullEvent: SessionEvent = {
-      ...event,
-      id: generateEventId(),
-      timestamp: new Date().toISOString(),
-    } as SessionEvent;
-
-    const project = this.extractProject(fullEvent.session_id);
-    const logPath = this.getLogPath(project);
-    appendFileSync(logPath, `${JSON.stringify(fullEvent)}\n`);
-
-    // Best-effort Convex write (fire-and-forget)
-    this.appendToStore(fullEvent).catch(() => {});
-
-    return fullEvent;
-  }
-
-  /**
-   * Best-effort write event to Convex store.
-   */
-  private async appendToStore(event: SessionEvent): Promise<void> {
-    try {
-      const { getHttpClient, api } = await import("@creativeintelligence/sdk/convex");
-      const client = getHttpClient();
-      await client.mutation(api.events.append, {
-        sessionId: event.session_id,
-        eventType: event.type,
-        payload: "data" in event ? event.data : {},
-      });
-    } catch {
-      // Best-effort: local JSONL is the primary record
-    }
-  }
-
-  /**
-   * Read all events for a project.
-   */
-  readAll(project: string): SessionEvent[] {
-    const logPath = this.getLogPath(project);
-    if (!existsSync(logPath)) {
-      return [];
-    }
-
-    const content = readFileSync(logPath, "utf-8");
-    return content
-      .split("\n")
-      .filter(Boolean)
-      .map((line) => JSON.parse(line) as SessionEvent);
-  }
-
-  /**
-   * Read events for a specific session.
-   */
-  readSession(sessionId: string): SessionEvent[] {
-    const project = this.extractProject(sessionId);
-    const allEvents = this.readAll(project);
-    return allEvents.filter((e) => e.session_id === sessionId);
-  }
-
-  /**
-   * Read events of a specific type.
-   */
-  readByType(project: string, type: EventType): SessionEvent[] {
-    return this.readAll(project).filter((e) => e.type === type);
-  }
-
-  /**
-   * Get the latest event for a session.
-   */
-  getLatest(sessionId: string): SessionEvent | undefined {
-    const events = this.readSession(sessionId);
-    return events[events.length - 1];
-  }
-
-  /**
-   * Get active sessions (started but not completed/failed).
-   */
-  getActiveSessions(project: string): string[] {
-    const events = this.readAll(project);
-    const started = new Set<string>();
-    const ended = new Set<string>();
-
-    for (const event of events) {
-      if (event.type === "session:start") {
-        started.add(event.session_id);
-      } else if (event.type === "session:complete" || event.type === "session:failed") {
-        ended.add(event.session_id);
-      }
-    }
-
-    return [...started].filter((id) => !ended.has(id));
-  }
-
-  /**
-   * Extract project from session ID (format: project-YYYYMMDD-HHMMSS-random).
-   */
-  private extractProject(sessionId: string): string {
-    const parts = sessionId.split("-");
-    return parts[0];
-  }
-
-  /**
-   * List all projects with events.
-   */
-  listProjects(): string[] {
-    if (!existsSync(this.basePath)) {
-      return [];
-    }
-
-    return readdirSync(this.basePath).filter((name) => {
-      const path = join(this.basePath, name);
-      return statSync(path).isDirectory();
-    });
-  }
-
-  /**
-   * Compact old events (keep last N days).
-   */
-  compact(project: string, keepDays: number = 30): number {
-    const cutoff = new Date();
-    cutoff.setDate(cutoff.getDate() - keepDays);
-    const cutoffStr = cutoff.toISOString();
-
-    const events = this.readAll(project);
-    const kept = events.filter((e) => e.timestamp >= cutoffStr);
-    const removed = events.length - kept.length;
-
-    if (removed > 0) {
-      const logPath = this.getLogPath(project);
-      writeFileSync(logPath, `${kept.map((e) => JSON.stringify(e)).join("\n")}\n`);
-    }
-
-    return removed;
-  }
-}
-
-/**
- * Helper to create common events.
- */
-export const createEvent = {
-  sessionStart: (
-    sessionId: string,
-    agent: string,
-    data: SessionStartEvent["data"],
-  ): Omit<SessionStartEvent, "id" | "timestamp"> => ({
-    type: "session:start",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  heartbeat: (
-    sessionId: string,
-    agent: string,
-    data: SessionHeartbeatEvent["data"],
-  ): Omit<SessionHeartbeatEvent, "id" | "timestamp"> => ({
-    type: "session:heartbeat",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  checkpoint: (
-    sessionId: string,
-    agent: string,
-    data: SessionCheckpointEvent["data"],
-  ): Omit<SessionCheckpointEvent, "id" | "timestamp"> => ({
-    type: "session:checkpoint",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  complete: (
-    sessionId: string,
-    agent: string,
-    data: SessionCompleteEvent["data"],
-  ): Omit<SessionCompleteEvent, "id" | "timestamp"> => ({
-    type: "session:complete",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  blocked: (
-    sessionId: string,
-    agent: string,
-    data: SessionBlockedEvent["data"],
-  ): Omit<SessionBlockedEvent, "id" | "timestamp"> => ({
-    type: "session:blocked",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  taskStart: (
-    sessionId: string,
-    agent: string,
-    data: TaskStartEvent["data"],
-  ): Omit<TaskStartEvent, "id" | "timestamp"> => ({
-    type: "task:start",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  taskComplete: (
-    sessionId: string,
-    agent: string,
-    data: TaskCompleteEvent["data"],
-  ): Omit<TaskCompleteEvent, "id" | "timestamp"> => ({
-    type: "task:complete",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  previewCreated: (
-    sessionId: string,
-    agent: string,
-    data: PreviewCreatedEvent["data"],
-  ): Omit<PreviewCreatedEvent, "id" | "timestamp"> => ({
-    type: "preview:created",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  resourceAcquired: (
-    sessionId: string,
-    agent: string,
-    data: ResourceAcquiredEvent["data"],
-  ): Omit<ResourceAcquiredEvent, "id" | "timestamp"> => ({
-    type: "resource:acquired",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-
-  resourceReleased: (
-    sessionId: string,
-    agent: string,
-    data: ResourceReleasedEvent["data"],
-  ): Omit<ResourceReleasedEvent, "id" | "timestamp"> => ({
-    type: "resource:released",
-    session_id: sessionId,
-    agent,
-    data,
-  }),
-};
-
-/**
- * Generate a session ID.
- */
-export function generateSessionId(project: string): string {
-  const now = new Date();
-  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
-  const time = now.toISOString().slice(11, 19).replace(/:/g, "");
-  const random = Math.random().toString(36).slice(2, 6);
-  return `${project}-${date}-${time}-${random}`;
-}

package/src/lib/heartbeat.test.ts

@@ -1,164 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { EventStore } from "./events";
-import { HeartbeatManager, type SessionLiveness } from "./heartbeat";
-
-describe("HeartbeatManager", () => {
-  let tempDir: string;
-  let eventsDir: string;
-  let manager: HeartbeatManager;
-  let eventStore: 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: SessionLiveness = {
-      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();
-  });
-});