@zzclub/pipeline 0.10.2 → 0.11.0

package/src/commands/analytics.ts

@@ -1,240 +0,0 @@
-import { readFile } from "fs/promises";
-import { dirname, isAbsolute, resolve } from "path";
-import { ensureDb } from "../db";
-import { AnalyticsSchema, type Analytics } from "../schema/analytics";
-import { parseArgs, requireArg, optionalArg } from "../args";
-import { printResult } from "../output";
-
-export interface RecordAnalyticsInput {
-  statePath: string;
-  reads?: number;
-  likes?: number;
-  favorites?: number;
-  shares?: number;
-  comments?: number;
-  notes?: string;
-}
-
-function resolveWorkspace(statePath: string): string {
-  const postsIdx = statePath.lastIndexOf("/posts/");
-  if (postsIdx !== -1) {
-    return statePath.substring(0, postsIdx);
-  }
-  return dirname(statePath);
-}
-
-export async function recordAnalytics(
-  input: RecordAnalyticsInput,
-): Promise<Analytics> {
-  const requestedPath = resolve(input.statePath);
-  let statePath = requestedPath;
-  let state = JSON.parse(await readFile(statePath, "utf-8"));
-  if (typeof state.state_path === "string" && state.state_path.trim()) {
-    const candidatePath = isAbsolute(state.state_path)
-      ? resolve(state.state_path)
-      : resolve(dirname(statePath), state.state_path);
-    if (candidatePath !== statePath) {
-      try {
-        state = JSON.parse(await readFile(candidatePath, "utf-8"));
-        statePath = candidatePath;
-      } catch (error) {
-        const code = error instanceof Error && "code" in error
-          ? String((error as NodeJS.ErrnoException).code)
-          : "";
-        if (code !== "ENOENT") throw error;
-      }
-    }
-  }
-
-  const workspace = state.workspace_root || resolveWorkspace(statePath);
-  const db = ensureDb(workspace);
-
-  try {
-    const now = new Date().toISOString();
-    const publishDate = state.metadata?.date || now.split("T")[0];
-    const title = state.metadata?.title || "Untitled";
-    const topicId = state.topic_id || null;
-
-    db.prepare(
-      `INSERT OR REPLACE INTO analytics (
-        run_id, topic_id, title, publish_date,
-        reads, likes, favorites, shares, comments,
-        notes, recorded_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    ).run(
-      state.run_id,
-      topicId,
-      title,
-      publishDate,
-      input.reads ?? 0,
-      input.likes ?? 0,
-      input.favorites ?? 0,
-      input.shares ?? 0,
-      input.comments ?? 0,
-      input.notes ?? null,
-      now,
-    );
-
-    const row = db
-      .prepare("SELECT * FROM analytics WHERE run_id = ?")
-      .get(state.run_id) as Record<string, unknown>;
-    return AnalyticsSchema.parse(row);
-  } finally {
-    db.close();
-  }
-}
-
-export interface ListAnalyticsFilter {
-  days?: number;
-  sort?: string;
-  limit?: number;
-}
-
-const ALLOWED_SORT_FIELDS = new Set([
-  "publish_date",
-  "reads",
-  "likes",
-  "favorites",
-  "shares",
-  "comments",
-  "recorded_at",
-  "title",
-]);
-
-export async function listAnalytics(
-  workspace: string,
-  filter: ListAnalyticsFilter,
-): Promise<Analytics[]> {
-  const db = ensureDb(workspace);
-
-  try {
-    const conditions: string[] = [];
-    const params: (string | number)[] = [];
-
-    if (filter.days) {
-      conditions.push("publish_date >= date('now', ?)");
-      params.push(`-${filter.days} days`);
-    }
-
-    const where =
-      conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-
-    const sortField = filter.sort || "publish_date";
-    if (!ALLOWED_SORT_FIELDS.has(sortField)) {
-      throw new Error(
-        `Invalid sort field: ${sortField}. Allowed: ${[...ALLOWED_SORT_FIELDS].join(", ")}`,
-      );
-    }
-
-    const limit = filter.limit ?? 50;
-
-    const sql = `SELECT * FROM analytics ${where} ORDER BY ${sortField} DESC LIMIT ?`;
-    params.push(limit);
-
-    const rows = db
-      .prepare(sql)
-      .all(...params) as Record<string, unknown>[];
-    return rows.map((row) => AnalyticsSchema.parse(row));
-  } finally {
-    db.close();
-  }
-}
-
-// CLI handler
-export async function analytics(args: string[]): Promise<void> {
-  const parsed = parseArgs(args);
-
-  if (parsed.help || args.length === 0) {
-    console.log(`
-Usage: zzhub-pipeline analytics <subcommand> [options]
-
-Subcommands:
-  record     Record post-publish metrics
-  list       List analytics history
-
-Run 'zzhub-pipeline analytics <subcommand> --help' for details.
-`.trim());
-    return;
-  }
-
-  const subcommand = args[0];
-  const subArgs = args.slice(1);
-
-  switch (subcommand) {
-    case "record":
-      return analyticsRecord(subArgs);
-    case "list":
-      return analyticsList(subArgs);
-    default:
-      throw new Error(`Unknown analytics subcommand: ${subcommand}`);
-  }
-}
-
-async function analyticsRecord(args: string[]): Promise<void> {
-  const parsed = parseArgs(args);
-
-  if (parsed.help) {
-    console.log(`
-Usage: zzhub-pipeline analytics record [options]
-
-Options:
-  --state      State file path (required)
-  --reads      Read count
-  --likes      Like count
-  --favorites  Favorite count
-  --shares     Share count
-  --comments   Comment count
-  --notes      Notes
-`.trim());
-    return;
-  }
-
-  const statePath = requireArg(parsed, "state", "State file path");
-  const readsStr = optionalArg(parsed, "reads");
-  const likesStr = optionalArg(parsed, "likes");
-  const favoritesStr = optionalArg(parsed, "favorites");
-  const sharesStr = optionalArg(parsed, "shares");
-  const commentsStr = optionalArg(parsed, "comments");
-  const notes = optionalArg(parsed, "notes");
-
-  const result = await recordAnalytics({
-    statePath,
-    reads: readsStr ? parseInt(readsStr, 10) : undefined,
-    likes: likesStr ? parseInt(likesStr, 10) : undefined,
-    favorites: favoritesStr ? parseInt(favoritesStr, 10) : undefined,
-    shares: sharesStr ? parseInt(sharesStr, 10) : undefined,
-    comments: commentsStr ? parseInt(commentsStr, 10) : undefined,
-    notes,
-  });
-
-  printResult(result);
-}
-
-async function analyticsList(args: string[]): Promise<void> {
-  const parsed = parseArgs(args);
-
-  if (parsed.help) {
-    console.log(`
-Usage: zzhub-pipeline analytics list [options]
-
-Options:
-  --workspace  Workspace path (required)
-  --days       Show last N days (default: all)
-  --sort       Sort field: publish_date/reads/likes (default: publish_date)
-  --limit      Max results (default: 50)
-  --view       Output format: json/markdown/agent (default: json)
-`.trim());
-    return;
-  }
-
-  const workspace = requireArg(parsed, "workspace", "Workspace path");
-  const daysStr = optionalArg(parsed, "days");
-  const days = daysStr ? parseInt(daysStr, 10) : undefined;
-  const sort = optionalArg(parsed, "sort");
-  const limitStr = optionalArg(parsed, "limit");
-  const limit = limitStr ? parseInt(limitStr, 10) : undefined;
-
-  const result = await listAnalytics(workspace, { days, sort, limit });
-
-  printResult(result);
-}

package/src/commands/topic.test.ts

@@ -1,146 +0,0 @@
-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");
-    });
-  });
-});