skema-core 0.2.0 → 2.1.0

package/dist/server.js

@@ -45,7 +45,7 @@ function getGridCellReference(x, y, gridSize = 100) {
 // src/server/prompts.ts
 var CRITICAL_RULES = `CRITICAL RULES:
 - Do NOT create new files. Only edit existing files.
-- Do NOT modify the import { SkemaWrapper } from "@/components/skema-wrapper" line.
+- Do NOT modify the Skema overlay component import or the SkemaOverlay component itself.
 - Ensure all JSX tags are properly closed - every <tag> needs a matching </tag>.
 - Do NOT run any shell commands. No npm, no git, no lint, no build commands. Just edit files.
 - STOP immediately after making the file changes. Do not verify, do not run tests, do not check status.`;
@@ -184,7 +184,7 @@ var DRAWING_IMPLEMENTATION_GUIDELINES = `- **CRITICAL: DO NOT CREATE ANY NEW FIL
 var DRAWING_ERROR_PREVENTION_RULES = `1. **NEVER CREATE NEW FILES** - Do NOT create new component files, utility files, or any other files. Write everything inline in the existing file
 2. You do not need to update package.json or anything, just add / edit the react component.
 3. Do NOT add import statements in the middle of the file or inside JSX - imports go ONLY at the top
-4. Do NOT modify the import { SkemaWrapper } from "@/components/skema-wrapper" line or the SkemaWrapper component itself
+4. Do NOT modify the Skema overlay component import or the SkemaOverlay component itself
 5. If you need something that requires an import and it's not already imported, either use an alternative that doesn't need an import, or add the import at the very TOP of the file with the other imports
 6. DONT MAKE ANY CHANGES THAT WOULD RESULT IN A Build Error
 7. **JSX SYNTAX VALIDATION** - ALWAYS ensure every JSX tag is properly closed. Every opening tag like <div>, <a>, <span>, <button> MUST have a matching closing tag </div>, </a>, </span>, </button>. Self-closing tags like <img />, <input />, <br /> must end with />. Before finishing, mentally verify all tag pairs are balanced.`;
@@ -859,6 +859,50 @@ function isProviderAvailable(provider) {
 function getAvailableProviders() {
   return ["gemini", "claude"].filter(isProviderAvailable);
 }
+function checkProviderAuthorized(provider) {
+  const { execSync: execSync3 } = __require("child_process");
+  try {
+    if (provider === "gemini") {
+      execSync3("gemini --version", { stdio: "ignore", timeout: 5e3 });
+      return true;
+    } else if (provider === "claude") {
+      execSync3("claude --version", { stdio: "ignore", timeout: 5e3 });
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getProviderStatus(provider) {
+  const installed = isProviderAvailable(provider);
+  if (!installed) {
+    return {
+      installed: false,
+      authorized: false,
+      message: `${provider} CLI not installed`
+    };
+  }
+  const authorized = checkProviderAuthorized(provider);
+  if (!authorized) {
+    return {
+      installed: true,
+      authorized: false,
+      message: `${provider} CLI installed but not authorized`
+    };
+  }
+  return {
+    installed: true,
+    authorized: true,
+    message: "Ready"
+  };
+}
+function getAllProviderStatuses() {
+  return {
+    gemini: getProviderStatus("gemini"),
+    claude: getProviderStatus("claude")
+  };
+}
 async function analyzeWithGemini(base64Image, apiKey, model = "gemini-2.5-flash") {
   try {
     const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
@@ -966,10 +1010,108 @@ function isVisionAvailable(provider) {
   }
 }
 
+// src/server/annotation-store.ts
+var storedAnnotations = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+function notify(event, annotation) {
+  for (const listener of listeners) {
+    try {
+      listener(event, annotation);
+    } catch (e) {
+      console.error("[AnnotationStore] Listener error:", e);
+    }
+  }
+}
+function queueAnnotation(annotation, comment) {
+  const id = annotation.id || `ann-${Date.now()}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stored = {
+    annotation: { ...annotation, id },
+    comment,
+    status: "pending",
+    createdAt: now,
+    updatedAt: now
+  };
+  storedAnnotations.set(id, stored);
+  console.log(`[AnnotationStore] Queued annotation ${id}: "${comment.slice(0, 50)}..."`);
+  notify("annotation.created", stored);
+  return stored;
+}
+function getPendingAnnotations() {
+  return Array.from(storedAnnotations.values()).filter((a) => a.status === "pending");
+}
+function getAllAnnotations() {
+  return Array.from(storedAnnotations.values());
+}
+function getAnnotation(id) {
+  return storedAnnotations.get(id);
+}
+function acknowledgeAnnotation(id) {
+  const stored = storedAnnotations.get(id);
+  if (!stored) return void 0;
+  stored.status = "acknowledged";
+  stored.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  notify("annotation.updated", stored);
+  return stored;
+}
+function resolveAnnotation(id, summary) {
+  const stored = storedAnnotations.get(id);
+  if (!stored) return void 0;
+  stored.status = "resolved";
+  stored.resolvedBy = "agent";
+  stored.resolutionSummary = summary;
+  stored.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  notify("annotation.updated", stored);
+  return stored;
+}
+function dismissAnnotation(id, reason) {
+  const stored = storedAnnotations.get(id);
+  if (!stored) return void 0;
+  stored.status = "dismissed";
+  stored.resolvedBy = "agent";
+  stored.dismissalReason = reason;
+  stored.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  notify("annotation.updated", stored);
+  return stored;
+}
+function removeAnnotation(id) {
+  const stored = storedAnnotations.get(id);
+  if (!stored) return void 0;
+  storedAnnotations.delete(id);
+  notify("annotation.deleted", stored);
+  return stored;
+}
+function clearAnnotations() {
+  storedAnnotations.clear();
+}
+function onStoreEvent(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function getPendingCount() {
+  let count = 0;
+  for (const a of storedAnnotations.values()) {
+    if (a.status === "pending") count++;
+  }
+  return count;
+}
+
 // src/server/daemon.ts
 var currentProvider = "gemini";
 var workingDirectory = process.cwd();
+var currentMode = "direct-cli";
 var annotationSnapshots2 = /* @__PURE__ */ new Map();
+var mcpServerClient = null;
+var mcpClientName = null;
+function getAnnotationCounts() {
+  const all = getAllAnnotations();
+  return {
+    pending: all.filter((a) => a.status === "pending").length,
+    acknowledged: all.filter((a) => a.status === "acknowledged").length,
+    resolved: all.filter((a) => a.status === "resolved").length,
+    dismissed: all.filter((a) => a.status === "dismissed").length
+  };
+}
 function createSnapshot2(annotationId) {
   try {
     const stashRef = child_process.execSync("git stash create", { cwd: workingDirectory, encoding: "utf-8" }).trim();
@@ -1029,17 +1171,45 @@ var handlers = {
     if (!["gemini", "claude"].includes(newProvider)) {
       return { id: msg.id, type: "error", error: `Invalid provider: ${newProvider}` };
     }
-    if (!isProviderAvailable(newProvider)) {
+    if (currentMode === "direct-cli" && !isProviderAvailable(newProvider)) {
       return {
         id: msg.id,
         type: "error",
-        error: `Provider "${newProvider}" is not installed. Run: ${newProvider === "gemini" ? "npm install -g @anthropic-ai/gemini-cli" : "npm install -g @anthropic-ai/claude-code"}`
+        error: `Provider "${newProvider}" CLI is not installed.`
       };
     }
     currentProvider = newProvider;
     console.log(`[Daemon] Switched to provider: ${currentProvider}`);
     return { id: msg.id, type: "provider-changed", provider: currentProvider };
   },
+  "check-providers": async (msg) => {
+    const statuses = getAllProviderStatuses();
+    return {
+      id: msg.id,
+      type: "provider-statuses",
+      providerStatus: statuses
+    };
+  },
+  // -------------------------------------------------------------------------
+  // Mode Management
+  // -------------------------------------------------------------------------
+  "get-mode": async (msg) => {
+    return {
+      id: msg.id,
+      type: "mode",
+      mode: currentMode,
+      availableModes: ["direct-cli", "mcp"]
+    };
+  },
+  "set-mode": async (msg) => {
+    const newMode = msg.mode;
+    if (!["direct-cli", "mcp"].includes(newMode)) {
+      return { id: msg.id, type: "error", error: `Invalid mode: ${newMode}` };
+    }
+    currentMode = newMode;
+    console.log(`[Daemon] Switched to mode: ${currentMode}`);
+    return { id: msg.id, type: "mode-changed", mode: currentMode };
+  },
   // -------------------------------------------------------------------------
   // AI Generation (streaming)
   // -------------------------------------------------------------------------
@@ -1047,21 +1217,41 @@ var handlers = {
     const annotation = msg.annotation;
     const projectContext = msg.projectContext;
     const annotationId = annotation.id || `temp-${Date.now()}`;
+    const requestMode = msg.mode || currentMode;
+    const requestProvider = msg.provider || currentProvider;
+    if (requestMode === "mcp") {
+      const comment = annotation.comment || "";
+      const stored = queueAnnotation(annotation, comment);
+      const counts = getAnnotationCounts();
+      sendMessage(ws, {
+        id: msg.id,
+        type: "annotation-queued",
+        success: true,
+        annotationId: stored.annotation.id,
+        pendingCount: getPendingCount(),
+        annotationCounts: counts
+      });
+      broadcastToClients({
+        type: "mcp-annotation-counts",
+        counts
+      });
+      return;
+    }
     createSnapshot2(annotationId);
     let visionDescription = "";
     const drawingAnnotation = annotation;
     if (annotation.type === "drawing" && drawingAnnotation.drawingImage) {
+      sendMessage(ws, {
+        id: msg.id,
+        type: "ai-event",
+        event: {
+          type: "text",
+          content: `[Analyzing drawing with vision...]`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          provider: requestProvider
+        }
+      });
       if (isVisionAvailable("gemini")) {
-        sendMessage(ws, {
-          id: msg.id,
-          type: "ai-event",
-          event: {
-            type: "text",
-            content: `[Analyzing drawing with Gemini vision...]`,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            provider: currentProvider
-          }
-        });
         const visionResult = await analyzeImage(drawingAnnotation.drawingImage, {
           provider: "gemini"
         });
@@ -1075,7 +1265,7 @@ var handlers = {
               content: `[Vision analysis complete]
 ${visionDescription}`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              provider: currentProvider
+              provider: requestProvider
             }
           });
         } else {
@@ -1086,7 +1276,7 @@ ${visionDescription}`,
               type: "error",
               content: `Vision analysis failed: ${visionResult.error}`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              provider: currentProvider
+              provider: requestProvider
             }
           });
         }
@@ -1098,14 +1288,13 @@ ${visionDescription}`,
             type: "text",
             content: `[Vision not available - set GEMINI_API_KEY for image analysis]`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            provider: currentProvider
+            provider: requestProvider
           }
         });
       }
     }
     const prompt = buildPromptFromAnnotation(annotation, projectContext, {
       fastMode: msg.fastMode === true,
-      // Default to detailed mode (false) unless explicitly set to true
       visionDescription
     });
     sendMessage(ws, {
@@ -1115,11 +1304,25 @@ ${visionDescription}`,
         type: "debug",
         content: prompt,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        provider: currentProvider
+        provider: requestProvider
       }
     });
+    const cliProvider = requestProvider;
+    if (!isProviderAvailable(cliProvider)) {
+      sendMessage(ws, {
+        id: msg.id,
+        type: "ai-event",
+        event: {
+          type: "error",
+          content: `${requestProvider} CLI is not installed. Run: npm install -g @google/gemini-cli`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          provider: requestProvider
+        }
+      });
+      return;
+    }
     const config = {
-      provider: currentProvider,
+      provider: cliProvider,
       cwd: workingDirectory,
       model: msg.model
     };
@@ -1137,7 +1340,8 @@ ${visionDescription}`,
           type: "generate-complete",
           success: true,
           annotationId,
-          provider: currentProvider
+          provider: requestProvider,
+          mode: requestMode
         });
         break;
       }
