@see-ms/converter 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,2919 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import pc4 from "picocolors";
+import * as readline2 from "readline";
+import fs12 from "fs-extra";
+import path14 from "path";
+
+// src/converter.ts
+import pc3 from "picocolors";
+import path12 from "path";
+import fs10 from "fs-extra";
+
+// src/filesystem.ts
+import fs from "fs-extra";
+import path from "path";
+import { glob } from "glob";
+import { execSync } from "child_process";
+import pc from "picocolors";
+async function scanAssets(webflowDir) {
+  const assets = {
+    css: [],
+    images: [],
+    fonts: [],
+    js: []
+  };
+  const cssFiles = await glob("css/**/*.css", { cwd: webflowDir });
+  assets.css = cssFiles;
+  const imageFiles = await glob("images/**/*", { cwd: webflowDir });
+  assets.images = imageFiles;
+  const fontFiles = await glob("fonts/**/*", { cwd: webflowDir });
+  assets.fonts = fontFiles;
+  const jsFiles = await glob("js/**/*.js", { cwd: webflowDir });
+  assets.js = jsFiles;
+  return assets;
+}
+async function copyCSSFiles(webflowDir, outputDir, cssFiles) {
+  const targetDir = path.join(outputDir, "assets", "css");
+  await fs.ensureDir(targetDir);
+  for (const file of cssFiles) {
+    const source = path.join(webflowDir, file);
+    const target = path.join(targetDir, path.basename(file));
+    await fs.copy(source, target);
+  }
+}
+async function copyImages(webflowDir, outputDir, imageFiles) {
+  const targetDir = path.join(outputDir, "public", "assets", "images");
+  await fs.ensureDir(targetDir);
+  for (const file of imageFiles) {
+    const source = path.join(webflowDir, file);
+    const target = path.join(targetDir, path.basename(file));
+    await fs.copy(source, target);
+  }
+}
+async function copyFonts(webflowDir, outputDir, fontFiles) {
+  const targetDir = path.join(outputDir, "public", "assets", "fonts");
+  await fs.ensureDir(targetDir);
+  for (const file of fontFiles) {
+    const source = path.join(webflowDir, file);
+    const target = path.join(targetDir, path.basename(file));
+    await fs.copy(source, target);
+  }
+}
+async function copyJSFiles(webflowDir, outputDir, jsFiles) {
+  const targetDir = path.join(outputDir, "public", "assets", "js");
+  await fs.ensureDir(targetDir);
+  for (const file of jsFiles) {
+    const source = path.join(webflowDir, file);
+    const target = path.join(targetDir, path.basename(file));
+    await fs.copy(source, target);
+  }
+}
+async function copyAllAssets(webflowDir, outputDir, assets) {
+  await copyCSSFiles(webflowDir, outputDir, assets.css);
+  await copyImages(webflowDir, outputDir, assets.images);
+  await copyFonts(webflowDir, outputDir, assets.fonts);
+  await copyJSFiles(webflowDir, outputDir, assets.js);
+}
+async function findHTMLFiles(webflowDir) {
+  const htmlFiles = await glob("**/*.html", { cwd: webflowDir });
+  return htmlFiles;
+}
+async function readHTMLFile(webflowDir, fileName) {
+  const filePath = path.join(webflowDir, fileName);
+  return await fs.readFile(filePath, "utf-8");
+}
+async function writeVueComponent(outputDir, fileName, content) {
+  const pagesDir = path.join(outputDir, "pages");
+  const vueName = fileName.replace(".html", ".vue");
+  const targetPath = path.join(pagesDir, vueName);
+  await fs.ensureDir(path.dirname(targetPath));
+  await fs.writeFile(targetPath, content, "utf-8");
+}
+async function formatVueFiles(outputDir) {
+  const pagesDir = path.join(outputDir, "pages");
+  try {
+    console.log(pc.blue("\n\u2728 Formatting Vue files with Prettier..."));
+    execSync("npx prettier --version", { stdio: "ignore" });
+    execSync(`npx prettier --write "${pagesDir}/**/*.vue"`, {
+      cwd: outputDir,
+      stdio: "inherit"
+    });
+    console.log(pc.green("  \u2713 Vue files formatted"));
+  } catch (error) {
+    console.log(pc.yellow("  \u26A0 Prettier not available, skipping formatting"));
+  }
+}
+
+// src/parser.ts
+import * as cheerio from "cheerio";
+import path2 from "path";
+function normalizeRoute(href) {
+  let route = href.replace(".html", "");
+  if (route === "index" || route === "/index" || route.endsWith("/index")) {
+    return "/";
+  }
+  if (route === ".." || route === "../" || route === "/.." || route === "../index") {
+    return "/";
+  }
+  route = route.replace(/\.\.\//g, "").replace(/\.\//g, "");
+  const normalized = path2.posix.normalize(route);
+  if (!normalized.startsWith("/")) {
+    return "/" + normalized;
+  }
+  if (normalized === "." || normalized === "") {
+    return "/";
+  }
+  return normalized;
+}
+function normalizeAssetPath(src) {
+  if (!src || src.startsWith("http") || src.startsWith("https")) {
+    return src;
+  }
+  let normalized = src.replace(/^(\.\.\/)+/, "").replace(/^\.\//, "");
+  if (normalized.startsWith("/assets/")) {
+    normalized = normalized.replace(/\/\.\.\//g, "/");
+    return normalized;
+  }
+  return `/assets/${normalized}`;
+}
+function parseHTML(html, fileName) {
+  const $ = cheerio.load(html);
+  const title = $("title").text() || fileName.replace(".html", "");
+  const cssFiles = [];
+  $('link[rel="stylesheet"]').each((_, el) => {
+    const href = $(el).attr("href");
+    if (href) {
+      cssFiles.push(href);
+    }
+  });
+  let embeddedStyles = "";
+  $(".global-embed style").each((_, el) => {
+    embeddedStyles += $(el).html() + "\n";
+  });
+  $("body > style").each((_, el) => {
+    embeddedStyles += $(el).html() + "\n";
+  });
+  $(".global-embed").remove();
+  $("body > style").remove();
+  $("body script").remove();
+  const images = [];
+  $("img").each((_, el) => {
+    const src = $(el).attr("src");
+    if (src) {
+      images.push(src);
+    }
+  });
+  const links = [];
+  $("a").each((_, el) => {
+    const href = $(el).attr("href");
+    if (href) {
+      links.push(href);
+    }
+  });
+  const htmlContent = $("body").html() || "";
+  return {
+    fileName,
+    title,
+    htmlContent,
+    cssFiles,
+    embeddedStyles,
+    images,
+    links
+  };
+}
+function transformForNuxt(html) {
+  const $ = cheerio.load(html);
+  $("html, head, body").each((_, el) => {
+    const $el = $(el);
+    $el.replaceWith($el.html() || "");
+  });
+  $("script").remove();
+  $("a").each((_, el) => {
+    const $el = $(el);
+    const href = $el.attr("href");
+    if (!href) return;
+    const isExternal = href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("#");
+    if (!isExternal) {
+      const route = normalizeRoute(href);
+      $el.attr("to", route);
+      $el.removeAttr("href");
+      const content = $el.html();
+      const classes = $el.attr("class") || "";
+      $el.replaceWith(`<nuxt-link to="${route}" class="${classes}">${content}</nuxt-link>`);
+    }
+  });
+  $("img").each((_, el) => {
+    const $el = $(el);
+    const src = $el.attr("src");
+    if (src) {
+      const normalizedSrc = normalizeAssetPath(src);
+      $el.attr("src", normalizedSrc);
+    }
+    $el.removeAttr("srcset");
+    $el.removeAttr("sizes");
+  });
+  return $.html();
+}
+function htmlToVueComponent(html, pageName) {
+  return `
+<script setup lang="ts">
+// Page: ${pageName}
+</script>
+
+<template>
+  <div>
+    ${html}
+  </div>
+</template>
+`;
+}
+function deduplicateStyles(styles) {
+  if (!styles.trim()) return "";
+  const sections = styles.split(/\/\* From .+ \*\//);
+  const uniqueStyles = /* @__PURE__ */ new Set();
+  for (const section of sections) {
+    const trimmed = section.trim();
+    if (trimmed) {
+      uniqueStyles.add(trimmed);
+    }
+  }
+  return Array.from(uniqueStyles).join("\n\n");
+}
+
+// src/config-updater.ts
+import fs2 from "fs-extra";
+import path3 from "path";
+function generateWebflowAssetPlugin(cssFiles) {
+  const webflowFiles = cssFiles.map((file) => `/assets/css/${path3.basename(file)}`);
+  return `import type { Plugin } from 'vite'
+
+const webflowFiles = [${webflowFiles.map((f) => `'${f}'`).join(", ")}]
+const replacements = [
+  ['../images/', '/assets/images/'],
+  ['../fonts/', '/assets/fonts/']
+]
+
+const webflowURLReset = (): Plugin => ({
+  name: 'webflowURLReset',
+  config: () => ({
+    build: {
+      rollupOptions: {
+        external: [/\\.\\.\\/fonts\\//, /\\.\\.\\/images\\//]
+      }
+    }
+  }),
+  transform: (code, id) => {
+    if (webflowFiles.some((path) => id.includes(path))) {
+      replacements.forEach(([search, replace]) => {
+        code = code.replaceAll(search, replace)
+      })
+    }
+
+    return { code, id, map: null }
+  }
+})
+
+export default webflowURLReset
+`;
+}
+async function writeWebflowAssetPlugin(outputDir, cssFiles) {
+  const utilsDir = path3.join(outputDir, "utils");
+  await fs2.ensureDir(utilsDir);
+  const content = generateWebflowAssetPlugin(cssFiles);
+  const targetPath = path3.join(utilsDir, "webflow-assets.ts");
+  await fs2.writeFile(targetPath, content, "utf-8");
+}
+async function updateNuxtConfig(outputDir, cssFiles) {
+  const configPath = path3.join(outputDir, "nuxt.config.ts");
+  const configExists = await fs2.pathExists(configPath);
+  if (!configExists) {
+    throw new Error("nuxt.config.ts not found in output directory");
+  }
+  let config = await fs2.readFile(configPath, "utf-8");
+  const cssEntries = cssFiles.map((file) => `    '~/assets/css/${path3.basename(file)}'`);
+  if (config.includes("css:")) {
+    config = config.replace(
+      /css:\s*\[/,
+      `css: [
+${cssEntries.join(",\n")},`
+    );
+  } else {
+    config = config.replace(
+      /export default defineNuxtConfig\(\{/,
+      `export default defineNuxtConfig({
+  css: [
+${cssEntries.join(",\n")}
+  ],`
+    );
+  }
+  await fs2.writeFile(configPath, config, "utf-8");
+}
+async function writeEmbeddedStyles(outputDir, styles) {
+  if (!styles.trim()) return;
+  const cssDir = path3.join(outputDir, "assets", "css");
+  await fs2.ensureDir(cssDir);
+  const mainCssPath = path3.join(cssDir, "main.css");
+  const exists = await fs2.pathExists(mainCssPath);
+  if (exists) {
+    const existing = await fs2.readFile(mainCssPath, "utf-8");
+    await fs2.writeFile(mainCssPath, `${existing}
+
+/* Webflow Embedded Styles */
+${styles}`, "utf-8");
+  } else {
+    await fs2.writeFile(mainCssPath, `/* Webflow Embedded Styles */
+${styles}`, "utf-8");
+  }
+}
+async function addStrapiUrlToConfig(outputDir, strapiUrl = "http://localhost:1337") {
+  const configPath = path3.join(outputDir, "nuxt.config.ts");
+  const configExists = await fs2.pathExists(configPath);
+  if (!configExists) {
+    throw new Error("nuxt.config.ts not found in output directory");
+  }
+  let config = await fs2.readFile(configPath, "utf-8");
+  if (config.includes("runtimeConfig:")) {
+    if (config.includes("public:")) {
+      config = config.replace(
+        /public:\s*\{/,
+        `public: {
+      strapiUrl: process.env.STRAPI_URL || '${strapiUrl}',`
+      );
+    } else {
+      config = config.replace(
+        /runtimeConfig:\s*\{/,
+        `runtimeConfig: {
+    public: {
+      strapiUrl: process.env.STRAPI_URL || '${strapiUrl}'
+    },`
+      );
+    }
+  } else {
+    config = config.replace(
+      /export default defineNuxtConfig\(\{/,
+      `export default defineNuxtConfig({
+  runtimeConfig: {
+    public: {
+      strapiUrl: process.env.STRAPI_URL || '${strapiUrl}'
+    }
+  },`
+    );
+  }
+  await fs2.writeFile(configPath, config, "utf-8");
+}
+
+// src/editor-integration.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+async function createEditorContentComposable(outputDir) {
+  const composablesDir = path4.join(outputDir, "composables");
+  await fs3.ensureDir(composablesDir);
+  const composableContent = `/**
+ * Global state for editor content in preview mode
+ * This allows the editor overlay to update content reactively
+ */
+
+// Global reactive state
+const editorState = reactive<{
+  isPreviewMode: boolean;
+  currentPage: string | null;
+  content: Record<string, Record<string, any>>; // page -> field -> value
+  hasChanges: Record<string, boolean>; // page -> hasChanges
+}>({
+  isPreviewMode: false,
+  currentPage: null,
+  content: {},
+  hasChanges: {},
+});
+
+export function useEditorContent(pageName?: string) {
+  const route = useRoute();
+
+  // Check if we're in preview mode
+  const isPreviewMode = computed(() => route.query.preview === 'true');
+
+  // Update global state
+  if (import.meta.client) {
+    editorState.isPreviewMode = isPreviewMode.value;
+    if (pageName) {
+      editorState.currentPage = pageName;
+    }
+  }
+
+  // Get content for specific page
+  const getPageContent = (page: string) => {
+    return editorState.content[page] || {};
+  };
+
+  // Update a field's value
+  const updateField = (page: string, fieldName: string, value: any) => {
+    if (!editorState.content[page]) {
+      editorState.content[page] = {};
+    }
+    editorState.content[page][fieldName] = value;
+    editorState.hasChanges[page] = true;
+  };
+
+  // Clear all changes for a page
+  const clearPageChanges = (page: string) => {
+    delete editorState.content[page];
+    editorState.hasChanges[page] = false;
+  };
+
+  // Initialize page content from Strapi data
+  const initializePageContent = (page: string, content: Record<string, any>) => {
+    if (!editorState.content[page]) {
+      editorState.content[page] = { ...content };
+    }
+  };
+
+  // Get content for current page (reactive)
+  const content = computed(() => {
+    const page = pageName || editorState.currentPage;
+    if (!page) return {};
+    return editorState.content[page] || {};
+  });
+
+  // Check if page has unsaved changes
+  const hasChanges = computed(() => {
+    const page = pageName || editorState.currentPage;
+    if (!page) return false;
+    return editorState.hasChanges[page] || false;
+  });
+
+  // Get all pages with changes
+  const pagesWithChanges = computed(() => {
+    return Object.keys(editorState.hasChanges).filter(
+      (page) => editorState.hasChanges[page]
+    );
+  });
+
+  // Expose state for window object (for editor overlay to access)
+  if (import.meta.client) {
+    (window as any).__editorState = editorState;
+  }
+
+  return {
+    isPreviewMode,
+    content,
+    hasChanges,
+    pagesWithChanges,
+    getPageContent,
+    updateField,
+    clearPageChanges,
+    initializePageContent,
+  };
+}
+`;
+  const composablePath = path4.join(composablesDir, "useEditorContent.ts");
+  await fs3.writeFile(composablePath, composableContent, "utf-8");
+}
+async function createStrapiContentComposable(outputDir) {
+  const composablesDir = path4.join(outputDir, "composables");
+  await fs3.ensureDir(composablesDir);
+  const composableContent = `/**
+ * Composable to fetch content from Strapi based on CMS manifest
+ * Integrates with editor state for preview mode
+ */
+
+export function useStrapiContent(pageName: string) {
+  const config = useRuntimeConfig();
+  const strapiUrl = config.public.strapiUrl || 'http://localhost:1337';
+  const editorContent = useEditorContent(pageName);
+
+  // Helper to transform Strapi image objects to URL strings
+  const transformStrapiImages = (data: any, baseUrl: string): any => {
+    if (!data || typeof data !== 'object') return data;
+
+    const transformed: any = {};
+
+    for (const [key, value] of Object.entries(data)) {
+      if (value && typeof value === 'object') {
+        // Check if it's a Strapi media object
+        if ('url' in value && ('mime' in value || 'formats' in value)) {
+          // It's an image - extract the URL
+          transformed[key] = value.url.startsWith('http')
+            ? value.url
+            : \`\${baseUrl}\${value.url}\`;
+        } else if (Array.isArray(value)) {
+          // Handle arrays (collections of images)
+          transformed[key] = value.map((item) =>
+            item && typeof item === 'object' && 'url' in item
+              ? item.url.startsWith('http')
+                ? item.url
+                : \`\${baseUrl}\${item.url}\`
+              : item
+          );
+        } else {
+          // Recursively transform nested objects
+          transformed[key] = transformStrapiImages(value, baseUrl);
+        }
+      } else {
+        transformed[key] = value;
+      }
+    }
+
+    return transformed;
+  };
+
+  // Fetch content from Strapi with populated media fields
+  const { data: strapiData } = useFetch<any>(
+    \`\${strapiUrl}/api/\${pageName}\`,
+    {
+      key: \`strapi-\${pageName}\`,
+      query: {
+        populate: '*', // Strapi v5: Populate all fields including images
+      },
+      transform: (response) => {
+        // Strapi v5 returns data in response.data
+        const data = response?.data || response;
+
+        // Transform image fields from Strapi objects to URL strings
+        if (data && typeof data === 'object') {
+          return transformStrapiImages(data, strapiUrl);
+        }
+
+        return data;
+      },
+    }
+  );
+
+  // Initialize editor state with Strapi data when fetched
+  // This runs in both normal AND preview mode to ensure initial content is available
+  watch(
+    strapiData,
+    (newData) => {
+      if (newData) {
+        // Always initialize from Strapi on first load
+        // Drafts will override this when they load in the editor
+        editorContent.initializePageContent(pageName, newData);
+      }
+    },
+    { immediate: true }
+  );
+
+  // In preview mode: use editor state
+  // In normal mode: use Strapi data (and sync to editor state)
+  const content = computed(() => {
+    if (editorContent.isPreviewMode.value) {
+      // Use editor state in preview mode
+      return editorContent.getPageContent(pageName);
+    } else {
+      // Use Strapi data in normal mode
+      return strapiData.value || editorContent.getPageContent(pageName);
+    }
+  });
+
+  return {
+    content,
+  };
+}
+`;
+  const composablePath = path4.join(composablesDir, "useStrapiContent.ts");
+  await fs3.writeFile(composablePath, composableContent, "utf-8");
+}
+async function createEditorPlugin(outputDir) {
+  const pluginsDir = path4.join(outputDir, "plugins");
+  await fs3.ensureDir(pluginsDir);
+  const pluginContent = `/**
+ * CMS Editor Overlay Plugin
+ * Loads the inline editor when ?preview=true with full state management
+ */
+
+/**
+ * Disable Lenis smooth scroll to allow native scrolling in edit mode
+ */
+function disableLenisInEditMode() {
+  try {
+    // Check for Lenis in common locations
+    const lenisInstances = [
+      (window as any).lenis,
+      (window as any).__lenis,
+      document.querySelector('.lenis'),
+    ];
+
+    for (const lenis of lenisInstances) {
+      if (lenis && typeof lenis.destroy === 'function') {
+        lenis.destroy();
+        return;
+      }
+    }
+
+    // Check for Vue Lenis component instances
+    const lenisElements = document.querySelectorAll('[data-lenis], .lenis');
+    if (lenisElements.length > 0) {
+      // Try to find and destroy via data attributes or component instances
+      lenisElements.forEach((el: any) => {
+        if (el.__lenis && typeof el.__lenis.destroy === 'function') {
+          el.__lenis.destroy();
+        }
+      });
+    }
+  } catch (error) {
+    // Silently fail - Lenis may not be present
+  }
+}
+
+export default defineNuxtPlugin(async (nuxtApp) => {
+  // Only run on client side
+  if (process.server) return;
+
+  // Import editor overlay modules
+  const {
+    initEditor,
+    createAuthManager,
+    showLoginModal,
+    createDraftStorage,
+    createURLStateManager,
+    createManifestLoader,
+    createNavigationGuard,
+    getCurrentPageFromRoute,
+  } = await import('@see-ms/editor-overlay');
+
+  // Initialize URL state manager
+  const urlState = createURLStateManager();
+  const state = urlState.getState();
+
+  // Only proceed if in preview mode
+  if (!state.preview) return;
+
+  // Get Strapi URL from runtime config
+  const config = useRuntimeConfig();
+  const strapiUrl = config.public.strapiUrl || 'http://localhost:1337';
+
+  // Initialize components
+  const authManager = createAuthManager({
+    strapiUrl,
+    storageKey: 'cms_editor_token',
+  });
+
+  const draftStorage = createDraftStorage();
+  const manifestLoader = createManifestLoader();
+
+  // Load manifest
+  try {
+    await manifestLoader.load();
+  } catch (error) {
+    console.error('[CMS Editor] Failed to load manifest:', error);
+    return;
+  }
+
+  // Get current page from route
+  let currentPage = getCurrentPageFromRoute();
+  if (!currentPage) {
+    currentPage = manifestLoader.getPageFromRoute(window.location.pathname);
+  }
+
+  if (!currentPage) {
+    console.error('[CMS Editor] Could not determine current page');
+    return;
+  }
+
+  // URL state only manages preview mode (page is derived from route)
+  urlState.setState({ preview: true });
+
+  // Auth flow
+  let token = authManager.getToken();
+  if (!token || !await authManager.verifyToken(token)) {
+    try {
+      token = await showLoginModal(authManager);
+    } catch (error) {
+      // Login cancelled - exit preview mode
+      console.log('[CMS Editor] Login cancelled');
+      urlState.clearPreviewMode();
+      return;
+    }
+  }
+
+  // Disable Lenis smooth scroll in edit mode (allows native scrolling)
+  disableLenisInEditMode();
+
+  // Initialize navigation guard
+  const navigationGuard = createNavigationGuard({
+    showToast: true,
+    toastMessage: 'Navigation disabled in edit mode',
+  });
+  navigationGuard.enable();
+
+  // Initialize editor with full context
+  const editor = initEditor({
+    apiEndpoint: '/api/cms/save',
+    authToken: token,
+    richText: true,
+    manifestLoader,
+    draftStorage,
+    currentPage,
+  });
+
+  // Enable editor (will auto-load drafts)
+  await editor.enable();
+
+  // Create toolbar with navigation
+  const { createToolbar } = await import('@see-ms/editor-overlay');
+  const toolbar = await createToolbar(editor, {
+    draftStorage,
+    urlState,
+    navigationGuard,
+    manifestLoader,
+    currentPage,
+  });
+  document.body.appendChild(toolbar);
+
+  // Watch for route changes
+  const router = useRouter();
+  router.afterEach(async (to) => {
+    const newPage = manifestLoader.getPageFromRoute(to.path);
+    if (newPage && newPage !== currentPage) {
+      currentPage = newPage;
+      await editor.setPage(newPage);
+
+      // Update toolbar if it has an update method
+      if (typeof (toolbar as any).updateCurrentPage === 'function') {
+        await (toolbar as any).updateCurrentPage(newPage);
+      }
+    }
+  });
+
+  // Cleanup on navigation away from preview mode
+  nuxtApp.hook('page:finish', () => {
+    const currentState = urlState.getState();
+    if (!currentState.preview) {
+      navigationGuard.disable();
+      editor.destroy();
+    }
+  });
+});
+`;
+  const pluginPath = path4.join(pluginsDir, "cms-editor.client.ts");
+  await fs3.writeFile(pluginPath, pluginContent, "utf-8");
+}
+async function addEditorDependency(outputDir) {
+  const packageJsonPath = path4.join(outputDir, "package.json");
+  if (await fs3.pathExists(packageJsonPath)) {
+    const packageJson = await fs3.readJson(packageJsonPath);
+    if (!packageJson.dependencies) {
+      packageJson.dependencies = {};
+    }
+    packageJson.dependencies["@see-ms/editor-overlay"] = "^1.0.0";
+    await fs3.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  }
+}
+async function createSaveEndpoint(outputDir) {
+  const serverDir = path4.join(outputDir, "server", "api", "cms");
+  await fs3.ensureDir(serverDir);
+  const endpointContent = `/**
+ * API endpoint for saving CMS changes
+ * Handles draft and final saving to Strapi
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export default defineEventHandler(async (event) => {
+  // Get Strapi URL from runtime config
+  const config = useRuntimeConfig();
+  const strapiUrl = config.public.strapiUrl || 'http://localhost:1337';
+
+  // Extract Authorization header
+  const authHeader = getHeader(event, 'authorization');
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: 'Unauthorized: Missing or invalid authorization header',
+    });
+  }
+
+  const token = authHeader.substring(7); // Remove 'Bearer ' prefix
+
+  // Verify token with Strapi and determine if it's an admin or user token
+  let userResponse: any;
+  let isAdminToken = false;
+
+  try {
+    // Try admin token verification first
+    try {
+      userResponse = await $fetch(\`\${strapiUrl}/admin/users/me\`, {
+        headers: {
+          Authorization: \`Bearer \${token}\`,
+        },
+      });
+      isAdminToken = true;
+    } catch (adminError) {
+      // Fallback to regular user token verification
+      userResponse = await $fetch(\`\${strapiUrl}/api/users/me\`, {
+        headers: {
+          Authorization: \`Bearer \${token}\`,
+        },
+      });
+      isAdminToken = false;
+    }
+
+    // Get the request body
+    const body = await readBody(event);
+    const { page, fields, isDraft = true } = body;
+
+    if (!page || !fields) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'Bad Request: Missing page or fields',
+      });
+    }
+
+    // Load manifest to understand field mappings
+    const manifestPath = path.join(process.cwd(), 'cms-manifest.json');
+    let manifest;
+    try {
+      const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+      manifest = JSON.parse(manifestContent);
+    } catch (error) {
+      console.error('Failed to load manifest:', error);
+      throw createError({
+        statusCode: 500,
+        statusMessage: 'Failed to load CMS manifest',
+      });
+    }
+
+    // Get page configuration from manifest
+    const pageConfig = manifest.pages[page];
+    if (!pageConfig) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: \`Page "\${page}" not found in manifest\`,
+      });
+    }
+
+    // Transform fields to Strapi format
+    const strapiData: Record<string, any> = {};
+    for (const [fieldName, value] of Object.entries(fields)) {
+      const fieldConfig = pageConfig.fields[fieldName];
+      if (!fieldConfig) {
+        console.warn(\`Field "\${fieldName}" not found in manifest for page "\${page}"\`);
+        continue;
+      }
+
+      // Handle different field types
+      if (fieldConfig.type === 'image') {
+        // TODO: Handle image uploads - for now just store the value
+        strapiData[fieldName] = value;
+      } else {
+        strapiData[fieldName] = value;
+      }
+    }
+
+    // Update Strapi v5 content - use different endpoints for admin vs user tokens
+    if (isAdminToken) {
+      // Admin tokens use the content-manager API (Strapi v5)
+      const contentEndpoint = \`\${strapiUrl}/content-manager/single-types/api::\${page}.\${page}\`;
+
+      // Step 1: Update the content
+      await $fetch(contentEndpoint, {
+        method: 'PUT',
+        headers: {
+          'Authorization': \`Bearer \${token}\`,
+          'Content-Type': 'application/json',
+        },
+        body: strapiData,
+      });
+
+      // Step 2: Publish if not a draft (Strapi v5)
+      if (!isDraft) {
+        const publishEndpoint = \`\${strapiUrl}/content-manager/single-types/api::\${page}.\${page}/actions/publish\`;
+        await $fetch(publishEndpoint, {
+          method: 'POST',
+          headers: {
+            'Authorization': \`Bearer \${token}\`,
+            'Content-Type': 'application/json',
+          },
+          body: {},
+        });
+      }
+    } else {
+      // User tokens use the regular REST API
+      const strapiEndpoint = \`\${strapiUrl}/api/\${page}\`;
+
+      await $fetch(strapiEndpoint, {
+        method: 'PUT',
+        headers: {
+          'Authorization': \`Bearer \${token}\`,
+          'Content-Type': 'application/json',
+        },
+        body: {
+          data: strapiData,
+        },
+      });
+
+      // Publish if not a draft (Strapi v5)
+      if (!isDraft) {
+        const publishEndpoint = \`\${strapiUrl}/api/\${page}/publish\`;
+        await $fetch(publishEndpoint, {
+          method: 'POST',
+          headers: {
+            'Authorization': \`Bearer \${token}\`,
+            'Content-Type': 'application/json',
+          },
+          body: {},
+        });
+      }
+    }
+
+    console.log(\`[CMS Save] Updated "\${page}" in Strapi (draft: \${isDraft})\`);
+
+    return {
+      success: true,
+      message: 'Changes saved successfully',
+      page,
+      isDraft,
+      user: {
+        id: userResponse.id,
+        username: userResponse.username || userResponse.firstname || 'Unknown',
+      },
+    };
+  } catch (error: any) {
+    console.error('[CMS Save] Error:', error);
+
+    // Token verification failed
+    if (error.statusCode === 401 || error.status === 401) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: 'Unauthorized: Invalid or expired token',
+      });
+    }
+
+    // Strapi error
+    if (error.statusCode || error.status) {
+      throw createError({
+        statusCode: error.statusCode || error.status,
+        statusMessage: error.statusMessage || error.message || 'Failed to save to Strapi',
+      });
+    }
+
+    // Generic error
+    throw createError({
+      statusCode: 500,
+      statusMessage: 'Internal server error while saving changes',
+    });
+  }
+});
+`;
+  const endpointPath = path4.join(serverDir, "save.post.ts");
+  await fs3.writeFile(endpointPath, endpointContent, "utf-8");
+}
+async function createStrapiBootstrap(outputDir) {
+  const strapiBootstrapDir = path4.join(outputDir, "strapi-bootstrap");
+  await fs3.ensureDir(strapiBootstrapDir);
+  const bootstrapContent = `/**
+ * Strapi Bootstrap File
+ * Auto-enables public read permissions for all single types
+ *
+ * Place this file in your Strapi project at: src/index.ts
+ */
+
+export default {
+  /**
+   * Bootstrap function runs when Strapi starts
+   */
+  async bootstrap({ strapi }: { strapi: any }) {
+    try {
+      console.log('[Bootstrap] Configuring public permissions for CMS...');
+
+      // Get the public role
+      const publicRole = await strapi
+        .query('plugin::users-permissions.role')
+        .findOne({ where: { type: 'public' } });
+
+      if (!publicRole) {
+        console.error('[Bootstrap] Public role not found');
+        return;
+      }
+
+      // Get all content types
+      const contentTypes = Object.keys(strapi.contentTypes).filter(
+        (uid) => uid.startsWith('api::')
+      );
+
+      // Enable find and findOne for each content type
+      const permissions = await strapi
+        .query('plugin::users-permissions.permission')
+        .findMany({
+          where: {
+            role: publicRole.id,
+          },
+        });
+
+      let updatedCount = 0;
+
+      for (const contentType of contentTypes) {
+        const [, apiName] = contentType.split('::');
+        const [controllerName] = apiName.split('.');
+
+        // Find or create find permission
+        const findPermission = permissions.find(
+          (p: any) =>
+            p.action === \`api::\${apiName}.find\` ||
+            p.action === 'find' && p.controller === controllerName
+        );
+
+        const findOnePermission = permissions.find(
+          (p: any) =>
+            p.action === \`api::\${apiName}.findOne\` ||
+            p.action === 'findOne' && p.controller === controllerName
+        );
+
+        // Enable find
+        if (findPermission && !findPermission.enabled) {
+          await strapi
+            .query('plugin::users-permissions.permission')
+            .update({
+              where: { id: findPermission.id },
+              data: { enabled: true },
+            });
+          updatedCount++;
+        }
+
+        // Enable findOne
+        if (findOnePermission && !findOnePermission.enabled) {
+          await strapi
+            .query('plugin::users-permissions.permission')
+            .update({
+              where: { id: findOnePermission.id },
+              data: { enabled: true },
+            });
+          updatedCount++;
+        }
+
+        // If permissions don't exist, create them
+        if (!findPermission) {
+          await strapi.query('plugin::users-permissions.permission').create({
+            data: {
+              action: \`api::\${apiName}.find\`,
+              role: publicRole.id,
+              enabled: true,
+            },
+          });
+          updatedCount++;
+        }
+
+        if (!findOnePermission) {
+          await strapi.query('plugin::users-permissions.permission').create({
+            data: {
+              action: \`api::\${apiName}.findOne\`,
+              role: publicRole.id,
+              enabled: true,
+            },
+          });
+          updatedCount++;
+        }
+      }
+
+      console.log(
+        \`[Bootstrap] \u2705 Enabled \${updatedCount} public permissions for \${contentTypes.length} content types\`
+      );
+    } catch (error) {
+      console.error('[Bootstrap] Error enabling public permissions:', error);
+    }
+  },
+};
+`;
+  const bootstrapPath = path4.join(strapiBootstrapDir, "index.ts");
+  await fs3.writeFile(bootstrapPath, bootstrapContent, "utf-8");
+  const readmeContent = `# Strapi Bootstrap File
+
+This file automatically enables public read permissions for all CMS content types when Strapi starts.
+
+## Installation
+
+1. Copy the \`index.ts\` file to your Strapi project:
+   \`\`\`bash
+   cp strapi-bootstrap/index.ts <your-strapi-project>/src/index.ts
+   \`\`\`
+
+2. Restart Strapi:
+   \`\`\`bash
+   cd <your-strapi-project>
+   npm run develop
+   \`\`\`
+
+3. Check the console logs - you should see:
+   \`\`\`
+   [Bootstrap] \u2705 Enabled X public permissions for Y content types
+   \`\`\`
+
+## What It Does
+
+- Runs automatically when Strapi starts
+- Finds the "Public" role
+- Enables \`find\` and \`findOne\` permissions for all API content types
+- Allows unauthenticated users to read published content
+- Fixes 403 Forbidden errors from \`useStrapiContent\`
+
+## Manual Alternative
+
+If you prefer to set permissions manually:
+
+1. Open Strapi admin: http://localhost:1337/admin
+2. Go to: Settings \u2192 Users & Permissions Plugin \u2192 Roles \u2192 Public
+3. For each content type, check:
+   - \u2705 find
+   - \u2705 findOne
+4. Click Save
+
+## Notes
+
+- Only enables READ permissions (find, findOne)
+- Does NOT enable write permissions (create, update, delete)
+- Only affects the "Public" role (unauthenticated users)
+- Safe to run multiple times (idempotent)
+`;
+  const readmePath = path4.join(strapiBootstrapDir, "README.md");
+  await fs3.writeFile(readmePath, readmeContent, "utf-8");
+  console.log("  \u2713 Generated Strapi bootstrap file");
+}
+async function createPublishEndpoint(outputDir) {
+  const serverDir = path4.join(outputDir, "server", "api", "cms");
+  await fs3.ensureDir(serverDir);
+  const endpointContent = `/**
+ * API endpoint for batch publishing CMS changes
+ * Publishes all drafts at once
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export default defineEventHandler(async (event) => {
+  // Get Strapi URL from runtime config
+  const config = useRuntimeConfig();
+  const strapiUrl = config.public.strapiUrl || 'http://localhost:1337';
+
+  // Extract Authorization header
+  const authHeader = getHeader(event, 'authorization');
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: 'Unauthorized: Missing or invalid authorization header',
+    });
+  }
+
+  const token = authHeader.substring(7); // Remove 'Bearer ' prefix
+
+  // Verify token with Strapi and determine if it's an admin or user token
+  let userResponse: any;
+  let isAdminToken = false;
+
+  try {
+    // Try admin token verification first
+    try {
+      userResponse = await $fetch(\`\${strapiUrl}/admin/users/me\`, {
+        headers: {
+          Authorization: \`Bearer \${token}\`,
+        },
+      });
+      isAdminToken = true;
+    } catch (adminError) {
+      // Fallback to regular user token verification
+      userResponse = await $fetch(\`\${strapiUrl}/api/users/me\`, {
+        headers: {
+          Authorization: \`Bearer \${token}\`,
+        },
+      });
+      isAdminToken = false;
+    }
+
+    // Get the request body
+    const body = await readBody(event);
+    const { pages } = body;
+
+    if (!pages || !Array.isArray(pages)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'Bad Request: Missing or invalid pages array',
+      });
+    }
+
+    // Load manifest to understand field mappings
+    const manifestPath = path.join(process.cwd(), 'cms-manifest.json');
+    let manifest;
+    try {
+      const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+      manifest = JSON.parse(manifestContent);
+    } catch (error) {
+      console.error('Failed to load manifest:', error);
+      throw createError({
+        statusCode: 500,
+        statusMessage: 'Failed to load CMS manifest',
+      });
+    }
+
+    // Process all pages - call Strapi directly
+    const results = await Promise.allSettled(
+      pages.map(async ({ page, fields }) => {
+        try {
+          // Get page configuration from manifest
+          const pageConfig = manifest.pages[page];
+          if (!pageConfig) {
+            throw new Error(\`Page "\${page}" not found in manifest\`);
+          }
+
+          // Transform fields to Strapi format
+          const strapiData: Record<string, any> = {};
+          for (const [fieldName, value] of Object.entries(fields)) {
+            const fieldConfig = pageConfig.fields[fieldName];
+            if (!fieldConfig) {
+              console.warn(\`Field "\${fieldName}" not found in manifest for page "\${page}"\`);
+              continue;
+            }
+
+            // Handle different field types
+            if (fieldConfig.type === 'image') {
+              // TODO: Handle image uploads - for now just store the value
+              strapiData[fieldName] = value;
+            } else {
+              strapiData[fieldName] = value;
+            }
+          }
+
+          // Update Strapi v5 content - use different endpoints for admin vs user tokens
+          if (isAdminToken) {
+            // Admin tokens use the content-manager API (Strapi v5)
+            const contentEndpoint = \`\${strapiUrl}/content-manager/single-types/api::\${page}.\${page}\`;
+
+            // Step 1: Update the content
+            await $fetch(contentEndpoint, {
+              method: 'PUT',
+              headers: {
+                'Authorization': \`Bearer \${token}\`,
+                'Content-Type': 'application/json',
+              },
+              body: strapiData,
+            });
+
+            // Step 2: Publish the content (Strapi v5)
+            const publishEndpoint = \`\${strapiUrl}/content-manager/single-types/api::\${page}.\${page}/actions/publish\`;
+            await $fetch(publishEndpoint, {
+              method: 'POST',
+              headers: {
+                'Authorization': \`Bearer \${token}\`,
+                'Content-Type': 'application/json',
+              },
+              body: {},
+            });
+          } else {
+            // User tokens use the regular REST API
+            const strapiEndpoint = \`\${strapiUrl}/api/\${page}\`;
+
+            await $fetch(strapiEndpoint, {
+              method: 'PUT',
+              headers: {
+                'Authorization': \`Bearer \${token}\`,
+                'Content-Type': 'application/json',
+              },
+              body: {
+                data: strapiData,
+              },
+            });
+
+            // Publish using the publish endpoint (Strapi v5)
+            const publishEndpoint = \`\${strapiUrl}/api/\${page}/publish\`;
+            await $fetch(publishEndpoint, {
+              method: 'POST',
+              headers: {
+                'Authorization': \`Bearer \${token}\`,
+                'Content-Type': 'application/json',
+              },
+              body: {},
+            });
+          }
+
+          console.log(\`[CMS Publish] Published "\${page}" to Strapi\`);
+          return { page, success: true };
+        } catch (error: any) {
+          console.error(\`[CMS Publish] Failed to publish "\${page}":\`, error);
+          return {
+            page,
+            success: false,
+            error: error.message || 'Unknown error',
+          };
+        }
+      })
+    );
+
+    // Separate successful and failed publications
+    const successful: string[] = [];
+    const failed: Array<{ page: string; error: string }> = [];
+
+    results.forEach((result, index) => {
+      if (result.status === 'fulfilled' && result.value.success) {
+        successful.push(result.value.page);
+      } else if (result.status === 'fulfilled' && !result.value.success) {
+        failed.push({
+          page: result.value.page,
+          error: result.value.error || 'Unknown error',
+        });
+      } else if (result.status === 'rejected') {
+        failed.push({
+          page: pages[index].page,
+          error: result.reason?.message || 'Unknown error',
+        });
+      }
+    });
+
+    console.log(\`[CMS Publish] Published \${successful.length} pages, \${failed.length} failed\`);
+
+    return {
+      success: failed.length === 0,
+      message: \`Published \${successful.length} of \${pages.length} pages\`,
+      successful,
+      failed,
+      user: {
+        id: userResponse.id,
+        username: userResponse.username || userResponse.firstname || 'Unknown',
+      },
+    };
+  } catch (error: any) {
+    console.error('[CMS Publish] Error:', error);
+
+    // Token verification failed
+    if (error.statusCode === 401 || error.status === 401) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: 'Unauthorized: Invalid or expired token',
+      });
+    }
+
+    // Generic error
+    throw createError({
+      statusCode: 500,
+      statusMessage: 'Internal server error while publishing changes',
+    });
+  }
+});
+`;
+  const endpointPath = path4.join(serverDir, "publish.post.ts");
+  await fs3.writeFile(endpointPath, endpointContent, "utf-8");
+}
+
+// src/boilerplate.ts
+import fs4 from "fs-extra";
+import path5 from "path";
+import { execSync as execSync2 } from "child_process";
+import pc2 from "picocolors";
+function isGitHubURL(source) {
+  return source.startsWith("https://github.com/") || source.startsWith("git@github.com:") || source.includes("github.com");
+}
+async function cloneFromGitHub(repoUrl, outputDir) {
+  console.log(pc2.blue("  Cloning from GitHub..."));
+  try {
+    execSync2(`git clone ${repoUrl} ${outputDir}`, { stdio: "inherit" });
+    const gitDir = path5.join(outputDir, ".git");
+    await fs4.remove(gitDir);
+    console.log(pc2.green("  \u2713 Boilerplate cloned successfully"));
+  } catch (error) {
+    throw new Error(`Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function copyFromLocal(sourcePath, outputDir) {
+  console.log(pc2.blue("  Copying from local path..."));
+  const sourceExists = await fs4.pathExists(sourcePath);
+  if (!sourceExists) {
+    throw new Error(`Local boilerplate not found: ${sourcePath}`);
+  }
+  await fs4.copy(sourcePath, outputDir, {
+    filter: (src) => {
+      const name = path5.basename(src);
+      return !["node_modules", ".nuxt", ".output", ".git", "dist"].includes(name);
+    }
+  });
+  console.log(pc2.green("  \u2713 Boilerplate copied successfully"));
+}
+async function setupBoilerplate(boilerplateSource, outputDir) {
+  if (!boilerplateSource) {
+    console.log(pc2.blue("\n\u{1F4E6} Creating minimal Nuxt structure..."));
+    await fs4.ensureDir(outputDir);
+    await fs4.ensureDir(path5.join(outputDir, "pages"));
+    await fs4.ensureDir(path5.join(outputDir, "assets"));
+    await fs4.ensureDir(path5.join(outputDir, "public"));
+    await fs4.ensureDir(path5.join(outputDir, "utils"));
+    const configPath = path5.join(outputDir, "nuxt.config.ts");
+    const configExists = await fs4.pathExists(configPath);
+    if (!configExists) {
+      const basicConfig = `export default defineNuxtConfig({
+  devtools: { enabled: true },
+  css: [],
+})
+`;
+      await fs4.writeFile(configPath, basicConfig, "utf-8");
+    }
+    console.log(pc2.green("  \u2713 Structure created"));
+    return;
+  }
+  const outputExists = await fs4.pathExists(outputDir);
+  if (outputExists) {
+    throw new Error(`Output directory already exists: ${outputDir}. Please choose a different path or remove it first.`);
+  }
+  console.log(pc2.blue("\n\u{1F4E6} Setting up boilerplate..."));
+  if (isGitHubURL(boilerplateSource)) {
+    await cloneFromGitHub(boilerplateSource, outputDir);
+  } else {
+    await copyFromLocal(boilerplateSource, outputDir);
+  }
+}
+
+// src/manifest.ts
+import fs6 from "fs-extra";
+import path7 from "path";
+
+// src/detector.ts
+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).join(" ");
+}
+function getPrimaryClass(classAttr) {
+  if (!classAttr) return null;
+  const cleaned = cleanClassName(classAttr);
+  const classes = cleaned.split(" ").filter((c) => c.length > 0);
+  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();
+  let depth = 0;
+  while ($current.length > 0 && depth < 5) {
+    const classes = $current.attr("class");
+    if (classes) {
+      const ccClass = classes.split(" ").find((c) => c.startsWith("cc-"));
+      if (ccClass) {
+        return ccClass.replace("cc-", "").replace(/-/g, "_");
+      }
+    }
+    $current = $current.parent();
+    depth++;
+  }
+  return null;
+}
+function isDecorativeImage(_$, $img) {
+  const $parent = $img.parent();
+  const parentClass = $parent.attr("class") || "";
+  const decorativePatterns = [
+    "nav",
+    "logo",
+    "icon",
+    "arrow",
+    "button",
+    "quote",
+    "pagination",
+    "footer",
+    "link"
+  ];
+  return decorativePatterns.some(
+    (pattern) => parentClass.includes(pattern) || parentClass.includes(`${pattern}_`)
+  );
+}
+function isInsideButton($, el) {
+  const $el = $(el);
+  const $button = $el.closest("button, a, NuxtLink, .c_button, .c_icon_button");
+  return $button.length > 0;
+}
+function extractTemplateFromVue(vueContent) {
+  const templateMatch = vueContent.match(/<template>([\s\S]*?)<\/template>/);
+  if (!templateMatch) {
+    return "";
+  }
+  return templateMatch[1];
+}
+function detectEditableFields(templateHtml) {
+  const $ = cheerio2.load(templateHtml);
+  const detectedFields = {};
+  const detectedCollections = {};
+  const collectionElements = /* @__PURE__ */ new Set();
+  const processedCollectionClasses = /* @__PURE__ */ new Set();
+  const potentialCollections = /* @__PURE__ */ new Map();
+  $("[class]").each((_, el) => {
+    const primaryClass = getPrimaryClass($(el).attr("class"));
+    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.fieldName)?.push(el);
+    }
+  });
+  potentialCollections.forEach((elements, className) => {
+    if (elements.length >= 2) {
+      const $first = $(elements[0]);
+      const collectionFields = {};
+      processedCollectionClasses.add(className);
+      elements.forEach((el) => {
+        collectionElements.add(el);
+        $(el).find("*").each((_, child) => {
+          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 parentClassInfo = getPrimaryClass($parent.attr("class"));
+        if (parentClassInfo && parentClassInfo.fieldName.includes("image")) {
+          collectionFields.image = `.${parentClassInfo.selector}`;
+          return false;
+        }
+      });
+      $first.find("div").each((_, el) => {
+        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 classInfo = getPrimaryClass($(el).attr("class"));
+        if (classInfo) {
+          collectionFields.title = `.${classInfo.selector}`;
+        }
+      });
+      $first.find("p").first().each((_, el) => {
+        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) {
+          const classInfo = getPrimaryClass($link.attr("class"));
+          collectionFields.link = classInfo ? `.${classInfo.selector}` : "a";
+          return false;
+        }
+      });
+      if (Object.keys(collectionFields).length > 0) {
+        let collectionName = className;
+        if (!collectionName.endsWith("s")) {
+          collectionName += "s";
+        }
+        detectedCollections[collectionName] = {
+          selector: collectionSelector,
+          fields: collectionFields
+        };
+      }
+    }
+  });
+  const $body = $("body");
+  $body.find("h1, h2, h3, h4, h5, h6").each((index, el) => {
+    if (collectionElements.has(el)) return;
+    const $el = $(el);
+    const text = $el.text().trim();
+    const classInfo = getPrimaryClass($el.attr("class"));
+    if (text) {
+      let fieldName;
+      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 parentClassInfo = getPrimaryClass($parent.attr("class"));
+        const modifier = getContextModifier($, $el);
+        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,
+        type: "plain",
+        editable: true
+      };
+    }
+  });
+  $body.find("p").each((_index, el) => {
+    if (collectionElements.has(el)) return;
+    const $el = $(el);
+    const text = $el.text().trim();
+    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[classInfo.fieldName] = {
+        selector: `.${classInfo.selector}`,
+        type: hasFormatting ? "rich" : "plain",
+        editable: true
+      };
+    }
+  });
+  $body.find("img").each((_index, el) => {
+    if (collectionElements.has(el)) return;
+    if (isInsideButton($, el)) return;
+    const $el = $(el);
+    if (isDecorativeImage($, $el)) return;
+    const $parent = $el.parent();
+    const parentClassInfo = getPrimaryClass($parent.attr("class"));
+    if (parentClassInfo) {
+      const fieldName = parentClassInfo.fieldName.includes("image") ? parentClassInfo.fieldName : `${parentClassInfo.fieldName}_image`;
+      detectedFields[fieldName] = {
+        selector: `.${parentClassInfo.selector}`,
+        type: "image",
+        editable: true
+      };
+    }
+  });
+  $body.find("NuxtLink.c_button, a.c_button, .c_button").each((_index, el) => {
+    if (collectionElements.has(el)) return;
+    const $el = $(el);
+    const text = $el.contents().filter(function() {
+      return this.type === "text" || this.type === "tag" && this.name === "div";
+    }).first().text().trim();
+    if (text && text.length > 2) {
+      const $parent = $el.closest('[class*="cta"]').first();
+      const parentClassInfo = getPrimaryClass($parent.attr("class"));
+      const fieldName = parentClassInfo ? `${parentClassInfo.fieldName}_button_text` : "button_text";
+      detectedFields[fieldName] = {
+        selector: `.c_button`,
+        type: "plain",
+        editable: true
+      };
+    }
+  });
+  return {
+    fields: detectedFields,
+    collections: detectedCollections
+  };
+}
+async function analyzeVuePages(pagesDir) {
+  const results = {};
+  const vueFiles = await fs5.readdir(pagesDir);
+  for (const file of vueFiles) {
+    if (file.endsWith(".vue")) {
+      const filePath = path6.join(pagesDir, file);
+      const content = await fs5.readFile(filePath, "utf-8");
+      const template = extractTemplateFromVue(content);
+      if (template) {
+        const pageName = file.replace(".vue", "");
+        results[pageName] = detectEditableFields(template);
+      }
+    }
+  }
+  return results;
+}
+
+// src/manifest.ts
+async function generateManifest(pagesDir) {
+  const analyzed = await analyzeVuePages(pagesDir);
+  const pages = {};
+  for (const [pageName, detection] of Object.entries(analyzed)) {
+    pages[pageName] = {
+      fields: detection.fields,
+      collections: detection.collections,
+      meta: {
+        route: pageName === "index" ? "/" : `/${pageName}`
+      }
+    };
+  }
+  const manifest = {
+    version: "1.0",
+    pages
+  };
+  return manifest;
+}
+async function writeManifest(outputDir, manifest) {
+  const manifestContent = JSON.stringify(manifest, null, 2);
+  const manifestPath = path7.join(outputDir, "cms-manifest.json");
+  await fs6.writeFile(manifestPath, manifestContent, "utf-8");
+  const publicDir = path7.join(outputDir, "public");
+  await fs6.ensureDir(publicDir);
+  const publicManifestPath = path7.join(publicDir, "cms-manifest.json");
+  await fs6.writeFile(publicManifestPath, manifestContent, "utf-8");
+}
+
+// src/vue-transformer.ts
+import * as cheerio3 from "cheerio";
+import fs7 from "fs-extra";
+import path8 from "path";
+function replaceWithBinding(_$, $el, fieldName, type) {
+  if (type === "image") {
+    const $img = $el.find("img").first();
+    if ($img.length) {
+      $img.attr(":src", `content.${fieldName}`);
+      $img.removeAttr("src");
+    }
+  } else if (type === "rich") {
+    $el.attr("v-html", `content.${fieldName}`);
+    $el.empty();
+  } else {
+    $el.empty();
+    $el.text(`{{ content.${fieldName} }}`);
+  }
+}
+function transformCollection($, collectionName, collection) {
+  const $items = $(collection.selector);
+  if ($items.length === 0) return;
+  const $first = $items.first();
+  $first.attr("v-for", `(item, index) in content.${collectionName}`);
+  $first.attr(":key", "index");
+  Object.entries(collection.fields).forEach(([fieldName, selector]) => {
+    const $fieldEl = $first.find(selector);
+    if ($fieldEl.length) {
+      if (fieldName === "image") {
+        const $img = $fieldEl.find("img").first();
+        if ($img.length) {
+          $img.attr(":src", "item.image");
+          $img.removeAttr("src");
+        }
+      } else if (fieldName === "link") {
+        $fieldEl.attr(":to", "item.link");
+        $fieldEl.removeAttr("to");
+        $fieldEl.removeAttr("href");
+      } else {
+        $fieldEl.empty();
+        $fieldEl.text(`{{ item.${fieldName} }}`);
+      }
+    }
+  });
+  $items.slice(1).remove();
+}
+async function transformVueToReactive(vueFilePath, pageName, manifest) {
+  const pageManifest = manifest.pages[pageName];
+  if (!pageManifest) return;
+  const vueContent = await fs7.readFile(vueFilePath, "utf-8");
+  if (vueContent.includes("useStrapiContent")) {
+    console.log(`  Skipping ${pageName} - already transformed`);
+    return;
+  }
+  const templateMatch = vueContent.match(/<template>([\s\S]*?)<\/template>/);
+  if (!templateMatch) return;
+  const templateContent = templateMatch[1];
+  const $ = cheerio3.load(templateContent, { xmlMode: false });
+  if (pageManifest.collections) {
+    Object.entries(pageManifest.collections).forEach(([collectionName, collection]) => {
+      transformCollection($, collectionName, collection);
+    });
+  }
+  if (pageManifest.fields) {
+    Object.entries(pageManifest.fields).forEach(([fieldName, field]) => {
+      const $elements = $(field.selector);
+      $elements.each((_, el) => {
+        const $el = $(el);
+        replaceWithBinding($, $el, fieldName, field.type);
+      });
+    });
+  }
+  let transformedTemplate = $.html();
+  const bodyMatch = transformedTemplate.match(/<body>([\s\S]*)<\/body>/);
+  if (bodyMatch) {
+    transformedTemplate = bodyMatch[1];
+  }
+  transformedTemplate = transformedTemplate.replace(/<\/?html[^>]*>/gi, "").replace(/<head><\/head>/gi, "").trim();
+  const wrapperDivMatch = transformedTemplate.match(/^<div>\s*([\s\S]*?)\s*<\/div>$/);
+  if (wrapperDivMatch) {
+    transformedTemplate = wrapperDivMatch[1].trim();
+  }
+  const scriptSetup = `<script setup lang="ts">
+// Auto-generated reactive content from Strapi
+const { content } = useStrapiContent('${pageName}');
+</script>`;
+  const finalTemplate = transformedTemplate.split("\n").map((line) => "  " + line).join("\n");
+  const newVueContent = `${scriptSetup}
+
+<template>
+${finalTemplate}
+</template>
+`;
+  await fs7.writeFile(vueFilePath, newVueContent, "utf-8");
+}
+async function transformAllVuePages(pagesDir, manifest) {
+  const vueFiles = await fs7.readdir(pagesDir);
+  for (const file of vueFiles) {
+    if (file.endsWith(".vue")) {
+      const pageName = file.replace(".vue", "");
+      const vueFilePath = path8.join(pagesDir, file);
+      await transformVueToReactive(vueFilePath, pageName, manifest);
+    }
+  }
+}
+
+// src/transformer.ts
+function mapFieldTypeToStrapi(fieldType) {
+  const typeMap = {
+    plain: "string",
+    rich: "richtext",
+    html: "richtext",
+    image: "media",
+    link: "string",
+    email: "email",
+    phone: "string"
+  };
+  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)) {
+    attributes[fieldName] = {
+      type: mapFieldTypeToStrapi(field.type),
+      required: field.required || false
+    };
+    if (field.default) {
+      attributes[fieldName].default = field.default;
+    }
+  }
+  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: kebabCaseName,
+    info: {
+      singularName: kebabCaseName,
+      pluralName,
+      displayName
+    },
+    options: {
+      draftAndPublish: true
+    },
+    attributes
+  };
+}
+function collectionToStrapiSchema(collectionName, collection) {
+  const attributes = {};
+  for (const [fieldName, _selector] of Object.entries(collection.fields)) {
+    let type = "string";
+    if (fieldName === "image" || fieldName.includes("image")) {
+      type = "media";
+    } else if (fieldName === "description" || fieldName === "content") {
+      type = "richtext";
+    } else if (fieldName === "link" || fieldName === "url") {
+      type = "string";
+    } else if (fieldName === "title" || fieldName === "tag") {
+      type = "string";
+    }
+    attributes[fieldName] = {
+      type
+    };
+  }
+  const displayName = collectionName.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const kebabCaseName = collectionName.replace(/_/g, "-");
+  const singularName = kebabCaseName.endsWith("s") ? kebabCaseName.slice(0, -1) : kebabCaseName;
+  return {
+    kind: "collectionType",
+    collectionName: kebabCaseName,
+    info: {
+      singularName,
+      pluralName: kebabCaseName,
+      displayName
+    },
+    options: {
+      draftAndPublish: true
+    },
+    attributes
+  };
+}
+function manifestToSchemas(manifest) {
+  const schemas = {};
+  for (const [pageName, page] of Object.entries(manifest.pages)) {
+    if (page.fields && Object.keys(page.fields).length > 0) {
+      schemas[pageName] = pageToStrapiSchema(pageName, page.fields);
+    }
+    if (page.collections) {
+      for (const [collectionName, collection] of Object.entries(page.collections)) {
+        schemas[collectionName] = collectionToStrapiSchema(collectionName, collection);
+      }
+    }
+  }
+  return schemas;
+}
+
+// src/schema-writer.ts
+import fs8 from "fs-extra";
+import path9 from "path";
+async function writeStrapiSchema(outputDir, name, schema) {
+  const schemasDir = path9.join(outputDir, "cms-schemas");
+  await fs8.ensureDir(schemasDir);
+  const schemaPath = path9.join(schemasDir, `${name}.json`);
+  await fs8.writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf-8");
+}
+async function writeAllSchemas(outputDir, schemas) {
+  for (const [name, schema] of Object.entries(schemas)) {
+    await writeStrapiSchema(outputDir, name, schema);
+  }
+}
+async function createStrapiReadme(outputDir) {
+  const readmePath = path9.join(outputDir, "cms-schemas", "README.md");
+  const content = `# CMS Schemas
+
+Auto-generated Strapi content type schemas from your Webflow export.
+
+## What's in this folder?
+
+Each \`.json\` file is a Strapi content type schema:
+
+- **Pages** (single types) - Unique pages like \`index.json\`, \`about.json\`
+- **Collections** (collection types) - Repeating content like \`portfolio_cards.json\`
+
+## How to use with Strapi
+
+### Option 1: Manual Setup (Recommended for learning)
+
+1. Start your Strapi project
+2. In Strapi admin, go to **Content-Type Builder**
+3. Create each content type manually using these schemas as reference
+4. Match the field names and types
+
+### Option 2: Automated Setup (Advanced)
+
+Copy schemas to your Strapi project structure:
+
+\`\`\`bash
+# For each schema file, create the Strapi directory structure
+# Example for index.json (single type):
+mkdir -p strapi/src/api/index/content-types/index
+cp cms-schemas/index.json strapi/src/api/index/content-types/index/schema.json
+
+# Example for portfolio_cards.json (collection type):
+mkdir -p strapi/src/api/portfolio-cards/content-types/portfolio-card
+cp cms-schemas/portfolio_cards.json strapi/src/api/portfolio-cards/content-types/portfolio-card/schema.json
+\`\`\`
+
+Then restart Strapi - it will auto-create the content types.
+
+## Schema Structure
+
+Each schema defines:
+- \`kind\`: "singleType" (unique page) or "collectionType" (repeating)
+- \`attributes\`: Fields and their types (string, richtext, media, etc.)
+- \`displayName\`: How it appears in Strapi admin
+
+## Field Types
+
+- \`string\` - Plain text
+- \`richtext\` - Formatted text with HTML
+- \`media\` - Image uploads
+
+## Next Steps
+
+1. Set up a Strapi project: \`npx create-strapi-app@latest my-strapi\`
+2. Use these schemas to create content types
+3. Populate content in Strapi admin
+4. Connect your Nuxt app to Strapi API
+
+## API Usage in Nuxt
+
+Once Strapi is running with these content types:
+
+\`\`\`typescript
+// Fetch single type (e.g., home page)
+const { data } = await $fetch('http://localhost:1337/api/index')
+
+// Fetch collection type (e.g., portfolio cards)
+const { data } = await $fetch('http://localhost:1337/api/portfolio-cards')
+\`\`\`
+`;
+  await fs8.writeFile(readmePath, content, "utf-8");
+}
+
+// src/content-extractor.ts
+import * as cheerio4 from "cheerio";
+import path10 from "path";
+function extractContentFromHTML(html, _pageName, pageManifest) {
+  const $ = cheerio4.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 = path10.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 fs9 from "fs-extra";
+import path11 from "path";
+async function writeSeedData(outputDir, seedData) {
+  const seedDir = path11.join(outputDir, "cms-seed");
+  await fs9.ensureDir(seedDir);
+  const seedPath = path11.join(seedDir, "seed-data.json");
+  await fs9.writeJson(seedPath, seedData, { spaces: 2 });
+}
+async function createSeedReadme(outputDir) {
+  const readmePath = path11.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 fs9.writeFile(readmePath, content, "utf-8");
+}
+
+// src/converter.ts
+async function convertWebflowExport(options) {
+  const { inputDir, outputDir, boilerplate } = options;
+  console.log(pc3.cyan("\u{1F680} Starting Webflow to Nuxt conversion..."));
+  console.log(pc3.dim(`Input: ${inputDir}`));
+  console.log(pc3.dim(`Output: ${outputDir}`));
+  try {
+    await setupBoilerplate(boilerplate, outputDir);
+    const inputExists = await fs10.pathExists(inputDir);
+    if (!inputExists) {
+      throw new Error(`Input directory not found: ${inputDir}`);
+    }
+    console.log(pc3.blue("\n\u{1F4C2} Scanning assets..."));
+    const assets = await scanAssets(inputDir);
+    console.log(pc3.green(`  \u2713 Found ${assets.css.length} CSS files`));
+    console.log(pc3.green(`  \u2713 Found ${assets.images.length} images`));
+    console.log(pc3.green(`  \u2713 Found ${assets.fonts.length} fonts`));
+    console.log(pc3.green(`  \u2713 Found ${assets.js.length} JS files`));
+    console.log(pc3.blue("\n\u{1F4E6} Copying assets..."));
+    await copyAllAssets(inputDir, outputDir, assets);
+    console.log(pc3.green("  \u2713 Assets copied successfully"));
+    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 = htmlContentMap.get(htmlFile.replace(".html", "").replace(/\//g, "-"));
+      const parsed = parseHTML(html, htmlFile);
+      if (parsed.embeddedStyles) {
+        allEmbeddedStyles += `
+/* From ${htmlFile} */
+${parsed.embeddedStyles}
+`;
+      }
+      const transformed = transformForNuxt(parsed.htmlContent);
+      const pageName = htmlFile.replace(".html", "").replace(/\//g, "-");
+      const vueComponent = htmlToVueComponent(transformed, pageName);
+      await writeVueComponent(outputDir, htmlFile, vueComponent);
+      console.log(pc3.green(`  \u2713 Created ${htmlFile.replace(".html", ".vue")}`));
+    }
+    await formatVueFiles(outputDir);
+    console.log(pc3.blue("\n\u{1F50D} Analyzing pages for CMS fields..."));
+    const pagesDir = path12.join(outputDir, "pages");
+    const manifest = await generateManifest(pagesDir);
+    await writeManifest(outputDir, manifest);
+    const totalFields = Object.values(manifest.pages).reduce(
+      (sum, page) => sum + Object.keys(page.fields || {}).length,
+      0
+    );
+    const totalCollections = Object.values(manifest.pages).reduce(
+      (sum, page) => sum + Object.keys(page.collections || {}).length,
+      0
+    );
+    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\u26A1 Transforming Vue files to reactive templates..."));
+    await transformAllVuePages(pagesDir, manifest);
+    console.log(pc3.green(`  \u2713 Transformed ${Object.keys(manifest.pages).length} pages to use Vue template syntax`));
+    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: cms-schemas/"));
+    if (allEmbeddedStyles.trim()) {
+      console.log(pc3.blue("\n\u2728 Writing embedded styles..."));
+      const dedupedStyles = deduplicateStyles(allEmbeddedStyles);
+      await writeEmbeddedStyles(outputDir, dedupedStyles);
+      console.log(pc3.green("  \u2713 Embedded styles added to main.css"));
+    }
+    console.log(pc3.blue("\n\u{1F527} Generating webflow-assets.ts plugin..."));
+    await writeWebflowAssetPlugin(outputDir, assets.css);
+    console.log(pc3.green("  \u2713 Plugin generated (existing file overwritten)"));
+    console.log(pc3.blue("\n\u2699\uFE0F  Updating nuxt.config.ts..."));
+    try {
+      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.dim("    Please add CSS files manually"));
+    }
+    console.log(pc3.blue("\n\u{1F3A8} Setting up editor overlay..."));
+    await createEditorPlugin(outputDir);
+    await createEditorContentComposable(outputDir);
+    await createStrapiContentComposable(outputDir);
+    await addEditorDependency(outputDir);
+    await createSaveEndpoint(outputDir);
+    await createPublishEndpoint(outputDir);
+    await createStrapiBootstrap(outputDir);
+    await addStrapiUrlToConfig(outputDir);
+    console.log(pc3.green("  \u2713 Editor plugin created"));
+    console.log(pc3.green("  \u2713 Editor content composable created"));
+    console.log(pc3.green("  \u2713 Strapi content composable created"));
+    console.log(pc3.green("  \u2713 Editor dependency added"));
+    console.log(pc3.green("  \u2713 Save endpoint created"));
+    console.log(pc3.green("  \u2713 Publish endpoint created"));
+    console.log(pc3.green("  \u2713 Strapi bootstrap file generated"));
+    console.log(pc3.green("  \u2713 Strapi config added"));
+    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 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. Copy strapi-bootstrap/index.ts to your Strapi project at src/index.ts"));
+    console.log(pc3.dim("     (This auto-enables public read permissions on Strapi startup)"));
+    console.log(pc3.dim("  5. Seed Strapi with data from cms-seed/"));
+    console.log(pc3.dim("  6. pnpm install && pnpm dev"));
+    console.log(pc3.dim("  7. 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)));
+    throw error;
+  }
+}
+
+// src/strapi-setup.ts
+import fs11 from "fs-extra";
+import path13 from "path";
+import { glob as glob2 } from "glob";
+import * as readline from "readline";
+var ENV_FILE = ".env";
+async function loadConfig(projectDir) {
+  const envPath = path13.join(projectDir, ENV_FILE);
+  if (await fs11.pathExists(envPath)) {
+    try {
+      const content = await fs11.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 = path13.join(projectDir, ENV_FILE);
+  let content = "";
+  if (await fs11.pathExists(envPath)) {
+    content = await fs11.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 fs11.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 fs11.pathExists(strapiDir)) {
+    console.error(`   \u2717 Strapi directory not found: ${strapiDir}`);
+    console.error(`   Resolved to: ${path13.resolve(strapiDir)}`);
+    throw new Error(`Strapi directory not found: ${strapiDir}`);
+  }
+  const packageJsonPath = path13.join(strapiDir, "package.json");
+  if (await fs11.pathExists(packageJsonPath)) {
+    const pkg = await fs11.readJson(packageJsonPath);
+    if (!pkg.dependencies?.["@strapi/strapi"]) {
+      console.warn(`   \u26A0\uFE0F  Warning: ${strapiDir} may not be a Strapi project`);
+    }
+  }
+  const schemaDir = path13.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 = path13.join(schemaDir, file);
+    const schema = await fs11.readJson(schemaPath);
+    const singularName = schema.info?.singularName || path13.basename(file, ".json");
+    console.log(`   Installing ${singularName}...`);
+    try {
+      const apiPath = path13.join(strapiDir, "src", "api", singularName);
+      const contentTypesPath = path13.join(
+        apiPath,
+        "content-types",
+        singularName
+      );
+      const targetPath = path13.join(contentTypesPath, "schema.json");
+      await fs11.ensureDir(contentTypesPath);
+      await fs11.ensureDir(path13.join(apiPath, "routes"));
+      await fs11.ensureDir(path13.join(apiPath, "controllers"));
+      await fs11.ensureDir(path13.join(apiPath, "services"));
+      await fs11.writeJson(targetPath, schema, { spaces: 2 });
+      const routeContent = `import { factories } from '@strapi/strapi';
+         export default factories.createCoreRouter('api::${singularName}.${singularName}');
+        `;
+      await fs11.writeFile(
+        path13.join(apiPath, "routes", `${singularName}.ts`),
+        routeContent
+      );
+      const controllerContent = `import { factories } from '@strapi/strapi';
+         export default factories.createCoreController('api::${singularName}.${singularName}');
+        `;
+      await fs11.writeFile(
+        path13.join(apiPath, "controllers", `${singularName}.ts`),
+        controllerContent
+      );
+      const serviceContent = `import { factories } from '@strapi/strapi';
+         export default factories.createCoreService('api::${singularName}.${singularName}');
+        `;
+      await fs11.writeFile(
+        path13.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 = path13.join(projectDir, "public", "assets", "images");
+  if (!await fs11.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 = path13.basename(imageFile);
+    const existingId = existingMedia.get(fileName);
+    if (existingId) {
+      mediaMap.set(`/images/${imageFile}`, existingId);
+      mediaMap.set(imageFile, existingId);
+      skippedCount++;
+      continue;
+    }
+    const imagePath = path13.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 fs11.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 = path13.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 = path13.join(projectDir, "cms-seed", "seed-data.json");
+  if (!await fs11.pathExists(seedPath)) {
+    console.log("   No seed data found");
+    return;
+  }
+  const seedData = await fs11.readJson(seedPath);
+  const schemasDir = path13.join(projectDir, "cms-schemas");
+  const schemas = /* @__PURE__ */ new Map();
+  const schemaFiles = await glob2("*.json", { cwd: schemasDir });
+  for (const file of schemaFiles) {
+    const schema = await fs11.readJson(path13.join(schemasDir, file));
+    const name = path13.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();
+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,
+      outputDir: output,
+      boilerplate: options.boilerplate,
+      overridesPath: options.overrides,
+      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("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 fs12.pathExists(manifestPath);
+    if (!manifestExists) {
+      throw new Error(`Manifest file not found: ${manifestPath}`);
+    }
+    const manifestContent = await fs12.readFile(manifestPath, "utf-8");
+    const manifest = JSON.parse(manifestContent);
+    console.log(pc4.green(`  \u2713 Manifest loaded successfully`));
+    const outputDir = options.output || path14.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: ${path14.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