@zzclub/pipeline 0.2.0 → 0.4.0

package/src/wechat-preview.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { extractFrontmatter, parseYAML } from "./wechat-preview/frontmatter-handler";
+import { getWechatPreviewStyleName, getWechatPreviewTheme } from "./wechat-preview/themes";
+import { minifyHtmlPreservingCodeBlocks, resolveImageDimensionStyles } from "./wechat-preview/wechat-formatter";
+
+describe("wechat preview theme mapping", () => {
+  test("resolves account-specific theme metadata", () => {
+    const ancientone = getWechatPreviewTheme("ancientone");
+    expect(ancientone.name).toBe("rose-ledger");
+    expect(ancientone.exportTheme.footerText).toBe("公众号 · 古一软件");
+    expect(getWechatPreviewStyleName("default")).toBe("sage-journal");
+  });
+
+  test("falls back to default theme for unknown account", () => {
+    const theme = getWechatPreviewTheme("missing-account");
+    expect(theme.account).toBe("default");
+    expect(theme.exportTheme.footerText).toBe("公众号 · 早早集市");
+  });
+});
+
+describe("wechat preview frontmatter helpers", () => {
+  test("extracts frontmatter and body", () => {
+    const parsed = extractFrontmatter("---\nslug: hello-world\ntags: [\"a\", \"b\"]\n---\n# Title\nbody");
+    expect(parsed.frontmatter).toContain("slug: hello-world");
+    expect(parsed.content).toBe("# Title\nbody");
+  });
+
+  test("parses basic yaml values", () => {
+    const parsed = parseYAML("slug: hello-world\ntags: [\"a\", \"b\"]");
+    expect(parsed.slug).toBe("hello-world");
+    expect(parsed.tags).toEqual(["a", "b"]);
+  });
+});
+
+describe("wechat preview html minify", () => {
+  test("keeps indentation inside protected code blocks", () => {
+    const input = `<section>\n  <section data-code-block="true"><pre>if (ok) {\n  return 1;\n}</pre></section>\n  <section>after</section>\n</section>`;
+    const output = minifyHtmlPreservingCodeBlocks(input);
+
+    expect(output).toContain("<pre>if (ok) {\n  return 1;\n}</pre>");
+    expect(output).toContain("</section><section>after</section>");
+  });
+
+  test("does not exit preservation mode on nested section closes inside code blocks", () => {
+    const input = `<section data-code-block="true"><section><section>  const a = 1;</section><section>  return a;</section></section></section><section>after</section>`;
+    const output = minifyHtmlPreservingCodeBlocks(input);
+
+    expect(output).toContain("<section>  const a = 1;</section><section>  return a;</section>");
+    expect(output).toContain("</section><section>after</section>");
+  });
+});
+
+describe("wechat preview image dimensions", () => {
+  test("preserves Crepe image-block height when width is implicit", () => {
+    const styles = resolveImageDimensionStyles({
+      styleHeight: "180.5px",
+      renderedWidth: 320,
+      renderedHeight: 120,
+    });
+
+    expect(styles).toEqual(["width: 320px", "max-width: 100%", "height: 180.5px"]);
+  });
+
+  test("uses Crepe image-block data-height when inline height is absent", () => {
+    const styles = resolveImageDimensionStyles({
+      dataHeight: "210.25",
+      renderedWidth: 360,
+      renderedHeight: 140,
+    });
+
+    expect(styles).toEqual(["width: 360px", "max-width: 100%", "height: 210.25px"]);
+  });
+});

