create-snapify-app 0.0.0-stage → 1.1.1

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

@@ -0,0 +1,113 @@
+import type { AnalyzeContext, ConnectorDetect, ExtractResult, SeoConnector, SeoRecord, RedirectRecord } from '../types';
+import { pickTextFiles } from './utils';
+import { wxrConnector } from './wxr';
+import { yoastCsvConnector } from './yoastCsv';
+import { rankMathCsvConnector } from './rankMathCsv';
+import { redirectionConnector } from './redirection';
+import { exporterConnector } from './exporter';
+import {
+  aioseoCsvConnector,
+  seopressCsvConnector,
+  tsfCsvConnector,
+  slimSeoCsvConnector,
+  screamingFrogConnector,
+} from './pluginCsv';
+import { htaccessConnector } from './htaccess';
+import { sitemapConnector } from './sitemap';
+import { gscCsvConnector } from './gscCsv';
+import { htmlCrawlerConnector } from './htmlCrawler';
+
+export const CONNECTORS: SeoConnector[] = [
+  exporterConnector,
+  wxrConnector,
+  yoastCsvConnector,
+  rankMathCsvConnector,
+  aioseoCsvConnector,
+  seopressCsvConnector,
+  tsfCsvConnector,
+  slimSeoCsvConnector,
+  screamingFrogConnector,
+  redirectionConnector,
+  htaccessConnector,
+  sitemapConnector,
+  gscCsvConnector,
+  htmlCrawlerConnector,
+];
+
+const RICHNESS: (keyof SeoRecord)[] = [
+  'seoTitle',
+  'metaDescription',
+  'focusKeyphrase',
+  'canonicalUrl',
+  'ogTitle',
+  'ogDescription',
+  'ogImage',
+  'schemaJsonLd',
+  'schemaType',
+  'breadcrumbsTitle',
+];
+
+function richer(a: unknown, b: unknown): boolean {
+  const sa = typeof a === 'string' ? a.trim().length : a == null ? 0 : 1;
+  const sb = typeof b === 'string' ? b.trim().length : b == null ? 0 : 1;
+  return sb > sa;
+}
+
+/** Fusion par chemin : la valeur la plus riche gagne, sources tracées. */
+export function mergeRecords(parts: ExtractResult[]): { records: SeoRecord[]; redirects: RedirectRecord[]; warnings: string[] } {
+  const byPath = new Map<string, SeoRecord>();
+  const redirs = new Map<string, RedirectRecord>();
+  const warnings: string[] = [];
+  for (const part of parts) {
+    warnings.push(...part.warnings);
+    for (const r of part.records) {
+      const key = r.path || r.url;
+      const cur = byPath.get(key);
+      if (!cur) {
+        byPath.set(key, { ...r, sources: { ...r.sources } });
+        continue;
+      }
+      const next = { ...cur };
+      for (const field of RICHNESS) {
+        const incoming = r[field];
+        if (incoming == null || incoming === '') continue;
+        if (richer(cur[field], incoming)) {
+          (next as Record<string, unknown>)[field] = incoming;
+          if (r.sources[field as keyof typeof r.sources]) {
+            next.sources = { ...next.sources, [field]: r.sources[field as keyof typeof r.sources] };
+          }
+        } else if (cur[field] == null || cur[field] === '') {
+          (next as Record<string, unknown>)[field] = incoming;
+          next.sources = { ...next.sources, ...(r.sources || {}) };
+        }
+      }
+      if (r.noindex) next.noindex = true;
+      if (r.nofollow) next.nofollow = true;
+      if (r.hreflang?.length) next.hreflang = [...(next.hreflang || []), ...r.hreflang];
+      if (r.imageAlts?.length) next.imageAlts = [...(next.imageAlts || []), ...r.imageAlts];
+      if (!next.title && r.title) next.title = r.title;
+      if (next.kind === 'other' && r.kind !== 'other') next.kind = r.kind;
+      byPath.set(key, next);
+    }
+    for (const re of part.redirects) {
+      if (!redirs.has(re.from)) redirs.set(re.from, re);
+    }
+  }
+  return { records: [...byPath.values()], redirects: [...redirs.values()], warnings };
+}
+
+export function runConnectors(files: AnalyzeContext['files'], siteUrl?: string) {
+  const textFiles = pickTextFiles(files);
+  const ctx: AnalyzeContext = { siteUrl, files, textFiles };
+  const detects: ConnectorDetect[] = CONNECTORS.map((c) => c.detect(ctx));
+  const parts: ExtractResult[] = [];
+  for (const c of CONNECTORS) {
+    if (!detects.find((d) => d.id === c.id)?.found) continue;
+    parts.push(c.extract(ctx) as ExtractResult);
+  }
+  if (!parts.length && textFiles.length) {
+    for (const c of CONNECTORS) parts.push(c.extract(ctx) as ExtractResult);
+  }
+  const merged = mergeRecords(parts);
+  return { detects, ...merged };
+}

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