@@ -1155,6 +1359,109 @@ ${visionDescription}`,
     return { id: msg.id, type: "revert-result", ...result };
   },
   // -------------------------------------------------------------------------
+  // MCP Annotation Queue Management
+  // -------------------------------------------------------------------------
+  "get-pending-annotations": async (msg) => {
+    const pending = getPendingAnnotations();
+    return {
+      id: msg.id,
+      type: "pending-annotations",
+      count: pending.length,
+      annotations: pending.map(serializeStoredAnnotation)
+    };
+  },
+  "get-all-annotations": async (msg) => {
+    const all = getAllAnnotations();
+    return {
+      id: msg.id,
+      type: "all-annotations",
+      count: all.length,
+      annotations: all.map(serializeStoredAnnotation)
+    };
+  },
+  "get-annotation": async (msg) => {
+    const id = msg.annotationId;
+    const stored = getAnnotation(id);
+    if (!stored) {
+      return { id: msg.id, type: "error", error: `Annotation not found: ${id}` };
+    }
+    return {
+      id: msg.id,
+      type: "annotation",
+      annotation: serializeStoredAnnotation(stored)
+    };
+  },
+  "acknowledge-annotation": async (msg) => {
+    const id = msg.annotationId;
+    const stored = acknowledgeAnnotation(id);
+    if (!stored) {
+      return { id: msg.id, type: "error", error: `Annotation not found: ${id}` };
+    }
+    const counts = getAnnotationCounts();
+    broadcastToClients({
+      type: "annotation-status-changed",
+      annotationId: id,
+      status: "acknowledged"
+    });
+    broadcastToClients({ type: "mcp-annotation-counts", counts });
+    return {
+      id: msg.id,
+      type: "annotation-acknowledged",
+      annotationId: id
+    };
+  },
+  "resolve-annotation": async (msg) => {
+    const id = msg.annotationId;
+    const summary = msg.summary;
+    const stored = resolveAnnotation(id, summary);
+    if (!stored) {
+      return { id: msg.id, type: "error", error: `Annotation not found: ${id}` };
+    }
+    const counts = getAnnotationCounts();
+    broadcastToClients({
+      type: "annotation-status-changed",
+      annotationId: id,
+      status: "resolved",
+      summary
+    });
+    broadcastToClients({ type: "mcp-annotation-counts", counts });
+    return {
+      id: msg.id,
+      type: "annotation-resolved",
+      annotationId: id,
+      summary
+    };
+  },
+  "dismiss-annotation": async (msg) => {
+    const id = msg.annotationId;
+    const reason = msg.reason;
+    const stored = dismissAnnotation(id, reason);
+    if (!stored) {
+      return { id: msg.id, type: "error", error: `Annotation not found: ${id}` };
+    }
+    const counts = getAnnotationCounts();
+    broadcastToClients({
+      type: "annotation-status-changed",
+      annotationId: id,
+      status: "dismissed",
+      reason
+    });
+    broadcastToClients({ type: "mcp-annotation-counts", counts });
+    return {
+      id: msg.id,
+      type: "annotation-dismissed",
+      annotationId: id,
+      reason
+    };
+  },
+  "clear-queued-annotations": async (msg) => {
+    clearAnnotations();
+    return {
+      id: msg.id,
+      type: "annotations-cleared"
+    };
+  },
+  // -------------------------------------------------------------------------
   // File Operations
   // -------------------------------------------------------------------------
   "read-file": async (msg) => {
@@ -1216,6 +1523,33 @@ ${visionDescription}`,
     });
   },
   // -------------------------------------------------------------------------
