autocrew 0.1.0

package/src/tools/pre-publish.ts

@@ -0,0 +1,232 @@
+/**
+ * autocrew_pre_publish tool — Pre-publish checklist gate.
+ *
+ * Runs 6 checks before allowing content to be published:
+ * 1. Content review passed
+ * 2. Cover review passed (XHS/Douyin only)
+ * 3. Hashtags exist
+ * 4. Title within platform length range
+ * 5. Platform is set
+ * 6. Body length meets platform minimum
+ */
+import { Type } from "@sinclair/typebox";
+import { getContent, getCoverReview, transitionStatus, normalizeLegacyStatus } from "../storage/local-store.js";
+import { executeReview } from "./review.js";
+import { getPlatformRules } from "../modules/writing/title-hashtag.js";
+
+// --- Types ---
+
+export interface CheckItem {
+  name: string;
+  status: "pass" | "fail" | "warn" | "skip";
+  detail: string;
+  fix?: string;
+}
+
+export interface PrePublishResult {
+  ok: boolean;
+  contentId: string;
+  platform: string;
+  checks: CheckItem[];
+  allPassed: boolean;
+  passCount: number;
+  failCount: number;
+  summary: string;
+}
+
+// --- Platform body length minimums ---
+
+const PLATFORM_MIN_BODY: Record<string, number> = {
+  xiaohongshu: 200,
+  xhs: 200,
+  douyin: 100,
+  wechat_mp: 800,
+  wechat_video: 100,
+  bilibili: 200,
+};
+
+// --- Platforms that require cover review ---
+
+const COVER_REQUIRED_PLATFORMS = new Set(["xiaohongshu", "xhs", "douyin"]);
+
+// --- Schema ---
+
+export const prePublishSchema = Type.Object({
+  action: Type.Unsafe<"check">({
+    type: "string",
+    enum: ["check"],
+    description: "Action. 'check' runs the full pre-publish checklist.",
+  }),
+  content_id: Type.String({ description: "AutoCrew content id to check." }),
+});
+
+// --- Execute ---
+
+export async function executePrePublish(params: Record<string, unknown>): Promise<PrePublishResult | { ok: false; error: 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" };
+
+  const content = await getContent(contentId, dataDir);
+  if (!content) return { ok: false, error: `Content ${contentId} not found` };
+
+  const platform = content.platform || "";
+  const checks: CheckItem[] = [];
+
+  // --- Check 1: Content review ---
+  try {
+    const reviewResult = await executeReview({
+      action: "full_review",
+      content_id: contentId,
+      platform,
+      _dataDir: dataDir,
+    }) as any;
+
+    if (reviewResult.passed) {
+      const score = reviewResult.qualityScore?.total ?? "?";
+      checks.push({ name: "内容审核", status: "pass", detail: `通过 (质量 ${score}/100)` });
+    } else {
+      checks.push({
+        name: "内容审核",
+        status: "fail",
+        detail: reviewResult.summary || "未通过",
+        fix: "运行 autocrew_review action='auto_fix' 自动修复",
+      });
+    }
+  } catch {
+    checks.push({ name: "内容审核", status: "fail", detail: "审核执行出错", fix: "手动运行 autocrew_review" });
+  }
+
+  // --- Check 2: Cover review (XHS/Douyin only) ---
+  if (COVER_REQUIRED_PLATFORMS.has(platform)) {
+    const coverReview = await getCoverReview(contentId, dataDir);
+    if (coverReview && coverReview.status === "approved" && coverReview.approvedLabel) {
+      checks.push({ name: "封面审核", status: "pass", detail: `已选定 ${coverReview.approvedLabel.toUpperCase()} 方案` });
+    } else if (coverReview && coverReview.status === "publish_ready" && coverReview.approvedLabel) {
+      checks.push({ name: "封面审核", status: "pass", detail: `已选定 ${coverReview.approvedLabel.toUpperCase()} 方案` });
+    } else {
+      checks.push({
+        name: "封面审核",
+        status: "fail",
+        detail: coverReview ? `状态: ${coverReview.status}` : "未完成",
+        fix: "运行 autocrew_cover_review action='create_candidates' 创建候选",
+      });
+    }
+  } else {
+    checks.push({ name: "封面审核", status: "skip", detail: `${platform || "未知"} 平台无需封面审核` });
+  }
+
+  // --- Check 3: Hashtags ---
+  const hashtags = content.hashtags || [];
+  if (hashtags.length >= 1) {
+    checks.push({ name: "Hashtags", status: "pass", detail: `${hashtags.length} 个标签` });
+  } else {
+    checks.push({
+      name: "Hashtags",
+      status: "fail",
+      detail: "无标签",
+      fix: "通过 autocrew_rewrite 生成标题和标签，或手动 update hashtags",
+    });
+  }
+
+  // --- Check 4: Title length ---
+  const title = content.title || "";
+  const rules = getPlatformRules(platform);
+  if (!title) {
+    checks.push({ name: "标题规范", status: "fail", detail: "无标题", fix: "设置标题" });
+  } else if (rules) {
+    const [minLen, maxLen] = rules.titleLengthRange;
+    const maxAbsolute = rules.maxTitleLength;
+    if (title.length > maxAbsolute) {
+      checks.push({
+        name: "标题规范",
+        status: "warn",
+        detail: `「${title}」(${title.length}字，超出 ${maxAbsolute} 上限)`,
+        fix: "通过 autocrew_rewrite 生成更短的标题变体",
+      });
+    } else if (title.length < minLen) {
+      checks.push({
+        name: "标题规范",
+        status: "warn",
+        detail: `「${title}」(${title.length}字，低于建议 ${minLen} 下限)`,
+      });
+    } else {
+      checks.push({
+        name: "标题规范",
+        status: "pass",
+        detail: `「${title}」(${title.length}字，符合 ${minLen}-${maxLen} 范围)`,
+      });
+    }
+  } else {
+    // No rules for this platform, just check title exists
+    checks.push({ name: "标题规范", status: "pass", detail: `「${title}」(${title.length}字)` });
+  }
+
+  // --- Check 5: Platform set ---
+  const supportedPlatforms = ["xiaohongshu", "xhs", "douyin", "wechat_mp", "wechat_video", "bilibili"];
+  if (platform && supportedPlatforms.includes(platform)) {
+    checks.push({ name: "平台设置", status: "pass", detail: platform });
+  } else if (platform) {
+    checks.push({ name: "平台设置", status: "warn", detail: `${platform} (非标准平台)` });
+  } else {
+    checks.push({ name: "平台设置", status: "fail", detail: "未指定平台", fix: "通过 autocrew_content update 设置 platform" });
+  }
+
+  // --- Check 6: Body length ---
+  const bodyLen = (content.body || "").length;
+  const minBody = PLATFORM_MIN_BODY[platform] || 100;
+  if (bodyLen >= minBody) {
+    checks.push({ name: "正文字数", status: "pass", detail: `${bodyLen} 字 (≥${minBody})` });
+  } else {
+    checks.push({
+      name: "正文字数",
+      status: "fail",
+      detail: `${bodyLen} 字 (不足 ${minBody})`,
+      fix: "扩充正文，增加案例或数据",
+    });
+  }
+
+  // --- Aggregate ---
+  const passCount = checks.filter((c) => c.status === "pass" || c.status === "skip").length;
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const allPassed = failCount === 0;
+
+  // Build summary
+  const statusIcon: Record<string, string> = { pass: "✅", fail: "❌", warn: "⚠️", skip: "⏭️" };
+  const lines: string[] = [`📋 发布前检查 — ${contentId} (${platform || "未知平台"})`, ""];
+  for (const c of checks) {
+    lines.push(`${statusIcon[c.status]} ${c.name}：${c.detail}`);
+    if (c.fix) lines.push(`   → ${c.fix}`);
+  }
+  lines.push("");
+  if (allPassed) {
+    lines.push("🟢 全部通过，可以发布！");
+  } else {
+    const issues = failCount + warnCount;
+    lines.push(`🔴 ${issues} 项需要关注${failCount > 0 ? `（${failCount} 项未通过）` : ""}，请先修复再发布。`);
+  }
+  const summary = lines.join("\n");
+
+  // Auto-transition to publish_ready if all passed
+  if (allPassed) {
+    await transitionStatus(
+      contentId,
+      normalizeLegacyStatus("publish_ready"),
+      {},
+      dataDir,
+    ).catch(() => { /* transition may fail if not in correct state — ok */ });
+  }
+
+  return {
+    ok: true,
+    contentId,
+    platform,
+    checks,
+    allPassed,
+    passCount,
+    failCount,
+    summary,
+  };
+}