@@ -0,0 +1,77 @@
+/** Groupe A + F — exports CSV plugins SEO et crawlers */
+import { createCsvSeoConnector } from './csvSeoFactory';
+
+export const aioseoCsvConnector = createCsvSeoConnector({
+  id: 'aioseo-csv',
+  name: 'All in One SEO (CSV)',
+  detectHints: ['aioseo', 'all-in-one-seo', 'all in one seo', '_aioseo'],
+  columns: {
+    url: ['url', 'permalink', 'address', 'lien'],
+    seoTitle: ['title', 'seo title', 'meta title'],
+    metaDescription: ['description', 'meta description'],
+    focusKeyphrase: ['keyphrases', 'keywords', 'focus keyword'],
+    canonicalUrl: ['canonical', 'canonical url'],
+    ogTitle: ['og title', 'facebook title'],
+    ogDescription: ['og description', 'facebook description'],
+    ogImage: ['og image', 'facebook image'],
+    noindex: ['robots', 'noindex'],
+  },
+});
+
+export const seopressCsvConnector = createCsvSeoConnector({
+  id: 'seopress-csv',
+  name: 'SEOPress (CSV)',
+  detectHints: ['seopress', '_seopress'],
+  columns: {
+    url: ['url', 'permalink', 'address'],
+    seoTitle: ['title', 'meta title', 'seopress_titles_title'],
+    metaDescription: ['description', 'meta description', 'seopress_titles_desc'],
+    focusKeyphrase: ['target keyword', 'keyword'],
+    canonicalUrl: ['canonical url', 'canonical'],
+    ogTitle: ['og:title', 'facebook title'],
+    ogDescription: ['og:description', 'facebook description'],
+    noindex: ['noindex', 'robots'],
+  },
+});
+
+export const tsfCsvConnector = createCsvSeoConnector({
+  id: 'tsf-csv',
+  name: 'The SEO Framework (CSV)',
+  detectHints: ['the seo framework', 'tsf', '_tsf', 'genesis_title'],
+  columns: {
+    url: ['url', 'permalink', 'address'],
+    seoTitle: ['title', 'meta title', '_genesis_title'],
+    metaDescription: ['description', 'meta description', '_genesis_description'],
+    canonicalUrl: ['canonical', 'canonical url'],
+    noindex: ['noindex', '_genesis_noindex'],
+  },
+});
+
+export const slimSeoCsvConnector = createCsvSeoConnector({
+  id: 'slim-seo-csv',
+  name: 'Slim SEO (CSV)',
+  detectHints: ['slim seo', 'slim-seo', 'slimseo'],
+  columns: {
+    url: ['url', 'permalink'],
+    seoTitle: ['title', 'seo title'],
+    metaDescription: ['description', 'meta description'],
+    canonicalUrl: ['canonical'],
+    noindex: ['noindex'],
+  },
+});
+
+export const screamingFrogConnector = createCsvSeoConnector({
+  id: 'screamingfrog-csv',
+  name: 'Screaming Frog / Semrush / Ahrefs (CSV)',
+  detectHints: ['screaming', 'internal_all', 'semrush', 'ahrefs', 'indexability', 'address,content type'],
+  columns: {
+    url: ['address', 'url', 'page url'],
+    seoTitle: ['title 1', 'title', 'seo title'],
+    metaDescription: ['meta description 1', 'meta description', 'description'],
+    canonicalUrl: ['canonical link element 1', 'canonical'],
+    ogTitle: ['og:title', 'open graph title'],
+    ogDescription: ['og:description'],
+    ogImage: ['og:image'],
+    noindex: ['indexability', 'meta robots 1'],
+  },
+});

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

