create-snapify-app 0.0.0-stage → 1.1.1

package/template/modules/wp-seo-migrator/src/admin/i18n.ts

@@ -0,0 +1,156 @@
+export type Lang = 'fr' | 'en' | 'ar';
+
+const fr = {
+  title: 'Migrer le SEO WordPress',
+  sub: 'Trois minutes : on lit votre site tout seuls, vous validez, on importe.',
+  step1: 'Site',
+  step2: 'Analyse',
+  step3: 'Vérifier',
+  step4: 'Terminé',
+  howTitle: 'Comment ça marche ?',
+  how1: 'Collez l’adresse de votre site WordPress',
+  how2: 'On récupère titres, descriptions et redirections automatiquement',
+  how3: 'Vous validez, puis un clic pour migrer vers Snapify',
+  siteUrl: 'Adresse de votre site',
+  sitePh: 'https://www.monsite.tn',
+  siteHint: 'Commencez par https:// — pas besoin d’export ni de plugin.',
+  analyze: 'Lancer l’analyse',
+  analyzing: 'Analyse en cours…',
+  analyzingHint: 'Vous pouvez laisser cette page ouverte. On vous prévient dès que c’est prêt.',
+  waitConnect: 'Connexion au site',
+  waitApi: 'Lecture WordPress',
+  waitSitemap: 'Plan du site',
+  waitPages: 'Pages & articles',
+  waitFtp: 'Fichiers serveur (FTP)',
+  advanced: 'Le site refuse l’accès ? Options avancées',
+  advancedHint: 'Seulement si l’analyse simple échoue. La plupart des sites n’en ont pas besoin.',
+  wpUser: 'Identifiant WordPress',
+  wpPass: 'Mot de passe d’application',
+  wpPassHelp: 'WordPress → Utilisateurs → Votre profil → « Mots de passe d’application ». Ce n’est pas le mot de passe de connexion habituel.',
+  ftpTitle: 'Accès FTP (optionnel)',
+  ftpHint: 'Utile pour récupérer le fichier .htaccess (redirections serveur).',
+  ftpHost: 'Serveur FTP',
+  ftpUser: 'Utilisateur FTP',
+  ftpPass: 'Mot de passe FTP',
+  ftpRoot: 'Dossier du site',
+  ftpSecure: 'Connexion FTPS sécurisée',
+  expert: 'Dernier recours : fichier d’export',
+  upload: 'Téléverser un fichier',
+  uploadHelp: 'Export WordPress, CSV Yoast/Rank Math, ou JSON — uniquement si la connexion auto a échoué.',
+  downloadPlugin: 'Télécharger le mini-plugin Exporter',
+  pluginHelp: 'À installer sur WordPress seulement si le site bloque complètement l’accès public.',
+  cancel: 'Annuler',
+  next: 'Continuer',
+  back: 'Retour',
+  migrate: 'Migrer mon SEO',
+  migrateHint: 'Rien n’est destructif : on met à jour le SEO et on ajoute des redirections 301.',
+  coverage: 'SEO récupérable',
+  fix: 'Corriger automatiquement',
+  beforeAfter: 'Aperçu sur quelques pages',
+  dnsTitle: 'Ensuite, côté nom de domaine',
+  done: 'Migration terminée',
+  report: 'Télécharger le rapport',
+  applying: 'Migration en cours…',
+  needUrl: 'Indiquez l’adresse de votre site (https://…).',
+  analyzeFail: 'Analyse échouée',
+  analyzeOk: 'Analyse prête',
+  foundSources: 'Sources détectées',
+  contents: 'Contenus',
+  redirects: 'Redirections',
+  retry: 'Réessayer',
+  startOver: 'Recommencer',
+};
+
+const en: typeof fr = {
+  ...fr,
+  title: 'Migrate WordPress SEO',
+  sub: 'Three minutes: we read your site, you review, we import.',
+  step1: 'Site',
+  step2: 'Analysis',
+  step3: 'Review',
+  step4: 'Done',
+  howTitle: 'How it works',
+  how1: 'Paste your WordPress site URL',
+  how2: 'We fetch titles, descriptions and redirects automatically',
+  how3: 'You review, then one click to migrate into Snapify',
+  siteUrl: 'Your site URL',
+  siteHint: 'Start with https:// — no export or plugin needed.',
+  analyze: 'Start analysis',
+  analyzing: 'Analyzing…',
+  analyzingHint: 'Keep this page open. We’ll show results when ready.',
+  advanced: 'Site blocks access? Advanced options',
+  advancedHint: 'Only if the simple analysis fails. Most sites don’t need this.',
+  wpUser: 'WordPress username',
+  wpPass: 'Application password',
+  wpPassHelp: 'WordPress → Users → Profile → Application passwords. Not your normal login password.',
+  ftpTitle: 'FTP access (optional)',
+  ftpHint: 'Useful to fetch .htaccess redirects.',
+  ftpHost: 'FTP host',
+  ftpUser: 'FTP user',
+  ftpPass: 'FTP password',
+  ftpRoot: 'Site folder',
+  ftpSecure: 'Secure FTPS',
+  expert: 'Last resort: export file',
+  upload: 'Upload a file',
+  uploadHelp: 'Only if auto-connect failed.',
+  downloadPlugin: 'Download Exporter plugin',
+  cancel: 'Cancel',
+  next: 'Continue',
+  back: 'Back',
+  migrate: 'Migrate my SEO',
+  migrateHint: 'Non-destructive: we update SEO fields and add 301 redirects.',
+  coverage: 'Recoverable SEO',
+  fix: 'Auto-fix',
+  beforeAfter: 'Sample pages preview',
+  dnsTitle: 'Next: domain checklist',
+  done: 'Migration complete',
+  report: 'Download report',
+  applying: 'Migrating…',
+  needUrl: 'Enter your site URL (https://…).',
+  analyzeFail: 'Analysis failed',
+  analyzeOk: 'Analysis ready',
+  foundSources: 'Sources found',
+  contents: 'Content',
+  redirects: 'Redirects',
+  retry: 'Try again',
+  startOver: 'Start over',
+};
+
+const ar: typeof fr = {
+  ...fr,
+  title: 'ترحيل سيو ووردبريس',
+  sub: 'ثلاث دقائق: نقرأ موقعك تلقائياً ثم تُرحّل إلى Snapify.',
+  step1: 'الموقع',
+  step2: 'التحليل',
+  step3: 'مراجعة',
+  step4: 'تم',
+  howTitle: 'كيف يعمل؟',
+  how1: 'الصق عنوان موقع ووردبريس',
+  how2: 'نستخرج العناوين والوصف وإعادة التوجيه تلقائياً',
+  how3: 'تراجع ثم ترحّل بنقرة واحدة',
+  siteUrl: 'عنوان الموقع',
+  analyze: 'بدء التحليل',
+  analyzing: 'جاري التحليل…',
+  advanced: 'خيارات متقدمة',
+  cancel: 'إلغاء',
+  next: 'متابعة',
+  back: 'رجوع',
+  migrate: 'ترحيل السيو',
+  coverage: 'السيو القابل للاسترداد',
+  fix: 'إصلاح تلقائي',
+  done: 'اكتمل الترحيل',
+  report: 'تحميل التقرير',
+  needUrl: 'أدخل عنوان الموقع (https://…).',
+  analyzeFail: 'فشل التحليل',
+  analyzeOk: 'التحليل جاهز',
+  contents: 'المحتوى',
+  redirects: 'إعادة التوجيه',
+  retry: 'إعادة المحاولة',
+  startOver: 'البداية من جديد',
+};
+
+export function t(lang: Lang) {
+  if (lang === 'en') return en;
+  if (lang === 'ar') return ar;
+  return fr;
+}

