@curenorway/kode-mcp 1.1.0 → 1.3.0

package/dist/index.js

@@ -105,6 +105,16 @@ var KodeApiClient = class {
   async getDeploymentStatus(siteId) {
     return this.request(`/api/cdn/sites/${siteId}/deployments/status`);
   }
+  // v2.3: Production enabled toggle
+  async setProductionEnabled(siteId, enabled, productionDomain) {
+    return this.request(`/api/cdn/sites/${siteId}/production`, {
+      method: "POST",
+      body: JSON.stringify({
+        enabled,
+        productionDomain
+      })
+    });
+  }
   // HTML operations
   async fetchHtml(siteId, url) {
     return this.request("/api/cdn/fetch-html", {
@@ -121,6 +131,16 @@ var KodeApiClient = class {
       return false;
     }
   }
+  // Metadata operations
+  async analyzeScript(scriptId, options = {}) {
+    return this.request(`/api/cdn/scripts/${scriptId}/analyze`, {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  async getScriptMetadata(scriptId) {
+    return this.request(`/api/cdn/scripts/${scriptId}/metadata`);
+  }
 };
 
 // src/config.ts
@@ -252,13 +272,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "kode_get_script",
-        description: "Get the full content of a specific script by its slug (filename without extension) or ID.",
+        description: "Get a script by its slug or ID. By default returns full content. Use includeContent:false to get just metadata (saves context tokens for large scripts).",
         inputSchema: {
           type: "object",
           properties: {
             slug: {
               type: "string",
               description: 'Script slug (e.g., "init", "tracking") or script ID (UUID)'
+            },
+            includeContent: {
+              type: "boolean",
+              description: "Include full script content. Default: true. Set to false to get just metadata (name, type, scope, version, size) - useful for large scripts."
+            },
+            contentPreview: {
+              type: "number",
+              description: "If set, include only the first N characters of content. Useful for previewing large scripts without loading everything."
             }
           },
           required: ["slug"]
@@ -266,7 +294,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "kode_create_script",
-        description: "Create a new script on the Cure Kode CDN. The script will be available at the CDN URL after deployment. Global scripts auto-load by default; page-specific scripts do not.",
+        description: "Create a new script entry (metadata only). After creating, write the script file locally to .cure-kode-scripts/{name}.js and use kode_push to upload content. This keeps script content out of MCP context.",
         inputSchema: {
           type: "object",
           properties: {
@@ -279,10 +307,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               enum: ["javascript", "css"],
               description: "Script type"
             },
-            content: {
-              type: "string",
-              description: "Script content (JavaScript or CSS code)"
-            },
             scope: {
               type: "string",
               enum: ["global", "page-specific"],
@@ -290,15 +314,37 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             autoLoad: {
               type: "boolean",
-              description: "Whether to auto-load the script. Default: true for global scripts, false for page-specific. Set to false for scripts you want to load manually via CK.loadScript()."
+              description: "Whether to auto-load the script. Default: true for global scripts, false for page-specific."
+            },
+            purpose: {
+              type: "string",
+              description: "Brief description of what the script does (for metadata)"
             }
           },
-          required: ["name", "type", "content"]
+          required: ["name", "type"]
+        }
+      },
+      {
+        name: "kode_push",
+        description: "Push local script files to Cure Kode. Reads files from .cure-kode-scripts/ folder and uploads to API. This is the proper way to sync code - never send script content through other MCP tools.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scriptSlug: {
+              type: "string",
+              description: 'Specific script slug to push (e.g., "map"). If omitted, pushes all changed scripts.'
+            },
+            force: {
+              type: "boolean",
+              description: "Force push even if content appears unchanged. Default: false"
+            }
+          },
+          required: []
         }
       },
       {
         name: "kode_update_script",
-        description: "Update an existing script's content or settings. This creates a new version of the script when content changes.",
+        description: "Update script settings (NOT content). For content changes, edit the local file in .cure-kode-scripts/ and use kode_push. This tool is for metadata, scope, and autoLoad changes only.",
         inputSchema: {
           type: "object",
           properties: {
@@ -306,10 +352,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: "string",
               description: "Script slug or ID to update"
             },
-            content: {
-              type: "string",
-              description: "New script content"
-            },
             autoLoad: {
               type: "boolean",
               description: "Whether to auto-load the script. Set to true to load automatically, false for manual loading via CK.loadScript()."
@@ -319,9 +361,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               enum: ["global", "page-specific"],
               description: "Change script scope. Note: changing to page-specific requires assigning to pages."
             },
-            changeSummary: {
+            purpose: {
               type: "string",
-              description: "Brief description of the changes (for version history)"
+              description: "Update the script purpose description (shown in Chrome Extension)"
+            },
+            regenerateSummary: {
+              type: "boolean",
+              description: "Re-analyze the script content and regenerate the AI summary. Useful after significant changes."
             }
           },
           required: ["slug"]
@@ -371,7 +417,30 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "kode_status",
-        description: "Get the current deployment status for both staging and production environments.",
+        description: "Get the current deployment status including production enabled state, staging and production environments.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "kode_production_enable",
+        description: "Enable production environment for this site. Required before promoting to production. Sites start in staging-only mode by default.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            productionDomain: {
+              type: "string",
+              description: 'Production domain (e.g., "example.com"). Optional - can be set later.'
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "kode_production_disable",
+        description: "Disable production environment for this site. Production requests will return an empty script. Useful during development when only staging should be active.",
         inputSchema: {
           type: "object",
           properties: {},
@@ -450,6 +519,38 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: []
         }
       },
+      {
+        name: "kode_analyze_script",
+        description: "Analyze a script's content and auto-generate metadata. Detects DOM selectors, event triggers, dependencies (GSAP, Swiper, etc.), and behavior patterns. Optionally saves the analysis to the script.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: "Script slug or ID to analyze"
+            },
+            saveToScript: {
+              type: "boolean",
+              description: "Save the generated metadata to the script. Default: false (preview only)"
+            }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "kode_get_script_metadata",
+        description: "Get the metadata for a script, including detected DOM targets, triggers, dependencies, and AI summary. Useful for Chrome Extension visibility.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: "Script slug or ID to get metadata for"
+            }
+          },
+          required: ["slug"]
+        }
+      },
       {
         name: "kode_read_context",
         description: "Read the project context file (.cure-kode/context.md). Contains current scripts, notes, and session history. ALWAYS call this before starting work on a Kode project.",
@@ -597,7 +698,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
       case "kode_get_script": {
-        const { slug } = args;
+        const { slug, includeContent = true, contentPreview } = args;
         const scripts = await client.listScripts(siteId);
         const script = scripts.find((s) => s.slug === slug || s.id === slug);
         if (!script) {
@@ -606,6 +707,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             isError: true
           };
         }
+        const contentLength = script.content?.length || 0;
+        const estimatedTokens = Math.ceil(contentLength / 4);
+        if (!includeContent && !contentPreview) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Script: ${script.name}
+Slug: ${script.slug}
+Type: ${script.type}
+Scope: ${script.scope}
+Version: ${script.current_version}
+Auto-load: ${script.auto_load ? "yes" : "no"}
+Size: ${contentLength} chars (~${estimatedTokens} tokens)
+
+Use includeContent:true or contentPreview:N to fetch content.`
+              }
+            ]
+          };
+        }
+        if (contentPreview && contentPreview > 0) {
+          const preview = script.content?.slice(0, contentPreview) || "";
+          const isTruncated = contentLength > contentPreview;
+          return {
+            content: [
+              {
+                type: "text",
+                text: `// Script: ${script.name} (${script.type})
+// Version: ${script.current_version}
+// Scope: ${script.scope}
+// Size: ${contentLength} chars (~${estimatedTokens} tokens)${isTruncated ? `
+// Showing first ${contentPreview} chars` : ""}
+
+${preview}${isTruncated ? "\n\n// ... (truncated) - use includeContent:true for full content" : ""}`
+              }
+            ]
+          };
+        }
         return {
           content: [
             {
@@ -613,6 +752,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               text: `// Script: ${script.name} (${script.type})
 // Version: ${script.current_version}
 // Scope: ${script.scope}
+// Size: ${contentLength} chars (~${estimatedTokens} tokens)
 
 ${script.content}`
             }
@@ -620,35 +760,155 @@ ${script.content}`
         };
       }
       case "kode_create_script": {
-        const { name: scriptName, type, content, scope, autoLoad } = args;
+        const { name: scriptName, type, scope, autoLoad, purpose } = args;
         const scriptScope = scope || "global";
         const script = await client.createScript(siteId, {
           name: scriptName,
           slug: scriptName,
           type,
-          content,
+          content: "",
+          // Empty - content comes from local files via kode_push
           scope: scriptScope,
-          autoLoad
-          // Let API handle default based on scope
+          autoLoad,
+          metadata: purpose ? { purpose } : void 0
         });
-        const autoLoadStatus = script.auto_load ? "will auto-load" : "manual load only (use CK.loadScript())";
+        const scriptsDir = getScriptsDir();
+        const ext = type === "javascript" ? "js" : "css";
+        const localPath = scriptsDir ? `${scriptsDir}/${scriptName}.${ext}` : `.cure-kode-scripts/${scriptName}.${ext}`;
+        let responseText = `Created script "${script.name}" (${script.type})`;
+        responseText += `
+Slug: ${script.slug}`;
+        responseText += `
+Scope: ${script.scope}`;
+        responseText += `
+Auto-load: ${script.auto_load ? "yes" : "no"}`;
+        if (purpose) responseText += `
+Purpose: ${purpose}`;
+        responseText += `
+
+Next steps:`;
+        responseText += `
+1. Create file: ${localPath}`;
+        responseText += `
+2. Write your ${type} code`;
+        responseText += `
+3. Run kode_push to upload content`;
+        responseText += `
+4. Run kode_deploy to make it live`;
         return {
           content: [
             {
               type: "text",
-              text: `Created script "${script.name}" (${script.type})
-Slug: ${script.slug}
-Scope: ${script.scope}
-Auto-load: ${autoLoadStatus}
-Version: ${script.current_version}
-
-Note: Run kode_deploy to make it live.`
+              text: responseText
             }
           ]
         };
       }
