@zzclub/pipeline 0.4.0 → 0.9.0

package/src/commands/wechat-export.ts

@@ -54,6 +54,7 @@ ${CSS_DEMO}
   const customCss = optionalArg(parsed, "custom-css");
 
   const config = loadConfig();
+  const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
   const markdownRenderer = await resolveMarkdownRenderer(config);
   const result = await markdownRenderer.render({
     markdownPath,
@@ -62,6 +63,7 @@ ${CSS_DEMO}
     title,
     previewShellOutPath,
     customCss,
+    themeOverrides: wxAccount?.theme,
   });
 
   printResult(result, renderWechatExport);

package/src/commands/wx-draft-delete.ts

@@ -0,0 +1,36 @@
+/**
+ * wx-draft-delete — Delete a draft from WeChat draft box.
+ *
+ * Usage:
+ *   zzhub-pipeline wx-draft-delete [--account <account>] --media-id <media_id>
+ */
+
+import { optionalArg, parseArgs, requireArg } from "../args";
+import { loadConfig } from "../config";
+import { printHelp, printResult } from "../output";
+import { deleteWxDraft } from "../providers/wechat";
+
+export async function wxDraftDelete(args: string[]): Promise<void> {
+  const parsed = parseArgs(args);
+
+  if (parsed.help) {
+    printHelp(`
+Usage: zzhub-pipeline wx-draft-delete [options]
+
+Options:
+  --account    WeChat account name (defaults to wx.defaultAccount from config)
+  --media-id   Draft media_id to delete (required)
+
+Examples:
+  zzhub-pipeline wx-draft-delete --media-id MEDIA_ID
+`.trim());
+    return;
+  }
+
+  const config = loadConfig();
+  const account = optionalArg(parsed, "account") || config.wx.defaultAccount;
+  const mediaId = requireArg(parsed, "media-id", "draft media_id to delete");
+
+  const result = await deleteWxDraft({ account, mediaId, config });
+  printResult(result);
+}

package/src/commands/wx-drafts.ts

@@ -0,0 +1,47 @@
+/**
+ * wx-drafts — List or get WeChat draft box drafts.
+ *
+ * Usage:
+ *   zzhub-pipeline wx-drafts [--account <account>] [--limit 20] [--offset 0]
+ *   zzhub-pipeline wx-drafts [--account <account>] --media-id <media_id>
+ */
+
+import { optionalArg, parseArgs } from "../args";
+import { loadConfig } from "../config";
+import { printHelp, printResult } from "../output";
+import { getWxDraft, getWxDraftList } from "../providers/wechat";
+
+export async function wxDrafts(args: string[]): Promise<void> {
+  const parsed = parseArgs(args);
+
+  if (parsed.help) {
+    printHelp(`
+Usage: zzhub-pipeline wx-drafts [options]
+
+Options:
+  --account    WeChat account name (defaults to wx.defaultAccount from config)
+  --media-id   Draft media_id to fetch a single draft (optional)
+  --limit      Number of drafts to list, default 20, max 20 (optional)
+  --offset     Pagination offset, default 0 (optional)
+
+Examples:
+  zzhub-pipeline wx-drafts --limit 10
+  zzhub-pipeline wx-drafts --media-id MEDIA_ID
+`.trim());
+    return;
+  }
+
+  const config = loadConfig();
+  const account = optionalArg(parsed, "account") || config.wx.defaultAccount;
+  const mediaId = optionalArg(parsed, "media-id") ?? null;
+  const limit = optionalArg(parsed, "limit") ? Number.parseInt(optionalArg(parsed, "limit")!, 10) : undefined;
+  const offset = optionalArg(parsed, "offset") ? Number.parseInt(optionalArg(parsed, "offset")!, 10) : undefined;
+
+  if (mediaId) {
+    const result = await getWxDraft({ account, mediaId, config });
+    printResult(result);
+  } else {
+    const result = await getWxDraftList({ account, limit, offset, config });
+    printResult(result);
+  }
+}

package/src/db.test.ts

@@ -0,0 +1,47 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, exists } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { getDb, initDb } from "./db";
+
+describe("db", () => {
+  let workspace: string;
+
+  beforeEach(async () => {
+    workspace = await mkdtemp(join(tmpdir(), "zzhub-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(workspace, { recursive: true, force: true });
+  });
+
+  test("getDb creates database file", () => {
+    const db = getDb(workspace);
+    db.close();
+    expect(exists(join(workspace, "zzhub.db"))).resolves.toBe(true);
+  });
+
+  test("initDb creates topics table", () => {
+    const db = getDb(workspace);
+    initDb(db);
+
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='topics'"
+    ).all();
+
+    expect(tables.length).toBe(1);
+    db.close();
+  });
+
+  test("initDb creates analytics table", () => {
+    const db = getDb(workspace);
+    initDb(db);
+
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='analytics'"
+    ).all();
+
+    expect(tables.length).toBe(1);
+    db.close();
+  });
+});

