autocrew 0.1.0

package/src/cli/bootstrap.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared runtime initialization for all entry points (CLI, MCP, HTTP server, OpenClaw adapter).
+ * Single source of truth — eliminates duplicated bootstrap code.
+ */
+import { createContext, type PluginConfig } from "../runtime/context.js";
+import { ToolRunner } from "../runtime/tool-runner.js";
+import { EventBus } from "../runtime/events.js";
+import { HookManager } from "../runtime/hooks.js";
+import { WorkflowEngine } from "../runtime/workflow-engine.js";
+import { registerAllTools } from "../tools/registry.js";
+
+export interface BootstrapResult {
+  ctx: ReturnType<typeof createContext>;
+  eventBus: EventBus;
+  runner: ToolRunner;
+  hookManager: HookManager;
+  workflowEngine: WorkflowEngine;
+}
+
+export function bootstrap(config?: PluginConfig): BootstrapResult {
+  const ctx = createContext(config);
+  const eventBus = new EventBus();
+  const runner = new ToolRunner({ ctx, eventBus });
+
+  registerAllTools(runner);
+
+  const hookManager = new HookManager();
+  hookManager.init(eventBus, runner, ctx.dataDir).catch(() => {});
+
+  const workflowEngine = new WorkflowEngine(runner, ctx.dataDir);
+
+  return { ctx, eventBus, runner, hookManager, workflowEngine };
+}

package/src/cli/commands/adapt.ts

@@ -0,0 +1,28 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "adapt",
+  description: "Create a platform-native rewrite",
+  usage: "autocrew adapt <content-id> <platform>",
+  action: async (args, runner) => {
+    const contentId = args[0];
+    const platform = args[1];
+    if (!contentId || !platform) {
+      console.error("Usage: autocrew adapt <content-id> <platform>");
+      process.exitCode = 1;
+      return;
+    }
+    const result = await runner.execute("autocrew_rewrite", {
+      action: "adapt_platform",
+      content_id: contentId,
+      target_platform: platform,
+    });
+    if (!result.ok) {
+      console.error(`Adapt failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`Platform rewrite complete → ${platform}`);
+    console.log(`  New content: ${result.newContentId || result.id || "(saved)"}`);
+  },
+};

package/src/cli/commands/advance.ts

@@ -0,0 +1,28 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "advance",
+  description: "Advance a project to the next pipeline stage",
+  usage: "autocrew advance <project>",
+  action: async (args, runner) => {
+    const project = args[0];
+    if (!project) {
+      console.error("Usage: autocrew advance <project>");
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = await runner.execute("autocrew_pipeline_ops", {
+      action: "advance",
+      project,
+    });
+
+    if (!result.ok) {
+      console.error(`Advance failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(`Project advanced to: ${result.newDir}`);
+  },
+};

package/src/cli/commands/assets.ts

@@ -0,0 +1,24 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "assets",
+  description: "List assets for a content project",
+  usage: "autocrew assets <content-id>",
+  action: async (args, runner) => {
+    const contentId = args[0];
+    if (!contentId) {
+      console.error("Usage: autocrew assets <content-id>");
+      process.exitCode = 1;
+      return;
+    }
+    const result = await runner.execute("autocrew_asset", { action: "list", content_id: contentId });
+    const assets = (result.assets || []) as any[];
+    if (assets.length === 0) {
+      console.log(`No assets for ${contentId}.`);
+      return;
+    }
+    for (const a of assets) {
+      console.log(`  [${a.type}] ${a.filename} (${a.role || "general"})`);
+    }
+  },
+};

package/src/cli/commands/audit.ts

@@ -0,0 +1,18 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "audit",
+  description: "Show recent tool execution audit log",
+  usage: "autocrew audit",
+  action: async (_args, _runner, ctx) => {
+    if (ctx.audit.length === 0) {
+      console.log("No audit entries yet.");
+      return;
+    }
+    for (const entry of ctx.audit.slice(-20)) {
+      const status = entry.ok ? "\u2713" : "\u2717";
+      console.log(`  ${status} ${entry.tool}${entry.action ? `:${entry.action}` : ""} — ${entry.durationMs}ms (${entry.timestamp})`);
+      if (entry.error) console.log(`    Error: ${entry.error}`);
+    }
+  },
+};

package/src/cli/commands/contents.ts

