@sonordev/site-kit 1.2.7

package/dist/chunk-24277A3Q.mjs

@@ -0,0 +1,968 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+// src/cli/migrator/index.ts
+function addImportSafely(content, importStatement) {
+  const importModule = importStatement.match(/from\s+['"]([^'"]+)['"]/)?.[1];
+  if (importModule && content.includes(importModule)) {
+    return content;
+  }
+  const directiveMatch = content.match(/^(['"]use (client|server)['"][\s;]*\n?)/);
+  if (directiveMatch) {
+    const directive = directiveMatch[0];
+    const restOfFile = content.slice(directive.length);
+    const firstImportMatch = restOfFile.match(/^(import\s+)/);
+    if (firstImportMatch) {
+      return directive + importStatement + "\n" + restOfFile;
+    } else {
+      return directive + importStatement + "\n" + restOfFile;
+    }
+  } else {
+    const firstImportMatch = content.match(/^(import\s+)/);
+    if (firstImportMatch) {
+      return importStatement + "\n" + content;
+    } else {
+      return importStatement + "\n\n" + content;
+    }
+  }
+}
+function isClientComponent(content) {
+  const firstLines = content.split("\n").slice(0, 5).join("\n");
+  return /['"]use client['"]/.test(firstLines);
+}
+function addToExistingImport(content, namedExport, modulePath) {
+  const importPattern = new RegExp(
+    `(import\\s*\\{[^}]*)\\}\\s*from\\s*['"]${modulePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`,
+    "g"
+  );
+  if (importPattern.test(content)) {
+    importPattern.lastIndex = 0;
+    return content.replace(importPattern, (match, imports) => {
+      if (imports.includes(namedExport)) {
+        return match;
+      }
+      return `${imports.trim()}, ${namedExport} } from '${modulePath}'`;
+    });
+  }
+  return content;
+}
+function insertManagedSchemaIntoJSX(content, pagePath, isTypeScript) {
+  if (content.includes("<ManagedSchema")) {
+    return content;
+  }
+  const projectIdSuffix = isTypeScript ? "!" : "";
+  const schemaComponent = `<ManagedSchema
+        projectId={process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${projectIdSuffix}}
+        path="${pagePath}"
+      />`;
+  const returnPatterns = [
+    // return (<> ... - fragment
+    /return\s*\(\s*<>/,
+    // return ( <Fragment> ...
+    /return\s*\(\s*<Fragment>/,
+    // return (<div ... or return (<main ... etc
+    /return\s*\(\s*<([a-zA-Z][a-zA-Z0-9]*)[^>]*>/
+  ];
+  for (const pattern of returnPatterns) {
+    const match = content.match(pattern);
+    if (match && match.index !== void 0) {
+      const insertPos = match.index + match[0].length;
+      content = content.slice(0, insertPos) + "\n      " + schemaComponent + content.slice(insertPos);
+      return content;
+    }
+  }
+  const simpleReturnMatch = content.match(/return\s*\(/);
+  if (simpleReturnMatch && simpleReturnMatch.index !== void 0) {
+    const afterReturn = content.slice(simpleReturnMatch.index + simpleReturnMatch[0].length);
+    const firstTagMatch = afterReturn.match(/^\s*<([a-zA-Z>][^>]*)>?/);
+    if (firstTagMatch) {
+      const insertPos = simpleReturnMatch.index + simpleReturnMatch[0].length + firstTagMatch[0].length;
+      content = content.slice(0, insertPos) + "\n      " + schemaComponent + content.slice(insertPos);
+      return content;
+    }
+  }
+  return content;
+}
+async function migrateFiles(scanResults, options) {
+  const results = [];
+  for (const form of scanResults.forms) {
+    if (form.suggestedAction === "manual") {
+      results.push({
+        filePath: form.filePath,
+        success: false,
+        changes: [],
+        error: "Form too complex for auto-migration"
+      });
+      continue;
+    }
+    try {
+      const result = await migrateForm(form, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        filePath: form.filePath,
+        success: false,
+        changes: [],
+        error: error.message
+      });
+    }
+  }
+  for (const widget of scanResults.widgets) {
+    try {
+      const result = await migrateWidget(widget.filePath, widget, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        filePath: widget.filePath,
+        success: false,
+        changes: [],
+        error: error.message
+      });
+    }
+  }
+  for (const meta of scanResults.metadata || []) {
+    try {
+      const result = await migrateMetadata(meta.filePath, meta, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        filePath: meta.filePath,
+        success: false,
+        changes: [],
+        error: error.message
+      });
+    }
+  }
+  for (const schema of scanResults.schemas || []) {
+    try {
+      const result = await migrateSchema(schema.filePath, schema, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        filePath: schema.filePath,
+        success: false,
+        changes: [],
+        error: error.message
+      });
+    }
+  }
+  for (const faq of scanResults.faqs || []) {
+    try {
+      const result = await migrateFAQ(faq.filePath, faq, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        filePath: faq.filePath,
+        success: false,
+        changes: [],
+        error: error.message
+      });
+    }
+  }
+  for (const sitemap of scanResults.sitemaps || []) {
+    if (sitemap.generator === "site-kit") continue;
+    try {
+      const result = await migrateSitemap(sitemap.filePath, sitemap, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        filePath: sitemap.filePath,
+        success: false,
+        changes: [],
+        error: error.message
+      });
+    }
+  }
+  for (const analytics of scanResults.analytics || []) {
+    try {
+      const result = await migrateAnalytics(analytics.filePath, analytics, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        filePath: analytics.filePath,
+        success: false,
+        changes: [],
+        error: error.message
+      });
+    }
+  }
+  return results;
+}
+async function migrateForm(form, options) {
+  const changes = [];
+  const fullPath = path.resolve(process.cwd(), form.filePath);
+  const formSlug = generateSlug(form.componentName);
+  let formId;
+  if (!options.dryRun) {
+    try {
+      formId = await createFormInUptrade(form, formSlug, options);
+      changes.push(`Created managed form: ${formSlug}`);
+    } catch (error) {
+      changes.push(`Form may already exist: ${formSlug}`);
+    }
+  } else {
+    changes.push(`[DRY RUN] Would create managed form: ${formSlug}`);
+  }
+  if (options.dryRun) {
+    changes.push("[DRY RUN] Would create backup of original file");
+    changes.push("[DRY RUN] Would replace form with Site-Kit managed form");
+    return { filePath: form.filePath, success: true, changes, formId };
+  }
+  const content = await fs.readFile(fullPath, "utf-8");
+  const backupPath = fullPath + ".backup";
+  await fs.writeFile(backupPath, content, "utf-8");
+  changes.push(`Created backup: ${form.filePath}.backup`);
+  const isTypeScript = form.filePath.endsWith(".tsx") || form.filePath.endsWith(".ts");
+  const newCode = generateMigratedFormCode(form, formSlug, isTypeScript);
+  await fs.writeFile(fullPath, newCode, "utf-8");
+  changes.push("Replaced component with Site-Kit managed form");
+  changes.push("Original saved to .backup file - delete when satisfied");
+  return {
+    filePath: form.filePath,
+    success: true,
+    changes,
+    formId
+  };
+}
+function generateMigratedFormCode(form, formSlug, isTypeScript = true) {
+  const componentName = form.componentName || "MigratedForm";
+  const classNameType = isTypeScript ? "{ className?: string }" : "{ className }";
+  return `/**
+ * ${componentName}
+ * 
+ * Migrated to @sonordev/site-kit
+ * Managed form: ${formSlug}
+ * 
+ * Original file backed up to: ${form.filePath}.backup
+ */
+
+'use client'
+
+import { useForm } from '@sonordev/site-kit/forms'
+
+export function ${componentName}(${classNameType}) {
+  const { 
+    form,
+    fields, 
+    values, 
+    errors, 
+    setFieldValue, 
+    submit, 
+    isSubmitting,
+    isComplete 
+  } = useForm('${formSlug}')
+
+  if (isComplete) {
+    return (
+      <div className={className}>
+        <p className="text-green-600">{form?.successMessage || 'Thanks for your submission!'}</p>
+      </div>
+    )
+  }
+
+  return (
+    <form 
+      onSubmit={(e) => { e.preventDefault(); submit() }} 
+      className={className}
+    >
+      {fields.map(field => (
+        <div key={field.slug} className="mb-4">
+          <label className="block text-sm font-medium mb-1">
+            {field.label}
+            {field.isRequired && <span className="text-red-500 ml-1">*</span>}
+          </label>
+          
+          {field.fieldType === 'textarea' ? (
+            <textarea
+              name={field.slug}
+              placeholder={field.placeholder}
+              value={String(values[field.slug] || '')}
+              onChange={(e) => setFieldValue(field.slug, e.target.value)}
+              className="w-full p-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              rows={4}
+            />
+          ) : field.fieldType === 'select' && field.options ? (
+            <select
+              name={field.slug}
+              value={String(values[field.slug] || '')}
+              onChange={(e) => setFieldValue(field.slug, e.target.value)}
+              className="w-full p-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            >
+              <option value="">Select...</option>
+              {field.options.map(opt => (
+                <option key={opt.value} value={opt.value}>{opt.label}</option>
+              ))}
+            </select>
+          ) : (
+            <input
+              type={field.fieldType}
+              name={field.slug}
+              placeholder={field.placeholder}
+              value={String(values[field.slug] || '')}
+              onChange={(e) => setFieldValue(field.slug, e.target.value)}
+              className="w-full p-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            />
+          )}
+          
+          {errors[field.slug] && (
+            <p className="mt-1 text-sm text-red-500">{errors[field.slug]}</p>
+          )}
+          
+          {field.helpText && (
+            <p className="mt-1 text-xs text-gray-500">{field.helpText}</p>
+          )}
+        </div>
+      ))}
+      
+      <button 
+        type="submit" 
+        disabled={isSubmitting}
+        className="w-full py-2 px-4 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+      >
+        {isSubmitting ? 'Submitting...' : (form?.submitButtonText || 'Submit')}
+      </button>
+    </form>
+  )
+}
+
+export default ${componentName}
+`;
+}
+async function createFormInUptrade(form, slug, options) {
+  const response = await fetch("https://api.uptrademedia.com/forms", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${options.apiKey}`
+    },
+    body: JSON.stringify({
+      projectId: options.projectId,
+      slug,
+      name: formatName(form.componentName),
+      formType: detectFormType(form),
+      successMessage: "Thanks for your submission!",
+      submitButtonText: "Submit",
+      fields: form.fields.map((f, i) => ({
+        slug: f.name,
+        label: formatLabel(f.name),
+        fieldType: mapFieldType(f.type),
+        placeholder: f.placeholder,
+        isRequired: f.required,
+        sortOrder: i,
+        width: "full"
+      }))
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.message || "Failed to create form");
+  }
+  const data = await response.json();
+  return data.id;
+}
+async function migrateWidget(filePath, widget, options) {
+  const changes = [];
+  if (options.dryRun) {
+    changes.push(`[DRY RUN] Would remove ${widget.widgetType} script`);
+    changes.push("[DRY RUN] Would enable Engage in SiteKitProvider");
+    return { filePath, success: true, changes };
+  }
+  const fullPath = path.resolve(process.cwd(), filePath);
+  let content = await fs.readFile(fullPath, "utf-8");
+  switch (widget.widgetType) {
+    case "intercom":
+      content = content.replace(/<Script[^>]*intercom[^>]*\/?>(?:<\/Script>)?/gi, "{/* Intercom replaced with Uptrade Engage */}");
+      content = content.replace(/window\.Intercom\s*=\s*[^;]+;/g, "");
+      break;
+    case "crisp":
+      content = content.replace(/<Script[^>]*crisp[^>]*\/?>(?:<\/Script>)?/gi, "{/* Crisp replaced with Uptrade Engage */}");
+      break;
+    case "drift":
+      content = content.replace(/<Script[^>]*drift[^>]*\/?>(?:<\/Script>)?/gi, "{/* Drift replaced with Uptrade Engage */}");
+      break;
+  }
+  await fs.writeFile(fullPath, content, "utf-8");
+  changes.push(`Removed ${widget.widgetType} script`);
+  changes.push("Enable Engage in SiteKitProvider to add chat widget");
+  return { filePath, success: true, changes };
+}
+function matchBalancedBraces(content, startIndex) {
+  if (content[startIndex] !== "{") return null;
+  let depth = 0;
+  let i = startIndex;
+  while (i < content.length) {
+    if (content[i] === "{") depth++;
+    else if (content[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        return content.slice(startIndex, i + 1);
+      }
+    }
+    i++;
+  }
+  return null;
+}
+async function migrateMetadata(filePath, metadata, options) {
+  const changes = [];
+  const fullPath = path.resolve(process.cwd(), filePath);
+  let pagePath = filePath.replace(/^app\//, "/").replace(/^src\/app\//, "/").replace(/\/page\.(tsx?|jsx?)$/, "").replace(/\/layout\.(tsx?|jsx?)$/, "").replace(/\[([^\]]+)\]/g, ":$1");
+  if (pagePath === "") pagePath = "/";
+  let content = await fs.readFile(fullPath, "utf-8");
+  const isTypeScript = filePath.endsWith(".tsx") || filePath.endsWith(".ts");
+  const ext = isTypeScript ? ".tsx" : ".jsx";
+  if (isClientComponent(content)) {
+    const dir = path.dirname(fullPath);
+    const layoutPath = path.join(dir, `layout${ext}`);
+    try {
+      await fs.access(layoutPath);
+      const layoutContent = await fs.readFile(layoutPath, "utf-8");
+      if (layoutContent.includes("getManagedMetadata")) {
+        changes.push("Layout already has managed metadata");
+        return { filePath, success: true, changes };
+      }
+      changes.push("Layout exists but does not have managed metadata - add generateMetadata manually");
+      return { filePath, success: true, changes };
+    } catch {
+    }
+    if (options.dryRun) {
+      changes.push(`[DRY RUN] Client component detected - would create layout${ext} with managed metadata`);
+      changes.push(`[DRY RUN] Page path: ${pagePath}`);
+      return { filePath, success: true, changes };
+    }
+    try {
+      await createPageMetadata(pagePath, metadata, options);
+      changes.push(`Created managed metadata for page: ${pagePath}`);
+    } catch (error) {
+      changes.push(`Page metadata may already exist: ${pagePath}`);
+    }
+    const dirName = path.basename(dir).replace(/^\[\.\.\.([^\]]+)\]$/, "$1").replace(/^\[([^\]]+)\]$/, "$1");
+    const layoutName = dirName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("") + "Layout";
+    const layoutCode = `import { getManagedMetadata, ManagedSchema } from '@sonordev/site-kit/seo'
+
+export async function generateMetadata() {
+  return getManagedMetadata({
+    projectId: process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${isTypeScript ? "!" : ""},
+    path: '${pagePath}',
+    fallback: {
+      title: '${(metadata.title || "Page Title").replace(/'/g, "\\'")}',
+      description: '${(metadata.description || "Page description").replace(/'/g, "\\'")}',
+    },
+  })
+}
+
+export default function ${layoutName}({ children }${isTypeScript ? ": { children: React.ReactNode }" : ""}) {
+  return (
+    <>
+      <ManagedSchema
+        projectId={process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${isTypeScript ? "!" : ""}}
+        path="${pagePath}"
+      />
+      {children}
+    </>
+  )
+}
+`;
+    await fs.writeFile(layoutPath, layoutCode, "utf-8");
+    changes.push(`Created layout${ext} with managed metadata and schema (client component page)`);
+    return { filePath, success: true, changes };
+  }
+  if (options.dryRun) {
+    changes.push(`[DRY RUN] Would create managed metadata for page: ${pagePath}`);
+    changes.push("[DRY RUN] Would add generateMetadata function (preserving rest of file)");
+    return { filePath, success: true, changes };
+  }
+  try {
+    await createPageMetadata(pagePath, metadata, options);
+    changes.push(`Created managed metadata for page: ${pagePath}`);
+  } catch (error) {
+    changes.push(`Page metadata may already exist: ${pagePath}`);
+  }
+  if (metadata.type === "no-metadata") {
+    if (!content.includes("'@sonordev/site-kit/seo") && !content.includes('"@sonordev/site-kit/seo')) {
+      content = addImportSafely(content, `import { getManagedMetadata, ManagedSchema } from '@sonordev/site-kit/seo'`);
+    } else if (!content.includes("ManagedSchema")) {
+      content = addToExistingImport(content, "ManagedSchema", "@sonordev/site-kit/seo");
+    }
+    const generateMetadataCode = `
+export async function generateMetadata() {
+  return getManagedMetadata({
+    projectId: process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${isTypeScript ? "!" : ""},
+    path: '${pagePath}',
+    fallback: {
+      title: '${(metadata.title || "Page Title").replace(/'/g, "\\'")}',
+      description: '${(metadata.description || "Page description").replace(/'/g, "\\'")}',
+    },
+  })
+}
+`;
+    const importEndMatch = content.match(/^(import\s+.*?['"][^'"]+['"];?\s*\n)+/m);
+    if (importEndMatch) {
+      const insertPos = importEndMatch.index + importEndMatch[0].length;
+      content = content.slice(0, insertPos) + generateMetadataCode + content.slice(insertPos);
+    } else {
+      const useClientMatch = content.match(/^['"]use client['"];?\s*\n/);
+      if (useClientMatch) {
+        const insertPos = useClientMatch[0].length;
+        content = content.slice(0, insertPos) + generateMetadataCode + content.slice(insertPos);
+      } else {
+        content = generateMetadataCode + content;
+      }
+    }
+    content = insertManagedSchemaIntoJSX(content, pagePath, isTypeScript);
+    changes.push("Added ManagedSchema component");
+    await fs.writeFile(fullPath, content, "utf-8");
+    changes.push("Added generateMetadata function");
+    return { filePath, success: true, changes };
+  }
+  if (metadata.type === "next-metadata") {
+    const metadataExportMatch = content.match(/export const metadata(?::\s*Metadata)?\s*=\s*/);
+    if (metadataExportMatch && metadataExportMatch.index !== void 0) {
+      const braceStart = metadataExportMatch.index + metadataExportMatch[0].length;
+      const braceContent = matchBalancedBraces(content, braceStart);
+      if (braceContent) {
+        const fullMatch = metadataExportMatch[0] + braceContent;
+        if (!content.includes("'@sonordev/site-kit/seo") && !content.includes('"@sonordev/site-kit/seo')) {
+          content = addImportSafely(content, `import { getManagedMetadata, ManagedSchema } from '@sonordev/site-kit/seo'`);
+        } else if (!content.includes("ManagedSchema")) {
+          content = addToExistingImport(content, "ManagedSchema", "@sonordev/site-kit/seo");
+        }
+        const generateMetadataCode = `export async function generateMetadata() {
+  return getManagedMetadata({
+    projectId: process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${isTypeScript ? "!" : ""},
+    path: '${pagePath}',
+    fallback: {
+      title: '${(metadata.title || "Page Title").replace(/'/g, "\\'")}',
+      description: '${(metadata.description || "Page description").replace(/'/g, "\\'")}',
+    },
+  })
+}`;
+        content = content.replace(fullMatch, generateMetadataCode);
+        changes.push("Replaced static metadata with getManagedMetadata");
+        content = insertManagedSchemaIntoJSX(content, pagePath, isTypeScript);
+        changes.push("Added ManagedSchema component");
+      }
+    }
+    if (content.includes("generateMetadata") && !content.includes("getManagedMetadata")) {
+      changes.push("generateMetadata function detected - add getManagedMetadata manually for full control");
+    }
+  }
+  await fs.writeFile(fullPath, content, "utf-8");
+  return { filePath, success: true, changes };
+}
+async function createPageMetadata(pagePath, metadata, options) {
+  const response = await fetch("https://api.uptrademedia.com/seo/pages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${options.apiKey}`
+    },
+    body: JSON.stringify({
+      project_id: options.projectId,
+      path: pagePath,
+      managed_title: metadata.title,
+      managed_meta_description: metadata.description
+    })
+  });
+  if (!response.ok && response.status !== 409) {
+    throw new Error(`Failed to create page: ${response.statusText}`);
+  }
+}
+function extractSchemaJSON(content) {
+  const scriptPatterns = [
+    /<script\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/i,
+    /<Script\s+[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/Script>/i
+  ];
+  for (const pattern of scriptPatterns) {
+    const match = content.match(pattern);
+    if (match && match[1]) {
+      try {
+        let jsonStr = match[1].trim();
+        if (jsonStr.startsWith("{") && (jsonStr.includes("`") || jsonStr.includes('"'))) {
+          const templateMatch = jsonStr.match(/\{[`"]([\s\S]*?)[`"]\}/);
+          if (templateMatch) {
+            jsonStr = templateMatch[1];
+          }
+        }
+        const innerHTMLMatch = jsonStr.match(/dangerouslySetInnerHTML=\{\{\s*__html:\s*['"`]([\s\S]*?)['"`]\s*\}\}/);
+        if (innerHTMLMatch) {
+          jsonStr = innerHTMLMatch[1];
+        }
+        const parsed = JSON.parse(jsonStr);
+        return {
+          schemaType: parsed["@type"] || "Unknown",
+          schemaJson: parsed
+        };
+      } catch {
+        return null;
+      }
+    }
+  }
+  const schemaObjectMatch = content.match(/const\s+\w*[sS]chema\w*\s*=\s*(\{[\s\S]*?@context[\s\S]*?\})\s*;?/);
+  if (schemaObjectMatch) {
+    try {
+      const typeMatch = schemaObjectMatch[1].match(/@type["']?\s*:\s*["']([^"']+)["']/);
+      if (typeMatch) {
+        return {
+          schemaType: typeMatch[1],
+          schemaJson: { "@type": typeMatch[1], "_note": "Schema extracted from JS object - review in Portal" }
+        };
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function createSchemaRecord(pagePath, schemaType, schemaJson, options) {
+  const apiUrl = process.env.NEXT_PUBLIC_UPTRADE_API_URL || "https://api.uptrademedia.com";
+  const response = await fetch(`${apiUrl}/api/public/seo/register-schema`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": options.apiKey
+    },
+    body: JSON.stringify({
+      page_path: pagePath,
+      schema_type: schemaType,
+      schema_json: schemaJson,
+      is_implemented: true
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to create schema: ${response.status} ${errorText}`);
+  }
+}
+async function migrateSchema(filePath, schema, options) {
+  const changes = [];
+  const fullPath = path.resolve(process.cwd(), filePath);
+  let pagePath = filePath.replace(/^app\//, "/").replace(/^src\/app\//, "/").replace(/\/page\.(tsx?|jsx?)$/, "").replace(/\[([^\]]+)\]/g, ":$1");
+  if (pagePath === "") pagePath = "/";
+  let content = await fs.readFile(fullPath, "utf-8");
+  if (isClientComponent(content)) {
+    changes.push("Skipped: Client component cannot use ManagedSchema (requires server rendering)");
+    changes.push("Consider moving schema to a parent server component or layout.tsx");
+    return { filePath, success: true, changes };
+  }
+  const extractedSchema = extractSchemaJSON(content);
+  if (options.dryRun) {
+    changes.push(`[DRY RUN] Would replace JSON-LD script with ManagedSchema component`);
+    changes.push(`[DRY RUN] Schema type: ${extractedSchema?.schemaType || schema.schemaType || "Unknown"}`);
+    if (extractedSchema) {
+      changes.push(`[DRY RUN] Would upload extracted schema to Portal`);
+    }
+    return { filePath, success: true, changes };
+  }
+  if (extractedSchema) {
+    try {
+      await createSchemaRecord(pagePath, extractedSchema.schemaType, extractedSchema.schemaJson, options);
+      changes.push(`Created managed schema (${extractedSchema.schemaType}) for: ${pagePath}`);
+    } catch (error) {
+      changes.push(`Schema record may already exist for: ${pagePath}`);
+    }
+  }
+  const alreadyHasManagedSchema = content.includes("<ManagedSchema");
+  const isTypeScript = filePath.endsWith(".tsx") || filePath.endsWith(".ts");
+  const projectIdSuffix = isTypeScript ? "!" : "";
+  const jsonLdPattern = /<script\s+type=["']application\/ld\+json["'][^>]*>[\s\S]*?<\/script>/gi;
+  const scriptPattern = /<Script\s+[^>]*type=["']application\/ld\+json["'][^>]*>[\s\S]*?<\/Script>/gi;
+  const hasJsonLd = jsonLdPattern.test(content) || scriptPattern.test(content);
+  if (hasJsonLd) {
+    jsonLdPattern.lastIndex = 0;
+    scriptPattern.lastIndex = 0;
+    if (alreadyHasManagedSchema) {
+      content = content.replace(jsonLdPattern, "{/* JSON-LD migrated to ManagedSchema */}");
+      content = content.replace(scriptPattern, "{/* JSON-LD migrated to ManagedSchema */}");
+      changes.push("Removed JSON-LD script (ManagedSchema already present)");
+    } else {
+      if (!content.includes("ManagedSchema")) {
+        if (content.includes("'@sonordev/site-kit/seo") || content.includes('"@sonordev/site-kit/seo')) {
+          content = addToExistingImport(content, "ManagedSchema", "@sonordev/site-kit/seo");
+        } else {
+          content = addImportSafely(content, `import { ManagedSchema } from '@sonordev/site-kit/seo'`);
+        }
+        changes.push("Added ManagedSchema import");
+      }
+      content = content.replace(jsonLdPattern, `<ManagedSchema 
+        projectId={process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${projectIdSuffix}}
+        path="${pagePath}"
+      />`);
+      content = content.replace(scriptPattern, `<ManagedSchema 
+        projectId={process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${projectIdSuffix}}
+        path="${pagePath}"
+      />`);
+      changes.push("Replaced JSON-LD script with ManagedSchema component");
+    }
+  }
+  await fs.writeFile(fullPath, content, "utf-8");
+  return { filePath, success: true, changes };
+}
+function extractFAQItems(content, faqType) {
+  const items = [];
+  if (faqType === "details-summary") {
+    const detailsPattern = /<details[^>]*>[\s\S]*?<summary[^>]*>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi;
+    let match2;
+    while ((match2 = detailsPattern.exec(content)) !== null) {
+      const question = match2[1].replace(/<[^>]+>/g, "").trim();
+      const answer = match2[2].replace(/<[^>]+>/g, "").trim();
+      if (question && answer) {
+        items.push({ question, answer });
+      }
+    }
+  }
+  const accordionItemPattern = /<(?:Accordion\.Item|AccordionItem|FAQItem)[^>]*(?:question|title)=["'`]([^"'`]+)["'`][^>]*>[\s\S]*?(?:answer|content)=["'`]([^"'`]+)["'`]/gi;
+  let match;
+  while ((match = accordionItemPattern.exec(content)) !== null) {
+    items.push({ question: match[1], answer: match[2] });
+  }
+  const faqArrayPattern = /\{\s*question:\s*["'`]([^"'`]+)["'`]\s*,\s*answer:\s*["'`]([^"'`]+)["'`]\s*\}/gi;
+  while ((match = faqArrayPattern.exec(content)) !== null) {
+    items.push({ question: match[1], answer: match[2] });
+  }
+  const shortFaqPattern = /\{\s*q:\s*["'`]([^"'`]+)["'`]\s*,\s*a:\s*["'`]([^"'`]+)["'`]\s*\}/gi;
+  while ((match = shortFaqPattern.exec(content)) !== null) {
+    items.push({ question: match[1], answer: match[2] });
+  }
+  return items;
+}
+async function createFAQRecord(pagePath, items, options) {
+  const apiUrl = process.env.NEXT_PUBLIC_UPTRADE_API_URL || "https://api.uptrademedia.com";
+  const response = await fetch(`${apiUrl}/api/public/seo/register-faq`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": options.apiKey
+    },
+    body: JSON.stringify({
+      path: pagePath,
+      title: "Frequently Asked Questions",
+      items: items.map((item, index) => ({
+        id: `faq-${index + 1}`,
+        question: item.question,
+        answer: item.answer,
+        order: index,
+        is_visible: true
+      })),
+      include_schema: true,
+      is_published: items.length > 0
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to create FAQ: ${response.status} ${errorText}`);
+  }
+}
+async function migrateFAQ(filePath, faq, options) {
+  const changes = [];
+  const fullPath = path.resolve(process.cwd(), filePath);
+  let pagePath = filePath.replace(/^app\//, "/").replace(/^src\/app\//, "/").replace(/\/page\.(tsx?|jsx?)$/, "").replace(/\[([^\]]+)\]/g, ":$1");
+  if (pagePath === "") pagePath = "/";
+  let content = await fs.readFile(fullPath, "utf-8");
+  if (isClientComponent(content)) {
+    changes.push("Skipped: Client component cannot use ManagedFAQ (requires server rendering)");
+    changes.push("Consider using ManagedFAQ in a parent server component or layout.tsx");
+    return { filePath, success: true, changes };
+  }
+  const extractedItems = extractFAQItems(content, faq.type);
+  if (options.dryRun) {
+    changes.push(`[DRY RUN] Would extract ${extractedItems.length} FAQ items`);
+    changes.push(`[DRY RUN] Would create managed FAQ record for path: ${pagePath}`);
+    changes.push(`[DRY RUN] Would insert ManagedFAQ component`);
+    changes.push(`[DRY RUN] FAQ type: ${faq.type}${faq.componentName ? ` (${faq.componentName})` : ""}`);
+    return { filePath, success: true, changes };
+  }
+  if (extractedItems.length > 0) {
+    try {
+      await createFAQRecord(pagePath, extractedItems, options);
+      changes.push(`Created managed FAQ with ${extractedItems.length} items for: ${pagePath}`);
+    } catch (error) {
+      changes.push(`FAQ record may already exist for: ${pagePath}`);
+    }
+  } else {
+    try {
+      await createFAQRecord(pagePath, [], options);
+      changes.push(`Created empty managed FAQ for: ${pagePath} (add items in Portal)`);
+    } catch {
+      changes.push(`FAQ record may already exist for: ${pagePath}`);
+    }
+  }
+  if (!content.includes("ManagedFAQ")) {
+    if (content.includes("'@sonordev/site-kit/seo") || content.includes('"@sonordev/site-kit/seo')) {
+      content = addToExistingImport(content, "ManagedFAQ", "@sonordev/site-kit/seo");
+    } else {
+      content = addImportSafely(content, `import { ManagedFAQ } from '@sonordev/site-kit/seo'`);
+    }
+    changes.push("Added ManagedFAQ import");
+  }
+  const isTypeScript = filePath.endsWith(".tsx") || filePath.endsWith(".ts");
+  const projectIdSuffix = isTypeScript ? "!" : "";
+  const managedFAQComponent = `<ManagedFAQ
+      projectId={process.env.NEXT_PUBLIC_UPTRADE_PROJECT_ID${projectIdSuffix}}
+      path="${pagePath}"
+    />`;
+  if (faq.componentName) {
+    const componentPattern = new RegExp(`(<${faq.componentName}[^>]*>)`, "i");
+    if (componentPattern.test(content)) {
+      content = content.replace(componentPattern, `{/* Managed FAQ - content controlled via Portal */}
+    ${managedFAQComponent}
+    {/* Original FAQ component (can be removed once migrated) */}
+    $1`);
+      changes.push("Inserted ManagedFAQ component before existing FAQ");
+    }
+  } else if (faq.type === "details-summary") {
+    const detailsMatch = content.match(/<details[^>]*>/);
+    if (detailsMatch && detailsMatch.index !== void 0) {
+      content = content.slice(0, detailsMatch.index) + `{/* Managed FAQ - content controlled via Portal */}
+    ${managedFAQComponent}
+    {/* Original FAQ (can be removed once migrated) */}
+    ` + content.slice(detailsMatch.index);
+      changes.push("Inserted ManagedFAQ component before details/summary FAQ");
+    }
+  }
+  if (!changes.some((c) => c.includes("Inserted ManagedFAQ"))) {
+    changes.push(`Add ManagedFAQ to your page JSX: ${managedFAQComponent}`);
+  }
+  await fs.writeFile(fullPath, content, "utf-8");
+  return { filePath, success: true, changes };
+}
+async function migrateSitemap(filePath, sitemap, options) {
+  const changes = [];
+  const fullPath = path.resolve(process.cwd(), filePath);
+  if (options.dryRun) {
+    changes.push(`[DRY RUN] Would migrate ${sitemap.type} to Site-Kit sitemap`);
+    if (sitemap.type === "next-sitemap-config") {
+      changes.push("[DRY RUN] Would update next-sitemap.config.js to use Site-Kit URLs");
+    }
+    return { filePath, success: true, changes };
+  }
+  if (sitemap.type === "next-sitemap-config") {
+    let content = await fs.readFile(fullPath, "utf-8");
+    if (!content.includes("Site-Kit")) {
+      content = `/**
+ * Site-Kit Integration
+ * 
+ * Pages are automatically synced to Portal SEO module.
+ * Manage URLs, priorities, and change frequencies in the Portal.
+ */
+` + content;
+    }
+    await fs.writeFile(fullPath, content, "utf-8");
+    changes.push("Added Site-Kit integration comment to sitemap config");
+    changes.push("Configure sitemap settings in Portal SEO module for centralized management");
+  }
+  if (sitemap.type === "custom-sitemap" && filePath.includes("sitemap")) {
+    changes.push("Custom sitemap detected - consider using Site-Kit's createSitemap helper");
+    changes.push("Import: import { createSitemap } from '@sonordev/site-kit/seo'");
+  }
+  return { filePath, success: true, changes };
+}
+async function migrateAnalytics(filePath, analytics, options) {
+  const changes = [];
+  if (options.dryRun) {
+    changes.push(`[DRY RUN] Detected ${analytics.type}${analytics.trackingId ? ` (${analytics.trackingId})` : ""}`);
+    changes.push("[DRY RUN] Would recommend moving to SiteKitProvider analytics");
+    return { filePath, success: true, changes };
+  }
+  changes.push(`Detected ${analytics.type}${analytics.trackingId ? ` (${analytics.trackingId})` : ""}`);
+  changes.push("SiteKitProvider supports analytics integration");
+  changes.push("Configure analytics in project settings to consolidate tracking");
+  return { filePath, success: true, changes };
+}
+async function migrateFile(filePath, options) {
+  const fullPath = path.resolve(filePath);
+  const relPath = path.relative(process.cwd(), fullPath);
+  const content = await fs.readFile(fullPath, "utf-8");
+  const hasFormTag = content.includes("<form") || content.includes("onSubmit");
+  const hasWidget = /intercom|crisp|drift|hubspot|zendesk/i.test(content);
+  if (!hasFormTag && !hasWidget) {
+    return {
+      filePath: relPath,
+      success: false,
+      changes: [],
+      error: "No migratable components found in file"
+    };
+  }
+  if (hasWidget) {
+    const widgetType = content.toLowerCase().includes("intercom") ? "intercom" : content.toLowerCase().includes("crisp") ? "crisp" : content.toLowerCase().includes("drift") ? "drift" : content.toLowerCase().includes("hubspot") ? "hubspot" : content.toLowerCase().includes("zendesk") ? "zendesk" : "other";
+    return migrateWidget(relPath, {
+      widgetType}, options);
+  }
+  const { parse } = await import('@babel/parser');
+  const ast = parse(content, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"]
+  });
+  let componentName = "Form";
+  const traverse = (await import('@babel/traverse')).default;
+  traverse(ast, {
+    ExportNamedDeclaration(path2) {
+      const decl = path2.node.declaration;
+      if (decl && decl.type === "FunctionDeclaration" && decl.id) {
+        componentName = decl.id.name;
+        path2.stop();
+      }
+    },
+    ExportDefaultDeclaration(path2) {
+      const decl = path2.node.declaration;
+      if (decl && decl.type === "FunctionDeclaration" && decl.id) {
+        componentName = decl.id.name;
+        path2.stop();
+      }
+    }
+  });
+  const form = {
+    filePath: relPath,
+    componentName,
+    fields: [],
+    hasValidation: false,
+    formLibrary: "native",
+    submitsTo: null,
+    complexity: "simple",
+    suggestedAction: "auto-migrate",
+    startLine: 0,
+    endLine: 0
+  };
+  return migrateForm(form, options);
+}
+function generateSlug(name) {
+  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "").replace(/form$/i, "").replace(/-+/g, "-").replace(/-$/, "") || "form";
+}
+function formatName(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
+}
+function formatLabel(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/_/g, " ").replace(/^./, (str) => str.toUpperCase()).trim();
+}
+function mapFieldType(type) {
+  const mapping = {
+    "text": "text",
+    "email": "email",
+    "tel": "phone",
+    "phone": "phone",
+    "number": "number",
+    "textarea": "textarea",
+    "select": "select",
+    "checkbox": "checkbox",
+    "radio": "radio",
+    "date": "date",
+    "file": "file",
+    "url": "url",
+    "password": "text"
+    // Don't use password for managed forms
+  };
+  return mapping[type] || "text";
+}
+function detectFormType(form) {
+  const name = form.componentName.toLowerCase();
+  const fields = form.fields.map((f) => f.name.toLowerCase()).join(" ");
+  if (name.includes("contact") || fields.includes("message")) return "contact";
+  if (name.includes("newsletter") || name.includes("subscribe")) return "newsletter";
+  if (name.includes("quote") || name.includes("estimate")) return "prospect";
+  if (name.includes("support") || name.includes("help")) return "support";
+  if (name.includes("feedback")) return "feedback";
+  return "contact";
+}
+
+export { migrateAnalytics, migrateFAQ, migrateFile, migrateFiles, migrateMetadata, migrateSchema, migrateSitemap };
+//# sourceMappingURL=chunk-24277A3Q.mjs.map
+//# sourceMappingURL=chunk-24277A3Q.mjs.map