autocrew 0.1.0

package/src/tools/asset.ts

@@ -0,0 +1,96 @@
+import { Type } from "@sinclair/typebox";
+import { addAsset, listAssets, removeAsset, listVersions, getVersion, revertToVersion } from "../storage/local-store.js";
+
+/**
+ * autocrew_asset — manage media files (covers, B-Roll, images, videos, subtitles)
+ * and version history for content projects.
+ */
+
+export const assetSchema = Type.Object({
+  action: Type.Unsafe<"add" | "list" | "remove" | "versions" | "get_version" | "revert">({
+    type: "string",
+    enum: ["add", "list", "remove", "versions", "get_version", "revert"],
+    description:
+      "Action: 'add' asset to content, 'list' assets, 'remove' asset, 'versions' list version history, 'get_version' read a specific version, 'revert' to a previous version.",
+  }),
+  content_id: Type.String({ description: "Content project id (e.g. content-xxx)" }),
+  filename: Type.Optional(Type.String({ description: "Asset filename (for add/remove)" })),
+  asset_type: Type.Optional(
+    Type.Unsafe<"cover" | "broll" | "image" | "video" | "audio" | "subtitle" | "other">({
+      type: "string",
+      enum: ["cover", "broll", "image", "video", "audio", "subtitle", "other"],
+      description: "Asset type (for add)",
+    }),
+  ),
+  description: Type.Optional(Type.String({ description: "Asset description (for add)" })),
+  source_path: Type.Optional(
+    Type.String({ description: "Absolute path to source file to copy into the project (for add)" }),
+  ),
+  version: Type.Optional(Type.Number({ description: "Version number (for get_version/revert)" })),
+});
+
+export async function executeAsset(params: Record<string, unknown>) {
+  const action = params.action as string;
+  const contentId = params.content_id as string;
+  const dataDir = (params._dataDir as string) || undefined;
+
+  if (!contentId) {
+    return { ok: false, error: "content_id is required" };
+  }
+
+  // --- Asset operations ---
+
+  if (action === "add") {
+    const filename = params.filename as string;
+    const assetType = (params.asset_type as string) || "other";
+    if (!filename) return { ok: false, error: "filename is required for add" };
+    const result = await addAsset(
+      contentId,
+      {
+        filename,
+        type: assetType as any,
+        description: (params.description as string) || undefined,
+        sourcePath: (params.source_path as string) || undefined,
+      },
+      dataDir,
+    );
+    return result;
+  }
+
+  if (action === "list") {
+    const assets = await listAssets(contentId, dataDir);
+    return { ok: true, content_id: contentId, assets };
+  }
+
+  if (action === "remove") {
+    const filename = params.filename as string;
+    if (!filename) return { ok: false, error: "filename is required for remove" };
+    const removed = await removeAsset(contentId, filename, dataDir);
+    return { ok: removed, message: removed ? `Removed ${filename}` : "Asset not found" };
+  }
+
+  // --- Version operations ---
+
+  if (action === "versions") {
+    const versions = await listVersions(contentId, dataDir);
+    return { ok: true, content_id: contentId, versions };
+  }
+
+  if (action === "get_version") {
+    const ver = params.version as number;
+    if (!ver) return { ok: false, error: "version number is required" };
+    const body = await getVersion(contentId, ver, dataDir);
+    if (!body) return { ok: false, error: `Version ${ver} not found` };
+    return { ok: true, content_id: contentId, version: ver, body };
+  }
+
+  if (action === "revert") {
+    const ver = params.version as number;
+    if (!ver) return { ok: false, error: "version number is required" };
+    const content = await revertToVersion(contentId, ver, dataDir);
+    if (!content) return { ok: false, error: `Failed to revert to version ${ver}` };
+    return { ok: true, content };
+  }
+
+  return { ok: false, error: `Unknown action: ${action}` };
+}

package/src/tools/content-save.ts