@@ -0,0 +1,77 @@
+/** CSV Rank Math export */
+import type { AnalyzeContext, ExtractResult, SeoConnector, SeoRecord } from '../types';
+import { pathFromUrl, slugFromPath } from './utils';
+
+function parseCsv(text: string): string[][] {
+  return text
+    .split(/\r?\n/)
+    .filter((l) => l.trim())
+    .map((line) => {
+      const cols: string[] = [];
+      let cur = '';
+      let q = false;
+      for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (q) {
+          if (c === '"' && line[i + 1] === '"') {
+            cur += '"';
+            i++;
+          } else if (c === '"') q = false;
+          else cur += c;
+        } else if (c === '"') q = true;
+        else if (c === ',') {
+          cols.push(cur);
+          cur = '';
+        } else cur += c;
+      }
+      cols.push(cur);
+      return cols;
+    });
+}
+
+export const rankMathCsvConnector: SeoConnector = {
+  id: 'rankmath-csv',
+  name: 'Rank Math (CSV)',
+  fields: ['url', 'seoTitle', 'metaDescription', 'focusKeyphrase', 'canonicalUrl', 'schemaType'],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some((f) => {
+      const h = f.text.slice(0, 500).toLowerCase();
+      return h.includes('rank_math') || h.includes('rank math') || (f.name.includes('rank') && f.name.endsWith('.csv'));
+    });
+    return { id: 'rankmath-csv', name: 'Rank Math (CSV)', found: hit };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const records: SeoRecord[] = [];
+    for (const f of ctx.textFiles) {
+      const head = f.text.slice(0, 300).toLowerCase();
+      if (!(head.includes('rank') || f.name.includes('rank'))) continue;
+      const rows = parseCsv(f.text);
+      if (rows.length < 2) continue;
+      const header = rows[0].map((h) => h.trim().toLowerCase());
+      const col = (...names: string[]) => names.map((n) => header.indexOf(n)).find((i) => i >= 0) ?? -1;
+      const iUrl = col('url', 'permalink', 'link');
+      const iTitle = col('title', 'seo title', 'rank_math_title');
+      const iDesc = col('description', 'meta description', 'rank_math_description');
+      const iKw = col('focus keyword', 'focus_keyword', 'keyword');
+      if (iUrl < 0) continue;
+      for (const r of rows.slice(1)) {
+        const url = (r[iUrl] || '').trim();
+        if (!url) continue;
+        const path = pathFromUrl(url);
+        records.push({
+          id: `rankmath-csv:${path}`,
+          kind: 'other',
+          url,
+          path,
+          slug: slugFromPath(path),
+          status: 'publish',
+          seoTitle: iTitle >= 0 ? r[iTitle] : undefined,
+          metaDescription: iDesc >= 0 ? r[iDesc] : undefined,
+          focusKeyphrase: iKw >= 0 ? r[iKw] : undefined,
+          sources: { url: 'rankmath-csv', seoTitle: 'rankmath-csv', metaDescription: 'rankmath-csv' },
+        });
+      }
+    }
+    return { records, redirects: [], warnings: [] };
+  },
+};

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

