@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/annotations-convex.ts

@@ -1,296 +0,0 @@
-/**
- * Convex-backed annotation client for CLI commands.
- *
- * Replaces the file-based AnnotationStore with Convex mutations/queries,
- * making annotations visible across devices and in the web UI.
- *
- * Falls back to local AnnotationStore when Convex is unavailable.
- */
-import { api, getHttpClient, isConvexConfigured } from "@creativeintelligence/sdk/convex";
-import type {
-  Annotation,
-  AnnotationIntent,
-  AnnotationSeverity,
-  AnnotationStatus,
-} from "./annotations.js";
-import { AnnotationStore } from "./annotations.js";
-
-// Map our domain types to AFS types used by Convex
-function intentToAfs(intent: AnnotationIntent): "fix" | "change" | "question" | "approve" {
-  switch (intent) {
-    case "bug":
-    case "blocker":
-      return "fix";
-    case "suggestion":
-      return "change";
-    case "question":
-      return "question";
-    default:
-      return "approve";
-  }
-}
-
-function severityToAfs(
-  severity: AnnotationSeverity,
-): "blocking" | "important" | "suggestion" {
-  switch (severity) {
-    case "critical":
-    case "error":
-      return "blocking";
-    case "warning":
-      return "important";
-    default:
-      return "suggestion";
-  }
-}
-
-function afsToIntent(intent?: string): AnnotationIntent {
-  switch (intent) {
-    case "fix":
-      return "bug";
-    case "change":
-      return "suggestion";
-    case "question":
-      return "question";
-    default:
-      return "feedback";
-  }
-}
-
-function afsToSeverity(severity?: string): AnnotationSeverity {
-  switch (severity) {
-    case "blocking":
-      return "critical";
-    case "important":
-      return "warning";
-    default:
-      return "info";
-  }
-}
-
-function convexToAnnotation(row: any, previewId: string): Annotation {
-  return {
-    id: row.annotationId,
-    previewId,
-    status: row.status ?? "pending",
-    severity: afsToSeverity(row.severity),
-    intent: afsToIntent(row.intent),
-    body: row.comment,
-    target: row.url,
-    selector: row.elementPath,
-    source: "convex",
-    thread: (row.thread ?? []).map((t: any) => ({
-      id: t.id,
-      author: t.role,
-      body: t.content,
-      timestamp: new Date(t.timestamp).toISOString(),
-    })),
-    seq: 0,
-    createdAt: new Date(row.timestamp).toISOString(),
-    updatedAt: new Date(row.timestamp).toISOString(),
-  };
-}
-
-/**
- * Convex-backed annotation client.
- *
- * All operations go to Convex first. If Convex is unavailable,
- * falls back to local AnnotationStore.
- */
-export class ConvexAnnotationClient {
-  private local: AnnotationStore;
-  private useConvex: boolean;
-
-  constructor() {
-    this.local = new AnnotationStore();
-    this.useConvex = isConvexConfigured();
-  }
-
-  private get http() {
-    return getHttpClient();
-  }
-
-  async create(opts: {
-    previewId: string;
-    body: string;
-    severity?: AnnotationSeverity;
-    intent?: AnnotationIntent;
-    source?: string;
-    target?: string;
-    selector?: string;
-  }): Promise<Annotation> {
-    if (!this.useConvex) {
-      return this.local.create(opts);
-    }
-
-    const annotationId = `ann_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
-
-    try {
-      await this.http.mutation(api.annotations.create, {
-        annotationId,
-        comment: opts.body,
-        elementPath: opts.selector ?? "body",
-        x: 50,
-        y: 0,
-        element: "div",
-        url: opts.target,
-        intent: intentToAfs(opts.intent ?? "feedback"),
-        severity: severityToAfs(opts.severity ?? "info"),
-        sessionId: opts.previewId,
-      });
-
-      return {
-        id: annotationId,
-        previewId: opts.previewId,
-        status: "pending",
-        severity: opts.severity ?? "info",
-        intent: opts.intent ?? "feedback",
-        body: opts.body,
-        target: opts.target,
-        selector: opts.selector,
-        source: opts.source ?? "cli",
-        thread: [],
-        seq: 0,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      };
-    } catch (err) {
-      // Fallback to local
-      return this.local.create(opts);
-    }
-  }
-
-  async list(
-    previewId: string,
-    filter?: { status?: AnnotationStatus },
-  ): Promise<Annotation[]> {
-    if (!this.useConvex) {
-      return this.local.list(previewId, filter);
-    }
-
-    try {
-      const rows = (await this.http.query(api.annotations.listBySession, {
-        sessionId: previewId,
-        status: filter?.status,
-      })) as any[];
-
-      return rows.map((r) => convexToAnnotation(r, previewId));
-    } catch {
-      return this.local.list(previewId, filter);
-    }
-  }
-
-  async get(previewId: string, annotationId: string): Promise<Annotation | null> {
-    if (!this.useConvex) {
-      return this.local.get(previewId, annotationId);
-    }
-
-    try {
-      const row = (await this.http.query(api.annotations.get, {
-        annotationId,
-      })) as any;
-
-      if (!row) return null;
-      return convexToAnnotation(row, previewId);
-    } catch {
-      return this.local.get(previewId, annotationId);
-    }
-  }
-
-  async acknowledge(previewId: string, annotationId: string): Promise<Annotation | null> {
-    return this.updateStatus(previewId, annotationId, "acknowledged");
-  }
-
-  async resolve(previewId: string, annotationId: string): Promise<Annotation | null> {
-    return this.updateStatus(previewId, annotationId, "resolved");
-  }
-
-  async dismiss(previewId: string, annotationId: string): Promise<Annotation | null> {
-    return this.updateStatus(previewId, annotationId, "dismissed");
-  }
-
-  async reply(
-    previewId: string,
-    annotationId: string,
-    author: string,
-    body: string,
-  ): Promise<Annotation | null> {
-    if (!this.useConvex) {
-      return this.local.reply(previewId, annotationId, author, body);
-    }
-
-    try {
-      const entryId = `thr_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
-      await this.http.mutation(api.annotations.addThread, {
-        annotationId,
-        entry: {
-          id: entryId,
-          role: author === "human" || author === "user" ? ("human" as const) : ("agent" as const),
-          content: body,
-          timestamp: Date.now(),
-        },
-      });
-
-      return this.get(previewId, annotationId);
-    } catch {
-      return this.local.reply(previewId, annotationId, author, body);
-    }
-  }
-
-  async countPending(previewId: string): Promise<number> {
-    if (!this.useConvex) {
-      return this.local.list(previewId, { status: "pending" }).length;
-    }
-
-    try {
-      const result = (await this.http.query(api.annotations.countPending, {
-        sessionId: previewId,
-      })) as { count: number };
-      return result.count;
-    } catch {
-      return this.local.list(previewId, { status: "pending" }).length;
-    }
-  }
-
-  private async updateStatus(
-    previewId: string,
-    annotationId: string,
-    status: AnnotationStatus,
-  ): Promise<Annotation | null> {
-    if (!this.useConvex) {
-      switch (status) {
-        case "acknowledged":
-          return this.local.acknowledge(previewId, annotationId);
-        case "resolved":
-          return this.local.resolve(previewId, annotationId);
-        case "dismissed":
-          return this.local.dismiss(previewId, annotationId);
-        default:
-          return null;
-      }
-    }
-
-    try {
-      await this.http.mutation(api.annotations.updateStatus, {
-        annotationId,
-        status: status as "pending" | "acknowledged" | "resolved" | "dismissed",
-        resolvedBy:
-          status === "resolved" || status === "dismissed"
-            ? ("human" as const)
-            : undefined,
-      });
-      return this.get(previewId, annotationId);
-    } catch {
-      switch (status) {
-        case "acknowledged":
-          return this.local.acknowledge(previewId, annotationId);
-        case "resolved":
-          return this.local.resolve(previewId, annotationId);
-        case "dismissed":
-          return this.local.dismiss(previewId, annotationId);
-        default:
-          return null;
-      }
-    }
-  }
-}

