skema-core 0.1.2 → 2.1.0

package/dist/cli.js

@@ -3,11 +3,16 @@
 
 var fs = require('fs');
 var path = require('path');
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var WebSocket2 = require('ws');
 require('dotenv/config');
-var ws = require('ws');
 var child_process = require('child_process');
 var generativeAi = require('@google/generative-ai');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   var n = Object.create(null);
@@ -28,6 +33,7 @@ function _interopNamespace(e) {
 
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -221,6 +227,411 @@ var init_init = __esm({
     }
   }
 });
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startMcpServer: () => startMcpServer
+});
+function scheduleReconnect() {
+  if (reconnectTimer) return;
+  reconnectTimer = setTimeout(async () => {
+    reconnectTimer = null;
+    console.error("[Skema MCP] Attempting to reconnect to daemon...");
+    try {
+      await connectToDaemon();
+    } catch {
+    }
+  }, RECONNECT_INTERVAL);
+}
+function connectToDaemon() {
+  return new Promise((resolve, reject) => {
+    if (daemonWs && daemonConnected) {
+      resolve();
+      return;
+    }
+    if (daemonWs) {
+      daemonWs.removeAllListeners();
+      daemonWs = null;
+    }
+    daemonWs = new WebSocket2__default.default(DAEMON_URL);
+    daemonWs.on("open", () => {
+      daemonConnected = true;
+      console.error("[Skema MCP] Connected to daemon at", DAEMON_URL);
+      daemonWs.send(JSON.stringify({
+        id: `mcp-identify-${Date.now()}`,
+        type: "identify",
+        client: "mcp-server"
+      }));
+      resolve();
+    });
+    daemonWs.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.id && pendingRequests.has(msg.id)) {
+          const pending = pendingRequests.get(msg.id);
+          pendingRequests.delete(msg.id);
+          clearTimeout(pending.timeout);
+          if (msg.type === "error") {
+            pending.reject(new Error(msg.error));
+          } else {
+            pending.resolve(msg);
+          }
+        }
+      } catch (e) {
+        console.error("[Skema MCP] Failed to parse daemon message:", e);
+      }
+    });
+    daemonWs.on("close", () => {
+      daemonConnected = false;
+      daemonWs = null;
+      console.error("[Skema MCP] Disconnected from daemon");
+      scheduleReconnect();
+    });
+    daemonWs.on("error", (err) => {
+      daemonConnected = false;
+      console.error("[Skema MCP] Daemon connection error:", err.message);
+      reject(err);
+    });
+  });
+}
+function sendToDaemon(type, payload = {}) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      if (!daemonConnected) {
+        await connectToDaemon();
+      }
+      if (!daemonWs || !daemonConnected) {
+        reject(new Error("Not connected to Skema daemon. Is it running?"));
+        return;
+      }
+      const id = `mcp-${++messageIdCounter}`;
+      const timeout = setTimeout(() => {
+        pendingRequests.delete(id);
+        reject(new Error(`Daemon request timed out: ${type}`));
+      }, 3e4);
+      pendingRequests.set(id, { resolve, reject, timeout });
+      daemonWs.send(JSON.stringify({ id, type, ...payload }));
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+function success(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function error(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+async function handleTool(name, args2) {
+  switch (name) {
+    case "skema_get_pending": {
+      try {
+        const response = await sendToDaemon("get-pending-annotations");
+        return success({
+          count: response.count,
+          annotations: response.annotations
+        });
+      } catch (err) {
+        return error(`Failed to get pending annotations: ${err.message}`);
+      }
+    }
+    case "skema_get_all_annotations": {
+      try {
+        const response = await sendToDaemon("get-all-annotations");
+        return success({
+          count: response.count,
+          annotations: response.annotations
+        });
+      } catch (err) {
+        return error(`Failed to get annotations: ${err.message}`);
+      }
+    }
+    case "skema_get_annotation": {
+      try {
+        const response = await sendToDaemon("get-annotation", {
+          annotationId: args2.annotationId
+        });
+        return success(response.annotation);
+      } catch (err) {
+        return error(`Failed to get annotation: ${err.message}`);
+      }
+    }
+    case "skema_acknowledge": {
+      try {
+        await sendToDaemon("acknowledge-annotation", {
+          annotationId: args2.annotationId
+        });
+        return success({ acknowledged: true, annotationId: args2.annotationId });
+      } catch (err) {
+        return error(`Failed to acknowledge: ${err.message}`);
+      }
+    }
+    case "skema_resolve": {
+      try {
+        await sendToDaemon("resolve-annotation", {
+          annotationId: args2.annotationId,
+          summary: args2.summary
+        });
+        return success({
+          resolved: true,
+          annotationId: args2.annotationId,
+          summary: args2.summary
+        });
+      } catch (err) {
+        return error(`Failed to resolve: ${err.message}`);
+      }
+    }
+    case "skema_dismiss": {
+      try {
+        await sendToDaemon("dismiss-annotation", {
+          annotationId: args2.annotationId,
+          reason: args2.reason
+        });
+        return success({
+          dismissed: true,
+          annotationId: args2.annotationId,
+          reason: args2.reason
+        });
+      } catch (err) {
+        return error(`Failed to dismiss: ${err.message}`);
+      }
+    }
+    case "skema_watch": {
+      const timeoutSeconds = Math.min(300, Math.max(1, args2?.timeoutSeconds ?? 120));
+      const pollInterval = 2e3;
+      const maxPolls = Math.ceil(timeoutSeconds * 1e3 / pollInterval);
+      for (let i = 0; i < maxPolls; i++) {
+        try {
+          const response = await sendToDaemon("get-pending-annotations");
+          if (response.count > 0) {
+            return success({
+              timeout: false,
+              count: response.count,
+              annotations: response.annotations
+            });
+          }
+        } catch (err) {
+          return error(`Lost connection to daemon: ${err.message}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+      return success({
+        timeout: true,
+        message: `No new annotations within ${timeoutSeconds} seconds`
+      });
+    }
+    default:
+      return error(`Unknown tool: ${name}`);
+  }
+}
+async function startMcpServer() {
+  try {
+    await connectToDaemon();
+  } catch {
+    console.error("[Skema MCP] Warning: Could not connect to daemon. Will auto-retry...");
+    scheduleReconnect();
+  }
+  const server = new index_js.Server(
+    {
+      name: "skema",
+      version: "0.3.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  server.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+  });
+  server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args2 } = request.params;
+    try {
+      return await handleTool(name, args2);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return error(message);
+    }
+  });
+  server.setRequestHandler(types_js.ListResourcesRequestSchema, async () => {
+    return {
+      resources: [
+        {
+          uri: "skema://status",
+          name: "Skema Status",
+          description: "Current Skema daemon connection status and pending annotation count",
+          mimeType: "application/json"
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(types_js.ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    switch (uri) {
+      case "skema://status": {
+        let pendingCount = 0;
+        let connected = false;
+        try {
+          const response = await sendToDaemon("get-pending-annotations");
+          pendingCount = response.count;
+          connected = true;
+        } catch {
+          connected = false;
+        }
+        return {
+          contents: [{
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify({
+              daemonConnected: connected,
+              daemonUrl: DAEMON_URL,
+              pendingAnnotations: pendingCount
+            }, null, 2)
+          }]
+        };
+      }
+      default:
+        throw new Error(`Unknown resource: ${uri}`);
+    }
+  });
+  server.oninitialized = () => {
+    const clientInfo = server.getClientVersion();
+    const clientName = clientInfo?.name || "unknown";
+    console.error("[Skema MCP] Connected client:", clientName, clientInfo?.version || "");
+    if (daemonWs && daemonConnected) {
+      daemonWs.send(JSON.stringify({
+        id: `mcp-client-info-${Date.now()}`,
+        type: "mcp-client-info",
+        clientName,
+        clientVersion: clientInfo?.version
+      }));
+    }
+  };
+  const transport = new stdio_js.StdioServerTransport();
+  await server.connect(transport);
+  console.error("[Skema MCP] Server started");
+  console.error("[Skema MCP] Daemon URL:", DAEMON_URL);
+  console.error("[Skema MCP] Tools: skema_get_pending, skema_acknowledge, skema_resolve, skema_dismiss, skema_watch");
+}
+var DAEMON_PORT, DAEMON_URL, daemonWs, daemonConnected, reconnectTimer, RECONNECT_INTERVAL, messageIdCounter, pendingRequests, TOOLS;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    DAEMON_PORT = parseInt(process.env.SKEMA_PORT || "9999", 10);
+    DAEMON_URL = `ws://localhost:${DAEMON_PORT}`;
+    daemonWs = null;
+    daemonConnected = false;
+    reconnectTimer = null;
+    RECONNECT_INTERVAL = 3e3;
+    messageIdCounter = 0;
+    pendingRequests = /* @__PURE__ */ new Map();
+    TOOLS = [
+      {
+        name: "skema_get_pending",
+        description: "Get all pending annotations from the Skema browser overlay. These are visual annotations (DOM selections, drawings, multi-selects) that the user has made on their web page and wants you to implement as code changes. Each annotation includes the user's comment describing what they want, plus element selectors, CSS paths, bounding boxes, and other context to help you find the right code to modify.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "skema_get_all_annotations",
+        description: "Get all annotations (pending, acknowledged, resolved, dismissed). Useful for reviewing the full history of annotation requests and their current status.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "skema_get_annotation",
+        description: "Get details of a specific annotation by ID.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            annotationId: {
+              type: "string",
+              description: "The annotation ID to look up"
+            }
+          },
+          required: ["annotationId"]
+        }
+      },
+      {
+        name: "skema_acknowledge",
+        description: "Mark an annotation as acknowledged. Use this to tell the user you've seen their annotation and are working on it. The browser overlay will update to show the status change.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            annotationId: {
+              type: "string",
+              description: "The annotation ID to acknowledge"
+            }
+          },
+          required: ["annotationId"]
+        }
+      },
+      {
+        name: "skema_resolve",
+        description: "Mark an annotation as resolved after you've implemented the requested change. Include a summary of what you did so the user can see it in the browser overlay.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            annotationId: {
+              type: "string",
+              description: "The annotation ID to resolve"
+            },
+            summary: {
+              type: "string",
+              description: "Summary of what was done to resolve this annotation"
+            }
+          },
+          required: ["annotationId"]
+        }
+      },
+      {
+        name: "skema_dismiss",
+        description: "Dismiss an annotation if you decide not to implement it. Include a reason so the user understands why.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            annotationId: {
+              type: "string",
+              description: "The annotation ID to dismiss"
+            },
+            reason: {
+              type: "string",
+              description: "Reason for dismissing this annotation"
+            }
+          },
+          required: ["annotationId", "reason"]
+        }
+      },
+      {
+        name: "skema_watch",
+        description: "Wait for new annotations to appear. This blocks until the user creates new annotations in the browser overlay, then returns them as a batch. Use this in a loop for hands-free processing: call skema_watch, process the returned annotations, resolve them, then call skema_watch again.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            timeoutSeconds: {
+              type: "number",
+              description: "Max seconds to wait for annotations (default: 120, max: 300)"
+            }
+          },
+          required: []
+        }
+      }
+    ];
+  }
+});
 var PROVIDERS = {
   gemini: {
     command: "gemini",
@@ -430,6 +841,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")
+  };
+}
 
 // src/lib/utils.ts
 function getGridCellReference(x, y, gridSize = 100) {
@@ -442,7 +897,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.`;
@@ -581,7 +1036,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.`;
@@ -702,8 +1157,8 @@ async function analyzeWithGemini(base64Image, apiKey, model = "gemini-2.5-flash"
       description: text,
       provider: "gemini"
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     console.error("[Vision] Gemini analysis failed:", message);
     return {
       success: false,
@@ -748,8 +1203,8 @@ async function analyzeWithClaude(base64Image, apiKey, model = "claude-sonnet-4-2
       description,
       provider: "claude"
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     console.error("[Vision] Claude analysis failed:", message);
     return {
       success: false,
@@ -786,10 +1241,97 @@ 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 clearAnnotations() {
+  storedAnnotations.clear();
+}
+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();
@@ -801,8 +1343,8 @@ function createSnapshot2(annotationId) {
     const headRef = child_process.execSync("git rev-parse HEAD", { cwd: workingDirectory, encoding: "utf-8" }).trim();
     annotationSnapshots2.set(annotationId, headRef);
     return headRef;
-  } catch (error) {
-    console.error("[Daemon] Failed to create snapshot:", error);
+  } catch (error2) {
+    console.error("[Daemon] Failed to create snapshot:", error2);
     return null;
   }
 }
@@ -828,8 +1370,8 @@ function revertSnapshot(annotationId) {
     }
     annotationSnapshots2.delete(annotationId);
     return { success: true, message: `Reverted ${changedFiles.length} file(s)` };
-  } catch (error) {
-    return { success: false, message: String(error) };
+  } catch (error2) {
+    return { success: false, message: String(error2) };
   }
 }
 var handlers = {
@@ -849,17 +1391,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)
   // -------------------------------------------------------------------------
@@ -867,21 +1437,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()) {
-        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"
         });
