@see-ms/converter 0.1.2 → 0.1.4

package/dist/cli.mjs

@@ -3,11 +3,14 @@
 // src/cli.ts
 import { Command } from "commander";
 import pc4 from "picocolors";
+import * as readline2 from "readline";
+import fs11 from "fs-extra";
+import path13 from "path";
 
 // src/converter.ts
 import pc3 from "picocolors";
-import path9 from "path";
-import fs8 from "fs-extra";
+import path11 from "path";
+import fs9 from "fs-extra";
 
 // src/filesystem.ts
 import fs from "fs-extra";
@@ -478,13 +481,20 @@ import * as cheerio2 from "cheerio";
 import fs5 from "fs-extra";
 import path6 from "path";
 function cleanClassName(className) {
-  return className.split(" ").filter((cls) => !cls.startsWith("c-") && !cls.startsWith("w-")).filter((cls) => cls.length > 0).map((cls) => cls.replace(/-/g, "_")).join(" ");
+  return className.split(" ").filter((cls) => !cls.startsWith("c-") && !cls.startsWith("w-")).filter((cls) => cls.length > 0).join(" ");
 }
 function getPrimaryClass(classAttr) {
   if (!classAttr) return null;
   const cleaned = cleanClassName(classAttr);
   const classes = cleaned.split(" ").filter((c) => c.length > 0);
-  return classes[0] || null;
+  if (classes.length === 0) return null;
+  const original = classes[0];
+  return {
+    selector: original,
+    // Keep original with dashes for CSS selector
+    fieldName: original.replace(/-/g, "_")
+    // Normalize for field name
+  };
 }
 function getContextModifier(_$, $el) {
   let $current = $el.parent();
@@ -541,11 +551,11 @@ function detectEditableFields(templateHtml) {
   const potentialCollections = /* @__PURE__ */ new Map();
   $("[class]").each((_, el) => {
     const primaryClass = getPrimaryClass($(el).attr("class"));
-    if (primaryClass && (primaryClass.includes("card") || primaryClass.includes("item") || primaryClass.includes("post") || primaryClass.includes("feature")) && !primaryClass.includes("image") && !primaryClass.includes("inner")) {
-      if (!potentialCollections.has(primaryClass)) {
-        potentialCollections.set(primaryClass, []);
+    if (primaryClass && (primaryClass.fieldName.includes("card") || primaryClass.fieldName.includes("item") || primaryClass.fieldName.includes("post") || primaryClass.fieldName.includes("feature")) && !primaryClass.fieldName.includes("image") && !primaryClass.fieldName.includes("inner")) {
+      if (!potentialCollections.has(primaryClass.fieldName)) {
+        potentialCollections.set(primaryClass.fieldName, []);
       }
-      potentialCollections.get(primaryClass)?.push(el);
+      potentialCollections.get(primaryClass.fieldName)?.push(el);
     }
   });
   potentialCollections.forEach((elements, className) => {
@@ -559,40 +569,43 @@ function detectEditableFields(templateHtml) {
           collectionElements.add(child);
         });
       });
+      const collectionClassInfo = getPrimaryClass($(elements[0]).attr("class"));
+      const collectionSelector = collectionClassInfo ? `.${collectionClassInfo.selector}` : `.${className}`;
       $first.find("img").each((_, img) => {
         if (isInsideButton($, img)) return;
         const $img = $(img);
         const $parent = $img.parent();
-        const parentClass = getPrimaryClass($parent.attr("class"));
-        if (parentClass && parentClass.includes("image")) {
-          collectionFields.image = `.${parentClass}`;
+        const parentClassInfo = getPrimaryClass($parent.attr("class"));
+        if (parentClassInfo && parentClassInfo.fieldName.includes("image")) {
+          collectionFields.image = `.${parentClassInfo.selector}`;
           return false;
         }
       });
       $first.find("div").each((_, el) => {
-        const primaryClass = getPrimaryClass($(el).attr("class"));
-        if (primaryClass && primaryClass.includes("tag") && !primaryClass.includes("container")) {
-          collectionFields.tag = `.${primaryClass}`;
+        const classInfo = getPrimaryClass($(el).attr("class"));
+        if (classInfo && classInfo.fieldName.includes("tag") && !classInfo.fieldName.includes("container")) {
+          collectionFields.tag = `.${classInfo.selector}`;
           return false;
         }
       });
       $first.find("h1, h2, h3, h4, h5, h6").first().each((_, el) => {
-        const primaryClass = getPrimaryClass($(el).attr("class"));
-        if (primaryClass) {
-          collectionFields.title = `.${primaryClass}`;
+        const classInfo = getPrimaryClass($(el).attr("class"));
+        if (classInfo) {
+          collectionFields.title = `.${classInfo.selector}`;
         }
       });
       $first.find("p").first().each((_, el) => {
-        const primaryClass = getPrimaryClass($(el).attr("class"));
-        if (primaryClass) {
-          collectionFields.description = `.${primaryClass}`;
+        const classInfo = getPrimaryClass($(el).attr("class"));
+        if (classInfo) {
+          collectionFields.description = `.${classInfo.selector}`;
         }
       });
       $first.find("a, NuxtLink").not(".c_button, .c_icon_button").each((_, el) => {
         const $link = $(el);
         const linkText = $link.text().trim();
         if (linkText) {
-          collectionFields.link = `.${getPrimaryClass($link.attr("class")) || "a"}`;
+          const classInfo = getPrimaryClass($link.attr("class"));
+          collectionFields.link = classInfo ? `.${classInfo.selector}` : "a";
           return false;
         }
       });
@@ -602,7 +615,7 @@ function detectEditableFields(templateHtml) {
           collectionName += "s";
         }
         detectedCollections[collectionName] = {
-          selector: `.${className}`,
+          selector: collectionSelector,
           fields: collectionFields
         };
       }
@@ -613,25 +626,30 @@ function detectEditableFields(templateHtml) {
     if (collectionElements.has(el)) return;
     const $el = $(el);
     const text = $el.text().trim();
-    const primaryClass = getPrimaryClass($el.attr("class"));
+    const classInfo = getPrimaryClass($el.attr("class"));
     if (text) {
       let fieldName;
-      if (primaryClass && !primaryClass.startsWith("heading_")) {
-        fieldName = primaryClass;
+      let selector;
+      if (classInfo && !classInfo.fieldName.startsWith("heading_")) {
+        fieldName = classInfo.fieldName;
+        selector = `.${classInfo.selector}`;
       } else {
         const $parent = $el.closest('[class*="header"], [class*="hero"], [class*="cta"]').first();
-        const parentClass = getPrimaryClass($parent.attr("class"));
+        const parentClassInfo = getPrimaryClass($parent.attr("class"));
         const modifier = getContextModifier($, $el);
-        if (parentClass) {
-          fieldName = modifier ? `${modifier}_${parentClass}` : parentClass;
+        if (parentClassInfo) {
+          fieldName = modifier ? `${modifier}_${parentClassInfo.fieldName}` : parentClassInfo.fieldName;
+          selector = classInfo ? `.${classInfo.selector}` : `.${parentClassInfo.selector}`;
         } else if (modifier) {
           fieldName = `${modifier}_heading`;
+          selector = classInfo ? `.${classInfo.selector}` : el.tagName.toLowerCase();
         } else {
           fieldName = `heading_${index}`;
+          selector = classInfo ? `.${classInfo.selector}` : el.tagName.toLowerCase();
         }
       }
       detectedFields[fieldName] = {
-        selector: primaryClass ? `.${primaryClass}` : el.tagName.toLowerCase(),
+        selector,
         type: "plain",
         editable: true
       };
@@ -641,11 +659,11 @@ function detectEditableFields(templateHtml) {
     if (collectionElements.has(el)) return;
     const $el = $(el);
     const text = $el.text().trim();
-    const primaryClass = getPrimaryClass($el.attr("class"));
-    if (text && text.length > 20 && primaryClass) {
+    const classInfo = getPrimaryClass($el.attr("class"));
+    if (text && text.length > 20 && classInfo) {
       const hasFormatting = $el.find("strong, em, b, i, a, NuxtLink").length > 0;
-      detectedFields[primaryClass] = {
-        selector: `.${primaryClass}`,
+      detectedFields[classInfo.fieldName] = {
+        selector: `.${classInfo.selector}`,
         type: hasFormatting ? "rich" : "plain",
         editable: true
       };
@@ -657,11 +675,11 @@ function detectEditableFields(templateHtml) {
     const $el = $(el);
     if (isDecorativeImage($, $el)) return;
     const $parent = $el.parent();
-    const parentClass = getPrimaryClass($parent.attr("class"));
-    if (parentClass) {
-      const fieldName = parentClass.includes("image") ? parentClass : `${parentClass}_image`;
+    const parentClassInfo = getPrimaryClass($parent.attr("class"));
+    if (parentClassInfo) {
+      const fieldName = parentClassInfo.fieldName.includes("image") ? parentClassInfo.fieldName : `${parentClassInfo.fieldName}_image`;
       detectedFields[fieldName] = {
-        selector: `.${parentClass}`,
+        selector: `.${parentClassInfo.selector}`,
         type: "image",
         editable: true
       };
@@ -675,8 +693,9 @@ function detectEditableFields(templateHtml) {
     }).first().text().trim();
     if (text && text.length > 2) {
       const $parent = $el.closest('[class*="cta"]').first();
-      const parentClass = getPrimaryClass($parent.attr("class")) || "button";
-      detectedFields[`${parentClass}_button_text`] = {
+      const parentClassInfo = getPrimaryClass($parent.attr("class"));
+      const fieldName = parentClassInfo ? `${parentClassInfo.fieldName}_button_text` : "button_text";
+      detectedFields[fieldName] = {
         selector: `.c_button`,
         type: "plain",
         editable: true
@@ -742,6 +761,18 @@ function mapFieldTypeToStrapi(fieldType) {
   };
   return typeMap[fieldType] || "string";
 }
+function pluralize(word) {
+  if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) {
+    return word + "es";
+  }
+  if (word.endsWith("y") && word.length > 1) {
+    const secondLast = word[word.length - 2];
+    if (!"aeiou".includes(secondLast.toLowerCase())) {
+      return word.slice(0, -1) + "ies";
+    }
+  }
+  return word + "s";
+}
 function pageToStrapiSchema(pageName, fields) {
   const attributes = {};
   for (const [fieldName, field] of Object.entries(fields)) {
@@ -754,12 +785,14 @@ function pageToStrapiSchema(pageName, fields) {
     }
   }
   const displayName = pageName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const kebabCaseName = pageName;
+  const pluralName = pluralize(kebabCaseName);
   return {
     kind: "singleType",
-    collectionName: pageName.replace(/-/g, "_"),
+    collectionName: kebabCaseName,
     info: {
-      singularName: pageName.replace(/-/g, "_"),
-      pluralName: pageName.replace(/-/g, "_"),
+      singularName: kebabCaseName,
+      pluralName,
       displayName
     },
     options: {
@@ -786,13 +819,14 @@ function collectionToStrapiSchema(collectionName, collection) {
     };
   }
   const displayName = collectionName.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  const singularName = collectionName.endsWith("s") ? collectionName.slice(0, -1) : collectionName;
+  const kebabCaseName = collectionName.replace(/_/g, "-");
+  const singularName = kebabCaseName.endsWith("s") ? kebabCaseName.slice(0, -1) : kebabCaseName;
   return {
     kind: "collectionType",
-    collectionName: collectionName.replace(/[-_]/g, "_"),
+    collectionName: kebabCaseName,
     info: {
-      singularName: singularName.replace(/[-_]/g, "_"),
-      pluralName: collectionName.replace(/[-_]/g, "_"),
+      singularName,
+      pluralName: kebabCaseName,
       displayName
     },
     options: {
@@ -904,6 +938,186 @@ const { data } = await $fetch('http://localhost:1337/api/portfolio-cards')
   await fs7.writeFile(readmePath, content, "utf-8");
 }
 
+// src/content-extractor.ts
+import * as cheerio3 from "cheerio";
+import path9 from "path";
+function extractContentFromHTML(html, _pageName, pageManifest) {
+  const $ = cheerio3.load(html);
+  const content = {
+    fields: {},
+    collections: {}
+  };
+  if (pageManifest.fields) {
+    for (const [fieldName, field] of Object.entries(pageManifest.fields)) {
+      const selector = field.selector;
+      const element = $(selector).first();
+      if (element.length > 0) {
+        if (field.type === "image") {
+          const src = element.attr("src") || element.find("img").attr("src") || "";
+          content.fields[fieldName] = src;
+        } else {
+          const text = element.text().trim();
+          content.fields[fieldName] = text;
+        }
+      }
+    }
+  }
+  if (pageManifest.collections) {
+    for (const [collectionName, collection] of Object.entries(pageManifest.collections)) {
+      const items = [];
+      const collectionElements = $(collection.selector);
+      collectionElements.each((_, elem) => {
+        const item = {};
+        const $elem = $(elem);
+        for (const [fieldName, fieldSelector] of Object.entries(collection.fields)) {
+          const fieldElement = $elem.find(fieldSelector).first();
+          if (fieldElement.length > 0) {
+            if (fieldName === "image" || fieldName.includes("image")) {
+              const src = fieldElement.attr("src") || fieldElement.find("img").attr("src") || "";
+              item[fieldName] = src;
+            } else if (fieldName === "link" || fieldName === "url") {
+              const href = fieldElement.attr("href") || "";
+              item[fieldName] = href;
+            } else {
+              const text = fieldElement.text().trim();
+              item[fieldName] = text;
+            }
+          }
+        }
+        if (Object.keys(item).length > 0) {
+          items.push(item);
+        }
+      });
+      if (items.length > 0) {
+        content.collections[collectionName] = items;
+      }
+    }
+  }
+  return content;
+}
+function extractAllContent(htmlFiles, manifest) {
+  const extractedContent = {
+    pages: {}
+  };
+  for (const [pageName, pageManifest] of Object.entries(manifest.pages)) {
+    const html = htmlFiles.get(pageName);
+    if (html) {
+      const content = extractContentFromHTML(html, pageName, pageManifest);
+      extractedContent.pages[pageName] = content;
+    }
+  }
+  return extractedContent;
+}
+function normalizeImagePath(imageSrc) {
+  if (!imageSrc) return "";
+  if (imageSrc.startsWith("/")) return imageSrc;
+  const filename = path9.basename(imageSrc);
+  if (imageSrc.includes("images/")) {
+    return `/images/${filename}`;
+  }
+  return `/${filename}`;
+}
+function formatForStrapi(extracted) {
+  const seedData = {};
+  for (const [pageName, content] of Object.entries(extracted.pages)) {
+    if (Object.keys(content.fields).length > 0) {
+      const formattedFields = {};
+      for (const [fieldName, value] of Object.entries(content.fields)) {
+        if (fieldName.includes("image") || fieldName.includes("bg")) {
+          formattedFields[fieldName] = normalizeImagePath(value);
+        } else {
+          formattedFields[fieldName] = value;
+        }
+      }
+      seedData[pageName] = formattedFields;
+    }
+    for (const [collectionName, items] of Object.entries(content.collections)) {
+      const formattedItems = items.map((item) => {
+        const formattedItem = {};
+        for (const [fieldName, value] of Object.entries(item)) {
+          if (fieldName === "image" || fieldName.includes("image")) {
+            formattedItem[fieldName] = normalizeImagePath(value);
+          } else {
+            formattedItem[fieldName] = value;
+          }
+        }
+        return formattedItem;
+      });
+      seedData[collectionName] = formattedItems;
+    }
+  }
+  return seedData;
+}
+
+// src/seed-writer.ts
+import fs8 from "fs-extra";
+import path10 from "path";
+async function writeSeedData(outputDir, seedData) {
+  const seedDir = path10.join(outputDir, "cms-seed");
+  await fs8.ensureDir(seedDir);
+  const seedPath = path10.join(seedDir, "seed-data.json");
+  await fs8.writeJson(seedPath, seedData, { spaces: 2 });
+}
+async function createSeedReadme(outputDir) {
+  const readmePath = path10.join(outputDir, "cms-seed", "README.md");
+  const content = `# CMS Seed Data
+
+Auto-extracted content from your Webflow export, ready to seed into Strapi.
+
+## What's in this folder?
+
+\`seed-data.json\` contains the actual content extracted from your HTML:
+- **Single types** - Page-specific content (homepage, about page, etc.)
+- **Collection types** - Repeating items (portfolio cards, team members, etc.)
+
+## Structure
+
+\`\`\`json
+{
+  "index": {
+    "hero_heading_container": "Actual heading from HTML",
+    "hero_bg_image": "/images/hero.jpg",
+    ...
+  },
+  "portfolio_cards": [
+    {
+      "image": "/images/card1.jpg",
+      "tag": "Technology",
+      "description": "Card description"
+    }
+  ]
+}
+\`\`\`
+
+## How to Seed Strapi
+
+### Option 1: Manual Entry
+1. Open Strapi admin panel
+2. Go to Content Manager
+3. Create entries using the data from \`seed-data.json\`
+
+### Option 2: Automated Seeding (Coming Soon)
+We'll provide a seeding script that:
+1. Uploads images to Strapi media library
+2. Creates content entries via Strapi API
+3. Handles relationships between content types
+
+## Image Paths
+
+Image paths in the seed data reference files in your Nuxt \`public/\` directory:
+- \`/images/hero.jpg\` \u2192 \`public/images/hero.jpg\`
+
+When seeding Strapi, these images will be uploaded to Strapi's media library.
+
+## Next Steps
+
+1. Review the extracted data for accuracy
+2. Set up your Strapi instance with the schemas from \`cms-schemas/\`
+3. Use this seed data to populate your CMS
+`;
+  await fs8.writeFile(readmePath, content, "utf-8");
+}
+
 // src/converter.ts
 async function convertWebflowExport(options) {
   const { inputDir, outputDir, boilerplate } = options;
@@ -912,7 +1126,7 @@ async function convertWebflowExport(options) {
   console.log(pc3.dim(`Output: ${outputDir}`));
   try {
     await setupBoilerplate(boilerplate, outputDir);
-    const inputExists = await fs8.pathExists(inputDir);
+    const inputExists = await fs9.pathExists(inputDir);
     if (!inputExists) {
       throw new Error(`Input directory not found: ${inputDir}`);
     }
@@ -928,10 +1142,17 @@ async function convertWebflowExport(options) {
     console.log(pc3.blue("\n\u{1F50D} Finding HTML files..."));
     const htmlFiles = await findHTMLFiles(inputDir);
     console.log(pc3.green(`  \u2713 Found ${htmlFiles.length} HTML files`));
+    const htmlContentMap = /* @__PURE__ */ new Map();
+    for (const htmlFile of htmlFiles) {
+      const html = await readHTMLFile(inputDir, htmlFile);
+      const pageName = htmlFile.replace(".html", "").replace(/\//g, "-");
+      htmlContentMap.set(pageName, html);
+      console.log(pc3.dim(`  Stored: ${pageName} from ${htmlFile}`));
+    }
     console.log(pc3.blue("\n\u2699\uFE0F  Converting HTML to Vue components..."));
     let allEmbeddedStyles = "";
     for (const htmlFile of htmlFiles) {
-      const html = await readHTMLFile(inputDir, htmlFile);
+      const html = htmlContentMap.get(htmlFile.replace(".html", "").replace(/\//g, "-"));
       const parsed = parseHTML(html, htmlFile);
       if (parsed.embeddedStyles) {
         allEmbeddedStyles += `
@@ -947,7 +1168,7 @@ ${parsed.embeddedStyles}
     }
     await formatVueFiles(outputDir);
     console.log(pc3.blue("\n\u{1F50D} Analyzing pages for CMS fields..."));
-    const pagesDir = path9.join(outputDir, "pages");
+    const pagesDir = path11.join(outputDir, "pages");
     const manifest = await generateManifest(pagesDir);
     await writeManifest(outputDir, manifest);
     const totalFields = Object.values(manifest.pages).reduce(
@@ -961,12 +1182,26 @@ ${parsed.embeddedStyles}
     console.log(pc3.green(`  \u2713 Detected ${totalFields} fields across ${Object.keys(manifest.pages).length} pages`));
     console.log(pc3.green(`  \u2713 Detected ${totalCollections} collections`));
     console.log(pc3.green("  \u2713 Generated cms-manifest.json"));
+    console.log(pc3.blue("\n\u{1F4DD} Extracting content from HTML..."));
+    console.log(pc3.dim(`  HTML map has ${htmlContentMap.size} entries`));
+    console.log(pc3.dim(`  Manifest has ${Object.keys(manifest.pages).length} pages`));
+    const extractedContent = extractAllContent(htmlContentMap, manifest);
+    const seedData = formatForStrapi(extractedContent);
+    await writeSeedData(outputDir, seedData);
+    await createSeedReadme(outputDir);
+    const pagesWithContent = Object.keys(seedData).filter((key) => {
+      const data = seedData[key];
+      if (Array.isArray(data)) return data.length > 0;
+      return Object.keys(data).length > 0;
+    }).length;
+    console.log(pc3.green(`  \u2713 Extracted content from ${pagesWithContent} pages`));
+    console.log(pc3.green(`  \u2713 Generated cms-seed/seed-data.json`));
     console.log(pc3.blue("\n\u{1F4CB} Generating Strapi schemas..."));
     const schemas = manifestToSchemas(manifest);
     await writeAllSchemas(outputDir, schemas);
     await createStrapiReadme(outputDir);
     console.log(pc3.green(`  \u2713 Generated ${Object.keys(schemas).length} Strapi content types`));
-    console.log(pc3.dim("    View schemas in: strapi/src/api/"));
+    console.log(pc3.dim("    View schemas in: cms-schemas/"));
     if (allEmbeddedStyles.trim()) {
       console.log(pc3.blue("\n\u2728 Writing embedded styles..."));
       const dedupedStyles = deduplicateStyles(allEmbeddedStyles);
@@ -981,7 +1216,7 @@ ${parsed.embeddedStyles}
       await updateNuxtConfig(outputDir, assets.css);
       console.log(pc3.green("  \u2713 Config updated"));
     } catch (error) {
-      console.log(pc3.yellow("  \u26A0 Could not update nuxt.config.ts automatically"));
+      console.log(pc3.yellow("  \u26A0  Could not update nuxt.config.ts automatically"));
       console.log(pc3.dim("    Please add CSS files manually"));
     }
     console.log(pc3.blue("\n\u{1F3A8} Setting up editor overlay..."));
@@ -994,10 +1229,11 @@ ${parsed.embeddedStyles}
     console.log(pc3.green("\n\u2705 Conversion completed successfully!"));
     console.log(pc3.cyan("\n\u{1F4CB} Next steps:"));
     console.log(pc3.dim(`  1. cd ${outputDir}`));
-    console.log(pc3.dim("  2. Review cms-manifest.json"));
-    console.log(pc3.dim("  3. Copy strapi/ schemas to your Strapi project"));
-    console.log(pc3.dim("  4. pnpm install && pnpm dev"));
-    console.log(pc3.dim("  5. Visit http://localhost:3000?preview=true to edit inline!"));
+    console.log(pc3.dim("  2. Review cms-manifest.json and cms-seed/seed-data.json"));
+    console.log(pc3.dim("  3. Set up Strapi and install schemas from cms-schemas/"));
+    console.log(pc3.dim("  4. Seed Strapi with data from cms-seed/"));
+    console.log(pc3.dim("  5. pnpm install && pnpm dev"));
+    console.log(pc3.dim("  6. Visit http://localhost:3000?preview=true to edit inline!"));
   } catch (error) {
     console.error(pc3.red("\n\u274C Conversion failed:"));
     console.error(pc3.red(error instanceof Error ? error.message : String(error)));
@@ -1005,10 +1241,501 @@ ${parsed.embeddedStyles}
   }
 }
 
+// src/strapi-setup.ts
+import fs10 from "fs-extra";
+import path12 from "path";
+import { glob as glob2 } from "glob";
+import * as readline from "readline";
+var ENV_FILE = ".env";
+async function loadConfig(projectDir) {
+  const envPath = path12.join(projectDir, ENV_FILE);
+  if (await fs10.pathExists(envPath)) {
+    try {
+      const content = await fs10.readFile(envPath, "utf-8");
+      const config = {};
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const [key, ...valueParts] = trimmed.split("=");
+        const value = valueParts.join("=").trim();
+        if (key === "STRAPI_API_TOKEN") {
+          config.apiToken = value;
+        } else if (key === "STRAPI_URL") {
+          config.strapiUrl = value;
+        }
+      }
+      return config;
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+async function saveConfig(projectDir, config) {
+  const envPath = path12.join(projectDir, ENV_FILE);
+  let content = "";
+  if (await fs10.pathExists(envPath)) {
+    content = await fs10.readFile(envPath, "utf-8");
+    content = content.split("\n").filter((line) => !line.startsWith("STRAPI_API_TOKEN=") && !line.startsWith("STRAPI_URL=")).join("\n");
+    if (content && !content.endsWith("\n")) {
+      content += "\n";
+    }
+  }
+  if (config.strapiUrl) {
+    content += `STRAPI_URL=${config.strapiUrl}
+`;
+  }
+  if (config.apiToken) {
+    content += `STRAPI_API_TOKEN=${config.apiToken}
+`;
+  }
+  await fs10.writeFile(envPath, content);
+}
+async function completeSetup(options) {
+  const { projectDir, strapiDir, strapiUrl: optionUrl, apiToken: optionToken, ignoreSavedToken } = options;
+  const savedConfig = await loadConfig(projectDir);
+  const strapiUrl = optionUrl || savedConfig.strapiUrl || "http://localhost:1337";
+  console.log("\u{1F680} Starting complete Strapi setup...\n");
+  console.log("\u{1F4E6} Step 1: Installing schemas...");
+  await installSchemas(projectDir, strapiDir);
+  console.log("\u2713 Schemas installed\n");
+  console.log("\u23F8\uFE0F  Step 2: Restart Strapi to load schemas");
+  console.log("   Run: npm run develop (in Strapi directory)");
+  console.log("   Press Enter when Strapi is running...");
+  await waitForEnter();
+  console.log("\n\u{1F50D} Step 3: Checking Strapi connection...");
+  const isRunning = await checkStrapiRunning(strapiUrl);
+  if (!isRunning) {
+    console.error("\u274C Cannot connect to Strapi at", strapiUrl);
+    console.log("   Make sure Strapi is running: npm run develop");
+    process.exit(1);
+  }
+  console.log("\u2713 Connected to Strapi\n");
+  let token = optionToken || (!ignoreSavedToken ? savedConfig.apiToken : void 0);
+  if (token && !ignoreSavedToken) {
+    console.log("\u{1F511} Step 4: Using saved API token");
+  } else if (token && optionToken) {
+    console.log("\u{1F511} Step 4: Using provided API token");
+  } else {
+    console.log("\u{1F511} Step 4: API Token needed");
+    console.log("   1. Open Strapi admin: http://localhost:1337/admin");
+    console.log("   2. Go to Settings > API Tokens > Create new API Token");
+    console.log('   3. Name: "Seed Script", Type: "Full access", Duration: "Unlimited"');
+    console.log("   4. Copy the token and paste it here:\n");
+    token = await promptForToken();
+    const saveToken = await promptYesNo("   Save token for future use?");
+    if (saveToken) {
+      await saveConfig(projectDir, { ...savedConfig, apiToken: token, strapiUrl });
+      console.log("   \u2713 Token saved to .env");
+    }
+    console.log("");
+  }
+  console.log("\u{1F4F8} Step 5: Uploading images...");
+  const mediaMap = await uploadAllImages(projectDir, strapiUrl, token);
+  console.log(`\u2713 Uploaded ${Object.keys(mediaMap).length} images
+`);
+  console.log("\u{1F4DD} Step 6: Seeding content...");
+  await seedContent(projectDir, strapiUrl, token, mediaMap);
+  console.log("\u2713 Content seeded\n");
+  console.log("\u2705 Complete setup finished!");
+  console.log("\n\u{1F4CB} Next steps:");
+  console.log("   1. Open Strapi admin: http://localhost:1337/admin");
+  console.log("   2. Check Content Manager - your content should be there!");
+  console.log("   3. Connect your Nuxt app to Strapi API");
+}
+async function installSchemas(projectDir, strapiDir) {
+  if (!await fs10.pathExists(strapiDir)) {
+    console.error(`   \u2717 Strapi directory not found: ${strapiDir}`);
+    console.error(`   Resolved to: ${path12.resolve(strapiDir)}`);
+    throw new Error(`Strapi directory not found: ${strapiDir}`);
+  }
+  const packageJsonPath = path12.join(strapiDir, "package.json");
+  if (await fs10.pathExists(packageJsonPath)) {
+    const pkg = await fs10.readJson(packageJsonPath);
+    if (!pkg.dependencies?.["@strapi/strapi"]) {
+      console.warn(`   \u26A0\uFE0F  Warning: ${strapiDir} may not be a Strapi project`);
+    }
+  }
+  const schemaDir = path12.join(projectDir, "cms-schemas");
+  const schemaFiles = await glob2("*.json", {
+    cwd: schemaDir,
+    absolute: false
+  });
+  if (schemaFiles.length === 0) {
+    console.log("\u26A0\uFE0F  No schema files found");
+    return;
+  }
+  console.log(`   Found ${schemaFiles.length} schema file(s)`);
+  for (const file of schemaFiles) {
+    const schemaPath = path12.join(schemaDir, file);
+    const schema = await fs10.readJson(schemaPath);
+    const singularName = schema.info?.singularName || path12.basename(file, ".json");
+    console.log(`   Installing ${singularName}...`);
+    try {
+      const apiPath = path12.join(strapiDir, "src", "api", singularName);
+      const contentTypesPath = path12.join(
+        apiPath,
+        "content-types",
+        singularName
+      );
+      const targetPath = path12.join(contentTypesPath, "schema.json");
+      await fs10.ensureDir(contentTypesPath);
+      await fs10.ensureDir(path12.join(apiPath, "routes"));
+      await fs10.ensureDir(path12.join(apiPath, "controllers"));
+      await fs10.ensureDir(path12.join(apiPath, "services"));
+      await fs10.writeJson(targetPath, schema, { spaces: 2 });
+      const routeContent = `import { factories } from '@strapi/strapi';
+         export default factories.createCoreRouter('api::${singularName}.${singularName}');
+        `;
+      await fs10.writeFile(
+        path12.join(apiPath, "routes", `${singularName}.ts`),
+        routeContent
+      );
+      const controllerContent = `import { factories } from '@strapi/strapi';
+         export default factories.createCoreController('api::${singularName}.${singularName}');
+        `;
+      await fs10.writeFile(
+        path12.join(apiPath, "controllers", `${singularName}.ts`),
+        controllerContent
+      );
+      const serviceContent = `import { factories } from '@strapi/strapi';
+         export default factories.createCoreService('api::${singularName}.${singularName}');
+        `;
+      await fs10.writeFile(
+        path12.join(apiPath, "services", `${singularName}.ts`),
+        serviceContent
+      );
+    } catch (error) {
+      console.error(`   \u2717 Failed to install ${singularName}: ${error.message}`);
+    }
+  }
+}
+async function checkStrapiRunning(strapiUrl) {
+  try {
+    const response = await fetch(`${strapiUrl}/_health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function waitForEnter() {
+  const rl = createReadline();
+  return new Promise((resolve) => {
+    rl.question("", () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+async function promptForToken() {
+  const rl = createReadline();
+  return new Promise((resolve) => {
+    rl.question("   Token: ", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function promptYesNo(question) {
+  const rl = createReadline();
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/n): `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
+async function getExistingMedia(strapiUrl, apiToken) {
+  const existingMedia = /* @__PURE__ */ new Map();
+  try {
+    let page = 1;
+    const pageSize = 100;
+    let hasMore = true;
+    while (hasMore) {
+      const response = await fetch(
+        `${strapiUrl}/api/upload/files?pagination[page]=${page}&pagination[pageSize]=${pageSize}`,
+        {
+          headers: {
+            Authorization: `Bearer ${apiToken}`
+          }
+        }
+      );
+      if (!response.ok) {
+        break;
+      }
+      const data = await response.json();
+      const files = Array.isArray(data) ? data : data.results || [];
+      for (const file of files) {
+        if (file.name) {
+          existingMedia.set(file.name, file.id);
+        }
+      }
+      hasMore = files.length === pageSize;
+      page++;
+    }
+  } catch (error) {
+  }
+  return existingMedia;
+}
+async function uploadAllImages(projectDir, strapiUrl, apiToken) {
+  const mediaMap = /* @__PURE__ */ new Map();
+  const imagesDir = path12.join(projectDir, "public", "assets", "images");
+  if (!await fs10.pathExists(imagesDir)) {
+    console.log("   No images directory found");
+    return mediaMap;
+  }
+  const imageFiles = await glob2("**/*.{jpg,jpeg,png,gif,webp,svg}", {
+    cwd: imagesDir,
+    absolute: false
+  });
+  console.log(`   Checking for existing media...`);
+  const existingMedia = await getExistingMedia(strapiUrl, apiToken);
+  let uploadedCount = 0;
+  let skippedCount = 0;
+  console.log(`   Processing ${imageFiles.length} images...`);
+  for (const imageFile of imageFiles) {
+    const fileName = path12.basename(imageFile);
+    const existingId = existingMedia.get(fileName);
+    if (existingId) {
+      mediaMap.set(`/images/${imageFile}`, existingId);
+      mediaMap.set(imageFile, existingId);
+      skippedCount++;
+      continue;
+    }
+    const imagePath = path12.join(imagesDir, imageFile);
+    const mediaId = await uploadImage(imagePath, imageFile, strapiUrl, apiToken);
+    if (mediaId) {
+      mediaMap.set(`/images/${imageFile}`, mediaId);
+      mediaMap.set(imageFile, mediaId);
+      uploadedCount++;
+      console.log(`   \u2713 ${imageFile}`);
+    }
+  }
+  console.log(`   Uploaded: ${uploadedCount}, Skipped (existing): ${skippedCount}`);
+  return mediaMap;
+}
+async function uploadImage(filePath, fileName, strapiUrl, apiToken) {
+  try {
+    const fileBuffer = await fs10.readFile(filePath);
+    const mimeType = getMimeType(fileName);
+    const blob = new Blob([fileBuffer], { type: mimeType });
+    const formData = new globalThis.FormData();
+    formData.append("files", blob, fileName);
+    const response = await fetch(`${strapiUrl}/api/upload`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiToken}`
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(
+        `   \u2717 Failed to upload ${fileName}: ${response.status} - ${errorText}`
+      );
+      return null;
+    }
+    const data = await response.json();
+    return data[0]?.id || null;
+  } catch (error) {
+    console.error(`   \u2717 Error uploading ${fileName}:`, error);
+    return null;
+  }
+}
+function getMimeType(fileName) {
+  const ext = path12.extname(fileName).toLowerCase();
+  const mimeTypes = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml"
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}
+async function seedContent(projectDir, strapiUrl, apiToken, mediaMap) {
+  const seedPath = path12.join(projectDir, "cms-seed", "seed-data.json");
+  if (!await fs10.pathExists(seedPath)) {
+    console.log("   No seed data found");
+    return;
+  }
+  const seedData = await fs10.readJson(seedPath);
+  const schemasDir = path12.join(projectDir, "cms-schemas");
+  const schemas = /* @__PURE__ */ new Map();
+  const schemaFiles = await glob2("*.json", { cwd: schemasDir });
+  for (const file of schemaFiles) {
+    const schema = await fs10.readJson(path12.join(schemasDir, file));
+    const name = path12.basename(file, ".json");
+    schemas.set(name, schema);
+  }
+  let successCount = 0;
+  let totalCount = 0;
+  for (const [contentType, data] of Object.entries(seedData)) {
+    const schema = schemas.get(contentType);
+    if (!schema) {
+      console.log(`   \u26A0\uFE0F  No schema found for ${contentType}, skipping...`);
+      continue;
+    }
+    const singularName = schema.info.singularName;
+    const pluralName = schema.info.pluralName;
+    if (Array.isArray(data)) {
+      console.log(`   Seeding ${contentType} (${data.length} items)...`);
+      for (const item of data) {
+        totalCount++;
+        const processedItem = processMediaFields(item, mediaMap);
+        const success = await createEntry(
+          pluralName,
+          processedItem,
+          strapiUrl,
+          apiToken
+        );
+        if (success) successCount++;
+      }
+    } else {
+      console.log(`   Seeding ${contentType}...`);
+      totalCount++;
+      const processedData = processMediaFields(data, mediaMap);
+      const success = await createOrUpdateSingleType(
+        singularName,
+        processedData,
+        strapiUrl,
+        apiToken
+      );
+      if (success) successCount++;
+    }
+  }
+  console.log(`   \u2713 Successfully seeded ${successCount}/${totalCount} entries`);
+}
+function processMediaFields(data, mediaMap) {
+  const processed = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (typeof value === "string") {
+      if (key.includes("image") || key.includes("bg") || value.startsWith("/images/")) {
+        const mediaId = mediaMap.get(value);
+        if (mediaId) {
+          processed[key] = mediaId;
+        } else {
+          processed[key] = value;
+        }
+      } else {
+        processed[key] = value;
+      }
+    } else {
+      processed[key] = value;
+    }
+  }
+  return processed;
+}
+async function createEntry(contentType, data, strapiUrl, apiToken) {
+  try {
+    const response = await fetch(`${strapiUrl}/api/${contentType}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiToken}`
+      },
+      body: JSON.stringify({ data })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(
+        `   \u2717 Failed to create ${contentType}: ${response.status} - ${errorText}`
+      );
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(`   \u2717 Error creating ${contentType}:`, error);
+    return false;
+  }
+}
+async function createOrUpdateSingleType(contentType, data, strapiUrl, apiToken) {
+  try {
+    const response = await fetch(`${strapiUrl}/api/${contentType}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiToken}`
+      },
+      body: JSON.stringify({ data })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(
+        `   \u2717 Failed to update ${contentType}: ${response.status} - ${errorText}`
+      );
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(`   \u2717 Error updating ${contentType}:`, error);
+    return false;
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 2) {
+    console.log(
+      "Usage: tsx strapi-setup.ts <project-dir> <strapi-dir> [strapi-url] [api-token]"
+    );
+    console.log("");
+    console.log("Example:");
+    console.log("  tsx strapi-setup.ts ./nuxt-project ./strapi-dev");
+    console.log(
+      "  tsx strapi-setup.ts ./nuxt-project ./strapi-dev http://localhost:1337 abc123"
+    );
+    process.exit(1);
+  }
+  const [projectDir, strapiDir, strapiUrl, apiToken] = args;
+  await completeSetup({
+    projectDir,
+    strapiDir,
+    strapiUrl,
+    apiToken
+  });
+}
+var isMainModule = process.argv[1] && process.argv[1].endsWith("strapi-setup.ts");
+if (isMainModule) {
+  main().catch((error) => {
+    console.error("\u274C Setup failed:", error.message);
+    process.exit(1);
+  });
+}
+
 // src/cli.ts
 var program = new Command();
-program.name("cms").description("SeeMS - Webflow to CMS converter").version("0.1.0");
-program.command("convert").description("Convert Webflow export to Nuxt 3 project").argument("<input>", "Path to Webflow export directory").argument("<output>", "Path to output Nuxt project directory").option("-b, --boilerplate <source>", "Boilerplate source (GitHub URL or local path)").option("-o, --overrides <path>", "Path to overrides JSON file").option("--generate-schemas", "Generate CMS schemas immediately").option("--cms <type>", "CMS backend type (strapi|contentful|sanity)", "strapi").action(async (input, output, options) => {
+async function prompt(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function confirm(question) {
+  const answer = await prompt(`${question} (y/n): `);
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+program.name("cms").description("SeeMS - Webflow to CMS converter").version("0.1.2");
+program.command("convert").description("Convert Webflow export to Nuxt 3 project").argument("<input>", "Path to Webflow export directory").argument("<output>", "Path to output Nuxt project directory").option(
+  "-b, --boilerplate <source>",
+  "Boilerplate source (GitHub URL or local path)"
+).option("-o, --overrides <path>", "Path to overrides JSON file").option("--generate-schemas", "Generate CMS schemas immediately").option(
+  "--cms <type>",
+  "CMS backend type (strapi|contentful|sanity)",
+  "strapi"
+).option("--no-interactive", "Skip interactive prompts").action(async (input, output, options) => {
   try {
     await convertWebflowExport({
       inputDir: input,
@@ -1018,15 +1745,99 @@ program.command("convert").description("Convert Webflow export to Nuxt 3 project
       generateStrapi: options.generateSchemas,
       cmsBackend: options.cms
     });
+    if (options.interactive && options.cms === "strapi") {
+      console.log("");
+      const shouldSetup = await confirm(
+        pc4.cyan("\u{1F3AF} Would you like to setup Strapi now?")
+      );
+      if (shouldSetup) {
+        const strapiDir = await prompt(
+          pc4.cyan(
+            "\u{1F4C1} Enter path to your Strapi directory (e.g., ./strapi-dev): "
+          )
+        );
+        if (strapiDir) {
+          console.log("");
+          console.log(pc4.cyan("\u{1F680} Starting Strapi setup..."));
+          console.log("");
+          try {
+            await completeSetup({
+              projectDir: output,
+              strapiDir
+            });
+          } catch (error) {
+            console.error(pc4.red("\n\u274C Strapi setup failed"));
+            console.error(pc4.dim("You can run setup manually later with:"));
+            console.error(
+              pc4.dim(`  cms setup-strapi ${output} ${strapiDir}`)
+            );
+          }
+        }
+      } else {
+        console.log("");
+        console.log(pc4.dim("\u{1F4A1} You can setup Strapi later with:"));
+        console.log(
+          pc4.dim(`   cms setup-strapi ${output} <strapi-directory>`)
+        );
+      }
+    }
   } catch (error) {
     console.error(pc4.red("Conversion failed"));
     process.exit(1);
   }
 });
-program.command("generate").description("Generate CMS schemas from manifest").argument("<manifest>", "Path to cms-manifest.json").option("-t, --type <cms>", "CMS type (strapi|contentful|sanity)", "strapi").option("-o, --output <dir>", "Output directory for schemas").action(async (manifest, _options) => {
-  console.log(pc4.cyan("\u{1F3D7}\uFE0F  SeeMS Schema Generator"));
-  console.log(pc4.dim(`Generating schemas from: ${manifest}`));
-  console.log(pc4.yellow("\u26A0\uFE0F  Schema generation logic to be implemented"));
+program.command("setup-strapi").description("Setup Strapi with schemas and seed data").argument("<project-dir>", "Path to converted project directory").argument("<strapi-dir>", "Path to Strapi directory").option("--url <url>", "Strapi URL", "http://localhost:1337").option("--token <token>", "Strapi API token (optional)").option("--new-token", "Ignore saved token and prompt for a new one").action(async (projectDir, strapiDir, options) => {
+  try {
+    await completeSetup({
+      projectDir,
+      strapiDir,
+      strapiUrl: options.url,
+      apiToken: options.token,
+      ignoreSavedToken: options.newToken
+    });
+  } catch (error) {
+    console.error(pc4.red("Strapi setup failed"));
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.command("generate").description("Generate CMS schemas from manifest").argument("<manifest>", "Path to cms-manifest.json").option("-t, --type <cms>", "CMS type (strapi|contentful|sanity)", "strapi").option("-o, --output <dir>", "Output directory for schemas").action(async (manifestPath, options) => {
+  try {
+    console.log(pc4.cyan("\u{1F5C2}\uFE0F  SeeMS Schema Generator"));
+    console.log(pc4.dim(`Reading manifest from: ${manifestPath}`));
+    const manifestExists = await fs11.pathExists(manifestPath);
+    if (!manifestExists) {
+      throw new Error(`Manifest file not found: ${manifestPath}`);
+    }
+    const manifestContent = await fs11.readFile(manifestPath, "utf-8");
+    const manifest = JSON.parse(manifestContent);
+    console.log(pc4.green(`  \u2713 Manifest loaded successfully`));
+    const outputDir = options.output || path13.dirname(manifestPath);
+    if (options.type !== "strapi") {
+      console.log(
+        pc4.yellow(
+          `\u26A0\uFE0F  Only Strapi is currently supported. Using Strapi schema format.`
+        )
+      );
+    }
+    console.log(pc4.blue("\n\u{1F4CB} Generating Strapi schemas..."));
+    const schemas = manifestToSchemas(manifest);
+    await writeAllSchemas(outputDir, schemas);
+    await createStrapiReadme(outputDir);
+    console.log(
+      pc4.green(
+        `  \u2713 Generated ${Object.keys(schemas).length} Strapi content types`
+      )
+    );
+    console.log(pc4.dim(`  \u2713 Schemas written to: ${path13.join(outputDir, "cms-schemas")}/`));
+    console.log(pc4.green("\n\u2705 Schema generation completed successfully!"));
+  } catch (error) {
+    console.error(pc4.red("\n\u274C Schema generation failed:"));
+    console.error(
+      pc4.red(error instanceof Error ? error.message : String(error))
+    );
+    process.exit(1);
+  }
 });
 program.parse();
 //# sourceMappingURL=cli.mjs.map