autocrew 0.1.0

package/src/runtime/tool-runner.test.ts

@@ -0,0 +1,204 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ToolRunner, type ToolDefinition } from "../runtime/tool-runner.js";
+import { createContext } from "../runtime/context.js";
+import { EventBus } from "../runtime/events.js";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+let testDir: string;
+
+function makeTool(name: string, result: Record<string, unknown> = { ok: true }): ToolDefinition {
+  return {
+    name,
+    label: name,
+    description: `Test tool ${name}`,
+    parameters: { type: "object" as const, properties: {} },
+    execute: vi.fn(async () => result),
+  };
+}
+
+/** Create a complete profile so onboarding gate doesn't block */
+async function seedProfile(dir: string) {
+  const profileDir = path.join(dir, "profiles");
+  await fs.mkdir(profileDir, { recursive: true });
+  const profile = {
+    industry: "tech",
+    platforms: ["xhs"],
+    audiencePersona: { name: "test", age: "25-35", job: "dev" },
+    styleCalibrated: true,
+    writingRules: [],
+    competitorAccounts: [],
+    performanceHistory: [],
+  };
+  await fs.writeFile(path.join(dir, "creator-profile.json"), JSON.stringify(profile));
+}
+
+describe("ToolRunner", () => {
+  let runner: ToolRunner;
+  let eventBus: EventBus;
+
+  beforeEach(async () => {
+    testDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-runner-test-"));
+    await seedProfile(testDir);
+    const ctx = createContext({ data_dir: testDir });
+    eventBus = new EventBus();
+    runner = new ToolRunner({ ctx, eventBus });
+  });
+
+  it("registers and retrieves tools", () => {
+    runner.register(makeTool("test_tool"));
+    expect(runner.getTool("test_tool")).toBeDefined();
+    expect(runner.getTools()).toHaveLength(1);
+  });
+
+  it("executes a tool and returns result", async () => {
+    runner.register(makeTool("test_tool", { ok: true, value: 42 }));
+    const result = await runner.execute("test_tool", {});
+    expect(result.ok).toBe(true);
+    expect(result.value).toBe(42);
+  });
+
+  it("returns error for unknown tool", async () => {
+    const result = await runner.execute("nonexistent", {});
+    expect(result.ok).toBe(false);
+    expect(result.error).toContain("Unknown tool");
+  });
+
+  it("injects _dataDir via middleware", async () => {
+    const tool = makeTool("test_tool");
+    runner.register(tool);
+    await runner.execute("test_tool", {});
+    const passedParams = (tool.execute as any).mock.calls[0][0];
+    expect(passedParams._dataDir).toBe(testDir);
+  });
+
+  it("catches errors and returns error result", async () => {
+    runner.register({
+      name: "crash_tool",
+      label: "Crash",
+      description: "Crashes",
+      parameters: { type: "object" as const, properties: {} },
+      execute: async () => { throw new Error("boom"); },
+    });
+    const result = await runner.execute("crash_tool", {});
+    expect(result.ok).toBe(false);
+    expect(result.error).toContain("boom");
+  });
+
+  it("records audit entries", async () => {
+    runner.register(makeTool("test_tool"));
+    await runner.execute("test_tool", { action: "test" });
+    const ctx = runner["ctx"];
+    expect(ctx.audit.length).toBeGreaterThanOrEqual(1);
+    expect(ctx.audit[0].tool).toBe("test_tool");
+    expect(ctx.audit[0].action).toBe("test");
+    expect(ctx.audit[0].ok).toBe(true);
+    expect(ctx.audit[0].durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it("tracks activeContentId in workspace", async () => {
+    runner.register(makeTool("autocrew_content", { ok: true, id: "content-123" }));
+    await runner.execute("autocrew_content", {});
+    const ctx = runner["ctx"];
+    expect(ctx.workspace.activeContentId).toBe("content-123");
+  });
+
+  it("tracks activeTopicId in workspace", async () => {
+    runner.register(makeTool("autocrew_topic", { ok: true, id: "topic-456" }));
+    await runner.execute("autocrew_topic", {});
+    const ctx = runner["ctx"];
+    expect(ctx.workspace.activeTopicId).toBe("topic-456");
+  });
+
+  it("emits pre and post events", async () => {
+    const handler = vi.fn();
+    eventBus.on("*", handler);
+    runner.register(makeTool("test_tool"));
+    await runner.execute("test_tool", {});
+    // Should have pre + post events
+    const types = handler.mock.calls.map((c: any) => c[0].type);
+    expect(types).toContain("tool:pre_execute");
+    expect(types).toContain("tool:post_execute");
+  });
+
+  it("emits execute_failed event on error result", async () => {
+    const handler = vi.fn();
+    eventBus.on("tool:execute_failed", handler);
+    runner.register(makeTool("fail_tool", { ok: false, error: "nope" }));
+    await runner.execute("fail_tool", {});
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it("injects gemini config for needsGemini tools", async () => {
+    const tool: ToolDefinition = {
+      ...makeTool("gemini_tool"),
+      needsGemini: true,
+    };
+    runner.register(tool);
+    await runner.execute("gemini_tool", {});
+    const passedParams = (tool.execute as any).mock.calls[0][0];
+    expect("_geminiApiKey" in passedParams).toBe(true);
+    expect("_geminiModel" in passedParams).toBe(true);
+  });
+
+  it("does NOT inject gemini config for non-gemini tools", async () => {
+    const tool = makeTool("normal_tool");
+    runner.register(tool);
+    await runner.execute("normal_tool", {});
+    const passedParams = (tool.execute as any).mock.calls[0][0];
+    expect("_geminiApiKey" in passedParams).toBe(false);
+  });
+
+  it("onboarding gate blocks tools when no profile exists", async () => {
+    // Create a runner with empty dataDir (no profile)
+    const emptyDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-empty-"));
+    const emptyCtx = createContext({ data_dir: emptyDir });
+    const emptyRunner = new ToolRunner({ ctx: emptyCtx, eventBus });
+
+    emptyRunner.register(makeTool("autocrew_content", { ok: true }));
+    const result = await emptyRunner.execute("autocrew_content", {});
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe("onboarding_required");
+
+    await fs.rm(emptyDir, { recursive: true, force: true });
+  });
+
+  it("onboarding gate allows exempt tools without profile", async () => {
+    const emptyDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-empty-"));
+    const emptyCtx = createContext({ data_dir: emptyDir });
+    const emptyRunner = new ToolRunner({ ctx: emptyCtx, eventBus });
+
+    emptyRunner.register(makeTool("autocrew_init", { ok: true, dataDir: emptyDir }));
+    const result = await emptyRunner.execute("autocrew_init", {});
+    expect(result.ok).toBe(true);
+
+    await fs.rm(emptyDir, { recursive: true, force: true });
+  });
+
+  it("onboarding gate blocks when style not calibrated", async () => {
+    const uncalDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-uncal-"));
+    const profile = {
+      industry: "tech",
+      platforms: ["xhs"],
+      audiencePersona: { name: "test", age: "25-35", job: "dev" },
+      styleCalibrated: false,
+      writingRules: [],
+      competitorAccounts: [],
+      performanceHistory: [],
+    };
+    await fs.writeFile(path.join(uncalDir, "creator-profile.json"), JSON.stringify(profile));
+
+    const uncalCtx = createContext({ data_dir: uncalDir });
+    const uncalRunner = new ToolRunner({ ctx: uncalCtx, eventBus });
+    uncalRunner.register(makeTool("autocrew_content", { ok: true }));
+
+    const result = await uncalRunner.execute("autocrew_content", {});
+    expect(result.ok).toBe(false);
+    // styleCalibrated:false is detected as missing info by detectMissingInfo,
+    // so profile_incomplete fires before style_not_calibrated
+    expect(["profile_incomplete", "style_not_calibrated"]).toContain(result.error);
+
+    await fs.rm(uncalDir, { recursive: true, force: true });
+  });
+});

package/src/runtime/tool-runner.ts

@@ -0,0 +1,282 @@
+/**
+ * ToolRunner — middleware pipeline for tool execution.
+ *
+ * Inspired by Claude Code's StreamingToolExecutor. Provides:
+ * - Middleware chain (dataDir injection, config, error boundary, audit)
+ * - Unified tool registration (eliminates copy-paste in index.ts)
+ * - Pre/Post hook integration points
+ */
+import {
+  type ToolContext,
+  type AuditEntry,
+  updateWorkspace,
+  recordAudit,
+  resolveGeminiKey,
+  resolveGeminiModel,
+  resolveGatewayUrl,
+} from "./context.js";
+import { type EventBus, createEvent } from "./events.js";
+import { loadProfile, detectMissingInfo } from "../modules/profile/creator-profile.js";
+
+// --- Types ---
+
+export type ToolResult = Record<string, unknown> & { ok?: boolean; error?: string };
+export type ToolExecuteFn = (params: Record<string, unknown>) => Promise<ToolResult>;
+export type Middleware = (
+  ctx: ToolContext,
+  toolName: string,
+  params: Record<string, unknown>,
+  next: () => Promise<ToolResult>,
+) => Promise<ToolResult>;
+
+export interface ToolDefinition {
+  name: string;
+  label: string;
+  description: string;
+  parameters: unknown;
+  execute: ToolExecuteFn;
+  /** Tool actions that require Pro (e.g. ["generate_ratios"]) */
+  proActions?: string[];
+  /** If true, inject _geminiApiKey and _geminiModel into params */
+  needsGemini?: boolean;
+  /** If true, this tool is exempt from onboarding gate (e.g. init, pro_status) */
+  skipOnboardingGate?: boolean;
+}
+
+export interface ToolRunnerOptions {
+  ctx: ToolContext;
+  eventBus?: EventBus;
+  middleware?: Middleware[];
+}
+
+// --- Built-in Middleware ---
+
+/** Tools exempt from onboarding gate */
+const ONBOARDING_EXEMPT_TOOLS = new Set([
+  "autocrew_init",
+  "autocrew_pro_status",
+  "autocrew_status",
+  "autocrew_memory",
+]);
+
+/** Block non-exempt tools if profile is incomplete or style not calibrated */
+const onboardingGateMiddleware: Middleware = async (ctx, toolName, _params, next) => {
+  // Skip for exempt tools
+  if (ONBOARDING_EXEMPT_TOOLS.has(toolName)) return next();
+
+  try {
+    const profile = await loadProfile(ctx.dataDir);
+    if (!profile) {
+      return {
+        ok: false,
+        error: "onboarding_required",
+        message: "⚠️ 首次使用 AutoCrew，需要先完成初始设置。",
+        action_required: "请先调用 autocrew_init 初始化数据目录，然后通过对话收集用户的行业、平台、受众信息，保存到 creator-profile.json。完成后再调用 autocrew_pro_status 确认。",
+        steps: [
+          "1. 调用 autocrew_init 初始化",
+          "2. 询问用户：你的行业/领域是什么？",
+          "3. 询问用户：你主要在哪些平台发内容？（小红书/抖音/公众号/视频号）",
+          "4. 询问用户：你的目标受众是谁？",
+          "5. 通过风格校准确定写作风格（正式vs口语、专业vs大白话等）",
+          "6. 生成 STYLE.md 并更新 creator-profile.json",
+          "7. 完成后再执行用户的原始请求",
+        ],
+      };
+    }
+
+    const missing = detectMissingInfo(profile);
+    if (missing.length > 0) {
+      return {
+        ok: false,
+        error: "profile_incomplete",
+        message: `⚠️ 创作者档案不完整，缺少：${missing.join("、")}`,
+        action_required: `请通过对话补充以下信息：${missing.join("、")}。更新 creator-profile.json 后再继续。`,
+        missing,
+      };
+    }
+
+    if (!profile.styleCalibrated) {
+      return {
+        ok: false,
+        error: "style_not_calibrated",
+        message: "⚠️ 还没有完成风格校准。写出来的内容可能不符合你的品牌调性。",
+        action_required: "请先进行风格校准：通过 A/B 选择题确定写作风格偏好，生成 STYLE.md，然后更新 creator-profile.json 的 styleCalibrated 为 true。",
+        steps: [
+          "1. 询问用户的风格偏好（正式vs口语、专业vs大白话、长文vs短文、情感vs干货）",
+          "2. 根据回答生成 ~/.autocrew/STYLE.md",
+          "3. 更新 creator-profile.json: styleCalibrated = true",
+          "4. 完成后再执行用户的原始请求",
+        ],
+      };
+    }
+  } catch {
+    // If profile check fails, let the tool proceed (don't block on errors)
+  }
+
+  return next();
+};
+
+/** Inject _dataDir into every tool call */
+const dataDirMiddleware: Middleware = async (ctx, _tool, params, next) => {
+  params._dataDir = ctx.dataDir;
+  params._gatewayUrl = resolveGatewayUrl(ctx);
+  return next();
+};
+
+/** Inject Gemini config for tools that need it */
+const geminiConfigMiddleware: Middleware = async (ctx, _tool, params, next) => {
+  // Only inject if the tool definition says it needs Gemini
+  // The runner checks this before adding to the chain
+  params._geminiApiKey = resolveGeminiKey(ctx);
+  params._geminiModel = resolveGeminiModel(ctx);
+  return next();
+};
+
+/** Catch errors and return friendly error objects */
+const errorBoundaryMiddleware: Middleware = async (_ctx, toolName, _params, next) => {
+  try {
+    return await next();
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `[${toolName}] ${message}` };
+  }
+};
+
+/** Record audit trail */
+const auditMiddleware: Middleware = async (ctx, toolName, params, next) => {
+  const start = Date.now();
+  let result: ToolResult;
+  try {
+    result = await next();
+  } catch (err) {
+    const entry: AuditEntry = {
+      tool: toolName,
+      action: params.action as string | undefined,
+      timestamp: new Date().toISOString(),
+      durationMs: Date.now() - start,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+    recordAudit(ctx, entry);
+    throw err;
+  }
+  const entry: AuditEntry = {
+    tool: toolName,
+    action: params.action as string | undefined,
+    timestamp: new Date().toISOString(),
+    durationMs: Date.now() - start,
+    ok: result.ok !== false,
+    error: result.error as string | undefined,
+  };
+  recordAudit(ctx, entry);
+  return result;
+};
+
+/** Update workspace state based on tool results */
+const workspaceTrackingMiddleware: Middleware = async (ctx, toolName, params, next) => {
+  const result = await next();
+
+  // Track active content/topic IDs
+  if (result.ok !== false) {
+    if (toolName === "autocrew_content" && result.id) {
+      updateWorkspace(ctx, { activeContentId: result.id as string });
+    }
+    if (toolName === "autocrew_topic" && result.id) {
+      updateWorkspace(ctx, { activeTopicId: result.id as string });
+    }
+    updateWorkspace(ctx, { lastToolResult: result, lastToolName: toolName });
+  }
+
+  return result;
+};
+
+// --- ToolRunner ---
+
+export class ToolRunner {
+  private ctx: ToolContext;
+  private eventBus?: EventBus;
+  private tools = new Map<string, ToolDefinition>();
+  private middleware: Middleware[];
+
+  constructor(options: ToolRunnerOptions) {
+    this.ctx = options.ctx;
+    this.eventBus = options.eventBus;
+    this.middleware = [
+      dataDirMiddleware,
+      onboardingGateMiddleware,
+      errorBoundaryMiddleware,
+      auditMiddleware,
+      workspaceTrackingMiddleware,
+      ...(options.middleware || []),
+    ];
+  }
+
+  /** Register a tool definition */
+  register(def: ToolDefinition): void {
+    this.tools.set(def.name, def);
+  }
+
+  /** Get all registered tool definitions (for OpenClaw/MCP registration) */
+  getTools(): ToolDefinition[] {
+    return Array.from(this.tools.values());
+  }
+
+  /** Get a single tool definition by name */
+  getTool(name: string): ToolDefinition | undefined {
+    return this.tools.get(name);
+  }
+
+  /** Execute a tool through the middleware pipeline */
+  async execute(toolName: string, params: Record<string, unknown>): Promise<ToolResult> {
+    const def = this.tools.get(toolName);
+    if (!def) {
+      return { ok: false, error: `Unknown tool: ${toolName}` };
+    }
+
+    // Build middleware chain for this specific tool
+    const chain = [...this.middleware];
+
+    // Inject Gemini config only for tools that need it
+    if (def.needsGemini) {
+      chain.splice(1, 0, geminiConfigMiddleware); // After dataDir, before errorBoundary
+    }
+
+    // Emit PreToolUse event
+    if (this.eventBus) {
+      this.eventBus.emit(createEvent("tool:pre_execute", { tool: toolName, action: params.action as string }));
+    }
+
+    // Execute through middleware chain
+    const result = await this.runChain(chain, toolName, { ...params }, def.execute);
+
+    // Emit PostToolUse event
+    if (this.eventBus) {
+      const eventType = result.ok !== false ? "tool:post_execute" : "tool:execute_failed";
+      this.eventBus.emit(createEvent(eventType, {
+        tool: toolName,
+        action: params.action as string,
+        ok: result.ok !== false,
+        contentId: (result.id || result.contentId || params.content_id) as string | undefined,
+      }));
+    }
+
+    return result;
+  }
+
+  private async runChain(
+    chain: Middleware[],
+    toolName: string,
+    params: Record<string, unknown>,
+    executeFn: ToolExecuteFn,
+  ): Promise<ToolResult> {
+    let index = 0;
+    const next = async (): Promise<ToolResult> => {
+      if (index < chain.length) {
+        const mw = chain[index++];
+        return mw(this.ctx, toolName, params, next);
+      }
+      return executeFn(params);
+    };
+    return next();
+  }
+}