+      case "kode_push": {
+        const { scriptSlug, force } = args;
+        const scriptsDir = getScriptsDir();
+        if (!scriptsDir || !fs2.existsSync(scriptsDir)) {
+          return {
+            content: [{
+              type: "text",
+              text: 'No .cure-kode-scripts/ folder found. Run "kode init" first or create the folder manually.'
+            }],
+            isError: true
+          };
+        }
+        const remoteScripts = await client.listScripts(siteId);
+        const localFiles = fs2.readdirSync(scriptsDir).filter((f) => f.endsWith(".js") || f.endsWith(".css"));
+        if (scriptSlug) {
+          const ext = remoteScripts.find((s) => s.slug === scriptSlug)?.type === "css" ? "css" : "js";
+          const fileName = `${scriptSlug}.${ext}`;
+          const filePath = path2.join(scriptsDir, fileName);
+          if (!fs2.existsSync(filePath)) {
+            return {
+              content: [{
+                type: "text",
+                text: `File not found: ${filePath}
+
+Available files: ${localFiles.join(", ") || "(none)"}`
+              }],
+              isError: true
+            };
+          }
+          const content = fs2.readFileSync(filePath, "utf-8");
+          const remote = remoteScripts.find((s) => s.slug === scriptSlug);
+          if (!remote) {
+            return {
+              content: [{
+                type: "text",
+                text: `Script "${scriptSlug}" not found on server. Create it first with kode_create_script.`
+              }],
+              isError: true
+            };
+          }
+          if (!force && remote.content === content) {
+            return {
+              content: [{
+                type: "text",
+                text: `Script "${scriptSlug}" is already up to date (${content.length} chars). Use force: true to push anyway.`
+              }]
+            };
+          }
+          const updated = await client.updateScript(remote.id, {
+            content,
+            changeSummary: "Pushed via MCP"
+          });
+          return {
+            content: [{
+              type: "text",
+              text: `Pushed "${scriptSlug}": ${content.length} chars \u2192 v${updated.current_version}
+
+Run kode_deploy to make changes live.`
+            }]
+          };
+        }
+        const results = [];
+        let pushedCount = 0;
+        let skippedCount = 0;
+        for (const file of localFiles) {
+          const slug = file.replace(/\.(js|css)$/, "");
+          const filePath = path2.join(scriptsDir, file);
+          const content = fs2.readFileSync(filePath, "utf-8");
+          const remote = remoteScripts.find((s) => s.slug === slug);
+          if (!remote) {
+            results.push(`\u26A0\uFE0F ${slug}: not on server (create with kode_create_script first)`);
+            continue;
+          }
+          if (!force && remote.content === content) {
+            skippedCount++;
+            continue;
+          }
+          try {
+            const updated = await client.updateScript(remote.id, {
+              content,
+              changeSummary: "Pushed via MCP"
+            });
+            results.push(`\u2713 ${slug}: ${content.length} chars \u2192 v${updated.current_version}`);
+            pushedCount++;
+          } catch (err) {
+            results.push(`\u2717 ${slug}: ${err instanceof Error ? err.message : "failed"}`);
+          }
+        }
+        let responseText = `Push complete: ${pushedCount} updated, ${skippedCount} unchanged`;
+        if (results.length > 0) {
+          responseText += `
+
+${results.join("\n")}`;
+        }
+        if (pushedCount > 0) {
+          responseText += `
+
+Run kode_deploy to make changes live.`;
+        }
+        return {
+          content: [{ type: "text", text: responseText }]
+        };
+      }
       case "kode_update_script": {
-        const { slug, content, autoLoad, scope, changeSummary } = args;
+        const { slug, autoLoad, scope, purpose, regenerateSummary } = args;
         const scripts = await client.listScripts(siteId);
         const script = scripts.find((s) => s.slug === slug || s.id === slug);
         if (!script) {
@@ -657,24 +917,32 @@ Note: Run kode_deploy to make it live.`
             isError: true
           };
         }
-        const updateData = {};
-        if (content !== void 0) updateData.content = content;
+        const updateData = {
+          changeSummary: "Updated settings via MCP"
+        };
         if (autoLoad !== void 0) updateData.autoLoad = autoLoad;
         if (scope !== void 0) updateData.scope = scope;
-        updateData.changeSummary = changeSummary || "Updated via MCP";
+        if (purpose !== void 0) updateData.metadata = { purpose };
+        if (regenerateSummary !== void 0) updateData.regenerateSummary = regenerateSummary;
         const updated = await client.updateScript(script.id, updateData);
         const changes = [];
-        if (content !== void 0) changes.push(`content \u2192 v${updated.current_version}`);
-        if (autoLoad !== void 0) changes.push(`auto_load \u2192 ${autoLoad}`);
+        if (autoLoad !== void 0) changes.push(`autoLoad \u2192 ${autoLoad}`);
         if (scope !== void 0) changes.push(`scope \u2192 ${scope}`);
+        if (purpose !== void 0) changes.push(`purpose updated`);
+        if (regenerateSummary) changes.push("AI summary regenerated");
+        let responseText = `Updated script "${updated.name}"`;
+        if (changes.length > 0) {
+          responseText += `
+Changes: ${changes.join(", ")}`;
+        }
+        responseText += `
+
+To update content: edit local file and run kode_push`;
         return {
           content: [
             {
               type: "text",
-              text: `Updated script "${updated.name}"
-Changes: ${changes.join(", ")}
-
-Note: Run kode_deploy to make changes live.`
+              text: responseText
             }
           ]
         };
@@ -705,19 +973,54 @@ Note: Run kode_deploy to make changes live.`
           environment: environment || "staging",
           notes: notes || "Deployed via MCP"
         });
