skema-core 0.1.2 → 2.1.0

package/dist/mcp.js

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+'use strict';
+
+require('dotenv/config');
+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 WebSocket = require('ws');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+
+var DAEMON_PORT = parseInt(process.env.SKEMA_PORT || "9999", 10);
+var DAEMON_URL = `ws://localhost:${DAEMON_PORT}`;
+var daemonWs = null;
+var daemonConnected = false;
+var reconnectTimer = null;
+var RECONNECT_INTERVAL = 3e3;
+var messageIdCounter = 0;
+var pendingRequests = /* @__PURE__ */ new Map();
+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 WebSocket__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);
+    }
+  });
+}
+var 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: []
+    }
+  }
+];
+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, args) {
+  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: args.annotationId
+        });
+        return success(response.annotation);
+      } catch (err) {
+        return error(`Failed to get annotation: ${err.message}`);
+      }
+    }
+    case "skema_acknowledge": {
+      try {
+        await sendToDaemon("acknowledge-annotation", {
+          annotationId: args.annotationId
+        });
+        return success({ acknowledged: true, annotationId: args.annotationId });
+      } catch (err) {
+        return error(`Failed to acknowledge: ${err.message}`);
+      }
+    }
+    case "skema_resolve": {
+      try {
+        await sendToDaemon("resolve-annotation", {
+          annotationId: args.annotationId,
+          summary: args.summary
+        });
+        return success({
+          resolved: true,
+          annotationId: args.annotationId,
+          summary: args.summary
+        });
+      } catch (err) {
+        return error(`Failed to resolve: ${err.message}`);
+      }
+    }
+    case "skema_dismiss": {
+      try {
+        await sendToDaemon("dismiss-annotation", {
+          annotationId: args.annotationId,
+          reason: args.reason
+        });
+        return success({
+          dismissed: true,
+          annotationId: args.annotationId,
+          reason: args.reason
+        });
+      } catch (err) {
+        return error(`Failed to dismiss: ${err.message}`);
+      }
+    }
+    case "skema_watch": {
+      const timeoutSeconds = Math.min(300, Math.max(1, args?.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: args } = request.params;
+    try {
+      return await handleTool(name, args);
+    } 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");
+}
+
+// src/mcp/index.ts
+startMcpServer().catch((error2) => {
+  console.error("[Skema MCP] Fatal error:", error2);
+  process.exit(1);
+});

package/dist/server.d.mts

@@ -369,7 +369,47 @@ declare function buildDrawingToCodePrompt(input: DrawingInput): string;
  */
 declare const IMAGE_ANALYSIS_PROMPT: string;
 
+/**
+ * Execution modes:
+ * - 'direct-cli': Annotations processed instantly via CLI agents (gemini/claude CLI tools)
+ * - 'mcp': Annotations routed through an AI agent (Cursor, Claude Desktop, etc.)
+ */
+type ExecutionMode = 'direct-cli' | 'mcp';
+type ProviderName = 'gemini' | 'claude';
+
+interface DaemonConfig {
+    /** Port for WebSocket server (default: 9999) */
+    port?: number;
+    /** Working directory for file operations and AI commands */
+    cwd?: string;
+    /** Default AI provider */
+    defaultProvider?: ProviderName;
+    /** Default execution mode */
+    defaultMode?: ExecutionMode;
+}
+interface IncomingMessage {
+    id: string;
+    type: string;
+    [key: string]: unknown;
+}
+interface OutgoingMessage {
+    id?: string;
+    type: string;
+    success?: boolean;
+    error?: string;
+    [key: string]: unknown;
+}
+interface DaemonInstance {
+    port: number;
+    close: () => void;
+}
+/**
+ * Start the Skema daemon (WebSocket server)
+ */
+declare function startDaemon(config?: DaemonConfig): DaemonInstance;
+
 type AIProvider = 'gemini' | 'claude';
+type AnyProvider = 'gemini' | 'claude';
 interface AIProviderConfig {
     provider: AIProvider;
     /** Working directory for CLI commands */
@@ -381,7 +421,7 @@ interface AIStreamEvent {
     type: 'init' | 'text' | 'tool_use' | 'tool_result' | 'error' | 'done' | 'debug';
     content?: string;
     timestamp: string;
-    provider: AIProvider;
+    provider: AnyProvider;
     /** Raw event from the CLI (provider-specific) */
     raw?: unknown;
 }
@@ -411,35 +451,6 @@ declare function isProviderAvailable(provider: AIProvider): boolean;
  */
 declare function getAvailableProviders(): AIProvider[];
 
-interface DaemonConfig {
-    /** Port for WebSocket server (default: 9999) */
-    port?: number;
-    /** Working directory for file operations and AI commands */
-    cwd?: string;
-    /** Default AI provider */
-    defaultProvider?: AIProvider;
-}
-interface IncomingMessage {
-    id: string;
-    type: string;
-    [key: string]: unknown;
-}
-interface OutgoingMessage {
-    id?: string;
-    type: string;
-    success?: boolean;
-    error?: string;
-    [key: string]: unknown;
-}
-interface DaemonInstance {
-    port: number;
-    close: () => void;
-}
-/**
- * Start the Skema daemon (WebSocket server)
- */
-declare function startDaemon(config?: DaemonConfig): DaemonInstance;
-
 interface VisionAnalysisResult {
     success: boolean;
     description: string;
@@ -462,4 +473,69 @@ declare function analyzeImage(base64Image: string, config: VisionConfig): Promis
  */
 declare function isVisionAvailable(provider: AIProvider): boolean;
 
-export { type AIProvider, type AIProviderConfig, type AIRunResult, type AIStreamEvent, DELETE, type DaemonConfig, type DaemonInstance, type DetailedDomSelectionInput, type DomSelectionInput, type DrawingInput, type GeminiCLIEvent, type GeminiCLIOptions, type GestureInput, IMAGE_ANALYSIS_PROMPT, type IncomingMessage, type OutgoingMessage, POST, type ProjectContext, type VisionAnalysisResult, type VisionConfig, analyzeImage, buildDetailedDomSelectionPrompt, buildDrawingToCodePrompt, buildFastDomSelectionPrompt, buildGesturePrompt, buildPromptFromAnnotation, createGeminiCLIStream, createGeminiRouteHandler, createRevertRouteHandler, getAvailableProviders, getTrackedAnnotations, isProviderAvailable, isVisionAvailable, revertAnnotation, runAICLI, runGeminiCLI, spawnAICLI, spawnGeminiCLI, startDaemon };
+type AnnotationStatus = 'pending' | 'acknowledged' | 'resolved' | 'dismissed';
+interface StoredAnnotation {
+    /** The original Skema annotation data */
+    annotation: Annotation;
+    /** User comment describing the desired change */
+    comment: string;
+    /** Current status in the MCP workflow */
+    status: AnnotationStatus;
+    /** When it was queued */
+    createdAt: string;
+    /** When status last changed */
+    updatedAt: string;
+    /** If resolved/dismissed, who did it */
+    resolvedBy?: 'human' | 'agent';
+    /** Resolution summary (from agent) */
+    resolutionSummary?: string;
+    /** Dismissal reason (from agent) */
+    dismissalReason?: string;
+}
+type StoreListener = (event: string, annotation: StoredAnnotation) => void;
+/**
+ * Queue an annotation (called when user submits in MCP mode)
+ */
+declare function queueAnnotation(annotation: Annotation, comment: string): StoredAnnotation;
+/**
+ * Get all pending annotations
+ */
+declare function getPendingAnnotations(): StoredAnnotation[];
+/**
+ * Get all annotations (any status)
+ */
+declare function getAllAnnotations(): StoredAnnotation[];
+/**
+ * Get a specific annotation by ID
+ */
+declare function getAnnotation(id: string): StoredAnnotation | undefined;
+/**
+ * Mark an annotation as acknowledged (agent has seen it)
+ */
+declare function acknowledgeAnnotation(id: string): StoredAnnotation | undefined;
+/**
+ * Mark an annotation as resolved (agent has implemented the change)
+ */
+declare function resolveAnnotation(id: string, summary?: string): StoredAnnotation | undefined;
+/**
+ * Dismiss an annotation (agent decided not to address it)
+ */
+declare function dismissAnnotation(id: string, reason: string): StoredAnnotation | undefined;
+/**
+ * Remove an annotation from the store
+ */
+declare function removeAnnotation(id: string): StoredAnnotation | undefined;
+/**
+ * Clear all annotations
+ */
+declare function clearAnnotations(): void;
+/**
+ * Subscribe to store events
+ */
+declare function onStoreEvent(listener: StoreListener): () => void;
+/**
+ * Get count of pending annotations
+ */
+declare function getPendingCount(): number;
+
+export { type AIProviderConfig, type AIRunResult, type AIStreamEvent, type AnnotationStatus, type AIProvider as CLIProvider, DELETE, type DaemonConfig, type DaemonInstance, type DetailedDomSelectionInput, type DomSelectionInput, type DrawingInput, type ExecutionMode, type GeminiCLIEvent, type GeminiCLIOptions, type GestureInput, IMAGE_ANALYSIS_PROMPT, type IncomingMessage, type OutgoingMessage, POST, type ProjectContext, type ProviderName, type StoredAnnotation, type VisionAnalysisResult, type VisionConfig, acknowledgeAnnotation, analyzeImage, buildDetailedDomSelectionPrompt, buildDrawingToCodePrompt, buildFastDomSelectionPrompt, buildGesturePrompt, buildPromptFromAnnotation, clearAnnotations, createGeminiCLIStream, createGeminiRouteHandler, createRevertRouteHandler, dismissAnnotation, getAllAnnotations, getAnnotation, getAvailableProviders as getCLIProviders, getPendingAnnotations, getPendingCount, getTrackedAnnotations, isProviderAvailable, isVisionAvailable, onStoreEvent, queueAnnotation, removeAnnotation, resolveAnnotation, revertAnnotation, runAICLI, runGeminiCLI, spawnAICLI, spawnGeminiCLI, startDaemon };