@curenorway/kode-mcp 1.0.0 → 1.0.2

package/README.md

@@ -55,7 +55,7 @@ Run `kode init` in your project to create `.cure-kode/config.json`:
 ```bash
 export CURE_KODE_API_KEY="ck_..."
 export CURE_KODE_SITE_ID="your-site-uuid"
-export CURE_KODE_API_URL="https://cure-app-v2-production.up.railway.app"  # optional
+export CURE_KODE_API_URL="https://app.cure.no"  # optional
 ```
 
 ## Available Tools
@@ -109,10 +109,38 @@ Once configured, you can ask Claude:
 
 ## Security
 
-- API keys are stored locally in `.cure-kode/config.json` (git-ignored)
-- Keys are scoped per-site with specific permissions
-- All API calls are authenticated
+### API Key Authentication
+
+- **SHA256 Hashed Storage**: API keys are hashed before storage on the server
+- **Site-scoped**: Each API key is bound to a specific CDN site
+- **Permission-based**: Keys have granular permissions:
+  - `read` - List/view scripts and deployments
+  - `write` - Create and update scripts
+  - `deploy` - Deploy to staging/production
+  - `delete` - Delete scripts
+- **Expiration**: Keys can have optional expiration dates
+
+### Local Security
+
+- API keys stored in `.cure-kode/config.json` (auto-gitignored)
 - Never commit API keys to version control
+- Keys prefixed with `ck_` for easy identification
+
+### Network Security
+
+- All API calls use HTTPS
+- **SSRF Protection**: HTML fetch endpoints block:
+  - Private IP ranges (127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16)
+  - Localhost and internal hostnames
+  - Cloud metadata endpoints (169.254.169.254)
+- Only HTTP/HTTPS protocols allowed
+
+### Best Practices
+
+- Generate separate API keys for different environments/developers
+- Use read-only keys when full access isn't needed
+- Rotate keys periodically
+- Revoke keys when team members leave
 
 ## Troubleshooting
 

package/dist/index.js

@@ -115,7 +115,7 @@ var KodeApiClient = class {
 // src/config.ts
 import * as fs from "fs";
 import * as path from "path";
-var DEFAULT_API_URL = "https://cure-app-v2-production.up.railway.app";
+var DEFAULT_API_URL = "https://app.cure.no";
 var CONFIG_DIR = ".cure-kode";
 var CONFIG_FILE = "config.json";
 function findProjectRoot(startDir = process.cwd()) {
@@ -171,10 +171,30 @@ function getScriptsDir() {
   if (!projectRoot || !projectConfig) return void 0;
   return path.join(projectRoot, projectConfig.scriptsDir);
 }
+function getContextPath() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return void 0;
+  return path.join(projectRoot, CONFIG_DIR, "context.md");
+}
+function getPagesDir() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return void 0;
+  return path.join(projectRoot, CONFIG_DIR, "pages");
+}
 
 // src/index.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+function urlToSlug(url) {