package/src/workflow-materials.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  getPreferredBodyPath,
+  collectNewspicRequiredMarkers,
+  shouldUseNewspicLongform,
+  discoverRenderAssets,
+} from "./workflow-materials";
+import { defaultState } from "./state";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return mkdtemp(join(tmpdir(), prefix));
+}
+
+describe("getPreferredBodyPath", () => {
+  test("returns source_body_path when it exists on disk", async () => {
+    const workspace = await makeTempDir("zzhub-materials-body-");
+    const bodyPath = join(workspace, "source.md");
+    await writeFile(bodyPath, "content", "utf-8");
+
+    const state = defaultState();
+    state.source_body_path = bodyPath;
+    state.asset_path = join(workspace, "posts");
+
+    const result = await getPreferredBodyPath(state);
+    expect(result).toBe(bodyPath);
+  });
+
+  test("falls back to asset_path/post.md when source_body_path missing", async () => {
+    const workspace = await makeTempDir("zzhub-materials-fallback-");
+    const assetPath = join(workspace, "posts", "2026-04-10-test");
+    await mkdir(assetPath, { recursive: true });
+    await writeFile(join(assetPath, "post.md"), "post content", "utf-8");
+
+    const state = defaultState();
+    state.source_body_path = "/nonexistent/path.md";
+    state.asset_path = assetPath;
+
+    const result = await getPreferredBodyPath(state);
+    expect(result).toBe(join(assetPath, "post.md"));
+  });
+
+  test("returns null when neither exists", async () => {
+    const state = defaultState();
+    state.source_body_path = "/nonexistent/source.md";
+    state.asset_path = "/nonexistent/asset";
+
+    const result = await getPreferredBodyPath(state);
+    expect(result).toBeNull();
+  });
+});
+
+describe("collectNewspicRequiredMarkers", () => {
+  test("collects markers from body text", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = null;
+
+    const markers = collectNewspicRequiredMarkers("Some text\n\n插图1\n\nMore text\n\n插图2", state);
+    expect(markers).toContain("插图1");
+    expect(markers).toContain("插图2");
+  });
+
+  test("merges body markers with page_spec markers", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = {
+      pagination_mode: "multi",
+      min_pages: 2,
+      max_pages: 0,
+      require_image_every_page: true,
+      default_image_layout: "staggered",
+      target_fill_ratio: 0.8,
+      page_specs: [
+        { page: 1, image_markers: ["插图3"], image_layout: null, target_fill_ratio: null, note: null },
+      ],
+    };
+
+    const markers = collectNewspicRequiredMarkers("插图1\n\n插图2", state);
+    expect(markers).toContain("插图1");
+    expect(markers).toContain("插图2");
+    expect(markers).toContain("插图3");
+  });
+
+  test("deduplicates markers", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = {
+      pagination_mode: "multi",
+      min_pages: 1,
+      max_pages: 0,
+      require_image_every_page: false,
+      default_image_layout: "staggered",
+      target_fill_ratio: 0.8,
+      page_specs: [
+        { page: 1, image_markers: ["插图1"], image_layout: null, target_fill_ratio: null, note: null },
+      ],
+    };
+
+    const markers = collectNewspicRequiredMarkers("插图1", state);
+    const uniqueCount = new Set(markers).size;
+    expect(uniqueCount).toBe(markers.length);
+  });
+
+  test("returns empty array when no markers found", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = null;
+
+    const markers = collectNewspicRequiredMarkers("Plain text without markers", state);
+    expect(markers).toEqual([]);
+  });
+});
+
+describe("shouldUseNewspicLongform", () => {
+  test("returns true for multi mode", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = {
+      pagination_mode: "multi",
+      min_pages: 2,
+      max_pages: 0,
+      require_image_every_page: false,
+      default_image_layout: "staggered",
+      target_fill_ratio: 0.8,
+      page_specs: [],
+    };
+
+    expect(shouldUseNewspicLongform(state)).toBe(true);
+  });
+
+  test("returns false for single mode even with long body", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = {
+      pagination_mode: "single",
+      min_pages: 1,
+      max_pages: 0,
+      require_image_every_page: false,
+      default_image_layout: "staggered",
+      target_fill_ratio: 0.8,
+      page_specs: [],
+    };
+
+    expect(shouldUseNewspicLongform(state)).toBe(false);
+  });
+
+  test("returns false for default/auto mode with short body", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = null;
+
+    expect(shouldUseNewspicLongform(state)).toBe(false);
+  });
+
+  test("returns false for auto mode with long body", () => {
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.intent.newspic_render = {
+      pagination_mode: "auto",
+      min_pages: 1,
+      max_pages: 0,
+      require_image_every_page: false,
+      default_image_layout: "staggered",
+      target_fill_ratio: 0.8,
+      page_specs: [],
+    };
+
+    expect(shouldUseNewspicLongform(state)).toBe(false);
+  });
+});
+
+describe("discoverRenderAssets", () => {
+  test("finds cover.png for wechat-article route", async () => {
+    const workspace = await makeTempDir("zzhub-discover-article-");
+    const assetPath = join(workspace, "posts", "2026-04-10-test");
+    const imageDir = join(assetPath, "images", "wechat");
+    await mkdir(imageDir, { recursive: true });
+    await writeFile(join(imageDir, "cover.png"), "fake-png", "utf-8");
+
+    const state = defaultState();
+    state.route.primary = "wechat-article";
+    state.asset_path = assetPath;
+
+    const assets = await discoverRenderAssets(state);
+    expect(assets).toHaveLength(1);
+    expect(assets[0].kind).toBe("cover");
+    expect(assets[0].route).toBe("wechat-article");
+  });
+
+  test("finds cover and page files for wechat-newspic route", async () => {
+    const workspace = await makeTempDir("zzhub-discover-newspic-");
+    const assetPath = join(workspace, "posts", "2026-04-10-newspic");
+    const imageDir = join(assetPath, "images", "newspic");
+    await mkdir(imageDir, { recursive: true });
+    await writeFile(join(imageDir, "cover.png"), "cover", "utf-8");
+    await writeFile(join(imageDir, "article-3.png"), "page3", "utf-8");
+    await writeFile(join(imageDir, "article-1.png"), "page1", "utf-8");
+    await writeFile(join(imageDir, "article-2.png"), "page2", "utf-8");
+
+    const state = defaultState();
+    state.route.primary = "wechat-newspic";
+    state.asset_path = assetPath;
+
+    const assets = await discoverRenderAssets(state);
+    expect(assets.length).toBeGreaterThanOrEqual(3);
+
+    const pages = assets.filter((a) => a.kind === "page");
+    expect(pages).toHaveLength(3);
+    expect(pages[0].index).toBe(1);
+    expect(pages[1].index).toBe(2);
+    expect(pages[2].index).toBe(3);
+  });
+
+  test("returns empty array when image directory does not exist", async () => {
+    const state = defaultState();
+    state.route.primary = "wechat-article";
+    state.asset_path = "/nonexistent/path";
+
+    const assets = await discoverRenderAssets(state);
+    expect(assets).toEqual([]);
+  });
+});