@@ -0,0 +1,276 @@
+import { Type } from "@sinclair/typebox";
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import {
+  saveContent,
+  listContents,
+  getContent,
+  updateContent,
+  transitionStatus,
+  createPlatformVariant,
+  listSiblings,
+  getAllowedTransitions,
+  normalizeLegacyStatus,
+} from "../storage/local-store.js";
+import type { ContentStatus } from "../storage/local-store.js";
+import {
+  slugify,
+  stagePath,
+  initPipeline,
+  addDraftVersion,
+  type ProjectMeta,
+} from "../storage/pipeline-store.js";
+import { executeHumanize } from "./humanize.js";
+
+const ALL_STATUSES = [
+  "topic_saved", "drafting", "draft_ready", "reviewing", "revision",
+  "approved", "cover_pending", "publish_ready", "publishing", "published", "archived",
+  // Legacy compat
+  "draft", "review",
+] as const;
+
+export const contentSaveSchema = Type.Object({
+  action: Type.Unsafe<"save" | "list" | "get" | "update" | "transition" | "create_variant" | "siblings" | "allowed_transitions">({
+    type: "string",
+    enum: ["save", "list", "get", "update", "transition", "create_variant", "siblings", "allowed_transitions"],
+    description:
+      "Action: 'save' new content, 'list' all, 'get' by id, 'update' existing, " +
+      "'transition' change status via state machine, 'create_variant' create platform variant from topic, " +
+      "'siblings' list sibling content, 'allowed_transitions' show valid next statuses.",
+  }),
+  id: Type.Optional(Type.String({ description: "Content id (for get/update/transition/siblings/allowed_transitions)" })),
+  title: Type.Optional(Type.String({ description: "Content title" })),
+  body: Type.Optional(Type.String({ description: "Content body (markdown)" })),
+  platform: Type.Optional(Type.String({ description: "Target platform: xhs, douyin, wechat_video, wechat_mp, bilibili" })),
+  topicId: Type.Optional(Type.String({ description: "Related topic id (for save/create_variant)" })),
+  status: Type.Optional(Type.Unsafe<string>({
+    type: "string",
+    enum: ALL_STATUSES as unknown as string[],
+    description: "Content status (for save/update). Use 'transition' action for validated state changes.",
+  })),
+  target_status: Type.Optional(Type.Unsafe<string>({
+    type: "string",
+    enum: ALL_STATUSES as unknown as string[],
+    description: "Target status for 'transition' action.",
+  })),
+  tags: Type.Optional(Type.Array(Type.String())),
+  hashtags: Type.Optional(Type.Array(Type.String(), { description: "Platform-specific hashtags" })),
+  siblings: Type.Optional(Type.Array(Type.String(), { description: "Sibling content IDs" })),
+  publish_url: Type.Optional(Type.String({ description: "Published URL on target platform" })),
+  performance_data: Type.Optional(Type.Record(Type.String(), Type.Number(), { description: "Performance metrics: views, likes, comments, shares, etc." })),
+  force: Type.Optional(Type.Boolean({ description: "Force transition even if not in allowed transitions" })),
+  diff_note: Type.Optional(Type.String({ description: "Note for revision diff tracking" })),
+  hypothesis: Type.Optional(Type.String({ description: "Traffic hypothesis: what this content tests and expected outcome" })),
+  experiment_type: Type.Optional(Type.Unsafe<string>({
+    type: "string",
+    enum: ["title_test", "hook_test", "format_test", "angle_test"],
+    description: "Type of experiment this content represents",
+  })),
+  control_ref: Type.Optional(Type.String({ description: "Content ID this is being A/B tested against" })),
+  content_pillar: Type.Optional(Type.String({ description: "Which content pillar this belongs to" })),
+  comment_triggers: Type.Optional(Type.Array(
+    Type.Object({
+      type: Type.Unsafe<string>({ type: "string", enum: ["controversy", "unanswered_question", "quote_hook"] }),
+      position: Type.String(),
+    }),
+    { description: "Comment engineering trigger points" },
+  )),
+});
+
+export async function executeContentSave(params: Record<string, unknown>) {
+  const action = (params.action as string) || "save";
+  const dataDir = (params._dataDir as string) || undefined;
+
+  if (action === "list") {
+    const contents = await listContents(dataDir);
+    return { ok: true, contents };
+  }
+
+  if (action === "get") {
+    const id = params.id as string;
+    if (!id) return { ok: false, error: "id is required for get" };
+    const content = await getContent(id, dataDir);
+    if (!content) return { ok: false, error: `Content ${id} not found` };
+    return { ok: true, content };
+  }
+
+  if (action === "update") {
+    const id = params.id as string;
+    if (!id) return { ok: false, error: "id is required for update" };
+    const updated = await updateContent(id, {
+      title: params.title as string | undefined,
+      body: params.body as string | undefined,
+      platform: params.platform as string | undefined,
+      status: params.status ? normalizeLegacyStatus(params.status as string) : undefined,
+      tags: params.tags as string[] | undefined,
+      hashtags: params.hashtags as string[] | undefined,
+      siblings: params.siblings as string[] | undefined,
+      publishUrl: params.publish_url as string | undefined,
+      performanceData: params.performance_data as Record<string, number> | undefined,
+    }, dataDir);
+    if (!updated) return { ok: false, error: `Content ${id} not found` };
+
+    // Also version in pipeline storage if body changed
+    if (params.body && updated.title) {
+      try {
+        const projectName = slugify(updated.title);
+        await addDraftVersion(
+          projectName,
+          params.body as string,
+          (params.diff_note as string) || "Edit via update",
+          dataDir ? path.join(dataDir, "data") : undefined,
+        );
+      } catch {
+        // Pipeline project may not exist for legacy content — that's OK
+      }
+    }
+
+    return { ok: true, content: updated };
+  }
+
+  if (action === "transition") {
+    const id = params.id as string;
+    const targetStatus = params.target_status as string;
+    if (!id) return { ok: false, error: "id is required for transition" };
+    if (!targetStatus) return { ok: false, error: "target_status is required for transition" };
+    const result = await transitionStatus(
+      id,
+      normalizeLegacyStatus(targetStatus),
+      { force: params.force as boolean, diffNote: params.diff_note as string },
+      dataDir,
+    );
+    return result;
+  }
+
+  if (action === "create_variant") {
+    const topicId = params.topicId as string;
+    const platform = params.platform as string;
+    if (!topicId) return { ok: false, error: "topicId is required for create_variant" };
+    if (!platform) return { ok: false, error: "platform is required for create_variant" };
+    const result = await createPlatformVariant(
+      topicId,
+      platform,
+      { title: params.title as string, body: params.body as string },
+      dataDir,
+    );
+    return result;
+  }
+
+  if (action === "siblings") {
+    const id = params.id as string;
+    if (!id) return { ok: false, error: "id is required for siblings" };
+    const sibs = await listSiblings(id, dataDir);
+    return { ok: true, siblings: sibs };
+  }
+
+  if (action === "allowed_transitions") {
+    const id = params.id as string;
+    if (!id) return { ok: false, error: "id is required for allowed_transitions" };
+    const content = await getContent(id, dataDir);
+    if (!content) return { ok: false, error: `Content ${id} not found` };
+    const currentStatus = normalizeLegacyStatus(content.status);
+    const allowed = getAllowedTransitions(currentStatus);
+    return { ok: true, currentStatus, allowedTransitions: allowed };
+  }
+
+  // save
+  const title = params.title as string;
+  const body = params.body as string;
+  if (!title || !body) {
+    return { ok: false, error: "title and body are required for save" };
+  }
+
+  const rawStatus = (params.status as string) || "draft_ready";
+  const platform = (params.platform as string) || undefined;
+
+  // 1. Save to old contents/ system (backward compat)
+  const content = await saveContent({
+    title,
+    body,
+    platform,
+    topicId: (params.topicId as string) || undefined,
+    status: normalizeLegacyStatus(rawStatus),
+    tags: (params.tags as string[]) || [],
+    hashtags: (params.hashtags as string[]) || [],
+  }, dataDir);
+
+  // 2. Also create project in new pipeline/drafting/ structure
+  const effectiveDataDir = dataDir || path.join(process.env.HOME ?? "~", ".autocrew");
+  await initPipeline(effectiveDataDir);
+
+  const projectName = slugify(title);
+  const draftingDir = stagePath("drafting", effectiveDataDir);
+  const projectDir = path.join(draftingDir, projectName);
+  await fs.mkdir(path.join(projectDir, "references"), { recursive: true });
+
+  const now = new Date().toISOString();
+  const meta: ProjectMeta = {
+    title,
+    domain: "",
+    format: platform || "article",
+    createdAt: now,
+    sourceTopic: "",
+    intelRefs: [],
+    versions: [{ file: "draft-v1.md", createdAt: now, note: "initial draft" }],
+    current: "draft-v1.md",
+    history: [{ stage: "drafting", entered: now }],
+    platforms: platform ? [{ format: platform, status: "drafting" }] : [],
+    hypothesis: (params.hypothesis as string) || undefined,
+    experimentType: (params.experiment_type as ProjectMeta["experimentType"]) || undefined,
+    controlRef: (params.control_ref as string) || undefined,
+    contentPillar: (params.content_pillar as string) || undefined,
+    commentTriggers: (params.comment_triggers as ProjectMeta["commentTriggers"]) || undefined,
+  };
+
+  await fs.writeFile(
+    path.join(projectDir, "meta.yaml"),
+    yaml.dump(meta, { lineWidth: -1 }),
+    "utf-8",
+  );
+  await fs.writeFile(
+    path.join(projectDir, "draft-v1.md"),
+    body,
+    "utf-8",
+  );
+  await fs.writeFile(
+    path.join(projectDir, "draft.md"),
+    `# ${title}\n\n${body}\n`,
+    "utf-8",
+  );
+
+  // Auto-humanize (tool-level enforcement — LLM cannot skip this)
+  let humanizeResult: Record<string, unknown> | null = null;
+  try {
+    humanizeResult = await executeHumanize({
+      action: "humanize_zh",
+      content_id: content.id,
+      save_back: true,
+      _dataDir: dataDir,
+    }) as Record<string, unknown>;
+  } catch {
+    // Humanize failure should not block save
+  }
+
+  return {
+    ok: true,
+    content,
+    humanized: humanizeResult?.ok ?? false,
+    humanizeChanges: (humanizeResult as any)?.changeCount ?? 0,
+    filePath: `${projectDir}/draft.md`,
+    projectDir,
+    pipelinePath: projectDir,
+    legacyDir: `${effectiveDataDir}/contents/${content.id}`,
+    openCommand: `open "${projectDir}"`,
+    message: [
+      `📄 内容已保存到 pipeline：`,
+      `   草稿：${projectDir}/draft.md`,
+      `   元数据：${projectDir}/meta.yaml`,
+      `   版本：${projectDir}/draft-v1.md`,
+      `   自动去AI味：${humanizeResult?.ok ? "✅ 已处理" : "⚠️ 跳过"}`,
+      ``,
+      `打开文件夹：open "${projectDir}"`,
+      `查看草稿：cat "${projectDir}/draft.md"`,
+    ].join("\n"),
+  };
+}