package/template/modules/wp-seo-migrator/src/admin/index.tsx

@@ -0,0 +1,11 @@
+import { defineAdminModule } from '@snapify/sdk/admin';
+import { WizardPage } from './WizardPage';
+import { HistoryPage } from './HistoryPage';
+import type { Settings } from '../types';
+
+export default defineAdminModule<Settings>({
+  pages: {
+    wizard: WizardPage,
+    history: HistoryPage,
+  },
+});

package/template/modules/wp-seo-migrator/src/connectors/CUSTOM_CONNECTOR.md

@@ -0,0 +1,31 @@
+# Gabarit — connecteur SEO personnalisé (groupe G)
+
+Tout connecteur implémente `SeoConnector` (`src/types.ts`) :
+
+```ts
+import type { SeoConnector } from '../types';
+import { pathFromUrl, slugFromPath } from './utils';
+// ou createCsvSeoConnector depuis ./csvSeoFactory
+
+export const monConnector: SeoConnector = {
+  id: 'mon-plugin',          // unique, kebab-case
+  name: 'Mon plugin SEO',
+  fields: ['url', 'seoTitle', 'metaDescription'],
+  detect(ctx) {
+    const found = ctx.textFiles.some((f) => f.name.includes('mon-plugin'));
+    return { id: 'mon-plugin', name: 'Mon plugin SEO', found };
+  },
+  extract(ctx) {
+    return { records: [], redirects: [], warnings: [] };
+  },
+};
+```
+
+1. Ajoutez le fichier dans `src/connectors/`.
+2. Enregistrez-le dans `CONNECTORS` (`src/connectors/index.ts`).
+3. Ajoutez une fixture + un test dans `tests/`.
+4. Rebuild / republiez le module (`npm run module -- build modules/wp-seo-migrator`).
+
+Pour un CSV simple, préférez `createCsvSeoConnector({ id, name, detectHints, columns })`.
+
+**Limite SDK** : pas d’hôte `net:` dynamique — un connecteur live REST vers un WordPress arbitraire nécessite une évolution core (`net:outbound` SSRF-safe) ; en attendant, fournissez un export fichier ou le plugin Snapify Exporter.