+  try {
+    const parsed = new URL(url);
+    let slug = parsed.pathname.replace(/^\//, "").replace(/\//g, "--") || "home";
+    slug = slug.replace(/--$/, "");
+    return slug.replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
+  } catch {
+    return "page";
+  }
+}
 var server = new Server(
   {
     name: "cure-kode",
@@ -365,6 +385,123 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {},
           required: []
         }
+      },
+      {
+        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.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "kode_update_context",
+        description: "Update the project context file. Use this to add notes, record session history, or update script purposes. Call this after making changes to persist your discoveries.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            addNote: {
+              type: "string",
+              description: "Add a note to the notes section (e.g., HTML structure discovery, third-party integration found)"
+            },
+            addSession: {
+              type: "object",
+              description: "Record a work session",
+              properties: {
+                task: {
+                  type: "string",
+                  description: "What task was performed"
+                },
+                changes: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "List of changes made"
+                }
+              },
+              required: ["task", "changes"]
+            },
+            updateScriptPurpose: {
+              type: "object",
+              description: "Update a script's purpose description",
+              properties: {
+                slug: {
+                  type: "string",
+                  description: "Script slug"
+                },
+                purpose: {
+                  type: "string",
+                  description: "Purpose description"
+                }
+              },
+              required: ["slug", "purpose"]
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "kode_fetch_html_smart",
+        description: "Fetch and analyze a webpage with smart CMS truncation. Shows template pattern instead of all CMS items. Better for understanding page structure.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: 'Full URL to analyze (e.g., "https://example.com")'
+            },
+            truncateCms: {
+              type: "boolean",
+              description: "Truncate CMS collections to show template pattern only. Default: true"
+            },
+            includeHtml: {
+              type: "boolean",
+              description: "Include HTML preview in response. Default: false (returns structure only)"
+            }
+          },
+          required: ["url"]
+        }
+      },
+      {
+        name: "kode_refresh_page",
+        description: 'Fetch webpage and extract FULL structure with CSS selectors. WHEN TO USE: (1) User says "HTML changed" or "refresh", (2) Cache is >7 days old, (3) First time analyzing a page, (4) Before writing code that targets elements. Returns: sections, CTAs, forms, CMS, headings, scripts, images, embeds, interactions - all with CSS selectors for development.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: 'Full URL to analyze and cache (e.g., "https://example.com/about")'
+            },
+            force: {
+              type: "boolean",
+              description: "Force refresh even if cached. Use when user says HTML has changed."
+            }
+          },
+          required: ["url"]
+        }
+      },
+      {
+        name: "kode_get_page_context",
+        description: "Get FULL page context with CSS selectors for development. Returns: sections with selectors, navigation, CTAs with classes, forms with field selectors, CMS patterns, headings, scripts inventory, images, embeds, and Webflow interactions. Warns if cache is >7 days old. Use kode_refresh_page if HTML has changed or cache is stale.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            urlOrSlug: {
+              type: "string",
+              description: 'URL or slug of the cached page (e.g., "https://example.com/about" or "about")'
+            }
+          },
+          required: ["urlOrSlug"]
+        }
+      },
+      {
+        name: "kode_list_pages_context",
+        description: "List all cached page contexts. Shows which pages have been analyzed and when. Use kode_refresh_page to add new pages.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
       }
     ]
   };
@@ -665,6 +802,630 @@ Embed code:
           content: [{ type: "text", text }]
         };
       }