@@ -0,0 +1,62 @@
+/** Redirection (J. Godley) JSON/CSV + Simple 301-like CSV */
+import type { AnalyzeContext, ExtractResult, RedirectRecord, SeoConnector } from '../types';
+import { pathFromUrl, safeJson } from './utils';
+
+export const redirectionConnector: SeoConnector = {
+  id: 'redirection',
+  name: 'Redirections',
+  fields: ['redirects'],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some((f) => {
+      const t = f.text.slice(0, 800).toLowerCase();
+      return (
+        t.includes('"url"') && t.includes('"action_data"') ||
+        t.includes('source') && t.includes('target') ||
+        f.name.includes('redirection') ||
+        (t.includes('from') && t.includes('to') && f.name.endsWith('.csv'))
+      );
+    });
+    return { id: 'redirection', name: 'Redirections', found: hit };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const redirects: RedirectRecord[] = [];
+    const warnings: string[] = [];
+    for (const f of ctx.textFiles) {
+      const json = safeJson<{ redirects?: { url?: string; action_data?: { url?: string }; match_data?: unknown; enabled?: boolean }[] } | { url?: string; action_data?: { url?: string } }[]>(f.text);
+      const list = Array.isArray(json) ? json : json?.redirects;
+      if (list?.length) {
+        for (const r of list) {
+          const from = pathFromUrl(String(r.url || ''));
+          const to = String(r.action_data?.url || '').trim();
+          if (!from || !to) continue;
+          redirects.push({ id: `redir:${from}`, from, to: to.startsWith('http') ? to : pathFromUrl(to), permanent: true, source: 'redirection' });
+        }
+        continue;
+      }
+      if (f.name.endsWith('.csv') || f.text.includes(',')) {
+        const lines = f.text.split(/\r?\n/).filter(Boolean);
+        const header = (lines[0] || '').toLowerCase();
+        if (!(header.includes('source') || header.includes('from') || header.includes('url'))) continue;
+        const cols = lines[0].split(',').map((c) => c.trim().toLowerCase().replace(/"/g, ''));
+        const iFrom = cols.findIndex((c) => ['source', 'from', 'url', 'old'].includes(c));
+        const iTo = cols.findIndex((c) => ['target', 'to', 'new', 'destination'].includes(c));
+        if (iFrom < 0 || iTo < 0) continue;
+        for (const line of lines.slice(1)) {
+          const parts = line.split(',').map((p) => p.trim().replace(/^"|"$/g, ''));
+          const from = pathFromUrl(parts[iFrom] || '');
+          const to = parts[iTo] || '';
+          if (!from || !to) continue;
+          redirects.push({
+            id: `redir-csv:${from}`,
+            from,
+            to: to.startsWith('http') ? to : pathFromUrl(to),
+            permanent: true,
+            source: 'redirection-csv',
+          });
+        }
+      }
+    }
+    if (!redirects.length) warnings.push('Aucune redirection trouvée dans les fichiers');
+    return { records: [], redirects, warnings };
+  },
+};

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

@@ -0,0 +1,44 @@
+/** Groupe F — index / sous-sitemaps XML (URLs à prioriser) */
+import type { AnalyzeContext, ExtractResult, SeoConnector, SeoRecord } from '../types';
+import { pathFromUrl, slugFromPath } from './utils';
+
+export const sitemapConnector: SeoConnector = {
+  id: 'sitemap',
+  name: 'Sitemap XML',
+  fields: ['url', 'slug'],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some(
+      (f) =>
+        f.name.includes('sitemap') ||
+        f.text.includes('<urlset') ||
+        f.text.includes('<sitemapindex')
+    );
+    return { id: 'sitemap', name: 'Sitemap XML', found: hit };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const records: SeoRecord[] = [];
+    const warnings: string[] = [];
+    const seen = new Set<string>();
+    for (const f of ctx.textFiles) {
+      if (!(f.text.includes('<url') || f.text.includes('<sitemap'))) continue;
+      const locs = [...f.text.matchAll(/<loc>\s*([^<]+)\s*<\/loc>/gi)].map((m) => m[1].trim());
+      for (const url of locs) {
+        if (url.endsWith('.xml')) continue; // index entry — pas une page
+        const path = pathFromUrl(url);
+        if (seen.has(path)) continue;
+        seen.add(path);
+        records.push({
+          id: `sitemap:${path}`,
+          kind: path.includes('/product') ? 'product' : path.includes('/category') || path.includes('/tag') ? 'term' : 'other',
+          url,
+          path,
+          slug: slugFromPath(path),
+          status: 'publish',
+          sources: { url: 'sitemap' },
+        });
+      }
+    }
+    if (!records.length) warnings.push('Sitemap : aucune URL <loc> trouvée');
+    return { records, redirects: [], warnings };
+  },
+};

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