package/template/modules/wp-seo-migrator/src/connectors/csvSeoFactory.ts

@@ -0,0 +1,106 @@
+/**
+ * Fabrique de connecteurs CSV SEO (Yoast-like, AIOSEO, SEOPress, Screaming Frog…).
+ * Gabarit réutilisable pour la communauté (groupe G).
+ */
+import type { AnalyzeContext, ExtractResult, SeoConnector, SeoField, SeoRecord } from '../types';
+import { csvIdx, parseCsv, pathFromUrl, slugFromPath } from './utils';
+
+export type CsvColumnMap = {
+  url: string[];
+  seoTitle?: string[];
+  metaDescription?: string[];
+  focusKeyphrase?: string[];
+  canonicalUrl?: string[];
+  ogTitle?: string[];
+  ogDescription?: string[];
+  ogImage?: string[];
+  noindex?: string[];
+};
+
+export function createCsvSeoConnector(opts: {
+  id: string;
+  name: string;
+  /** Indices / noms de colonnes */
+  columns: CsvColumnMap;
+  /** Détection : noms de fichier ou en-têtes attendus */
+  detectHints: string[];
+  fields?: SeoField[];
+}): SeoConnector {
+  const fields: SeoField[] = opts.fields || [
+    'url',
+    'seoTitle',
+    'metaDescription',
+    'focusKeyphrase',
+    'canonicalUrl',
+    'ogTitle',
+    'ogDescription',
+    'ogImage',
+    'noindex',
+  ];
+
+  return {
+    id: opts.id,
+    name: opts.name,
+    fields,
+    detect: (ctx) => {
+      const hit = ctx.textFiles.some((f) => {
+        const head = f.text.slice(0, 600).toLowerCase();
+        const name = f.name.toLowerCase();
+        return opts.detectHints.some((h) => name.includes(h) || head.includes(h));
+      });
+      return { id: opts.id, name: opts.name, found: hit };
+    },
+    extract: (ctx: AnalyzeContext): ExtractResult => {
+      const records: SeoRecord[] = [];
+      const warnings: string[] = [];
+      for (const f of ctx.textFiles) {
+        if (!f.name.endsWith('.csv') && !f.text.includes(',')) continue;
+        const rows = parseCsv(f.text);
+        if (rows.length < 2) continue;
+        const header = rows[0];
+        const iUrl = csvIdx(header, ...opts.columns.url);
+        if (iUrl < 0) continue;
+        const iTitle = opts.columns.seoTitle ? csvIdx(header, ...opts.columns.seoTitle) : -1;
+        const iDesc = opts.columns.metaDescription ? csvIdx(header, ...opts.columns.metaDescription) : -1;
+        const iKw = opts.columns.focusKeyphrase ? csvIdx(header, ...opts.columns.focusKeyphrase) : -1;
+        const iCanon = opts.columns.canonicalUrl ? csvIdx(header, ...opts.columns.canonicalUrl) : -1;
+        const iOgT = opts.columns.ogTitle ? csvIdx(header, ...opts.columns.ogTitle) : -1;
+        const iOgD = opts.columns.ogDescription ? csvIdx(header, ...opts.columns.ogDescription) : -1;
+        const iOgI = opts.columns.ogImage ? csvIdx(header, ...opts.columns.ogImage) : -1;
+        const iNo = opts.columns.noindex ? csvIdx(header, ...opts.columns.noindex) : -1;
+
+        for (const r of rows.slice(1)) {
+          const url = (r[iUrl] || '').trim();
+          if (!url) continue;
+          const path = pathFromUrl(url);
+          const noRaw = iNo >= 0 ? (r[iNo] || '').toLowerCase() : '';
+          records.push({
+            id: `${opts.id}:${path}`,
+            kind: 'other',
+            url,
+            path,
+            slug: slugFromPath(path),
+            status: 'publish',
+            seoTitle: iTitle >= 0 ? r[iTitle] || undefined : undefined,
+            metaDescription: iDesc >= 0 ? r[iDesc] || undefined : undefined,
+            focusKeyphrase: iKw >= 0 ? r[iKw] || undefined : undefined,
+            canonicalUrl: iCanon >= 0 ? r[iCanon] || undefined : undefined,
+            ogTitle: iOgT >= 0 ? r[iOgT] || undefined : undefined,
+            ogDescription: iOgD >= 0 ? r[iOgD] || undefined : undefined,
+            ogImage: iOgI >= 0 ? r[iOgI] || undefined : undefined,
+            noindex: noRaw === '1' || noRaw === 'true' || noRaw === 'yes' || noRaw === 'noindex',
+            sources: {
+              url: opts.id,
+              seoTitle: iTitle >= 0 ? opts.id : undefined,
+              metaDescription: iDesc >= 0 ? opts.id : undefined,
+              focusKeyphrase: iKw >= 0 ? opts.id : undefined,
+              canonicalUrl: iCanon >= 0 ? opts.id : undefined,
+            },
+          });
+        }
+      }
+      if (!records.length) warnings.push(`${opts.name} : aucune ligne URL trouvée`);
+      return { records, redirects: [], warnings };
+    },
+  };
+}