+      case "kode_read_context": {
+        const contextPath = getContextPath();
+        if (!contextPath) {
+          return {
+            content: [{ type: "text", text: 'Not in a Cure Kode project. Run "kode init" first.' }],
+            isError: true
+          };
+        }
+        if (!fs2.existsSync(contextPath)) {
+          return {
+            content: [{ type: "text", text: 'No context file found. Run "kode context --refresh" to create one.' }],
+            isError: true
+          };
+        }
+        const content = fs2.readFileSync(contextPath, "utf-8");
+        return {
+          content: [{ type: "text", text: content }]
+        };
+      }
+      case "kode_update_context": {
+        const contextPath = getContextPath();
+        if (!contextPath) {
+          return {
+            content: [{ type: "text", text: 'Not in a Cure Kode project. Run "kode init" first.' }],
+            isError: true
+          };
+        }
+        if (!fs2.existsSync(contextPath)) {
+          return {
+            content: [{ type: "text", text: 'No context file found. Run "kode context --refresh" to create one.' }],
+            isError: true
+          };
+        }
+        const { addNote, addSession, updateScriptPurpose } = args;
+        let content = fs2.readFileSync(contextPath, "utf-8");
+        const updates = [];
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        content = content.replace(
+          /> Last updated: .+$/m,
+          `> Last updated: ${timestamp}`
+        );
+        content = content.replace(
+          /> Updated by: .+$/m,
+          "> Updated by: Claude (AI Agent)"
+        );
+        if (addNote) {
+          const notesMatch = content.match(/## Notes\n\n((?:- .+\n?)*)/m);
+          if (notesMatch) {
+            const existingNotes = notesMatch[1];
+            const cleanedNotes = existingNotes.split("\n").filter((line) => line && !line.includes("(HTML structure") && !line.includes("(Third-party") && !line.includes("(Known issues")).join("\n");
+            const newNotes = cleanedNotes ? `${cleanedNotes}
+- ${addNote}
+` : `- ${addNote}
+`;
+            content = content.replace(
+              /## Notes\n\n(?:- .+\n?)*/m,
+              `## Notes
+
+${newNotes}`
+            );
+            updates.push(`Added note: "${addNote}"`);
+          }
+        }
+        if (addSession) {
+          const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          const sessionMd = `### ${date} - Claude
+**Task**: ${addSession.task}
+**Changes**:
+${addSession.changes.map((c) => `- ${c}`).join("\n")}
+
+`;
+          const sessionsMatch = content.match(/## Sessions\n\n/);
+          if (sessionsMatch) {
+            content = content.replace(
+              /## Sessions\n\n/m,
+              `## Sessions
+
+${sessionMd}`
+            );
+            content = content.replace(/\(No sessions recorded yet\)\n?/m, "");
+            updates.push(`Added session: "${addSession.task}"`);
+          }
+        }
+        if (updateScriptPurpose) {
+          const { slug, purpose } = updateScriptPurpose;
+          const rowRegex = new RegExp(`\\| ${slug} \\| (\\w+) \\| ([\\w-]+) \\| [^|]* \\|`, "m");
+          const match = content.match(rowRegex);
+          if (match) {
+            content = content.replace(
+              rowRegex,
+              `| ${slug} | ${match[1]} | ${match[2]} | ${purpose} |`
+            );
+            updates.push(`Updated purpose for "${slug}": "${purpose}"`);
+          }
+        }
+        fs2.writeFileSync(contextPath, content, "utf-8");
+        return {
+          content: [
+            {
+              type: "text",
+              text: updates.length > 0 ? `Context updated:
+${updates.map((u) => `- ${u}`).join("\n")}` : "No updates applied"
+            }
+          ]
+        };
+      }
+      case "kode_fetch_html_smart": {
+        const { url, truncateCms = true, includeHtml = false } = args;
+        const config = getConfig();
+        if (!config) {
+          return {
+            content: [{ type: "text", text: "Cure Kode not configured" }],
+            isError: true
+          };
+        }
+        const response = await fetch(`${config.apiUrl}/api/cdn/fetch-html`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": config.apiKey
+          },
+          body: JSON.stringify({ url, truncateCms })
+        });
+        if (!response.ok) {
+          return {
+            content: [{ type: "text", text: `Failed to fetch HTML: ${response.statusText}` }],
+            isError: true
+          };
+        }
+        const result = await response.json();
+        let text = `URL: ${result.url}
+Title: ${result.title || "(no title)"}
+
+`;
+        text += `Scripts (${result.stats.totalScripts} total):
+`;
+        if (result.scripts.webflow.length > 0) {
+          text += `  Webflow: ${result.scripts.webflow.length}
+`;
+        }
+        if (result.scripts.cureKode.length > 0) {
+          text += `  Cure Kode: ${result.scripts.cureKode.length}
+`;
+        }
+        if (result.scripts.thirdParty.length > 0) {
+          text += `  Third-party: ${result.scripts.thirdParty.length}
+`;
+          for (const script of result.scripts.thirdParty.slice(0, 5)) {
+            text += `    - ${script.type || script.src || "(inline)"}
+`;
+          }
+          if (result.scripts.thirdParty.length > 5) {
+            text += `    ... and ${result.scripts.thirdParty.length - 5} more
+`;
+          }
+        }
+        if (result.scripts.custom.length > 0) {
+          text += `  Custom: ${result.scripts.custom.length}
+`;
+        }
+        text += "\n";
+        text += `Styles: ${result.stats.totalStyles}
+
+`;
+        if (result.detectedComponents.length > 0) {
+          text += `Webflow Components:
+`;
+          for (const comp of result.detectedComponents) {
+            text += `  - ${comp}
+`;
+          }
+          text += "\n";
+        }
+        if (result.cmsCollections && result.cmsCollections.length > 0) {
+          text += `CMS Collections (truncated):
+`;
+          for (const collection of result.cmsCollections) {
+            text += `  - ${collection.selector}: ${collection.itemCount} items
+`;
+          }
+          text += "\n";
+        }
+        if (includeHtml && result.htmlPreview) {
+          text += `HTML Preview (first 5000 chars):
+${result.htmlPreview.slice(0, 5e3)}`;
+          if (result.htmlPreview.length > 5e3) {
+            text += "\n... (truncated)";
+          }
+        }
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      case "kode_refresh_page": {
+        const { url, force = false } = args;
+        const pagesDir = getPagesDir();
+        if (!pagesDir) {
+          return {
+            content: [{ type: "text", text: 'Not in a Cure Kode project. Run "kode init" first.' }],
+            isError: true
+          };
+        }
+        const slug = urlToSlug(url);
+        const cachePath = path2.join(pagesDir, `${slug}.json`);
+        if (!force && fs2.existsSync(cachePath)) {
+          try {
+            const cached = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
+            return {
+              content: [{
+                type: "text",
+                text: `Using cached version from ${cached.extractedAt}
+Slug: ${slug}
+Use force: true to refresh.
+
+Page: ${cached.title || url}
+Sections: ${cached.sections.length}
+CTAs: ${cached.ctas.length}
+Forms: ${cached.forms.length}
+CMS Collections: ${cached.cmsPatterns.length}`
+              }]
+            };
+          } catch {
+          }
+        }
+        const config = getConfig();
+        if (!config) {
+          return {
+            content: [{ type: "text", text: "Cure Kode not configured" }],
+            isError: true
+          };
+        }
+        const response = await fetch(`${config.apiUrl}/api/cdn/page-context`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": config.apiKey
+          },
+          body: JSON.stringify({ url })
+        });
+        if (!response.ok) {
+          return {
+            content: [{ type: "text", text: `Failed to fetch page: ${response.statusText}` }],
+            isError: true
+          };
+        }
+        const structure = await response.json();
+        if (!fs2.existsSync(pagesDir)) {
+          fs2.mkdirSync(pagesDir, { recursive: true });
+        }
+        fs2.writeFileSync(cachePath, JSON.stringify(structure, null, 2), "utf-8");
+        const contextPath = getContextPath();
+        if (contextPath && fs2.existsSync(contextPath)) {
+        }
+        let text = `Page cached: ${slug}
+Path: ${cachePath}
+
+`;
+        text += `Title: ${structure.title || "(no title)"}
+`;
+        text += `URL: ${structure.url}
+
+`;
+        text += `Sections (${structure.sections.length}):
+`;
+        for (const s of structure.sections.slice(0, 6)) {
+          const name2 = s.heading || s.id || s.className?.split(" ")[0] || "section";
+          const flags = [s.hasCms && "CMS", s.hasForm && "Form"].filter(Boolean).join(", ");
+          text += `  - ${name2}${flags ? ` [${flags}]` : ""}
+`;
+        }
+        if (structure.sections.length > 6) {
+          text += `  ... and ${structure.sections.length - 6} more
+`;
+        }
+        if (structure.ctas.length > 0) {
+          text += `
+CTAs (${structure.ctas.length}):
+`;
+          for (const c of structure.ctas.slice(0, 4)) {
+            text += `  - "${c.text}"
+`;
+          }
+          if (structure.ctas.length > 4) {
+            text += `  ... and ${structure.ctas.length - 4} more
+`;
+          }
+        }
+        if (structure.forms.length > 0) {
+          text += `
+Forms (${structure.forms.length}):
+`;
+          for (const f of structure.forms) {
+            text += `  - ${f.name || "form"}: ${f.fields.length} fields
+`;
+          }
+        }
+        if (structure.cmsPatterns.length > 0) {
+          text += `
+CMS Collections (${structure.cmsPatterns.length}):
+`;
+          for (const c of structure.cmsPatterns) {
+            text += `  - ${c.containerSelector}: ${c.itemCount} items
+`;
+          }
+        }
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      case "kode_get_page_context": {
+        const { urlOrSlug } = args;
+        const pagesDir = getPagesDir();
+        if (!pagesDir) {
+          return {
+            content: [{ type: "text", text: 'Not in a Cure Kode project. Run "kode init" first.' }],
+            isError: true
+          };
+        }
+        const slug = urlOrSlug.startsWith("http") ? urlToSlug(urlOrSlug) : urlOrSlug;
+        const cachePath = path2.join(pagesDir, `${slug}.json`);
+        if (!fs2.existsSync(cachePath)) {
+          return {
+            content: [{
+              type: "text",
+              text: `Page not found: ${slug}
+
+Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a new page.`
+            }],
+            isError: true
+          };
+        }
+        const context = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
+        const cacheAge = Date.now() - new Date(context.extractedAt).getTime();
+        const cacheAgeDays = Math.floor(cacheAge / (1e3 * 60 * 60 * 24));
+        const isStale = cacheAgeDays > 7;
+        let text = `# ${context.title || context.url}
+
+`;
+        text += `URL: ${context.url}
+`;
+        text += `Cached: ${context.extractedAt}${isStale ? ` \u26A0\uFE0F (${cacheAgeDays} days old - consider refreshing with kode_refresh_page)` : ""}
+`;
+        if (context.stats) {
+          text += `Stats: ${context.stats.sectionCount} sections, ${context.stats.ctaCount} CTAs, ${context.stats.formCount} forms, ${context.stats.linkCount} links, ${context.stats.gridCount || 0} grids, ${context.stats.imageCount} images, ${context.stats.interactiveCount || 0} interactive
+`;
+        }
+        text += "\n";
+        if (context.sections && context.sections.length > 0) {
+          text += `## Sections (${context.sections.length})
+
+`;
+          for (const s of context.sections) {
+            const flags = [s.hasCms && "CMS", s.hasForm && "Form", s.webflowInteraction && "Interaction"].filter(Boolean).join(", ");
+            text += `### ${s.heading || s.selector}
+`;
+            text += `Selector: \`${s.selector}\`
+`;
+            if (flags) text += `Flags: [${flags}]
+`;
+            if (s.children) {
+              const c = s.children;
+              const childInfo = [
+                c.divs && `${c.divs} divs`,
+                c.links && `${c.links} links`,
+                c.buttons && `${c.buttons} buttons`,
+                c.images && `${c.images} images`
+              ].filter(Boolean).join(", ");
+              if (childInfo) text += `Contains: ${childInfo}
+`;
+            }
+            if (s.textSample) text += `Preview: ${s.textSample.slice(0, 120)}...
+`;
+            text += "\n";
+          }
+        }
+        if (context.navigation && context.navigation.length > 0) {
+          text += `## Navigation
+
+`;
+          for (const n of context.navigation) {
+            text += `### ${n.type} nav
+`;
+            text += `Selector: \`${n.selector}\`
+`;
+            for (const item of n.items.slice(0, 10)) {
+              text += `  - "${item.text}" \`${item.selector}\`${item.href ? ` \u2192 ${item.href}` : ""}
+`;
+            }
+            text += "\n";
+          }
+        }
+        if (context.ctas && context.ctas.length > 0) {
+          text += `## CTAs (${context.ctas.length})
+
+`;
+          for (const c of context.ctas) {
+            text += `- "${c.text}" \`${c.selector}\`${c.href ? ` \u2192 ${c.href}` : ""}
+`;
+            if (c.classes && c.classes.length > 0) {
+              text += `  Classes: ${c.classes.join(", ")}
+`;
+            }
+          }
+          text += "\n";
+        }
+        if (context.forms && context.forms.length > 0) {
+          text += `## Forms (${context.forms.length})
+
+`;
+          for (const f of context.forms) {
+            text += `### ${f.name || f.id || "Form"}
+`;
+            text += `Selector: \`${f.selector}\`
+`;
+            if (f.action) text += `Action: ${f.action} (${f.method || "GET"})
+`;
+            text += `Fields:
+`;
+            for (const field of f.fields) {
+              const req = field.required ? " *" : "";
+              text += `  - ${field.label || field.name || field.type}${req}: \`${field.selector}\`
+`;
+            }
+            if (f.submitButton) {
+              text += `Submit: "${f.submitButton.text}" \`${f.submitButton.selector}\`
+`;
+            }
+            text += "\n";
+          }
+        }
+        if (context.cmsPatterns && context.cmsPatterns.length > 0) {
+          text += `## CMS Collections (${context.cmsPatterns.length})
+
+`;
+          for (const c of context.cmsPatterns) {
+            text += `Container: \`${c.containerSelector}\` (${c.itemCount} items)
+`;
+            text += `Item: \`${c.itemSelector}\`
+`;
+            if (c.templateFields && c.templateFields.length > 0) {
+              text += `Template fields: ${c.templateFields.join(", ")}
+`;
+            }
+            text += "\n";
+          }
+        }
+        if (context.headings && context.headings.length > 0) {
+          text += `## Headings (${context.headings.length})
+
+`;
+          for (const h of context.headings.slice(0, 15)) {
+            const indent = "  ".repeat(h.level - 1);
+            text += `${indent}H${h.level}: "${h.text}" \`${h.selector}\`
+`;
+          }
+          if (context.headings.length > 15) {
+            text += `... and ${context.headings.length - 15} more
+`;
+          }
+          text += "\n";
+        }
+        if (context.scripts && context.scripts.length > 0) {
+          text += `## Scripts (${context.scripts.length})
+
+`;
+          const byCategory = {};
+          for (const s of context.scripts) {
+            byCategory[s.category] = byCategory[s.category] || [];
+            byCategory[s.category].push(s);
+          }
+          for (const [cat, scripts] of Object.entries(byCategory)) {
+            text += `### ${cat} (${scripts.length})
+`;
+            for (const s of scripts.slice(0, 5)) {
+              if (s.src) {
+                text += `  - ${s.src}${s.async ? " (async)" : ""}${s.defer ? " (defer)" : ""}
+`;
+              } else {
+                text += `  - [inline ${s.type}] ${s.contentPreview?.slice(0, 50)}...
+`;
+              }
+            }
+            if (scripts.length > 5) text += `  ... and ${scripts.length - 5} more
+`;
+          }
+          text += "\n";
+        }
+        if (context.images && context.images.length > 0) {
+          text += `## Images (${context.images.length})
+
+`;
+          for (const img of context.images.slice(0, 10)) {
+            const dims = img.dimensions ? ` (${img.dimensions.width}\xD7${img.dimensions.height})` : "";
+            text += `- "${img.alt || "no alt"}" \`${img.selector}\`${dims}
+`;
+          }
+          if (context.images.length > 10) {
+            text += `... and ${context.images.length - 10} more
+`;
+          }
+          text += "\n";
+        }
+        if (context.webflowInteractions && context.webflowInteractions.length > 0) {
+          text += `## Webflow Interactions (${context.webflowInteractions.length})
+
+`;
+          for (const i of context.webflowInteractions) {
+            text += `- \`${i.triggerSelector}\`${i.type ? ` (${i.type})` : ""}
+`;
+          }
+          text += "\n";
+        }
+        if (context.embeds && context.embeds.length > 0) {
+          text += `## Custom Embeds (${context.embeds.length})
+
+`;
+          for (const e of context.embeds) {
+            text += `- ${e.type} embed \`${e.selector}\` in ${e.location}
+`;
+          }
+          text += "\n";
+        }
+        if (context.grids && context.grids.length > 0) {
+          text += `## Grids/Lists (${context.grids.length})
+
+`;
+          for (const g of context.grids) {
+            text += `- \`${g.selector}\` (${g.gridType}, ${g.itemCount} items)
+`;
+            text += `  Item: \`${g.itemSelector}\`
+`;
+          }
+          text += "\n";
+        }
+        if (context.interactiveElements && context.interactiveElements.length > 0) {
+          text += `## Interactive Elements (${context.interactiveElements.length})
+
+`;
+          for (const el of context.interactiveElements) {
+            text += `- ${el.type}: \`${el.selector}\`${el.trigger ? ` [${el.trigger}]` : ""}
+`;
+          }
+          text += "\n";
+        }
+        if (context.links && context.links.length > 0) {
+          const internal = context.links.filter((l) => !l.isExternal).length;
+          const external = context.links.filter((l) => l.isExternal).length;
+          text += `## Links (${context.links.length})
+
+`;
+          text += `Internal: ${internal}, External: ${external}
+
+`;
+        }
+        if (context.notes && context.notes.length > 0) {
+          text += `## Notes
+
+`;
+          for (const note of context.notes) {
+            text += `- ${note}
+`;
+          }
+        }
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      case "kode_list_pages_context": {
+        const pagesDir = getPagesDir();
+        if (!pagesDir) {
+          return {
+            content: [{ type: "text", text: 'Not in a Cure Kode project. Run "kode init" first.' }],
+            isError: true
+          };
+        }
+        if (!fs2.existsSync(pagesDir)) {
+          return {
+            content: [{
+              type: "text",
+              text: "No cached pages.\n\nUse kode_refresh_page to analyze and cache a page's structure."
+            }]
+          };
+        }
+        const files = fs2.readdirSync(pagesDir).filter((f) => f.endsWith(".json"));
+        if (files.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: "No cached pages.\n\nUse kode_refresh_page to analyze and cache a page's structure."
+            }]
+          };
+        }
+        let text = `Cached Pages (${files.length})
+
+`;
+        for (const file of files) {
+          const slug = file.replace(".json", "");
+          try {
+            const context = JSON.parse(fs2.readFileSync(path2.join(pagesDir, file), "utf-8"));
+            const urlPath = new URL(context.url).pathname;
+            text += `${urlPath} [${slug}]
+`;
+            if (context.title) {
+              text += `  "${context.title}"
+`;
+            }
+            text += `  Sections: ${context.sections.length}, CTAs: ${context.ctas.length}, Forms: ${context.forms.length}, CMS: ${context.cmsPatterns.length}
+`;
+            text += `  Cached: ${context.extractedAt}
+
+`;
+          } catch {
+            text += `${slug} (invalid cache file)
+
+`;
+          }
+        }
+        text += `Use kode_get_page_context to see full details for a page.
+`;
+        text += `Use kode_refresh_page to update or add pages.`;
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
       default:
         return {
           content: [{ type: "text", text: `Unknown tool: ${name}` }],

package/package.json

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