autocrew 0.1.0

package/src/modules/profile/creator-profile.test.ts

@@ -0,0 +1,178 @@
+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 {
+  initProfile,
+  loadProfile,
+  saveProfile,
+  updateProfile,
+  addWritingRule,
+  addCompetitor,
+  detectMissingInfo,
+  type CreatorProfile,
+} from "../profile/creator-profile.js";
+
+let testDir: string;
+
+beforeEach(async () => {
+  testDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-profile-test-"));
+});
+
+afterEach(async () => {
+  await fs.rm(testDir, { recursive: true, force: true });
+});
+
+describe("initProfile", () => {
+  it("creates a new empty profile", async () => {
+    const profile = await initProfile(testDir);
+    expect(profile.industry).toBe("");
+    expect(profile.platforms).toEqual([]);
+    expect(profile.styleCalibrated).toBe(false);
+    expect(profile.writingRules).toEqual([]);
+  });
+
+  it("is idempotent — does not overwrite existing profile", async () => {
+    await initProfile(testDir);
+    // Manually update
+    const existing = await loadProfile(testDir);
+    existing!.industry = "科技";
+    await saveProfile(existing!, testDir);
+
+    // Init again — should not overwrite
+    const profile = await initProfile(testDir);
+    expect(profile.industry).toBe("科技");
+  });
+});
+
+describe("loadProfile", () => {
+  it("returns null when profile does not exist", async () => {
+    const profile = await loadProfile(testDir);
+    expect(profile).toBeNull();
+  });
+
+  it("loads a saved profile", async () => {
+    await initProfile(testDir);
+    const profile = await loadProfile(testDir);
+    expect(profile).not.toBeNull();
+    expect(profile!.createdAt).toBeTruthy();
+  });
+});
+
+describe("updateProfile", () => {
+  it("merges partial updates", async () => {
+    await initProfile(testDir);
+    const updated = await updateProfile({ industry: "美妆", platforms: ["xhs", "douyin"] }, testDir);
+    expect(updated.industry).toBe("美妆");
+    expect(updated.platforms).toEqual(["xhs", "douyin"]);
+  });
+
+  it("preserves fields not in the update", async () => {
+    await initProfile(testDir);
+    await updateProfile({ industry: "科技" }, testDir);
+    const updated = await updateProfile({ platforms: ["xhs"] }, testDir);
+    expect(updated.industry).toBe("科技");
+    expect(updated.platforms).toEqual(["xhs"]);
+  });
+
+  it("updates updatedAt timestamp", async () => {
+    const profile = await initProfile(testDir);
+    const before = profile.updatedAt;
+    await new Promise((r) => setTimeout(r, 5));
+    const updated = await updateProfile({ industry: "教育" }, testDir);
+    expect(updated.updatedAt).not.toBe(before);
+  });
+});
+
+describe("addWritingRule", () => {
+  it("adds a new rule", async () => {
+    await initProfile(testDir);
+    const profile = await addWritingRule(
+      { rule: "禁用顺序词", source: "auto_distilled", confidence: 0.9 },
+      testDir,
+    );
+    expect(profile.writingRules).toHaveLength(1);
+    expect(profile.writingRules[0].rule).toBe("禁用顺序词");
+  });
+
+  it("deduplicates rules by text", async () => {
+    await initProfile(testDir);
+    await addWritingRule({ rule: "禁用顺序词", source: "auto_distilled", confidence: 0.9 }, testDir);
+    const profile = await addWritingRule(
+      { rule: "禁用顺序词", source: "user_explicit", confidence: 1.0 },
+      testDir,
+    );
+    expect(profile.writingRules).toHaveLength(1);
+  });
+
+  it("adds multiple distinct rules", async () => {
+    await initProfile(testDir);
+    await addWritingRule({ rule: "规则A", source: "auto_distilled", confidence: 0.8 }, testDir);
+    const profile = await addWritingRule(
+      { rule: "规则B", source: "user_explicit", confidence: 1.0 },
+      testDir,
+    );
+    expect(profile.writingRules).toHaveLength(2);
+  });
+});
+
+describe("addCompetitor", () => {
+  it("adds a competitor account", async () => {
+    await initProfile(testDir);
+    const profile = await addCompetitor(
+      { platform: "xhs", profileUrl: "https://xhs.com/user/123", name: "测试账号" },
+      testDir,
+    );
+    expect(profile.competitorAccounts).toHaveLength(1);
+    expect(profile.competitorAccounts[0].name).toBe("测试账号");
+  });
+
+  it("deduplicates by profileUrl", async () => {
+    await initProfile(testDir);
+    await addCompetitor(
+      { platform: "xhs", profileUrl: "https://xhs.com/user/123", name: "账号A" },
+      testDir,
+    );
+    const profile = await addCompetitor(
+      { platform: "xhs", profileUrl: "https://xhs.com/user/123", name: "账号B" },
+      testDir,
+    );
+    expect(profile.competitorAccounts).toHaveLength(1);
+    expect(profile.competitorAccounts[0].name).toBe("账号A");
+  });
+});
+
+describe("detectMissingInfo", () => {
+  it("reports all missing fields on empty profile", async () => {
+    const profile = await initProfile(testDir);
+    const missing = detectMissingInfo(profile);
+    expect(missing).toContain("industry");
+    expect(missing).toContain("platforms");
+    expect(missing).toContain("audience");
+    expect(missing).toContain("style");
+  });
+
+  it("reports nothing when profile is complete", async () => {
+    const profile = await initProfile(testDir);
+    const complete: CreatorProfile = {
+      ...profile,
+      industry: "科技",
+      platforms: ["xhs"],
+      audiencePersona: { name: "职场人", painPoints: [] },
+      styleCalibrated: true,
+    };
+    const missing = detectMissingInfo(complete);
+    expect(missing).toHaveLength(0);
+  });
+
+  it("reports only missing fields", async () => {
+    const profile = await initProfile(testDir);
+    await updateProfile({ industry: "美妆", platforms: ["xhs"] }, testDir);
+    const updated = await loadProfile(testDir);
+    const missing = detectMissingInfo(updated!);
+    expect(missing).not.toContain("industry");
+    expect(missing).not.toContain("platforms");
+    expect(missing).toContain("audience");
+    expect(missing).toContain("style");
+  });
+});