package/template/modules/wp-seo-migrator/src/connectors/exporter.ts

@@ -0,0 +1,96 @@
+/**
+ * JSON produit par le plugin WordPress « Snapify Exporter ».
+ * Format : { format: 'snapify-wp-seo/1', site, plugins, records, redirects }
+ */
+import type { AnalyzeContext, ExtractResult, RedirectRecord, SeoConnector, SeoRecord } from '../types';
+import { pathFromUrl, safeJson, slugFromPath } from './utils';
+
+type ExporterPayload = {
+  format?: string;
+  site?: { url?: string };
+  plugins?: { id: string; name: string; active?: boolean }[];
+  records?: Partial<SeoRecord>[];
+  redirects?: { from: string; to: string; permanent?: boolean }[];
+};
+
+export const exporterConnector: SeoConnector = {
+  id: 'snapify-exporter',
+  name: 'Plugin Snapify Exporter',
+  fields: [
+    'url',
+    'slug',
+    'seoTitle',
+    'metaDescription',
+    'focusKeyphrase',
+    'canonicalUrl',
+    'noindex',
+    'nofollow',
+    'ogTitle',
+    'ogDescription',
+    'ogImage',
+    'schemaJsonLd',
+    'hreflang',
+    'redirects',
+  ],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some((f) => {
+      const j = safeJson<ExporterPayload>(f.text);
+      return j?.format === 'snapify-wp-seo/1' || (Array.isArray(j?.records) && Array.isArray(j?.plugins));
+    });
+    return {
+      id: 'snapify-exporter',
+      name: 'Plugin Snapify Exporter',
+      found: hit,
+      detail: hit ? 'Export Snapify complet détecté' : undefined,
+    };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const records: SeoRecord[] = [];
+    const redirects: RedirectRecord[] = [];
+    const warnings: string[] = [];
+    for (const f of ctx.textFiles) {
+      const j = safeJson<ExporterPayload>(f.text);
+      if (!j || (j.format !== 'snapify-wp-seo/1' && !j.records)) continue;
+      for (const r of j.records || []) {
+        const url = String(r.url || '');
+        const path = r.path || pathFromUrl(url);
+        records.push({
+          id: String(r.id || `exp:${path}`),
+          kind: (r.kind as SeoRecord['kind']) || 'other',
+          url: url || path,
+          path,
+          slug: r.slug || slugFromPath(path),
+          status: (r.status as SeoRecord['status']) || 'publish',
+          title: r.title,
+          seoTitle: r.seoTitle,
+          metaDescription: r.metaDescription,
+          focusKeyphrase: r.focusKeyphrase,
+          canonicalUrl: r.canonicalUrl,
+          noindex: !!r.noindex,
+          nofollow: !!r.nofollow,
+          ogTitle: r.ogTitle,
+          ogDescription: r.ogDescription,
+          ogImage: r.ogImage,
+          twitterCard: r.twitterCard || 'summary_large_image',
+          schemaType: r.schemaType,
+          schemaJsonLd: r.schemaJsonLd,
+          hreflang: r.hreflang,
+          breadcrumbsTitle: r.breadcrumbsTitle,
+          imageAlts: r.imageAlts,
+          sources: { ...(r.sources || {}), url: 'snapify-exporter' },
+        });
+      }
+      for (const re of j.redirects || []) {
+        redirects.push({
+          id: `exp-redir:${re.from}`,
+          from: pathFromUrl(re.from),
+          to: re.to.startsWith('http') ? re.to : pathFromUrl(re.to),
+          permanent: re.permanent !== false,
+          source: 'snapify-exporter',
+        });
+      }
+    }
+    if (!records.length && !redirects.length) warnings.push('Export Snapify vide ou illisible');
+    return { records, redirects, warnings };
+  },
+};