package/src/tools/cover-review.ts

@@ -0,0 +1,221 @@
+/**
+ * Cover Review Tool — generate, review, and approve cover images.
+ *
+ * Actions:
+ * - create_candidates: generate 3 style variants (A/B/C) as 3:4 images
+ * - get: retrieve existing cover review for a content
+ * - approve: approve a selected variant
+ * - generate_ratios: [Pro] generate 16:9 + 4:3 from approved cover
+ */
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import {
+  getContent,
+  getCoverReview,
+  saveCoverReview,
+  approveCoverVariant,
+  type CoverReview,
+  type CoverVariant,
+} from "../storage/local-store.js";
+import { buildCoverPrompts, type CoverPromptSet } from "../modules/cover/prompt-builder.js";
+import { generateImage, listReferencePhotos, type GeminiModel } from "../adapters/image/gemini.js";
+import { generateMultiRatio } from "../modules/cover/ratio-adapter.js";
+
+type CoverLabel = "a" | "b" | "c";
+
+export const coverReviewSchema = Type.Object({
+  action: Type.Unsafe<"create_candidates" | "get" | "approve" | "generate_ratios">({
+    type: "string",
+    enum: ["create_candidates", "get", "approve", "generate_ratios"],
+    description:
+      "Cover action: create_candidates (generate 3 covers), get (view review), approve (pick one), generate_ratios (Pro: 16:9 + 4:3).",
+  }),
+  content_id: Type.String({ description: "AutoCrew content id." }),
+  label: Type.Optional(
+    Type.Unsafe<CoverLabel>({
+      type: "string",
+      enum: ["a", "b", "c"],
+      description: "Which variant to approve (for approve action).",
+    }),
+  ),
+  custom_title: Type.Optional(
+    Type.String({ description: "Override the auto-extracted cover title (2-8 Chinese chars)." }),
+  ),
+  _geminiApiKey: Type.Optional(Type.String()),
+  _geminiModel: Type.Optional(Type.String()),
+  _dataDir: Type.Optional(Type.String()),
+});
+
+function getDataDir(params: Record<string, unknown>): string {
+  if (params._dataDir) return params._dataDir as string;
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".autocrew");
+}
+
+function getGeminiApiKey(params: Record<string, unknown>): string | null {
+  return (params._geminiApiKey as string) || process.env.GEMINI_API_KEY || null;
+}
+
+function getGeminiModel(params: Record<string, unknown>): GeminiModel {
+  const m = params._geminiModel as string;
+  if (m === "imagen-4" || m === "gemini-native") return m;
+  return "auto";
+}
+
+export async function executeCoverReview(params: Record<string, unknown>) {
+  const action = params.action as string;
+  const contentId = params.content_id as string;
+  const dataDir = getDataDir(params);
+
+  if (!contentId) return { ok: false, error: "content_id is required" };
+
+  // --- GET ---
+  if (action === "get") {
+    const review = await getCoverReview(contentId, dataDir);
+    if (!review) return { ok: false, error: `No cover review found for ${contentId}` };
+    return { ok: true, review };
+  }
+
+  // --- APPROVE ---
+  if (action === "approve") {
+    const label = params.label as CoverLabel;
+    if (!label) return { ok: false, error: "label (a/b/c) is required for approve action" };
+
+    const result = await approveCoverVariant(contentId, label, dataDir);
+    if (!result) return { ok: false, error: `Failed to approve variant ${label} for ${contentId}` };
+    return { ok: true, review: result };
+  }
+
+  // --- CREATE CANDIDATES ---
+  if (action === "create_candidates") {
+    const apiKey = getGeminiApiKey(params);
+    if (!apiKey) {
+      return {
+        ok: false,
+        error: "Gemini API key required for cover generation.",
+        hint: "免费获取：https://aistudio.google.com/apikey — 在 OpenClaw 插件设置中填入 gemini_api_key",
+      };
+    }
+
+    const content = await getContent(contentId, dataDir);
+    if (!content) return { ok: false, error: `Content ${contentId} not found` };
+
+    const model = getGeminiModel(params);
+    const referencePhotos = await listReferencePhotos(dataDir);
+
+    // Build 3 prompt sets
+    const promptSets = buildCoverPrompts({
+      title: content.title,
+      body: content.body,
+      platform: content.platform,
+      hasReferencePhotos: referencePhotos.length > 0,
+      customTitle: params.custom_title as string | undefined,
+    });
+
+    // Generate 3 images
+    const assetsDir = path.join(dataDir, "contents", contentId, "assets", "covers");
+    const variants: CoverVariant[] = [];
+    const errors: string[] = [];
+
+    for (const ps of promptSets) {
+      const outputPath = path.join(assetsDir, `cover-${ps.label.toLowerCase()}`);
+      const result = await generateImage({
+        prompt: ps.imagePrompt,
+        aspectRatio: "3:4",
+        model,
+        apiKey,
+        referenceImagePaths: referencePhotos.length > 0 ? referencePhotos : undefined,
+        outputPath,
+      });
+
+      if (result.ok) {
+        variants.push({
+          label: ps.label.toLowerCase() as CoverLabel,
+          imagePrompt: ps.imagePrompt,
+          style: ps.style,
+          titleText: ps.titleText,
+          imagePaths: { "3:4": result.imagePath },
+          model: result.model,
+          hasPersonalIP: referencePhotos.length > 0,
+          layoutHint: ps.layoutHint,
+          designReason: `${ps.style} 风格 — ${ps.layoutHint.slice(0, 60)}`,
+        });
+      } else {
+        errors.push(`${ps.label}: ${result.error}`);
+      }
+    }
+
+    if (variants.length === 0) {
+      return { ok: false, error: "All 3 cover generations failed", details: errors };
+    }
+
+    // Save cover review
+    const review: CoverReview = {
+      platform: content.platform || "xhs",
+      status: "review_pending",
+      variants,
+      createdAt: new Date().toISOString(),
+    };
+
+    const saved = await saveCoverReview(contentId, review, dataDir);
+    if (!saved) return { ok: false, error: "Failed to save cover review" };
+
+    return {
+      ok: true,
+      review,
+      generated: variants.length,
+      failed: errors.length,
+      errors: errors.length > 0 ? errors : undefined,
+    };
+  }
+
+  // --- GENERATE RATIOS (Pro) ---
+  if (action === "generate_ratios") {
+    const apiKey = getGeminiApiKey(params);
+    if (!apiKey) {
+      return { ok: false, error: "Gemini API key required." };
+    }
+
+    const review = await getCoverReview(contentId, dataDir);
+    if (!review) return { ok: false, error: `No cover review found for ${contentId}` };
+    if (!review.approvedLabel) return { ok: false, error: "No variant approved yet. Run approve first." };
+
+    const approved = review.variants.find((v) => v.label === review.approvedLabel);
+    if (!approved?.imagePrompt) return { ok: false, error: "Approved variant has no prompt" };
+
+    const model = getGeminiModel(params);
+    const referencePhotos = approved.hasPersonalIP ? await listReferencePhotos(dataDir) : undefined;
+    const assetsDir = path.join(dataDir, "contents", contentId, "assets", "covers");
+
+    const result = await generateMultiRatio({
+      originalPrompt: approved.imagePrompt,
+      apiKey,
+      model,
+      referenceImagePaths: referencePhotos,
+      outputDir: assetsDir,
+      baseName: `cover-${approved.label}`,
+      dataDir,
+    });
+
+    // Pro gate returned upgrade hint
+    if ("upgradeHint" in result) return result;
+
+    // Update variant with new paths
+    if (result.paths["16:9"]) {
+      approved.imagePaths = { ...approved.imagePaths, "16:9": result.paths["16:9"] };
+    }
+    if (result.paths["4:3"]) {
+      approved.imagePaths = { ...approved.imagePaths, "4:3": result.paths["4:3"] };
+    }
+
+    await saveCoverReview(contentId, review, dataDir);
+
+    return {
+      ok: result.ok,
+      paths: result.paths,
+      errors: result.errors.length > 0 ? result.errors : undefined,
+    };
+  }
+
+  return { ok: false, error: `Unknown action: ${action}` };
+}