package/src/modules/profile/creator-profile.ts

@@ -0,0 +1,248 @@
+/**
+ * Creator Profile — Structured creator persona stored at ~/.autocrew/creator-profile.json
+ *
+ * This is the core identity file that drives personalized writing, topic scoring,
+ * and style calibration. It's initialized during onboarding (from host MEMORY or
+ * by asking the user) and continuously enriched by the Learnings system.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export interface WritingRule {
+  rule: string;
+  /** "auto_distilled" = extracted from user edits, "user_explicit" = user stated directly */
+  source: "auto_distilled" | "user_explicit";
+  /** 0-1, higher = more confident */
+  confidence: number;
+  createdAt: string;
+}
+
+export interface AudiencePersona {
+  name: string;
+  age?: string;
+  job?: string;
+  painPoints: string[];
+  scrollStopTriggers?: string[];
+}
+
+export interface CompetitorAccount {
+  platform: string;
+  profileUrl: string;
+  name: string;
+  addedAt: string;
+}
+
+export interface PerformanceEntry {
+  contentId: string;
+  platform: string;
+  metrics: Record<string, number>;
+  recordedAt: string;
+}
+
+export interface CreatorPersona {
+  /** Creator personality type: thought_leader, storyteller, analyst, curator, entertainer */
+  type: string;
+  /** One-line unique angle — what makes this creator different */
+  uniqueAngle: string;
+  /** Content goals: growth, monetization, branding, community */
+  contentGoals: string[];
+  /** Core expertise areas */
+  expertise: string[];
+  /** Why audience follows this creator (not competitors) */
+  audienceResonance: string;
+  /** Creator's blind spots or growth areas */
+  growthAreas: string[];
+}
+
+export interface ContentPillar {
+  name: string;
+  targetPersona: string;
+  valueProposition: string;
+  contentRatio: number;
+  toneGuide: string;
+  exampleAngles: string[];
+}
+
+export interface CreatorProfile {
+  /** User's content industry/niche */
+  industry: string;
+  /** Active platforms */
+  platforms: string[];
+  /** Target audience persona */
+  audiencePersona: AudiencePersona | null;
+  /** Creator personality profile (from calibration) */
+  creatorPersona: CreatorPersona | null;
+  /** Auto-distilled + user-explicit writing rules */
+  writingRules: WritingRule[];
+  /** Style boundaries */
+  styleBoundaries: { never: string[]; always: string[] };
+  /** Competitor accounts (Pro) */
+  competitorAccounts: CompetitorAccount[];
+  /** Historical performance data points */
+  performanceHistory: PerformanceEntry[];
+  /** Natural language description of how this creator writes (from calibration) */
+  expressionPersona: string;
+  /** Additional audience personas (from calibration Phase 0.5) */
+  secondaryPersonas: AudiencePersona[];
+  /** Content pillars defining the creator's content strategy */
+  contentPillars?: ContentPillar[];
+  /** Whether style calibration has been completed */
+  styleCalibrated: boolean;
+  /** Profile creation timestamp */
+  createdAt: string;
+  /** Last update timestamp */
+  updatedAt: string;
+}
+
+const PROFILE_FILE = "creator-profile.json";
+
+function getDataDir(customDir?: string): string {
+  if (customDir) return customDir;
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".autocrew");
+}
+
+function emptyProfile(): CreatorProfile {
+  const now = new Date().toISOString();
+  return {
+    industry: "",
+    platforms: [],
+    audiencePersona: null,
+    creatorPersona: null,
+    writingRules: [],
+    styleBoundaries: { never: [], always: [] },
+    competitorAccounts: [],
+    performanceHistory: [],
+    expressionPersona: "",
+    secondaryPersonas: [],
+    styleCalibrated: false,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+/**
+ * Check if creator-profile.json exists.
+ */
+export async function profileExists(dataDir?: string): Promise<boolean> {
+  const filePath = path.join(getDataDir(dataDir), PROFILE_FILE);
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Load the creator profile. Returns null if it doesn't exist.
+ */
+export async function loadProfile(dataDir?: string): Promise<CreatorProfile | null> {
+  const filePath = path.join(getDataDir(dataDir), PROFILE_FILE);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(raw) as CreatorProfile;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save the full creator profile (overwrite).
+ */
+export async function saveProfile(profile: CreatorProfile, dataDir?: string): Promise<void> {
+  const dir = getDataDir(dataDir);
+  await fs.mkdir(dir, { recursive: true });
+  profile.updatedAt = new Date().toISOString();
+  await fs.writeFile(path.join(dir, PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+}
+
+/**
+ * Initialize a new empty profile. No-op if one already exists.
+ * Returns the profile (existing or newly created).
+ */
+export async function initProfile(dataDir?: string): Promise<CreatorProfile> {
+  const existing = await loadProfile(dataDir);
+  if (existing) return existing;
+  const profile = emptyProfile();
+  await saveProfile(profile, dataDir);
+  return profile;
+}
+
+/**
+ * Partially update the profile (merge fields).
+ */
+export async function updateProfile(
+  updates: Partial<Omit<CreatorProfile, "createdAt" | "updatedAt">>,
+  dataDir?: string,
+): Promise<CreatorProfile> {
+  let profile = await loadProfile(dataDir);
+  if (!profile) profile = emptyProfile();
+
+  const merged: CreatorProfile = {
+    ...profile,
+    ...updates,
+    // Arrays: replace entirely if provided, keep existing otherwise
+    writingRules: updates.writingRules ?? profile.writingRules,
+    competitorAccounts: updates.competitorAccounts ?? profile.competitorAccounts,
+    performanceHistory: updates.performanceHistory ?? profile.performanceHistory,
+    // Preserve immutable fields
+    createdAt: profile.createdAt,
+    updatedAt: new Date().toISOString(),
+  };
+
+  await saveProfile(merged, dataDir);
+  return merged;
+}
+
+/**
+ * Add a writing rule (deduplicates by rule text).
+ */
+export async function addWritingRule(rule: Omit<WritingRule, "createdAt">, dataDir?: string): Promise<CreatorProfile> {
+  const profile = (await loadProfile(dataDir)) || emptyProfile();
+  const exists = profile.writingRules.some((r) => r.rule === rule.rule);
+  if (!exists) {
+    profile.writingRules.push({ ...rule, createdAt: new Date().toISOString() });
+  }
+  await saveProfile(profile, dataDir);
+  return profile;
+}
+
+/**
+ * Add a competitor account (deduplicates by profileUrl).
+ */
+export async function addCompetitor(account: Omit<CompetitorAccount, "addedAt">, dataDir?: string): Promise<CreatorProfile> {
+  const profile = (await loadProfile(dataDir)) || emptyProfile();
+  const exists = profile.competitorAccounts.some((c) => c.profileUrl === account.profileUrl);
+  if (!exists) {
+    profile.competitorAccounts.push({ ...account, addedAt: new Date().toISOString() });
+  }
+  await saveProfile(profile, dataDir);
+  return profile;
+}
+
+/**
+ * Record a performance data point.
+ */
+export async function addPerformanceEntry(entry: Omit<PerformanceEntry, "recordedAt">, dataDir?: string): Promise<void> {
+  const profile = (await loadProfile(dataDir)) || emptyProfile();
+  profile.performanceHistory.push({ ...entry, recordedAt: new Date().toISOString() });
+  // Keep last 100 entries
+  if (profile.performanceHistory.length > 100) {
+    profile.performanceHistory = profile.performanceHistory.slice(-100);
+  }
+  await saveProfile(profile, dataDir);
+}
+
+/**
+ * Detect what information is missing from the profile.
+ * Used by the onboarding skill to decide what to ask.
+ */
+export function detectMissingInfo(profile: CreatorProfile): string[] {
+  const missing: string[] = [];
+  if (!profile.industry) missing.push("industry");
+  if (profile.platforms.length === 0) missing.push("platforms");
+  if (!profile.audiencePersona) missing.push("audience");
+  if (!profile.styleCalibrated) missing.push("style");
+  return missing;
+}

package/src/modules/publish/douyin-api.ts

@@ -0,0 +1,34 @@
+/**
+ * Douyin (抖音) publisher — placeholder module.
+ *
+ * Implementation should use the Douyin Creator Open Platform API:
+ * https://open.douyin.com/platform/doc/6848806527751489550
+ *
+ * Required capabilities:
+ * - Video upload via /video/upload/
+ * - Content publishing via /video/create/
+ * - OAuth 2.0 token management
+ */
+
+export interface DouyinPublishOptions {
+  title: string;
+  description: string;
+  videoPath?: string;
+  imagePaths?: string[];
+  isPrivate?: boolean;
+  postTime?: string;
+}
+
+export interface DouyinPublishResult {
+  ok: boolean;
+  itemId?: string;
+  url?: string;
+  error?: string;
+}
+
+export async function publishToDouyin(_options: DouyinPublishOptions): Promise<DouyinPublishResult> {
+  return {
+    ok: false,
+    error: "Douyin publishing is not yet implemented. Planned: Douyin Creator Open Platform API integration.",
+  };
+}