@@ -0,0 +1,111 @@
+/** Helpers parse / paths */
+
+export function parseCsv(text: string): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let cur = '';
+  let q = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (q) {
+      if (c === '"' && text[i + 1] === '"') {
+        cur += '"';
+        i++;
+      } else if (c === '"') q = false;
+      else cur += c;
+    } else if (c === '"') q = true;
+    else if (c === ',') {
+      row.push(cur);
+      cur = '';
+    } else if (c === '\n' || c === '\r') {
+      if (c === '\r' && text[i + 1] === '\n') i++;
+      row.push(cur);
+      if (row.some((x) => x.trim())) rows.push(row);
+      row = [];
+      cur = '';
+    } else cur += c;
+  }
+  if (cur || row.length) {
+    row.push(cur);
+    if (row.some((x) => x.trim())) rows.push(row);
+  }
+  return rows;
+}
+
+export function csvIdx(header: string[], ...names: string[]): number {
+  const lower = header.map((h) => h.trim().toLowerCase());
+  for (const n of names) {
+    const i = lower.indexOf(n.toLowerCase());
+    if (i >= 0) return i;
+  }
+  // fuzzy contains
+  for (const n of names) {
+    const i = lower.findIndex((h) => h.includes(n.toLowerCase()));
+    if (i >= 0) return i;
+  }
+  return -1;
+}
+
+export function decodeFile(f: { content: string; encoding: 'utf8' | 'base64' }): string {
+  if (f.encoding === 'base64') {
+    try {
+      return Buffer.from(f.content, 'base64').toString('utf8');
+    } catch {
+      return '';
+    }
+  }
+  return f.content;
+}
+
+/** Décode %xx (ex. arabe) pour affichage et chemins lisibles. */
+export function decodePath(path: string): string {
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return path.replace(/%[0-9A-Fa-f]{2}/g, (m) => {
+      try {
+        return decodeURIComponent(m);
+      } catch {
+        return m;
+      }
+    });
+  }
+}
+
+export function pathFromUrl(url: string): string {
+  try {
+    const u = new URL(url, 'https://example.invalid');
+    let p = u.pathname || '/';
+    if (!p.startsWith('/')) p = `/${p}`;
+    if (p.length > 1 && p.endsWith('/')) p = p.slice(0, -1);
+    return decodePath(p) || '/';
+  } catch {
+    const p = url.startsWith('/') ? url : `/${url}`;
+    return decodePath(p.replace(/\/$/, '') || '/');
+  }
+}
+
+export function slugFromPath(path: string): string {
+  const seg = decodePath(path).split('/').filter(Boolean);
+  return seg[seg.length - 1] || 'home';
+}
+
+export function stripTags(html: string): string {
+  return html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+export function safeJson<T>(text: string): T | null {
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return null;
+  }
+}
+
+export function pickTextFiles(
+  files: { name: string; content: string; encoding: 'utf8' | 'base64' }[]
+): { name: string; text: string }[] {
+  return files
+    .map((f) => ({ name: f.name.toLowerCase(), text: decodeFile(f) }))
+    .filter((f) => f.text.length > 0);
+}

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