+  // MCP Server Identification
+  // -------------------------------------------------------------------------
+  identify: async (msg, ws) => {
+    if (msg.client === "mcp-server") {
+      mcpServerClient = ws;
+      mcpClientName = null;
+      console.log("[Daemon] MCP server identified and connected");
+      broadcastToClients({
+        type: "mcp-server-status",
+        connected: true,
+        clientName: null
+      });
+      return { id: msg.id, type: "identified", client: "mcp-server" };
+    }
+    return { id: msg.id, type: "identified", client: "unknown" };
+  },
+  "mcp-client-info": async (msg) => {
+    mcpClientName = msg.clientName || null;
+    console.log("[Daemon] MCP client identified:", mcpClientName, msg.clientVersion || "");
+    broadcastToClients({
+      type: "mcp-server-status",
+      connected: true,
+      clientName: mcpClientName
+    });
+    return { id: msg.id, type: "ok" };
+  },
+  // -------------------------------------------------------------------------
   // Status
   // -------------------------------------------------------------------------
   ping: async (msg) => {
@@ -1223,54 +1557,112 @@ ${visionDescription}`,
       id: msg.id,
       type: "pong",
       provider: currentProvider,
+      mode: currentMode,
       cwd: workingDirectory,
-      availableProviders: getAvailableProviders()
+      availableProviders: getAvailableProviders(),
+      availableModes: ["direct-cli", "mcp"],
+      mcpServerConnected: mcpServerClient?.readyState === ws.WebSocket.OPEN,
+      mcpClientName
     };
   }
 };
+var connectedClients = /* @__PURE__ */ new Set();
+function broadcastToClients(message) {
+  for (const client of connectedClients) {
+    sendMessage(client, message);
+  }
+}
+function serializeStoredAnnotation(stored) {
+  return {
+    id: stored.annotation.id,
+    type: stored.annotation.type,
+    comment: stored.comment,
+    status: stored.status,
+    createdAt: stored.createdAt,
+    updatedAt: stored.updatedAt,
+    resolvedBy: stored.resolvedBy,
+    resolutionSummary: stored.resolutionSummary,
+    dismissalReason: stored.dismissalReason,
+    // Include key annotation data the agent needs
+    annotation: {
+      type: stored.annotation.type,
+      selector: stored.annotation.selector,
+      tagName: stored.annotation.tagName,
+      text: stored.annotation.text,
+      elementPath: stored.annotation.elementPath,
+      boundingBox: stored.annotation.boundingBox,
+      drawingSvg: stored.annotation.drawingSvg,
+      drawingImage: stored.annotation.drawingImage,
+      extractedText: stored.annotation.extractedText,
+      nearbyElements: stored.annotation.nearbyElements,
+      viewport: stored.annotation.viewport,
+      projectStyles: stored.annotation.projectStyles,
+      isMultiSelect: stored.annotation.isMultiSelect,
+      elements: stored.annotation.elements
+    }
+  };
+}
 function sendMessage(ws$1, message) {
   if (ws$1.readyState === ws.WebSocket.OPEN) {
     ws$1.send(JSON.stringify(message));
   }
 }
-function handleConnection(ws) {
+function handleConnection(ws$1) {
   console.log("[Daemon] Client connected");
-  sendMessage(ws, {
+  connectedClients.add(ws$1);
+  sendMessage(ws$1, {
     type: "connected",
     provider: currentProvider,
+    mode: currentMode,
     cwd: workingDirectory,
-    availableProviders: getAvailableProviders()
+    availableProviders: getAvailableProviders(),
+    availableModes: ["direct-cli", "mcp"],
+    pendingAnnotations: currentMode === "mcp" ? getPendingCount() : 0,
+    providerStatus: getAllProviderStatuses(),
+    mcpServerConnected: mcpServerClient?.readyState === ws.WebSocket.OPEN,
+    mcpClientName
   });
-  ws.on("message", async (data) => {
+  ws$1.on("message", async (data) => {
     let msg;
     try {
       msg = JSON.parse(data.toString());
     } catch {
-      sendMessage(ws, { type: "error", error: "Invalid JSON" });
+      sendMessage(ws$1, { type: "error", error: "Invalid JSON" });
       return;
     }
     const handler = handlers[msg.type];
     if (!handler) {
-      sendMessage(ws, { id: msg.id, type: "error", error: `Unknown message type: ${msg.type}` });
+      sendMessage(ws$1, { id: msg.id, type: "error", error: `Unknown message type: ${msg.type}` });
       return;
     }
     try {
-      const response = await handler(msg, ws);
+      const response = await handler(msg, ws$1);
       if (response) {
-        sendMessage(ws, response);
+        sendMessage(ws$1, response);
       }
     } catch (error) {
-      sendMessage(ws, {
+      sendMessage(ws$1, {
         id: msg.id,
         type: "error",
         error: `Handler error: ${error}`
       });
     }
   });
-  ws.on("close", () => {
+  ws$1.on("close", () => {
     console.log("[Daemon] Client disconnected");
+    connectedClients.delete(ws$1);
+    if (ws$1 === mcpServerClient) {
+      mcpServerClient = null;
+      mcpClientName = null;
+      console.log("[Daemon] MCP server disconnected");
+      broadcastToClients({
+        type: "mcp-server-status",
+        connected: false,
+        clientName: null
+      });
+    }
   });
-  ws.on("error", (error) => {
+  ws$1.on("error", (error) => {
     console.error("[Daemon] WebSocket error:", error);
   });
 }
@@ -1278,25 +1670,31 @@ function startDaemon(config = {}) {
   const port = config.port ?? 9999;
   workingDirectory = config.cwd ?? process.cwd();
   currentProvider = config.defaultProvider ?? "gemini";
-  if (!isProviderAvailable(currentProvider)) {
-    const available = getAvailableProviders();
-    if (available.length > 0) {
-      console.log(`[Daemon] ${currentProvider} not found, falling back to ${available[0]}`);
-      currentProvider = available[0];
-    } else {
-      console.warn("[Daemon] Warning: No AI providers found. Install gemini or claude CLI.");
+  currentMode = config.defaultMode ?? "direct-cli";
+  if (currentMode === "direct-cli") {
+    if (!isProviderAvailable(currentProvider)) {
+      const available = getAvailableProviders();
+      if (available.length > 0) {
+        console.log(`[Daemon] ${currentProvider} CLI not found, falling back to ${available[0]}`);
+        currentProvider = available[0];
+      } else {
+        console.warn("[Daemon] Warning: No CLI providers found. Install gemini or claude CLI.");
+      }
     }
   }
   const wss = new ws.WebSocketServer({ port });
   wss.on("connection", handleConnection);
   wss.on("listening", () => {
+    const cliProviders = getAvailableProviders();
     console.log("");
     console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
     console.log("  \u2502                                                 \u2502");
-    console.log(`  \u2502   \u{1F3A8} Skema Daemon running on ws://localhost:${port}  \u2502`);
+    console.log(`  \u2502   Skema Daemon running on ws://localhost:${port}    \u2502`);
     console.log("  \u2502                                                 \u2502");
+    console.log(`  \u2502   Mode: ${currentMode.padEnd(39)}\u2502`);
     console.log(`  \u2502   Provider: ${currentProvider.padEnd(35)}\u2502`);
     console.log(`  \u2502   Directory: ${workingDirectory.slice(-33).padEnd(34)}\u2502`);
+    console.log(`  \u2502   CLI Providers: ${(cliProviders.join(", ") || "none").padEnd(29)}\u2502`);
     console.log("  \u2502                                                 \u2502");
     console.log("  \u2502   Waiting for browser connections...           \u2502");
     console.log("  \u2502                                                 \u2502");
@@ -1322,19 +1720,30 @@ function startDaemon(config = {}) {
 exports.DELETE = DELETE;
 exports.IMAGE_ANALYSIS_PROMPT = IMAGE_ANALYSIS_PROMPT;
 exports.POST = POST;
+exports.acknowledgeAnnotation = acknowledgeAnnotation;
 exports.analyzeImage = analyzeImage;
 exports.buildDetailedDomSelectionPrompt = buildDetailedDomSelectionPrompt;
 exports.buildDrawingToCodePrompt = buildDrawingToCodePrompt;
 exports.buildFastDomSelectionPrompt = buildFastDomSelectionPrompt;
 exports.buildGesturePrompt = buildGesturePrompt;
 exports.buildPromptFromAnnotation = buildPromptFromAnnotation;
+exports.clearAnnotations = clearAnnotations;
 exports.createGeminiCLIStream = createGeminiCLIStream;
 exports.createGeminiRouteHandler = createGeminiRouteHandler;
 exports.createRevertRouteHandler = createRevertRouteHandler;
-exports.getAvailableProviders = getAvailableProviders;
+exports.dismissAnnotation = dismissAnnotation;
+exports.getAllAnnotations = getAllAnnotations;
+exports.getAnnotation = getAnnotation;
+exports.getCLIProviders = getAvailableProviders;
+exports.getPendingAnnotations = getPendingAnnotations;
+exports.getPendingCount = getPendingCount;
 exports.getTrackedAnnotations = getTrackedAnnotations;
 exports.isProviderAvailable = isProviderAvailable;
 exports.isVisionAvailable = isVisionAvailable;
+exports.onStoreEvent = onStoreEvent;
+exports.queueAnnotation = queueAnnotation;
+exports.removeAnnotation = removeAnnotation;
+exports.resolveAnnotation = resolveAnnotation;
 exports.revertAnnotation = revertAnnotation;
 exports.runAICLI = runAICLI;
 exports.runGeminiCLI = runGeminiCLI;