@curenorway/kode-cli 1.0.0 → 1.0.2

package/dist/{chunk-NWXEBN2N.js → chunk-LYIXUQOG.js}

@@ -5,7 +5,7 @@ import { join, dirname } from "path";
 var globalConfig = new Conf({
   projectName: "cure-kode",
   defaults: {
-    apiUrl: "https://cure-app-v2-production.up.railway.app"
+    apiUrl: "https://app.cure.no"
   }
 });
 var PROJECT_CONFIG_DIR = ".cure-kode";
@@ -54,12 +54,414 @@ function getScriptsDir(projectRoot, projectConfig) {
   return join(projectRoot, projectConfig?.scriptsDir || "scripts");
 }
 
+// src/lib/context.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var CONTEXT_FILE = "context.md";
+var PROJECT_CONFIG_DIR2 = ".cure-kode";
+function getContextPath(projectRoot) {
+  return join2(projectRoot, PROJECT_CONFIG_DIR2, CONTEXT_FILE);
+}
+function parseContext(content) {
+  const context = {
+    site: { name: "", slug: "" },
+    scripts: [],
+    pages: [],
+    notes: [],
+    sessions: [],
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedBy: "unknown"
+  };
+  const titleMatch = content.match(/^# Context: (.+)$/m);
+  if (titleMatch) {
+    context.site.name = titleMatch[1];
+  }
+  const updatedMatch = content.match(/> Last updated: (.+)$/m);
+  if (updatedMatch) {
+    context.lastUpdated = updatedMatch[1];
+  }
+  const byMatch = content.match(/> Updated by: (.+)$/m);
+  if (byMatch) {
+    context.updatedBy = byMatch[1];
+  }
+  const domainMatch = content.match(/- \*\*Domain\*\*: (.+)$/m);
+  if (domainMatch) {
+    context.site.domain = domainMatch[1];
+  }
+  const stagingMatch = content.match(/- \*\*Staging\*\*: (.+)$/m);
+  if (stagingMatch) {
+    context.site.stagingDomain = stagingMatch[1];
+  }
+  const scriptsTableMatch = content.match(/## Scripts\n\n\|[^\n]+\n\|[-|\s]+\n((?:\|[^\n]+\n?)+)/m);
+  if (scriptsTableMatch) {
+    const rows = scriptsTableMatch[1].trim().split("\n");
+    for (const row of rows) {
+      const cols = row.split("|").map((c) => c.trim()).filter(Boolean);
+      if (cols.length >= 3) {
+        context.scripts.push({
+          slug: cols[0],
+          type: cols[1].toLowerCase() === "css" ? "css" : "javascript",
+          scope: cols[2].toLowerCase() === "page-specific" ? "page-specific" : "global",
+          purpose: cols[3] || void 0
+        });
+      }
+    }
+  }
+  const notesMatch = content.match(/## Notes\n\n((?:- .+\n?)+)/m);
+  if (notesMatch) {
+    context.notes = notesMatch[1].trim().split("\n").map((line) => line.replace(/^- /, "").trim()).filter(Boolean);
+  }
+  const sessionsMatch = content.match(/## Sessions\n\n([\s\S]+?)(?=\n##|$)/m);
+  if (sessionsMatch) {
+    const sessionBlocks = sessionsMatch[1].split(/\n### /).filter(Boolean);
+    for (const block of sessionBlocks) {
+      const headerMatch = block.match(/^(.+?) - (.+)$/m);
+      const taskMatch = block.match(/\*\*Task\*\*: (.+)$/m);
+      const changesMatch = block.match(/\*\*Changes\*\*:\n((?:- .+\n?)+)/m);
+      if (headerMatch) {
+        const session = {
+          date: headerMatch[1].replace("### ", ""),
+          agent: headerMatch[2],
+          task: taskMatch?.[1] || "",
+          changes: []
+        };
+        if (changesMatch) {
+          session.changes = changesMatch[1].trim().split("\n").map((line) => line.replace(/^- /, "").trim()).filter(Boolean);
+        }
+        context.sessions.push(session);
+      }
+    }
+  }
+  return context;
+}
+function serializeContext(context) {
+  let md = `# Context: ${context.site.name}
+
+`;
+  md += `> Last updated: ${context.lastUpdated}
+`;
+  md += `> Updated by: ${context.updatedBy}
+
+`;
+  if (context.site.domain || context.site.stagingDomain) {
+    md += `## Site
+
+`;
+    if (context.site.domain) {
+      md += `- **Domain**: ${context.site.domain}
+`;
+    }
+    if (context.site.stagingDomain) {
+      md += `- **Staging**: ${context.site.stagingDomain}
+`;
+    }
+    md += `
+`;
+  }
+  md += `## Scripts
+
+`;
+  md += `| Script | Type | Scope | Purpose |
+`;
+  md += `|--------|------|-------|--------|
+`;
+  for (const script of context.scripts) {
+    const purpose = script.purpose || "(add purpose)";
+    md += `| ${script.slug} | ${script.type === "css" ? "CSS" : "JS"} | ${script.scope} | ${purpose} |
+`;
+  }
+  md += `
+`;
+  if (context.pages && context.pages.length > 0) {
+    md += `## Pages
+
+`;
+    md += `> Cached HTML structure. Use \`kode html <url> --save\` to refresh.
+
+`;
+    for (const page of context.pages) {
+      const path = new URL(page.url).pathname;
+      md += `### ${path}
+`;
+      if (page.title) {
+        md += `"${page.title}"
+`;
+      }
+      md += `
+`;
+      if (page.sections) {
+        md += `**Sections**: ${page.sections}
+`;
+      }
+      if (page.ctas) {
+        md += `**CTAs**: ${page.ctas}
+`;
+      }
+      if (page.forms) {
+        md += `**Forms**: ${page.forms}
+`;
+      }
+      if (page.cms) {
+        md += `**CMS**: ${page.cms}
+`;
+      }
+      if (page.notes && page.notes.length > 0) {
+        md += `
+**Notes**:
+`;
+        for (const note of page.notes) {
+          md += `- ${note}
+`;
+        }
+      }
+      md += `
+`;
+    }
+  }
+  md += `## Notes
+
+`;
+  if (context.notes.length > 0) {
+    for (const note of context.notes) {
+      md += `- ${note}
+`;
+    }
+  } else {
+    md += `- (HTML structure discoveries go here)
+`;
+    md += `- (Third-party integrations detected)
+`;
+    md += `- (Known issues/workarounds)
+`;
+  }
+  md += `
+`;
+  md += `## Sessions
+
+`;
+  if (context.sessions.length > 0) {
+    for (const session of context.sessions) {
+      md += `### ${session.date} - ${session.agent}
+`;
+      md += `**Task**: ${session.task}
+`;
+      md += `**Changes**:
+`;
+      for (const change of session.changes) {
+        md += `- ${change}
+`;
+      }
+      md += `
+`;
+    }
+  } else {
+    md += `(No sessions recorded yet)
+`;
+  }
+  return md;
+}
+function readContext(projectRoot) {
+  const contextPath = getContextPath(projectRoot);
+  if (!existsSync2(contextPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(contextPath, "utf-8");
+    return parseContext(content);
+  } catch {
+    return null;
+  }
+}
+function writeContext(projectRoot, context) {
+  const contextPath = getContextPath(projectRoot);
+  const content = serializeContext(context);
+  writeFileSync2(contextPath, content, "utf-8");
+}
+function appendNote(projectRoot, note, agent = "CLI") {
+  const context = readContext(projectRoot);
+  if (!context) {
+    throw new Error('No context file found. Run "kode init" first.');
+  }
+  context.notes.push(note);
+  context.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  context.updatedBy = agent;
+  writeContext(projectRoot, context);
+}
+function addSession(projectRoot, session, agent = "Claude") {
+  const context = readContext(projectRoot);
+  if (!context) {
+    throw new Error('No context file found. Run "kode init" first.');
+  }
+  context.sessions.unshift({
+    ...session,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  });
+  context.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  context.updatedBy = agent;
+  writeContext(projectRoot, context);
+}
+function updateScriptPurpose(projectRoot, slug, purpose, agent = "Claude") {
+  const context = readContext(projectRoot);
+  if (!context) {
+    throw new Error('No context file found. Run "kode init" first.');
+  }
+  const script = context.scripts.find((s) => s.slug === slug);
+  if (script) {
+    script.purpose = purpose;
+  }
+  context.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  context.updatedBy = agent;
+  writeContext(projectRoot, context);
+}
+function generateInitialContext(config, scripts, site) {
+  const context = {
+    site: {
+      name: config.siteName,
+      slug: config.siteSlug,
+      domain: site?.domain || void 0,
+      stagingDomain: site?.staging_domain || void 0
+    },
+    scripts: scripts.map((s) => ({
+      slug: s.slug,
+      type: s.type,
+      scope: s.scope
+    })),
+    pages: [],
+    notes: [],
+    sessions: [],
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedBy: "kode init"
+  };
+  return serializeContext(context);
+}
+function upsertPage(projectRoot, page, agent = "kode html") {
+  const context = readContext(projectRoot);
+  if (!context) {
+    throw new Error('No context file found. Run "kode init" first.');
+  }
+  if (!context.pages) {
+    context.pages = [];
+  }
+  const existingIndex = context.pages.findIndex(
+    (p) => p.url === page.url || p.slug === page.slug
+  );
+  if (existingIndex >= 0) {
+    const existingNotes = context.pages[existingIndex].notes;
+    context.pages[existingIndex] = {
+      ...page,
+      notes: page.notes || existingNotes
+    };
+  } else {
+    context.pages.push(page);
+  }
+  context.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  context.updatedBy = agent;
+  writeContext(projectRoot, context);
+}
+function generateClaudeMd(siteName, scriptsDir = "scripts") {
+  return `# Cure Kode Project: ${siteName}
+
+> AI Agent Instructions for Webflow Script Management
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| \`kode pull\` | Download scripts from remote |
+| \`kode push\` | Upload local scripts |
+| \`kode watch\` | Auto-sync on file changes |
+| \`kode deploy --env staging\` | Deploy to staging |
+| \`kode deploy --env production\` | Deploy to production |
+| \`kode status\` | Show sync status |
+| \`kode html <url>\` | Analyze page HTML |
+| \`kode html <url> --save\` | Analyze and cache page structure |
+| \`kode pages\` | List cached page contexts |
+| \`kode context\` | View/edit project context |
+
+## Project Structure
+
+\`\`\`
+.cure-kode/
+\u251C\u2500\u2500 config.json      # Site configuration (contains API key - DO NOT COMMIT)
+\u251C\u2500\u2500 context.md       # Dynamic context - READ and WRITE this file
+\u251C\u2500\u2500 pages/           # Cached page structure (JSON files)
+\u251C\u2500\u2500 .gitignore
+\u2514\u2500\u2500 scripts.json     # Script metadata cache
+${scriptsDir}/
+\u2514\u2500\u2500 (your scripts)
+\`\`\`
+
+## Dynamic Context
+
+**IMPORTANT**: Read \`.cure-kode/context.md\` before starting work.
+
+This file contains:
+- Current scripts and their purposes
+- **Cached page structures** (sections, CTAs, forms, CMS patterns)
+- Site-specific notes and discoveries
+- Session history from previous AI work
+
+**Update it after your work session** with:
+- What you changed
+- Any HTML/CSS patterns you discovered
+- Notes for future sessions
+
+## HTML Context
+
+When working on a specific page:
+1. Use \`kode html <url> --save\` to cache the page structure
+2. The structure is saved to \`.cure-kode/pages/\` and summarized in context.md
+3. If the user says HTML has changed, refresh with \`--force\`
+
+Page context includes:
+- **Sections**: Main content areas (hero, features, footer, etc.)
+- **CTAs**: Buttons and prominent links with their text
+- **Forms**: Form fields, labels, and submit buttons
+- **CMS**: Collection patterns with item counts
+
+## Workflow
+
+1. \`kode pull\` to get latest scripts
+2. Read \`.cure-kode/context.md\` for project state
+3. If working on specific page: \`kode html <url> --save\`
+4. Make changes to scripts in \`${scriptsDir}/\`
+5. \`kode push\` to upload
+6. \`kode deploy --env staging\` to test
+7. Update context.md with session notes
+8. \`kode deploy --env production\` when ready
+
+## Best Practices
+
+1. **Always deploy to staging first** - Test before production
+2. **Use page-specific scripts** - Don't pollute global scope
+3. **Document your changes** - Update context.md
+4. **Cache page HTML** - Use \`kode html <url> --save\` to understand structure
+
+## MCP Tools
+
+If using the Kode MCP server, these tools are available:
+- \`kode_list_scripts\` - List all scripts
+- \`kode_get_script\` - Get script content
+- \`kode_create_script\` - Create new script
+- \`kode_update_script\` - Update script content
+- \`kode_deploy\` - Deploy to environment
+- \`kode_status\` - Get deployment status
+- \`kode_fetch_html\` - Analyze page HTML
+- \`kode_read_context\` - Read context file
+- \`kode_update_context\` - Update context file
+- \`kode_refresh_page\` - Fetch and cache page structure
+- \`kode_get_page_context\` - Get cached page structure
+- \`kode_list_pages\` - List cached pages
+`;
+}
+
 // src/commands/init.ts
 import chalk from "chalk";
 import ora from "ora";
-import { prompt } from "enquirer";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
+import enquirer from "enquirer";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var { prompt } = enquirer;
 async function initCommand(options) {
   const cwd = process.cwd();
   const existingRoot = findProjectRoot(cwd);
@@ -119,7 +521,7 @@ async function initCommand(options) {
   const spinner = ora("Validating configuration...").start();
   try {
     const response = await fetch(
-      `https://cure-app-v2-production.up.railway.app/api/cdn/sites/${answers.siteId}`,
+      `https://app.cure.no/api/cdn/sites/${answers.siteId}`,
       {
         headers: {
           "X-API-Key": answers.apiKey
@@ -142,21 +544,102 @@ async function initCommand(options) {
       environment: answers.environment
     };
     saveProjectConfig(config, cwd);
-    const scriptsPath = join2(cwd, answers.scriptsDir);
-    if (!existsSync2(scriptsPath)) {
+    const scriptsPath = join3(cwd, answers.scriptsDir);
+    if (!existsSync3(scriptsPath)) {
       mkdirSync2(scriptsPath, { recursive: true });
     }
-    const gitignorePath = join2(cwd, ".cure-kode", ".gitignore");
+    const gitignorePath = join3(cwd, ".cure-kode", ".gitignore");
     const gitignoreContent = `# Keep config.json private - contains API key
 config.json
 `;
-    const fs = await import("fs");
-    fs.writeFileSync(gitignorePath, gitignoreContent);
+    writeFileSync3(gitignorePath, gitignoreContent);
+    spinner.text = "Generating AI context files...";
+    spinner.start();
+    let scripts = [];
+    let siteInfo;
+    try {
+      const siteResponse = await fetch(
+        `https://app.cure.no/api/cdn/sites/${answers.siteId}`,
+        {
+          headers: { "X-API-Key": answers.apiKey }
+        }
+      );
+      if (siteResponse.ok) {
+        siteInfo = await siteResponse.json();
+      }
+      const scriptsResponse = await fetch(
+        `https://app.cure.no/api/cdn/sites/${answers.siteId}/scripts`,
+        {
+          headers: { "X-API-Key": answers.apiKey }
+        }
+      );
+      if (scriptsResponse.ok) {
+        scripts = await scriptsResponse.json();
+      }
+    } catch {
+    }
+    const claudeMdPath = join3(cwd, "CLAUDE.md");
+    const claudeMdContent = generateClaudeMd(config.siteName, config.scriptsDir || "scripts");
+    let claudeMdAction = "created";
+    if (existsSync3(claudeMdPath)) {
+      spinner.stop();
+      console.log(chalk.yellow("\n\u26A0\uFE0F  CLAUDE.md already exists in this directory.\n"));
+      const { action } = await prompt([
+        {
+          type: "select",
+          name: "action",
+          message: "How would you like to handle Kode instructions?",
+          choices: [
+            {
+              name: "append",
+              message: "Append to existing CLAUDE.md (recommended)"
+            },
+            {
+              name: "separate",
+              message: "Create separate KODE.md file"
+            },
+            {
+              name: "skip",
+              message: "Skip - I'll add instructions manually"
+            }
+          ],
+          initial: 0
+        }
+      ]);
+      spinner.start("Generating AI context files...");
+      if (action === "append") {
+        const existingContent = readFileSync3(claudeMdPath, "utf-8");
+        const separator = "\n\n---\n\n";
+        writeFileSync3(claudeMdPath, existingContent + separator + claudeMdContent);
+        claudeMdAction = "appended";
+      } else if (action === "separate") {
+        writeFileSync3(join3(cwd, "KODE.md"), claudeMdContent);
+        claudeMdAction = "separate";
+      } else {
+        claudeMdAction = "skipped";
+      }
+    } else {
+      writeFileSync3(claudeMdPath, claudeMdContent);
+    }
+    const contextMdContent = generateInitialContext(config, scripts, siteInfo);
+    writeFileSync3(join3(cwd, ".cure-kode", "context.md"), contextMdContent);
+    spinner.succeed("AI context files generated");
     console.log(chalk.green("\n\u2705 Cure Kode initialized successfully!\n"));
     console.log(chalk.dim("Project structure:"));
     console.log(chalk.dim(`  ${cwd}/`));
+    if (claudeMdAction === "created") {
+      console.log(chalk.dim(`  \u251C\u2500\u2500 CLAUDE.md         (AI agent instructions)`));
+    } else if (claudeMdAction === "appended") {
+      console.log(chalk.dim(`  \u251C\u2500\u2500 CLAUDE.md         (Kode instructions appended)`));
+    } else if (claudeMdAction === "separate") {
+      console.log(chalk.dim(`  \u251C\u2500\u2500 CLAUDE.md         (existing - unchanged)`));
+      console.log(chalk.dim(`  \u251C\u2500\u2500 KODE.md           (Kode AI instructions)`));
+    } else {
+      console.log(chalk.dim(`  \u251C\u2500\u2500 CLAUDE.md         (existing - unchanged)`));
+    }
     console.log(chalk.dim(`  \u251C\u2500\u2500 .cure-kode/`));
     console.log(chalk.dim(`  \u2502   \u251C\u2500\u2500 config.json   (your configuration)`));
+    console.log(chalk.dim(`  \u2502   \u251C\u2500\u2500 context.md    (dynamic AI context)`));
     console.log(chalk.dim(`  \u2502   \u2514\u2500\u2500 .gitignore    (protects API key)`));
     console.log(chalk.dim(`  \u2514\u2500\u2500 ${answers.scriptsDir}/`));
     console.log(chalk.dim(`      \u2514\u2500\u2500 (your scripts will be here)`));
@@ -164,6 +647,10 @@ config.json
     console.log(chalk.cyan("  1. kode pull     ") + chalk.dim("Download existing scripts"));
     console.log(chalk.cyan("  2. kode watch    ") + chalk.dim("Watch for changes and auto-push"));
     console.log(chalk.cyan("  3. kode deploy   ") + chalk.dim("Deploy to staging/production"));
+    if (claudeMdAction === "separate") {
+      console.log(chalk.yellow("\n\u{1F4A1} Tip: Add this line to your CLAUDE.md to reference Kode instructions:"));
+      console.log(chalk.dim("   See KODE.md for Cure Kode CDN management instructions."));
+    }
   } catch (error) {
     spinner.fail("Initialization failed");
     console.error(chalk.red("\nError:"), error);
@@ -294,8 +781,8 @@ function createApiClient(config) {
 // src/commands/pull.ts
 import chalk2 from "chalk";
 import ora2 from "ora";
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 async function pullCommand(options) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -319,7 +806,7 @@ async function pullCommand(options) {
     }
     spinner.succeed(`Found ${scripts.length} script(s)`);
     const scriptsDir = getScriptsDir(projectRoot, config);
-    if (!existsSync3(scriptsDir)) {
+    if (!existsSync4(scriptsDir)) {
       mkdirSync3(scriptsDir, { recursive: true });
     }
     const scriptsToPull = options.script ? scripts.filter((s) => s.slug === options.script || s.name === options.script) : scripts;
@@ -338,8 +825,8 @@ async function pullCommand(options) {
     for (const script of scriptsToPull) {
       const ext = script.type === "javascript" ? "js" : "css";
       const fileName = `${script.slug}.${ext}`;
-      const filePath = join3(scriptsDir, fileName);
-      if (existsSync3(filePath) && !options.force) {
+      const filePath = join4(scriptsDir, fileName);
+      if (existsSync4(filePath) && !options.force) {
         const localContent = await import("fs").then(
           (fs) => fs.readFileSync(filePath, "utf-8")
         );
@@ -351,7 +838,7 @@ async function pullCommand(options) {
           continue;
         }
       }
-      writeFileSync2(filePath, script.content);
+      writeFileSync4(filePath, script.content);
       const scopeTag = script.scope === "global" ? chalk2.blue("[G]") : chalk2.magenta("[P]");
       console.log(
         chalk2.green(`  \u2713 ${fileName}`) + chalk2.dim(` v${script.current_version} ${scopeTag}`)
@@ -365,7 +852,7 @@ async function pullCommand(options) {
     if (skipped > 0) {
       console.log(chalk2.yellow(`\u26A0\uFE0F  Skipped ${skipped} script(s) with local changes`));
     }
-    const metadataPath = join3(projectRoot, ".cure-kode", "scripts.json");
+    const metadataPath = join4(projectRoot, ".cure-kode", "scripts.json");
     const metadata = scripts.map((s) => ({
       id: s.id,
       slug: s.slug,
@@ -375,7 +862,7 @@ async function pullCommand(options) {
       version: s.current_version,
       loadOrder: s.load_order
     }));
-    writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2));
+    writeFileSync4(metadataPath, JSON.stringify(metadata, null, 2));
   } catch (error) {
     spinner.fail("Failed to pull scripts");
     console.error(chalk2.red("\nError:"), error);
@@ -385,8 +872,8 @@ async function pullCommand(options) {
 // src/commands/push.ts
 import chalk3 from "chalk";
 import ora3 from "ora";
-import { readFileSync as readFileSync2, existsSync as existsSync4, readdirSync } from "fs";
-import { join as join4, basename, extname } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync5, readdirSync } from "fs";
+import { join as join5, basename, extname } from "path";
 async function pushCommand(options) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -400,16 +887,16 @@ async function pushCommand(options) {
     return;
   }
   const scriptsDir = getScriptsDir(projectRoot, config);
-  if (!existsSync4(scriptsDir)) {
+  if (!existsSync5(scriptsDir)) {
     console.log(chalk3.yellow("\u26A0\uFE0F  Scripts directory not found."));
     console.log(chalk3.dim(`   Expected: ${scriptsDir}`));
     console.log(chalk3.dim('   Run "kode pull" first or create scripts manually.'));
     return;
   }
-  const metadataPath = join4(projectRoot, ".cure-kode", "scripts.json");
+  const metadataPath = join5(projectRoot, ".cure-kode", "scripts.json");
   let metadata = [];
-  if (existsSync4(metadataPath)) {
-    metadata = JSON.parse(readFileSync2(metadataPath, "utf-8"));
+  if (existsSync5(metadataPath)) {
+    metadata = JSON.parse(readFileSync4(metadataPath, "utf-8"));
   }
   const files = readdirSync(scriptsDir).filter(
     (f) => f.endsWith(".js") || f.endsWith(".css")
@@ -440,8 +927,8 @@ async function pushCommand(options) {
     spinner.stop();
     console.log();
     for (const file of filesToPush) {
-      const filePath = join4(scriptsDir, file);
-      const content = readFileSync2(filePath, "utf-8");
+      const filePath = join5(scriptsDir, file);
+      const content = readFileSync4(filePath, "utf-8");
       const slug = basename(file, extname(file));
       const type = extname(file) === ".js" ? "javascript" : "css";
       const remoteScript = remoteScripts.find((s) => s.slug === slug);
@@ -507,8 +994,8 @@ async function pushCommand(options) {
 // src/commands/watch.ts
 import chalk4 from "chalk";
 import chokidar from "chokidar";
-import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
-import { join as join5, basename as basename2, extname as extname2 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { join as join6, basename as basename2, extname as extname2 } from "path";
 async function watchCommand(options) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -522,7 +1009,7 @@ async function watchCommand(options) {
     return;
   }
   const scriptsDir = getScriptsDir(projectRoot, config);
-  if (!existsSync5(scriptsDir)) {
+  if (!existsSync6(scriptsDir)) {
     console.log(chalk4.yellow("\u26A0\uFE0F  Scripts directory not found."));
     console.log(chalk4.dim(`   Expected: ${scriptsDir}`));
     console.log(chalk4.dim('   Run "kode pull" first.'));
@@ -538,10 +1025,10 @@ async function watchCommand(options) {
   console.log();
   console.log(chalk4.dim("Press Ctrl+C to stop.\n"));
   const client = createApiClient(config);
-  const metadataPath = join5(projectRoot, ".cure-kode", "scripts.json");
+  const metadataPath = join6(projectRoot, ".cure-kode", "scripts.json");
   let metadata = [];
-  if (existsSync5(metadataPath)) {
-    metadata = JSON.parse(readFileSync3(metadataPath, "utf-8"));
+  if (existsSync6(metadataPath)) {
+    metadata = JSON.parse(readFileSync5(metadataPath, "utf-8"));
   }
   let remoteScripts = [];
   try {
@@ -563,7 +1050,7 @@ async function watchCommand(options) {
     const timeout = setTimeout(async () => {
       pendingChanges.delete(filePath);
       try {
-        const content = readFileSync3(filePath, "utf-8");
+        const content = readFileSync5(filePath, "utf-8");
         const remoteScript = remoteScripts.find((s) => s.slug === slug);
         const localMeta = metadata.find((m) => m.slug === slug);
         const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("nb-NO");
@@ -625,7 +1112,7 @@ async function watchCommand(options) {
     }, DEBOUNCE_MS);
     pendingChanges.set(filePath, timeout);
   };
-  const watcher = chokidar.watch(join5(scriptsDir, "**/*.{js,css}"), {
+  const watcher = chokidar.watch(join6(scriptsDir, "**/*.{js,css}"), {
     persistent: true,
     ignoreInitial: true,
     awaitWriteFinish: {
@@ -708,6 +1195,126 @@ async function deployCommand(environment, options) {
 // src/commands/html.ts
 import chalk6 from "chalk";
 import ora5 from "ora";
+
+// src/lib/page-cache.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync } from "fs";
+import { join as join7, basename as basename3 } from "path";
+var PROJECT_CONFIG_DIR3 = ".cure-kode";
+var PAGES_DIR = "pages";
+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";
+  }
+}
+function getPagesDir(projectRoot) {
+  return join7(projectRoot, PROJECT_CONFIG_DIR3, PAGES_DIR);
+}
+function getPageCachePath(projectRoot, urlOrSlug) {
+  const slug = urlOrSlug.startsWith("http") ? urlToSlug(urlOrSlug) : urlOrSlug;
+  return join7(getPagesDir(projectRoot), `${slug}.json`);
+}
+function ensurePagesDir(projectRoot) {
+  const pagesDir = getPagesDir(projectRoot);
+  if (!existsSync7(pagesDir)) {
+    mkdirSync4(pagesDir, { recursive: true });
+  }
+}
+function savePageContext(projectRoot, context) {
+  ensurePagesDir(projectRoot);
+  const slug = urlToSlug(context.url);
+  const cachePath = getPageCachePath(projectRoot, slug);
+  writeFileSync5(cachePath, JSON.stringify(context, null, 2), "utf-8");
+  return slug;
+}
+function readPageContext(projectRoot, urlOrSlug) {
+  const cachePath = getPageCachePath(projectRoot, urlOrSlug);
+  if (!existsSync7(cachePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync6(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function deletePageContext(projectRoot, urlOrSlug) {
+  const cachePath = getPageCachePath(projectRoot, urlOrSlug);
+  if (existsSync7(cachePath)) {
+    unlinkSync(cachePath);
+    return true;
+  }
+  return false;
+}
+function listCachedPages(projectRoot) {
+  const pagesDir = getPagesDir(projectRoot);
+  if (!existsSync7(pagesDir)) {
+    return [];
+  }
+  const files = readdirSync2(pagesDir).filter((f) => f.endsWith(".json"));
+  const pages = [];
+  for (const file of files) {
+    const slug = basename3(file, ".json");
+    const context = readPageContext(projectRoot, slug);
+    if (context) {
+      pages.push({
+        slug,
+        url: context.url,
+        title: context.title,
+        extractedAt: context.extractedAt,
+        sectionCount: context.sections.length,
+        cmsCollectionCount: context.cmsPatterns.length
+      });
+    }
+  }
+  pages.sort((a, b) => new Date(b.extractedAt).getTime() - new Date(a.extractedAt).getTime());
+  return pages;
+}
+function toCachedContext(structure) {
+  return {
+    url: structure.url,
+    title: structure.title,
+    sections: structure.sections.map((s) => ({
+      id: s.id,
+      className: s.className,
+      heading: s.heading,
+      textSample: s.textSample,
+      hasCms: s.hasCms,
+      hasForm: s.hasForm
+    })),
+    navigation: structure.navigation.map((n) => ({
+      type: n.type,
+      items: n.items.map((i) => ({ text: i.text, href: i.href }))
+    })),
+    ctas: structure.ctas.map((c) => ({
+      text: c.text,
+      href: c.href,
+      location: c.location
+    })),
+    forms: structure.forms.map((f) => ({
+      name: f.name || f.id,
+      fields: f.fields.map((field) => ({
+        type: field.type,
+        label: field.label || field.name,
+        required: field.required
+      })),
+      submitText: f.submitText
+    })),
+    cmsPatterns: structure.cmsPatterns,
+    headings: structure.headings.map((h) => ({
+      level: h.level,
+      text: h.text
+    })),
+    extractedAt: structure.extractedAt
+  };
+}
+
+// src/commands/html.ts
 async function htmlCommand(url, options) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -727,9 +1334,54 @@ async function htmlCommand(url, options) {
     console.log(chalk6.red("\u274C Invalid URL."));
     return;
   }
+  if (options?.save && !options?.force) {
+    const slug = urlToSlug(parsedUrl.toString());
+    const cached = readPageContext(projectRoot, slug);
+    if (cached) {
+      console.log(chalk6.dim(`Using cached version from ${cached.extractedAt}`));
+      console.log(chalk6.dim(`Use --force to refresh`));
+      console.log();
+      printPageContext(cached);
+      return;
+    }
+  }
   const spinner = ora5(`Fetching ${parsedUrl.hostname}${parsedUrl.pathname}...`).start();
   try {
     const client = createApiClient(config);
+    if (options?.save) {
+      const apiUrl = config.apiUrl || "https://app.cure.no";
+      const response = await fetch(`${apiUrl}/api/cdn/page-context`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": config.apiKey
+        },
+        body: JSON.stringify({ url: parsedUrl.toString() })
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: response.statusText }));
+        throw new Error(error.error || `HTTP ${response.status}`);
+      }
+      const structure = await response.json();
+      spinner.succeed("Page structure extracted");
+      const cachedContext = toCachedContext(structure);
+      const slug = savePageContext(projectRoot, cachedContext);
+      console.log(chalk6.dim(`Saved to .cure-kode/pages/${slug}.json`));
+      const contextPage = {
+        slug,
+        url: structure.url,
+        title: structure.title,
+        sections: structure.sections.slice(0, 5).map((s) => s.heading || s.id || s.className?.split(" ")[0] || "section").join(", "),
+        ctas: structure.ctas.length > 0 ? structure.ctas.slice(0, 3).map((c) => `"${c.text}"`).join(", ") : void 0,
+        forms: structure.forms.length > 0 ? structure.forms.map((f) => f.name || "form").join(", ") : void 0,
+        cms: structure.cmsPatterns.length > 0 ? structure.cmsPatterns.map((c) => `${c.containerClass} (${c.itemCount})`).join(", ") : void 0
+      };
+      upsertPage(projectRoot, contextPage, "kode html --save");
+      console.log(chalk6.dim(`Updated .cure-kode/context.md`));
+      console.log();
+      printPageContext(cachedContext);
+      return;
+    }
     const result = await client.fetchHtml(parsedUrl.toString());
     spinner.succeed("HTML fetched");
     if (options?.json) {
@@ -746,7 +1398,7 @@ async function htmlCommand(url, options) {
     } else {
       console.log(chalk6.yellow("\u26A0\uFE0F  Cure Kode not found"));
       console.log(chalk6.dim("   Add this to your Webflow site:"));
-      console.log(chalk6.cyan(`   <script src="https://cure-app-v2-production.up.railway.app/api/cdn/${config.siteSlug}/init.js"></script>`));
+      console.log(chalk6.cyan(`   <script src="https://app.cure.no/api/cdn/${config.siteSlug}/init.js"></script>`));
     }
     console.log();
     console.log(chalk6.dim("\u2500".repeat(50)));
@@ -812,12 +1464,80 @@ async function htmlCommand(url, options) {
     console.error(chalk6.red("\nError:"), error.message || error);
   }
 }
+function printPageContext(context) {
+  console.log(chalk6.bold(context.title || context.url));
+  console.log(chalk6.dim(context.url));
+  console.log();
+  if (context.sections.length > 0) {
+    console.log(chalk6.bold("Sections"));
+    for (const section of context.sections.slice(0, 8)) {
+      const name = section.heading || section.id || section.className?.split(" ")[0] || "section";
+      const badges = [];
+      if (section.hasCms) badges.push(chalk6.cyan("CMS"));
+      if (section.hasForm) badges.push(chalk6.yellow("Form"));
+      const badgeStr = badges.length > 0 ? ` [${badges.join(", ")}]` : "";
+      console.log(`  \u2022 ${name}${badgeStr}`);
+      if (section.textSample) {
+        console.log(chalk6.dim(`    "${section.textSample.slice(0, 60)}..."`));
+      }
+    }
+    if (context.sections.length > 8) {
+      console.log(chalk6.dim(`  ... and ${context.sections.length - 8} more`));
+    }
+    console.log();
+  }
+  if (context.ctas.length > 0) {
+    console.log(chalk6.bold("CTAs"));
+    for (const cta of context.ctas.slice(0, 6)) {
+      console.log(`  \u2022 "${cta.text}" ${chalk6.dim(`(${cta.location})`)}`);
+    }
+    if (context.ctas.length > 6) {
+      console.log(chalk6.dim(`  ... and ${context.ctas.length - 6} more`));
+    }
+    console.log();
+  }
+  if (context.forms.length > 0) {
+    console.log(chalk6.bold("Forms"));
+    for (const form of context.forms) {
+      const fields = form.fields.map((f) => f.label || f.type).slice(0, 4).join(", ");
+      const more = form.fields.length > 4 ? ` +${form.fields.length - 4}` : "";
+      console.log(`  \u2022 ${form.name || "form"}: ${fields}${more}`);
+    }
+    console.log();
+  }
+  if (context.cmsPatterns.length > 0) {
+    console.log(chalk6.bold("CMS Collections"));
+    for (const cms of context.cmsPatterns) {
+      console.log(`  \u2022 ${cms.containerClass}: ${chalk6.cyan(`${cms.itemCount} items`)}`);
+      if (cms.templateFields.length > 0) {
+        console.log(chalk6.dim(`    Fields: ${cms.templateFields.slice(0, 5).join(", ")}`));
+      }
+    }
+    console.log();
+  }
+  if (context.navigation.length > 0) {
+    console.log(chalk6.bold("Navigation"));
+    for (const nav of context.navigation) {
+      const items = nav.items.slice(0, 5).map((i) => i.text).join(", ");
+      const more = nav.items.length > 5 ? ` +${nav.items.length - 5}` : "";
+      console.log(`  \u2022 ${nav.type}: ${items}${more}`);
+    }
+    console.log();
+  }
+  if (context.notes && context.notes.length > 0) {
+    console.log(chalk6.bold("Notes"));
+    for (const note of context.notes) {
+      console.log(`  \u2022 ${note}`);
+    }
+    console.log();
+  }
+}
 
 // src/commands/status.ts
 import chalk7 from "chalk";
 import ora6 from "ora";
-import { readFileSync as readFileSync4, existsSync as existsSync6, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join6, basename as basename3, extname as extname3 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync8, readdirSync as readdirSync3, statSync } from "fs";
+import { join as join8, basename as basename4, extname as extname3 } from "path";
 async function statusCommand(options) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -873,12 +1593,12 @@ async function statusCommand(options) {
     console.log(chalk7.bold("Scripts"));
     console.log();
     const scriptsDir = getScriptsDir(projectRoot, config);
-    const localFiles = existsSync6(scriptsDir) ? readdirSync2(scriptsDir).filter((f) => f.endsWith(".js") || f.endsWith(".css")) : [];
+    const localFiles = existsSync8(scriptsDir) ? readdirSync3(scriptsDir).filter((f) => f.endsWith(".js") || f.endsWith(".css")) : [];
     const localBySlug = /* @__PURE__ */ new Map();
     for (const file of localFiles) {
-      const slug = basename3(file, extname3(file));
-      const filePath = join6(scriptsDir, file);
-      const content = readFileSync4(filePath, "utf-8");
+      const slug = basename4(file, extname3(file));
+      const filePath = join8(scriptsDir, file);
+      const content = readFileSync7(filePath, "utf-8");
       const stats = statSync(filePath);
       localBySlug.set(slug, { file, content, modified: stats.mtime });
     }
@@ -959,6 +1679,168 @@ function formatDate(dateStr) {
   });
 }
 
+// src/commands/context.ts
+import chalk8 from "chalk";
+import ora7 from "ora";
+import { spawn } from "child_process";
+async function contextCommand(options) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    console.log(chalk8.red("Error: Not in a Cure Kode project."));
+    console.log(chalk8.dim('Run "kode init" first.'));
+    return;
+  }
+  const config = getProjectConfig(projectRoot);
+  if (!config) {
+    console.log(chalk8.red("Error: Invalid project configuration."));
+    return;
+  }
+  const contextPath = getContextPath(projectRoot);
+  const context = readContext(projectRoot);
+  if (options.refresh) {
+    const spinner = ora7("Refreshing context from server...").start();
+    try {
+      const siteResponse = await fetch(
+        `https://app.cure.no/api/cdn/sites/${config.siteId}`,
+        {
+          headers: { "X-API-Key": config.apiKey }
+        }
+      );
+      const scriptsResponse = await fetch(
+        `https://app.cure.no/api/cdn/sites/${config.siteId}/scripts`,
+        {
+          headers: { "X-API-Key": config.apiKey }
+        }
+      );
+      if (!siteResponse.ok || !scriptsResponse.ok) {
+        spinner.fail("Failed to fetch from server");
+        return;
+      }
+      const siteInfo = await siteResponse.json();
+      const scripts = await scriptsResponse.json();
+      const existingScripts = context?.scripts || [];
+      const existingNotes = context?.notes || [];
+      const existingSessions = context?.sessions || [];
+      const existingPages = context?.pages || [];
+      const newContext = {
+        site: {
+          name: config.siteName,
+          slug: config.siteSlug,
+          domain: siteInfo?.domain || void 0,
+          stagingDomain: siteInfo?.staging_domain || void 0
+        },
+        scripts: scripts.map((s) => {
+          const existing = existingScripts.find((e) => e.slug === s.slug);
+          return {
+            slug: s.slug,
+            type: s.type,
+            scope: s.scope,
+            purpose: existing?.purpose
+          };
+        }),
+        pages: existingPages,
+        notes: existingNotes,
+        sessions: existingSessions,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedBy: "kode context --refresh"
+      };
+      writeContext(projectRoot, newContext);
+      spinner.succeed("Context refreshed");
+      console.log(chalk8.dim(`Updated: ${contextPath}`));
+      return;
+    } catch (error) {
+      spinner.fail("Failed to refresh context");
+      console.log(chalk8.red(error instanceof Error ? error.message : "Unknown error"));
+      return;
+    }
+  }
+  if (options.edit) {
+    if (!context) {
+      console.log(chalk8.red("Error: No context file found."));
+      console.log(chalk8.dim('Run "kode init" or "kode context --refresh" first.'));
+      return;
+    }
+    const editor = process.env.EDITOR || process.env.VISUAL || "vim";
+    console.log(chalk8.dim(`Opening ${contextPath} in ${editor}...`));
+    const child = spawn(editor, [contextPath], {
+      stdio: "inherit"
+    });
+    child.on("error", (err) => {
+      console.log(chalk8.red(`Failed to open editor: ${err.message}`));
+      console.log(chalk8.dim(`You can edit the file manually: ${contextPath}`));
+    });
+    return;
+  }
+  if (options.json) {
+    if (!context) {
+      console.log(JSON.stringify({ error: "No context file found" }));
+      return;
+    }
+    console.log(JSON.stringify(context, null, 2));
+    return;
+  }
+  if (!context) {
+    console.log(chalk8.yellow("No context file found."));
+    console.log(chalk8.dim('Run "kode context --refresh" to create one.'));
+    return;
+  }
+  console.log(chalk8.bold(`Context: ${context.site.name}`));
+  console.log(chalk8.dim(`Last updated: ${context.lastUpdated}`));
+  console.log(chalk8.dim(`Updated by: ${context.updatedBy}`));
+  console.log();
+  if (context.site.domain || context.site.stagingDomain) {
+    if (context.site.domain) {
+      console.log(chalk8.dim("Domain:  ") + context.site.domain);
+    }
+    if (context.site.stagingDomain) {
+      console.log(chalk8.dim("Staging: ") + context.site.stagingDomain);
+    }
+    console.log();
+  }
+  console.log(chalk8.bold("Scripts:"));
+  if (context.scripts.length === 0) {
+    console.log(chalk8.dim("  (no scripts)"));
+  } else {
+    for (const script of context.scripts) {
+      const typeIcon = script.type === "css" ? "\u{1F3A8}" : "\u{1F4DC}";
+      const scopeLabel = script.scope === "global" ? chalk8.cyan("global") : chalk8.yellow("page");
+      const purpose = script.purpose ? chalk8.dim(` - ${script.purpose}`) : "";
+      console.log(`  ${typeIcon} ${script.slug} [${scopeLabel}]${purpose}`);
+    }
+  }
+  console.log();
+  console.log(chalk8.bold("Notes:"));
+  if (context.notes.length === 0 || context.notes.length === 3 && context.notes[0].startsWith("(HTML")) {
+    console.log(chalk8.dim("  (no notes yet)"));
+  } else {
+    for (const note of context.notes) {
+      if (!note.startsWith("(")) {
+        console.log(`  \u2022 ${note}`);
+      }
+    }
+  }
+  console.log();
+  console.log(chalk8.bold("Recent Sessions:"));
+  if (context.sessions.length === 0) {
+    console.log(chalk8.dim("  (no sessions recorded)"));
+  } else {
+    const recentSessions = context.sessions.slice(0, 3);
+    for (const session of recentSessions) {
+      console.log(`  ${chalk8.dim(session.date)} ${session.agent}`);
+      console.log(`    ${session.task}`);
+      if (session.changes.length > 0) {
+        console.log(chalk8.dim(`    ${session.changes.length} change(s)`));
+      }
+    }
+    if (context.sessions.length > 3) {
+      console.log(chalk8.dim(`  ... and ${context.sessions.length - 3} more sessions`));
+    }
+  }
+  console.log();
+  console.log(chalk8.dim(`Context file: ${contextPath}`));
+  console.log(chalk8.dim("Use --edit to open in editor, --refresh to update from server"));
+}
+
 export {
   findProjectRoot,
   getProjectConfig,
@@ -967,6 +1849,16 @@ export {
   getApiKey,
   setGlobalConfig,
   getScriptsDir,
+  getContextPath,
+  parseContext,
+  serializeContext,
+  readContext,
+  writeContext,
+  appendNote,
+  addSession,
+  updateScriptPurpose,
+  generateInitialContext,
+  generateClaudeMd,
   initCommand,
   KodeApiError,
   KodeApiClient,
@@ -975,6 +1867,10 @@ export {
   pushCommand,
   watchCommand,
   deployCommand,
+  readPageContext,
+  deletePageContext,
+  listCachedPages,
   htmlCommand,
-  statusCommand
+  statusCommand,
+  contextCommand
 };