package/src/tools/publish.ts

@@ -0,0 +1,183 @@
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { getContent } from "../storage/local-store.js";
+import { publishWechatMpDraft } from "../modules/publish/wechat-mp.js";
+import { publishToXiaohongshu } from "../modules/publish/xiaohongshu-api.js";
+import { publishToDouyin } from "../modules/publish/douyin-api.js";
+import { loadCookie } from "../modules/auth/cookie-manager.js";
+
+export const publishSchema = Type.Object({
+  action: Type.Unsafe<
+    "wechat_mp_draft" | "xiaohongshu_publish" | "douyin_publish" | "relay_publish"
+  >({
+    type: "string",
+    enum: ["wechat_mp_draft", "xiaohongshu_publish", "douyin_publish", "relay_publish"],
+    description:
+      "Publish action. Supported: 'wechat_mp_draft', 'xiaohongshu_publish', 'douyin_publish', 'relay_publish'.",
+  }),
+  article_path: Type.Optional(
+    Type.String({ description: "Absolute or relative path to the markdown article file." }),
+  ),
+  content_id: Type.Optional(
+    Type.String({ description: "AutoCrew content id. If provided, draft.md will be used." }),
+  ),
+  theme: Type.Optional(
+    Type.String({ description: "WeChat formatting theme. Default: newspaper." }),
+  ),
+  dry_run: Type.Optional(
+    Type.Boolean({ description: "Generate assets and show the publish command without pushing." }),
+  ),
+  skip_images: Type.Optional(
+    Type.Boolean({ description: "Skip image generation if images already exist." }),
+  ),
+  author: Type.Optional(
+    Type.String({ description: "Displayed author name for the WeChat publish script." }),
+  ),
+  image_size: Type.Optional(
+    Type.String({ description: "Image ratio for generated images. Default: 16:9." }),
+  ),
+  image_generator_script: Type.Optional(
+    Type.String({ description: "Override path to the image generation script." }),
+  ),
+  image_api_key: Type.Optional(
+    Type.String({ description: "Override image generation API key." }),
+  ),
+  wechat_publish_script: Type.Optional(
+    Type.String({ description: "Override path to the WeChat publish.py script." }),
+  ),
+
+  // XiaoHongShu-specific fields
+  title: Type.Optional(
+    Type.String({ description: "Title for XiaoHongShu / Douyin note." }),
+  ),
+  description: Type.Optional(
+    Type.String({ description: "Description text for XiaoHongShu / Douyin note." }),
+  ),
+  image_paths: Type.Optional(
+    Type.Array(Type.String(), { description: "Image file paths for XiaoHongShu note." }),
+  ),
+  cookie: Type.Optional(
+    Type.String({ description: "Platform cookie string. Falls back to stored cookie or env." }),
+  ),
+  is_private: Type.Optional(
+    Type.Boolean({ description: "Publish as private. Default: true (safety first)." }),
+  ),
+  post_time: Type.Optional(
+    Type.String({ description: "Scheduled post time (e.g. '2026-04-05 10:00')." }),
+  ),
+
+  // Douyin-specific fields
+  video_path: Type.Optional(
+    Type.String({ description: "Video file path for Douyin publish." }),
+  ),
+});
+
+function resolveDataDir(customDir?: string): string {
+  if (customDir) return customDir;
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".autocrew");
+}
+
+async function resolveArticlePath(params: Record<string, unknown>): Promise<string | null> {
+  const articlePath = params.article_path as string | undefined;
+  if (articlePath) {
+    return path.resolve(articlePath);
+  }
+
+  const contentId = params.content_id as string | undefined;
+  if (!contentId) {
+    return null;
+  }
+
+  const dataDir = resolveDataDir((params._dataDir as string) || undefined);
+  const content = await getContent(contentId, dataDir);
+  if (!content) {
+    return null;
+  }
+
+  return path.join(dataDir, "contents", content.id, "draft.md");
+}
+
+async function executeWechatMpDraft(params: Record<string, unknown>) {
+  const articlePath = await resolveArticlePath(params);
+  if (!articlePath) {
+    return { ok: false, error: "article_path or content_id is required" };
+  }
+
+  return publishWechatMpDraft({
+    articlePath,
+    theme: (params.theme as string) || "newspaper",
+    dryRun: Boolean(params.dry_run),
+    skipImages: Boolean(params.skip_images),
+    author: (params.author as string) || "Lawrence",
+    imageSize: (params.image_size as string) || "16:9",
+    imageGeneratorScript: (params.image_generator_script as string) || undefined,
+    imageApiKey: (params.image_api_key as string) || undefined,
+    wechatPublishScript: (params.wechat_publish_script as string) || undefined,
+  });
+}
+
+async function executeXiaohongshuPublish(params: Record<string, unknown>) {
+  const title = params.title as string | undefined;
+  const description = params.description as string | undefined;
+  const imagePaths = params.image_paths as string[] | undefined;
+
+  if (!title || !description) {
+    return { ok: false, error: "title and description are required for xiaohongshu_publish" };
+  }
+
+  if (!imagePaths || imagePaths.length === 0) {
+    return { ok: false, error: "image_paths (at least one image) is required for xiaohongshu_publish" };
+  }
+
+  let cookie = params.cookie as string | undefined;
+  if (!cookie) {
+    cookie = (await loadCookie("xiaohongshu")) ?? undefined;
+  }
+
+  return publishToXiaohongshu({
+    title,
+    description,
+    imagePaths,
+    cookie,
+    isPrivate: params.is_private !== false,
+    postTime: (params.post_time as string) || undefined,
+    dryRun: Boolean(params.dry_run),
+  });
+}
+
+async function executeDouyinPublish(params: Record<string, unknown>) {
+  return publishToDouyin({
+    title: (params.title as string) || "",
+    description: (params.description as string) || "",
+    videoPath: (params.video_path as string) || undefined,
+    imagePaths: (params.image_paths as string[]) || undefined,
+    isPrivate: params.is_private !== false,
+    postTime: (params.post_time as string) || undefined,
+  });
+}
+
+export async function executePublish(params: Record<string, unknown>) {
+  const action = params.action as string;
+
+  switch (action) {
+    case "wechat_mp_draft":
+      return executeWechatMpDraft(params);
+
+    case "xiaohongshu_publish":
+      return executeXiaohongshuPublish(params);
+
+    case "douyin_publish":
+      return executeDouyinPublish(params);
+
+    case "relay_publish":
+      return {
+        ok: false,
+        error:
+          "relay_publish is experimental. Chrome Relay via OpenClaw Gateway is for research only, not publishing. Use platform-specific API publishers instead.",
+      };
+
+    default:
+      return { ok: false, error: `Unknown action: ${action}` };
+  }
+}