package/template/modules/wp-seo-migrator/src/connectors/gscCsv.ts

@@ -0,0 +1,53 @@
+/** Groupe F — Google Search Console (CSV) pour prioriser les URLs à fort trafic */
+import type { AnalyzeContext, ExtractResult, SeoConnector, SeoRecord } from '../types';
+import { csvIdx, parseCsv, pathFromUrl, slugFromPath } from './utils';
+
+export const gscCsvConnector: SeoConnector = {
+  id: 'gsc-csv',
+  name: 'Google Search Console (CSV)',
+  fields: ['url'],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some((f) => {
+      const h = f.text.slice(0, 400).toLowerCase();
+      const n = f.name.toLowerCase();
+      return n.includes('gsc') || n.includes('search-console') || (h.includes('clicks') && h.includes('impressions') && (h.includes('top pages') || h.includes('page') || h.includes('url')));
+    });
+    return { id: 'gsc-csv', name: 'Google Search Console (CSV)', found: hit };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const records: SeoRecord[] = [];
+    const warnings: string[] = [];
+    for (const f of ctx.textFiles) {
+      if (!f.name.endsWith('.csv') && !f.text.includes(',')) continue;
+      const rows = parseCsv(f.text);
+      if (rows.length < 2) continue;
+      const header = rows[0];
+      const iUrl = csvIdx(header, 'top pages', 'page', 'url', 'landing page');
+      const iClicks = csvIdx(header, 'clicks', 'clics');
+      if (iUrl < 0) continue;
+      const scored: { path: string; url: string; clicks: number }[] = [];
+      for (const r of rows.slice(1)) {
+        const url = (r[iUrl] || '').trim();
+        if (!url) continue;
+        const clicks = iClicks >= 0 ? Number(r[iClicks]) || 0 : 0;
+        scored.push({ url, path: pathFromUrl(url), clicks });
+      }
+      scored.sort((a, b) => b.clicks - a.clicks);
+      for (const s of scored) {
+        records.push({
+          id: `gsc:${s.path}`,
+          kind: 'other',
+          url: s.url,
+          path: s.path,
+          slug: slugFromPath(s.path),
+          status: 'publish',
+          // focusKeyphrase détourné : stocke un hint de priorité lisible
+          focusKeyphrase: s.clicks > 0 ? `gsc-clicks:${s.clicks}` : undefined,
+          sources: { url: 'gsc-csv', focusKeyphrase: s.clicks > 0 ? 'gsc-csv' : undefined },
+        });
+      }
+    }
+    if (!records.length) warnings.push('GSC : aucune page dans le CSV');
+    return { records, redirects: [], warnings };
+  },
+};

