autocrew 0.1.0

package/src/tools/rewrite.ts

@@ -0,0 +1,165 @@
+import { Type } from "@sinclair/typebox";
+import { getContent, saveContent, updateContent } from "../storage/local-store.js";
+import { adaptPlatformDraft, type SupportedPlatform } from "../modules/writing/platform-rewrite.js";
+import { generateForPlatform } from "../modules/writing/title-hashtag.js";
+
+export const rewriteSchema = Type.Object({
+  action: Type.Unsafe<"adapt_platform" | "batch_adapt">({
+    type: "string",
+    enum: ["adapt_platform", "batch_adapt"],
+    description:
+      "Action. 'adapt_platform' adapts to one platform, 'batch_adapt' adapts to multiple platforms at once.",
+  }),
+  content_id: Type.Optional(Type.String({ description: "Existing AutoCrew content id to adapt." })),
+  title: Type.Optional(Type.String({ description: "Source title when adapting raw text directly." })),
+  body: Type.Optional(Type.String({ description: "Source body when adapting raw text directly." })),
+  tags: Type.Optional(Type.Array(Type.String({ description: "Optional tags" }))),
+  target_platform: Type.Optional(
+    Type.Unsafe<"xiaohongshu" | "douyin" | "wechat_mp" | "wechat_video" | "bilibili">({
+      type: "string",
+      enum: ["xiaohongshu", "douyin", "wechat_mp", "wechat_video", "bilibili"],
+      description: "Target platform for adapt_platform action.",
+    }),
+  ),
+  target_platforms: Type.Optional(
+    Type.Array(
+      Type.Unsafe<"xiaohongshu" | "douyin" | "wechat_mp" | "wechat_video" | "bilibili">({
+        type: "string",
+        enum: ["xiaohongshu", "douyin", "wechat_mp", "wechat_video", "bilibili"],
+      }),
+      { description: "Target platforms for batch_adapt action." },
+    ),
+  ),
+  save_as_draft: Type.Optional(Type.Boolean({ description: "Save the adapted result as a new AutoCrew draft." })),
+});
+
+/**
+ * Resolve source content from params (content_id or raw title+body).
+ */
+async function resolveSource(params: Record<string, unknown>) {
+  const dataDir = (params._dataDir as string) || undefined;
+  let title = (params.title as string) || "";
+  let body = (params.body as string) || "";
+  let tags = (params.tags as string[]) || [];
+  const contentId = params.content_id as string | undefined;
+  let topicId: string | undefined;
+
+  if (contentId) {
+    const content = await getContent(contentId, dataDir);
+    if (!content) return { ok: false as const, error: `Content ${contentId} not found` };
+    title = content.title;
+    body = content.body;
+    tags = content.tags || tags;
+    topicId = content.topicId;
+  }
+
+  if (!title || !body) return { ok: false as const, error: "content_id or title + body is required" };
+
+  return { ok: true as const, title, body, tags, contentId, topicId, dataDir };
+}
+
+/**
+ * Adapt a single platform: rewrite + generate title/hashtag + optionally save.
+ */
+async function adaptOne(
+  title: string,
+  body: string,
+  tags: string[],
+  platform: SupportedPlatform,
+  opts: { saveAsDraft?: boolean; topicId?: string; siblingIds?: string[]; dataDir?: string },
+) {
+  const adapted = adaptPlatformDraft({ title, body, tags, targetPlatform: platform });
+
+  // Generate title variants + hashtags
+  const titleResult = generateForPlatform(adapted.title, platform, { tags });
+  const hashtags = titleResult.hashtags.map((h) => h.tag);
+
+  const result: Record<string, unknown> = {
+    ...adapted,
+    titleVariants: titleResult.titles,
+    hashtags,
+  };
+
+  if (opts.saveAsDraft) {
+    const saved = await saveContent(
+      {
+        title: adapted.title,
+        body: adapted.body,
+        platform: adapted.platform,
+        status: "draft",
+        tags,
+        hashtags,
+        topicId: opts.topicId,
+        siblings: opts.siblingIds || [],
+      } as any,
+      opts.dataDir,
+    );
+    result.content = saved;
+  }
+
+  return result;
+}
+
+export async function executeRewrite(params: Record<string, unknown>) {
+  const action = params.action as string;
+
+  // --- adapt_platform (single) ---
+  if (action === "adapt_platform") {
+    const src = await resolveSource(params);
+    if (!src.ok) return src;
+
+    const platform = params.target_platform as SupportedPlatform;
+    if (!platform) return { ok: false, error: "target_platform is required for adapt_platform" };
+
+    return adaptOne(src.title, src.body, src.tags, platform, {
+      saveAsDraft: Boolean(params.save_as_draft),
+      topicId: src.topicId,
+      dataDir: src.dataDir,
+    });
+  }
+
+  // --- batch_adapt (multiple platforms) ---
+  if (action === "batch_adapt") {
+    const src = await resolveSource(params);
+    if (!src.ok) return src;
+
+    const platforms = params.target_platforms as SupportedPlatform[] | undefined;
+    if (!platforms || platforms.length === 0) {
+      return { ok: false, error: "target_platforms is required for batch_adapt" };
+    }
+
+    const results: Record<string, unknown>[] = [];
+    const savedIds: string[] = [];
+
+    for (const platform of platforms) {
+      const result = await adaptOne(src.title, src.body, src.tags, platform, {
+        saveAsDraft: Boolean(params.save_as_draft),
+        topicId: src.topicId,
+        dataDir: src.dataDir,
+      });
+      results.push(result);
+      const savedContent = result.content as { id: string } | undefined;
+      if (savedContent?.id) savedIds.push(savedContent.id);
+    }
+
+    // Build sibling relationships among all saved drafts (+ source if it exists)
+    if (params.save_as_draft && savedIds.length > 1) {
+      const allIds = src.contentId ? [src.contentId, ...savedIds] : savedIds;
+      for (const id of allIds) {
+        const siblingIds = allIds.filter((s) => s !== id);
+        await updateContent(id, { siblings: siblingIds }, src.dataDir);
+      }
+    }
+
+    return {
+      ok: true,
+      action: "batch_adapt",
+      sourceContentId: src.contentId || null,
+      platforms: platforms,
+      results,
+      siblingIds: savedIds,
+    };
+  }
+
+  return { ok: false, error: `Unknown action: ${action}` };
+}