package/src/tools/humanize.ts

@@ -0,0 +1,54 @@
+import { Type } from "@sinclair/typebox";
+import { getContent, updateContent } from "../storage/local-store.js";
+import { humanizeZh } from "../modules/humanizer/zh.js";
+
+export const humanizeSchema = Type.Object({
+  action: Type.Unsafe<"humanize_zh">({
+    type: "string",
+    enum: ["humanize_zh"],
+    description: "Action. Currently supports 'humanize_zh'.",
+  }),
+  content_id: Type.Optional(Type.String({ description: "AutoCrew content id to humanize and optionally save back." })),
+  text: Type.Optional(Type.String({ description: "Raw text to humanize directly." })),
+  save_back: Type.Optional(Type.Boolean({ description: "When content_id is provided, save the humanized text back into the draft." })),
+});
+
+export async function executeHumanize(params: Record<string, unknown>) {
+  const action = params.action as string;
+  if (action !== "humanize_zh") {
+    return { ok: false, error: `Unknown action: ${action}` };
+  }
+
+  const dataDir = (params._dataDir as string) || undefined;
+  let title = "";
+  let text = (params.text as string) || "";
+  const contentId = params.content_id as string | undefined;
+
+  if (!text && contentId) {
+    const content = await getContent(contentId, dataDir);
+    if (!content) {
+      return { ok: false, error: `Content ${contentId} not found` };
+    }
+    title = content.title;
+    text = content.body;
+  }
+
+  if (!text) {
+    return { ok: false, error: "text or content_id is required" };
+  }
+
+  const result = humanizeZh({ text });
+  if (contentId && params.save_back) {
+    const updated = await updateContent(
+      contentId,
+      {
+        title: title || undefined,
+        body: result.humanizedText,
+      },
+      dataDir,
+    );
+    return { ...result, content: updated };
+  }
+
+  return result;
+}