@topy-ai/maggie 0.7.33 → 0.7.35

package/bundled-templates/astro-blog/starter/src/lib/wordpress.ts

@@ -0,0 +1,847 @@
+import { createHash } from "node:crypto";
+import { audit, db, id, now } from "./db";
+
+export type WordPressImportOptions = {
+  maxPosts: number;
+  maxTerms: number;
+  mediaMode: "featured" | "all";
+  preservePublished: boolean;
+  includeDrafts: boolean;
+  incremental: boolean;
+  syncMode: "all" | "modified" | "new";
+  detectDeleted: boolean;
+  conflictStrategy: "wordpress-wins" | "maggie-wins" | "manual";
+  postTypes: string[];
+  mapping: {
+    categoryToTopic: Record<string, string>;
+    authorToAuthor: Record<string, string>;
+    tagToTaxonomy: string;
+    featuredImageToMedia: boolean;
+    seo: Record<string, boolean>;
+  };
+};
+export type WordPressCounts = {
+  posts: {
+    total: number;
+    created: number;
+    updated: number;
+    skipped: number;
+    deleted: number;
+    conflicts: number;
+  };
+  categories: number;
+  tags: number;
+  authors: number;
+  media: number;
+  redirects: number;
+};
+type WpItem = any;
+
+function apiRoot(sourceUrl: string): string {
+  const input = new URL(sourceUrl);
+  if (input.pathname.includes("/wp-json/wp/v2"))
+    return input.toString().replace(/\/$/, "");
+  return `${input.origin}${input.pathname.replace(/\/$/, "")}/wp-json/wp/v2`.replace(
+    /\/\/wp-json/,
+    "/wp-json",
+  );
+}
+function headers(): HeadersInit {
+  const result: Record<string, string> = { accept: "application/json" };
+  if (import.meta.env.WORDPRESS_API_TOKEN)
+    result.authorization = `Bearer ${import.meta.env.WORDPRESS_API_TOKEN}`;
+  else if (
+    import.meta.env.WORDPRESS_USERNAME &&
+    import.meta.env.WORDPRESS_APP_PASSWORD
+  )
+    result.authorization = `Basic ${btoa(`${import.meta.env.WORDPRESS_USERNAME}:${import.meta.env.WORDPRESS_APP_PASSWORD}`)}`;
+  return result;
+}
+async function fetchPage(
+  root: string,
+  resource: string,
+  page: number,
+  perPage = 100,
+  includeDrafts = false,
+): Promise<{ items: WpItem[]; total: number; totalPages: number }> {
+  const url = new URL(`${root}/${resource}`);
+  url.searchParams.set("page", String(page));
+  url.searchParams.set("per_page", String(perPage));
+  if (resource === "posts" || resource === "pages") {
+    if (includeDrafts)
+      for (const status of ["publish", "draft", "pending", "private", "future"])
+        url.searchParams.append("status[]", status);
+    else url.searchParams.set("status", "publish");
+    url.searchParams.set("_embed", "author,wp:term,wp:featuredmedia");
+  }
+  const response = await fetch(url, {
+    headers: headers(),
+    signal: AbortSignal.timeout(30000),
+  });
+  const raw = await response.text();
+  let body: any;
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    throw new Error(`WordPress ${resource} returned invalid JSON`);
+  }
+  if (!response.ok)
+    throw new Error(
+      `WordPress ${resource} returned ${response.status}: ${JSON.stringify(body).slice(0, 500)}`,
+    );
+  return {
+    items: Array.isArray(body) ? body : [],
+    total: Number(response.headers.get("X-WP-Total") || body.length || 0),
+    totalPages: Number(response.headers.get("X-WP-TotalPages") || page),
+  };
+}
+async function fetchCollection(
+  root: string,
+  resource: string,
+  limit: number,
+  includeDrafts = false,
+): Promise<{ items: WpItem[]; total: number }> {
+  const items: WpItem[] = [];
+  let page = 1;
+  let total = 0;
+  let totalPages = 1;
+  while (page <= totalPages && items.length < limit) {
+    const result = await fetchPage(root, resource, page, 100, includeDrafts);
+    total = result.total;
+    totalPages = result.totalPages;
+    items.push(...result.items.slice(0, limit - items.length));
+    page++;
+  }
+  return { items, total };
+}
+async function fetchPostTypes(
+  root: string,
+  options: WordPressImportOptions,
+): Promise<{ items: WpItem[]; total: number }> {
+  const resources = (options.postTypes || ["post"])
+    .map((type) =>
+      type === "page" ? "pages" : type === "post" ? "posts" : type,
+    )
+    .filter((resource) => /^[a-z0-9_-]+$/.test(resource));
+  const results = await Promise.all(
+    resources.map((resource) =>
+      fetchCollection(
+        root,
+        resource,
+        options.maxPosts,
+        options.includeDrafts,
+      ).catch(() => ({ items: [] as WpItem[], total: 0 })),
+    ),
+  );
+  return {
+    items: results.flatMap((result) => result.items).slice(0, options.maxPosts),
+    total: results.reduce((total, result) => total + result.total, 0),
+  };
+}
+function text(value: any): string {
+  return String(value?.rendered ?? value ?? "")
+    .replace(/<[^>]*>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+function slug(value: string): string {
+  return (
+    value
+      .toLowerCase()
+      .normalize("NFKD")
+      .replace(/[^\w\s-]/g, "")
+      .trim()
+      .replace(/[\s_-]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 180) || "untitled"
+  );
+}
+function sourceLink(item: WpItem): string | undefined {
+  return typeof item.link === "string" && /^https?:\/\//.test(item.link)
+    ? item.link
+    : undefined;
+}
+function embeddedTerms(post: WpItem): WpItem[] {
+  return (post?._embedded?.["wp:term"] || [])
+    .flat()
+    .filter(
+      (term: WpItem) =>
+        term?.taxonomy === "category" || term?.taxonomy === "post_tag",
+    );
+}
+function embeddedMedia(post: WpItem): WpItem | undefined {
+  return post?._embedded?.["wp:featuredmedia"]?.[0];
+}
+function defaultOptions(
+  options?: Partial<WordPressImportOptions>,
+): WordPressImportOptions {
+  return {
+    maxPosts: Math.min(Math.max(options?.maxPosts || 100, 1), 10000),
+    maxTerms: Math.min(Math.max(options?.maxTerms || 1000, 1), 10000),
+    mediaMode: options?.mediaMode === "all" ? "all" : "featured",
+    preservePublished: options?.preservePublished === true,
+    includeDrafts: options?.includeDrafts === true,
+    incremental: options?.incremental === true,
+    syncMode:
+      options?.syncMode === "modified" || options?.syncMode === "new"
+        ? options.syncMode
+        : "all",
+    detectDeleted: options?.detectDeleted === true,
+    conflictStrategy:
+      options?.conflictStrategy === "wordpress-wins" ||
+      options?.conflictStrategy === "maggie-wins"
+        ? options.conflictStrategy
+        : "manual",
+    postTypes:
+      Array.isArray(options?.postTypes) && options.postTypes.length
+        ? options.postTypes.map(String)
+        : ["post"],
+    mapping: {
+      categoryToTopic: options?.mapping?.categoryToTopic || {},
+      authorToAuthor: options?.mapping?.authorToAuthor || {},
+      tagToTaxonomy: options?.mapping?.tagToTaxonomy || "tag",
+      featuredImageToMedia: options?.mapping?.featuredImageToMedia !== false,
+      seo: options?.mapping?.seo || {
+        yoast: true,
+        rankMath: true,
+        aioseo: true,
+        customFields: true,
+      },
+    },
+  };
+}
+function checksum(item: WpItem): string {
+  return createHash("sha256")
+    .update(
+      JSON.stringify({
+        id: item.id,
+        slug: item.slug,
+        title: item.title,
+        content: item.content,
+        modified: item.modified,
+      }),
+    )
+    .digest("hex");
+}
+function normalizedSeo(item: WpItem): {
+  seoTitle: string | null;
+  metaDescription: string | null;
+  focusKeyword: string | null;
+  canonicalOverride: string | null;
+  robotsIndex: string;
+  robotsFollow: string;
+  ogImageUrl: string | null;
+  schemaType: string;
+} {
+  const meta = item.meta || {};
+  const yoast = item.yoast_head_json || {};
+  const value = (...values: any[]) =>
+    values
+      .find((candidate) => typeof candidate === "string" && candidate.trim())
+      ?.trim() || null;
+  const robots =
+    value(
+      meta._yoast_wpseo_meta_robots_noindex,
+      meta.rank_math_robots,
+      meta._aioseo_robots,
+    ) || "index,follow";
+  const customMetadata = Object.fromEntries(
+    Object.entries(meta).filter(
+      ([key]) => !/^(_yoast|rank_math|_aioseo)/i.test(key),
+    ),
+  );
+  const target = item.id
+    ? (db()
+        .prepare("SELECT id FROM posts WHERE source='cms' AND source_id=?")
+        .get(`wordpress:${item.id}`) as { id: string } | undefined)
+    : undefined;
+  if (target)
+    db()
+      .prepare("UPDATE posts SET custom_metadata_json=? WHERE id=?")
+      .run(JSON.stringify(customMetadata), target.id);
+  return {
+    seoTitle: value(
+      yoast.title,
+      meta._yoast_wpseo_title,
+      meta.rank_math_title,
+      meta._aioseo_title,
+    ),
+    metaDescription: value(
+      yoast.description,
+      meta._yoast_wpseo_metadesc,
+      meta.rank_math_description,
+      meta._aioseo_description,
+    ),
+    focusKeyword: value(
+      meta._yoast_wpseo_focuskw,
+      meta.rank_math_focus_keyword,
+      meta._aioseo_keyphrases,
+    ),
+    canonicalOverride: value(
+      yoast.canonical,
+      meta._yoast_wpseo_canonical,
+      meta.rank_math_canonical_url,
+      meta._aioseo_canonical_url,
+    ),
+    robotsIndex: /noindex/i.test(robots) ? "noindex" : "index",
+    robotsFollow: /nofollow/i.test(robots) ? "nofollow" : "follow",
+    ogImageUrl: value(
+      yoast.og_image?.[0]?.url,
+      meta["_yoast_wpseo_opengraph-image"],
+      meta.rank_math_facebook_image,
+    ),
+    schemaType:
+      value(
+        meta._yoast_wpseo_schema_page_type,
+        meta.rank_math_schema_type,
+        meta._aioseo_schema_type,
+      ) || "Article",
+  };
+}
+
+export async function inspectWordPressCapabilities(sourceUrl: string): Promise<{
+  apiRoot: string;
+  namespaces: string[];
+  postTypes: Array<{ slug: string; name: string; restBase?: string }>;
+  supportsRest: boolean;
+}> {
+  const root = apiRoot(sourceUrl).replace(/\/wp\/v2$/, "");
+  const response = await fetch(root, {
+    headers: headers(),
+    signal: AbortSignal.timeout(30000),
+  });
+  const body = (await response.json().catch(() => ({}))) as any;
+  const routes = Object.keys(body?.routes || {});
+  const postTypes = [
+    { slug: "post", name: "Posts", restBase: "posts" },
+    { slug: "page", name: "Pages", restBase: "pages" },
+  ].filter(
+    (item) =>
+      !routes.length ||
+      routes.some((route) => route.endsWith(`/${item.restBase}`)),
+  );
+  return {
+    apiRoot: apiRoot(sourceUrl),
+    namespaces: Array.isArray(body?.namespaces) ? body.namespaces : [],
+    postTypes,
+    supportsRest: response.ok,
+  };
+}
+export async function inspectWordPress(
+  sourceUrl: string,
+  options?: Partial<WordPressImportOptions>,
+): Promise<{
+  sourceUrl: string;
+  totals: { posts: number; categories: number; tags: number; media: number };
+  sample: Array<{ id: number; title: string; slug: string; status: string }>;
+}> {
+  const root = apiRoot(sourceUrl);
+  const opts = defaultOptions(options);
+  const [posts, categories, tags] = await Promise.all([
+    fetchPostTypes(root, opts),
+    fetchCollection(root, "categories", opts.maxTerms),
+    fetchCollection(root, "tags", opts.maxTerms),
+  ]);
+  return {
+    sourceUrl,
+    totals: {
+      posts: posts.total,
+      categories: categories.total,
+      tags: tags.total,
+      media:
+        opts.mediaMode === "all"
+          ? (await fetchCollection(root, "media", opts.maxTerms)).total
+          : posts.items.filter((post) => embeddedMedia(post)).length,
+    },
+    sample: posts.items.slice(0, 10).map((post) => ({
+      id: Number(post.id),
+      title: text(post.title),
+      slug: String(post.slug || slug(text(post.title))),
+      status: String(post.status || "draft"),
+    })),
+  };
+}
+
+export async function importWordPress(
+  migrationId: string,
+  sourceUrl: string,
+  options?: Partial<WordPressImportOptions>,
+): Promise<WordPressCounts> {
+  const opts = defaultOptions(options);
+  const root = apiRoot(sourceUrl);
+  const [posts, categories, tags] = await Promise.all([
+    fetchPostTypes(root, opts),
+    fetchCollection(root, "categories", opts.maxTerms),
+    fetchCollection(root, "tags", opts.maxTerms),
+  ]);
+  const media =
+    opts.mediaMode === "all"
+      ? (await fetchCollection(root, "media", opts.maxTerms)).items
+      : posts.items.map(embeddedMedia).filter(Boolean);
+  const timestamp = now();
+  const sourceSnapshotChecksum = createHash("sha256")
+    .update(JSON.stringify(posts.items.map((post) => checksum(post)).sort()))
+    .digest("hex");
+  const counts: WordPressCounts = {
+    posts: {
+      total: posts.total,
+      created: 0,
+      updated: 0,
+      skipped: 0,
+      deleted: 0,
+      conflicts: 0,
+    },
+    categories: 0,
+    tags: 0,
+    authors: 0,
+    media: 0,
+    redirects: 0,
+  };
+  const transaction = db().transaction(() => {
+    for (const item of categories.items) {
+      const sourceId = String(item.id);
+      const mappedTopicId = opts.mapping.categoryToTopic[sourceId];
+      const topicId =
+        mappedTopicId &&
+        db().prepare("SELECT id FROM topics WHERE id=?").get(mappedTopicId)
+          ? mappedTopicId
+          : `topic-wp-category-${sourceId}`;
+      const existing = db()
+        .prepare(
+          "SELECT id FROM wp_terms WHERE taxonomy='category' AND source_id=?",
+        )
+        .get(sourceId) as { id: string } | undefined;
+      if (!mappedTopicId)
+        db()
+          .prepare(
+            "INSERT INTO topics (id,slug,title,description,status,minimum_published_posts,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET title=excluded.title,description=excluded.description,updated_at=excluded.updated_at",
+          )
+          .run(
+            topicId,
+            `wp-${slug(String(item.slug || item.name))}-${sourceId}`,
+            String(item.name || "Untitled category"),
+            text(item.description),
+            "draft",
+            0,
+            timestamp,
+            timestamp,
+          );
+      const termId = existing?.id || id("wp_term");
+      db()
+        .prepare(
+          "INSERT INTO wp_terms (id,taxonomy,source_id,name,slug,description,topic_id,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?) ON CONFLICT(taxonomy,source_id) DO UPDATE SET name=excluded.name,slug=excluded.slug,description=excluded.description,topic_id=excluded.topic_id,updated_at=excluded.updated_at",
+        )
+        .run(
+          termId,
+          "category",
+          sourceId,
+          String(item.name || ""),
+          String(item.slug || slug(item.name)),
+          text(item.description),
+          topicId,
+          timestamp,
+          timestamp,
+        );
+      counts.categories++;
+      recordItem(migrationId, "category", sourceId, topicId, "updated");
+    }
+    for (const item of tags.items) {
+      const sourceId = String(item.id);
+      const existing = db()
+        .prepare("SELECT id FROM wp_terms WHERE taxonomy='tag' AND source_id=?")
+        .get(sourceId) as { id: string } | undefined;
+      const termId = existing?.id || id("wp_term");
+      db()
+        .prepare(
+          "INSERT INTO wp_terms (id,taxonomy,source_id,name,slug,description,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(taxonomy,source_id) DO UPDATE SET name=excluded.name,slug=excluded.slug,updated_at=excluded.updated_at",
+        )
+        .run(
+          termId,
+          "tag",
+          sourceId,
+          String(item.name || ""),
+          String(item.slug || slug(item.name)),
+          text(item.description),
+          timestamp,
+          timestamp,
+        );
+      counts.tags++;
+      recordItem(migrationId, "tag", sourceId, termId, "updated");
+    }
+    const authorIds = new Map<string, string>();
+    for (const post of posts.items) {
+      const author = post._embedded?.author?.[0];
+      if (!author?.id) continue;
+      const sourceId = String(author.id);
+      const authorId = `author-wp-${sourceId}`;
+      db()
+        .prepare(
+          "INSERT INTO authors (id,slug,name,bio,profile_url,credentials_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET name=excluded.name,bio=excluded.bio,profile_url=excluded.profile_url,updated_at=excluded.updated_at",
+        )
+        .run(
+          authorId,
+          `wp-${slug(text(author.name))}-${sourceId}`,
+          text(author.name) || `WordPress author ${sourceId}`,
+          text(author.description),
+          author.link || null,
+          "[]",
+          timestamp,
+          timestamp,
+        );
+      authorIds.set(sourceId, authorId);
+      counts.authors++;
+      recordItem(migrationId, "author", sourceId, authorId, "updated");
+    }
+    const mediaIds = new Map<string, string>();
+    for (const item of media) {
+      if (!item?.id || !item.source_url) continue;
+      const sourceId = String(item.id);
+      const existing = db()
+        .prepare(
+          "SELECT id FROM media_assets WHERE source='wordpress' AND source_id=?",
+        )
+        .get(sourceId) as { id: string } | undefined;
+      const mediaId = existing?.id || id("media");
+      const details = item.media_details || {};
+      db()
+        .prepare(
+          "INSERT INTO media_assets (id,source,source_id,source_url,mime_type,alt_text,caption,width,height,metadata_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(source,source_id) DO UPDATE SET source_url=excluded.source_url,mime_type=excluded.mime_type,alt_text=excluded.alt_text,caption=excluded.caption,width=excluded.width,height=excluded.height,metadata_json=excluded.metadata_json,updated_at=excluded.updated_at",
+        )
+        .run(
+          mediaId,
+          "wordpress",
+          sourceId,
+          String(item.source_url),
+          item.mime_type || null,
+          String(item.alt_text || ""),
+          text(item.caption),
+          details.width || null,
+          details.height || null,
+          JSON.stringify({
+            title: text(item.title),
+            mediaType: item.media_type,
+          }),
+          timestamp,
+          timestamp,
+        );
+      const stored = db()
+        .prepare(
+          "SELECT id FROM media_assets WHERE source='wordpress' AND source_id=?",
+        )
+        .get(sourceId) as { id: string };
+      mediaIds.set(sourceId, stored.id);
+      counts.media++;
+      recordItem(migrationId, "media", sourceId, stored.id, "updated");
+    }
+    const seen = new Set<string>();
+    for (const post of posts.items) {
+      const sourceId = String(post.id || "");
+      seen.add(sourceId);
+      const title = text(post.title);
+      const originalSlug = String(post.slug || slug(title));
+      if (!sourceId || !title) {
+        counts.posts.skipped++;
+        recordItem(
+          migrationId,
+          "post",
+          sourceId || "unknown",
+          null,
+          "skipped",
+          "missing id or title",
+        );
+        continue;
+      }
+      const sourceIdentity = `wordpress:${sourceId}`;
+      const existing = db()
+        .prepare(
+          "SELECT id,slug,checksum,source_modified_at,updated_at FROM posts WHERE source='cms' AND source_id=?",
+        )
+        .get(sourceIdentity) as
+        { id: string; slug: string; checksum?: string; source_modified_at?: string; updated_at?: string } | undefined;
+      const sourceHash = checksum(post);
+      const sourceModified = post.modified_gmt || post.modified || null;
+      if (opts.syncMode === "new" && existing) {
+        counts.posts.skipped++;
+        continue;
+      }
+      if (opts.syncMode === "modified" && existing && (existing.checksum === sourceHash || (sourceModified && existing.source_modified_at && existing.source_modified_at >= sourceModified))) {
+        counts.posts.skipped++;
+        continue;
+      }
+      if (existing && sourceModified && existing.updated_at && existing.updated_at > sourceModified && opts.conflictStrategy !== "wordpress-wins") {
+        counts.posts.conflicts++;
+        db().prepare("INSERT INTO migration_conflicts (id,migration_id,source_id,target_id,resolution,details_json,created_at) VALUES (?,?,?,?,?,?,?)").run(id("conflict"), migrationId, sourceIdentity, existing.id, opts.conflictStrategy === "maggie-wins" ? "target-wins" : "manual", JSON.stringify({ sourceModified, targetUpdated: existing.updated_at }), timestamp);
+        counts.posts.skipped++; recordItem(migrationId, "post", sourceId, existing.id, "skipped", opts.conflictStrategy === "maggie-wins" ? "target wins conflict" : "manual review required"); continue;
+      }
+      let targetSlug = existing?.slug || originalSlug;
+      const slugOwner = db()
+        .prepare("SELECT id FROM posts WHERE slug=?")
+        .get(targetSlug) as { id: string } | undefined;
+      if (slugOwner && slugOwner.id !== existing?.id) {
+        targetSlug = `wp-${sourceId}-${originalSlug}`;
+        counts.posts.conflicts++;
+        db()
+          .prepare(
+            "INSERT INTO migration_conflicts (id,migration_id,source_id,target_id,resolution,details_json,created_at) VALUES (?,?,?,?,?,?,?)",
+          )
+          .run(
+            id("conflict"),
+            migrationId,
+            sourceIdentity,
+            slugOwner.id,
+            opts.conflictStrategy === "wordpress-wins"
+              ? "source-wins"
+              : opts.conflictStrategy === "maggie-wins"
+                ? "target-wins"
+                : "manual",
+            JSON.stringify({ sourceSlug: originalSlug, targetSlug }),
+            timestamp,
+          );
+      }
+      const author = post._embedded?.author?.[0];
+      const authorId =
+        authorIds.get(String(author?.id)) ||
+        opts.mapping.authorToAuthor[String(author?.id || post.author || "")] ||
+        `author-wp-${String(post.author || "unknown")}`;
+      if (!db().prepare("SELECT 1 FROM authors WHERE id=?").get(authorId))
+        db()
+          .prepare(
+            "INSERT OR IGNORE INTO authors (id,slug,name,credentials_json,created_at,updated_at) VALUES (?,?,?,?,?,?)",
+          )
+          .run(
+            authorId,
+            `wp-unknown-${post.author || "unknown"}`,
+            "WordPress author",
+            "[]",
+            timestamp,
+          );
+      const isPublished = opts.preservePublished && post.status === "publish";
+      const status = isPublished ? "published" : "draft";
+      const publishedAt = isPublished
+        ? post.date_gmt || post.date || timestamp
+        : null;
+      const destination = new URL(
+        `/blog/${targetSlug}`,
+        import.meta.env.PUBLIC_SITE_URL || "https://example.com",
+      ).toString();
+      const featured = embeddedMedia(post);
+      const params = [
+        "cms",
+        sourceIdentity,
+        targetSlug,
+        title,
+        text(post.excerpt),
+        post.content?.rendered || "",
+        destination,
+        featured?.source_url || null,
+        featured?.alt_text || "",
+        authorId,
+        "en",
+        status,
+        publishedAt,
+        timestamp,
+        timestamp,
+        sourceModified,
+      ];
+      if (existing) {
+        saveRevision(existing.id, "WordPress migration", timestamp);
+        db()
+          .prepare(
+            "UPDATE posts SET slug=?,title=?,excerpt=?,content_html=?,canonical_url=?,cover_image_url=?,cover_image_alt=?,author_id=?,language=?,status=?,published_at=?,updated_at=?,checksum=?,source_modified_at=? WHERE id=?",
+          )
+          .run(
+            targetSlug,
+            title,
+            text(post.excerpt),
+            post.content?.rendered || "",
+            destination,
+            featured?.source_url || null,
+            featured?.alt_text || "",
+            authorId,
+            "en",
+            status,
+            publishedAt,
+            timestamp,
+            sourceHash,
+            sourceModified,
+            existing.id,
+          );
+        counts.posts.updated++;
+        recordItem(migrationId, "post", sourceId, existing.id, "updated");
+      } else {
+        const postId = id("post");
+        db()
+          .prepare(
+            "INSERT INTO posts (id,source,source_id,slug,title,excerpt,content_html,canonical_url,cover_image_url,cover_image_alt,author_id,language,status,published_at,updated_at,created_at,checksum,source_modified_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+          )
+          .run(postId, ...params, sourceHash);
+        counts.posts.created++;
+        recordItem(migrationId, "post", sourceId, postId, "created");
+      }
+      const seo = normalizedSeo(post);
+      const target = db()
+        .prepare("SELECT id FROM posts WHERE source='cms' AND source_id=?")
+        .get(sourceIdentity) as { id: string };
+      db()
+        .prepare(
+          "UPDATE posts SET seo_title=?,meta_description=?,focus_keyword=?,canonical_override=?,robots_index=?,robots_follow=?,og_image_url=?,schema_type=? WHERE id=?",
+        )
+        .run(
+          seo.seoTitle,
+          seo.metaDescription,
+          seo.focusKeyword,
+          seo.canonicalOverride,
+          seo.robotsIndex,
+          seo.robotsFollow,
+          seo.ogImageUrl,
+          seo.schemaType,
+          target.id,
+        );
+      db().prepare("DELETE FROM post_topics WHERE post_id=?").run(target.id);
+      db().prepare("DELETE FROM post_wp_terms WHERE post_id=?").run(target.id);
+      for (const term of embeddedTerms(post)) {
+        const taxonomy = term.taxonomy === "category" ? "category" : "tag";
+        const wpTerm = db()
+          .prepare(
+            "SELECT id,topic_id FROM wp_terms WHERE taxonomy=? AND source_id=?",
+          )
+          .get(taxonomy, String(term.id)) as
+          { id: string; topic_id?: string } | undefined;
+        if (!wpTerm) continue;
+        db()
+          .prepare(
+            "INSERT OR IGNORE INTO post_wp_terms (post_id,term_id) VALUES (?,?)",
+          )
+          .run(target.id, wpTerm.id);
+        if (taxonomy === "category" && wpTerm.topic_id)
+          db()
+            .prepare(
+              "INSERT OR IGNORE INTO post_topics (post_id,topic_id) VALUES (?,?)",
+            )
+            .run(target.id, wpTerm.topic_id);
+      }
+      if (
+        opts.mapping.featuredImageToMedia &&
+        featured?.id &&
+        mediaIds.get(String(featured.id))
+      )
+        db()
+          .prepare(
+            "INSERT OR IGNORE INTO post_media (post_id,media_id,role) VALUES (?,?,?)",
+          )
+          .run(target.id, mediaIds.get(String(featured.id)), "featured");
+      const oldLink = sourceLink(post);
+      if (oldLink) {
+        const oldPath = new URL(oldLink).pathname;
+        const newPath = `/blog/${targetSlug}`;
+        if (oldPath !== newPath) {
+          db()
+            .prepare(
+              "INSERT INTO redirects (id,source_path,target_path,status_code,reason,created_at) VALUES (?,?,?,?,?,?) ON CONFLICT(source_path) DO UPDATE SET target_path=excluded.target_path",
+            )
+            .run(
+              id("redirect"),
+              oldPath,
+              newPath,
+              301,
+              "wordpress migration",
+              timestamp,
+            );
+          counts.redirects++;
+        }
+      }
+    }
+    if (opts.detectDeleted && opts.syncMode === "all") {
+      const old = db()
+        .prepare(
+          "SELECT id,source_id FROM posts WHERE source='cms' AND source_id LIKE 'wordpress:%'",
+        )
+        .all() as Array<{ id: string; source_id: string }>;
+      for (const item of old)
+        if (!seen.has(item.source_id.replace(/^wordpress:/, ""))) {
+          db()
+            .prepare(
+              "UPDATE posts SET status='archived',updated_at=? WHERE id=?",
+            )
+            .run(timestamp, item.id);
+          counts.posts.deleted++;
+        }
+    }
+    db()
+      .prepare(
+        "UPDATE wp_migrations SET checkpoint_json=?,source_checksum=?,deleted_count=?,conflict_count=? WHERE id=?",
+      )
+      .run(
+        JSON.stringify({
+          processed: posts.items.length,
+          total: posts.items.length,
+          completed: true,
+        }),
+        sourceSnapshotChecksum,
+        counts.posts.deleted,
+        counts.posts.conflicts,
+        migrationId,
+      );
+    audit(
+      "wordpress.migration.applied",
+      "wordpress_migration",
+      migrationId,
+      null,
+      counts,
+    );
+  });
+  transaction();
+  return counts;
+}
+function recordItem(
+  migrationId: string,
+  entityType: string,
+  sourceId: string,
+  targetId: string | null,
+  action: string,
+  error?: string,
+): void {
+  db()
+    .prepare(
+      "INSERT INTO wp_import_items (id,migration_id,entity_type,source_id,target_id,action,error,created_at) VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(migration_id,entity_type,source_id) DO UPDATE SET target_id=excluded.target_id,action=excluded.action,error=excluded.error",
+    )
+    .run(
+      id("wp_item"),
+      migrationId,
+      entityType,
+      sourceId,
+      targetId,
+      action,
+      error || null,
+      now(),
+    );
+}
+function saveRevision(postId: string, reason: string, timestamp: string): void {
+  const snapshot = db()
+    .prepare("SELECT * FROM posts WHERE id=?")
+    .get(postId) as Record<string, unknown> | undefined;
+  if (!snapshot) return;
+  const version =
+    Number(
+      (
+        db()
+          .prepare(
+            "SELECT MAX(version) version FROM post_revisions WHERE post_id=?",
+          )
+          .get(postId) as any
+      )?.version || 0,
+    ) + 1;
+  db()
+    .prepare(
+      "INSERT INTO post_revisions (id,post_id,version,snapshot_json,actor_id,reason,created_at) VALUES (?,?,?,?,?,?,?)",
+    )
+    .run(
+      id("revision"),
+      postId,
+      version,
+      JSON.stringify(snapshot),
+      "maggie-migration",
+      reason,
+      timestamp,
+    );
+}