package/src/tools/registry.ts

@@ -0,0 +1,198 @@
+/**
+ * Tool Registry — single source of truth for all AutoCrew tool definitions.
+ *
+ * Used by both the OpenClaw plugin (index.ts) and the standalone server (start.ts).
+ */
+import { topicCreateSchema, executeTopicCreate } from "./topic-create.js";
+import { researchSchema, executeResearch } from "./research.js";
+import { contentSaveSchema, executeContentSave } from "./content-save.js";
+import { statusSchema, executeStatus } from "./status.js";
+import { assetSchema, executeAsset } from "./asset.js";
+import { pipelineSchema, createPipelineExecutor } from "./pipeline.js";
+import { publishSchema, executePublish } from "./publish.js";
+import { humanizeSchema, executeHumanize } from "./humanize.js";
+import { rewriteSchema, executeRewrite } from "./rewrite.js";
+import { coverReviewSchema, executeCoverReview } from "./cover-review.js";
+import { memorySchema, executeMemory } from "./memory.js";
+import { reviewSchema, executeReview } from "./review.js";
+import { prePublishSchema, executePrePublish } from "./pre-publish.js";
+import { intelSchema, executeIntel } from "./intel.js";
+import { pipelineOpsSchema, executePipelineOps } from "./pipeline-ops.js";
+import { timelineSchema, executeTimeline } from "./timeline.js";
+import { executeInit } from "./init.js";
+import { getProStatus } from "../modules/pro/gate.js";
+import { loadProfile, detectMissingInfo } from "../modules/profile/creator-profile.js";
+import type { ToolRunner } from "../runtime/tool-runner.js";
+
+export function registerAllTools(runner: ToolRunner): void {
+  runner.register({
+    name: "autocrew_topic",
+    label: "AutoCrew Topic",
+    description: "Create or list content topics. Actions: create, list.",
+    parameters: topicCreateSchema,
+    execute: executeTopicCreate,
+  });
+
+  runner.register({
+    name: "autocrew_research",
+    label: "AutoCrew Research",
+    description:
+      "Topic discovery with multiple modes: browser-first (Pro), API fallback, free (web search + viral scoring), or manual. " +
+      "Supports action='discover' to generate/save topics and action='session_status' to inspect browser login readiness.",
+    parameters: researchSchema,
+    execute: executeResearch,
+  });
+
+  runner.register({
+    name: "autocrew_content",
+    label: "AutoCrew Content",
+    description:
+      "Manage content lifecycle: save drafts, list/get/update content, transition status, manage siblings and variants. " +
+      "Actions: save, list, get, update, transition, list_siblings, create_variant.",
+    parameters: contentSaveSchema,
+    execute: executeContentSave,
+  });
+
+  runner.register({
+    name: "autocrew_status",
+    label: "AutoCrew Status",
+    description: "Show pipeline status: topic count, content count, status breakdown.",
+    parameters: statusSchema,
+    execute: executeStatus,
+  });
+
+  runner.register({
+    name: "autocrew_asset",
+    label: "AutoCrew Asset",
+    description:
+      "Manage content project assets (covers, B-Roll, images, videos, subtitles) and version history. Actions: add, list, remove, versions, get_version, revert.",
+    parameters: assetSchema,
+    execute: executeAsset,
+  });
+
+  runner.register({
+    name: "autocrew_pipeline",
+    label: "AutoCrew Pipeline",
+    description:
+      "Workflow orchestration for content pipelines. Actions: create (from template), start, status, approve (paused step), cancel, list, templates.",
+    parameters: pipelineSchema,
+    execute: createPipelineExecutor(runner),
+  });
+
+  runner.register({
+    name: "autocrew_publish",
+    label: "AutoCrew Publish",
+    description:
+      "Run proven publishing flows. Actions: xiaohongshu_publish (API mode), douyin_publish, wechat_mp_draft, relay_publish (experimental).",
+    parameters: publishSchema,
+    execute: executePublish,
+  });
+
+  runner.register({
+    name: "autocrew_humanize",
+    label: "AutoCrew Humanize",
+    description: "Run the Chinese de-AI pass on content text. Removes AI-sounding patterns and corporate buzzwords.",
+    parameters: humanizeSchema,
+    execute: executeHumanize,
+  });
+
+  runner.register({
+    name: "autocrew_rewrite",
+    label: "AutoCrew Rewrite",
+    description:
+      "Create platform-native rewrites. Actions: adapt_platform (single platform), batch_adapt (multi-platform + auto title/hashtag + sibling linking).",
+    parameters: rewriteSchema,
+    execute: executeRewrite,
+  });
+
+  runner.register({
+    name: "autocrew_cover_review",
+    label: "AutoCrew Cover Review",
+    description:
+      "Generate, review, and approve cover images via Gemini. Actions: create_candidates (generate 3 style variants), get (view review), approve (pick one), generate_ratios (Pro: 16:9 + 4:3).",
+    parameters: coverReviewSchema,
+    execute: executeCoverReview,
+    needsGemini: true,
+  });
+
+  runner.register({
+    name: "autocrew_memory",
+    label: "AutoCrew Memory",
+    description:
+      "Capture user feedback into MEMORY.md or read current memory. Supports action='capture_feedback' and action='get_memory'.",
+    parameters: memorySchema,
+    execute: executeMemory,
+  });
+
+  runner.register({
+    name: "autocrew_review",
+    label: "AutoCrew Review",
+    description:
+      "Content review: sensitive words scan + quality score + de-AI check. Actions: full_review, scan_only, quality_score, auto_fix.",
+    parameters: reviewSchema,
+    execute: executeReview,
+  });
+
+  runner.register({
+    name: "autocrew_pre_publish",
+    label: "AutoCrew Pre-Publish",
+    description: "Pre-publish gate: 6 checks before allowing publish. Actions: check.",
+    parameters: prePublishSchema,
+    execute: executePrePublish,
+  });
+
+  runner.register({
+    name: "autocrew_intel",
+    label: "AutoCrew 灵感源",
+    description:
+      "Inspiration source pipeline. Actions: pull (collect from web/RSS/trends), list (show saved inspiration), clean (archive expired).",
+    parameters: intelSchema,
+    execute: executeIntel,
+  });
+
+  runner.register({
+    name: "autocrew_pipeline_ops",
+    label: "AutoCrew Pipeline Ops",
+    description:
+      "Content pipeline lifecycle management. Actions: status (stage counts), start (topic→project), advance (next stage), version (add draft), trash, restore.",
+    parameters: pipelineOpsSchema,
+    execute: executePipelineOps,
+  });
+
+  runner.register({
+    name: "autocrew_timeline",
+    label: "AutoCrew Timeline",
+    description:
+      "Generate and manage video timelines. Actions: generate (parse marked script into timeline.json), get (retrieve timeline), update_segment (update segment status/asset), confirm_all (confirm all ready segments).",
+    parameters: timelineSchema,
+    execute: executeTimeline,
+  });
+
+  runner.register({
+    name: "autocrew_init",
+    label: "AutoCrew Init",
+    description: "Initialize the AutoCrew data directory (~/.autocrew/) and creator profile. Safe to run multiple times.",
+    parameters: { type: "object" as const, properties: {} },
+    execute: async (params) => executeInit({ dataDir: params._dataDir as string }),
+  });
+
+  runner.register({
+    name: "autocrew_pro_status",
+    label: "AutoCrew Pro Status",
+    description: "Check AutoCrew Pro status: whether Pro is active, profile completeness, and missing info.",
+    parameters: { type: "object" as const, properties: {} },
+    execute: async (params) => {
+      const dir = params._dataDir as string;
+      const proStatus = await getProStatus(dir);
+      const profile = await loadProfile(dir);
+      const missing = profile ? detectMissingInfo(profile) : ["profile_not_initialized"];
+      return {
+        ok: true,
+        isPro: proStatus.isPro,
+        profileExists: profile !== null,
+        missingInfo: missing,
+        styleCalibrated: profile?.styleCalibrated ?? false,
+      };
+    },
+  });
+}