package/src/lib/annotations.test.ts

@@ -1,274 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { AnnotationStore } from "./annotations";
-
-const TEST_DIR = join(import.meta.dir, "..", "..", ".tmp-tests", "annotations");
-const PREVIEW_ID = "test-preview-001";
-
-describe("AnnotationStore", () => {
-  let store: AnnotationStore;
-
-  beforeEach(() => {
-    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
-    mkdirSync(TEST_DIR, { recursive: true });
-    store = new AnnotationStore(TEST_DIR);
-  });
-
-  afterEach(() => {
-    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
-  });
-
-  describe("create", () => {
-    it("creates an annotation with defaults", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Button is broken" });
-
-      expect(a.id).toBeDefined();
-      expect(a.previewId).toBe(PREVIEW_ID);
-      expect(a.status).toBe("pending");
-      expect(a.severity).toBe("info");
-      expect(a.intent).toBe("feedback");
-      expect(a.body).toBe("Button is broken");
-      expect(a.source).toBe("cli");
-      expect(a.thread).toHaveLength(0);
-      expect(a.seq).toBe(1);
-    });
-
-    it("creates with custom severity and intent", () => {
-      const a = store.create({
-        previewId: PREVIEW_ID,
-        body: "Auth redirect fails",
-        severity: "error",
-        intent: "bug",
-        source: "agent-browser",
-        target: "/login",
-      });
-
-      expect(a.severity).toBe("error");
-      expect(a.intent).toBe("bug");
-      expect(a.source).toBe("agent-browser");
-      expect(a.target).toBe("/login");
-    });
-
-    it("increments sequence numbers", () => {
-      const a1 = store.create({ previewId: PREVIEW_ID, body: "First" });
-      const a2 = store.create({ previewId: PREVIEW_ID, body: "Second" });
-      const a3 = store.create({ previewId: PREVIEW_ID, body: "Third" });
-
-      expect(a1.seq).toBe(1);
-      expect(a2.seq).toBe(2);
-      expect(a3.seq).toBe(3);
-    });
-  });
-
-  describe("list", () => {
-    it("lists all annotations", () => {
-      store.create({ previewId: PREVIEW_ID, body: "One" });
-      store.create({ previewId: PREVIEW_ID, body: "Two" });
-
-      const all = store.list(PREVIEW_ID);
-      expect(all).toHaveLength(2);
-    });
-
-    it("filters by status", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "One" });
-      store.create({ previewId: PREVIEW_ID, body: "Two" });
-      store.acknowledge(PREVIEW_ID, a.id);
-
-      const pending = store.list(PREVIEW_ID, { status: "pending" });
-      expect(pending).toHaveLength(1);
-
-      const acked = store.list(PREVIEW_ID, { status: "acknowledged" });
-      expect(acked).toHaveLength(1);
-    });
-
-    it("returns empty for nonexistent preview", () => {
-      expect(store.list("nonexistent")).toHaveLength(0);
-    });
-  });
-
-  describe("status transitions", () => {
-    it("acknowledges an annotation", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      const updated = store.acknowledge(PREVIEW_ID, a.id);
-
-      expect(updated?.status).toBe("acknowledged");
-    });
-
-    it("resolves an annotation", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      const updated = store.resolve(PREVIEW_ID, a.id);
-
-      expect(updated?.status).toBe("resolved");
-    });
-
-    it("dismisses an annotation", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      const updated = store.dismiss(PREVIEW_ID, a.id);
-
-      expect(updated?.status).toBe("dismissed");
-    });
-
-    it("returns null for nonexistent annotation", () => {
-      expect(store.acknowledge(PREVIEW_ID, "nonexistent")).toBeNull();
-    });
-  });
-
-  describe("thread", () => {
-    it("adds a reply to a thread", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Bug report" });
-      const updated = store.reply(PREVIEW_ID, a.id, "claude", "Looking into it");
-
-      expect(updated?.thread).toHaveLength(1);
-      expect(updated?.thread[0].author).toBe("claude");
-      expect(updated?.thread[0].body).toBe("Looking into it");
-    });
-
-    it("supports multiple replies", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Bug report" });
-      store.reply(PREVIEW_ID, a.id, "claude", "Looking into it");
-      store.reply(PREVIEW_ID, a.id, "codex", "Fixed in abc1234");
-      store.reply(PREVIEW_ID, a.id, "luke", "Confirmed fixed");
-
-      const updated = store.get(PREVIEW_ID, a.id);
-      expect(updated?.thread).toHaveLength(3);
-    });
-  });
-
-  describe("session linking", () => {
-    it("links annotation to agent session", () => {
-      const a = store.create({
-        previewId: PREVIEW_ID,
-        body: "Blocking issue",
-        intent: "blocker",
-      });
-
-      const updated = store.linkSession(PREVIEW_ID, a.id, "abbie-20260206-fix-abc1");
-      expect(updated?.linkedSessionId).toBe("abbie-20260206-fix-abc1");
-    });
-  });
-
-  describe("events", () => {
-    it("records creation event", () => {
-      store.create({ previewId: PREVIEW_ID, body: "Test" });
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(1);
-      expect(events[0].type).toBe("annotation.created");
-    });
-
-    it("records status change events", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      store.acknowledge(PREVIEW_ID, a.id);
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(2);
-      expect(events[1].type).toBe("status.changed");
-      expect(events[1].data.from).toBe("pending");
-      expect(events[1].data.to).toBe("acknowledged");
-    });
-
-    it("records thread message events", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      store.reply(PREVIEW_ID, a.id, "claude", "Reply text");
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(2);
-      expect(events[1].type).toBe("thread.message");
-    });
-
-    it("preserves event ordering for replay", () => {
-      const a = store.create({ previewId: PREVIEW_ID, body: "Test" });
-      store.acknowledge(PREVIEW_ID, a.id);
-      store.reply(PREVIEW_ID, a.id, "claude", "Working on it");
-      store.resolve(PREVIEW_ID, a.id);
-
-      const events = store.events(PREVIEW_ID);
-      expect(events).toHaveLength(4);
-      expect(events.map((e) => e.type)).toEqual([
-        "annotation.created",
-        "status.changed",
-        "thread.message",
-        "status.changed",
-      ]);
-      expect(events.map((e) => e.seq)).toEqual([1, 2, 3, 4]);
-    });
-  });
-
-  describe("afs interoperability", () => {
-    it("imports an AFS annotation and exports it back", () => {
-      const afs = {
-        id: "ann_k8x2m",
-        comment: "Button is cut off on mobile viewport",
-        elementPath: "body > main > .hero-section > button.cta",
-        timestamp: 1705694400000,
-        x: 45.5,
-        y: 480,
-        element: "button",
-        url: "http://localhost:3000/landing",
-        intent: "fix" as const,
-        severity: "blocking" as const,
-        status: "pending" as const,
-        thread: [
-          {
-            id: "thr_1",
-            role: "human" as const,
-            content: "Can we make this 48px high?",
-            timestamp: 1705694401000,
-          },
-        ],
-      };
-
-      const imported = store.createFromAfs({ previewId: PREVIEW_ID, annotation: afs });
-      expect(imported.id).toBe("ann_k8x2m");
-      expect(imported.intent).toBe("bug");
-      expect(imported.severity).toBe("critical");
-      expect(imported.selector).toBe(afs.elementPath);
-
-      const exported = store.exportAfs(PREVIEW_ID, imported.id);
-      expect(exported?.id).toBe(afs.id);
-      expect(exported?.comment).toBe(afs.comment);
-      expect(exported?.elementPath).toBe(afs.elementPath);
-      expect(exported?.status).toBe("pending");
-      expect(exported?.severity).toBe("blocking");
-      expect(exported?.intent).toBe("fix");
-      expect(exported?.thread).toHaveLength(1);
-    });
-
-    it("upserts existing AFS annotations and records update events", () => {
-      const created = store.createFromAfs({
-        previewId: PREVIEW_ID,
-        annotation: {
-          id: "ann_upsert",
-          comment: "Initial",
-          elementPath: "body",
-          timestamp: 1705694400000,
-          x: 10,
-          y: 20,
-          element: "div",
-        },
-      });
-      const updated = store.createFromAfs({
-        previewId: PREVIEW_ID,
-        annotation: {
-          id: "ann_upsert",
-          comment: "Updated",
-          elementPath: "body > main",
-          timestamp: 1705694405000,
-          x: 12,
-          y: 25,
-          element: "main",
-          status: "acknowledged",
-        },
-      });
-
-      expect(updated.id).toBe(created.id);
-      expect(updated.body).toBe("Updated");
-      expect(updated.status).toBe("acknowledged");
-
-      const events = store.events(PREVIEW_ID);
-      expect(events.map((e) => e.type)).toEqual(["annotation.created", "annotation.updated"]);
-      expect(events.map((e) => e.seq)).toEqual([1, 2]);
-    });
-  });
-});