package/src/workflow-materials.ts

@@ -0,0 +1,217 @@
+import { access, readFile, readdir } from "fs/promises";
+import { join } from "path";
+
+import {
+  normalizeNewspicRenderSpec,
+  type BodyInputReceived,
+  defaultBodyInputs,
+  type RenderAsset,
+  type WorkflowState,
+} from "./state";
+import {
+  findIllustrationMarkers,
+  stripFrontmatter,
+} from "./text";
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function dedupeReceived(received: BodyInputReceived[]): BodyInputReceived[] {
+  const map = new Map<string, string>();
+  for (const item of received) {
+    if (!item.marker?.trim() || !item.path?.trim()) {
+      continue;
+    }
+    map.set(item.marker.trim(), item.path.trim());
+  }
+  return [...map.entries()].map(([marker, path]) => ({ marker, path }));
+}
+
+export async function getPreferredBodyPath(state: WorkflowState): Promise<string | null> {
+  if (state.source_body_path && await pathExists(state.source_body_path)) {
+    return state.source_body_path;
+  }
+  if (state.asset_path) {
+    const canonicalBodyPath = join(state.asset_path, "post.md");
+    if (await pathExists(canonicalBodyPath)) {
+      return canonicalBodyPath;
+    }
+  }
+  return null;
+}
+
+export async function readBodyContent(state: WorkflowState): Promise<{ path: string | null; content: string | null }> {
+  const bodyPath = await getPreferredBodyPath(state);
+  if (!bodyPath) {
+    return { path: null, content: null };
+  }
+  return {
+    path: bodyPath,
+    content: await readFile(bodyPath, "utf-8"),
+  };
+}
+
+export function collectNewspicRequiredMarkers(
+  cleanBody: string,
+  state: WorkflowState,
+): string[] {
+  const spec = normalizeNewspicRenderSpec(state.intent.newspic_render);
+  const markers = new Set(findIllustrationMarkers(cleanBody).map((item) => item.trim()));
+  for (const pageSpec of spec.page_specs) {
+    for (const marker of pageSpec.image_markers) {
+      if (marker.trim()) {
+        markers.add(marker.trim());
+      }
+    }
+  }
+  return [...markers];
+}
+
+export function shouldUseNewspicLongform(state: WorkflowState): boolean {
+  const spec = normalizeNewspicRenderSpec(state.intent.newspic_render);
+  return spec.pagination_mode === "multi";
+}
+
+export async function reconcileBodyInputs(state: WorkflowState): Promise<void> {
+  const body = await readBodyContent(state);
+  if (!body.content) {
+    if (state.images.body_inputs.scope !== "none" && state.images.body_inputs.received.length === 0) {
+      state.images.body_inputs = defaultBodyInputs();
+    }
+    return;
+  }
+
+  const cleanBody = stripFrontmatter(body.content);
+  const previousReceived = dedupeReceived(state.images.body_inputs.received);
+  const usesArticleImages =
+    state.intent.content_form === "article" ||
+    state.route.primary === "wechat-article" ||
+    state.route.extras.includes("wechat-article");
+  const usesNewspicImages =
+    state.intent.content_form === "newspic" ||
+    state.route.primary === "wechat-newspic" ||
+    state.route.extras.includes("wechat-newspic");
+
+  if (usesArticleImages && !usesNewspicImages) {
+    const markers = findIllustrationMarkers(cleanBody);
+    const markerSet = new Set(markers);
+    const received = previousReceived.filter((item) => markerSet.has(item.marker));
+    if (markers.length === 0) {
+      state.images.body_inputs = defaultBodyInputs();
+      return;
+    }
+    state.images.body_inputs = {
+      scope: "article",
+      expected: markers.length,
+      received,
+      status: received.length >= markers.length ? "ready" : "pending",
+      layout: state.images.body_inputs.layout || "staggered",
+    };
+    return;
+  }
+
+  if (usesNewspicImages && shouldUseNewspicLongform(state)) {
+    const markers = collectNewspicRequiredMarkers(cleanBody, state);
+    const markerSet = new Set(markers);
+    const received = previousReceived.filter((item) => markerSet.has(item.marker));
+    state.images.body_inputs = {
+      scope: markers.length > 0 ? "newspic-longform" : "none",
+      expected: markers.length,
+      received,
+      status:
+        markers.length === 0
+          ? "none"
+          : received.length >= markers.length
+            ? "ready"
+            : "pending",
+      layout:
+        state.images.body_inputs.layout ||
+        normalizeNewspicRenderSpec(state.intent.newspic_render).default_image_layout,
+    };
+    return;
+  }
+
+  if (state.images.body_inputs.scope !== "none") {
+    state.images.body_inputs = defaultBodyInputs();
+  }
+}
+
+export async function discoverRenderAssets(state: WorkflowState): Promise<RenderAsset[]> {
+  if (!state.asset_path) {
+    return [];
+  }
+
+  const assets: RenderAsset[] = [];
+  const needsWechatArticle =
+    state.route.primary === "wechat-article" || state.route.extras.includes("wechat-article");
+  const needsNewspic =
+    state.route.primary === "wechat-newspic" || state.route.extras.includes("wechat-newspic");
+
+  if (needsWechatArticle) {
+    const coverPath = join(state.asset_path, "images", "wechat", "cover.png");
+    if (await pathExists(coverPath)) {
+      assets.push({
+        kind: "cover",
+        route: "wechat-article",
+        path: coverPath,
+      });
+    }
+  }
+
+  if (needsNewspic) {
+    const newspicDir = join(state.asset_path, "images", "newspic");
+    const coverPath = join(newspicDir, "cover.png");
+    if (await pathExists(coverPath)) {
+      assets.push({
+        kind: "cover",
+        route: "wechat-newspic",
+        path: coverPath,
+      });
+    }
+
+    if (await pathExists(newspicDir)) {
+      const files = await readdir(newspicDir);
+      const pageFiles = files
+        .filter((name) => /^article-\d+\.png$/.test(name))
+        .sort();
+      for (let index = 0; index < pageFiles.length; index += 1) {
+        assets.push({
+          kind: "page",
+          route: "wechat-newspic",
+          path: join(newspicDir, pageFiles[index]),
+          index: index + 1,
+        });
+      }
+    }
+  }
+
+  return assets;
+}
+
+export async function reconcileStateArtifacts(state: WorkflowState): Promise<void> {
+  // NOTE: This function mutates `state` in memory only — it does NOT write back to disk.
+  // It is called on every `status` read to produce a reconciled view.
+  // Any caller reading the raw state file directly (bypassing this function) will see
+  // stale values for images.body_inputs and images.render_assets.
+
+  await reconcileBodyInputs(state);
+
+  if (!state.asset_path) {
+    return;
+  }
+
+  const renderAssets = await discoverRenderAssets(state);
+  if (renderAssets.length > 0) {
+    state.images.render_assets = renderAssets;
+    state.images.plan.status = "rendered";
+  } else if (state.images.plan.needed && state.images.plan.status === "rendered") {
+    state.images.plan.status = "planned";
+    state.images.render_assets = [];
+  }
+}