+        let responseText = `Deployment ${deployment.version} to ${deployment.environment}: ${deployment.status}`;
+        responseText += `
+Started: ${deployment.started_at}`;
+        if (deployment.completed_at) {
+          responseText += `
+Completed: ${deployment.completed_at}`;
+        }
+        const scriptSizes = deployment.stats?.scriptSizes;
+        if (scriptSizes && scriptSizes.length > 0) {
+          responseText += `
+
+Scripts deployed (${scriptSizes.length}):`;
+          for (const s of scriptSizes) {
+            const flags = [
+              s.scope === "global" ? "G" : "P",
+              s.autoLoad ? "\u26A1" : "\u25CB"
+            ].join("");
+            responseText += `
+  ${s.slug} [${flags}]: ${s.contentSize} chars`;
+            if (s.contentSize === 0) {
+              responseText += " \u26A0\uFE0F EMPTY";
+            } else if (s.contentSize < 50 && s.scope === "global") {
+              responseText += " \u26A0\uFE0F very small";
+            }
+          }
+        }
         return {
           content: [
             {
               type: "text",
-              text: `Deployment ${deployment.version} to ${deployment.environment}: ${deployment.status}
-Started: ${deployment.started_at}${deployment.completed_at ? `
-Completed: ${deployment.completed_at}` : ""}`
+              text: responseText
             }
           ]
         };
       }
       case "kode_promote": {
         const status = await client.getDeploymentStatus(siteId);
+        if (!status.productionEnabled) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Cannot promote: Production is not enabled for this site.\n\nRun kode_production_enable first to activate the production environment."
+              }
+            ],
+            isError: true
+          };
+        }
         if (!status.canPromote) {
           return {
             content: [
@@ -740,12 +1043,46 @@ Status: ${deployment.status}`
           ]
         };
       }
+      case "kode_production_enable": {
+        const { productionDomain } = args;
+        const result = await client.setProductionEnabled(siteId, true, productionDomain);
+        let text = "Production environment enabled!\n\n";
+        if (result.productionDomain) {
+          text += `Domain: ${result.productionDomain}
+`;
+        }
+        text += "\nNext steps:\n";
+        text += "1. Deploy to staging: kode_deploy\n";
+        text += "2. Promote to production: kode_promote";
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      case "kode_production_disable": {
+        await client.setProductionEnabled(siteId, false);
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Production environment disabled.\n\nOnly staging is now active. Production domain requests will receive an empty script with a warning."
+            }
+          ]
+        };
+      }
       case "kode_status": {
         const status = await client.getDeploymentStatus(siteId);
         const config = getConfig();
         let text = `Site: ${config?.siteName || "Unknown"}
 
 `;
+        const productionEnabled = status.productionEnabled ?? false;
+        text += `PRODUCTION STATUS: ${productionEnabled ? "\u2713 Enabled" : "\u25CB Disabled (staging only)"}
+`;
+        if (productionEnabled && status.productionDomain) {
+          text += `  Domain: ${status.productionDomain}
+`;
+        }
+        text += "\n";
         text += `STAGING:
 `;
         if (status.staging.lastSuccessful) {
@@ -760,17 +1097,25 @@ Status: ${deployment.status}`
         text += `
 PRODUCTION:
 `;
-        if (status.production.lastSuccessful) {
+        if (!productionEnabled) {
+          text += `  (Disabled - use kode_production_enable to activate)
+`;
+        } else if (status.production.lastSuccessful) {
           text += `  Version: ${status.production.lastSuccessful.version}
 `;
           text += `  Deployed: ${status.production.lastSuccessful.completed_at}
 `;
         } else {
-          text += `  Not deployed
+          text += `  Enabled, not yet deployed
 `;
         }
-        text += `
+        if (productionEnabled) {
+          text += `
 Can promote staging to production: ${status.canPromote ? "Yes" : "No"}`;
+        } else {
+          text += `
+Enable production first (kode_production_enable) before promoting.`;
+        }
         return {
           content: [{ type: "text", text }]
         };
@@ -955,6 +1300,184 @@ Embed code:
           content: [{ type: "text", text }]
         };
       }
+      case "kode_analyze_script": {
+        const { slug, saveToScript } = args;
+        const scripts = await client.listScripts(siteId);
+        const script = scripts.find((s) => s.slug === slug || s.id === slug);
+        if (!script) {
+          return {
+            content: [{ type: "text", text: `Script "${slug}" not found` }],
+            isError: true
+          };
+        }
+        try {
+          const result = await client.analyzeScript(script.id, { saveToScript });
+          let text = `Script Analysis: ${script.name}
+
+`;
+          text += `Purpose: ${result.metadata.purpose || "(not detected)"}
+
+`;
+          if (result.metadata.triggers.length > 0) {
+            text += `Triggers:
+`;
+            for (const t of result.metadata.triggers) {
+              text += `  - ${t.event}${t.selector ? ` on ${t.selector}` : ""}
+`;
+            }
+            text += "\n";
+          }
+          if (result.metadata.domTargets.length > 0) {
+            text += `DOM Targets:
+`;
+            for (const d of result.metadata.domTargets) {
+              text += `  - ${d.selector} (${d.action})
+`;
+            }
+            text += "\n";
+          }
+          if (result.metadata.dependencies.length > 0) {
+            text += `Dependencies:
+`;
+            for (const dep of result.metadata.dependencies) {
+              text += `  - ${dep.name}${dep.required ? " (required)" : ""}
+`;
+            }
+            text += "\n";
+          }
+          text += `Flags:
+`;
+          text += `  - Modifies DOM: ${result.metadata.modifiesDom ? "Yes" : "No"}
+`;
+          text += `  - Event listeners: ${result.metadata.addsEventListeners ? "Yes" : "No"}
+`;
+          if (result.metadata.usesExternalApis) text += `  - Uses external APIs: Yes
+`;
+          if (result.metadata.usesLocalStorage) text += `  - Uses localStorage: Yes
+`;
+          if (result.metadata.usesCookies) text += `  - Uses cookies: Yes
+`;
+          if (result.warnings.length > 0) {
+            text += `
+Warnings:
+`;
+            for (const w of result.warnings) {
+              text += `  \u26A0\uFE0F ${w}
+`;
+            }
+          }
+          if (result.suggestions.length > 0) {
+            text += `
+Suggestions:
+`;
+            for (const s of result.suggestions) {
+              text += `  \u{1F4A1} ${s}
+`;
+            }
+          }
+          if (saveToScript) {
+            text += `
+\u2713 Metadata saved to script. Run kode_deploy to update CDN.`;
+          } else {
+            text += `
+Use saveToScript: true to save this metadata to the script.`;
+          }
+          return {
+            content: [{ type: "text", text }]
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          return {
+            content: [{ type: "text", text: `Failed to analyze script: ${message}` }],
+            isError: true
+          };
+        }
+      }
+      case "kode_get_script_metadata": {
+        const { slug } = args;
+        const scripts = await client.listScripts(siteId);
+        const script = scripts.find((s) => s.slug === slug || s.id === slug);
+        if (!script) {
+          return {
+            content: [{ type: "text", text: `Script "${slug}" not found` }],
+            isError: true
+          };
+        }
+        try {
+          const result = await client.getScriptMetadata(script.id);
+          if (!result.metadata) {
+            return {
+              content: [{
+                type: "text",
+                text: `Script "${script.name}" has no metadata.
+
+Use kode_analyze_script to generate metadata, or provide metadata when creating/updating the script.`
+              }]
+            };
+          }
+          let text = `Metadata for: ${script.name}
+
+`;
+          if (result.metadata.purpose) {
+            text += `Purpose: ${result.metadata.purpose}
+
+`;
+          }
+          if (result.aiSummary) {
+            text += `AI Summary: ${result.aiSummary}
+
+`;
+          }
+          if (result.metadata.triggers.length > 0) {
+            text += `Triggers:
+`;
+            for (const t of result.metadata.triggers) {
+              text += `  - ${t.event}${t.selector ? ` on ${t.selector}` : ""}
+`;
+            }
+            text += "\n";
+          }
+          if (result.metadata.domTargets.length > 0) {
+            text += `DOM Targets:
+`;
+            for (const d of result.metadata.domTargets) {
+              text += `  - ${d.selector} (${d.action})
+`;
+            }
+            text += "\n";
+          }
+          if (result.metadata.dependencies.length > 0) {
+            text += `Dependencies:
+`;
+            for (const dep of result.metadata.dependencies) {
+              text += `  - ${dep.name}${dep.required ? " (required)" : ""}
+`;
+            }
+            text += "\n";
+          }
+          text += `Flags:
+`;
+          text += `  - AI Generated: ${result.aiGenerated ? "Yes" : "No"}
+`;
+          text += `  - Modifies DOM: ${result.metadata.modifiesDom ? "Yes" : "No"}
+`;
+          text += `  - Event listeners: ${result.metadata.addsEventListeners ? "Yes" : "No"}
+`;
+          if (result.lastAnalyzed) {
+            text += `
+Last analyzed: ${result.lastAnalyzed}`;
+          }
+          return {
+            content: [{ type: "text", text }]
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          return {
+            content: [{ type: "text", text: `Failed to get metadata: ${message}` }],
+            isError: true
+          };
+        }
+      }
       case "kode_read_context": {
         const contextPath = getContextPath();
         if (!contextPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curenorway/kode-mcp",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "MCP server for Cure Kode - enables AI agents to manage Webflow scripts",
   "type": "module",
   "bin": {