@@ -0,0 +1,18 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "contents",
+  description: "List content items",
+  usage: "autocrew contents",
+  action: async (_args, runner) => {
+    const result = await runner.execute("autocrew_content", { action: "list" });
+    const items = (result.items || []) as any[];
+    if (items.length === 0) {
+      console.log("No content yet. Use 'autocrew_content' tool to save drafts.");
+      return;
+    }
+    for (const c of items) {
+      console.log(`[${c.id}] ${c.title} — ${c.status} (${c.platform || "general"})`);
+    }
+  },
+};

package/src/cli/commands/cover.ts

@@ -0,0 +1,58 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "cover",
+  description: "Cover operations: review candidates or approve a variant",
+  usage: "autocrew cover <content-id> [--approve <label>]",
+  action: async (args, runner) => {
+    const contentId = args[0];
+    if (!contentId) {
+      console.error("Usage: autocrew cover <content-id> [--approve <label>]");
+      process.exitCode = 1;
+      return;
+    }
+
+    // Check for --approve flag → approve-cover flow
+    const approveIdx = args.indexOf("--approve");
+    if (approveIdx !== -1) {
+      const label = args[approveIdx + 1];
+      if (!label) {
+        console.error("Usage: autocrew cover <content-id> --approve <label>");
+        process.exitCode = 1;
+        return;
+      }
+      const result = await runner.execute("autocrew_cover_review", {
+        action: "approve",
+        content_id: contentId,
+        label,
+      });
+      if (!result.ok) {
+        console.error(`Approve failed: ${result.error || "unknown error"}`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(`Cover ${label.toUpperCase()} approved for ${contentId}.`);
+      return;
+    }
+
+    // Default: cover-review flow
+    const result = await runner.execute("autocrew_cover_review", {
+      action: "create_candidates",
+      content_id: contentId,
+    });
+    if (!result.ok) {
+      console.error(`Cover generation failed: ${result.error || "unknown error"}`);
+      if (result.hint) console.log(`Hint: ${result.hint}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`Generated ${result.generated || 0} cover candidates.`);
+    const review = result.review as any;
+    if (review?.variants) {
+      for (const v of review.variants) {
+        console.log(`  [${v.label.toUpperCase()}] ${v.style} — ${v.titleText || ""}`);
+        if (v.imagePaths?.["3:4"]) console.log(`    → ${v.imagePaths["3:4"]}`);
+      }
+    }
+  },
+};

package/src/cli/commands/events.ts

@@ -0,0 +1,17 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "events",
+  description: "Show recent event history",
+  usage: "autocrew events",
+  action: async (_args, _runner, _ctx, eventBus) => {
+    const history = eventBus.getHistory(20);
+    if (history.length === 0) {
+      console.log("No events yet.");
+      return;
+    }
+    for (const e of history) {
+      console.log(`  ${e.type} — ${JSON.stringify(e.data)} (${e.timestamp})`);
+    }
+  },
+};

package/src/cli/commands/humanize.ts

@@ -0,0 +1,27 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "humanize",
+  description: "Run Chinese de-AI pass on a content draft",
+  usage: "autocrew humanize <content-id>",
+  action: async (args, runner) => {
+    const contentId = args[0];
+    if (!contentId) {
+      console.error("Usage: autocrew humanize <content-id>");
+      process.exitCode = 1;
+      return;
+    }
+    const result = await runner.execute("autocrew_humanize", { content_id: contentId });
+    if (!result.ok) {
+      console.error(`Humanize failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`De-AI pass complete. Changes: ${result.changeCount || 0}`);
+    if ((result.changes as any[])?.length > 0) {
+      for (const c of result.changes as string[]) {
+        console.log(`  • ${c}`);
+      }
+    }
+  },
+};

package/src/cli/commands/index.ts

@@ -0,0 +1,80 @@
+/**
+ * Command registry — exports all CLI commands and shared helpers.
+ */
+import type { ToolRunner } from "../../runtime/tool-runner.js";
+import type { ToolContext } from "../../runtime/context.js";
+import type { EventBus } from "../../runtime/events.js";
+
+export interface CommandDef {
+  name: string;
+  description: string;
+  usage?: string;
+  action: (args: string[], runner: ToolRunner, ctx: ToolContext, eventBus: EventBus) => Promise<void>;
+}
+
+/**
+ * Parse a CLI flag value from args array.
+ * e.g. getOption(["--keyword", "AI"], "--keyword") → "AI"
+ */
+export function getOption(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
+}
+
+import { cmd as statusCmd } from "./status.js";
+import { cmd as topicsCmd } from "./topics.js";
+import { cmd as contentsCmd } from "./contents.js";
+import { cmd as researchCmd } from "./research.js";
+import { cmd as assetsCmd } from "./assets.js";
+import { cmd as versionsCmd } from "./versions.js";
+import { cmd as openCmd } from "./open.js";
+import { cmd as pipelinesCmd } from "./pipelines.js";
+import { cmd as templatesCmd } from "./templates.js";
+import { cmd as humanizeCmd } from "./humanize.js";
+import { cmd as adaptCmd } from "./adapt.js";
+import { cmd as coverCmd } from "./cover.js";
+import { cmd as reviewCmd } from "./review.js";
+import { cmd as prePublishCmd } from "./pre-publish.js";
+import { cmd as learnCmd } from "./learn.js";
+import { cmd as memoryCmd } from "./memory.js";
+import { cmd as initCmd } from "./init.js";
+import { cmd as upgradeCmd } from "./upgrade.js";
+import { cmd as profileCmd } from "./profile.js";
+import { cmd as auditCmd } from "./audit.js";
+import { cmd as eventsCmd } from "./events.js";
+import { cmd as intelCmd } from "./intel.js";
+import { cmd as startCmd } from "./start.js";
+import { cmd as advanceCmd } from "./advance.js";
+import { cmd as trashCmd } from "./trash.js";
+import { cmd as restoreCmd } from "./restore.js";
+import { cmd as migrateCmd } from "./migrate.js";
+
+export const commands: CommandDef[] = [
+  statusCmd,
+  topicsCmd,
+  contentsCmd,
+  researchCmd,
+  assetsCmd,
+  versionsCmd,
+  openCmd,
+  pipelinesCmd,
+  templatesCmd,
+  humanizeCmd,
+  adaptCmd,
+  coverCmd,
+  reviewCmd,
+  prePublishCmd,
+  learnCmd,
+  memoryCmd,
+  initCmd,
+  upgradeCmd,
+  profileCmd,
+  auditCmd,
+  eventsCmd,
+  intelCmd,
+  startCmd,
+  advanceCmd,
+  trashCmd,
+  restoreCmd,
+  migrateCmd,
+];

package/src/cli/commands/init.ts

@@ -0,0 +1,28 @@
+import type { CommandDef } from "./index.js";
+import { loadProfile, detectMissingInfo } from "../../modules/profile/creator-profile.js";
+
+export const cmd: CommandDef = {
+  name: "init",
+  description: "Initialize ~/.autocrew/ data directory and creator profile",
+  usage: "autocrew init",
+  action: async (_args, runner, ctx) => {
+    const result = await runner.execute("autocrew_init", {});
+    if (result.alreadyExisted) {
+      console.log(`AutoCrew already initialized at ${result.dataDir}`);
+    } else {
+      console.log(`AutoCrew initialized at ${result.dataDir}`);
+    }
+    console.log(`  Created: ${(result.created as any[])?.length ?? 0} items`);
+
+    const profile = await loadProfile(ctx.dataDir);
+    if (profile) {
+      const missing = detectMissingInfo(profile);
+      if (missing.length > 0) {
+        console.log(`\n  Profile incomplete — missing: ${missing.join(", ")}`);
+        console.log(`  Start a conversation with your agent to complete onboarding.`);
+      } else {
+        console.log(`\n  Profile complete. Ready to go!`);
+      }
+    }
+  },
+};

package/src/cli/commands/intel.ts

@@ -0,0 +1,55 @@
+import type { CommandDef } from "./index.js";
+import { getOption } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "intel",
+  description: "Manage inspiration sources — pull signals, list saved items, clean expired",
+  usage: "autocrew intel pull [--source X] | autocrew intel list [--domain X] | autocrew intel clean",
+  action: async (args, runner) => {
+    const subcommand = args[0];
+    if (!subcommand || !["pull", "list", "clean"].includes(subcommand)) {
+      console.error("Usage: autocrew intel <pull|list|clean>");
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = await runner.execute("autocrew_intel", {
+      action: subcommand,
+      source: getOption(args, "--source"),
+      domain: getOption(args, "--domain"),
+    });
+
+    if (!result.ok) {
+      console.error(`Intel ${subcommand} failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    switch (subcommand) {
+      case "pull":
+        console.log(`Intel pull complete. Collected: ${result.totalCollected}, Saved: ${result.totalSaved}`);
+        if (result.bySource) {
+          for (const [src, count] of Object.entries(result.bySource as Record<string, number>)) {
+            console.log(`  ${src}: ${count}`);
+          }
+        }
+        if (result.errors) {
+          console.log(`  Errors: ${(result.errors as string[]).length}`);
+        }
+        break;
+
+      case "list": {
+        console.log(`Intel items: ${result.total} total, showing ${result.showing}`);
+        const items = (result.items || []) as any[];
+        for (const item of items) {
+          console.log(`  [${item.source}] ${item.title} — relevance: ${item.relevance ?? "?"}`);
+        }
+        break;
+      }
+
+      case "clean":
+        console.log(`Intel clean complete. Archived: ${result.archived}`);
+        break;
+    }
+  },
+};

package/src/cli/commands/learn.ts

@@ -0,0 +1,34 @@
+import type { CommandDef } from "./index.js";
+import { getOption } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "learn",
+  description: "Capture a feedback signal into AutoCrew memory",
+  usage: "autocrew learn <content-id> --signal <signal> [--feedback <feedback>] [--modified-text <text>]",
+  action: async (args, runner) => {
+    const contentId = args[0];
+    const signal = getOption(args, "--signal");
+    if (!contentId || !signal) {
+      console.error("Usage: autocrew learn <content-id> --signal <signal> [--feedback <feedback>]");
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = await runner.execute("autocrew_memory", {
+      action: "capture_feedback",
+      content_id: contentId,
+      signal_type: signal,
+      feedback: getOption(args, "--feedback"),
+      modified_text: getOption(args, "--modified-text"),
+    });
+
+    if (!result.ok) {
+      console.error(`Memory capture failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(`Saved learning to ${result.section}.`);
+    console.log(`  ${result.learning}`);
+  },
+};

package/src/cli/commands/memory.ts

@@ -0,0 +1,18 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "memory",
+  description: "Show current AutoCrew MEMORY.md",
+  usage: "autocrew memory",
+  action: async (_args, runner) => {
+    const result = await runner.execute("autocrew_memory", { action: "get_memory" });
+
+    if (!result.ok) {
+      console.error(`Read memory failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(result.content);
+  },
+};

package/src/cli/commands/migrate.ts

@@ -0,0 +1,24 @@
+import type { CommandDef } from "./index.js";
+import { migrateLegacyData } from "../../modules/migrate/legacy-migrate.js";
+
+export const cmd: CommandDef = {
+  name: "migrate",
+  description: "Migrate legacy data to the new pipeline format",
+  usage: "autocrew migrate",
+  action: async (_args, _runner, ctx) => {
+    console.log("Migrating legacy data...");
+    const result = await migrateLegacyData(ctx.dataDir);
+
+    console.log(`  Topics migrated:   ${result.topicsMigrated}`);
+    console.log(`  Contents migrated: ${result.contentsMigrated}`);
+
+    if (result.errors.length > 0) {
+      console.log(`\n  Errors (${result.errors.length}):`);
+      for (const err of result.errors) {
+        console.log(`    - ${err}`);
+      }
+    } else {
+      console.log("\n  Migration complete — no errors.");
+    }
+  },
+};

package/src/cli/commands/open.ts

@@ -0,0 +1,21 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "open",
+  description: "Show the file path of a content project directory",
+  usage: "autocrew open <content-id>",
+  action: async (args, _runner, ctx) => {
+    const contentId = args[0];
+    if (!contentId) {
+      console.error("Usage: autocrew open <content-id>");
+      process.exitCode = 1;
+      return;
+    }
+    const projPath = `${ctx.dataDir}/contents/${contentId}`;
+    console.log(`Content project: ${projPath}`);
+    console.log(`  draft.md    — current readable draft`);
+    console.log(`  meta.json   — metadata + asset index`);
+    console.log(`  assets/     — media files (covers, B-Roll, etc.)`);
+    console.log(`  versions/   — version history (v1.md, v2.md, ...)`);
+  },
+};

package/src/cli/commands/pipelines.ts

@@ -0,0 +1,18 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "pipelines",
+  description: "List configured pipelines",
+  usage: "autocrew pipelines",
+  action: async (_args, runner) => {
+    const result = await runner.execute("autocrew_pipeline", { action: "list" });
+    const pipelines = (result.pipelines || []) as any[];
+    if (pipelines.length === 0) {
+      console.log("No pipelines configured. Use 'autocrew_pipeline' tool to create one.");
+      return;
+    }
+    for (const p of pipelines) {
+      console.log(`  [${p.id}] ${p.name} — ${p.enabled ? "enabled" : "disabled"} (${p.schedule || "manual"})`);
+    }
+  },
+};

package/src/cli/commands/pre-publish.ts

@@ -0,0 +1,27 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "pre-publish",
+  description: "Run pre-publish checklist: 6 checks before allowing publish",
+  usage: "autocrew pre-publish <content-id>",
+  action: async (args, runner) => {
+    const contentId = args[0];
+    if (!contentId) {
+      console.error("Usage: autocrew pre-publish <content-id>");
+      process.exitCode = 1;
+      return;
+    }
+    const result = await runner.execute("autocrew_pre_publish", {
+      action: "check",
+      content_id: contentId,
+    }) as any;
+
+    if (!result.ok) {
+      console.error(`Pre-publish check failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(result.summary);
+  },
+};

package/src/cli/commands/profile.ts

@@ -0,0 +1,31 @@
+import type { CommandDef } from "./index.js";
+import { loadProfile, detectMissingInfo } from "../../modules/profile/creator-profile.js";
+
+export const cmd: CommandDef = {
+  name: "profile",
+  description: "Show creator profile",
+  usage: "autocrew profile",
+  action: async (_args, _runner, ctx) => {
+    const profile = await loadProfile(ctx.dataDir);
+    if (!profile) {
+      console.log("No creator profile yet. Run 'autocrew init' first.");
+      return;
+    }
+    console.log(`Industry: ${profile.industry || "(not set)"}`);
+    console.log(`Platforms: ${profile.platforms.length > 0 ? profile.platforms.join(", ") : "(not set)"}`);
+    console.log(`Style calibrated: ${profile.styleCalibrated ? "yes" : "no"}`);
+    if (profile.audiencePersona) {
+      console.log(`Audience: ${profile.audiencePersona.name} (${profile.audiencePersona.age || "?"}, ${profile.audiencePersona.job || "?"})`);
+    } else {
+      console.log(`Audience: (not set)`);
+    }
+    console.log(`Writing rules: ${profile.writingRules.length}`);
+    console.log(`Competitors: ${profile.competitorAccounts.length}`);
+    console.log(`Performance entries: ${profile.performanceHistory.length}`);
+
+    const missing = detectMissingInfo(profile);
+    if (missing.length > 0) {
+      console.log(`\nMissing: ${missing.join(", ")}`);
+    }
+  },
+};

package/src/cli/commands/research.ts

@@ -0,0 +1,36 @@
+import type { CommandDef } from "./index.js";
+import { getOption } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "research",
+  description: "Discover browser-first topic candidates and save them into AutoCrew",
+  usage: "autocrew research --keyword <keyword> [--industry <industry>] [--platform <platform>] [--count <count>]",
+  action: async (args, runner) => {
+    const keyword = getOption(args, "--keyword");
+    if (!keyword) {
+      console.error("Missing required option: --keyword <keyword>");
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = await runner.execute("autocrew_research", {
+      action: "discover",
+      keyword,
+      industry: getOption(args, "--industry"),
+      platform: getOption(args, "--platform") || "xiaohongshu",
+      topic_count: Number(getOption(args, "--count") || 3),
+    });
+
+    if (!result.ok) {
+      console.error(`Research failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(`Research complete. Mode: ${result.mode}`);
+    const topics = (result.topics || []) as any[];
+    for (const t of topics) {
+      console.log(`  [${t.id}] ${t.title} — score: ${t.viralScore ?? "?"}`);
+    }
+  },
+};

package/src/cli/commands/restore.ts

@@ -0,0 +1,28 @@
+import type { CommandDef } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "restore",
+  description: "Restore a project from the trash stage",
+  usage: "autocrew restore <project>",
+  action: async (args, runner) => {
+    const project = args[0];
+    if (!project) {
+      console.error("Usage: autocrew restore <project>");
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = await runner.execute("autocrew_pipeline_ops", {
+      action: "restore",
+      project,
+    });
+
+    if (!result.ok) {
+      console.error(`Restore failed: ${result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(`Project restored to: ${result.restoredTo}`);
+  },
+};