package/template/modules/wp-seo-migrator/src/connectors/htaccess.ts

@@ -0,0 +1,65 @@
+/** Groupe B — redirections .htaccess / nginx.conf */
+import type { AnalyzeContext, ExtractResult, RedirectRecord, SeoConnector } from '../types';
+import { pathFromUrl } from './utils';
+
+function push(redir: RedirectRecord[], from: string, to: string, permanent: boolean, source: string) {
+  if (!from || !to) return;
+  redir.push({
+    id: `${source}:${from}`,
+    from: pathFromUrl(from),
+    to: to.startsWith('http') ? to : pathFromUrl(to),
+    permanent,
+    source,
+  });
+}
+
+export const htaccessConnector: SeoConnector = {
+  id: 'htaccess',
+  name: '.htaccess / nginx',
+  fields: ['redirects'],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some((f) => {
+      const n = f.name.toLowerCase();
+      const t = f.text.slice(0, 400).toLowerCase();
+      return n.includes('.htaccess') || n.includes('nginx') || t.includes('rewriteengine') || t.includes('rewrite ^') || t.includes('redirect 301');
+    });
+    return { id: 'htaccess', name: '.htaccess / nginx', found: hit };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const redirects: RedirectRecord[] = [];
+    const warnings: string[] = [];
+    for (const f of ctx.textFiles) {
+      const lines = f.text.split(/\r?\n/);
+      for (const line of lines) {
+        const l = line.trim();
+        if (!l || l.startsWith('#')) continue;
+        // Redirect 301 /old /new
+        let m = /^Redirect\s+(301|302|permanent|temp)\s+(\S+)\s+(\S+)/i.exec(l);
+        if (m) {
+          push(redirects, m[2], m[3], /301|permanent/i.test(m[1]), 'htaccess');
+          continue;
+        }
+        // RedirectMatch 301 ^/old$ /new
+        m = /^RedirectMatch\s+(301|302)\s+(\S+)\s+(\S+)/i.exec(l);
+        if (m) {
+          push(redirects, m[2].replace(/^\^/, '').replace(/\$$/, ''), m[3], m[1] === '301', 'htaccess');
+          continue;
+        }
+        // RewriteRule ^old$ /new [R=301,L]
+        m = /^RewriteRule\s+(\S+)\s+(\S+)\s*\[([^\]]*)\]/i.exec(l);
+        if (m && /R=\d+/i.test(m[3])) {
+          const code = /R=(\d+)/i.exec(m[3])?.[1] || '302';
+          push(redirects, m[1].replace(/^\^/, '').replace(/\$$/, ''), m[2], code === '301', 'htaccess');
+          continue;
+        }
+        // nginx: rewrite ^/old$ /new permanent;
+        m = /^rewrite\s+(\S+)\s+(\S+)\s+(permanent|redirect)/i.exec(l);
+        if (m) {
+          push(redirects, m[1].replace(/^\^/, '').replace(/\$$/, ''), m[2].replace(/;$/, ''), m[3] === 'permanent', 'nginx');
+        }
+      }
+    }
+    if (!redirects.length) warnings.push('Aucune règle de redirection dans .htaccess / nginx');
+    return { records: [], redirects, warnings };
+  },
+};

package/template/modules/wp-seo-migrator/src/connectors/htmlCrawler.ts