@@ -0,0 +1,103 @@
+/**
+ * Connecteur WXR (export WordPress XML) — titres, liens, meta postmeta Yoast/Rank Math.
+ */
+import type { AnalyzeContext, ExtractResult, RedirectRecord, SeoConnector, SeoRecord } from '../types';
+import { pathFromUrl, slugFromPath, stripTags } from './utils';
+
+function metaMap(itemXml: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  const re = /<wp:postmeta>[\s\S]*?<wp:meta_key><!\[CDATA\[(.*?)\]\]><\/wp:meta_key>[\s\S]*?<wp:meta_value><!\[CDATA\[([\s\S]*?)\]\]><\/wp:meta_value>[\s\S]*?<\/wp:postmeta>/gi;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(itemXml))) out[m[1]] = m[2];
+  // fallback without CDATA
+  const re2 =
+    /<wp:meta_key>([^<]+)<\/wp:meta_key>[\s\S]*?<wp:meta_value>([\s\S]*?)<\/wp:meta_value>/gi;
+  while ((m = re2.exec(itemXml))) {
+    const k = m[1].trim();
+    if (!out[k]) out[k] = stripTags(m[2]);
+  }
+  return out;
+}
+
+function tag(xml: string, name: string): string {
+  const cdata = xml.match(new RegExp(`<${name}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${name}>`, 'i'));
+  if (cdata) return cdata[1].trim();
+  const plain = xml.match(new RegExp(`<${name}>([\\s\\S]*?)<\\/${name}>`, 'i'));
+  return plain ? stripTags(plain[1]) : '';
+}
+
+function parseItems(xml: string): SeoRecord[] {
+  const items = xml.match(/<item>[\s\S]*?<\/item>/gi) || [];
+  const records: SeoRecord[] = [];
+  for (const item of items) {
+    const postType = tag(item, 'wp:post_type') || 'post';
+    if (!['post', 'page', 'product'].includes(postType)) continue;
+    const statusRaw = tag(item, 'wp:status') || 'publish';
+    const link = tag(item, 'link');
+    const title = tag(item, 'title');
+    const path = pathFromUrl(link);
+    const meta = metaMap(item);
+    const kind = postType === 'page' ? 'page' : postType === 'product' ? 'product' : 'post';
+    const sources: SeoRecord['sources'] = { url: 'wxr' };
+
+    const yoastTitle = meta['_yoast_wpseo_title'] || meta['rank_math_title'];
+    const yoastDesc = meta['_yoast_wpseo_metadesc'] || meta['rank_math_description'];
+    const focus = meta['_yoast_wpseo_focuskw'] || meta['rank_math_focus_keyword'];
+    const canonical = meta['_yoast_wpseo_canonical'] || meta['rank_math_canonical_url'];
+    const noindex =
+      meta['_yoast_wpseo_meta-robots-noindex'] === '1' || meta['rank_math_robots']?.includes('noindex');
+    const ogTitle = meta['_yoast_wpseo_opengraph-title'] || meta['rank_math_facebook_title'];
+    const ogDesc = meta['_yoast_wpseo_opengraph-description'] || meta['rank_math_facebook_description'];
+    const ogImage = meta['_yoast_wpseo_opengraph-image'] || meta['rank_math_facebook_image'];
+
+    if (yoastTitle) sources.seoTitle = meta['_yoast_wpseo_title'] ? 'yoast' : 'rankmath';
+    if (yoastDesc) sources.metaDescription = meta['_yoast_wpseo_metadesc'] ? 'yoast' : 'rankmath';
+    if (focus) sources.focusKeyphrase = meta['_yoast_wpseo_focuskw'] ? 'yoast' : 'rankmath';
+    if (canonical) sources.canonicalUrl = meta['_yoast_wpseo_canonical'] ? 'yoast' : 'rankmath';
+
+    records.push({
+      id: `wxr:${tag(item, 'wp:post_id') || path}`,
+      kind,
+      url: link || path,
+      path,
+      slug: slugFromPath(path),
+      status: statusRaw === 'publish' ? 'publish' : statusRaw === 'draft' ? 'draft' : 'other',
+      title,
+      seoTitle: yoastTitle || title,
+      metaDescription: yoastDesc || undefined,
+      focusKeyphrase: focus || undefined,
+      canonicalUrl: canonical || undefined,
+      noindex: !!noindex,
+      nofollow: false,
+      ogTitle: ogTitle || undefined,
+      ogDescription: ogDesc || undefined,
+      ogImage: ogImage || undefined,
+      twitterCard: 'summary_large_image',
+      schemaType: kind === 'product' ? 'Product' : kind === 'post' ? 'Article' : 'WebPage',
+      sources,
+    });
+  }
+  return records;
+}
+
+export const wxrConnector: SeoConnector = {
+  id: 'wxr',
+  name: 'Export WordPress (WXR)',
+  fields: ['url', 'slug', 'seoTitle', 'metaDescription', 'focusKeyphrase', 'canonicalUrl', 'noindex', 'ogTitle', 'ogDescription', 'ogImage'],
+  detect: (ctx: AnalyzeContext) => {
+    const hit = ctx.textFiles.some((f) => f.text.includes('<wp:wxr_version>') || (f.text.includes('<rss') && f.text.includes('xmlns:wp=')));
+    return { id: 'wxr', name: 'Export WordPress (WXR)', found: hit, detail: hit ? 'Fichier XML WordPress détecté' : undefined };
+  },
+  extract: (ctx: AnalyzeContext): ExtractResult => {
+    const records: SeoRecord[] = [];
+    const redirects: RedirectRecord[] = [];
+    const warnings: string[] = [];
+    for (const f of ctx.textFiles) {
+      if (!(f.text.includes('<wp:wxr_version>') || f.text.includes('xmlns:wp='))) continue;
+      const part = parseItems(f.text);
+      if (!part.length) warnings.push(`Aucune page/article lisible dans ${f.name}`);
+      records.push(...part);
+    }
+    return { records, redirects, warnings };
+  },
+};

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