@@ -895,7 +1485,7 @@ var handlers = {
               content: `[Vision analysis complete]
 ${visionDescription}`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              provider: currentProvider
+              provider: requestProvider
             }
           });
         } else {
@@ -906,7 +1496,7 @@ ${visionDescription}`,
               type: "error",
               content: `Vision analysis failed: ${visionResult.error}`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              provider: currentProvider
+              provider: requestProvider
             }
           });
         }
@@ -918,14 +1508,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, {
@@ -935,11 +1524,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
     };
@@ -957,7 +1560,8 @@ ${visionDescription}`,
           type: "generate-complete",
           success: true,
           annotationId,
-          provider: currentProvider
+          provider: requestProvider,
+          mode: requestMode
         });
         break;
       }
@@ -975,6 +1579,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) => {
@@ -983,8 +1690,8 @@ ${visionDescription}`,
     try {
       const content = fs__namespace.readFileSync(absolutePath, "utf-8");
       return { id: msg.id, type: "file-content", path: filePath, content };
-    } catch (error) {
-      return { id: msg.id, type: "error", error: `Failed to read file: ${error}` };
+    } catch (error2) {
+      return { id: msg.id, type: "error", error: `Failed to read file: ${error2}` };
     }
   },
   "write-file": async (msg) => {
@@ -996,8 +1703,8 @@ ${visionDescription}`,
       fs__namespace.writeFileSync(absolutePath, content, "utf-8");
       console.log(`[Daemon] Wrote file: ${filePath}`);
       return { id: msg.id, type: "write-success", path: filePath };
-    } catch (error) {
-      return { id: msg.id, type: "error", error: `Failed to write file: ${error}` };
+    } catch (error2) {
+      return { id: msg.id, type: "error", error: `Failed to write file: ${error2}` };
     }
   },
   "list-files": async (msg) => {
@@ -1010,8 +1717,8 @@ ${visionDescription}`,
         isDirectory: entry.isDirectory()
       }));
       return { id: msg.id, type: "file-list", path: dirPath, files };
-    } catch (error) {
-      return { id: msg.id, type: "error", error: `Failed to list files: ${error}` };
+    } catch (error2) {
+      return { id: msg.id, type: "error", error: `Failed to list files: ${error2}` };
     }
   },
   // -------------------------------------------------------------------------
@@ -1024,18 +1731,45 @@ ${visionDescription}`,
     }
     console.log(`[Daemon] Running command: ${command2}`);
     return new Promise((resolve) => {
-      child_process.exec(command2, { cwd: workingDirectory }, (error, stdout, stderr) => {
+      child_process.exec(command2, { cwd: workingDirectory }, (error2, stdout, stderr) => {
         resolve({
           id: msg.id,
           type: "command-result",
           stdout,
           stderr,
-          exitCode: error ? error.code : 0
+          exitCode: error2 ? error2.code : 0
         });
       });
     });
   },
   // -------------------------------------------------------------------------
+  // 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) => {
@@ -1043,23 +1777,70 @@ ${visionDescription}`,
       id: msg.id,
       type: "pong",
       provider: currentProvider,
+      mode: currentMode,
       cwd: workingDirectory,
-      availableProviders: getAvailableProviders()
+      availableProviders: getAvailableProviders(),
+      availableModes: ["direct-cli", "mcp"],
+      mcpServerConnected: mcpServerClient?.readyState === WebSocket2.WebSocket.OPEN,
+      mcpClientName
     };
   }
 };
-function sendMessage(ws$1, message) {
-  if (ws$1.readyState === ws.WebSocket.OPEN) {
-    ws$1.send(JSON.stringify(message));
+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, message) {
+  if (ws.readyState === WebSocket2.WebSocket.OPEN) {
+    ws.send(JSON.stringify(message));
   }
 }
 function handleConnection(ws) {
   console.log("[Daemon] Client connected");
+  connectedClients.add(ws);
   sendMessage(ws, {
     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 === WebSocket2.WebSocket.OPEN,
+    mcpClientName
   });
   ws.on("message", async (data) => {
     let msg;
@@ -1079,55 +1860,72 @@ function handleConnection(ws) {
       if (response) {
         sendMessage(ws, response);
       }
-    } catch (error) {
+    } catch (error2) {
       sendMessage(ws, {
         id: msg.id,
         type: "error",
-        error: `Handler error: ${error}`
+        error: `Handler error: ${error2}`
       });
     }
   });
   ws.on("close", () => {
     console.log("[Daemon] Client disconnected");
+    connectedClients.delete(ws);
+    if (ws === mcpServerClient) {
+      mcpServerClient = null;
+      mcpClientName = null;
+      console.log("[Daemon] MCP server disconnected");
+      broadcastToClients({
+        type: "mcp-server-status",
+        connected: false,
+        clientName: null
+      });
+    }
   });
-  ws.on("error", (error) => {
-    console.error("[Daemon] WebSocket error:", error);
+  ws.on("error", (error2) => {
+    console.error("[Daemon] WebSocket error:", error2);
   });
 }
 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 });
+  const wss = new WebSocket2.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");
     console.log("  \u2514\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\u2518");
     console.log("");
   });
-  wss.on("error", (error) => {
-    if (error.code === "EADDRINUSE") {
+  wss.on("error", (error2) => {
+    if (error2.code === "EADDRINUSE") {
       console.error(`[Daemon] Port ${port} is already in use. Is another Skema daemon running?`);
     } else {
-      console.error("[Daemon] Server error:", error);
+      console.error("[Daemon] Server error:", error2);
     }
   });
   return {
@@ -1148,17 +1946,26 @@ function printHelp() {
   console.log("");
   console.log("  Usage:");
   console.log("    npx skema-core          Start the daemon (default)");
+  console.log("    npx skema-core --mcp    Start as MCP server (for Cursor/Claude Desktop)");
   console.log("    npx skema-core init     Configure your project");
   console.log("    npx skema-core help     Show this help");
   console.log("");
   console.log("  Options (for daemon):");
-  console.log("    -p, --port <port>  Port number (default: 9999)");
-  console.log("    -d, --dir <path>   Working directory");
-  console.log("    --provider <name>  Default AI provider (gemini|claude)");
+  console.log("    -p, --port <port>       Port number (default: 9999)");
+  console.log("    -d, --dir <path>        Working directory");
+  console.log("    --provider <name>       Default AI provider (gemini|claude)");
+  console.log("    --mode <mode>           Execution mode (direct-cli|mcp)");
+  console.log("    --mcp                   Start as MCP server (stdio transport)");
+  console.log("");
+  console.log("  Execution Modes:");
+  console.log("    direct-cli    Use Gemini/Claude CLI agents (default, no API key needed)");
+  console.log("    mcp           Route through AI agent (Cursor, Claude Desktop)");
   console.log("");
   console.log("  Examples:");
   console.log("    npx skema-core");
   console.log("    npx skema-core --port 8080");
+  console.log("    npx skema-core --provider claude");
+  console.log("    npx skema-core --mcp");
   console.log("    npx skema-core init");
   console.log("");
   console.log('  Note: After installing skema-core, you can also use "skema" directly.');
@@ -1178,6 +1985,11 @@ function parseArgs(args2) {
     } else if (arg === "--provider") {
       config.defaultProvider = next;
       i++;
+    } else if (arg === "--mode") {
+      config.defaultMode = next;
+      i++;
+    } else if (arg === "--mcp") {
+      config.mcp = true;
     }
   }
   return config;
@@ -1185,9 +1997,25 @@ function parseArgs(args2) {
 async function runInit() {
   await Promise.resolve().then(() => (init_init(), init_exports));
 }
+async function runMcpServer() {
+  const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startMcpServer2();
+}
 function runDaemon(args2) {
   const config = parseArgs(args2);
-  startDaemon(config);
+  if (config.mcp) {
+    runMcpServer().catch((error2) => {
+      console.error("[Skema] MCP server error:", error2);
+      process.exit(1);
+    });
+    return;
+  }
+  startDaemon({
+    port: config.port,
+    cwd: config.cwd,
+    defaultProvider: config.defaultProvider,
+    defaultMode: config.defaultMode
+  });
 }
 if (command === "help" || command === "-h" || command === "--help") {
   printHelp();
@@ -1195,6 +2023,11 @@ if (command === "help" || command === "-h" || command === "--help") {
   runInit();
 } else if (command === "serve") {
   runDaemon(args.slice(1));
+} else if (command === "mcp" || command === "--mcp") {
+  runMcpServer().catch((error2) => {
+    console.error("[Skema] MCP server error:", error2);
+    process.exit(1);
+  });
 } else {
   runDaemon(args);
 }