autocrew 0.1.0

package/src/modules/migrate/legacy-migrate.ts

@@ -0,0 +1,229 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import yaml from "js-yaml";
+import {
+  initPipeline,
+  saveTopic,
+  stagePath,
+  slugify,
+  type TopicCandidate,
+  type ProjectMeta,
+  type PipelineStage,
+} from "../../storage/pipeline-store.js";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface MigrationResult {
+  topicsMigrated: number;
+  contentsMigrated: number;
+  errors: string[];
+}
+
+// ─── Status → Stage Mapping ─────────────────────────────────────────────────
+
+const STATUS_TO_STAGE: Record<string, PipelineStage> = {
+  topic_saved: "topics",
+  drafting: "drafting",
+  draft_ready: "drafting",
+  reviewing: "drafting",
+  revision: "drafting",
+  approved: "production",
+  cover_pending: "production",
+  publish_ready: "production",
+  publishing: "production",
+  published: "published",
+  archived: "trash",
+};
+
+// ─── Migration ──────────────────────────────────────────────────────────────
+
+async function dirExists(p: string): Promise<boolean> {
+  try {
+    const stat = await fs.stat(p);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function fileExists(p: string): Promise<boolean> {
+  try {
+    const stat = await fs.stat(p);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+async function migrateTopics(
+  dataDir: string,
+  errors: string[],
+): Promise<number> {
+  const topicsDir = path.join(dataDir, "topics");
+  let migrated = 0;
+
+  let files: string[];
+  try {
+    files = await fs.readdir(topicsDir);
+  } catch {
+    return 0; // no legacy topics dir
+  }
+
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const raw = await fs.readFile(path.join(topicsDir, file), "utf-8");
+      const json = JSON.parse(raw);
+
+      const topic: TopicCandidate = {
+        title: json.title ?? "Untitled",
+        domain: json.domain ?? "general",
+        score: {
+          heat: json.score?.heat ?? json.heat ?? 50,
+          differentiation: json.score?.differentiation ?? json.differentiation ?? 50,
+          audienceFit: json.score?.audienceFit ?? json.audience_fit ?? 50,
+          overall: json.score?.overall ?? json.overall ?? 50,
+        },
+        formats: json.formats ?? [],
+        suggestedPlatforms: json.suggested_platforms ?? json.platforms ?? [],
+        createdAt: json.created_at ?? json.createdAt ?? new Date().toISOString(),
+        intelRefs: json.intel_refs ?? json.intelRefs ?? [],
+        angles: json.angles ?? [],
+        audienceResonance: json.audience_resonance ?? json.audienceResonance ?? "",
+        references: json.references ?? [],
+      };
+
+      // Idempotent check: does the target file already exist?
+      const targetFile = `${slugify(topic.domain)}-${slugify(topic.title)}.md`;
+      const targetPath = path.join(stagePath("topics", dataDir), targetFile);
+      if (await fileExists(targetPath)) continue;
+
+      await saveTopic(topic, dataDir);
+      migrated++;
+    } catch (err) {
+      errors.push(`topic ${file}: ${(err as Error).message}`);
+    }
+  }
+
+  return migrated;
+}
+
+async function migrateContents(
+  dataDir: string,
+  errors: string[],
+): Promise<number> {
+  const contentsDir = path.join(dataDir, "contents");
+  let migrated = 0;
+
+  let entries: string[];
+  try {
+    entries = await fs.readdir(contentsDir);
+  } catch {
+    return 0; // no legacy contents dir
+  }
+
+  for (const entry of entries) {
+    if (!entry.startsWith("content-")) continue;
+    const srcDir = path.join(contentsDir, entry);
+    if (!(await dirExists(srcDir))) continue;
+
+    try {
+      // Read legacy meta.json
+      const metaPath = path.join(srcDir, "meta.json");
+      if (!(await fileExists(metaPath))) {
+        errors.push(`content ${entry}: missing meta.json`);
+        continue;
+      }
+
+      const metaRaw = await fs.readFile(metaPath, "utf-8");
+      const legacyMeta = JSON.parse(metaRaw);
+
+      const status: string = legacyMeta.status ?? "drafting";
+      const stage = STATUS_TO_STAGE[status] ?? "drafting";
+
+      // For "topics" stage content, skip — topics are handled separately
+      if (stage === "topics") continue;
+
+      const projectName = slugify(legacyMeta.title ?? entry);
+      const targetDir = path.join(stagePath(stage, dataDir), projectName);
+
+      // Idempotent: skip if target already exists
+      if (await dirExists(targetDir)) continue;
+
+      // Create target directory
+      await fs.mkdir(targetDir, { recursive: true });
+      await fs.mkdir(path.join(targetDir, "references"), { recursive: true });
+
+      // Copy files from source (except meta.json, which we convert)
+      const srcFiles = await fs.readdir(srcDir);
+      for (const f of srcFiles) {
+        if (f === "meta.json") continue;
+        const srcFile = path.join(srcDir, f);
+        const stat = await fs.stat(srcFile);
+        if (stat.isFile()) {
+          await fs.copyFile(srcFile, path.join(targetDir, f));
+        }
+      }
+
+      // Convert meta.json → meta.yaml
+      const now = new Date().toISOString();
+      const draftFile = srcFiles.includes("draft.md") ? "draft-v1.md" : undefined;
+
+      // If draft.md exists, create draft-v1.md from it
+      if (draftFile && srcFiles.includes("draft.md")) {
+        const draftContent = await fs.readFile(
+          path.join(targetDir, "draft.md"),
+          "utf-8",
+        );
+        await fs.writeFile(
+          path.join(targetDir, "draft-v1.md"),
+          draftContent,
+          "utf-8",
+        );
+      }
+
+      const projectMeta: ProjectMeta = {
+        title: legacyMeta.title ?? entry,
+        domain: legacyMeta.domain ?? "general",
+        format: legacyMeta.format ?? "article",
+        createdAt: legacyMeta.created_at ?? legacyMeta.createdAt ?? now,
+        sourceTopic: legacyMeta.source_topic ?? "",
+        intelRefs: legacyMeta.intel_refs ?? [],
+        versions: draftFile
+          ? [{ file: "draft-v1.md", createdAt: legacyMeta.created_at ?? now, note: "migrated from legacy" }]
+          : [],
+        current: draftFile ?? "",
+        history: [{ stage, entered: now }],
+        platforms: legacyMeta.platforms?.map((p: string) => ({
+          format: p,
+          status: "pending",
+        })) ?? [],
+      };
+
+      await fs.writeFile(
+        path.join(targetDir, "meta.yaml"),
+        yaml.dump(projectMeta, { lineWidth: -1 }),
+        "utf-8",
+      );
+
+      migrated++;
+    } catch (err) {
+      errors.push(`content ${entry}: ${(err as Error).message}`);
+    }
+  }
+
+  return migrated;
+}
+
+export async function migrateLegacyData(
+  dataDir: string,
+): Promise<MigrationResult> {
+  const errors: string[] = [];
+
+  await initPipeline(dataDir);
+
+  const topicsMigrated = await migrateTopics(dataDir, errors);
+  const contentsMigrated = await migrateContents(dataDir, errors);
+
+  return { topicsMigrated, contentsMigrated, errors };
+}

package/src/modules/pro/api-client.ts

@@ -0,0 +1,192 @@
+/**
+ * Pro API Client — Communicates with the AutoCrew Pro cloud backend.
+ *
+ * All Pro features (ASR, crawling, competitor analysis, analytics, TTS, digital human)
+ * go through this client. The backend is a slimmed-down version of 墨灵 AI.
+ */
+import { readProKey } from "./gate.js";
+
+const DEFAULT_BASE_URL = "https://api.autocrew.dev";
+
+export interface ProApiOptions {
+  dataDir?: string;
+  baseUrl?: string;
+}
+
+export interface ProApiResponse<T = unknown> {
+  ok: boolean;
+  data?: T;
+  error?: string;
+  usage?: { used: number; remaining: number; unit: string };
+}
+
+function getBaseUrl(options?: ProApiOptions): string {
+  return options?.baseUrl || process.env.AUTOCREW_PRO_API_URL || DEFAULT_BASE_URL;
+}
+
+async function getHeaders(dataDir?: string): Promise<Record<string, string>> {
+  const key = await readProKey(dataDir);
+  if (!key) throw new Error("Pro API key not found. Run autocrew upgrade first.");
+  return {
+    Authorization: `Bearer ${key}`,
+    "Content-Type": "application/json",
+    "User-Agent": "autocrew/0.1.0",
+  };
+}
+
+async function request<T>(
+  method: string,
+  endpoint: string,
+  body: unknown | null,
+  options?: ProApiOptions,
+): Promise<ProApiResponse<T>> {
+  const url = `${getBaseUrl(options)}${endpoint}`;
+  const headers = await getHeaders(options?.dataDir);
+
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    const json = (await res.json()) as any;
+
+    if (!res.ok) {
+      return {
+        ok: false,
+        error: json.error || json.detail || `HTTP ${res.status}`,
+        usage: json.usage,
+      };
+    }
+
+    return { ok: true, data: json.data ?? json, usage: json.usage };
+  } catch (err: any) {
+    return { ok: false, error: `Network error: ${err.message}` };
+  }
+}
+
+// --- Auth ---
+
+export async function verifyKey(options?: ProApiOptions): Promise<ProApiResponse<{
+  valid: boolean;
+  plan: string;
+  expiresAt: string | null;
+  usage: { used: number; remaining: number; unit: string };
+}>> {
+  return request("GET", "/api/pro/verify", null, options);
+}
+
+export async function getUsage(options?: ProApiOptions): Promise<ProApiResponse> {
+  return request("GET", "/api/pro/usage", null, options);
+}
+
+// --- Research & Crawling ---
+
+export async function researchCrawl(
+  params: { keyword: string; platform: string; count?: number },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/research/crawl", params, options);
+}
+
+export async function researchTrending(
+  params: { platform: string; count?: number },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/research/trending", params, options);
+}
+
+// --- Competitor ---
+
+export async function competitorProfile(
+  params: { profileUrl: string; platform: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/competitor/profile", params, options);
+}
+
+export async function competitorNotes(
+  params: { profileUrl: string; platform: string; limit?: number },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/competitor/notes", params, options);
+}
+
+export async function competitorAnalyze(
+  params: { profileUrl: string; platform: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/competitor/analyze", params, options);
+}
+
+// --- Video ---
+
+export async function transcribe(
+  params: { videoUrl: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse<{ scriptText: string; title: string; author: string; wordCount: number; duration: number }>> {
+  return request("POST", "/api/pro/transcribe", params, options);
+}
+
+export async function videoAnalyze(
+  params: { videoUrl: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/video/analyze", params, options);
+}
+
+// --- Analytics ---
+
+export async function analyticsAccount(
+  params: { platform: string; accountId?: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/analytics/account", params, options);
+}
+
+export async function analyticsContent(
+  params: { platform: string; contentUrl: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/analytics/content", params, options);
+}
+
+export async function analyticsReport(
+  params: { platform: string; period?: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse> {
+  return request("POST", "/api/pro/analytics/report", params, options);
+}
+
+// --- Cover ---
+
+export async function coverGenerate(
+  params: { prompt: string; ratio: "16:9" | "4:3"; referenceImagePath?: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse<{ imageUrl: string }>> {
+  return request("POST", "/api/pro/cover/generate", params, options);
+}
+
+// --- TTS & Digital Human ---
+
+export async function ttsSynthesize(
+  params: { text: string; voiceId?: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse<{ audioUrl: string; duration: number }>> {
+  return request("POST", "/api/pro/tts/synthesize", params, options);
+}
+
+export async function ttsClone(
+  params: { sampleAudioUrl: string; name: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse<{ voiceId: string }>> {
+  return request("POST", "/api/pro/tts/clone", params, options);
+}
+
+export async function digitalHumanGenerate(
+  params: { scriptText: string; avatarId?: string; voiceId?: string },
+  options?: ProApiOptions,
+): Promise<ProApiResponse<{ videoUrl: string; duration: number }>> {
+  return request("POST", "/api/pro/digital-human/generate", params, options);
+}

package/src/modules/pro/gate.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  getProStatus,
+  saveProKey,
+  removeProKey,
+  readProKey,
+  requirePro,
+  proGateResponse,
+  isProFeature,
+  PRO_FEATURES,
+} from "../pro/gate.js";
+
+let testDir: string;
+
+beforeEach(async () => {
+  testDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-gate-test-"));
+});
+
+afterEach(async () => {
+  await fs.rm(testDir, { recursive: true, force: true });
+});
+
+describe("readProKey / saveProKey / removeProKey", () => {
+  it("returns null when .pro file does not exist", async () => {
+    const key = await readProKey(testDir);
+    expect(key).toBeNull();
+  });
+
+  it("saves and reads back a key", async () => {
+    await saveProKey("test-key-abc123", testDir);
+    const key = await readProKey(testDir);
+    expect(key).toBe("test-key-abc123");
+  });
+
+  it("trims whitespace from saved key", async () => {
+    await saveProKey("  my-key  \n", testDir);
+    const key = await readProKey(testDir);
+    expect(key).toBe("my-key");
+  });
+
+  it("removes the key file", async () => {
+    await saveProKey("some-key", testDir);
+    await removeProKey(testDir);
+    const key = await readProKey(testDir);
+    expect(key).toBeNull();
+  });
+
+  it("removeProKey is safe when file does not exist", async () => {
+    await expect(removeProKey(testDir)).resolves.not.toThrow();
+  });
+});
+
+describe("getProStatus", () => {
+  it("returns isPro:false when no key", async () => {
+    const status = await getProStatus(testDir);
+    expect(status.isPro).toBe(false);
+    expect(status.apiKey).toBeNull();
+    expect(status.verified).toBeNull();
+  });
+
+  it("returns isPro:true when key exists", async () => {
+    await saveProKey("valid-key", testDir);
+    const status = await getProStatus(testDir);
+    expect(status.isPro).toBe(true);
+    expect(status.apiKey).toBe("valid-key");
+  });
+});
+
+describe("requirePro", () => {
+  it("returns null (allow) when Pro key exists", async () => {
+    await saveProKey("valid-key", testDir);
+    const result = await requirePro("对标账号监控", testDir);
+    expect(result).toBeNull();
+  });
+
+  it("returns error object when no Pro key", async () => {
+    const result = await requirePro("对标账号监控", testDir);
+    expect(result).not.toBeNull();
+    expect(result!.ok).toBe(false);
+    expect(result!.error).toContain("对标账号监控");
+    expect(result!.upgradeHint).toContain("autocrew upgrade");
+  });
+});
+
+describe("proGateResponse", () => {
+  it("includes feature name, upgrade hint, and free alternative", () => {
+    const r = proGateResponse("视频文案提取", "手动粘贴文案给我分析");
+    expect(r.ok).toBe(false);
+    expect(r.error).toContain("视频文案提取");
+    expect(r.freeAlternative).toBe("手动粘贴文案给我分析");
+    expect(r.upgradeHint).toBeTruthy();
+  });
+});
+
+describe("isProFeature", () => {
+  it("returns true for known Pro features", () => {
+    for (const f of PRO_FEATURES) {
+      expect(isProFeature(f)).toBe(true);
+    }
+  });
+
+  it("returns false for Free features", () => {
+    expect(isProFeature("humanize")).toBe(false);
+    expect(isProFeature("write-script")).toBe(false);
+    expect(isProFeature("content-review")).toBe(false);
+  });
+});

package/src/modules/pro/gate.ts

@@ -0,0 +1,104 @@
+/**
+ * Pro Gate — Feature gating for AutoCrew Pro.
+ *
+ * Checks whether the user has a valid Pro API key stored in ~/.autocrew/.pro
+ * and provides helpers to guard Pro-only tool actions.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export interface ProStatus {
+  isPro: boolean;
+  apiKey: string | null;
+  verified: boolean | null;
+  expiresAt: string | null;
+}
+
+const PRO_FILE = ".pro";
+
+function getDataDir(customDir?: string): string {
+  if (customDir) return customDir;
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".autocrew");
+}
+
+export async function readProKey(dataDir?: string): Promise<string | null> {
+  const filePath = path.join(getDataDir(dataDir), PRO_FILE);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const key = raw.trim();
+    return key.length > 0 ? key : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function saveProKey(apiKey: string, dataDir?: string): Promise<void> {
+  const dir = getDataDir(dataDir);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(path.join(dir, PRO_FILE), apiKey.trim() + "\n", "utf-8");
+}
+
+export async function removeProKey(dataDir?: string): Promise<void> {
+  try {
+    await fs.unlink(path.join(getDataDir(dataDir), PRO_FILE));
+  } catch { /* already gone */ }
+}
+
+export async function getProStatus(dataDir?: string): Promise<ProStatus> {
+  const apiKey = await readProKey(dataDir);
+  return { isPro: apiKey !== null, apiKey, verified: null, expiresAt: null };
+}
+
+/**
+ * Guard a Pro-only feature. Returns null if Pro, or an error object if Free.
+ *
+ *   const gate = await requirePro("对标账号监控", dataDir);
+ *   if (gate) return gate;
+ */
+export async function requirePro(
+  featureName: string,
+  dataDir?: string,
+): Promise<{ ok: false; error: string; upgradeHint: string; freeAlternative?: string } | null> {
+  const status = await getProStatus(dataDir);
+  if (status.isPro) return null;
+  return {
+    ok: false,
+    error: `「${featureName}」是 Pro 版功能。`,
+    upgradeHint: "运行 autocrew upgrade 了解 Pro 版详情。",
+  };
+}
+
+export function proGateResponse(
+  featureName: string,
+  freeAlternative: string,
+): { ok: false; error: string; upgradeHint: string; freeAlternative: string } {
+  return {
+    ok: false,
+    error: `「${featureName}」是 Pro 版功能。`,
+    upgradeHint: "运行 autocrew upgrade 了解 Pro 版详情。",
+    freeAlternative,
+  };
+}
+
+export const PRO_FEATURES = [
+  "competitor-monitor",
+  "extract-video-script",
+  "video-analysis",
+  "analytics-report",
+  "research-crawl",
+  "research-trending",
+  "cover-multi-ratio",
+  "tts-synthesize",
+  "tts-clone",
+  "digital-human",
+  "publish-wechat-mp",
+  "publish-wechat-video",
+  "publish-bilibili",
+] as const;
+
+export type ProFeature = (typeof PRO_FEATURES)[number];
+
+export function isProFeature(featureId: string): boolean {
+  return (PRO_FEATURES as readonly string[]).includes(featureId);
+}