autocrew 0.1.0

package/src/tools/init.ts

@@ -0,0 +1,133 @@
+/**
+ * AutoCrew Init — Initialize the ~/.autocrew/ data directory.
+ *
+ * Creates the directory structure and empty creator-profile.json.
+ * Safe to run multiple times (idempotent).
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { initProfile, detectMissingInfo } from "../modules/profile/creator-profile.js";
+import { initPipeline } from "../storage/pipeline-store.js";
+
+function getDataDir(customDir?: string): string {
+  if (customDir) return customDir;
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".autocrew");
+}
+
+const SUBDIRS = [
+  "topics",
+  "contents",
+  "learnings/edits",
+  "assets/raw",
+  "sensitive-words",
+  "covers/templates",
+  "competitors",
+  "memory",
+];
+
+export interface InitResult {
+  ok: boolean;
+  dataDir: string;
+  created: string[];
+  alreadyExisted: boolean;
+  next_step?: {
+    action: string;
+    message: string;
+    steps: string[];
+  };
+}
+
+export async function executeInit(options?: { dataDir?: string }): Promise<InitResult> {
+  const dataDir = getDataDir(options?.dataDir);
+  const created: string[] = [];
+
+  // Check if already initialized
+  let alreadyExisted = false;
+  try {
+    await fs.access(dataDir);
+    alreadyExisted = true;
+  } catch {
+    // Will create
+  }
+
+  // Create all subdirectories
+  for (const sub of SUBDIRS) {
+    const dir = path.join(dataDir, sub);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+      created.push(sub);
+    } catch {
+      // Already exists — fine
+    }
+  }
+
+  // Initialize pipeline directory structure (idempotent)
+  await initPipeline(dataDir);
+
+  // Initialize creator-profile.json (no-op if exists)
+  const profile = await initProfile(dataDir);
+
+  // Create empty STYLE.md if not exists
+  const stylePath = path.join(dataDir, "STYLE.md");
+  try {
+    await fs.access(stylePath);
+  } catch {
+    await fs.writeFile(
+      stylePath,
+      "# Writing Style\n\n> 尚未校准。运行「风格校准」来设置你的写作风格。\n",
+      "utf-8",
+    );
+    created.push("STYLE.md");
+  }
+
+  // Create empty custom sensitive words file if not exists
+  const customWordsPath = path.join(dataDir, "sensitive-words", "custom.txt");
+  try {
+    await fs.access(customWordsPath);
+  } catch {
+    await fs.writeFile(customWordsPath, "# 自定义敏感词（每行一个）\n", "utf-8");
+    created.push("sensitive-words/custom.txt");
+  }
+
+  // Check profile completeness to guide next steps
+  const missing = detectMissingInfo(profile);
+
+  let next_step: InitResult["next_step"];
+
+  if (missing.length > 0) {
+    const needsOnboarding = missing.some((m) => m !== "style");
+    const needsCalibration = missing.includes("style") || !profile.styleCalibrated;
+
+    if (needsOnboarding) {
+      next_step = {
+        action: "onboarding",
+        message: "⚠️ 创作者档案不完整，请先完成初始设置。",
+        steps: [
+          "1. 询问用户：你的行业/领域是什么？",
+          "2. 询问用户：你主要在哪些平台发内容？（小红书/抖音/公众号/视频号）",
+          "3. 询问用户：你的目标受众是谁？",
+          "4. 将信息保存到 creator-profile.json",
+          ...(needsCalibration
+            ? [
+                "5. 进行风格校准：通过 A/B 选择题确定写作风格偏好",
+                "6. 生成 STYLE.md 并更新 creator-profile.json 的 styleCalibrated 为 true",
+              ]
+            : []),
+        ],
+      };
+    } else if (needsCalibration) {
+      next_step = {
+        action: "style_calibration",
+        message: "✨ 初始化完成！接下来进行风格校准，让写出来的内容更贴合你的调性。",
+        steps: [
+          "1. 询问用户的风格偏好（正式vs口语、专业vs大白话、长文vs短文、情感vs干货）",
+          "2. 根据回答生成 ~/.autocrew/STYLE.md",
+          "3. 更新 creator-profile.json: styleCalibrated = true",
+        ],
+      };
+    }
+  }
+
+  return { ok: true, dataDir, created, alreadyExisted, next_step };
+}

package/src/tools/intel.ts

@@ -0,0 +1,92 @@
+import { Type } from "@sinclair/typebox";
+import { loadProfile } from "../modules/profile/creator-profile.js";
+import { runIntelPull } from "../modules/intel/intel-engine.js";
+import { listIntel, archiveExpiredIntel } from "../storage/pipeline-store.js";
+
+export const intelSchema = Type.Object({
+  action: Type.Unsafe<string>({
+    type: "string",
+    enum: ["pull", "list", "clean"],
+    description: "Action to perform: pull (collect intel), list (show saved intel), clean (archive expired)",
+  }),
+  domain: Type.Optional(Type.String({ description: "Filter by domain" })),
+  source: Type.Optional(Type.String({ description: "Filter to specific source(s), comma-separated" })),
+  keywords: Type.Optional(Type.Array(Type.String(), { description: "Override keywords for pull" })),
+  _dataDir: Type.Optional(Type.String()),
+});
+
+export async function executeIntel(params: Record<string, unknown>) {
+  const action = params.action as string;
+  const dataDir = (params._dataDir as string) || undefined;
+  const domain = (params.domain as string) || undefined;
+
+  switch (action) {
+    case "pull": {
+      const profile = await loadProfile(dataDir);
+      if (!profile) {
+        return { ok: false, error: "No creator profile found. Run autocrew_init first." };
+      }
+
+      const searchFn = params._searchFn as
+        | ((query: string) => Promise<Array<{ title: string; snippet: string; url: string }>>)
+        | undefined;
+      if (!searchFn) {
+        return { ok: false, error: "Search function not available. Ensure MCP search is configured." };
+      }
+
+      const keywords = (params.keywords as string[]) ?? profile.writingRules.map((r) => r.rule).slice(0, 5);
+      const sources = params.source ? (params.source as string).split(",").map((s) => s.trim()) : undefined;
+
+      const result = await runIntelPull({
+        keywords: keywords.length > 0 ? keywords : [profile.industry],
+        industry: profile.industry,
+        platforms: profile.platforms,
+        dataDir,
+        searchFn,
+        skipBrowser: true,
+        sources,
+      });
+
+      return {
+        ok: true,
+        action: "pull",
+        totalCollected: result.totalCollected,
+        totalSaved: result.totalSaved,
+        bySource: result.bySource,
+        errors: result.errors.length > 0 ? result.errors.slice(0, 10) : undefined,
+      };
+    }
+
+    case "list": {
+      const items = await listIntel(domain, dataDir);
+      const top50 = items.slice(0, 50).map((item) => ({
+        title: item.title,
+        domain: item.domain,
+        source: item.source,
+        relevance: item.relevance,
+        collectedAt: item.collectedAt,
+        summary: item.summary.slice(0, 120),
+      }));
+
+      return {
+        ok: true,
+        action: "list",
+        total: items.length,
+        showing: top50.length,
+        items: top50,
+      };
+    }
+
+    case "clean": {
+      const result = await archiveExpiredIntel(dataDir);
+      return {
+        ok: true,
+        action: "clean",
+        archived: result.archived,
+      };
+    }
+
+    default:
+      return { ok: false, error: `Unknown action: ${action}` };
+  }
+}

package/src/tools/memory.ts

@@ -0,0 +1,76 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Type } from "@sinclair/typebox";
+import { getContent } from "../storage/local-store.js";
+import { distillMemory } from "../modules/memory/distill.js";
+
+export const memorySchema = Type.Object({
+  action: Type.Unsafe<"capture_feedback" | "get_memory">({
+    type: "string",
+    enum: ["capture_feedback", "get_memory"],
+    description: "Capture a new feedback signal into memory, or read the current MEMORY.md file.",
+  }),
+  signal_type: Type.Optional(
+    Type.Unsafe<"approval" | "rejection" | "edit" | "performance" | "general">({
+      type: "string",
+      enum: ["approval", "rejection", "edit", "performance", "general"],
+      description: "Feedback signal type for capture_feedback.",
+    }),
+  ),
+  content_id: Type.Optional(Type.String({ description: "Optional AutoCrew content id." })),
+  feedback: Type.Optional(Type.String({ description: "Freeform user feedback or performance note." })),
+  original_text: Type.Optional(Type.String({ description: "Original text before user edit." })),
+  modified_text: Type.Optional(Type.String({ description: "User-edited or final text." })),
+  platform: Type.Optional(Type.String({ description: "Optional platform label." })),
+});
+
+function resolveDataDir(customDir?: string): string {
+  if (customDir) return customDir;
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".autocrew");
+}
+
+export async function executeMemory(params: Record<string, unknown>) {
+  const action = params.action as string;
+  const dataDir = (params._dataDir as string) || undefined;
+
+  if (action === "get_memory") {
+    const memoryPath = path.join(resolveDataDir(dataDir), "MEMORY.md");
+    try {
+      const content = await fs.readFile(memoryPath, "utf-8");
+      return { ok: true, memoryPath, content };
+    } catch {
+      return { ok: true, memoryPath, content: "", note: "MEMORY.md 尚未创建。使用 capture_feedback 记录反馈后会自动生成。" };
+    }
+  }
+
+  if (action !== "capture_feedback") {
+    return { ok: false, error: `Unknown action: ${action}` };
+  }
+
+  const signalType = (params.signal_type as any) || "general";
+  let contentTitle: string | undefined;
+  let originalText = (params.original_text as string) || undefined;
+  let modifiedText = (params.modified_text as string) || undefined;
+  let platform = (params.platform as string) || undefined;
+
+  const contentId = params.content_id as string | undefined;
+  if (contentId) {
+    const content = await getContent(contentId, dataDir);
+    if (content) {
+      contentTitle = content.title;
+      platform = platform || content.platform;
+      originalText = originalText || content.body;
+    }
+  }
+
+  return distillMemory({
+    signalType,
+    feedback: (params.feedback as string) || undefined,
+    originalText,
+    modifiedText,
+    contentTitle,
+    platform,
+    dataDir,
+  });
+}

package/src/tools/pipeline-ops.ts

@@ -0,0 +1,109 @@
+import { Type } from "@sinclair/typebox";
+import {
+  initPipeline,
+  listIntel,
+  listTopics,
+  listProjects,
+  startProject,
+  advanceProject,
+  addDraftVersion,
+  trashProject,
+  restoreProject,
+  PIPELINE_STAGES,
+} from "../storage/pipeline-store.js";
+
+export const pipelineOpsSchema = Type.Object({
+  action: Type.Unsafe<string>({
+    type: "string",
+    enum: ["start", "advance", "trash", "restore", "status", "version"],
+    description: "Pipeline action: status (overview), start (topic→project), advance (next stage), version (add draft), trash/restore",
+  }),
+  project: Type.Optional(Type.String({ description: "Project slug name" })),
+  platform: Type.Optional(Type.String({ description: "Target platform" })),
+  content: Type.Optional(Type.String({ description: "Draft content for version action" })),
+  note: Type.Optional(Type.String({ description: "Version note or action note" })),
+  _dataDir: Type.Optional(Type.String()),
+});
+
+export async function executePipelineOps(params: Record<string, unknown>) {
+  const action = params.action as string;
+  const dataDir = (params._dataDir as string) || undefined;
+
+  switch (action) {
+    case "status": {
+      await initPipeline(dataDir);
+
+      const intel = await listIntel(undefined, dataDir);
+      const topics = await listTopics(undefined, dataDir);
+
+      const stages: Record<string, number> = {};
+      for (const stage of PIPELINE_STAGES) {
+        if (stage === "intel") {
+          stages[stage] = intel.length;
+        } else if (stage === "topics") {
+          stages[stage] = topics.length;
+        } else {
+          const projects = await listProjects(stage, dataDir);
+          stages[stage] = projects.length;
+        }
+      }
+
+      return {
+        ok: true,
+        action: "status",
+        stages,
+        total: Object.values(stages).reduce((a, b) => a + b, 0),
+      };
+    }
+
+    case "start": {
+      const project = params.project as string | undefined;
+      if (!project) {
+        return { ok: false, error: "Missing 'project' — provide a topic slug to start from." };
+      }
+      const dir = await startProject(project, dataDir);
+      return { ok: true, action: "start", projectDir: dir };
+    }
+
+    case "advance": {
+      const project = params.project as string | undefined;
+      if (!project) {
+        return { ok: false, error: "Missing 'project' — provide the project name to advance." };
+      }
+      const dir = await advanceProject(project, dataDir);
+      return { ok: true, action: "advance", newDir: dir };
+    }
+
+    case "version": {
+      const project = params.project as string | undefined;
+      const content = params.content as string | undefined;
+      const note = (params.note as string) ?? "new version";
+      if (!project || !content) {
+        return { ok: false, error: "Missing 'project' and/or 'content' for version action." };
+      }
+      const file = await addDraftVersion(project, content, note, dataDir);
+      return { ok: true, action: "version", file };
+    }
+
+    case "trash": {
+      const project = params.project as string | undefined;
+      if (!project) {
+        return { ok: false, error: "Missing 'project' — provide the project name to trash." };
+      }
+      await trashProject(project, dataDir);
+      return { ok: true, action: "trash", project };
+    }
+
+    case "restore": {
+      const project = params.project as string | undefined;
+      if (!project) {
+        return { ok: false, error: "Missing 'project' — provide the project name to restore." };
+      }
+      const dir = await restoreProject(project, dataDir);
+      return { ok: true, action: "restore", restoredTo: dir };
+    }
+
+    default:
+      return { ok: false, error: `Unknown action: ${action}` };
+  }
+}

package/src/tools/pipeline.ts

@@ -0,0 +1,168 @@
+import { Type } from "@sinclair/typebox";
+import { WorkflowEngine } from "../runtime/workflow-engine.js";
+import { getTemplates, getTemplate } from "../modules/workflow/templates.js";
+import type { ToolRunner } from "../runtime/tool-runner.js";
+
+/**
+ * autocrew_pipeline — workflow orchestration for content pipelines.
+ *
+ * Manages stateful multi-step workflows with approval gates,
+ * parameter interpolation, and persistent state.
+ */
+
+export const pipelineSchema = Type.Object({
+  action: Type.Unsafe<"create" | "start" | "status" | "approve" | "cancel" | "list" | "templates">({
+    type: "string",
+    enum: ["create", "start", "status", "approve", "cancel", "list", "templates"],
+    description:
+      "Action: 'create' workflow from template, 'start' a workflow, 'status' check progress, 'approve' a paused step, 'cancel' a workflow, 'list' all workflows, 'templates' list available templates.",
+  }),
+  id: Type.Optional(Type.String({ description: "Workflow instance id (for start/status/approve/cancel)" })),
+  template: Type.Optional(
+    Type.String({ description: "Template id: 'xiaohongshu_full', 'quick_publish'" }),
+  ),
+  params: Type.Optional(
+    Type.Record(Type.String(), Type.Unknown(), {
+      description: "Initial parameters for the workflow (e.g. content_id for quick_publish)",
+    }),
+  ),
+});
+
+/** Singleton engine per dataDir — avoids re-creating on every call */
+const engines = new Map<string, WorkflowEngine>();
+
+function getEngine(toolRunner: ToolRunner, dataDir: string): WorkflowEngine {
+  let engine = engines.get(dataDir);
+  if (!engine) {
+    engine = new WorkflowEngine(toolRunner, dataDir);
+    // Register all built-in templates
+    for (const tpl of getTemplates()) {
+      engine.registerDefinition(tpl);
+    }
+    engines.set(dataDir, engine);
+  }
+  return engine;
+}
+
+/**
+ * Create the pipeline executor. Needs a ToolRunner reference for workflow step execution.
+ */
+export function createPipelineExecutor(toolRunner: ToolRunner) {
+  return async function executePipeline(params: Record<string, unknown>) {
+    const action = params.action as string;
+    const dataDir = params._dataDir as string;
+
+    if (!dataDir) {
+      return { ok: false, error: "No _dataDir provided" };
+    }
+
+    const engine = getEngine(toolRunner, dataDir);
+
+    // --- Templates ---
+    if (action === "templates") {
+      const templates = getTemplates().map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        steps: t.steps.map((s) => `${s.name} (${s.tool})${s.requiresApproval ? " ⏸" : ""}`),
+      }));
+      return { ok: true, templates };
+    }
+
+    // --- List ---
+    if (action === "list") {
+      const instances = await engine.list();
+      return {
+        ok: true,
+        workflows: instances.map((i) => ({
+          id: i.id,
+          definitionId: i.definitionId,
+          status: i.status,
+          currentStepIndex: i.currentStepIndex,
+          createdAt: i.createdAt,
+          error: i.error,
+        })),
+      };
+    }
+
+    // --- Create ---
+    if (action === "create") {
+      const templateId = params.template as string;
+      if (!templateId) {
+        return { ok: false, error: "template is required for create" };
+      }
+      const tpl = getTemplate(templateId);
+      if (!tpl) {
+        return { ok: false, error: `Unknown template: ${templateId}. Use action='templates' to see available ones.` };
+      }
+      try {
+        const instance = await engine.create(templateId, params.params as Record<string, unknown>);
+        return {
+          ok: true,
+          workflow: instance,
+          hint: `Workflow created. Use action='start' with id='${instance.id}' to begin execution.`,
+        };
+      } catch (err: unknown) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+
+    // --- Start ---
+    if (action === "start") {
+      const id = params.id as string;
+      if (!id) return { ok: false, error: "id is required" };
+      try {
+        const instance = await engine.start(id);
+        return { ok: true, workflow: instance };
+      } catch (err: unknown) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+
+    // --- Status ---
+    if (action === "status") {
+      const id = params.id as string;
+      if (!id) return { ok: false, error: "id is required" };
+      const instance = await engine.getStatus(id);
+      if (!instance) {
+        return { ok: false, error: `Workflow ${id} not found` };
+      }
+      const def = getTemplate(instance.definitionId);
+      const currentStep = def?.steps[instance.currentStepIndex];
+      return {
+        ok: true,
+        workflow: instance,
+        currentStep: currentStep
+          ? { name: currentStep.name, tool: currentStep.tool, requiresApproval: currentStep.requiresApproval }
+          : null,
+        totalSteps: def?.steps.length ?? 0,
+      };
+    }
+
+    // --- Approve ---
+    if (action === "approve") {
+      const id = params.id as string;
+      if (!id) return { ok: false, error: "id is required" };
+      try {
+        const instance = await engine.approve(id);
+        return { ok: true, workflow: instance };
+      } catch (err: unknown) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+
+    // --- Cancel ---
+    if (action === "cancel") {
+      const id = params.id as string;
+      if (!id) return { ok: false, error: "id is required" };
+      try {
+        const instance = await engine.cancel(id);
+        return { ok: true, workflow: instance };
+      } catch (err: unknown) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+
+    return { ok: false, error: `Unknown action: ${action}` };
+  };
+}