@@ -0,0 +1,56 @@
+/** CSV export Yoast / Screaming Frog-like with yoast columns */
+import type { AnalyzeContext, ExtractResult, SeoConnector, SeoRecord } from '../types';
+import { csvIdx, parseCsv, pathFromUrl, slugFromPath } from './utils';
+
+export const yoastCsvConnector: SeoConnector = {
+  id: 'yoast-csv',
+  name: 'Yoast (CSV)',
+  fields: ['url', 'seoTitle', 'metaDescription', 'focusKeyphrase', 'canonicalUrl'],
+  detect: (ctx) => {
+    const hit = ctx.textFiles.some((f) => {
+      const h = f.text.slice(0, 400).toLowerCase();
+      return h.includes('seo title') || h.includes('meta description') || h.includes('_yoast') || (h.includes('title') && h.includes('url') && f.name.includes('yoast'));
+    });
+    return { id: 'yoast-csv', name: 'Yoast (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, 'url', 'address', 'permalink', 'lien');
+      const iTitle = csvIdx(header, 'seo title', 'title', 'titre seo', 'meta title');
+      const iDesc = csvIdx(header, 'meta description', 'description', 'meta desc');
+      const iKw = csvIdx(header, 'keyphrase', 'focus keyphrase', 'keyword', 'mot-clé');
+      const iCanon = csvIdx(header, 'canonical', 'canonical url');
+      if (iUrl < 0) continue;
+      for (const r of rows.slice(1)) {
+        const url = (r[iUrl] || '').trim();
+        if (!url) continue;
+        const path = pathFromUrl(url);
+        records.push({
+          id: `yoast-csv:${path}`,
+          kind: 'other',
+          url,
+          path,
+          slug: slugFromPath(path),
+          status: 'publish',
+          seoTitle: iTitle >= 0 ? r[iTitle] : undefined,
+          metaDescription: iDesc >= 0 ? r[iDesc] : undefined,
+          focusKeyphrase: iKw >= 0 ? r[iKw] : undefined,
+          canonicalUrl: iCanon >= 0 ? r[iCanon] : undefined,
+          sources: {
+            url: 'yoast-csv',
+            seoTitle: iTitle >= 0 ? 'yoast-csv' : undefined,
+            metaDescription: iDesc >= 0 ? 'yoast-csv' : undefined,
+          },
+        });
+      }
+    }
+    if (!records.length) warnings.push('CSV Yoast : aucune ligne URL trouvée');
+    return { records, redirects: [], warnings };
+  },
+};