lewxclaw 0.1.0

package/dist/index.js

@@ -0,0 +1,3282 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../providers/dist/registry.js
+var ProviderRegistry;
+var init_registry = __esm({
+  "../providers/dist/registry.js"() {
+    "use strict";
+    ProviderRegistry = class {
+      providers = /* @__PURE__ */ new Map();
+      register(provider) {
+        if (this.providers.has(provider.id)) {
+          throw new Error(`Provider with id "${provider.id}" is already registered`);
+        }
+        this.providers.set(provider.id, provider);
+      }
+      get(id) {
+        return this.providers.get(id);
+      }
+      getConfigured() {
+        return Array.from(this.providers.values()).filter((p) => p.isConfigured());
+      }
+      list() {
+        return Array.from(this.providers.values());
+      }
+    };
+  }
+});
+
+// ../providers/dist/config.js
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+function loadWxclawConfig() {
+  const projectConfig = join3(process.cwd(), ".wxclaw", "config.json");
+  const globalConfig = join3(homedir(), ".wxclaw", "config.json");
+  const configPath2 = existsSync2(projectConfig) ? projectConfig : globalConfig;
+  if (!existsSync2(configPath2))
+    return {};
+  return JSON.parse(readFileSync3(configPath2, "utf-8"));
+}
+function getProviderApiKey(providerId) {
+  const config = loadWxclawConfig();
+  const providers = config.providers;
+  return providers?.[providerId]?.apiKey ?? "";
+}
+var init_config = __esm({
+  "../providers/dist/config.js"() {
+    "use strict";
+  }
+});
+
+// ../providers/dist/openai-compatible.js
+function defaultClassifyError(error) {
+  if (error instanceof ProviderHttpError) {
+    if (error.status === 429)
+      return "rate-limited";
+    if (error.status === 401 || error.status === 403)
+      return "auth-failed";
+    if (error.status >= 500)
+      return "service-unavailable";
+  }
+  return null;
+}
+function createOpenAICompatibleProvider(config) {
+  const { id, name, baseUrl, getApiKey, defaultModel, classifyError } = config;
+  const classify = classifyError ?? defaultClassifyError;
+  function buildMessages(params) {
+    const msgs = [];
+    if (params.systemPrompt) {
+      msgs.push({ role: "system", content: params.systemPrompt });
+    }
+    for (const m2 of params.messages) {
+      msgs.push({ role: m2.role, content: m2.content });
+    }
+    return msgs;
+  }
+  async function fetchCompletion(params, stream) {
+    const apiKey = getApiKey();
+    const body = {
+      model: params.model ?? defaultModel,
+      messages: buildMessages(params),
+      stream
+    };
+    if (params.temperature !== void 0)
+      body.temperature = params.temperature;
+    if (params.maxTokens !== void 0)
+      body.max_tokens = params.maxTokens;
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new ProviderHttpError(response.status, `HTTP ${response.status}: ${response.statusText}`);
+    }
+    if (stream) {
+      return response.body;
+    }
+    return await response.json();
+  }
+  return {
+    id,
+    name,
+    isConfigured() {
+      return getApiKey().length > 0;
+    },
+    classifyError(error) {
+      return classify(error);
+    },
+    async chat(params) {
+      const data = await fetchCompletion(params, false);
+      const choice = data.choices[0];
+      return {
+        content: choice?.message.content ?? "",
+        model: data.model,
+        usage: data.usage ? {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        } : void 0
+      };
+    },
+    async *chatStream(params) {
+      const body = await fetchCompletion(params, true);
+      const reader = body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed === "data: [DONE]")
+              continue;
+            if (!trimmed.startsWith("data: "))
+              continue;
+            const json = trimmed.slice(6);
+            try {
+              const parsed = JSON.parse(json);
+              const delta = parsed.choices[0]?.delta?.content ?? "";
+              const isDone = parsed.choices[0]?.finish_reason != null;
+              yield { content: delta, done: isDone };
+            } catch {
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      yield { content: "", done: true };
+    }
+  };
+}
+var ProviderHttpError;
+var init_openai_compatible = __esm({
+  "../providers/dist/openai-compatible.js"() {
+    "use strict";
+    ProviderHttpError = class extends Error {
+      status;
+      constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ProviderHttpError";
+      }
+    };
+  }
+});
+
+// ../providers/dist/minimax.js
+function classifyMinimaxError(error) {
+  if (error instanceof ProviderHttpError) {
+    if (error.status === 429)
+      return "rate-limited";
+    if (error.status === 401 || error.status === 403)
+      return "auth-failed";
+    if (error.status >= 500)
+      return "service-unavailable";
+  }
+  return null;
+}
+function createMinimaxProvider() {
+  return createOpenAICompatibleProvider({
+    id: "minimax",
+    name: "MiniMax",
+    baseUrl: "https://api.minimax.chat/v1",
+    getApiKey: () => getProviderApiKey("minimax"),
+    defaultModel: "abab6.5s-chat",
+    classifyError: classifyMinimaxError
+  });
+}
+var init_minimax = __esm({
+  "../providers/dist/minimax.js"() {
+    "use strict";
+    init_openai_compatible();
+    init_config();
+    init_openai_compatible();
+  }
+});
+
+// ../providers/dist/deepseek.js
+function classifyDeepSeekError(error) {
+  if (error instanceof ProviderHttpError) {
+    if (error.status === 429)
+      return "rate-limited";
+    if (error.status === 401 || error.status === 403)
+      return "auth-failed";
+    if (error.status >= 500)
+      return "service-unavailable";
+  }
+  return null;
+}
+function createDeepSeekProvider() {
+  return createOpenAICompatibleProvider({
+    id: "deepseek",
+    name: "DeepSeek",
+    baseUrl: "https://api.deepseek.com",
+    getApiKey: () => getProviderApiKey("deepseek"),
+    defaultModel: "deepseek-chat",
+    classifyError: classifyDeepSeekError
+  });
+}
+var init_deepseek = __esm({
+  "../providers/dist/deepseek.js"() {
+    "use strict";
+    init_openai_compatible();
+    init_config();
+    init_openai_compatible();
+  }
+});
+
+// ../providers/dist/failover.js
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function executeWithFailover(stepName, fn, registry, config) {
+  const stepOrder = config.stepProviders[stepName] ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const orderedIds = [];
+  for (const id of stepOrder) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      orderedIds.push(id);
+    }
+  }
+  for (const id of config.globalFallbackOrder) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      orderedIds.push(id);
+    }
+  }
+  const errors = [];
+  for (const id of orderedIds) {
+    const provider = registry.get(id);
+    if (!provider || !provider.isConfigured())
+      continue;
+    try {
+      return await fn(provider);
+    } catch (err) {
+      const kind = provider.classifyError(err);
+      if (kind === "auth-failed") {
+        throw err;
+      }
+      if (kind === "rate-limited") {
+        await sleep(config.rateLimitBackoffMs);
+        try {
+          return await fn(provider);
+        } catch (retryErr) {
+          errors.push({ providerId: id, error: retryErr });
+          continue;
+        }
+      }
+      errors.push({ providerId: id, error: err });
+    }
+  }
+  throw new AllProvidersFailedError(stepName, errors);
+}
+var AllProvidersFailedError;
+var init_failover = __esm({
+  "../providers/dist/failover.js"() {
+    "use strict";
+    AllProvidersFailedError = class extends Error {
+      stepName;
+      errors;
+      constructor(stepName, errors) {
+        super(`All providers failed for step "${stepName}": ${errors.map((e) => e.providerId).join(", ")}`);
+        this.stepName = stepName;
+        this.errors = errors;
+        this.name = "AllProvidersFailedError";
+      }
+    };
+  }
+});
+
+// ../providers/dist/minimax-image.js
+function createMinimaxImageProvider() {
+  return {
+    id: "minimax-image",
+    name: "MiniMax Image",
+    isConfigured() {
+      return Boolean(getProviderApiKey("minimax"));
+    },
+    async generate(prompt, options) {
+      const apiKey = getProviderApiKey("minimax");
+      if (apiKey) {
+        try {
+          const width = options?.width ?? 1024;
+          const height = options?.height ?? 1024;
+          const response = await fetch("https://api.minimax.chat/v1/image_generation", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+              model: "image-01",
+              prompt,
+              width,
+              height
+            }),
+            signal: AbortSignal.timeout(6e4)
+          });
+          if (response.ok) {
+            const data = await response.json();
+            const imageUrl = data?.data?.url;
+            if (imageUrl) {
+              const imgResponse = await fetch(imageUrl, {
+                signal: AbortSignal.timeout(3e4)
+              });
+              if (imgResponse.ok) {
+                const arrayBuffer = await imgResponse.arrayBuffer();
+                const buffer2 = Buffer.from(arrayBuffer);
+                return {
+                  buffer: buffer2,
+                  mimeType: "image/png",
+                  width,
+                  height
+                };
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      const buffer = Buffer.from(PLACEHOLDER_PNG_BASE64, "base64");
+      return {
+        buffer,
+        mimeType: "image/png",
+        width: 1,
+        height: 1
+      };
+    }
+  };
+}
+var PLACEHOLDER_PNG_BASE64;
+var init_minimax_image = __esm({
+  "../providers/dist/minimax-image.js"() {
+    "use strict";
+    init_config();
+    PLACEHOLDER_PNG_BASE64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+  }
+});
+
+// ../providers/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  AllProvidersFailedError: () => AllProvidersFailedError,
+  ProviderHttpError: () => ProviderHttpError,
+  ProviderRegistry: () => ProviderRegistry,
+  VERSION: () => VERSION,
+  createDeepSeekProvider: () => createDeepSeekProvider,
+  createMinimaxImageProvider: () => createMinimaxImageProvider,
+  createMinimaxProvider: () => createMinimaxProvider,
+  createOpenAICompatibleProvider: () => createOpenAICompatibleProvider,
+  executeWithFailover: () => executeWithFailover,
+  getProviderApiKey: () => getProviderApiKey,
+  loadWxclawConfig: () => loadWxclawConfig
+});
+var VERSION;
+var init_dist = __esm({
+  "../providers/dist/index.js"() {
+    "use strict";
+    init_registry();
+    init_config();
+    init_openai_compatible();
+    init_minimax();
+    init_deepseek();
+    init_failover();
+    init_minimax_image();
+    VERSION = "0.1.0";
+  }
+});
+
+// src/index.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/commands/create.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+
+// ../core/dist/logger.js
+var Logger = class {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  log(level, message, context) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      context: { ...context, logger: this.name }
+    };
+    if (process.env.NODE_ENV === "production") {
+      const output = level === "error" ? console.error : console.log;
+      output(JSON.stringify(entry));
+    } else {
+      const prefix = `[${entry.timestamp}] [${level.toUpperCase()}] [${this.name}]`;
+      if (level === "error") {
+        console.error(prefix, message, context ?? "");
+      } else {
+        console.log(prefix, message, context ?? "");
+      }
+    }
+  }
+};
+function createLogger(name) {
+  return new Logger(name);
+}
+
+// ../core/dist/pipeline.js
+var logger = createLogger("pipeline");
+var DEFAULT_OPTIONS = {
+  defaultTimeout: 12e4
+  // 120s
+};
+var PipelineEngine = class {
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  async run(steps, context) {
+    const pipelineStart = Date.now();
+    context.status = "running";
+    logger.info("Pipeline started", {
+      pipelineId: context.pipelineId,
+      steps: steps.length
+    });
+    for (const step of steps) {
+      const startedAt = /* @__PURE__ */ new Date();
+      if (step.gate === "manual-approval") {
+        context.status = "paused";
+        const entry2 = {
+          stepId: step.id,
+          stepType: step.type,
+          status: "skipped",
+          startedAt,
+          duration: 0
+        };
+        context.logs.push(entry2);
+        return context;
+      }
+      logger.info("Step started", { stepId: step.id, stepType: step.type });
+      let result;
+      let timedOut = false;
+      try {
+        result = await Promise.race([
+          step.execute(context),
+          new Promise((_2, reject) => setTimeout(() => reject(new Error("Step timeout")), this.options.defaultTimeout))
+        ]);
+      } catch (err) {
+        const isTimeout = err instanceof Error && err.message === "Step timeout";
+        timedOut = isTimeout;
+        const completedAt2 = /* @__PURE__ */ new Date();
+        const duration2 = completedAt2.getTime() - startedAt.getTime();
+        const entry2 = {
+          stepId: step.id,
+          stepType: step.type,
+          status: isTimeout ? "timeout" : "failed",
+          startedAt,
+          completedAt: completedAt2,
+          duration: duration2,
+          error: err instanceof Error ? err.message : String(err)
+        };
+        context.logs.push(entry2);
+        context.status = "failed";
+        if (isTimeout) {
+          logger.warn("Step timeout", {
+            stepId: step.id,
+            timeout: this.options.defaultTimeout
+          });
+        } else {
+          logger.error("Step failed", {
+            stepId: step.id,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+        logger.error("Pipeline failed", {
+          pipelineId: context.pipelineId,
+          failedStep: step.id
+        });
+        return context;
+      }
+      const completedAt = /* @__PURE__ */ new Date();
+      const duration = completedAt.getTime() - startedAt.getTime();
+      const entry = {
+        stepId: step.id,
+        stepType: step.type,
+        status: result.success ? "success" : "failed",
+        startedAt,
+        completedAt,
+        duration,
+        error: result.error
+      };
+      context.logs.push(entry);
+      if (!result.success && !timedOut) {
+        logger.error("Step failed", {
+          stepId: step.id,
+          error: result.error
+        });
+        logger.error("Pipeline failed", {
+          pipelineId: context.pipelineId,
+          failedStep: step.id
+        });
+        context.status = "failed";
+        return context;
+      }
+      logger.info("Step completed", { stepId: step.id, duration });
+    }
+    const totalDuration = Date.now() - pipelineStart;
+    context.status = "completed";
+    logger.info("Pipeline completed", {
+      pipelineId: context.pipelineId,
+      totalDuration
+    });
+    return context;
+  }
+};
+
+// ../core/dist/steps/topic-selection.js
+var TopicSelectionStep = class {
+  id;
+  type = "topic-discovery";
+  gate = "auto";
+  llm;
+  constructor(llm, id = "topic-selection") {
+    this.llm = llm;
+    this.id = id;
+  }
+  async execute(context) {
+    const start = Date.now();
+    try {
+      const existingTopic = context.data.topic?.title;
+      const prompt = existingTopic ? `\u6839\u636E\u4EE5\u4E0B\u4E3B\u9898\u751F\u6210\u4E00\u4E2A\u516C\u4F17\u53F7\u6587\u7AE0\u9009\u9898\u89D2\u5EA6\uFF1A${existingTopic}` : "\u4E3A\u516C\u4F17\u53F7\u751F\u6210\u4E00\u4E2A\u6709\u5438\u5F15\u529B\u7684\u6587\u7AE0\u9009\u9898\uFF0C\u5305\u542B\u4E3B\u9898\u3001\u89D2\u5EA6\u548C\u5173\u952E\u8BCD";
+      const systemPrompt = [
+        context.config.soulPrompt,
+        context.config.agentsRules
+      ].filter(Boolean).join("\n\n---\n\n");
+      const response = await this.llm.chat({
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: prompt }
+        ],
+        temperature: 0.7
+      });
+      const content = response.content;
+      let title = existingTopic ?? "";
+      let angle = "";
+      const keywords = [];
+      const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) ?? content.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        try {
+          const parsed = JSON.parse(jsonMatch[1] ?? jsonMatch[0]);
+          title = parsed.title ?? title;
+          angle = parsed.angle ?? angle;
+          if (Array.isArray(parsed.keywords)) {
+            keywords.push(...parsed.keywords);
+          }
+        } catch {
+        }
+      }
+      if (!angle) {
+        angle = content.trim();
+      }
+      if (!title) {
+        title = "\u5F85\u786E\u5B9A\u4E3B\u9898";
+      }
+      context.data.topic = { title, angle, keywords };
+      return {
+        success: true,
+        data: context.data.topic,
+        duration: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        duration: Date.now() - start
+      };
+    }
+  }
+};
+
+// ../core/dist/steps/outline.js
+var OutlineStep = class {
+  id;
+  type = "outline";
+  gate = "auto";
+  llm;
+  constructor(llm, id = "outline") {
+    this.llm = llm;
+    this.id = id;
+  }
+  async execute(context) {
+    const start = Date.now();
+    try {
+      const topic = context.data.topic;
+      if (!topic) {
+        return {
+          success: false,
+          error: "\u7F3A\u5C11\u9009\u9898\u6570\u636E\uFF0C\u8BF7\u5148\u6267\u884C topic-discovery \u6B65\u9AA4",
+          duration: Date.now() - start
+        };
+      }
+      const topicDescription = [
+        `\u4E3B\u9898\uFF1A${topic.title}`,
+        topic.angle ? `\u89D2\u5EA6\uFF1A${topic.angle}` : null,
+        topic.keywords.length > 0 ? `\u5173\u952E\u8BCD\uFF1A${topic.keywords.join("\u3001")}` : null
+      ].filter(Boolean).join("\n");
+      const prompt = `\u4E3A\u4EE5\u4E0B\u4E3B\u9898\u751F\u6210\u516C\u4F17\u53F7\u6587\u7AE0\u5927\u7EB2\uFF0C\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\uFF1A
+
+${topicDescription}
+
+\u8BF7\u4E25\u683C\u6309\u7167\u4EE5\u4E0B JSON \u683C\u5F0F\u8F93\u51FA\uFF0C\u4E0D\u8981\u5305\u542B\u5176\u4ED6\u5185\u5BB9\uFF1A
+{
+  "title": "\u6587\u7AE0\u6807\u9898",
+  "sections": [
+    {
+      "heading": "\u5C0F\u8282\u6807\u9898",
+      "points": ["\u8981\u70B91", "\u8981\u70B92"]
+    }
+  ]
+}`;
+      const systemPrompt = [
+        context.config.soulPrompt,
+        context.config.agentsRules
+      ].filter(Boolean).join("\n\n---\n\n");
+      const response = await this.llm.chat({
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: prompt }
+        ],
+        temperature: 0.5
+      });
+      const content = response.content;
+      let parsed = {};
+      const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) ?? content.match(/```\s*([\s\S]*?)\s*```/);
+      try {
+        if (jsonMatch?.[1]) {
+          parsed = JSON.parse(jsonMatch[1]);
+        } else {
+          const jsonStart = content.indexOf("{");
+          const jsonEnd = content.lastIndexOf("}");
+          if (jsonStart !== -1 && jsonEnd !== -1) {
+            parsed = JSON.parse(content.slice(jsonStart, jsonEnd + 1));
+          }
+        }
+      } catch {
+        parsed = {
+          title: topic.title,
+          sections: [
+            {
+              heading: "\u4E3B\u4F53\u5185\u5BB9",
+              points: [content.trim()]
+            }
+          ]
+        };
+      }
+      const outline = {
+        title: parsed.title ?? topic.title,
+        sections: (parsed.sections ?? []).map((s) => ({
+          heading: s.heading ?? "",
+          points: Array.isArray(s.points) ? s.points : []
+        }))
+      };
+      if (outline.sections.length === 0) {
+        outline.sections = [
+          { heading: "\u4E3B\u4F53\u5185\u5BB9", points: ["\u5F85\u8865\u5145"] }
+        ];
+      }
+      context.data.outline = outline;
+      return {
+        success: true,
+        data: outline,
+        duration: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        duration: Date.now() - start
+      };
+    }
+  }
+};
+
+// ../core/dist/steps/writing.js
+var WritingStep = class {
+  id;
+  type = "writing";
+  gate = "auto";
+  llm;
+  constructor(llm, id = "writing") {
+    this.llm = llm;
+    this.id = id;
+  }
+  async execute(context) {
+    const start = Date.now();
+    try {
+      const outline = context.data.outline;
+      if (!outline) {
+        return {
+          success: false,
+          error: "\u7F3A\u5C11\u5927\u7EB2\u6570\u636E\uFF0C\u8BF7\u5148\u6267\u884C outline \u6B65\u9AA4",
+          duration: Date.now() - start
+        };
+      }
+      const outlineText = [
+        `\u6807\u9898\uFF1A${outline.title}`,
+        "",
+        ...outline.sections.map((section) => [
+          `## ${section.heading}`,
+          ...section.points.map((p) => `- ${p}`)
+        ].join("\n"))
+      ].join("\n");
+      const prompt = `\u6839\u636E\u4EE5\u4E0B\u5927\u7EB2\u64B0\u5199\u4E00\u7BC7\u516C\u4F17\u53F7\u6587\u7AE0\uFF0C\u4F7F\u7528 Markdown \u683C\u5F0F\uFF1A
+
+${outlineText}`;
+      const systemPrompt = [
+        context.config.soulPrompt,
+        context.config.agentsRules,
+        context.config.stylePrompt
+      ].filter(Boolean).join("\n\n---\n\n");
+      const response = await this.llm.chat({
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: prompt }
+        ],
+        temperature: 0.7,
+        maxTokens: 4e3
+      });
+      const content = response.content.trim();
+      const chineseChars = (content.match(/[\u4e00-\u9fa5]/g) ?? []).length;
+      const englishWords = (content.match(/[a-zA-Z]+/g) ?? []).length;
+      const wordCount = chineseChars + englishWords;
+      const titleMatch = content.match(/^#\s+(.+)$/m);
+      const title = titleMatch?.[1]?.trim() ?? outline.title;
+      context.data.article = {
+        title,
+        content,
+        wordCount
+      };
+      return {
+        success: true,
+        data: context.data.article,
+        duration: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        duration: Date.now() - start
+      };
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/marked@17.0.6/node_modules/marked/lib/marked.esm.js
+function M() {
+  return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
+}
+var O = M();
+function G(u3) {
+  O = u3;
+}
+var _ = { exec: () => null };
+function k(u3, e = "") {
+  let t = typeof u3 == "string" ? u3 : u3.source, n = { replace: (r, i) => {
+    let s = typeof i == "string" ? i : i.source;
+    return s = s.replace(m.caret, "$1"), t = t.replace(r, s), n;
+  }, getRegex: () => new RegExp(t, e) };
+  return n;
+}
+var be = (() => {
+  try {
+    return !!new RegExp("(?<=1)(?<!1)");
+  } catch {
+    return false;
+  }
+})();
+var m = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (u3) => new RegExp(`^( {0,3}${u3})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`), hrRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), fencesBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}(?:\`\`\`|~~~)`), headingBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}#`), htmlBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}<(?:[a-z].*>|!--)`, "i"), blockquoteBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}>`) };
+var Re = /^(?:[ \t]*(?:\n|$))+/;
+var Oe = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+var Te = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var C = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var we = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var Q = / {0,3}(?:[*+-]|\d{1,9}[.)])/;
+var se = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+var ie = k(se).replace(/bull/g, Q).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+var ye = k(se).replace(/bull/g, Q).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+var j = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+var Pe = /^[^\n]+/;
+var F = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
+var Se = k(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", F).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var $e = k(/^(bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, Q).getRegex();
+var v = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var U = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var _e = k("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))", "i").replace("comment", U).replace("tag", v).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var oe = k(j).replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex();
+var Le = k(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", oe).getRegex();
+var K = { blockquote: Le, code: Oe, def: Se, fences: Te, heading: we, hr: C, html: _e, lheading: ie, list: $e, newline: Re, paragraph: oe, table: _, text: Pe };
+var ne = k("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex();
+var Me = { ...K, lheading: ye, table: ne, paragraph: k(j).replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", ne).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex() };
+var ze = { ...K, html: k(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", U).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: _, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: k(j).replace("hr", C).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", ie).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() };
+var Ee = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var Ie = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var ae = /^( {2,}|\\)\n(?!\s*$)/;
+var Ae = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var z = /[\p{P}\p{S}]/u;
+var H = /[\s\p{P}\p{S}]/u;
+var W = /[^\s\p{P}\p{S}]/u;
+var Ce = k(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, H).getRegex();
+var le = /(?!~)[\p{P}\p{S}]/u;
+var Be = /(?!~)[\s\p{P}\p{S}]/u;
+var De = /(?:[^\s\p{P}\p{S}]|~)/u;
+var qe = k(/link|precode-code|html/, "g").replace("link", /\[(?:[^\[\]`]|(?<a>`+)[^`]+\k<a>(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", be ? "(?<!`)()" : "(^^|[^`])").replace("code", /(?<b>`+)[^`]+\k<b>(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex();
+var ue = /^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/;
+var ve = k(ue, "u").replace(/punct/g, z).getRegex();
+var He = k(ue, "u").replace(/punct/g, le).getRegex();
+var pe = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
+var Ze = k(pe, "gu").replace(/notPunctSpace/g, W).replace(/punctSpace/g, H).replace(/punct/g, z).getRegex();
+var Ge = k(pe, "gu").replace(/notPunctSpace/g, De).replace(/punctSpace/g, Be).replace(/punct/g, le).getRegex();
+var Ne = k("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, W).replace(/punctSpace/g, H).replace(/punct/g, z).getRegex();
+var Qe = k(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, z).getRegex();
+var je = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)";
+var Fe = k(je, "gu").replace(/notPunctSpace/g, W).replace(/punctSpace/g, H).replace(/punct/g, z).getRegex();
+var Ue = k(/\\(punct)/, "gu").replace(/punct/g, z).getRegex();
+var Ke = k(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var We = k(U).replace("(?:-->|$)", "-->").getRegex();
+var Xe = k("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", We).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var q = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/;
+var Je = k(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", q).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var ce = k(/^!?\[(label)\]\[(ref)\]/).replace("label", q).replace("ref", F).getRegex();
+var he = k(/^!?\[(ref)\](?:\[\])?/).replace("ref", F).getRegex();
+var Ve = k("reflink|nolink(?!\\()", "g").replace("reflink", ce).replace("nolink", he).getRegex();
+var re = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;
+var X = { _backpedal: _, anyPunctuation: Ue, autolink: Ke, blockSkip: qe, br: ae, code: Ie, del: _, delLDelim: _, delRDelim: _, emStrongLDelim: ve, emStrongRDelimAst: Ze, emStrongRDelimUnd: Ne, escape: Ee, link: Je, nolink: he, punctuation: Ce, reflink: ce, reflinkSearch: Ve, tag: Xe, text: Ae, url: _ };
+var Ye = { ...X, link: k(/^!?\[(label)\]\((.*?)\)/).replace("label", q).getRegex(), reflink: k(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", q).getRegex() };
+var N = { ...X, emStrongRDelimAst: Ge, emStrongLDelim: He, delLDelim: Qe, delRDelim: Fe, url: k(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", re).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: k(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/).replace("protocol", re).getRegex() };
+var et = { ...N, br: k(ae).replace("{2,}", "*").getRegex(), text: k(N.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() };
+var B = { normal: K, gfm: Me, pedantic: ze };
+var E = { normal: X, gfm: N, breaks: et, pedantic: Ye };
+var tt = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var ke = (u3) => tt[u3];
+function T(u3, e) {
+  if (e) {
+    if (m.escapeTest.test(u3)) return u3.replace(m.escapeReplace, ke);
+  } else if (m.escapeTestNoEncode.test(u3)) return u3.replace(m.escapeReplaceNoEncode, ke);
+  return u3;
+}
+function J(u3) {
+  try {
+    u3 = encodeURI(u3).replace(m.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return u3;
+}
+function V(u3, e) {
+  let t = u3.replace(m.findPipe, (i, s, a) => {
+    let o = false, l = s;
+    for (; --l >= 0 && a[l] === "\\"; ) o = !o;
+    return o ? "|" : " |";
+  }), n = t.split(m.splitPipe), r = 0;
+  if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), e) if (n.length > e) n.splice(e);
+  else for (; n.length < e; ) n.push("");
+  for (; r < n.length; r++) n[r] = n[r].trim().replace(m.slashPipe, "|");
+  return n;
+}
+function I(u3, e, t) {
+  let n = u3.length;
+  if (n === 0) return "";
+  let r = 0;
+  for (; r < n; ) {
+    let i = u3.charAt(n - r - 1);
+    if (i === e && !t) r++;
+    else if (i !== e && t) r++;
+    else break;
+  }
+  return u3.slice(0, n - r);
+}
+function de(u3, e) {
+  if (u3.indexOf(e[1]) === -1) return -1;
+  let t = 0;
+  for (let n = 0; n < u3.length; n++) if (u3[n] === "\\") n++;
+  else if (u3[n] === e[0]) t++;
+  else if (u3[n] === e[1] && (t--, t < 0)) return n;
+  return t > 0 ? -2 : -1;
+}
+function ge(u3, e = 0) {
+  let t = e, n = "";
+  for (let r of u3) if (r === "	") {
+    let i = 4 - t % 4;
+    n += " ".repeat(i), t += i;
+  } else n += r, t++;
+  return n;
+}
+function fe(u3, e, t, n, r) {
+  let i = e.href, s = e.title || null, a = u3[1].replace(r.other.outputLinkReplace, "$1");
+  n.state.inLink = true;
+  let o = { type: u3[0].charAt(0) === "!" ? "image" : "link", raw: t, href: i, title: s, text: a, tokens: n.inlineTokens(a) };
+  return n.state.inLink = false, o;
+}
+function nt(u3, e, t) {
+  let n = u3.match(t.other.indentCodeCompensation);
+  if (n === null) return e;
+  let r = n[1];
+  return e.split(`
+`).map((i) => {
+    let s = i.match(t.other.beginningSpace);
+    if (s === null) return i;
+    let [a] = s;
+    return a.length >= r.length ? i.slice(r.length) : i;
+  }).join(`
+`);
+}
+var w = class {
+  options;
+  rules;
+  lexer;
+  constructor(e) {
+    this.options = e || O;
+  }
+  space(e) {
+    let t = this.rules.block.newline.exec(e);
+    if (t && t[0].length > 0) return { type: "space", raw: t[0] };
+  }
+  code(e) {
+    let t = this.rules.block.code.exec(e);
+    if (t) {
+      let n = t[0].replace(this.rules.other.codeRemoveIndent, "");
+      return { type: "code", raw: t[0], codeBlockStyle: "indented", text: this.options.pedantic ? n : I(n, `
+`) };
+    }
+  }
+  fences(e) {
+    let t = this.rules.block.fences.exec(e);
+    if (t) {
+      let n = t[0], r = nt(n, t[3] || "", this.rules);
+      return { type: "code", raw: n, lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], text: r };
+    }
+  }
+  heading(e) {
+    let t = this.rules.block.heading.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (this.rules.other.endingHash.test(n)) {
+        let r = I(n, "#");
+        (this.options.pedantic || !r || this.rules.other.endingSpaceChar.test(r)) && (n = r.trim());
+      }
+      return { type: "heading", raw: t[0], depth: t[1].length, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  hr(e) {
+    let t = this.rules.block.hr.exec(e);
+    if (t) return { type: "hr", raw: I(t[0], `
+`) };
+  }
+  blockquote(e) {
+    let t = this.rules.block.blockquote.exec(e);
+    if (t) {
+      let n = I(t[0], `
+`).split(`
+`), r = "", i = "", s = [];
+      for (; n.length > 0; ) {
+        let a = false, o = [], l;
+        for (l = 0; l < n.length; l++) if (this.rules.other.blockquoteStart.test(n[l])) o.push(n[l]), a = true;
+        else if (!a) o.push(n[l]);
+        else break;
+        n = n.slice(l);
+        let p = o.join(`
+`), c = p.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        r = r ? `${r}
+${p}` : p, i = i ? `${i}
+${c}` : c;
+        let d = this.lexer.state.top;
+        if (this.lexer.state.top = true, this.lexer.blockTokens(c, s, true), this.lexer.state.top = d, n.length === 0) break;
+        let h = s.at(-1);
+        if (h?.type === "code") break;
+        if (h?.type === "blockquote") {
+          let R = h, f = R.raw + `
+` + n.join(`
+`), S = this.blockquote(f);
+          s[s.length - 1] = S, r = r.substring(0, r.length - R.raw.length) + S.raw, i = i.substring(0, i.length - R.text.length) + S.text;
+          break;
+        } else if (h?.type === "list") {
+          let R = h, f = R.raw + `
+` + n.join(`
+`), S = this.list(f);
+          s[s.length - 1] = S, r = r.substring(0, r.length - h.raw.length) + S.raw, i = i.substring(0, i.length - R.raw.length) + S.raw, n = f.substring(s.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return { type: "blockquote", raw: r, tokens: s, text: i };
+    }
+  }
+  list(e) {
+    let t = this.rules.block.list.exec(e);
+    if (t) {
+      let n = t[1].trim(), r = n.length > 1, i = { type: "list", raw: "", ordered: r, start: r ? +n.slice(0, -1) : "", loose: false, items: [] };
+      n = r ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = r ? n : "[*+-]");
+      let s = this.rules.other.listItemRegex(n), a = false;
+      for (; e; ) {
+        let l = false, p = "", c = "";
+        if (!(t = s.exec(e)) || this.rules.block.hr.test(e)) break;
+        p = t[0], e = e.substring(p.length);
+        let d = ge(t[2].split(`
+`, 1)[0], t[1].length), h = e.split(`
+`, 1)[0], R = !d.trim(), f = 0;
+        if (this.options.pedantic ? (f = 2, c = d.trimStart()) : R ? f = t[1].length + 1 : (f = d.search(this.rules.other.nonSpaceChar), f = f > 4 ? 1 : f, c = d.slice(f), f += t[1].length), R && this.rules.other.blankLine.test(h) && (p += h + `
+`, e = e.substring(h.length + 1), l = true), !l) {
+          let S = this.rules.other.nextBulletRegex(f), Y = this.rules.other.hrRegex(f), ee = this.rules.other.fencesBeginRegex(f), te = this.rules.other.headingBeginRegex(f), me = this.rules.other.htmlBeginRegex(f), xe = this.rules.other.blockquoteBeginRegex(f);
+          for (; e; ) {
+            let Z = e.split(`
+`, 1)[0], A;
+            if (h = Z, this.options.pedantic ? (h = h.replace(this.rules.other.listReplaceNesting, "  "), A = h) : A = h.replace(this.rules.other.tabCharGlobal, "    "), ee.test(h) || te.test(h) || me.test(h) || xe.test(h) || S.test(h) || Y.test(h)) break;
+            if (A.search(this.rules.other.nonSpaceChar) >= f || !h.trim()) c += `
+` + A.slice(f);
+            else {
+              if (R || d.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || ee.test(d) || te.test(d) || Y.test(d)) break;
+              c += `
+` + h;
+            }
+            R = !h.trim(), p += Z + `
+`, e = e.substring(Z.length + 1), d = A.slice(f);
+          }
+        }
+        i.loose || (a ? i.loose = true : this.rules.other.doubleBlankLine.test(p) && (a = true)), i.items.push({ type: "list_item", raw: p, task: !!this.options.gfm && this.rules.other.listIsTask.test(c), loose: false, text: c, tokens: [] }), i.raw += p;
+      }
+      let o = i.items.at(-1);
+      if (o) o.raw = o.raw.trimEnd(), o.text = o.text.trimEnd();
+      else return;
+      i.raw = i.raw.trimEnd();
+      for (let l of i.items) {
+        if (this.lexer.state.top = false, l.tokens = this.lexer.blockTokens(l.text, []), l.task) {
+          if (l.text = l.text.replace(this.rules.other.listReplaceTask, ""), l.tokens[0]?.type === "text" || l.tokens[0]?.type === "paragraph") {
+            l.tokens[0].raw = l.tokens[0].raw.replace(this.rules.other.listReplaceTask, ""), l.tokens[0].text = l.tokens[0].text.replace(this.rules.other.listReplaceTask, "");
+            for (let c = this.lexer.inlineQueue.length - 1; c >= 0; c--) if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[c].src)) {
+              this.lexer.inlineQueue[c].src = this.lexer.inlineQueue[c].src.replace(this.rules.other.listReplaceTask, "");
+              break;
+            }
+          }
+          let p = this.rules.other.listTaskCheckbox.exec(l.raw);
+          if (p) {
+            let c = { type: "checkbox", raw: p[0] + " ", checked: p[0] !== "[ ]" };
+            l.checked = c.checked, i.loose ? l.tokens[0] && ["paragraph", "text"].includes(l.tokens[0].type) && "tokens" in l.tokens[0] && l.tokens[0].tokens ? (l.tokens[0].raw = c.raw + l.tokens[0].raw, l.tokens[0].text = c.raw + l.tokens[0].text, l.tokens[0].tokens.unshift(c)) : l.tokens.unshift({ type: "paragraph", raw: c.raw, text: c.raw, tokens: [c] }) : l.tokens.unshift(c);
+          }
+        }
+        if (!i.loose) {
+          let p = l.tokens.filter((d) => d.type === "space"), c = p.length > 0 && p.some((d) => this.rules.other.anyLine.test(d.raw));
+          i.loose = c;
+        }
+      }
+      if (i.loose) for (let l of i.items) {
+        l.loose = true;
+        for (let p of l.tokens) p.type === "text" && (p.type = "paragraph");
+      }
+      return i;
+    }
+  }
+  html(e) {
+    let t = this.rules.block.html.exec(e);
+    if (t) return { type: "html", block: true, raw: t[0], pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", text: t[0] };
+  }
+  def(e) {
+    let t = this.rules.block.def.exec(e);
+    if (t) {
+      let n = t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), r = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", i = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3];
+      return { type: "def", tag: n, raw: t[0], href: r, title: i };
+    }
+  }
+  table(e) {
+    let t = this.rules.block.table.exec(e);
+    if (!t || !this.rules.other.tableDelimiter.test(t[2])) return;
+    let n = V(t[1]), r = t[2].replace(this.rules.other.tableAlignChars, "").split("|"), i = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], s = { type: "table", raw: t[0], header: [], align: [], rows: [] };
+    if (n.length === r.length) {
+      for (let a of r) this.rules.other.tableAlignRight.test(a) ? s.align.push("right") : this.rules.other.tableAlignCenter.test(a) ? s.align.push("center") : this.rules.other.tableAlignLeft.test(a) ? s.align.push("left") : s.align.push(null);
+      for (let a = 0; a < n.length; a++) s.header.push({ text: n[a], tokens: this.lexer.inline(n[a]), header: true, align: s.align[a] });
+      for (let a of i) s.rows.push(V(a, s.header.length).map((o, l) => ({ text: o, tokens: this.lexer.inline(o), header: false, align: s.align[l] })));
+      return s;
+    }
+  }
+  lheading(e) {
+    let t = this.rules.block.lheading.exec(e);
+    if (t) {
+      let n = t[1].trim();
+      return { type: "heading", raw: t[0], depth: t[2].charAt(0) === "=" ? 1 : 2, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  paragraph(e) {
+    let t = this.rules.block.paragraph.exec(e);
+    if (t) {
+      let n = t[1].charAt(t[1].length - 1) === `
+` ? t[1].slice(0, -1) : t[1];
+      return { type: "paragraph", raw: t[0], text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  text(e) {
+    let t = this.rules.block.text.exec(e);
+    if (t) return { type: "text", raw: t[0], text: t[0], tokens: this.lexer.inline(t[0]) };
+  }
+  escape(e) {
+    let t = this.rules.inline.escape.exec(e);
+    if (t) return { type: "escape", raw: t[0], text: t[1] };
+  }
+  tag(e) {
+    let t = this.rules.inline.tag.exec(e);
+    if (t) return !this.lexer.state.inLink && this.rules.other.startATag.test(t[0]) ? this.lexer.state.inLink = true : this.lexer.state.inLink && this.rules.other.endATag.test(t[0]) && (this.lexer.state.inLink = false), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t[0]) ? this.lexer.state.inRawBlock = true : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t[0]) && (this.lexer.state.inRawBlock = false), { type: "html", raw: t[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: false, text: t[0] };
+  }
+  link(e) {
+    let t = this.rules.inline.link.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n)) {
+        if (!this.rules.other.endAngleBracket.test(n)) return;
+        let s = I(n.slice(0, -1), "\\");
+        if ((n.length - s.length) % 2 === 0) return;
+      } else {
+        let s = de(t[2], "()");
+        if (s === -2) return;
+        if (s > -1) {
+          let o = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + s;
+          t[2] = t[2].substring(0, s), t[0] = t[0].substring(0, o).trim(), t[3] = "";
+        }
+      }
+      let r = t[2], i = "";
+      if (this.options.pedantic) {
+        let s = this.rules.other.pedanticHrefTitle.exec(r);
+        s && (r = s[1], i = s[3]);
+      } else i = t[3] ? t[3].slice(1, -1) : "";
+      return r = r.trim(), this.rules.other.startAngleBracket.test(r) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n) ? r = r.slice(1) : r = r.slice(1, -1)), fe(t, { href: r && r.replace(this.rules.inline.anyPunctuation, "$1"), title: i && i.replace(this.rules.inline.anyPunctuation, "$1") }, t[0], this.lexer, this.rules);
+    }
+  }
+  reflink(e, t) {
+    let n;
+    if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) {
+      let r = (n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " "), i = t[r.toLowerCase()];
+      if (!i) {
+        let s = n[0].charAt(0);
+        return { type: "text", raw: s, text: s };
+      }
+      return fe(n, i, n[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(e, t, n = "") {
+    let r = this.rules.inline.emStrongLDelim.exec(e);
+    if (!r || !r[1] && !r[2] && !r[3] && !r[4] || r[4] && n.match(this.rules.other.unicodeAlphaNumeric)) return;
+    if (!(r[1] || r[3] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let s = [...r[0]].length - 1, a, o, l = s, p = 0, c = r[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (c.lastIndex = 0, t = t.slice(-1 * e.length + s); (r = c.exec(t)) !== null; ) {
+        if (a = r[1] || r[2] || r[3] || r[4] || r[5] || r[6], !a) continue;
+        if (o = [...a].length, r[3] || r[4]) {
+          l += o;
+          continue;
+        } else if ((r[5] || r[6]) && s % 3 && !((s + o) % 3)) {
+          p += o;
+          continue;
+        }
+        if (l -= o, l > 0) continue;
+        o = Math.min(o, o + l + p);
+        let d = [...r[0]][0].length, h = e.slice(0, s + r.index + d + o);
+        if (Math.min(s, o) % 2) {
+          let f = h.slice(1, -1);
+          return { type: "em", raw: h, text: f, tokens: this.lexer.inlineTokens(f) };
+        }
+        let R = h.slice(2, -2);
+        return { type: "strong", raw: h, text: R, tokens: this.lexer.inlineTokens(R) };
+      }
+    }
+  }
+  codespan(e) {
+    let t = this.rules.inline.code.exec(e);
+    if (t) {
+      let n = t[2].replace(this.rules.other.newLineCharGlobal, " "), r = this.rules.other.nonSpaceChar.test(n), i = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n);
+      return r && i && (n = n.substring(1, n.length - 1)), { type: "codespan", raw: t[0], text: n };
+    }
+  }
+  br(e) {
+    let t = this.rules.inline.br.exec(e);
+    if (t) return { type: "br", raw: t[0] };
+  }
+  del(e, t, n = "") {
+    let r = this.rules.inline.delLDelim.exec(e);
+    if (!r) return;
+    if (!(r[1] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let s = [...r[0]].length - 1, a, o, l = s, p = this.rules.inline.delRDelim;
+      for (p.lastIndex = 0, t = t.slice(-1 * e.length + s); (r = p.exec(t)) !== null; ) {
+        if (a = r[1] || r[2] || r[3] || r[4] || r[5] || r[6], !a || (o = [...a].length, o !== s)) continue;
+        if (r[3] || r[4]) {
+          l += o;
+          continue;
+        }
+        if (l -= o, l > 0) continue;
+        o = Math.min(o, o + l);
+        let c = [...r[0]][0].length, d = e.slice(0, s + r.index + c + o), h = d.slice(s, -s);
+        return { type: "del", raw: d, text: h, tokens: this.lexer.inlineTokens(h) };
+      }
+    }
+  }
+  autolink(e) {
+    let t = this.rules.inline.autolink.exec(e);
+    if (t) {
+      let n, r;
+      return t[2] === "@" ? (n = t[1], r = "mailto:" + n) : (n = t[1], r = n), { type: "link", raw: t[0], text: n, href: r, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  url(e) {
+    let t;
+    if (t = this.rules.inline.url.exec(e)) {
+      let n, r;
+      if (t[2] === "@") n = t[0], r = "mailto:" + n;
+      else {
+        let i;
+        do
+          i = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? "";
+        while (i !== t[0]);
+        n = t[0], t[1] === "www." ? r = "http://" + t[0] : r = t[0];
+      }
+      return { type: "link", raw: t[0], text: n, href: r, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  inlineText(e) {
+    let t = this.rules.inline.text.exec(e);
+    if (t) {
+      let n = this.lexer.state.inRawBlock;
+      return { type: "text", raw: t[0], text: t[0], escaped: n };
+    }
+  }
+};
+var x = class u {
+  tokens;
+  options;
+  state;
+  inlineQueue;
+  tokenizer;
+  constructor(e) {
+    this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = e || O, this.options.tokenizer = this.options.tokenizer || new w(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: false, inRawBlock: false, top: true };
+    let t = { other: m, block: B.normal, inline: E.normal };
+    this.options.pedantic ? (t.block = B.pedantic, t.inline = E.pedantic) : this.options.gfm && (t.block = B.gfm, this.options.breaks ? t.inline = E.breaks : t.inline = E.gfm), this.tokenizer.rules = t;
+  }
+  static get rules() {
+    return { block: B, inline: E };
+  }
+  static lex(e, t) {
+    return new u(t).lex(e);
+  }
+  static lexInline(e, t) {
+    return new u(t).inlineTokens(e);
+  }
+  lex(e) {
+    e = e.replace(m.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let t = 0; t < this.inlineQueue.length; t++) {
+      let n = this.inlineQueue[t];
+      this.inlineTokens(n.src, n.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, t = [], n = false) {
+    for (this.tokenizer.lexer = this, this.options.pedantic && (e = e.replace(m.tabCharGlobal, "    ").replace(m.spaceLine, "")); e; ) {
+      let r;
+      if (this.options.extensions?.block?.some((s) => (r = s.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), true) : false)) continue;
+      if (r = this.tokenizer.space(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        r.raw.length === 1 && s !== void 0 ? s.raw += `
+` : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.code(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        s?.type === "paragraph" || s?.type === "text" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.text, this.inlineQueue.at(-1).src = s.text) : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.fences(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.heading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.hr(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.blockquote(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.list(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.html(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.def(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        s?.type === "paragraph" || s?.type === "text" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.raw, this.inlineQueue.at(-1).src = s.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { href: r.href, title: r.title }, t.push(r));
+        continue;
+      }
+      if (r = this.tokenizer.table(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.lheading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      let i = e;
+      if (this.options.extensions?.startBlock) {
+        let s = 1 / 0, a = e.slice(1), o;
+        this.options.extensions.startBlock.forEach((l) => {
+          o = l.call({ lexer: this }, a), typeof o == "number" && o >= 0 && (s = Math.min(s, o));
+        }), s < 1 / 0 && s >= 0 && (i = e.substring(0, s + 1));
+      }
+      if (this.state.top && (r = this.tokenizer.paragraph(i))) {
+        let s = t.at(-1);
+        n && s?.type === "paragraph" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = s.text) : t.push(r), n = i.length !== e.length, e = e.substring(r.raw.length);
+        continue;
+      }
+      if (r = this.tokenizer.text(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        s?.type === "text" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = s.text) : t.push(r);
+        continue;
+      }
+      if (e) {
+        let s = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(s);
+          break;
+        } else throw new Error(s);
+      }
+    }
+    return this.state.top = true, t;
+  }
+  inline(e, t = []) {
+    return this.inlineQueue.push({ src: e, tokens: t }), t;
+  }
+  inlineTokens(e, t = []) {
+    this.tokenizer.lexer = this;
+    let n = e, r = null;
+    if (this.tokens.links) {
+      let o = Object.keys(this.tokens.links);
+      if (o.length > 0) for (; (r = this.tokenizer.rules.inline.reflinkSearch.exec(n)) !== null; ) o.includes(r[0].slice(r[0].lastIndexOf("[") + 1, -1)) && (n = n.slice(0, r.index) + "[" + "a".repeat(r[0].length - 2) + "]" + n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex));
+    }
+    for (; (r = this.tokenizer.rules.inline.anyPunctuation.exec(n)) !== null; ) n = n.slice(0, r.index) + "++" + n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    let i;
+    for (; (r = this.tokenizer.rules.inline.blockSkip.exec(n)) !== null; ) i = r[2] ? r[2].length : 0, n = n.slice(0, r.index + i) + "[" + "a".repeat(r[0].length - i - 2) + "]" + n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n;
+    let s = false, a = "";
+    for (; e; ) {
+      s || (a = ""), s = false;
+      let o;
+      if (this.options.extensions?.inline?.some((p) => (o = p.call({ lexer: this }, e, t)) ? (e = e.substring(o.raw.length), t.push(o), true) : false)) continue;
+      if (o = this.tokenizer.escape(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.tag(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.link(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(o.raw.length);
+        let p = t.at(-1);
+        o.type === "text" && p?.type === "text" ? (p.raw += o.raw, p.text += o.text) : t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.emStrong(e, n, a)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.codespan(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.br(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.del(e, n, a)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.autolink(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (!this.state.inLink && (o = this.tokenizer.url(e))) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      let l = e;
+      if (this.options.extensions?.startInline) {
+        let p = 1 / 0, c = e.slice(1), d;
+        this.options.extensions.startInline.forEach((h) => {
+          d = h.call({ lexer: this }, c), typeof d == "number" && d >= 0 && (p = Math.min(p, d));
+        }), p < 1 / 0 && p >= 0 && (l = e.substring(0, p + 1));
+      }
+      if (o = this.tokenizer.inlineText(l)) {
+        e = e.substring(o.raw.length), o.raw.slice(-1) !== "_" && (a = o.raw.slice(-1)), s = true;
+        let p = t.at(-1);
+        p?.type === "text" ? (p.raw += o.raw, p.text += o.text) : t.push(o);
+        continue;
+      }
+      if (e) {
+        let p = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(p);
+          break;
+        } else throw new Error(p);
+      }
+    }
+    return t;
+  }
+};
+var y = class {
+  options;
+  parser;
+  constructor(e) {
+    this.options = e || O;
+  }
+  space(e) {
+    return "";
+  }
+  code({ text: e, lang: t, escaped: n }) {
+    let r = (t || "").match(m.notSpaceStart)?.[0], i = e.replace(m.endingNewline, "") + `
+`;
+    return r ? '<pre><code class="language-' + T(r) + '">' + (n ? i : T(i, true)) + `</code></pre>
+` : "<pre><code>" + (n ? i : T(i, true)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: e }) {
+    return `<blockquote>
+${this.parser.parse(e)}</blockquote>
+`;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  def(e) {
+    return "";
+  }
+  heading({ tokens: e, depth: t }) {
+    return `<h${t}>${this.parser.parseInline(e)}</h${t}>
+`;
+  }
+  hr(e) {
+    return `<hr>
+`;
+  }
+  list(e) {
+    let t = e.ordered, n = e.start, r = "";
+    for (let a = 0; a < e.items.length; a++) {
+      let o = e.items[a];
+      r += this.listitem(o);
+    }
+    let i = t ? "ol" : "ul", s = t && n !== 1 ? ' start="' + n + '"' : "";
+    return "<" + i + s + `>
+` + r + "</" + i + `>
+`;
+  }
+  listitem(e) {
+    return `<li>${this.parser.parse(e.tokens)}</li>
+`;
+  }
+  checkbox({ checked: e }) {
+    return "<input " + (e ? 'checked="" ' : "") + 'disabled="" type="checkbox"> ';
+  }
+  paragraph({ tokens: e }) {
+    return `<p>${this.parser.parseInline(e)}</p>
+`;
+  }
+  table(e) {
+    let t = "", n = "";
+    for (let i = 0; i < e.header.length; i++) n += this.tablecell(e.header[i]);
+    t += this.tablerow({ text: n });
+    let r = "";
+    for (let i = 0; i < e.rows.length; i++) {
+      let s = e.rows[i];
+      n = "";
+      for (let a = 0; a < s.length; a++) n += this.tablecell(s[a]);
+      r += this.tablerow({ text: n });
+    }
+    return r && (r = `<tbody>${r}</tbody>`), `<table>
+<thead>
+` + t + `</thead>
+` + r + `</table>
+`;
+  }
+  tablerow({ text: e }) {
+    return `<tr>
+${e}</tr>
+`;
+  }
+  tablecell(e) {
+    let t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td";
+    return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + `</${n}>
+`;
+  }
+  strong({ tokens: e }) {
+    return `<strong>${this.parser.parseInline(e)}</strong>`;
+  }
+  em({ tokens: e }) {
+    return `<em>${this.parser.parseInline(e)}</em>`;
+  }
+  codespan({ text: e }) {
+    return `<code>${T(e, true)}</code>`;
+  }
+  br(e) {
+    return "<br>";
+  }
+  del({ tokens: e }) {
+    return `<del>${this.parser.parseInline(e)}</del>`;
+  }
+  link({ href: e, title: t, tokens: n }) {
+    let r = this.parser.parseInline(n), i = J(e);
+    if (i === null) return r;
+    e = i;
+    let s = '<a href="' + e + '"';
+    return t && (s += ' title="' + T(t) + '"'), s += ">" + r + "</a>", s;
+  }
+  image({ href: e, title: t, text: n, tokens: r }) {
+    r && (n = this.parser.parseInline(r, this.parser.textRenderer));
+    let i = J(e);
+    if (i === null) return T(n);
+    e = i;
+    let s = `<img src="${e}" alt="${T(n)}"`;
+    return t && (s += ` title="${T(t)}"`), s += ">", s;
+  }
+  text(e) {
+    return "tokens" in e && e.tokens ? this.parser.parseInline(e.tokens) : "escaped" in e && e.escaped ? e.text : T(e.text);
+  }
+};
+var $ = class {
+  strong({ text: e }) {
+    return e;
+  }
+  em({ text: e }) {
+    return e;
+  }
+  codespan({ text: e }) {
+    return e;
+  }
+  del({ text: e }) {
+    return e;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  text({ text: e }) {
+    return e;
+  }
+  link({ text: e }) {
+    return "" + e;
+  }
+  image({ text: e }) {
+    return "" + e;
+  }
+  br() {
+    return "";
+  }
+  checkbox({ raw: e }) {
+    return e;
+  }
+};
+var b = class u2 {
+  options;
+  renderer;
+  textRenderer;
+  constructor(e) {
+    this.options = e || O, this.options.renderer = this.options.renderer || new y(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new $();
+  }
+  static parse(e, t) {
+    return new u2(t).parse(e);
+  }
+  static parseInline(e, t) {
+    return new u2(t).parseInline(e);
+  }
+  parse(e) {
+    this.renderer.parser = this;
+    let t = "";
+    for (let n = 0; n < e.length; n++) {
+      let r = e[n];
+      if (this.options.extensions?.renderers?.[r.type]) {
+        let s = r, a = this.options.extensions.renderers[s.type].call({ parser: this }, s);
+        if (a !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "def", "paragraph", "text"].includes(s.type)) {
+          t += a || "";
+          continue;
+        }
+      }
+      let i = r;
+      switch (i.type) {
+        case "space": {
+          t += this.renderer.space(i);
+          break;
+        }
+        case "hr": {
+          t += this.renderer.hr(i);
+          break;
+        }
+        case "heading": {
+          t += this.renderer.heading(i);
+          break;
+        }
+        case "code": {
+          t += this.renderer.code(i);
+          break;
+        }
+        case "table": {
+          t += this.renderer.table(i);
+          break;
+        }
+        case "blockquote": {
+          t += this.renderer.blockquote(i);
+          break;
+        }
+        case "list": {
+          t += this.renderer.list(i);
+          break;
+        }
+        case "checkbox": {
+          t += this.renderer.checkbox(i);
+          break;
+        }
+        case "html": {
+          t += this.renderer.html(i);
+          break;
+        }
+        case "def": {
+          t += this.renderer.def(i);
+          break;
+        }
+        case "paragraph": {
+          t += this.renderer.paragraph(i);
+          break;
+        }
+        case "text": {
+          t += this.renderer.text(i);
+          break;
+        }
+        default: {
+          let s = 'Token with "' + i.type + '" type was not found.';
+          if (this.options.silent) return console.error(s), "";
+          throw new Error(s);
+        }
+      }
+    }
+    return t;
+  }
+  parseInline(e, t = this.renderer) {
+    this.renderer.parser = this;
+    let n = "";
+    for (let r = 0; r < e.length; r++) {
+      let i = e[r];
+      if (this.options.extensions?.renderers?.[i.type]) {
+        let a = this.options.extensions.renderers[i.type].call({ parser: this }, i);
+        if (a !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(i.type)) {
+          n += a || "";
+          continue;
+        }
+      }
+      let s = i;
+      switch (s.type) {
+        case "escape": {
+          n += t.text(s);
+          break;
+        }
+        case "html": {
+          n += t.html(s);
+          break;
+        }
+        case "link": {
+          n += t.link(s);
+          break;
+        }
+        case "image": {
+          n += t.image(s);
+          break;
+        }
+        case "checkbox": {
+          n += t.checkbox(s);
+          break;
+        }
+        case "strong": {
+          n += t.strong(s);
+          break;
+        }
+        case "em": {
+          n += t.em(s);
+          break;
+        }
+        case "codespan": {
+          n += t.codespan(s);
+          break;
+        }
+        case "br": {
+          n += t.br(s);
+          break;
+        }
+        case "del": {
+          n += t.del(s);
+          break;
+        }
+        case "text": {
+          n += t.text(s);
+          break;
+        }
+        default: {
+          let a = 'Token with "' + s.type + '" type was not found.';
+          if (this.options.silent) return console.error(a), "";
+          throw new Error(a);
+        }
+      }
+    }
+    return n;
+  }
+};
+var P = class {
+  options;
+  block;
+  constructor(e) {
+    this.options = e || O;
+  }
+  static passThroughHooks = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"]);
+  static passThroughHooksRespectAsync = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"]);
+  preprocess(e) {
+    return e;
+  }
+  postprocess(e) {
+    return e;
+  }
+  processAllTokens(e) {
+    return e;
+  }
+  emStrongMask(e) {
+    return e;
+  }
+  provideLexer(e = this.block) {
+    return e ? x.lex : x.lexInline;
+  }
+  provideParser(e = this.block) {
+    return e ? b.parse : b.parseInline;
+  }
+};
+var D = class {
+  defaults = M();
+  options = this.setOptions;
+  parse = this.parseMarkdown(true);
+  parseInline = this.parseMarkdown(false);
+  Parser = b;
+  Renderer = y;
+  TextRenderer = $;
+  Lexer = x;
+  Tokenizer = w;
+  Hooks = P;
+  constructor(...e) {
+    this.use(...e);
+  }
+  walkTokens(e, t) {
+    let n = [];
+    for (let r of e) switch (n = n.concat(t.call(this, r)), r.type) {
+      case "table": {
+        let i = r;
+        for (let s of i.header) n = n.concat(this.walkTokens(s.tokens, t));
+        for (let s of i.rows) for (let a of s) n = n.concat(this.walkTokens(a.tokens, t));
+        break;
+      }
+      case "list": {
+        let i = r;
+        n = n.concat(this.walkTokens(i.items, t));
+        break;
+      }
+      default: {
+        let i = r;
+        this.defaults.extensions?.childTokens?.[i.type] ? this.defaults.extensions.childTokens[i.type].forEach((s) => {
+          let a = i[s].flat(1 / 0);
+          n = n.concat(this.walkTokens(a, t));
+        }) : i.tokens && (n = n.concat(this.walkTokens(i.tokens, t)));
+      }
+    }
+    return n;
+  }
+  use(...e) {
+    let t = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return e.forEach((n) => {
+      let r = { ...n };
+      if (r.async = this.defaults.async || r.async || false, n.extensions && (n.extensions.forEach((i) => {
+        if (!i.name) throw new Error("extension name required");
+        if ("renderer" in i) {
+          let s = t.renderers[i.name];
+          s ? t.renderers[i.name] = function(...a) {
+            let o = i.renderer.apply(this, a);
+            return o === false && (o = s.apply(this, a)), o;
+          } : t.renderers[i.name] = i.renderer;
+        }
+        if ("tokenizer" in i) {
+          if (!i.level || i.level !== "block" && i.level !== "inline") throw new Error("extension level must be 'block' or 'inline'");
+          let s = t[i.level];
+          s ? s.unshift(i.tokenizer) : t[i.level] = [i.tokenizer], i.start && (i.level === "block" ? t.startBlock ? t.startBlock.push(i.start) : t.startBlock = [i.start] : i.level === "inline" && (t.startInline ? t.startInline.push(i.start) : t.startInline = [i.start]));
+        }
+        "childTokens" in i && i.childTokens && (t.childTokens[i.name] = i.childTokens);
+      }), r.extensions = t), n.renderer) {
+        let i = this.defaults.renderer || new y(this.defaults);
+        for (let s in n.renderer) {
+          if (!(s in i)) throw new Error(`renderer '${s}' does not exist`);
+          if (["options", "parser"].includes(s)) continue;
+          let a = s, o = n.renderer[a], l = i[a];
+          i[a] = (...p) => {
+            let c = o.apply(i, p);
+            return c === false && (c = l.apply(i, p)), c || "";
+          };
+        }
+        r.renderer = i;
+      }
+      if (n.tokenizer) {
+        let i = this.defaults.tokenizer || new w(this.defaults);
+        for (let s in n.tokenizer) {
+          if (!(s in i)) throw new Error(`tokenizer '${s}' does not exist`);
+          if (["options", "rules", "lexer"].includes(s)) continue;
+          let a = s, o = n.tokenizer[a], l = i[a];
+          i[a] = (...p) => {
+            let c = o.apply(i, p);
+            return c === false && (c = l.apply(i, p)), c;
+          };
+        }
+        r.tokenizer = i;
+      }
+      if (n.hooks) {
+        let i = this.defaults.hooks || new P();
+        for (let s in n.hooks) {
+          if (!(s in i)) throw new Error(`hook '${s}' does not exist`);
+          if (["options", "block"].includes(s)) continue;
+          let a = s, o = n.hooks[a], l = i[a];
+          P.passThroughHooks.has(s) ? i[a] = (p) => {
+            if (this.defaults.async && P.passThroughHooksRespectAsync.has(s)) return (async () => {
+              let d = await o.call(i, p);
+              return l.call(i, d);
+            })();
+            let c = o.call(i, p);
+            return l.call(i, c);
+          } : i[a] = (...p) => {
+            if (this.defaults.async) return (async () => {
+              let d = await o.apply(i, p);
+              return d === false && (d = await l.apply(i, p)), d;
+            })();
+            let c = o.apply(i, p);
+            return c === false && (c = l.apply(i, p)), c;
+          };
+        }
+        r.hooks = i;
+      }
+      if (n.walkTokens) {
+        let i = this.defaults.walkTokens, s = n.walkTokens;
+        r.walkTokens = function(a) {
+          let o = [];
+          return o.push(s.call(this, a)), i && (o = o.concat(i.call(this, a))), o;
+        };
+      }
+      this.defaults = { ...this.defaults, ...r };
+    }), this;
+  }
+  setOptions(e) {
+    return this.defaults = { ...this.defaults, ...e }, this;
+  }
+  lexer(e, t) {
+    return x.lex(e, t ?? this.defaults);
+  }
+  parser(e, t) {
+    return b.parse(e, t ?? this.defaults);
+  }
+  parseMarkdown(e) {
+    return (n, r) => {
+      let i = { ...r }, s = { ...this.defaults, ...i }, a = this.onError(!!s.silent, !!s.async);
+      if (this.defaults.async === true && i.async === false) return a(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      if (typeof n > "u" || n === null) return a(new Error("marked(): input parameter is undefined or null"));
+      if (typeof n != "string") return a(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected"));
+      if (s.hooks && (s.hooks.options = s, s.hooks.block = e), s.async) return (async () => {
+        let o = s.hooks ? await s.hooks.preprocess(n) : n, p = await (s.hooks ? await s.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(o, s), c = s.hooks ? await s.hooks.processAllTokens(p) : p;
+        s.walkTokens && await Promise.all(this.walkTokens(c, s.walkTokens));
+        let h = await (s.hooks ? await s.hooks.provideParser(e) : e ? b.parse : b.parseInline)(c, s);
+        return s.hooks ? await s.hooks.postprocess(h) : h;
+      })().catch(a);
+      try {
+        s.hooks && (n = s.hooks.preprocess(n));
+        let l = (s.hooks ? s.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(n, s);
+        s.hooks && (l = s.hooks.processAllTokens(l)), s.walkTokens && this.walkTokens(l, s.walkTokens);
+        let c = (s.hooks ? s.hooks.provideParser(e) : e ? b.parse : b.parseInline)(l, s);
+        return s.hooks && (c = s.hooks.postprocess(c)), c;
+      } catch (o) {
+        return a(o);
+      }
+    };
+  }
+  onError(e, t) {
+    return (n) => {
+      if (n.message += `
+Please report this to https://github.com/markedjs/marked.`, e) {
+        let r = "<p>An error occurred:</p><pre>" + T(n.message + "", true) + "</pre>";
+        return t ? Promise.resolve(r) : r;
+      }
+      if (t) return Promise.reject(n);
+      throw n;
+    };
+  }
+};
+var L = new D();
+function g(u3, e) {
+  return L.parse(u3, e);
+}
+g.options = g.setOptions = function(u3) {
+  return L.setOptions(u3), g.defaults = L.defaults, G(g.defaults), g;
+};
+g.getDefaults = M;
+g.defaults = O;
+g.use = function(...u3) {
+  return L.use(...u3), g.defaults = L.defaults, G(g.defaults), g;
+};
+g.walkTokens = function(u3, e) {
+  return L.walkTokens(u3, e);
+};
+g.parseInline = L.parseInline;
+g.Parser = b;
+g.parser = b.parse;
+g.Renderer = y;
+g.TextRenderer = $;
+g.Lexer = x;
+g.lexer = x.lex;
+g.Tokenizer = w;
+g.Hooks = P;
+g.parse = g;
+var Qt = g.options;
+var jt = g.setOptions;
+var Ft = g.use;
+var Ut = g.walkTokens;
+var Kt = g.parseInline;
+var Xt = b.parse;
+var Jt = x.lex;
+
+// ../core/dist/formatting/renderer.js
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderToWeChatHtml(markdown, template) {
+  const instance = new D();
+  instance.use({
+    renderer: {
+      heading({ tokens, depth }) {
+        const text = this.parser.parseInline(tokens);
+        const style = depth === 1 ? template.styles.title : depth === 2 ? template.styles.h2 : template.styles.h3;
+        return `<h${depth} style="${style}">${text}</h${depth}>`;
+      },
+      paragraph({ tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return `<p style="${template.styles.paragraph}">${text}</p>`;
+      },
+      blockquote({ tokens }) {
+        const text = this.parser.parse(tokens);
+        return `<blockquote style="${template.styles.blockquote}">${text}</blockquote>`;
+      },
+      code({ text }) {
+        return `<pre style="${template.styles.codeBlock}"><code>${escapeHtml(text)}</code></pre>`;
+      },
+      codespan({ text }) {
+        return `<code style="${template.styles.codeInline}">${text}</code>`;
+      },
+      image({ href, text }) {
+        return `<img src="${href}" alt="${text}" style="${template.styles.image}" />`;
+      },
+      listitem(item) {
+        const text = this.parser.parse(item.tokens);
+        return `<li style="${template.styles.listItem}">${text}</li>`;
+      },
+      strong({ tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return `<strong style="${template.styles.strong}">${text}</strong>`;
+      },
+      em({ tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return `<em style="${template.styles.emphasis}">${text}</em>`;
+      },
+      link({ href, tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return `<a href="${href}" style="${template.styles.link}">${text}</a>`;
+      },
+      hr() {
+        return `<hr style="${template.styles.hr}" />`;
+      }
+    }
+  });
+  const html = instance.parse(markdown);
+  return `<section style="max-width: ${template.layout.maxWidth}; margin: 0 auto; padding: 16px; line-height: ${template.layout.lineHeight}; letter-spacing: ${template.layout.letterSpacing};">${html}</section>`;
+}
+
+// ../core/dist/formatting/templates/minimal.js
+var minimalTemplate = {
+  id: "minimal",
+  name: "\u7B80\u7EA6",
+  styles: {
+    title: "font-size: 22px; font-weight: bold; color: #1a1a1a; margin-bottom: 16px;",
+    h2: "font-size: 18px; font-weight: bold; color: #333; border-left: 4px solid #07c160; padding-left: 12px; margin: 24px 0 12px;",
+    h3: "font-size: 16px; font-weight: bold; color: #333;",
+    paragraph: "font-size: 15px; color: #3f3f3f; line-height: 1.8; margin-bottom: 16px; letter-spacing: 0.5px;",
+    blockquote: "border-left: 3px solid #ddd; padding: 8px 16px; color: #888; font-size: 14px; margin: 16px 0;",
+    codeBlock: "background: #f6f8fa; padding: 16px; border-radius: 4px; font-size: 13px; font-family: Menlo, monospace; overflow-x: auto; margin: 16px 0;",
+    codeInline: "background: #f0f0f0; padding: 2px 6px; border-radius: 3px; font-size: 13px; color: #e83e8c;",
+    image: "max-width: 100%; height: auto; border-radius: 4px; margin: 16px 0; display: block;",
+    listItem: "font-size: 15px; color: #3f3f3f; line-height: 1.8; margin-bottom: 8px;",
+    strong: "font-weight: bold; color: #1a1a1a;",
+    link: "color: #576b95; text-decoration: none;",
+    emphasis: "font-style: italic;",
+    hr: "border: none; border-top: 1px solid #eee; margin: 24px 0;"
+  },
+  layout: {
+    lineHeight: "1.8",
+    letterSpacing: "0.5px",
+    paragraphSpacing: "16px",
+    maxWidth: "100%"
+  }
+};
+
+// ../core/dist/steps/formatting.js
+var TEMPLATES = {
+  minimal: minimalTemplate
+};
+var FormattingStep = class {
+  templateId;
+  id;
+  type = "formatting";
+  gate = "auto";
+  constructor(templateId = "minimal", id = "formatting") {
+    this.templateId = templateId;
+    this.id = id;
+  }
+  async execute(context) {
+    const start = Date.now();
+    try {
+      const article = context.data.article;
+      if (!article) {
+        return {
+          success: false,
+          error: "\u7F3A\u5C11\u6587\u7AE0\u6570\u636E\uFF0C\u8BF7\u5148\u6267\u884C writing \u6B65\u9AA4",
+          duration: Date.now() - start
+        };
+      }
+      const template = TEMPLATES[this.templateId] ?? minimalTemplate;
+      const html = renderToWeChatHtml(article.content, template);
+      context.data.formatted = { html };
+      return {
+        success: true,
+        data: context.data.formatted,
+        duration: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        duration: Date.now() - start
+      };
+    }
+  }
+};
+
+// ../core/dist/steps/draft-publish.js
+var DraftPublishStep = class {
+  client;
+  thumbMediaId;
+  id;
+  type = "draft-publish";
+  gate = "auto";
+  constructor(client, thumbMediaId = "", id = "draft-publish") {
+    this.client = client;
+    this.thumbMediaId = thumbMediaId;
+    this.id = id;
+  }
+  async execute(context) {
+    const start = Date.now();
+    try {
+      const formatted = context.data.formatted;
+      if (!formatted) {
+        return {
+          success: false,
+          error: "\u7F3A\u5C11\u6392\u7248\u6570\u636E\uFF0C\u8BF7\u5148\u6267\u884C formatting \u6B65\u9AA4",
+          duration: Date.now() - start
+        };
+      }
+      const title = context.data.article?.title ?? "\u65E0\u6807\u9898";
+      const mediaId = await this.client.addDraft([
+        {
+          title,
+          content: formatted.html,
+          thumbMediaId: this.thumbMediaId
+        }
+      ]);
+      context.data.draftId = mediaId;
+      return {
+        success: true,
+        data: { draftId: mediaId },
+        duration: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        duration: Date.now() - start
+      };
+    }
+  }
+};
+
+// ../core/dist/config-loader.js
+import { readFileSync } from "fs";
+import { join } from "path";
+function findWxclawDir() {
+  const cwd = process.cwd();
+  const candidates = [
+    join(cwd, ".wxclaw"),
+    join(cwd, "..", ".wxclaw"),
+    join(cwd, "..", "..", ".wxclaw"),
+    join(cwd, "..", "..", "..", ".wxclaw")
+  ];
+  for (const candidate of candidates) {
+    try {
+      readFileSync(join(candidate, "soul.md"), "utf-8");
+      return candidate;
+    } catch {
+    }
+  }
+  return join(cwd, ".wxclaw");
+}
+var wxclawDir = null;
+function getWxclawDir() {
+  if (!wxclawDir) {
+    wxclawDir = findWxclawDir();
+  }
+  return wxclawDir;
+}
+function loadSoulPrompt() {
+  const filePath = join(getWxclawDir(), "soul.md");
+  return readFileSync(filePath, "utf-8");
+}
+function loadAgentsRules() {
+  const filePath = join(getWxclawDir(), "agents.md");
+  return readFileSync(filePath, "utf-8");
+}
+function loadStylePrompt(styleName) {
+  const filePath = join(getWxclawDir(), "styles", `${styleName}.md`);
+  return readFileSync(filePath, "utf-8");
+}
+function loadPipelineConfig(styleName) {
+  const soulPrompt = loadSoulPrompt();
+  let agentsRules;
+  try {
+    agentsRules = loadAgentsRules();
+  } catch {
+    agentsRules = void 0;
+  }
+  let stylePrompt;
+  if (styleName) {
+    try {
+      stylePrompt = loadStylePrompt(styleName);
+    } catch {
+      stylePrompt = void 0;
+    }
+  }
+  return {
+    soulPrompt,
+    agentsRules,
+    stylePrompt
+  };
+}
+
+// ../core/dist/styles/manager.js
+import { readdirSync, readFileSync as readFileSync2, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join as join2, basename } from "path";
+function findWxclawDir2() {
+  const cwd = process.cwd();
+  const candidates = [
+    join2(cwd, ".wxclaw"),
+    join2(cwd, "..", ".wxclaw"),
+    join2(cwd, "..", "..", ".wxclaw"),
+    join2(cwd, "..", "..", "..", ".wxclaw")
+  ];
+  for (const candidate of candidates) {
+    try {
+      readFileSync2(join2(candidate, "soul.md"), "utf-8");
+      return candidate;
+    } catch {
+    }
+  }
+  return join2(cwd, ".wxclaw");
+}
+function extractNameFromContent(content, fallback) {
+  const firstLine = content.split("\n")[0] ?? "";
+  const match = firstLine.match(/^#\s+(.+)/);
+  return match?.[1]?.trim() ?? fallback;
+}
+var StyleManager = class {
+  wxclawDir;
+  constructor(wxclawDir2) {
+    this.wxclawDir = wxclawDir2 ?? findWxclawDir2();
+  }
+  // 从 .wxclaw/styles/*.md 加载预设风格
+  loadPresets() {
+    const stylesDir = join2(this.wxclawDir, "styles");
+    if (!existsSync(stylesDir)) {
+      return [];
+    }
+    let files;
+    try {
+      files = readdirSync(stylesDir).filter((f) => f.endsWith(".md"));
+    } catch {
+      return [];
+    }
+    return files.map((file) => {
+      const filePath = join2(stylesDir, file);
+      const content = readFileSync2(filePath, "utf-8");
+      const id = basename(file, ".md");
+      const name = extractNameFromContent(content, id);
+      return {
+        id,
+        name,
+        type: "preset",
+        systemPrompt: content,
+        source: filePath
+      };
+    });
+  }
+  // 获取指定风格
+  getStyle(id) {
+    return this.listStyles().find((s) => s.id === id);
+  }
+  // 列出所有风格
+  listStyles() {
+    return this.loadPresets();
+  }
+  // 添加自定义风格
+  addCustomStyle(name, systemPrompt) {
+    const stylesDir = join2(this.wxclawDir, "styles");
+    if (!existsSync(stylesDir)) {
+      mkdirSync(stylesDir, { recursive: true });
+    }
+    const id = name.toLowerCase().replace(/\s+/g, "-");
+    const filePath = join2(stylesDir, `${id}.md`);
+    writeFileSync(filePath, `# ${name}
+
+${systemPrompt}`, "utf-8");
+    return {
+      id,
+      name,
+      type: "custom",
+      systemPrompt: `# ${name}
+
+${systemPrompt}`,
+      source: filePath
+    };
+  }
+  // 范文学习：调用 LLM 分析范文，提取 StyleProfile，生成 system prompt
+  async learnFromSamples(name, sampleTexts, llm) {
+    const samplesContent = sampleTexts.map((t, i) => `\u3010\u8303\u6587 ${i + 1}\u3011
+${t}`).join("\n\n---\n\n");
+    const prompt = `\u8BF7\u5206\u6790\u4EE5\u4E0B\u8303\u6587\uFF0C\u63D0\u53D6\u5199\u4F5C\u98CE\u683C\u7279\u5F81\uFF0C\u5E76\u4EE5 JSON \u683C\u5F0F\u8FD4\u56DE StyleProfile\u3002
+
+\u8303\u6587\u5185\u5BB9\uFF1A
+${samplesContent}
+
+\u8BF7\u8FD4\u56DE\u5982\u4E0B JSON \u683C\u5F0F\uFF08\u4E0D\u8981\u6709\u5176\u4ED6\u5185\u5BB9\uFF0C\u53EA\u8FD4\u56DE JSON\uFF09\uFF1A
+{
+  "tone": "\u8BED\u6C14\u7279\u5F81\u63CF\u8FF0",
+  "sentencePattern": "\u53E5\u5F0F\u7279\u5F81\u63CF\u8FF0",
+  "structure": "\u6587\u7AE0\u7ED3\u6784\u63CF\u8FF0",
+  "vocabulary": "\u7528\u8BCD\u7279\u5F81\u63CF\u8FF0",
+  "openingStyle": "\u5F00\u5934\u98CE\u683C\u63CF\u8FF0",
+  "closingStyle": "\u7ED3\u5C3E\u98CE\u683C\u63CF\u8FF0",
+  "specialHabits": ["\u7279\u6B8A\u4E60\u60EF1", "\u7279\u6B8A\u4E60\u60EF2"]
+}`;
+    const response = await llm.chat({
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.3
+    });
+    let profile;
+    try {
+      const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        throw new Error("LLM \u54CD\u5E94\u4E2D\u672A\u627E\u5230 JSON");
+      }
+      profile = JSON.parse(jsonMatch[0]);
+    } catch {
+      profile = {
+        tone: "\u81EA\u7136\u6D41\u7545",
+        sentencePattern: "\u957F\u77ED\u53E5\u7ED3\u5408",
+        structure: "\u5F00\u5934\u2192\u5C55\u5F00\u2192\u7ED3\u5C3E",
+        vocabulary: "\u53E3\u8BED\u5316",
+        openingStyle: "\u76F4\u63A5\u5207\u9898",
+        closingStyle: "\u603B\u7ED3\u8981\u70B9",
+        specialHabits: []
+      };
+    }
+    const systemPrompt = `# ${name}
+
+## \u98CE\u683C\u5B9A\u4E49
+
+\u57FA\u4E8E\u8303\u6587\u5B66\u4E60\u751F\u6210\u7684\u5199\u4F5C\u98CE\u683C\u3002
+
+## \u8BED\u6C14
+
+${profile.tone}
+
+## \u53E5\u5F0F\u7279\u5F81
+
+${profile.sentencePattern}
+
+## \u7ED3\u6784\u6A21\u677F
+
+${profile.structure}
+
+## \u7528\u8BCD\u7279\u70B9
+
+${profile.vocabulary}
+
+## \u5F00\u5934\u98CE\u683C
+
+${profile.openingStyle}
+
+## \u7ED3\u5C3E\u98CE\u683C
+
+${profile.closingStyle}
+${profile.specialHabits.length > 0 ? `
+## \u7279\u6B8A\u4E60\u60EF
+
+${profile.specialHabits.map((h) => `- ${h}`).join("\n")}` : ""}`;
+    const stylesDir = join2(this.wxclawDir, "styles");
+    if (!existsSync(stylesDir)) {
+      mkdirSync(stylesDir, { recursive: true });
+    }
+    const id = name.toLowerCase().replace(/\s+/g, "-");
+    const filePath = join2(stylesDir, `${id}.md`);
+    writeFileSync(filePath, systemPrompt, "utf-8");
+    return {
+      id,
+      name,
+      type: "learned",
+      systemPrompt,
+      profile,
+      sampleTexts,
+      source: filePath
+    };
+  }
+};
+
+// src/utils/mock-llm.ts
+var mockLLMClient = {
+  async chat({ messages }) {
+    const lastMessage = messages[messages.length - 1]?.content ?? "";
+    if (lastMessage.includes("\u9009\u9898") || lastMessage.includes("\u89D2\u5EA6")) {
+      return {
+        content: JSON.stringify({
+          title: "AI \u5982\u4F55\u91CD\u5851\u6559\u80B2\u884C\u4E1A\u7684\u672A\u6765",
+          angle: "\u4ECE\u6559\u5E08\u3001\u5B66\u751F\u3001\u5BB6\u957F\u4E09\u4E2A\u89C6\u89D2\u5206\u6790 AI \u6559\u80B2\u5DE5\u5177\u7684\u5B9E\u9645\u5F71\u54CD",
+          keywords: ["AI \u6559\u80B2", "\u4E2A\u6027\u5316\u5B66\u4E60", "\u6559\u80B2\u79D1\u6280"]
+        })
+      };
+    }
+    if ((lastMessage.includes("\u5927\u7EB2") || lastMessage.includes("outline")) && !lastMessage.includes("\u64B0\u5199")) {
+      return {
+        content: JSON.stringify({
+          title: "AI \u5982\u4F55\u91CD\u5851\u6559\u80B2\u884C\u4E1A\u7684\u672A\u6765",
+          sections: [
+            {
+              heading: "\u5F15\u8A00\uFF1A\u5F53 ChatGPT \u8D70\u8FDB\u8BFE\u5802",
+              points: ["\u4E00\u4E2A\u771F\u5B9E\u7684\u8BFE\u5802\u6545\u4E8B", "AI \u6559\u80B2\u5DE5\u5177\u7684\u7206\u53D1\u5F0F\u589E\u957F\u6570\u636E"]
+            },
+            {
+              heading: "\u6559\u5E08\u89C6\u89D2\uFF1A\u662F\u66FF\u4EE3\u8FD8\u662F\u8D4B\u80FD\uFF1F",
+              points: ["AI \u6279\u6539\u4F5C\u4E1A\u7684\u6548\u7387\u63D0\u5347", "\u6559\u5E08\u89D2\u8272\u7684\u8F6C\u53D8", "\u65E0\u6CD5\u66FF\u4EE3\u7684\u4EBA\u6587\u5173\u6000"]
+            },
+            {
+              heading: "\u5B66\u751F\u89C6\u89D2\uFF1A\u4E2A\u6027\u5316\u5B66\u4E60\u7684\u65B0\u65F6\u4EE3",
+              points: ["\u81EA\u9002\u5E94\u5B66\u4E60\u8DEF\u5F84", "AI \u8F85\u5BFC\u7684\u4F18\u52BF\u4E0E\u9677\u9631", "\u6279\u5224\u6027\u601D\u7EF4\u7684\u57F9\u517B\u6311\u6218"]
+            },
+            {
+              heading: "\u5BB6\u957F\u89C6\u89D2\uFF1A\u7126\u8651\u4E0E\u671F\u5F85\u5E76\u5B58",
+              points: ["\u5BF9 AI \u4F9D\u8D56\u7684\u62C5\u5FE7", "\u6559\u80B2\u516C\u5E73\u7684\u65B0\u673A\u9047", "\u5982\u4F55\u5F15\u5BFC\u5B69\u5B50\u6B63\u786E\u4F7F\u7528 AI"]
+            },
+            {
+              heading: "\u7ED3\u8BED\uFF1A\u62E5\u62B1\u53D8\u5316\uFF0C\u5B88\u4F4F\u5E95\u7EBF",
+              points: ["AI \u6559\u80B2\u7684\u4E09\u6761\u5E95\u7EBF", "\u5BF9\u672A\u6765\u7684\u5C55\u671B"]
+            }
+          ]
+        })
+      };
+    }
+    return {
+      content: `# AI \u5982\u4F55\u91CD\u5851\u6559\u80B2\u884C\u4E1A\u7684\u672A\u6765
+
+> \u4ECE\u6559\u5E08\u3001\u5B66\u751F\u3001\u5BB6\u957F\u4E09\u4E2A\u89C6\u89D2\uFF0C\u770B AI \u6559\u80B2\u5DE5\u5177\u7684\u771F\u5B9E\u5F71\u54CD
+
+\u5F53 ChatGPT \u7B2C\u4E00\u6B21\u88AB\u5E26\u8FDB\u5317\u4EAC\u67D0\u4E2D\u5B66\u7684\u8BED\u6587\u8BFE\u5802\u65F6\uFF0C\u8BED\u6587\u8001\u5E08\u5F20\u8001\u5E08\u7684\u7B2C\u4E00\u53CD\u5E94\u4E0D\u662F\u5174\u594B\uFF0C\u800C\u662F\u6050\u614C\u3002"\u5982\u679C\u5B66\u751F\u7528 AI \u5199\u4F5C\u6587\uFF0C\u6211\u8FD8\u600E\u4E48\u6559\uFF1F"
+
+\u8FD9\u4E2A\u95EE\u9898\uFF0C\u6B63\u5728\u5168\u7403\u6570\u767E\u4E07\u6559\u5E08\u7684\u8111\u6D77\u4E2D\u56DE\u54CD\u3002
+
+## \u6559\u5E08\u89C6\u89D2\uFF1A\u662F\u66FF\u4EE3\u8FD8\u662F\u8D4B\u80FD\uFF1F
+
+\u6570\u636E\u663E\u793A\uFF0C\u4F7F\u7528 AI \u6279\u6539\u5DE5\u5177\u540E\uFF0C\u6559\u5E08\u6279\u6539\u4F5C\u4E1A\u7684\u65F6\u95F4\u5E73\u5747\u51CF\u5C11\u4E86 60%\u3002\u4F46\u8FD9\u5E76\u4E0D\u610F\u5473\u7740\u6559\u5E08\u53D8\u5F97\u591A\u4F59\u2014\u2014\u6070\u6070\u76F8\u53CD\uFF0C\u4ED6\u4EEC\u6709\u4E86\u66F4\u591A\u65F6\u95F4\u505A\u771F\u6B63\u91CD\u8981\u7684\u4E8B\uFF1A\u4E0E\u5B66\u751F\u4E00\u5BF9\u4E00\u4EA4\u6D41\uFF0C\u8BBE\u8BA1\u66F4\u6709\u521B\u610F\u7684\u6559\u5B66\u6D3B\u52A8\u3002
+
+**\u6559\u5E08\u7684\u89D2\u8272\u6B63\u5728\u4ECE"\u77E5\u8BC6\u4F20\u9012\u8005"\u8F6C\u53D8\u4E3A"\u5B66\u4E60\u5F15\u5BFC\u8005"\u3002**
+
+## \u5B66\u751F\u89C6\u89D2\uFF1A\u4E2A\u6027\u5316\u5B66\u4E60\u7684\u65B0\u65F6\u4EE3
+
+\u6BCF\u4E2A\u5B66\u751F\u7684\u5B66\u4E60\u8282\u594F\u4E0D\u540C\uFF0C\u4F20\u7EDF\u8BFE\u5802\u5F88\u96BE\u517C\u987E\u3002AI \u81EA\u9002\u5E94\u5B66\u4E60\u7CFB\u7EDF\u53EF\u4EE5\u6839\u636E\u6BCF\u4E2A\u5B66\u751F\u7684\u638C\u63E1\u7A0B\u5EA6\uFF0C\u52A8\u6001\u8C03\u6574\u7EC3\u4E60\u96BE\u5EA6\u548C\u77E5\u8BC6\u70B9\u63A8\u8350\u3002
+
+\u4F46\u786C\u5E01\u7684\u53E6\u4E00\u9762\u662F\uFF1A\u8FC7\u5EA6\u4F9D\u8D56 AI \u8F85\u5BFC\u53EF\u80FD\u524A\u5F31\u5B66\u751F\u72EC\u7ACB\u601D\u8003\u7684\u80FD\u529B\u3002
+
+## \u5BB6\u957F\u89C6\u89D2\uFF1A\u7126\u8651\u4E0E\u671F\u5F85\u5E76\u5B58
+
+"\u522B\u7684\u5B69\u5B50\u90FD\u5728\u7528 AI \u5B66\u4E60\uFF0C\u6211\u5BB6\u5B69\u5B50\u4E0D\u7528\u4F1A\u4E0D\u4F1A\u843D\u540E\uFF1F"\u8FD9\u662F\u5F88\u591A\u5BB6\u957F\u7684\u771F\u5B9E\u7126\u8651\u3002
+
+\u597D\u6D88\u606F\u662F\uFF0CAI \u6559\u80B2\u5DE5\u5177\u6B63\u5728\u8BA9\u4F18\u8D28\u6559\u80B2\u8D44\u6E90\u53D8\u5F97\u66F4\u52A0\u666E\u60E0\u3002\u574F\u6D88\u606F\u662F\uFF0C\u5982\u4F55\u5F15\u5BFC\u5B69\u5B50\u6B63\u786E\u4F7F\u7528 AI\uFF0C\u6210\u4E86\u4E00\u4E2A\u5168\u65B0\u7684\u80B2\u513F\u8BFE\u9898\u3002
+
+## \u62E5\u62B1\u53D8\u5316\uFF0C\u5B88\u4F4F\u5E95\u7EBF
+
+AI \u4E0D\u4F1A\u53D6\u4EE3\u6559\u80B2\uFF0C\u4F46\u4F1A\u6DF1\u523B\u6539\u53D8\u6559\u80B2\u7684\u5F62\u6001\u3002\u5728\u8FD9\u573A\u53D8\u9769\u4E2D\uFF0C\u6211\u4EEC\u9700\u8981\u5B88\u4F4F\u4E09\u6761\u5E95\u7EBF\uFF1A
+
+1. **\u6280\u672F\u670D\u52A1\u4E8E\u6559\u80B2\uFF0C\u800C\u975E\u6559\u80B2\u670D\u52A1\u4E8E\u6280\u672F**
+2. **\u57F9\u517B\u601D\u7EF4\u80FD\u529B\uFF0C\u800C\u975E\u4F9D\u8D56\u73B0\u6210\u7B54\u6848**
+3. **\u4FDD\u6301\u4EBA\u4E0E\u4EBA\u4E4B\u95F4\u7684\u771F\u5B9E\u8FDE\u63A5**
+
+\u672A\u6765\u5DF2\u6765\uFF0C\u5173\u952E\u662F\u6211\u4EEC\u5982\u4F55\u9009\u62E9\u3002
+
+---
+
+*\u4F60\u5BF9 AI \u6559\u80B2\u6709\u4EC0\u4E48\u770B\u6CD5\uFF1F\u6B22\u8FCE\u5728\u8BC4\u8BBA\u533A\u5206\u4EAB\u4F60\u7684\u89C2\u70B9\u3002*
+`
+    };
+  }
+};
+
+// src/commands/create.ts
+async function createRealLLMClient() {
+  const {
+    createMinimaxProvider: createMinimaxProvider2,
+    createDeepSeekProvider: createDeepSeekProvider2,
+    ProviderRegistry: ProviderRegistry2,
+    executeWithFailover: executeWithFailover2
+  } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const registry = new ProviderRegistry2();
+  const minimax = createMinimaxProvider2();
+  const deepseek = createDeepSeekProvider2();
+  if (minimax.isConfigured()) registry.register(minimax);
+  if (deepseek.isConfigured()) registry.register(deepseek);
+  if (registry.list().length === 0) {
+    console.error(chalk.red("\u6CA1\u6709\u53EF\u7528\u7684 LLM Provider\u3002\u8BF7\u5728 .wxclaw/config.json \u4E2D\u914D\u7F6E API Key\u3002"));
+    console.error(chalk.gray('  \u6216\u4F7F\u7528 --mock \u6A21\u5F0F\uFF1Awxclaw create --mock --topic "\u4E3B\u9898"'));
+    process.exit(1);
+  }
+  return {
+    async chat({ messages, temperature, maxTokens }) {
+      return executeWithFailover2(
+        "writing",
+        async (provider) => {
+          const response = await provider.chat({ messages, temperature, maxTokens });
+          return { content: response.content };
+        },
+        registry,
+        {
+          stepProviders: {},
+          globalFallbackOrder: registry.list().map((p) => p.id),
+          rateLimitBackoffMs: 3e3
+        }
+      );
+    }
+  };
+}
+function withSpinner(step, label, successLabel) {
+  return {
+    id: step.id,
+    type: step.type,
+    gate: step.gate,
+    async execute(context) {
+      const spinner = ora(chalk.cyan(label)).start();
+      try {
+        const result = await step.execute(context);
+        if (result.success) {
+          spinner.succeed(chalk.green(successLabel));
+        } else {
+          spinner.fail(chalk.red(`${successLabel} \u2014 \u5931\u8D25: ${result.error ?? ""}`));
+        }
+        return result;
+      } catch (err) {
+        spinner.fail(chalk.red(`${successLabel} \u2014 \u5931\u8D25`));
+        throw err;
+      }
+    }
+  };
+}
+var createCommand = new Command("create").description("\u521B\u5EFA\u516C\u4F17\u53F7\u6587\u7AE0").requiredOption("--topic <topic>", "\u6587\u7AE0\u4E3B\u9898").option("--style <style>", "\u5199\u4F5C\u98CE\u683C", "tech").option("--mock", "\u4F7F\u7528 Mock LLM\uFF08\u4E0D\u9700\u8981 API Key\uFF09").action(async (options) => {
+  console.log(chalk.cyan("WxClaw \u6587\u7AE0\u521B\u4F5C"));
+  console.log(chalk.gray("\u2501".repeat(50)));
+  console.log(`\u4E3B\u9898\uFF1A${chalk.bold(options.topic)}`);
+  console.log(`\u98CE\u683C\uFF1A${chalk.bold(options.style)}`);
+  console.log(`\u6A21\u5F0F\uFF1A${chalk.bold(options.mock ? "Mock LLM" : "\u771F\u5B9E API")}`);
+  console.log(chalk.gray("\u2501".repeat(50)));
+  const llmClient = options.mock ? mockLLMClient : await createRealLLMClient();
+  let pipelineConfig;
+  try {
+    pipelineConfig = loadPipelineConfig(options.style);
+  } catch {
+    pipelineConfig = {
+      soulPrompt: "\u4F60\u662F\u4E00\u4F4D\u4E13\u4E1A\u7684\u516C\u4F17\u53F7\u5185\u5BB9\u521B\u4F5C\u8005\u3002",
+      stylePrompt: "",
+      agentsRules: ""
+    };
+  }
+  const mockDraftClient = {
+    async addDraft(_articles) {
+      return `draft-${Date.now()}`;
+    }
+  };
+  const steps = [
+    withSpinner(new TopicSelectionStep(llmClient), "\u6B63\u5728\u9009\u9898...", "\u9009\u9898\u5B8C\u6210"),
+    withSpinner(new OutlineStep(llmClient), "\u6B63\u5728\u751F\u6210\u5927\u7EB2...", "\u5927\u7EB2\u5B8C\u6210"),
+    withSpinner(new WritingStep(llmClient), "\u6B63\u5728\u64B0\u5199\u6587\u7AE0...", "\u6587\u7AE0\u5B8C\u6210"),
+    withSpinner(new FormattingStep(), "\u6B63\u5728\u6392\u7248...", "\u6392\u7248\u5B8C\u6210"),
+    withSpinner(new DraftPublishStep(mockDraftClient), "\u6B63\u5728\u4FDD\u5B58\u8349\u7A3F...", "\u8349\u7A3F\u4FDD\u5B58\u5B8C\u6210")
+  ];
+  const context = {
+    pipelineId: `create-${Date.now()}`,
+    userId: "cli-user",
+    data: {
+      topic: { title: options.topic, angle: "", keywords: [] }
+    },
+    status: "running",
+    logs: [],
+    config: pipelineConfig
+  };
+  const engine = new PipelineEngine({ defaultTimeout: 12e4 });
+  let result;
+  try {
+    result = await engine.run(steps, context);
+  } catch (err) {
+    console.error(chalk.red("\nPipeline \u6267\u884C\u5931\u8D25\uFF1A"), err);
+    process.exit(1);
+  }
+  console.log("\n" + chalk.gray("\u2501".repeat(50)));
+  console.log(`\u72B6\u6001\uFF1A${result.status === "completed" ? chalk.green("\u5B8C\u6210") : chalk.red(result.status)}`);
+  const totalMs = result.logs.reduce((s, l) => s + l.duration, 0);
+  console.log(`\u8017\u65F6\uFF1A${totalMs}ms`);
+  console.log(chalk.gray("\u2501".repeat(50)));
+  if (result.data.topic) {
+    console.log("\n" + chalk.bold.cyan("\u9009\u9898"));
+    console.log(`  \u6807\u9898\uFF1A${result.data.topic.title}`);
+    console.log(`  \u89D2\u5EA6\uFF1A${result.data.topic.angle}`);
+    if (result.data.topic.keywords?.length) {
+      console.log(`  \u5173\u952E\u8BCD\uFF1A${result.data.topic.keywords.join("\u3001")}`);
+    }
+  }
+  if (result.data.outline) {
+    console.log("\n" + chalk.bold.cyan("\u5927\u7EB2"));
+    console.log(`  ${result.data.outline.title}`);
+    result.data.outline.sections.forEach((s, i) => {
+      console.log(`  ${i + 1}. ${s.heading}`);
+    });
+  }
+  if (result.data.article) {
+    const preview = result.data.article.content.slice(0, 300);
+    const truncated = result.data.article.content.length > 300;
+    console.log("\n" + chalk.bold.cyan("\u6587\u7AE0\u9884\u89C8\uFF08\u524D 300 \u5B57\uFF09"));
+    console.log(chalk.gray("\u2500".repeat(40)));
+    console.log(preview + (truncated ? chalk.gray("\n...(\u7701\u7565)") : ""));
+    console.log(chalk.gray("\u2500".repeat(40)));
+    console.log(`  \u5B57\u6570\uFF1A${result.data.article.wordCount}`);
+  }
+  if (result.data.draftId) {
+    console.log(`
+\u8349\u7A3F ID\uFF1A${chalk.bold(result.data.draftId)}`);
+  }
+  console.log("\n" + chalk.green("Pipeline \u5B8C\u6210\uFF01\uFF085 Step \u7AEF\u5230\u7AEF\uFF09"));
+});
+
+// src/commands/config.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4, dirname } from "path";
+var CONFIG_PATH = join4(process.cwd(), ".wxclaw", "config.json");
+function readConfig() {
+  if (!existsSync3(CONFIG_PATH)) return {};
+  return JSON.parse(readFileSync4(CONFIG_PATH, "utf-8"));
+}
+function writeConfig(config) {
+  const dir = dirname(CONFIG_PATH);
+  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync2(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function getByDotPath(obj, path) {
+  return path.split(".").reduce((cur, key) => {
+    if (cur != null && typeof cur === "object") {
+      return cur[key];
+    }
+    return void 0;
+  }, obj);
+}
+function setByDotPath(obj, path, value) {
+  const keys = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (cur[key] == null || typeof cur[key] !== "object") {
+      cur[key] = {};
+    }
+    cur = cur[key];
+  }
+  cur[keys[keys.length - 1]] = value;
+}
+function maskApiKey(val) {
+  if (val.length <= 6) return "***";
+  return `***${val.slice(-3)}`;
+}
+function maskConfig(obj) {
+  if (obj == null || typeof obj !== "object") return obj;
+  const result = {};
+  for (const [k2, v2] of Object.entries(obj)) {
+    if (k2.toLowerCase().includes("apikey") && typeof v2 === "string") {
+      result[k2] = maskApiKey(v2);
+    } else if (typeof v2 === "object" && v2 !== null) {
+      result[k2] = maskConfig(v2);
+    } else {
+      result[k2] = v2;
+    }
+  }
+  return result;
+}
+var configCommand = new Command2("config").description("\u7BA1\u7406 WxClaw \u914D\u7F6E");
+configCommand.command("set <key> <value>").description("\u8BBE\u7F6E\u914D\u7F6E\u9879\uFF08\u5982 providers.minimax.apiKey\uFF09").action((key, value) => {
+  if (value.trim() === "") {
+    console.error(chalk2.red("\u9519\u8BEF\uFF1Avalue \u4E0D\u80FD\u4E3A\u7A7A"));
+    process.exit(1);
+  }
+  const config = readConfig();
+  setByDotPath(config, key, value);
+  writeConfig(config);
+  const displayValue = key.toLowerCase().includes("apikey") ? maskApiKey(value) : value;
+  console.log(chalk2.green(`\u2714 \u5DF2\u8BBE\u7F6E ${chalk2.bold(key)} = ${displayValue}`));
+});
+configCommand.command("get <key>").description("\u83B7\u53D6\u914D\u7F6E\u9879").action((key) => {
+  const config = readConfig();
+  const raw = getByDotPath(config, key);
+  if (raw === void 0) {
+    console.log(chalk2.yellow(`\u914D\u7F6E\u9879 ${chalk2.bold(key)} \u672A\u8BBE\u7F6E`));
+    return;
+  }
+  const display = key.toLowerCase().includes("apikey") && typeof raw === "string" ? maskApiKey(raw) : String(raw);
+  console.log(`${chalk2.bold(key)}: ${display}`);
+});
+configCommand.command("list").description("\u663E\u793A\u6240\u6709\u914D\u7F6E\uFF08API Key \u8131\u654F\uFF09").action(() => {
+  const config = readConfig();
+  if (Object.keys(config).length === 0) {
+    console.log(chalk2.yellow("\u6682\u65E0\u914D\u7F6E\u3002\u4F7F\u7528 wxclaw config set <key> <value> \u6765\u8BBE\u7F6E\u3002"));
+    return;
+  }
+  const masked = maskConfig(config);
+  console.log(chalk2.cyan("WxClaw \u914D\u7F6E\uFF08.wxclaw/config.json\uFF09\uFF1A"));
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  console.log(JSON.stringify(masked, null, 2));
+});
+
+// src/commands/topics.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5 } from "path";
+var CACHE_PATH = join5(process.cwd(), ".wxclaw", "topics-cache.json");
+var MOCK_TOPICS = [
+  { title: "AI Agent 2026\u8D8B\u52BF", heat: 95, source: "weibo" },
+  { title: "GPT-5.4 \u53D1\u5E03", heat: 88, source: "zhihu" },
+  { title: "DeepSeek V4 \u5F00\u6E90", heat: 82, source: "weibo" },
+  { title: "\u56FD\u4EA7\u5927\u6A21\u578B\u5546\u4E1A\u5316\u63D0\u901F", heat: 78, source: "zhihu" },
+  { title: "AI \u7F16\u7A0B\u52A9\u624B\u666E\u53CA\u7387\u7A81\u7834 60%", heat: 75, source: "weibo" },
+  { title: "\u591A\u6A21\u6001\u6A21\u578B\u7EDF\u4E00\u89C6\u89C9\u4E0E\u8BED\u8A00", heat: 70, source: "zhihu" },
+  { title: "\u4F01\u4E1A AI \u6CBB\u7406\u767D\u76AE\u4E66\u53D1\u5E03", heat: 65, source: "weibo" },
+  { title: "Robotics + LLM \u878D\u5408\u65B0\u8FDB\u5C55", heat: 60, source: "zhihu" }
+];
+function heatBar(heat) {
+  const filled = Math.round(heat / 10);
+  return chalk3.red("\u2588".repeat(filled)) + chalk3.gray("\u2591".repeat(10 - filled));
+}
+function printTopics(topics) {
+  console.log(chalk3.cyan("\u70ED\u70B9\u8BDD\u9898"));
+  console.log(chalk3.gray("\u2500".repeat(60)));
+  console.log(
+    chalk3.bold(
+      `${"#".padEnd(4)}${"\u70ED\u5EA6".padEnd(16)}${"\u6765\u6E90".padEnd(8)}\u6807\u9898`
+    )
+  );
+  console.log(chalk3.gray("\u2500".repeat(60)));
+  topics.forEach((t, i) => {
+    const idx = String(i + 1).padEnd(4);
+    const bar = heatBar(t.heat);
+    const src = t.source.padEnd(8);
+    console.log(`${chalk3.gray(idx)}${bar} ${chalk3.yellow(String(t.heat).padStart(2))}  ${chalk3.blue(src)}${t.title}`);
+  });
+  console.log(chalk3.gray("\u2500".repeat(60)));
+  console.log(chalk3.gray(`\u5171 ${topics.length} \u6761\u70ED\u70B9`));
+}
+function saveCache(topics) {
+  const dir = join5(process.cwd(), ".wxclaw");
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync3(CACHE_PATH, JSON.stringify({ fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), topics }, null, 2), "utf-8");
+}
+var topicsCommand = new Command3("topics").description("\u70ED\u70B9\u8BDD\u9898\u7BA1\u7406");
+topicsCommand.command("fetch").description("\u6293\u53D6\u6700\u65B0\u70ED\u70B9").option("--source <source>", "\u6307\u5B9A\u5E73\u53F0\uFF08weibo/zhihu\uFF09").option("--mock", "\u4F7F\u7528 Mock \u6570\u636E").action(async (options) => {
+  if (options.mock) {
+    let topics = MOCK_TOPICS;
+    if (options.source) {
+      topics = topics.filter((t) => t.source === options.source);
+      if (topics.length === 0) {
+        console.log(chalk3.yellow(`\u6CA1\u6709\u6765\u81EA ${options.source} \u7684 Mock \u6570\u636E`));
+        return;
+      }
+    }
+    console.log(chalk3.cyan(`\u6B63\u5728\u83B7\u53D6\u70ED\u70B9\uFF08Mock \u6A21\u5F0F${options.source ? ` - ${options.source}` : ""}\uFF09...`));
+    saveCache(topics);
+    printTopics(topics);
+    console.log(chalk3.green("\n\u5DF2\u7F13\u5B58\u5230 .wxclaw/topics-cache.json"));
+    return;
+  }
+  try {
+    const { ScraperRegistry, TopicAggregator } = await import("@wechat-agent/scrapers");
+    const registry = new ScraperRegistry();
+    const aggregator = new TopicAggregator();
+    const raw = await registry.fetchAll(options.source);
+    const topics = aggregator.aggregate(raw);
+    saveCache(topics);
+    printTopics(topics);
+    console.log(chalk3.green("\n\u5DF2\u7F13\u5B58\u5230 .wxclaw/topics-cache.json"));
+  } catch {
+    console.log(chalk3.yellow("scrapers \u5305\u5C1A\u672A\u53EF\u7528\uFF0C\u8BF7\u4F7F\u7528 --mock \u6A21\u5F0F\uFF1A"));
+    console.log(chalk3.gray("  wxclaw topics fetch --mock"));
+  }
+});
+topicsCommand.command("list").description("\u663E\u793A\u7F13\u5B58\u7684\u70ED\u70B9\u8BDD\u9898").action(() => {
+  if (!existsSync4(CACHE_PATH)) {
+    console.log(chalk3.yellow("\u6682\u65E0\u7F13\u5B58\u6570\u636E\u3002\u8BF7\u5148\u8FD0\u884C\uFF1A"));
+    console.log(chalk3.gray("  wxclaw topics fetch --mock"));
+    return;
+  }
+  const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf-8"));
+  console.log(chalk3.gray(`\u7F13\u5B58\u65F6\u95F4\uFF1A${raw.fetchedAt}`));
+  printTopics(raw.topics);
+});
+
+// src/commands/cron.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
+import { join as join6 } from "path";
+var TASKS_PATH = join6(process.cwd(), ".wxclaw", "scheduler-tasks.json");
+function loadTasks() {
+  if (!existsSync5(TASKS_PATH)) {
+    return [];
+  }
+  try {
+    const raw = readFileSync6(TASKS_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function saveTasks(tasks) {
+  const dir = join6(process.cwd(), ".wxclaw");
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  writeFileSync4(TASKS_PATH, JSON.stringify(tasks, null, 2), "utf-8");
+}
+function generateId() {
+  return `task-${Date.now().toString(36)}`;
+}
+function checkRedis() {
+  return !!process.env["REDIS_URL"];
+}
+var cronCommand = new Command4("cron").description("\u5B9A\u65F6\u4EFB\u52A1\u7BA1\u7406");
+cronCommand.command("list").description("\u663E\u793A\u6240\u6709\u5B9A\u65F6\u4EFB\u52A1").action(() => {
+  const tasks = loadTasks();
+  if (tasks.length === 0) {
+    console.log(chalk4.yellow("\u6682\u65E0\u5B9A\u65F6\u4EFB\u52A1\u3002\u4F7F\u7528 wxclaw cron add \u521B\u5EFA\u4EFB\u52A1\u3002"));
+    return;
+  }
+  console.log(
+    chalk4.bold(
+      `${"ID".padEnd(16)}${"\u72B6\u6001".padEnd(8)}${"Cron".padEnd(16)}${"\u6B65\u9AA4".padEnd(14)}\u540D\u79F0`
+    )
+  );
+  console.log(chalk4.gray("\u2500".repeat(70)));
+  for (const task of tasks) {
+    const status = task.enabled ? chalk4.green("\u542F\u7528".padEnd(8)) : chalk4.gray("\u7981\u7528".padEnd(8));
+    console.log(
+      `${chalk4.cyan(task.id.padEnd(16))}${status}${chalk4.yellow(task.cron.padEnd(16))}${task.step.padEnd(14)}${task.name}`
+    );
+  }
+  console.log(chalk4.gray("\u2500".repeat(70)));
+  console.log(chalk4.gray(`\u5171 ${tasks.length} \u4E2A\u5B9A\u65F6\u4EFB\u52A1`));
+  if (!checkRedis()) {
+    console.log(
+      chalk4.yellow(
+        "\n\u63D0\u793A\uFF1A\u672A\u68C0\u6D4B\u5230 Redis\uFF08REDIS_URL \u672A\u8BBE\u7F6E\uFF09\uFF0C\u5B9A\u65F6\u4EFB\u52A1\u65E0\u6CD5\u81EA\u52A8\u89E6\u53D1\u3002"
+      )
+    );
+  }
+});
+cronCommand.command("add").description("\u521B\u5EFA\u5B9A\u65F6\u4EFB\u52A1").requiredOption("--name <name>", "\u4EFB\u52A1\u540D\u79F0").requiredOption("--step <type>", "\u6B65\u9AA4\u7C7B\u578B\uFF08\u5982 topic-discovery, writing\uFF09").requiredOption("--cron <expression>", "Cron \u8868\u8FBE\u5F0F\uFF08\u5982 '0 8 * * *'\uFF09").action((options) => {
+  const tasks = loadTasks();
+  const task = {
+    id: generateId(),
+    name: options.name,
+    step: options.step,
+    cron: options.cron,
+    enabled: true,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    logs: []
+  };
+  tasks.push(task);
+  saveTasks(tasks);
+  console.log(chalk4.green(`\u5DF2\u521B\u5EFA\u5B9A\u65F6\u4EFB\u52A1\uFF1A${task.name}\uFF08ID: ${task.id}\uFF09`));
+  console.log(chalk4.gray(`  \u6B65\u9AA4\uFF1A${task.step}`));
+  console.log(chalk4.gray(`  \u8BA1\u5212\uFF1A${task.cron}`));
+  if (!checkRedis()) {
+    console.log(
+      chalk4.yellow(
+        "\n\u8B66\u544A\uFF1A\u672A\u68C0\u6D4B\u5230 Redis\uFF08REDIS_URL \u672A\u8BBE\u7F6E\uFF09\uFF0C\u5B9A\u65F6\u4EFB\u52A1\u4EC5\u4FDD\u5B58\u5230\u672C\u5730\uFF0C\u65E0\u6CD5\u81EA\u52A8\u89E6\u53D1\u3002"
+      )
+    );
+  }
+});
+cronCommand.command("enable <id>").description("\u542F\u7528\u5B9A\u65F6\u4EFB\u52A1").action((id) => {
+  const tasks = loadTasks();
+  const task = tasks.find((t) => t.id === id);
+  if (!task) {
+    console.log(chalk4.red(`\u4EFB\u52A1\u4E0D\u5B58\u5728\uFF1A${id}`));
+    process.exit(1);
+  }
+  task.enabled = true;
+  saveTasks(tasks);
+  console.log(chalk4.green(`\u5DF2\u542F\u7528\u4EFB\u52A1\uFF1A${task.name}\uFF08${id}\uFF09`));
+});
+cronCommand.command("disable <id>").description("\u7981\u7528\u5B9A\u65F6\u4EFB\u52A1").action((id) => {
+  const tasks = loadTasks();
+  const task = tasks.find((t) => t.id === id);
+  if (!task) {
+    console.log(chalk4.red(`\u4EFB\u52A1\u4E0D\u5B58\u5728\uFF1A${id}`));
+    process.exit(1);
+  }
+  task.enabled = false;
+  saveTasks(tasks);
+  console.log(chalk4.green(`\u5DF2\u7981\u7528\u4EFB\u52A1\uFF1A${task.name}\uFF08${id}\uFF09`));
+});
+cronCommand.command("logs <id>").description("\u67E5\u770B\u4EFB\u52A1\u6267\u884C\u65E5\u5FD7").option("--limit <n>", "\u663E\u793A\u6700\u8FD1 N \u6761", "20").action((id, options) => {
+  const tasks = loadTasks();
+  const task = tasks.find((t) => t.id === id);
+  if (!task) {
+    console.log(chalk4.red(`\u4EFB\u52A1\u4E0D\u5B58\u5728\uFF1A${id}`));
+    process.exit(1);
+  }
+  const logs = task.logs ?? [];
+  const limit = parseInt(options.limit, 10);
+  const recent = logs.slice(-limit);
+  console.log(chalk4.bold(`\u4EFB\u52A1\u65E5\u5FD7\uFF1A${task.name}\uFF08${id}\uFF09`));
+  console.log(chalk4.gray("\u2500".repeat(60)));
+  if (recent.length === 0) {
+    console.log(chalk4.gray("\u6682\u65E0\u6267\u884C\u8BB0\u5F55"));
+    return;
+  }
+  for (const log of recent) {
+    const icon = log.success ? chalk4.green("\u2713") : chalk4.red("\u2717");
+    const time = chalk4.gray(log.runAt);
+    const msg = log.message ? chalk4.gray(` \u2014 ${log.message}`) : "";
+    console.log(`${icon} ${time}${msg}`);
+  }
+  console.log(chalk4.gray("\u2500".repeat(60)));
+  console.log(chalk4.gray(`\u5171 ${logs.length} \u6761\u8BB0\u5F55\uFF0C\u663E\u793A\u6700\u8FD1 ${recent.length} \u6761`));
+});
+cronCommand.command("run <id>").description("\u624B\u52A8\u7ACB\u5373\u6267\u884C\u4EFB\u52A1").action(async (id) => {
+  const tasks = loadTasks();
+  const task = tasks.find((t) => t.id === id);
+  if (!task) {
+    console.log(chalk4.red(`\u4EFB\u52A1\u4E0D\u5B58\u5728\uFF1A${id}`));
+    process.exit(1);
+  }
+  console.log(chalk4.cyan(`\u6B63\u5728\u624B\u52A8\u6267\u884C\u4EFB\u52A1\uFF1A${task.name}\uFF08${id}\uFF09...`));
+  if (!checkRedis()) {
+    console.log(
+      chalk4.yellow(
+        "\u8B66\u544A\uFF1A\u672A\u68C0\u6D4B\u5230 Redis\uFF08REDIS_URL \u672A\u8BBE\u7F6E\uFF09\uFF0C\u4EFB\u52A1\u5C06\u4EE5\u672C\u5730\u6A21\u5F0F\u8FD0\u884C\u3002"
+      )
+    );
+  }
+  const runAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    if (!task.logs) task.logs = [];
+    task.logs.push({ runAt, success: true, message: "\u624B\u52A8\u89E6\u53D1\uFF08\u672C\u5730\u6A21\u5F0F\uFF09" });
+    task.lastRunAt = runAt;
+    saveTasks(tasks);
+    console.log(chalk4.green(`\u4EFB\u52A1\u6267\u884C\u5B8C\u6210\uFF1A${task.name}`));
+    console.log(
+      chalk4.gray("\u6CE8\u610F\uFF1A\u5B8C\u6574\u7684 pipeline \u6267\u884C\u9700\u8981 scheduler \u5305\u652F\u6301\u3002")
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (!task.logs) task.logs = [];
+    task.logs.push({ runAt, success: false, message });
+    saveTasks(tasks);
+    console.log(chalk4.red(`\u4EFB\u52A1\u6267\u884C\u5931\u8D25\uFF1A${message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/style.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import { readFileSync as readFileSync7, existsSync as existsSync6 } from "fs";
+function typeLabel(type) {
+  switch (type) {
+    case "preset":
+      return "\u9884\u8BBE";
+    case "custom":
+      return "\u81EA\u5B9A\u4E49";
+    case "learned":
+      return "\u5B66\u4E60";
+  }
+}
+var styleCommand = new Command5("style").description("\u5199\u4F5C\u98CE\u683C\u7BA1\u7406");
+styleCommand.command("list").description("\u663E\u793A\u6240\u6709\u98CE\u683C").action(() => {
+  const manager = new StyleManager();
+  const styles = manager.listStyles();
+  console.log(
+    chalk5.bold(
+      `${"ID".padEnd(12)}${"\u7C7B\u578B".padEnd(10)}\u540D\u79F0`
+    )
+  );
+  console.log(chalk5.gray("\u2500".repeat(40)));
+  if (styles.length === 0) {
+    console.log(chalk5.yellow("\u6682\u65E0\u98CE\u683C\u6587\u4EF6\u3002\u8BF7\u68C0\u67E5 .wxclaw/styles/ \u76EE\u5F55\u3002"));
+    return;
+  }
+  for (const s of styles) {
+    console.log(
+      `${chalk5.cyan(s.id.padEnd(12))}${chalk5.gray(typeLabel(s.type).padEnd(10))}${s.name}`
+    );
+  }
+  console.log(chalk5.gray("\u2500".repeat(40)));
+  console.log(chalk5.gray(`\u5171 ${styles.length} \u4E2A\u98CE\u683C`));
+});
+styleCommand.command("add").description("\u6DFB\u52A0\u81EA\u5B9A\u4E49\u98CE\u683C").requiredOption("--name <name>", "\u98CE\u683C\u540D\u79F0").requiredOption("--prompt <prompt>", "\u98CE\u683C\u63D0\u793A\u8BCD").action((options) => {
+  const manager = new StyleManager();
+  const result = manager.addCustomStyle(options.name, options.prompt);
+  console.log(chalk5.green(`\u5DF2\u6DFB\u52A0\u81EA\u5B9A\u4E49\u98CE\u683C\uFF1A${result.name}\uFF08ID: ${result.id}\uFF09`));
+  console.log(chalk5.gray(`\u6587\u4EF6\u5DF2\u4FDD\u5B58\u81F3\uFF1A${result.source}`));
+});
+styleCommand.command("learn").description("\u4ECE\u8303\u6587\u5B66\u4E60\u98CE\u683C\uFF08\u9700\u8981 LLM\uFF09").requiredOption("--file <file>", "\u8303\u6587\u6587\u4EF6\u8DEF\u5F84\uFF08.md \u6216 .txt\uFF09").requiredOption("--name <name>", "\u98CE\u683C\u540D\u79F0").option("--mock", "\u4F7F\u7528 Mock LLM\uFF08\u4E0D\u6D88\u8017 token\uFF09").action(async (options) => {
+  if (!existsSync6(options.file)) {
+    console.log(chalk5.red(`\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${options.file}`));
+    process.exit(1);
+  }
+  const sampleText = readFileSync7(options.file, "utf-8");
+  let llm;
+  if (options.mock) {
+    const mockProfile = {
+      tone: "\u81EA\u7136\u6D41\u7545\uFF0C\u4EB2\u5207\u968F\u548C",
+      sentencePattern: "\u957F\u77ED\u53E5\u7ED3\u5408\uFF0C\u8282\u594F\u81EA\u7136",
+      structure: "\u5F00\u5934\u2192\u5C55\u5F00\u2192\u7ED3\u5C3E",
+      vocabulary: "\u901A\u4FD7\u6613\u61C2\uFF0C\u5076\u5C14\u7528\u4E13\u4E1A\u8BCD\u6C47",
+      openingStyle: "\u6545\u4E8B\u6216\u95EE\u9898\u5F00\u5934",
+      closingStyle: "\u603B\u7ED3\u8981\u70B9\uFF0C\u5F15\u5BFC\u4E92\u52A8",
+      specialHabits: ["\u5584\u7528\u4E3E\u4F8B", "\u6CE8\u91CD\u903B\u8F91"]
+    };
+    llm = {
+      chat: async () => ({
+        content: JSON.stringify(mockProfile)
+      })
+    };
+    console.log(chalk5.yellow("\u4F7F\u7528 Mock LLM \u6A21\u5F0F"));
+  } else {
+    try {
+      const { createLLMClient } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+      llm = createLLMClient();
+    } catch {
+      console.log(chalk5.red("providers \u5305\u4E0D\u53EF\u7528\uFF0C\u8BF7\u4F7F\u7528 --mock \u6A21\u5F0F\uFF1A"));
+      console.log(chalk5.gray(`  wxclaw style learn --file ${options.file} --name "${options.name}" --mock`));
+      process.exit(1);
+    }
+  }
+  console.log(chalk5.cyan(`\u6B63\u5728\u5206\u6790\u8303\u6587\uFF0C\u5B66\u4E60\u98CE\u683C\u300C${options.name}\u300D...`));
+  const manager = new StyleManager();
+  const result = await manager.learnFromSamples(options.name, [sampleText], llm);
+  console.log(chalk5.green(`\u98CE\u683C\u5B66\u4E60\u5B8C\u6210\uFF1A${result.name}\uFF08ID: ${result.id}\uFF09`));
+  console.log(chalk5.gray(`\u6587\u4EF6\u5DF2\u4FDD\u5B58\u81F3\uFF1A${result.source}`));
+  if (result.profile) {
+    console.log(chalk5.bold("\n\u98CE\u683C\u6982\u8981\uFF1A"));
+    console.log(chalk5.gray(`  \u8BED\u6C14\uFF1A${result.profile.tone}`));
+    console.log(chalk5.gray(`  \u53E5\u5F0F\uFF1A${result.profile.sentencePattern}`));
+    console.log(chalk5.gray(`  \u5F00\u5934\uFF1A${result.profile.openingStyle}`));
+    console.log(chalk5.gray(`  \u7ED3\u5C3E\uFF1A${result.profile.closingStyle}`));
+  }
+});
+
+// src/commands/setup.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir2 } from "os";
+import { createInterface } from "readline";
+var setupCommand = new Command6("setup").description("\u4EA4\u4E92\u5F0F\u914D\u7F6E\u5411\u5BFC").action(async () => {
+  console.log("");
+  console.log(chalk6.cyan("\u{1F99E} WxClaw \u914D\u7F6E\u5411\u5BFC"));
+  console.log(chalk6.gray("\u2501".repeat(50)));
+  console.log("");
+  console.log("\u6B22\u8FCE\u4F7F\u7528 WxClaw\uFF01\u8BA9\u6211\u4EEC\u914D\u7F6E\u4F60\u7684\u516C\u4F17\u53F7\u521B\u4F5C Agent\u3002");
+  console.log("");
+  const wxclawDir2 = join7(homedir2(), ".wxclaw");
+  const configPath2 = join7(wxclawDir2, "config.json");
+  if (!existsSync7(wxclawDir2)) {
+    mkdirSync5(wxclawDir2, { recursive: true });
+  }
+  let config = {};
+  if (existsSync7(configPath2)) {
+    try {
+      config = JSON.parse(readFileSync8(configPath2, "utf-8"));
+    } catch {
+    }
+  }
+  if (!config.providers) config.providers = {};
+  if (!config.wechat) config.wechat = {};
+  if (!config.pipeline) config.pipeline = {};
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (question, defaultValue) => {
+    return new Promise((resolve) => {
+      const suffix = defaultValue ? chalk6.gray(` (${defaultValue})`) : "";
+      rl.question(`  ${question}${suffix}: `, (answer) => {
+        resolve(answer.trim() || defaultValue || "");
+      });
+    });
+  };
+  console.log(chalk6.yellow("\u{1F4E6} Step 1/4: LLM Provider \u914D\u7F6E"));
+  console.log(chalk6.gray("  WxClaw \u9700\u8981\u81F3\u5C11\u4E00\u4E2A LLM API Key \u6765\u751F\u6210\u5185\u5BB9\u3002"));
+  console.log("");
+  console.log(chalk6.white("  MiniMax\uFF08\u9ED8\u8BA4 Provider\uFF0C\u63A8\u8350\uFF09"));
+  const minimaxKey = await ask("  MiniMax API Key\uFF08\u7559\u7A7A\u8DF3\u8FC7\uFF09");
+  const providers = config.providers;
+  if (minimaxKey) {
+    if (!providers.minimax) providers.minimax = {};
+    providers.minimax.apiKey = minimaxKey;
+    providers.minimax.defaultModel = providers.minimax.defaultModel || "M2.7";
+    config.defaultProvider = "minimax";
+    console.log(chalk6.green("  \u2713 MiniMax \u5DF2\u914D\u7F6E"));
+  }
+  console.log("");
+  console.log(chalk6.white("  DeepSeek\uFF08\u5907\u9009 Provider\uFF09"));
+  const deepseekKey = await ask("  DeepSeek API Key\uFF08\u7559\u7A7A\u8DF3\u8FC7\uFF09");
+  if (deepseekKey) {
+    if (!providers.deepseek) providers.deepseek = {};
+    providers.deepseek.apiKey = deepseekKey;
+    providers.deepseek.defaultModel = providers.deepseek.defaultModel || "V4";
+    if (!config.defaultProvider) config.defaultProvider = "deepseek";
+    console.log(chalk6.green("  \u2713 DeepSeek \u5DF2\u914D\u7F6E"));
+  }
+  console.log("");
+  console.log(chalk6.white("  OpenAI\uFF08\u53EF\u9009\uFF09"));
+  const openaiKey = await ask("  OpenAI API Key\uFF08\u7559\u7A7A\u8DF3\u8FC7\uFF09");
+  if (openaiKey) {
+    if (!providers.openai) providers.openai = {};
+    providers.openai.apiKey = openaiKey;
+    providers.openai.defaultModel = providers.openai.defaultModel || "gpt-4o-mini";
+    console.log(chalk6.green("  \u2713 OpenAI \u5DF2\u914D\u7F6E"));
+  }
+  console.log("");
+  if (!minimaxKey && !deepseekKey && !openaiKey) {
+    console.log(chalk6.yellow("  \u26A0 \u672A\u914D\u7F6E\u4EFB\u4F55 LLM Provider\u3002\u4F60\u53EF\u4EE5\u4E4B\u540E\u901A\u8FC7 wxclaw config set \u6DFB\u52A0\u3002"));
+    console.log(chalk6.gray("    \u793A\u4F8B\uFF1Awxclaw config set providers.minimax.apiKey sk-xxx"));
+  }
+  console.log("");
+  console.log(chalk6.yellow("\u{1F4F1} Step 2/4: \u5FAE\u4FE1\u516C\u4F17\u53F7\u914D\u7F6E"));
+  console.log(chalk6.gray("  \u53EF\u9009\u3002\u914D\u7F6E\u540E\u53EF\u4EE5\u5C06\u6587\u7AE0\u76F4\u63A5\u4FDD\u5B58\u5230\u516C\u4F17\u53F7\u8349\u7A3F\u7BB1\u3002"));
+  console.log("");
+  const appId = await ask("  \u5FAE\u4FE1 AppID\uFF08\u7559\u7A7A\u8DF3\u8FC7\uFF09");
+  const wechat = config.wechat;
+  if (appId) {
+    wechat.appId = appId;
+    const appSecret = await ask("  \u5FAE\u4FE1 AppSecret");
+    wechat.appSecret = appSecret;
+    console.log(chalk6.green("  \u2713 \u5FAE\u4FE1\u516C\u4F17\u53F7\u5DF2\u914D\u7F6E"));
+  } else {
+    console.log(chalk6.gray("  \u8DF3\u8FC7\u5FAE\u4FE1\u914D\u7F6E\u3002\u6587\u7AE0\u5C06\u53EA\u4FDD\u5B58\u5728\u672C\u5730\u3002"));
+  }
+  console.log("");
+  console.log(chalk6.yellow("\u{1F3AD} Step 3/4: \u516C\u4F17\u53F7\u4EBA\u8BBE"));
+  console.log(chalk6.gray("  \u4F60\u7684\u516C\u4F17\u53F7\u5B9A\u4F4D\u662F\u4EC0\u4E48\uFF1F\u8FD9\u4F1A\u5F71\u54CD AI \u7684\u5199\u4F5C\u98CE\u683C\u3002"));
+  console.log("");
+  const positioning = await ask("  \u516C\u4F17\u53F7\u5B9A\u4F4D\uFF08\u5982\uFF1A\u79D1\u6280\u8BC4\u8BBA\u3001\u804C\u573A\u6210\u957F\uFF09", "\u79D1\u6280\u8BC4\u8BBA");
+  const soulDir = join7(wxclawDir2, "styles");
+  if (!existsSync7(soulDir)) {
+    mkdirSync5(soulDir, { recursive: true });
+  }
+  const soulContent = `# Soul \u2014 \u516C\u4F17\u53F7\u4EBA\u8BBE
+
+\u4F60\u662F\u4E00\u4F4D\u4E13\u6CE8\u4E8E\u300C${positioning}\u300D\u9886\u57DF\u7684\u516C\u4F17\u53F7\u5185\u5BB9\u521B\u4F5C\u8005\u3002
+
+## \u5199\u4F5C\u98CE\u683C
+- \u8BED\u8A00\u7B80\u6D01\u6709\u529B\uFF0C\u907F\u514D\u5197\u957F
+- \u5584\u7528\u7C7B\u6BD4\u8BA9\u590D\u6742\u6982\u5FF5\u901A\u4FD7\u6613\u61C2
+- \u89C2\u70B9\u9C9C\u660E\uFF0C\u4E0D\u8BF4\u6B63\u786E\u7684\u5E9F\u8BDD
+- \u9002\u5F53\u4F7F\u7528\u6570\u636E\u548C\u6848\u4F8B\u652F\u6491\u8BBA\u70B9
+
+## \u8BED\u6C14
+- \u4E13\u4E1A\u4F46\u4E0D\u5B66\u672F
+- \u4EB2\u5207\u4F46\u4E0D\u6CB9\u817B
+- \u81EA\u4FE1\u4F46\u4E0D\u50B2\u6162
+
+## \u7981\u6B62
+- \u4E0D\u4F7F\u7528"\u5C0F\u7F16"\u7B49\u81EA\u79F0
+- \u4E0D\u5806\u780C\u7F51\u7EDC\u6D41\u884C\u8BED
+- \u4E0D\u5199\u6807\u9898\u515A\u5185\u5BB9
+`;
+  writeFileSync5(join7(wxclawDir2, "soul.md"), soulContent, "utf-8");
+  console.log(chalk6.green(`  \u2713 \u516C\u4F17\u53F7\u4EBA\u8BBE\u5DF2\u4FDD\u5B58\uFF08${positioning}\uFF09`));
+  console.log("");
+  console.log(chalk6.yellow("\u{1F3A8} Step 4/4: \u9ED8\u8BA4\u5199\u4F5C\u98CE\u683C"));
+  console.log(
+    chalk6.gray(
+      "  \u53EF\u9009\u98CE\u683C\uFF1Atech(\u79D1\u6280\u9510\u8BC4) / emotion(\u6696\u5FC3\u60C5\u611F) / tutorial(\u5E72\u8D27\u6559\u7A0B) / meme(\u6BB5\u5B50\u624B) / deepdive(\u6DF1\u5EA6\u957F\u6587)"
+    )
+  );
+  console.log("");
+  const defaultStyle = await ask("  \u9ED8\u8BA4\u98CE\u683C", "tech");
+  const pipeline = config.pipeline;
+  pipeline.defaultStyle = defaultStyle;
+  const defaultProvider = config.defaultProvider || "minimax";
+  const defaultProviderConfig = providers[defaultProvider] || {};
+  const defaultModel = defaultProviderConfig.defaultModel || "default";
+  const modelId = `${defaultProvider}:${defaultModel}`;
+  if (!pipeline.stepModelMapping) {
+    pipeline.stepModelMapping = {
+      "topic-discovery": modelId,
+      outline: modelId,
+      writing: modelId,
+      review: modelId
+    };
+  }
+  writeFileSync5(configPath2, JSON.stringify(config, null, 2), "utf-8");
+  const presetStyles = {
+    tech: "# \u79D1\u6280\u9510\u8BC4\n\n\u4E13\u4E1A\u7280\u5229\u7684\u79D1\u6280\u8BC4\u8BBA\u98CE\u683C\uFF0C\u6570\u636E\u9A71\u52A8\uFF0C\u6562\u4E8E\u8868\u8FBE\u89C2\u70B9\u3002",
+    emotion: "# \u6696\u5FC3\u60C5\u611F\n\n\u6E29\u6696\u5171\u60C5\u7684\u60C5\u611F\u7C7B\u98CE\u683C\uFF0C\u5584\u7528\u6545\u4E8B\u5F15\u53D1\u5171\u9E23\u3002",
+    tutorial: "# \u5E72\u8D27\u6559\u7A0B\n\n\u5B9E\u7528\u5BFC\u5411\u7684\u6559\u7A0B\u98CE\u683C\uFF0C\u6B65\u9AA4\u6E05\u6670\uFF0C\u6613\u4E8E\u8DDF\u968F\u3002",
+    meme: "# \u6BB5\u5B50\u624B\n\n\u5E7D\u9ED8\u63A5\u5730\u6C14\u7684\u6BB5\u5B50\u98CE\u683C\uFF0C\u7F51\u611F\u5F3A\uFF0C\u5584\u7528\u6897\u3002",
+    deepdive: "# \u6DF1\u5EA6\u957F\u6587\n\n\u4E25\u8C28\u7684\u6DF1\u5EA6\u5206\u6790\u98CE\u683C\uFF0C\u5F15\u7ECF\u636E\u5178\uFF0C\u903B\u8F91\u7F1C\u5BC6\u3002"
+  };
+  for (const [style, content] of Object.entries(presetStyles)) {
+    const stylePath = join7(soulDir, `${style}.md`);
+    if (!existsSync7(stylePath)) {
+      writeFileSync5(stylePath, content, "utf-8");
+    }
+  }
+  console.log("");
+  console.log(chalk6.cyan("\u2501".repeat(50)));
+  console.log(chalk6.green("\u2705 WxClaw \u914D\u7F6E\u5B8C\u6210\uFF01"));
+  console.log("");
+  console.log("  \u914D\u7F6E\u6587\u4EF6\uFF1A" + chalk6.gray(configPath2));
+  console.log("  \u4EBA\u8BBE\u6587\u4EF6\uFF1A" + chalk6.gray(join7(wxclawDir2, "soul.md")));
+  console.log("  \u98CE\u683C\u76EE\u5F55\uFF1A" + chalk6.gray(soulDir));
+  console.log("");
+  console.log("  \u5FEB\u901F\u5F00\u59CB\uFF1A");
+  console.log(chalk6.cyan('    wxclaw create --topic "\u4F60\u611F\u5174\u8DA3\u7684\u4E3B\u9898"'));
+  console.log("");
+  console.log("  \u66F4\u591A\u547D\u4EE4\uFF1A");
+  console.log(chalk6.gray("    wxclaw --help"));
+  console.log("");
+  rl.close();
+});
+
+// src/index.ts
+var program = new Command7();
+program.name("lewxclaw").description("WxClaw \u2014 \u516C\u4F17\u53F7\u521B\u4F5C Agent").version("0.1.0");
+program.addCommand(setupCommand);
+program.addCommand(createCommand);
+program.addCommand(configCommand);
+program.addCommand(topicsCommand);
+program.addCommand(cronCommand);
+program.addCommand(styleCommand);
+var configPath = join8(homedir3(), ".lewxclaw", "config.json");
+var args = process.argv.slice(2);
+var isSetup = args[0] === "setup";
+var isHelp = args.includes("--help") || args.includes("-h");
+var isVersion = args.includes("--version") || args.includes("-V");
+if (!existsSync8(configPath) && !isSetup && !isHelp && !isVersion && args.length > 0) {
+  console.log(chalk7.yellow("\u{1F99E} \u9996\u6B21\u4F7F\u7528 WxClaw\uFF1F\u8FD0\u884C lewxclaw setup \u6765\u914D\u7F6E\u4F60\u7684 Agent\u3002"));
+  console.log(chalk7.gray('   \u6216\u4F7F\u7528 --mock \u6A21\u5F0F\u514D\u914D\u7F6E\u4F53\u9A8C\uFF1Alewxclaw create --mock --topic "AI \u8D8B\u52BF"'));
+  console.log("");
+}
+program.parse();
+//# sourceMappingURL=index.js.map