@@ -0,0 +1,90 @@
+/**
+ * Groupe F — crawler de secours hors-ligne : HTML déjà téléversé (rendu).
+ * Title, meta, canonical, OG, Twitter, JSON-LD, hreflang.
+ * (Crawl live HTTP = lacune SDK net:hôte — voir ARCHITECTURE.md)
+ */
+import type { AnalyzeContext, ExtractResult, SeoConnector, SeoRecord } from '../types';
+import { pathFromUrl, slugFromPath, stripTags } from './utils';
+
+function meta(html: string, name: string): string | undefined {
+  const re = new RegExp(`<meta[^>]+(?:name|property)=["']${name}["'][^>]+content=["']([^"']*)["']`, 'i');
+  const re2 = new RegExp(`<meta[^>]+content=["']([^"']*)["'][^>]+(?:name|property)=["']${name}["']`, 'i');
+  return re.exec(html)?.[1] || re2.exec(html)?.[1];
+}
+
+function linkRel(html: string, rel: string): string | undefined {
+  const re = new RegExp(`<link[^>]+rel=["']${rel}["'][^>]+href=["']([^"']+)["']`, 'i');
+  const re2 = new RegExp(`<link[^>]+href=["']([^"']+)["'][^>]+rel=["']${rel}["']`, 'i');
+  return re.exec(html)?.[1] || re2.exec(html)?.[1];
+}
+
+export const htmlCrawlerConnector: SeoConnector = {
+  id: 'html-crawler',
+  name: 'HTML rendu (secours)',
+  fields: ['url', 'seoTitle', 'metaDescription', 'canonicalUrl', 'ogTitle', 'ogDescription', 'ogImage', 'schemaJsonLd', 'hreflang', 'noindex'],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some((f) => {
+      const n = f.name.toLowerCase();
+      const t = f.text.slice(0, 300).toLowerCase();
+      return n.endsWith('.html') || n.endsWith('.htm') || t.includes('<html') || t.includes('<!doctype html');
+    });
+    return { id: 'html-crawler', name: 'HTML rendu (secours)', found: hit };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const records: SeoRecord[] = [];
+    const warnings: string[] = [];
+    for (const f of ctx.textFiles) {
+      const html = f.text;
+      if (!/<html|<!doctype html/i.test(html.slice(0, 500))) continue;
+      const title = /<title[^>]*>([^<]*)<\/title>/i.exec(html)?.[1]?.trim();
+      const canonical = linkRel(html, 'canonical');
+      const url =
+        canonical ||
+        meta(html, 'og:url') ||
+        `https://imported.local/${f.name.replace(/\.html?$/i, '')}`;
+      const path = pathFromUrl(url);
+      const robots = (meta(html, 'robots') || '').toLowerCase();
+      const jsonLds = [...html.matchAll(/<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)].map((m) =>
+        m[1].trim()
+      );
+      const hreflang = [...html.matchAll(/<link[^>]+rel=["']alternate["'][^>]+hreflang=["']([^"']+)["'][^>]+href=["']([^"']+)["']/gi)].map(
+        (m) => ({ lang: m[1], url: m[2] })
+      );
+      const alts = [...html.matchAll(/<img[^>]+src=["']([^"']+)["'][^>]*alt=["']([^"']*)["']/gi)].map((m) => ({
+        src: m[1],
+        alt: m[2],
+      }));
+      records.push({
+        id: `html:${path}`,
+        kind: 'other',
+        url,
+        path,
+        slug: slugFromPath(path),
+        status: 'publish',
+        title: title ? stripTags(title) : undefined,
+        seoTitle: title ? stripTags(title) : undefined,
+        metaDescription: meta(html, 'description'),
+        canonicalUrl: canonical,
+        ogTitle: meta(html, 'og:title'),
+        ogDescription: meta(html, 'og:description'),
+        ogImage: meta(html, 'og:image'),
+        twitterCard: (meta(html, 'twitter:card') as 'summary' | 'summary_large_image' | undefined) || undefined,
+        schemaJsonLd: jsonLds[0],
+        schemaType: jsonLds[0]?.includes('Product') ? 'Product' : jsonLds[0]?.includes('Article') ? 'Article' : undefined,
+        hreflang: hreflang.length ? hreflang : undefined,
+        imageAlts: alts.length ? alts : undefined,
+        noindex: robots.includes('noindex'),
+        nofollow: robots.includes('nofollow'),
+        sources: {
+          url: 'html-crawler',
+          seoTitle: 'html-crawler',
+          metaDescription: 'html-crawler',
+          canonicalUrl: canonical ? 'html-crawler' : undefined,
+          schemaJsonLd: jsonLds[0] ? 'html-crawler' : undefined,
+        },
+      });
+    }
+    if (!records.length) warnings.push('HTML : aucun fichier de page détecté');
+    return { records, redirects: [], warnings };
+  },
+};