@zzclub/pipeline 0.4.0 → 0.9.0

package/src/commands/publish.ts

@@ -16,14 +16,14 @@
 import { parseArgs, requireArg, optionalArg, flagArg } from "../args";
 import { printResult, renderPublish } from "../output";
 import { loadConfig, resolveWorkspacePaths } from "../config";
-import { getPublishProvider } from "../providers";
 import {
   readState,
   validateForPhase,
   writeState,
-  type PublishResult,
+  type PublishTarget,
   type RoutePrimary,
 } from "../state";
+import { executePublishTargets } from "../providers/publish-core";
 
 export async function publish(args: string[]): Promise<void> {
   const parsed = parseArgs(args);
@@ -34,7 +34,7 @@ Usage: zzhub-pipeline publish [options]
 
 Options:
   --state      Path to state JSON (required)
-  --route      Only publish this route (optional; default: all routes)
+  --route      Only publish this route (optional; default: all targets)
   --dry-run    Print commands without executing (optional)
 `.trim());
     return;
@@ -58,72 +58,45 @@ Options:
     );
   }
 
-  // Collect all routes to publish
-  const routes: RoutePrimary[] = routeOverride
-    ? [routeOverride]
-    : [state.route.primary, ...state.route.extras];
-
-  const results: PublishResult[] = [...state.publish.results];
-  let hasUnfinishedPublish = false;
-
-  for (const route of routes) {
-    // ── Idempotency check ──
-    const existing = results.find((r) => r.route === route);
-    if (
-      existing &&
-      existing.status === "success" &&
-      existing.content_version === state.artifacts.content_version &&
-      existing.render_version === state.artifacts.render_version
-    ) {
-      console.error(`[publish] Skipping ${route}: already published at current version`);
-      continue;
+  // Determine targets
+  let targets: PublishTarget[];
+  if (routeOverride) {
+    targets = [{ route: routeOverride, account: state.route.account }];
+  } else if (state.publish_targets.length > 0) {
+    targets = state.publish_targets;
+  } else {
+    // Derive from route (backward compat)
+    targets = [{ route: state.route.primary, account: state.route.account }];
+    for (const extra of state.route.extras) {
+      targets.push({ route: extra, account: state.route.account });
     }
+  }
 
-    try {
-      const provider = getPublishProvider(route);
-      const result = await provider({
-        state,
-        dryRun,
-        config,
-        workspacePaths,
-      });
-
-      // Upsert result
-      const idx = results.findIndex((r) => r.route === route);
-      if (idx >= 0) {
-        results[idx] = result;
-      } else {
-        results.push(result);
-      }
+  const { results, errors } = await executePublishTargets({
+    state,
+    targets,
+    dryRun,
+    config,
+    workspacePaths,
+  });
 
-      if (result.status !== "success" && result.status !== "skipped") {
-        hasUnfinishedPublish = true;
-      }
-    } catch (err) {
-      const detail = err instanceof Error ? err.message : String(err);
-      const failResult: PublishResult = {
-        route,
-        status: "failed",
-        detail,
-        published_at: null,
-        content_version: state.artifacts.content_version,
-        render_version: state.artifacts.render_version,
-      };
-      const idx = results.findIndex((r) => r.route === route);
-      if (idx >= 0) {
-        results[idx] = failResult;
-      } else {
-        results.push(failResult);
-      }
-      hasUnfinishedPublish = true;
+  // Upsert results into state
+  for (const result of results) {
+    const idx = state.publish.results.findIndex(
+      (r) => r.route === result.route && r.account === result.account,
+    );
+    if (idx >= 0) {
+      state.publish.results[idx] = result;
+    } else {
+      state.publish.results.push(result);
     }
   }
 
-  // Update state
-  state.publish.results = results;
-
-  const allDone = routes.every((route) => {
-    const r = results.find((x) => x.route === route);
+  // Check if all targets are done
+  const allDone = targets.every((target) => {
+    const r = state.publish.results.find(
+      (x) => x.route === target.route && x.account === target.account,
+    );
     return r && (r.status === "success" || r.status === "skipped");
   });
 
@@ -131,7 +104,7 @@ Options:
     state.mode = "done";
     state.phase.publish = { status: "done", error: null };
     state.phase.current = "done";
-  } else if (hasUnfinishedPublish) {
+  } else {
     state.mode = "active";
     state.phase.publish = { status: "pending", error: null };
     state.phase.current = "publish";
@@ -139,9 +112,13 @@ Options:
 
   await writeState(statePath, state);
 
-  printResult({
-    publish_results: results,
+  const output: any = {
+    publish_results: state.publish.results,
     mode: state.mode,
     phase: state.phase.current,
-  }, renderPublish);
+  };
+  if (errors.length > 0) {
+    output.errors = errors;
+  }
+  printResult(output, renderPublish);
 }

package/src/commands/republish.ts

@@ -0,0 +1,146 @@
+/**
+ * republish — Add publish targets and execute for new targets only.
+ *
+ * Used to publish a completed task to additional accounts/platforms
+ * without re-rendering.
+ *
+ * Usage:
+ *   zzhub-pipeline republish \
+ *     --state /path/to/state.json \
+ *     [--account ancientone] \
+ *     [--targets "wechat-article@ancientone,blog@default"] \
+ *     [--dry-run]
+ *
+ * Output: Updated state with new publish.results entries
+ */
+
+import { parseArgs, requireArg, optionalArg, flagArg } from "../args";
+import { printResult } from "../output";
+import { loadConfig, resolveWorkspacePaths } from "../config";
+import {
+  readState,
+  writeState,
+  type PublishTarget,
+  type RoutePrimary,
+} from "../state";
+import { executePublishTargets } from "../providers/publish-core";
+
+export async function republish(args: string[]): Promise<void> {
+  const parsed = parseArgs(args);
+
+  if (parsed.help) {
+    console.log(`
+Usage: zzhub-pipeline republish [options]
+
+Add publish targets and execute for new targets only.
+Used to publish a completed task to additional accounts/platforms.
+
+Options:
+  --state      Path to state JSON (required)
+  --account    Add target with state.route.primary and this account (optional)
+  --targets    Comma-separated: route@account,route@account (optional)
+  --dry-run    Print commands without executing (optional)
+
+Examples:
+  # Add single target (same route, different account)
+  zzhub-pipeline republish --state path --account ancientone
+
+  # Add multiple targets
+  zzhub-pipeline republish --state path --targets "wechat-article@ancientone,blog@default"
+
+  # Mix both
+  zzhub-pipeline republish --state path --account ancientone --targets "blog@default"
+`.trim());
+    return;
+  }
+
+  const statePath = requireArg(parsed, "state", "state JSON path");
+  const accountArg = optionalArg(parsed, "account");
+  const targetsArg = optionalArg(parsed, "targets");
+  const dryRun = flagArg(parsed, "dry-run");
+
+  const state = await readState(statePath);
+  const config = loadConfig();
+  const workspacePaths = resolveWorkspacePaths(state.workspace_root, config);
+
+  // Validate prerequisites
+  if (!state.asset_path) {
+    throw new Error("asset_path not set. Cannot republish.");
+  }
+  if (state.content_review.status !== "passed") {
+    throw new Error("content_review must be 'passed' before republish.");
+  }
+
+  // Parse new targets
+  const newTargets: PublishTarget[] = [];
+
+  // --account: add {state.route.primary, account}
+  if (accountArg) {
+    newTargets.push({
+      route: state.route.primary,
+      account: accountArg,
+    });
+  }
+
+  // --targets: parse "route@account,route@account,..."
+  if (targetsArg) {
+    const parts = targetsArg.split(",").map((t) => t.trim());
+    for (const part of parts) {
+      const atIdx = part.indexOf("@");
+      if (atIdx !== -1) {
+        const route = part.slice(0, atIdx).trim() as RoutePrimary;
+        const account = part.slice(atIdx + 1).trim();
+        newTargets.push({ route, account });
+      } else {
+        // No @: use state.route.primary as route, part as account
+        newTargets.push({
+          route: state.route.primary,
+          account: part.trim(),
+        });
+      }
+    }
+  }
+
+  if (newTargets.length === 0) {
+    throw new Error("No targets specified. Use --account or --targets.");
+  }
+
+  // Append to publish_targets (dedupe handled by executePublishTargets)
+  state.publish_targets = [...state.publish_targets, ...newTargets];
+
+  // Execute (executePublishTargets handles dedupe and idempotent filter)
+  const { results, errors } = await executePublishTargets({
+    state,
+    targets: newTargets,
+    dryRun,
+    config,
+    workspacePaths,
+  });
+
+  // Upsert results
+  for (const result of results) {
+    const idx = state.publish.results.findIndex(
+      (r) => r.route === result.route && r.account === result.account,
+    );
+    if (idx >= 0) {
+      state.publish.results[idx] = result;
+    } else {
+      state.publish.results.push(result);
+    }
+  }
+
+  // Mode stays done (or whatever it was)
+  state.updated_at = new Date().toISOString();
+
+  await writeState(statePath, state);
+
+  const output: any = {
+    publish_results: state.publish.results,
+    mode: state.mode,
+    new_targets: newTargets,
+  };
+  if (errors.length > 0) {
+    output.errors = errors;
+  }
+  printResult(output);
+}

package/src/commands/sync-blog.ts

@@ -1,7 +1,7 @@
 import { parseArgs, requireArg, flagArg } from "../args";
 import { printResult, renderSyncBlog } from "../output";
 import { loadConfig, resolveWorkspacePaths } from "../config";
-import { readState } from "../state";
+import { readState, updateState } from "../state";
 import { publishBlogRoute } from "../providers/blog";
 
 export async function syncBlog(args: string[]): Promise<void> {
@@ -20,13 +20,16 @@ Options:
 
   const statePath = requireArg(parsed, "state", "state JSON path");
   const dryRun = flagArg(parsed, "dry-run");
+
+  const config = loadConfig();
+
+  // Run the actual publish (may have network side effects)
   const state = await readState(statePath);
 
   if (!state.asset_path) {
     throw new Error("asset_path not set. Run prepare-finalize first.");
   }
 
-  const config = loadConfig();
   const workspacePaths = resolveWorkspacePaths(state.workspace_root, config);
   const result = await publishBlogRoute({
     state,
@@ -35,5 +38,18 @@ Options:
     workspacePaths,
   });
 
-  printResult(result, renderSyncBlog);
+  // Write result back to state
+  const finalState = await updateState(statePath, (s) => {
+    const idx = s.publish.results.findIndex((r) => r.route === "blog");
+    if (idx >= 0) {
+      s.publish.results[idx] = result;
+    } else {
+      s.publish.results.push(result);
+    }
+  });
+
+  printResult({
+    ...result,
+    mode: finalState.mode,
+  }, renderSyncBlog);
 }

package/src/commands/topic.test.ts

@@ -0,0 +1,146 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { addTopic, listTopics, updateTopic, scheduleTopic, retroTopic, abandonTopic } from "./topic";
+
+describe("topic commands", () => {
+  let workspace: string;
+
+  beforeEach(async () => {
+    workspace = await mkdtemp(join(tmpdir(), "zzhub-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(workspace, { recursive: true, force: true });
+  });
+
+  describe("addTopic", () => {
+    test("creates a new topic with defaults", async () => {
+      const result = await addTopic(workspace, {
+        title: "Test Topic",
+      });
+
+      expect(result.topic_id).toMatch(/^topic_/);
+      expect(result.title).toBe("Test Topic");
+      expect(result.status).toBe("backlog");
+      expect(result.priority).toBe("medium");
+    });
+
+    test("creates topic with all fields", async () => {
+      const result = await addTopic(workspace, {
+        title: "AI Tools",
+        description: "About AI",
+        priority: "high",
+        tags: ["AI", "tools"],
+        notes: "Some notes",
+      });
+
+      expect(result.priority).toBe("high");
+      expect(result.tags).toEqual(["AI", "tools"]);
+      expect(result.notes).toBe("Some notes");
+    });
+  });
+
+  describe("listTopics", () => {
+    test("lists all topics", async () => {
+      await addTopic(workspace, { title: "Topic 1" });
+      await addTopic(workspace, { title: "Topic 2" });
+
+      const topics = await listTopics(workspace, {});
+      expect(topics.length).toBe(2);
+    });
+
+    test("filters by status", async () => {
+      await addTopic(workspace, { title: "Topic 1", status: "backlog" });
+      await addTopic(workspace, { title: "Topic 2", status: "scheduled" });
+
+      const topics = await listTopics(workspace, { status: "backlog" });
+      expect(topics.length).toBe(1);
+      expect(topics[0].title).toBe("Topic 1");
+    });
+
+    test("filters by priority", async () => {
+      await addTopic(workspace, { title: "Topic 1", priority: "high" });
+      await addTopic(workspace, { title: "Topic 2", priority: "low" });
+
+      const topics = await listTopics(workspace, { priority: "high" });
+      expect(topics.length).toBe(1);
+    });
+
+    test("limits results", async () => {
+      await addTopic(workspace, { title: "Topic 1" });
+      await addTopic(workspace, { title: "Topic 2" });
+      await addTopic(workspace, { title: "Topic 3" });
+
+      const topics = await listTopics(workspace, { limit: 2 });
+      expect(topics.length).toBe(2);
+    });
+  });
+
+  describe("updateTopic", () => {
+    test("updates topic fields", async () => {
+      const topic = await addTopic(workspace, { title: "Original" });
+
+      const updated = await updateTopic(workspace, topic.topic_id, {
+        status: "evaluating",
+        ai_score: 85,
+        ai_reason: "Good topic",
+      });
+
+      expect(updated.status).toBe("evaluating");
+      expect(updated.ai_score).toBe(85);
+      expect(updated.ai_reason).toBe("Good topic");
+    });
+
+    test("throws if topic not found", async () => {
+      expect(
+        updateTopic(workspace, "nonexistent", { status: "scheduled" })
+      ).rejects.toThrow("Topic not found");
+    });
+  });
+
+  describe("scheduleTopic", () => {
+    test("schedules topic with date", async () => {
+      const topic = await addTopic(workspace, { title: "Test" });
+
+      const scheduled = await scheduleTopic(workspace, topic.topic_id, {
+        scheduled_date: "2026-06-15",
+        target_account: "default",
+      });
+
+      expect(scheduled.status).toBe("scheduled");
+      expect(scheduled.scheduled_date).toBe("2026-06-15");
+      expect(scheduled.target_account).toBe("default");
+    });
+  });
+
+  describe("retroTopic", () => {
+    test("adds retro and marks published", async () => {
+      const topic = await addTopic(workspace, { title: "Test" });
+
+      const retroed = await retroTopic(workspace, topic.topic_id, {
+        performance: "good",
+        lessons: "Learned something",
+        metrics_snapshot: { reads: 1500 },
+      });
+
+      expect(retroed.status).toBe("published");
+      expect(retroed.retro_performance).toBe("good");
+      expect(retroed.retro_lessons).toBe("Learned something");
+    });
+  });
+
+  describe("abandonTopic", () => {
+    test("marks topic as abandoned", async () => {
+      const topic = await addTopic(workspace, { title: "Test" });
+
+      const abandoned = await abandonTopic(workspace, topic.topic_id, {
+        reason: "Topic outdated",
+      });
+
+      expect(abandoned.status).toBe("abandoned");
+      expect(abandoned.notes).toContain("Topic outdated");
+    });
+  });
+});