package/src/db.ts

@@ -0,0 +1,95 @@
+import { Database } from "bun:sqlite";
+import { join } from "path";
+import { existsSync } from "fs";
+import { mkdirSync } from "fs";
+
+const DB_FILE = "zzhub.db";
+
+/**
+ * Get or create SQLite database for workspace.
+ */
+export function getDb(workspace: string): Database {
+  if (!existsSync(workspace)) {
+    mkdirSync(workspace, { recursive: true });
+  }
+
+  const dbPath = join(workspace, DB_FILE);
+  const db = new Database(dbPath);
+
+  // Enable WAL mode for better concurrent performance
+  db.exec("PRAGMA journal_mode = WAL;");
+
+  return db;
+}
+
+/**
+ * Initialize database schema (idempotent).
+ */
+export function initDb(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS topics (
+      topic_id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      priority TEXT CHECK(priority IN ('high', 'medium', 'low')) DEFAULT 'medium',
+      tags TEXT,
+      notes TEXT,
+      status TEXT CHECK(status IN (
+        'backlog', 'evaluating', 'scheduled', 'in_progress', 'published', 'abandoned'
+      )) DEFAULT 'backlog',
+
+      ai_score INTEGER,
+      ai_reason TEXT,
+
+      scheduled_date TEXT,
+      target_account TEXT,
+
+      run_id TEXT,
+
+      retro_performance TEXT CHECK(retro_performance IN (
+        'excellent', 'good', 'average', 'poor', null
+      )),
+      retro_lessons TEXT,
+      retro_metrics_snapshot TEXT,
+
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_topics_status ON topics(status);
+    CREATE INDEX IF NOT EXISTS idx_topics_priority ON topics(priority);
+    CREATE INDEX IF NOT EXISTS idx_topics_scheduled ON topics(scheduled_date);
+    CREATE INDEX IF NOT EXISTS idx_topics_created ON topics(created_at);
+
+    CREATE TABLE IF NOT EXISTS analytics (
+      run_id TEXT PRIMARY KEY,
+      topic_id TEXT,
+      title TEXT NOT NULL,
+      publish_date TEXT NOT NULL,
+
+      reads INTEGER DEFAULT 0,
+      likes INTEGER DEFAULT 0,
+      favorites INTEGER DEFAULT 0,
+      shares INTEGER DEFAULT 0,
+      comments INTEGER DEFAULT 0,
+
+      notes TEXT,
+      recorded_at TEXT NOT NULL,
+
+      FOREIGN KEY (topic_id) REFERENCES topics(topic_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_analytics_publish_date ON analytics(publish_date);
+    CREATE INDEX IF NOT EXISTS idx_analytics_topic ON analytics(topic_id);
+    CREATE INDEX IF NOT EXISTS idx_analytics_reads ON analytics(reads);
+  `);
+}
+
+/**
+ * Ensure database is initialized for workspace.
+ */
+export function ensureDb(workspace: string): Database {
+  const db = getDb(workspace);
+  initDb(db);
+  return db;
+}

package/src/imgx/assets/templates/wechat-cover-split.html

@@ -136,7 +136,7 @@
 <body>
   <div class="canvas">
     <section class="left">
-      <div class="eyebrow">公众号·早早集市</div>
+      <div class="eyebrow">{{FOOTER_TEXT}}</div>
       <div class="text-block">
         <div class="pretext-lines" id="cover-lines" aria-label="cover text"></div>
       </div>

package/src/imgx/render-card.ts

@@ -30,11 +30,7 @@ const DEFAULT_SIZE = { width: 900, height: 1200 } as const;
 const WECHAT_SPLIT_WINDOW_EXTRA_HEIGHT = 87;
 const PRETEXT_SCREENSHOT_VIRTUAL_TIME_BUDGET_MS = 6_000;
 
-function detectIcon(template: string, _text: string, _line1: string, _line2: string, _line3: string, fallbackIcon: string): string {
-  if (template === "wechat-cover-split") {
-    return join(ICONS_DIR, "logo.png");
-  }
-
+function detectIcon(_template: string, _text: string, _line1: string, _line2: string, _line3: string, fallbackIcon: string): string {
   if (fallbackIcon.length > 0) return fallbackIcon;
   return join(ICONS_DIR, "logo.png");
 }

package/src/plugins.ts

@@ -1,4 +1,5 @@
 import { abandon } from "./commands/abandon";
+import { analytics } from "./commands/analytics";
 import { attachBody } from "./commands/attach-body";
 import { attachBodyImages } from "./commands/attach-body-images";
 import { attachNewspicSpec } from "./commands/attach-newspic-spec";
@@ -16,12 +17,16 @@ import { prepare } from "./commands/prepare";
 import { publish } from "./commands/publish";
 import { reconcile } from "./commands/reconcile";
 import { render } from "./commands/render";
+import { republish } from "./commands/republish";
 import { reset } from "./commands/reset";
 import { review } from "./commands/review";
 import { status } from "./commands/status";
 import { syncBlog } from "./commands/sync-blog";
 import { tasks } from "./commands/tasks";
+import { topic } from "./commands/topic";
 import { wechatExport } from "./commands/wechat-export";
+import { wxDrafts } from "./commands/wx-drafts";
+import { wxDraftDelete } from "./commands/wx-draft-delete";
 
 export interface CommandDefinition {
   name: string;
@@ -62,13 +67,18 @@ export function getCommandPlugins(): CommandPlugin[] {
     {
       name: "ops",
       commands: [
-        { name: "sync-blog", summary: "Copy canonical markdown to the blog repo and publish there", plugin: "ops", handler: syncBlog },
+        { name: "sync-blog", summary: "Copy post.md to blog repo, publish, and record result in state JSON", plugin: "ops", handler: syncBlog },
+        { name: "republish", summary: "Publish completed task to additional accounts/platforms", plugin: "ops", handler: republish },
         { name: "imgx", summary: "Run bundled imgx renderer subcommands", plugin: "ops", handler: imgxCommand },
         { name: "wechat-export", summary: "Render markdown to WeChat HTML with bundled preview styles", plugin: "ops", handler: wechatExport },
         { name: "cos-upload", summary: "Upload a local image to configured COS CDN", plugin: "ops", handler: cosUpload },
         { name: "config", summary: "Read or update pipeline config", plugin: "ops", handler: configCommand },
         { name: "doctor", summary: "Inspect resolved paths and provider health", plugin: "ops", handler: doctor },
         { name: "hermes-metrics", summary: "Show Hermes execution metrics per task", plugin: "ops", handler: hermesMetrics },
+        { name: "wx-drafts", summary: "List or get drafts from WeChat draft box", plugin: "ops", handler: wxDrafts },
+        { name: "wx-draft-delete", summary: "Delete a draft from WeChat draft box", plugin: "ops", handler: wxDraftDelete },
+        { name: "topic", summary: "Manage topics (add, list, update, schedule, retro, abandon)", plugin: "ops", handler: topic },
+        { name: "analytics", summary: "Record and analyze post-publish metrics", plugin: "ops", handler: analytics },
       ],
     },
   ];

package/src/providers/blog.ts

@@ -84,9 +84,12 @@ export async function publishBlogRoute({
 }: BlogPublishContext): Promise<PublishResult> {
   const postPath = join(state.asset_path, "post.md");
   const postContent = await readFile(postPath, "utf-8");
-  const category = "posts";
+  const category = "nezus";
   const blogRoot = workspacePaths.blogRoot;
-  const blogPostPath = join(blogRoot, "content", category, `${state.metadata.slug}.md`);
+
+  const [year, month] = state.metadata.date.split("-");
+  const blogPostDir = join(blogRoot, "content", category, year, month);
+  const blogPostPath = join(blogPostDir, `${state.metadata.slug}.md`);
 
   const lines = ["---"];
   lines.push(`title: "${state.metadata.title.replace(/"/g, '\\"')}"`);
@@ -120,6 +123,7 @@ export async function publishBlogRoute({
     console.error(`[dry-run] Blog: cd ${blogRoot} && ${config.commands.blogPublish.join(" ")}`);
     return {
       route: "blog",
+      account: "default",
       status: "skipped",
       detail: "dry-run",
       published_at: null,
@@ -128,13 +132,14 @@ export async function publishBlogRoute({
     };
   }
 
-  await mkdir(join(blogRoot, "content", category), { recursive: true });
+  await mkdir(blogPostDir, { recursive: true });
   await writeFile(blogPostPath, blogContent, "utf-8");
   const result = spawnSync(config.commands.blogPublish, { cwd: blogRoot });
 
   if (result.exitCode !== 0) {
     return {
       route: "blog",
+      account: "default",
       status: "failed",
       detail: `blog publish command failed: ${config.commands.blogPublish.join(" ")}`,
       published_at: null,
@@ -145,6 +150,7 @@ export async function publishBlogRoute({
 
   return {
     route: "blog",
+    account: "default",
     status: "success",
     detail: null,
     published_at: new Date().toISOString(),

package/src/providers/index.test.ts

@@ -21,6 +21,6 @@ describe("getPublishProvider", () => {
   });
 
   test("throws for unregistered route", () => {
-    expect(() => getPublishProvider("blog" as never)).toThrow();
+    expect(() => getPublishProvider("nonexistent" as never)).toThrow();
   });
 });

package/src/providers/index.ts

@@ -7,6 +7,7 @@ import {
   prepareBodyForNewspic,
 } from "../text";
 import { resolveMarkdownRenderer } from "../adapter-loader";
+import { publishBlogRoute } from "./blog";
 import { createWechatDraft, createWechatNewspic, extractImageUrls, mergePhotoLists } from "./wechat";
 
 export interface PublishRouteContext {
@@ -14,6 +15,7 @@ export interface PublishRouteContext {
   dryRun: boolean;
   config: PipelineConfig;
   workspacePaths: ResolvedWorkspacePaths;
+  accountOverride?: string;
 }
 
 export type PublishProvider = (ctx: PublishRouteContext) => Promise<PublishResult>;
@@ -23,6 +25,7 @@ async function publishWechatArticleRoute({
   dryRun,
   config,
   workspacePaths,
+  accountOverride,
 }: PublishRouteContext): Promise<PublishResult> {
   const postPath = join(state.asset_path, "post.md");
   let exportPostPath = postPath;
@@ -51,11 +54,14 @@ async function publishWechatArticleRoute({
     }
   }
 
+  const account = accountOverride || state.route.account;
+
   if (dryRun) {
     console.error(`[dry-run] Zotepad export: ${exportPostPath}`);
     console.error(`[dry-run] Wechat draft: ${state.metadata.title}`);
     return {
       route: "wechat-article",
+      account,
       status: "skipped",
       detail: "dry-run",
       published_at: null,
@@ -66,24 +72,30 @@ async function publishWechatArticleRoute({
 
   try {
     const markdownRenderer = await resolveMarkdownRenderer(config);
-    const wxAccount = config.wx.accounts[state.route.account] ?? config.wx.accounts[config.wx.defaultAccount];
+    const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
     const { html } = await markdownRenderer.render({
       markdownPath: exportPostPath,
       outPath: workspacePaths.zotepadExportHtml,
-      account: state.route.account,
+      account,
       title: state.metadata.title,
       customCss: wxAccount?.customCss ?? null,
+      themeOverrides: wxAccount?.theme,
     });
     await createWechatDraft({
-      account: state.route.account,
+      account,
       title: state.metadata.title,
       html,
       photos,
       config,
+      existingDraftMediaId: state.intent.existing_draft_media_id,
+      noteId: state.intent.note_id,
+      nezusBaseUrl: process.env.ZZHUB_WX_BASE_URL || config.wx.baseUrl,
+      nezusPat: process.env.ZZCLUB_PAT || config.wx.accounts[account]?.pat || config.wx.accounts[config.wx.defaultAccount]?.pat,
     });
   } catch (error) {
     return {
       route: "wechat-article",
+      account,
       status: "failed",
       detail: error instanceof Error ? error.message : String(error),
       published_at: null,
@@ -94,6 +106,7 @@ async function publishWechatArticleRoute({
 
   return {
     route: "wechat-article",
+    account,
     status: "success",
     detail: null,
     published_at: new Date().toISOString(),
@@ -106,6 +119,7 @@ async function publishWechatNewspicRoute({
   state,
   dryRun,
   config,
+  accountOverride,
 }: PublishRouteContext): Promise<PublishResult> {
   const postPath = join(state.asset_path, "post.md");
   const postContent = await readFile(postPath, "utf-8");
@@ -125,11 +139,14 @@ async function publishWechatNewspicRoute({
   const renderPhotos = assets.map((asset) => asset.path);
   const photos = mergePhotoLists(renderPhotos, bodyImageUrls);
 
+  const account = accountOverride || state.route.account;
+
   if (dryRun) {
     console.error(`[dry-run] Wechat newspic: ${state.metadata.title}`);
     console.error(`[dry-run] Content file: ${cleanPath}`);
     return {
       route: "wechat-newspic",
+      account,
       status: "skipped",
       detail: "dry-run",
       published_at: null,
@@ -140,15 +157,20 @@ async function publishWechatNewspicRoute({
 
   try {
     await createWechatNewspic({
-      account: state.route.account,
+      account,
       title: state.metadata.title,
       content: cleanContent,
       photos,
       config,
+      existingDraftMediaId: state.intent.existing_draft_media_id,
+      noteId: state.intent.note_id,
+      nezusBaseUrl: process.env.ZZHUB_WX_BASE_URL || config.wx.baseUrl,
+      nezusPat: process.env.ZZCLUB_PAT || config.wx.accounts[account]?.pat || config.wx.accounts[config.wx.defaultAccount]?.pat,
     });
   } catch (error) {
     return {
       route: "wechat-newspic",
+      account,
       status: "failed",
       detail: error instanceof Error ? error.message : String(error),
       published_at: null,
@@ -159,6 +181,7 @@ async function publishWechatNewspicRoute({
 
   return {
     route: "wechat-newspic",
+    account,
     status: "success",
     detail: null,
     published_at: new Date().toISOString(),
@@ -167,9 +190,10 @@ async function publishWechatNewspicRoute({
   };
 }
 
-const PUBLISH_PROVIDERS: Partial<Record<RoutePrimary, PublishProvider>> = {
+const PUBLISH_PROVIDERS: Record<RoutePrimary, PublishProvider> = {
   "wechat-article": publishWechatArticleRoute,
   "wechat-newspic": publishWechatNewspicRoute,
+  "blog": publishBlogRoute,
 };
 
 export function getPublishProvider(route: RoutePrimary): PublishProvider {

package/src/providers/publish-core.ts

@@ -0,0 +1,124 @@
+/**
+ * publish-core.ts — Shared publish execution logic.
+ *
+ * Used by both `publish` (normal flow) and `republish` (add-on).
+ */
+
+import type { PipelineConfig, ResolvedWorkspacePaths } from "../config";
+import type { PublishResult, PublishTarget, WorkflowState } from "../state";
+import { getPublishProvider, type PublishRouteContext } from "./index";
+
+export interface PublishTargetError {
+  route: string;
+  account: string;
+  error: string;
+}
+
+export interface ExecutePublishTargetsParams {
+  state: WorkflowState;
+  targets: PublishTarget[];
+  dryRun: boolean;
+  config: PipelineConfig;
+  workspacePaths: ResolvedWorkspacePaths;
+}
+
+export interface ExecutePublishTargetsResult {
+  results: PublishResult[];
+  errors: PublishTargetError[];
+}
+
+/**
+ * Deduplicate targets by route+account.
+ */
+export function dedupeTargets(targets: PublishTarget[]): PublishTarget[] {
+  const seen = new Set<string>();
+  const result: PublishTarget[] = [];
+  for (const target of targets) {
+    const key = `${target.route}@${target.account}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(target);
+    }
+  }
+  return result;
+}
+
+/**
+ * Filter out targets that already have a successful publish result
+ * at the current content_version + render_version.
+ */
+export function filterIdempotent(
+  targets: PublishTarget[],
+  existingResults: PublishResult[],
+  contentVersion: number,
+  renderVersion: number,
+): PublishTarget[] {
+  return targets.filter((target) => {
+    const existing = existingResults.find(
+      (r) =>
+        r.route === target.route &&
+        r.account === target.account &&
+        r.status === "success" &&
+        r.content_version === contentVersion &&
+        r.render_version === renderVersion,
+    );
+    return !existing;
+  });
+}
+
+/**
+ * Execute publish for a list of targets in parallel.
+ */
+export async function executePublishTargets(
+  params: ExecutePublishTargetsParams,
+): Promise<ExecutePublishTargetsResult> {
+  const { state, targets, dryRun, config, workspacePaths } = params;
+
+  const deduped = dedupeTargets(targets);
+  const filtered = filterIdempotent(
+    deduped,
+    state.publish.results,
+    state.artifacts.content_version,
+    state.artifacts.render_version,
+  );
+
+  const results: PublishResult[] = [];
+  const errors: PublishTargetError[] = [];
+
+  // Execute in parallel
+  const promises = filtered.map(async (target) => {
+    const provider = getPublishProvider(target.route);
+    const ctx: PublishRouteContext = {
+      state,
+      dryRun,
+      config,
+      workspacePaths,
+      accountOverride: target.account,
+    };
+
+    try {
+      const result = await provider(ctx);
+      return { result, error: null };
+    } catch (err) {
+      const error: PublishTargetError = {
+        route: target.route,
+        account: target.account,
+        error: err instanceof Error ? err.message : String(err),
+      };
+      return { result: null, error };
+    }
+  });
+
+  const outcomes = await Promise.all(promises);
+
+  for (const { result, error } of outcomes) {
+    if (result) {
+      results.push(result);
+    }
+    if (error) {
+      errors.push(error);
+    }
+  }
+
+  return { results, errors };
+}