package/src/tools/status.ts

@@ -0,0 +1,30 @@
+import { Type } from "@sinclair/typebox";
+import { listTopics, listContents } from "../storage/local-store.js";
+
+export const statusSchema = Type.Object({
+  verbose: Type.Optional(Type.Boolean({ description: "Show detailed counts" })),
+});
+
+export async function executeStatus(params: Record<string, unknown>) {
+  const dataDir = (params._dataDir as string) || undefined;
+
+  const topics = await listTopics(dataDir);
+  const contents = await listContents(dataDir);
+
+  const byStatus = {
+    draft: contents.filter((c) => c.status === "draft").length,
+    review: contents.filter((c) => c.status === "review").length,
+    approved: contents.filter((c) => c.status === "approved").length,
+    published: contents.filter((c) => c.status === "published").length,
+  };
+
+  return {
+    ok: true,
+    version: "0.1.0",
+    topics: topics.length,
+    contents: contents.length,
+    contentsByStatus: byStatus,
+    latestTopic: topics[0]?.title || null,
+    latestContent: contents[0]?.title || null,
+  };
+}

package/src/tools/timeline.ts

@@ -0,0 +1,234 @@
+import { Type } from "@sinclair/typebox";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { parseMarkedScript } from "../modules/timeline/parser.js";
+import type {
+  VideoPreset,
+  AspectRatio,
+  SegmentStatus,
+  Timeline,
+} from "../types/timeline.js";
+
+export const timelineSchema = Type.Object({
+  action: Type.Unsafe<"generate" | "get" | "update_segment" | "confirm_all">({
+    type: "string",
+    enum: ["generate", "get", "update_segment", "confirm_all"],
+    description:
+      "generate: parse marked script into timeline.json. get: retrieve timeline. update_segment: update segment status/asset. confirm_all: confirm all ready segments.",
+  }),
+  content_id: Type.String({ description: "Content project ID" }),
+  preset: Type.Optional(
+    Type.Unsafe<VideoPreset>({
+      type: "string",
+      enum: ["knowledge-explainer", "tutorial"],
+    }),
+  ),
+  aspect_ratio: Type.Optional(
+    Type.Unsafe<AspectRatio>({
+      type: "string",
+      enum: ["9:16", "16:9", "3:4", "1:1", "4:3"],
+    }),
+  ),
+  segment_id: Type.Optional(
+    Type.String({ description: "Segment ID for update_segment" }),
+  ),
+  status: Type.Optional(
+    Type.Unsafe<SegmentStatus>({
+      type: "string",
+      enum: ["pending", "generating", "ready", "confirmed", "failed"],
+    }),
+  ),
+  asset_path: Type.Optional(
+    Type.String({ description: "Path to generated asset file" }),
+  ),
+  _dataDir: Type.Optional(Type.String()),
+});
+
+function contentDir(dataDir: string, contentId: string): string {
+  return join(dataDir, "contents", contentId);
+}
+
+function timelinePath(dataDir: string, contentId: string): string {
+  return join(contentDir(dataDir, contentId), "timeline.json");
+}
+
+async function loadTimeline(
+  dataDir: string,
+  contentId: string,
+): Promise<Timeline | null> {
+  try {
+    const raw = await readFile(timelinePath(dataDir, contentId), "utf-8");
+    return JSON.parse(raw) as Timeline;
+  } catch {
+    return null;
+  }
+}
+
+async function saveTimeline(
+  dataDir: string,
+  contentId: string,
+  timeline: Timeline,
+): Promise<void> {
+  const dir = contentDir(dataDir, contentId);
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    timelinePath(dataDir, contentId),
+    JSON.stringify(timeline, null, 2),
+    "utf-8",
+  );
+}
+
+export async function executeTimeline(
+  params: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  const action = params.action as string;
+  const contentId = params.content_id as string;
+  const dataDir = (params._dataDir as string) || "";
+
+  if (!contentId) {
+    return { ok: false, error: "content_id is required" };
+  }
+
+  if (action === "generate") {
+    const preset = (params.preset as VideoPreset) || "knowledge-explainer";
+    const aspectRatio = (params.aspect_ratio as AspectRatio) || "9:16";
+
+    let script: string;
+    try {
+      script = await readFile(
+        join(contentDir(dataDir, contentId), "draft.md"),
+        "utf-8",
+      );
+    } catch {
+      return {
+        ok: false,
+        error: `draft.md not found for content ${contentId}`,
+      };
+    }
+
+    const timeline = parseMarkedScript(script, {
+      contentId,
+      preset,
+      aspectRatio,
+    });
+
+    await saveTimeline(dataDir, contentId, timeline);
+
+    return {
+      ok: true,
+      content_id: contentId,
+      tts_count: timeline.tracks.tts.length,
+      visual_count: timeline.tracks.visual.length,
+      timeline,
+    };
+  }
+
+  if (action === "get") {
+    const timeline = await loadTimeline(dataDir, contentId);
+    if (!timeline) {
+      return {
+        ok: false,
+        error: `timeline.json not found for content ${contentId}`,
+      };
+    }
+    return { ok: true, content_id: contentId, timeline };
+  }
+
+  if (action === "update_segment") {
+    const segmentId = params.segment_id as string;
+    if (!segmentId) {
+      return { ok: false, error: "segment_id is required for update_segment" };
+    }
+
+    const timeline = await loadTimeline(dataDir, contentId);
+    if (!timeline) {
+      return {
+        ok: false,
+        error: `timeline.json not found for content ${contentId}`,
+      };
+    }
+
+    const newStatus = params.status as SegmentStatus | undefined;
+    const assetPath = params.asset_path as string | undefined;
+
+    // Search across all track arrays
+    let found = false;
+
+    const newText = params.text as string | undefined;
+
+    for (const seg of timeline.tracks.tts) {
+      if (seg.id === segmentId) {
+        if (newStatus) seg.status = newStatus;
+        if (assetPath !== undefined) seg.asset = assetPath;
+        if (newText !== undefined) seg.text = newText;
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      for (const seg of timeline.tracks.visual) {
+        if (seg.id === segmentId) {
+          if (newStatus) seg.status = newStatus;
+          if (assetPath !== undefined) seg.asset = assetPath;
+          found = true;
+          break;
+        }
+      }
+    }
+
+    if (!found) {
+      return { ok: false, error: `Segment ${segmentId} not found` };
+    }
+
+    await saveTimeline(dataDir, contentId, timeline);
+
+    // Sync text edits back to draft.md so regenerating timeline won't lose changes
+    if (newText !== undefined) {
+      const draftText = timeline.tracks.tts.map((s) => s.text).join("\n\n");
+      await writeFile(
+        join(contentDir(dataDir, contentId), "draft.md"),
+        draftText,
+        "utf-8",
+      );
+    }
+
+    return { ok: true, content_id: contentId, segment_id: segmentId };
+  }
+
+  if (action === "confirm_all") {
+    const timeline = await loadTimeline(dataDir, contentId);
+    if (!timeline) {
+      return {
+        ok: false,
+        error: `timeline.json not found for content ${contentId}`,
+      };
+    }
+
+    let confirmed = 0;
+
+    for (const seg of timeline.tracks.tts) {
+      if (seg.status === "ready") {
+        seg.status = "confirmed";
+        confirmed++;
+      }
+    }
+
+    for (const seg of timeline.tracks.visual) {
+      if (seg.status === "ready") {
+        seg.status = "confirmed";
+        confirmed++;
+      }
+    }
+
+    if (timeline.tracks.subtitle.status === "ready") {
+      timeline.tracks.subtitle.status = "confirmed";
+      confirmed++;
+    }
+
+    await saveTimeline(dataDir, contentId, timeline);
+    return { ok: true, content_id: contentId, confirmed_count: confirmed };
+  }
+
+  return { ok: false, error: `Unknown action: ${action}` };
+}

package/src/tools/topic-create.ts

@@ -0,0 +1,50 @@
+import { Type } from "@sinclair/typebox";
+import { saveTopic, listTopics } from "../storage/local-store.js";
+
+/**
+ * Core tool logic — platform-agnostic.
+ * Wrapped by index.ts (OpenClaw) and mcp/server.ts (Claude Code).
+ */
+
+export const topicCreateSchema = Type.Object({
+  action: Type.Unsafe<"create" | "list">({
+    type: "string",
+    enum: ["create", "list"],
+    description: "Action: 'create' to save a new topic, 'list' to show all topics.",
+  }),
+  title: Type.Optional(Type.String({ description: "Topic title (required for create)" })),
+  description: Type.Optional(Type.String({ description: "Topic description (required for create)" })),
+  tags: Type.Optional(Type.Array(Type.String(), { description: "Topic tags (required for create)" })),
+  source: Type.Optional(Type.String({ description: "Where this topic idea came from" })),
+});
+
+export async function executeTopicCreate(params: Record<string, unknown>) {
+  const action = (params.action as string) || "create";
+  const dataDir = (params._dataDir as string) || undefined;
+
+  if (action === "list") {
+    const topics = await listTopics(dataDir);
+    if (topics.length === 0) {
+      return { ok: true, message: "No topics yet.", topics: [] };
+    }
+    return { ok: true, topics };
+  }
+
+  // create
+  const title = params.title as string;
+  const description = params.description as string;
+  const tags = (params.tags as string[]) || [];
+
+  if (!title || !description) {
+    return { ok: false, error: "title and description are required for create" };
+  }
+
+  const topic = await saveTopic({
+    title,
+    description,
+    tags,
+    source: (params.source as string) || undefined,
+  }, dataDir);
+
+  return { ok: true, topic };
+}

package/src/types/providers.ts

@@ -0,0 +1,69 @@
+import type { AspectRatio, Timeline } from "./timeline.js";
+
+export interface Voice {
+  id: string;
+  name: string;
+  language: string;
+}
+
+export interface VoiceConfig {
+  voiceId: string;
+  speed?: number;
+  pitch?: number;
+}
+
+export interface AudioAsset {
+  path: string;
+  duration: number;
+  format: "mp3" | "wav" | "ogg";
+}
+
+export interface VideoConfig {
+  aspectRatio: AspectRatio;
+  duration: number;
+  style?: string;
+}
+
+export interface VideoAsset {
+  path: string;
+  duration: number;
+  format: "mp4" | "webm" | "mov";
+}
+
+export interface VideoFile {
+  path: string;
+  duration: number;
+  format: string;
+}
+
+export interface ProjectFile {
+  path: string;
+  format: ExportFormat;
+}
+
+export type ExportFormat = "jianying" | "davinci" | "fcpx";
+export type AssetMap = Record<string, string>;
+
+export interface TTSProvider {
+  name: string;
+  generate(text: string, voice: VoiceConfig): Promise<AudioAsset>;
+  estimateDuration(text: string): number;
+  listVoices(): Promise<Voice[]>;
+}
+
+export interface VideoProvider {
+  name: string;
+  generate(prompt: string, config: VideoConfig): Promise<VideoAsset>;
+  supportedRatios(): AspectRatio[];
+}
+
+export interface CompositorProvider {
+  name: string;
+  compose(timeline: Timeline, assets: AssetMap): Promise<VideoFile>;
+  export(
+    timeline: Timeline,
+    assets: AssetMap,
+    format: ExportFormat,
+  ): Promise<ProjectFile>;
+  supportedFormats(): ExportFormat[];
+}

package/src/types/timeline.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect } from "vitest";
+import type {
+  Timeline,
+  TTSSegment,
+  VisualSegment,
+  SubtitleTrack,
+  SubtitleConfig,
+  SegmentStatus,
+  VideoPreset,
+  AspectRatio,
+  SubtitleTemplate,
+  SubtitlePosition,
+  VisualType,
+  CardTemplate,
+} from "./timeline.js";
+
+describe("Timeline types", () => {
+  it("creates a valid Timeline with all fields", () => {
+    const tts: TTSSegment = {
+      id: "tts-001",
+      text: "Welcome to the tutorial",
+      estimatedDuration: 3.5,
+      start: 0,
+      asset: null,
+      status: "pending",
+    };
+
+    const visual: VisualSegment = {
+      id: "vis-001",
+      layer: 1,
+      type: "broll",
+      prompt: "city skyline at sunset",
+      linkedTts: ["tts-001"],
+      asset: null,
+      status: "pending",
+    };
+
+    const subtitle: SubtitleTrack = {
+      asset: null,
+      status: "pending",
+    };
+
+    const timeline: Timeline = {
+      version: "2.0",
+      contentId: "content-abc",
+      preset: "knowledge-explainer",
+      aspectRatio: "9:16",
+      subtitle: {
+        template: "modern-outline",
+        position: "bottom",
+      },
+      tracks: {
+        tts: [tts],
+        visual: [visual],
+        subtitle,
+      },
+    };
+
+    expect(timeline.version).toBe("2.0");
+    expect(timeline.contentId).toBe("content-abc");
+    expect(timeline.preset).toBe("knowledge-explainer");
+    expect(timeline.aspectRatio).toBe("9:16");
+    expect(timeline.subtitle.template).toBe("modern-outline");
+    expect(timeline.subtitle.position).toBe("bottom");
+    expect(timeline.tracks.tts).toHaveLength(1);
+    expect(timeline.tracks.visual).toHaveLength(1);
+    expect(timeline.tracks.subtitle.status).toBe("pending");
+  });
+
+  it("creates a card visual with template, data, and opacity", () => {
+    const card: VisualSegment = {
+      id: "vis-card-001",
+      layer: 2,
+      type: "card",
+      template: "comparison-table",
+      data: {
+        headers: ["Feature", "Plan A", "Plan B"],
+        rows: [["Price", "$10", "$20"]],
+      },
+      linkedTts: ["tts-001", "tts-002"],
+      opacity: 0.85,
+      asset: "cards/comparison.png",
+      status: "ready",
+    };
+
+    expect(card.type).toBe("card");
+    expect(card.template).toBe("comparison-table");
+    expect(card.data).toBeDefined();
+    expect(card.opacity).toBe(0.85);
+    expect(card.asset).toBe("cards/comparison.png");
+    expect(card.linkedTts).toEqual(["tts-001", "tts-002"]);
+  });
+
+  it("covers all valid SegmentStatus values", () => {
+    const statuses: SegmentStatus[] = [
+      "pending",
+      "generating",
+      "ready",
+      "confirmed",
+      "failed",
+    ];
+
+    expect(statuses).toHaveLength(5);
+
+    for (const status of statuses) {
+      const segment: TTSSegment = {
+        id: "tts-test",
+        text: "test",
+        estimatedDuration: 1,
+        start: 0,
+        asset: null,
+        status,
+      };
+      expect(segment.status).toBe(status);
+    }
+  });
+
+  it("covers all VideoPreset values", () => {
+    const presets: VideoPreset[] = ["knowledge-explainer", "tutorial"];
+    expect(presets).toHaveLength(2);
+  });
+
+  it("covers all AspectRatio values", () => {
+    const ratios: AspectRatio[] = ["9:16", "16:9", "3:4", "1:1", "4:3"];
+    expect(ratios).toHaveLength(5);
+  });
+
+  it("covers all SubtitleTemplate values", () => {
+    const templates: SubtitleTemplate[] = [
+      "modern-outline",
+      "karaoke-highlight",
+      "minimal-fade",
+      "bold-top",
+    ];
+    expect(templates).toHaveLength(4);
+  });
+
+  it("covers all CardTemplate values", () => {
+    const templates: CardTemplate[] = [
+      "comparison-table",
+      "key-points",
+      "flow-chart",
+      "data-chart",
+    ];
+    expect(templates).toHaveLength(4);
+  });
+});