hypercore-cli 1.1.0

package/dist/chunk-MV4TTRYX.js

@@ -0,0 +1,533 @@
+import {
+  createToolRegistry
+} from "./chunk-IXOIOGR5.js";
+import {
+  callLLM
+} from "./chunk-43OLRXM5.js";
+import {
+  callOpenAILLM
+} from "./chunk-GOOTEPBK.js";
+import {
+  MODEL_ALIASES,
+  MODEL_PROVIDERS
+} from "./chunk-V5UHPPSY.js";
+import {
+  loadAgent,
+  loadLine,
+  loadPWP,
+  loadSkill
+} from "./chunk-WHLVZCQY.js";
+
+// src/core/workspace-init.ts
+import { mkdir, copyFile, writeFile, readdir } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+var HYPERCORE_DIR = join(process.env.HOME || "~", ".hypercore");
+function getTemplatesDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const projectRoot = join(dirname(thisFile), "..", "..");
+  return join(projectRoot, "templates");
+}
+async function copyTemplateDir(srcDir, destDir) {
+  await mkdir(destDir, { recursive: true });
+  try {
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = join(srcDir, entry.name);
+      const destPath = join(destDir, entry.name);
+      if (entry.isDirectory()) {
+        await copyTemplateDir(srcPath, destPath);
+      } else {
+        if (!existsSync(destPath)) {
+          await copyFile(srcPath, destPath);
+        }
+      }
+    }
+  } catch {
+  }
+}
+function escapeTomlValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function generateConfigToml(provider, apiKey, tavilyKey) {
+  const modelConfigs = {
+    anthropic: { name: "claude-sonnet-4-20250514" },
+    minimax: { name: "MiniMax-M2.5", base_url: "https://api.minimax.io/anthropic" },
+    gemini: { name: "gemini-2.5-flash", base_url: "https://generativelanguage.googleapis.com/v1beta/openai" },
+    deepseek: { name: "deepseek-chat", base_url: "https://api.deepseek.com/v1" }
+  };
+  const modelConfig = modelConfigs[provider] || modelConfigs["gemini"];
+  let config = `# Hypercore \u914D\u7F6E\u6587\u4EF6
+# \u81EA\u52A8\u751F\u6210\uFF0C\u53EF\u624B\u52A8\u4FEE\u6539
+
+[model]
+provider = "${provider}"
+name = "${modelConfig.name}"
+api_key = "${escapeTomlValue(apiKey)}"
+`;
+  if (modelConfig.base_url) {
+    config += `base_url = "${modelConfig.base_url}"
+`;
+  }
+  config += `
+[output]
+dir = "${join(HYPERCORE_DIR, "outputs")}"
+`;
+  if (tavilyKey) {
+    config += `
+[search]
+provider = "tavily"
+api_key = "${escapeTomlValue(tavilyKey)}"
+`;
+  }
+  config += `
+# [keys] \u2014 \u591A\u6A21\u578B\u63D0\u4F9B\u5546 API Key\uFF08\u5DE5\u4F4D\u7EA7\u6A21\u578B\u5207\u6362\u65F6\u4F7F\u7528\uFF09
+# [keys]
+# anthropic = "sk-ant-..."
+# gemini = "AIza..."
+# deepseek = "sk-..."
+# minimax = "..."
+`;
+  return config;
+}
+function generatePWP(role) {
+  return `# \u4E2A\u4EBA\u5DE5\u4F5C\u7A7A\u95F4\u534F\u8BAE\uFF08PWP\uFF09
+
+## \u8EAB\u4EFD
+\u4F60\u662F\u4E00\u4E2A AI \u534F\u4F5C\u7CFB\u7EDF\uFF0C\u4E3A\u4EE5\u4E0B\u7528\u6237\u670D\u52A1\uFF1A
+${role}
+
+\u4F60\u7684\u76EE\u6807\u662F\u5E2E\u52A9\u7528\u6237\u9AD8\u6548\u5B8C\u6210\u77E5\u8BC6\u5DE5\u4F5C\uFF0C\u4EA7\u51FA\u9AD8\u8D28\u91CF\u5185\u5BB9\u3002
+
+## \u54C1\u8D28\u6807\u51C6
+- \u6240\u6709\u8F93\u51FA\u5FC5\u987B\u6709\u5B9E\u8D28\u5185\u5BB9\u548C\u72EC\u5230\u6D1E\u5BDF\uFF0C\u4E0D\u8981\u7A7A\u6D1E\u7684\u5957\u8BDD
+- \u5B81\u6DF1\u52FF\u6D45\uFF0C\u5B81\u7CBE\u52FF\u6CDB
+- \u5FC5\u987B\u6709\u539F\u521B\u89C2\u70B9\u6216\u72EC\u7279\u89C6\u89D2
+- \u6570\u636E\u548C\u6848\u4F8B\u5FC5\u987B\u6709\u6765\u6E90\u652F\u6491
+- \u8BED\u8A00\u7B80\u6D01\u6709\u529B\uFF0C\u4E0D\u62D6\u6CE5\u5E26\u6C34
+- \u5982\u679C\u4FE1\u606F\u4E0D\u8DB3\uFF0C\u660E\u786E\u6807\u6CE8\u800C\u975E\u7F16\u9020
+`;
+}
+async function initializeWorkspace(options) {
+  const { provider, apiKey, tavilyKey, role } = options;
+  await mkdir(HYPERCORE_DIR, { recursive: true });
+  for (const sub of ["agents", "skills", "lines", "outputs", "memory"]) {
+    await mkdir(join(HYPERCORE_DIR, sub), { recursive: true });
+  }
+  const templatesDir = getTemplatesDir();
+  await copyTemplateDir(join(templatesDir, "agents"), join(HYPERCORE_DIR, "agents"));
+  await copyTemplateDir(join(templatesDir, "skills"), join(HYPERCORE_DIR, "skills"));
+  await copyTemplateDir(join(templatesDir, "lines"), join(HYPERCORE_DIR, "lines"));
+  if (role) {
+    const pwpPath = join(HYPERCORE_DIR, "PWP.md");
+    if (!existsSync(pwpPath)) {
+      await writeFile(pwpPath, generatePWP(role), "utf-8");
+    }
+  }
+  const configPath = join(HYPERCORE_DIR, "config.toml");
+  if (existsSync(configPath)) {
+    const { copyFile: cpFile } = await import("fs/promises");
+    await cpFile(configPath, configPath + ".bak");
+  }
+  await writeFile(
+    configPath,
+    generateConfigToml(provider, apiKey, tavilyKey),
+    "utf-8"
+  );
+}
+
+// src/core/engine.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/core/prompt-assembler.ts
+function assembleSystemPrompt(pwp, agent, skill) {
+  const parts = [];
+  parts.push("## \u5DE5\u4F5C\u7A7A\u95F4\u534F\u8BAE\uFF08PWP\uFF09");
+  if (pwp.identity) {
+    parts.push(pwp.identity);
+  }
+  if (pwp.qualityStandards.length > 0) {
+    parts.push("\n### \u54C1\u8D28\u6807\u51C6");
+    for (const standard of pwp.qualityStandards) {
+      parts.push(`- ${standard}`);
+    }
+  }
+  parts.push(`
+## \u4F60\u7684\u89D2\u8272\uFF1A${agent.name}`);
+  if (agent.role) {
+    parts.push(agent.role);
+  }
+  if (agent.style) {
+    parts.push(`
+### \u98CE\u683C`);
+    parts.push(agent.style);
+  }
+  if (skill) {
+    parts.push(`
+## \u9886\u57DF\u77E5\u8BC6\uFF1A${skill.name}`);
+    if (skill.knowledge) {
+      parts.push(skill.knowledge);
+    }
+    if (skill.toolStrategy) {
+      parts.push("\n### \u5DE5\u5177\u4F7F\u7528\u7B56\u7565");
+      parts.push(skill.toolStrategy);
+    }
+    if (skill.qualityStandards.length > 0) {
+      parts.push("\n### \u9886\u57DF\u8D28\u91CF\u6807\u51C6");
+      for (const standard of skill.qualityStandards) {
+        parts.push(`- ${standard}`);
+      }
+    }
+  }
+  parts.push("\n## \u901A\u7528\u6307\u4EE4");
+  parts.push("- \u6240\u6709\u8F93\u51FA\u4F7F\u7528\u4E2D\u6587");
+  parts.push("- \u9700\u8981\u6700\u65B0\u4FE1\u606F\u65F6\u4E3B\u52A8\u4F7F\u7528 web_search \u5DE5\u5177");
+  parts.push("- \u8F93\u51FA\u5FC5\u987B\u6709\u5B9E\u8D28\u5185\u5BB9\u548C\u6D1E\u5BDF\uFF0C\u4E0D\u8981\u7A7A\u6D1E\u7684\u5957\u8BDD");
+  parts.push("- \u5982\u679C\u4FE1\u606F\u4E0D\u8DB3\uFF0C\u660E\u786E\u6807\u6CE8\u800C\u975E\u7F16\u9020");
+  return parts.join("\n");
+}
+function assembleUserPrompt(station, userInputs, upstreamOutput) {
+  const parts = [];
+  parts.push("## \u5F53\u524D\u4EFB\u52A1");
+  parts.push(station.task);
+  if (Object.keys(userInputs).length > 0) {
+    parts.push("\n## \u7528\u6237\u8F93\u5165");
+    for (const [key, value] of Object.entries(userInputs)) {
+      parts.push(`- **${key}**: ${value}`);
+    }
+  }
+  if (upstreamOutput) {
+    parts.push("\n## \u4E0A\u4E00\u4E2A\u5DE5\u4F4D\u7684\u4EA7\u51FA");
+    if (upstreamOutput.length > 4e3) {
+      parts.push(upstreamOutput.slice(0, 4e3));
+      parts.push("\n...(\u5185\u5BB9\u5DF2\u622A\u53D6\uFF0C\u4EE5\u4E0A\u4E3A\u4E3B\u8981\u90E8\u5206)");
+    } else {
+      parts.push(upstreamOutput);
+    }
+  }
+  if (station.checkpoint === "decision") {
+    parts.push("\n## \u6CE8\u610F");
+    parts.push("\u8BF7\u63D0\u4F9B\u591A\u4E2A\u5019\u9009\u65B9\u6848\u4F9B\u7528\u6237\u9009\u62E9\u3002\u5217\u51FA 2-3 \u4E2A\u65B9\u6848\uFF0C\u6BCF\u4E2A\u65B9\u6848\u5305\u542B\u6807\u9898\u548C\u7B80\u8981\u8BF4\u660E\u3002");
+  } else if (station.checkpoint === "approval") {
+    parts.push("\n## \u6CE8\u610F");
+    parts.push("\u8FD9\u662F\u7EC8\u5BA1\u5DE5\u4F4D\u3002\u8BF7\u786E\u4FDD\u4EA7\u51FA\u7684\u5B8C\u6574\u6027\u548C\u8D28\u91CF\uFF0C\u7528\u6237\u5C06\u5BA1\u9605\u4F60\u7684\u6700\u7EC8\u4EA7\u51FA\u3002");
+  }
+  return parts.join("\n");
+}
+
+// src/core/engine.ts
+var Engine = class {
+  client;
+  config;
+  hypercoreDir;
+  tools = [];
+  constructor(client, config, hypercoreDir) {
+    this.client = client;
+    this.config = config;
+    this.hypercoreDir = hypercoreDir;
+  }
+  /** 初始化工具（async，需在 run 前调用） */
+  async init() {
+    this.tools = await createToolRegistry(this.config);
+  }
+  /**
+   * 解析工位级模型覆盖
+   * 支持别名（flash, sonnet）和完整模型名
+   * 返回解析后的模型名和 SDK 类型
+   */
+  resolveStationModel(station) {
+    if (!station.model) {
+      return {
+        model: this.config.modelConfig.model,
+        sdkType: this.config.modelConfig.sdkType,
+        baseURL: this.config.modelConfig.baseURL,
+        apiKey: this.config.modelConfig.apiKey
+      };
+    }
+    const alias = MODEL_ALIASES[station.model.toLowerCase()];
+    if (alias) {
+      const providerInfo = MODEL_PROVIDERS[alias.provider];
+      const apiKey = this.config.providerKeys[alias.provider] || this.config.modelConfig.apiKey;
+      return {
+        model: alias.model,
+        sdkType: providerInfo.sdkType,
+        baseURL: providerInfo.baseURL,
+        apiKey
+      };
+    }
+    const modelLower = station.model.toLowerCase();
+    if (modelLower.includes("claude")) {
+      const apiKey = this.config.providerKeys["anthropic"] || this.config.modelConfig.apiKey;
+      return { model: station.model, sdkType: "anthropic", apiKey };
+    }
+    if (modelLower.includes("gemini")) {
+      const apiKey = this.config.providerKeys["gemini"] || this.config.modelConfig.apiKey;
+      return { model: station.model, sdkType: "openai", baseURL: MODEL_PROVIDERS["gemini"].baseURL, apiKey };
+    }
+    if (modelLower.includes("deepseek")) {
+      const apiKey = this.config.providerKeys["deepseek"] || this.config.modelConfig.apiKey;
+      return { model: station.model, sdkType: "openai", baseURL: MODEL_PROVIDERS["deepseek"].baseURL, apiKey };
+    }
+    if (modelLower.includes("gpt")) {
+      const apiKey = this.config.providerKeys["openai-compatible"] || this.config.modelConfig.apiKey;
+      return { model: station.model, sdkType: "openai", baseURL: this.config.modelConfig.baseURL, apiKey };
+    }
+    return {
+      model: station.model,
+      sdkType: this.config.modelConfig.sdkType,
+      baseURL: this.config.modelConfig.baseURL,
+      apiKey: this.config.modelConfig.apiKey
+    };
+  }
+  /**
+   * 根据 sdkType 调用对应的 LLM 客户端
+   * 支持工位级模型覆盖（不同 sdkType 动态创建客户端）
+   */
+  async invokeLLM(options, sdkTypeOverride, baseURLOverride, apiKeyOverride) {
+    const sdkType = sdkTypeOverride || this.config.modelConfig.sdkType;
+    const apiKey = apiKeyOverride || this.config.modelConfig.apiKey;
+    if (sdkType === "openai") {
+      if (this.config.modelConfig.sdkType !== "openai" || baseURLOverride || apiKeyOverride) {
+        const OpenAI2 = await import("openai");
+        const tempClient = new OpenAI2.default({
+          apiKey,
+          baseURL: baseURLOverride || this.config.modelConfig.baseURL
+        });
+        return callOpenAILLM(tempClient, options);
+      }
+      const OpenAI = await import("openai");
+      return callOpenAILLM(this.client, options);
+    }
+    if (this.config.modelConfig.sdkType !== "anthropic" || apiKeyOverride) {
+      const Anthropic2 = await import("@anthropic-ai/sdk");
+      const tempClient = new Anthropic2.default({ apiKey });
+      return callLLM(tempClient, options);
+    }
+    const Anthropic = await import("@anthropic-ai/sdk");
+    return callLLM(this.client, options);
+  }
+  /**
+   * 评估条件表达式
+   * 支持简单的关键词匹配：检查上游输出是否包含指定关键词
+   * 格式：'contains:关键词' 或 'not_empty' 或直接传入关键词
+   */
+  evaluateCondition(condition, upstreamOutput) {
+    if (!upstreamOutput) return false;
+    const condLower = condition.toLowerCase().trim();
+    if (condLower === "not_empty") {
+      return upstreamOutput.trim().length > 0;
+    }
+    if (condLower.startsWith("contains:")) {
+      const keyword = condition.slice("contains:".length).trim();
+      return upstreamOutput.includes(keyword);
+    }
+    if (condLower.startsWith("not_contains:")) {
+      const keyword = condition.slice("not_contains:".length).trim();
+      return !upstreamOutput.includes(keyword);
+    }
+    return upstreamOutput.includes(condition.trim());
+  }
+  async run(lineName, userInputs, callbacks) {
+    const startTime = /* @__PURE__ */ new Date();
+    if (this.tools.length === 0) {
+      await this.init();
+    }
+    const line = await loadLine(this.hypercoreDir, lineName);
+    let pwp;
+    try {
+      pwp = await loadPWP(this.hypercoreDir);
+    } catch {
+      pwp = { identity: "", qualityStandards: [], rawContent: "" };
+    }
+    const stationResults = [];
+    let upstreamOutput;
+    const totalTokens = { inputTokens: 0, outputTokens: 0 };
+    for (const station of line.stations) {
+      if (station.condition) {
+        const shouldRun = this.evaluateCondition(station.condition, upstreamOutput);
+        if (!shouldRun) {
+          callbacks.onStationSkipped?.(station.index, station.name, `\u6761\u4EF6\u4E0D\u6EE1\u8DB3: ${station.condition}`);
+          stationResults.push({
+            stationIndex: station.index,
+            stationName: station.name,
+            agentName: station.agentName,
+            output: upstreamOutput || "",
+            toolCalls: [],
+            tokenUsage: { inputTokens: 0, outputTokens: 0 }
+          });
+          continue;
+        }
+      }
+      callbacks.onStationStart(
+        station.index,
+        line.stations.length,
+        station.name,
+        station.agentName
+      );
+      const { model: stationModel, sdkType: stationSdkType, baseURL: stationBaseURL, apiKey: stationApiKey } = this.resolveStationModel(station);
+      let agent;
+      try {
+        agent = await loadAgent(this.hypercoreDir, station.agentName);
+      } catch {
+        agent = {
+          name: station.agentName,
+          role: `\u4F60\u662F${station.agentName}`,
+          skillIds: [],
+          style: "",
+          rawContent: ""
+        };
+      }
+      let skill;
+      if (station.skillName) {
+        try {
+          skill = await loadSkill(this.hypercoreDir, station.skillName);
+        } catch {
+        }
+      }
+      const systemPrompt = assembleSystemPrompt(pwp, agent, skill);
+      const userPrompt = assembleUserPrompt(station, userInputs, upstreamOutput);
+      const maxRetry = station.retry || 0;
+      let result = null;
+      let lastError = null;
+      for (let attempt = 0; attempt <= maxRetry; attempt++) {
+        try {
+          if (attempt > 0) {
+            callbacks.onStationRetry?.(
+              station.index,
+              station.name,
+              attempt,
+              maxRetry,
+              lastError?.message || "\u672A\u77E5\u9519\u8BEF"
+            );
+          }
+          result = await this.invokeLLM(
+            {
+              systemPrompt,
+              userPrompt,
+              tools: this.tools,
+              model: stationModel,
+              onText: (text) => callbacks.onStationText(text),
+              onToolCall: (name, input) => callbacks.onToolCall(name, input),
+              onToolCallDone: callbacks.onToolCallDone ? (name, dur) => callbacks.onToolCallDone(name, dur) : void 0,
+              onThinking: callbacks.onThinking ? (text) => callbacks.onThinking(text) : void 0
+            },
+            stationSdkType,
+            stationBaseURL,
+            stationApiKey !== this.config.modelConfig.apiKey ? stationApiKey : void 0
+          );
+          break;
+        } catch (err) {
+          lastError = err instanceof Error ? err : new Error(String(err));
+          if (attempt >= maxRetry) {
+            throw lastError;
+          }
+        }
+      }
+      if (!result) throw new Error(`\u5DE5\u4F4D ${station.name} \u6267\u884C\u5931\u8D25`);
+      const stationResult = {
+        stationIndex: station.index,
+        stationName: station.name,
+        agentName: station.agentName,
+        output: result.output,
+        toolCalls: result.toolCalls,
+        tokenUsage: result.tokenUsage
+      };
+      stationResults.push(stationResult);
+      totalTokens.inputTokens += result.tokenUsage.inputTokens;
+      totalTokens.outputTokens += result.tokenUsage.outputTokens;
+      callbacks.onStationComplete(station.index, station.name);
+      if (station.checkpoint) {
+        const checkpointResult = await callbacks.onCheckpoint(
+          station.checkpoint,
+          result.output,
+          station.checkpointDescription
+        );
+        if (checkpointResult.action === "modify" && checkpointResult.feedback) {
+          const modifyPrompt = `\u7528\u6237\u5BF9\u4F60\u7684\u4EA7\u51FA\u7ED9\u4E86\u4EE5\u4E0B\u53CD\u9988\uFF0C\u8BF7\u636E\u6B64\u4FEE\u6539\uFF1A
+
+${checkpointResult.feedback}
+
+\u4F60\u4E4B\u524D\u7684\u4EA7\u51FA\uFF1A
+${result.output}`;
+          const modifyResult = await this.invokeLLM(
+            {
+              systemPrompt,
+              userPrompt: modifyPrompt,
+              tools: this.tools,
+              model: stationModel,
+              onText: (text) => callbacks.onStationText(text),
+              onToolCall: (name, input) => callbacks.onToolCall(name, input),
+              onToolCallDone: callbacks.onToolCallDone ? (name, dur) => callbacks.onToolCallDone(name, dur) : void 0,
+              onThinking: callbacks.onThinking ? (text) => callbacks.onThinking(text) : void 0
+            },
+            stationSdkType,
+            stationBaseURL,
+            stationApiKey !== this.config.modelConfig.apiKey ? stationApiKey : void 0
+          );
+          stationResult.output = modifyResult.output;
+          totalTokens.inputTokens += modifyResult.tokenUsage.inputTokens;
+          totalTokens.outputTokens += modifyResult.tokenUsage.outputTokens;
+        }
+      }
+      upstreamOutput = stationResult.output;
+    }
+    const finalOutput = stationResults[stationResults.length - 1]?.output || "";
+    const outputDir = join2(this.config.outputDir);
+    await mkdir2(outputDir, { recursive: true });
+    const endTime = /* @__PURE__ */ new Date();
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const sanitizedName = lineName.replace(/[^\w\u4e00-\u9fff-]/g, "_");
+    const outputPath = join2(outputDir, `${date}-${sanitizedName}.md`);
+    const durationMin = ((endTime.getTime() - startTime.getTime()) / 6e4).toFixed(1);
+    const totalTokenCount = totalTokens.inputTokens + totalTokens.outputTokens;
+    const frontmatter = [
+      "---",
+      `line: ${lineName}`,
+      `date: ${startTime.toISOString()}`,
+      `model: ${this.config.modelConfig.model}`,
+      `tokens: ${totalTokenCount}`,
+      `duration: ${durationMin}min`,
+      `stations: ${line.stations.length}`,
+      "---",
+      ""
+    ].join("\n");
+    await writeFile2(outputPath, frontmatter + finalOutput, "utf-8");
+    const runMeta = {
+      lineName,
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      model: this.config.modelConfig.model,
+      userInputs,
+      totalTokens,
+      stations: stationResults.map((s) => ({
+        index: s.stationIndex,
+        name: s.stationName,
+        agent: s.agentName,
+        output: s.output,
+        toolCalls: s.toolCalls,
+        tokens: s.tokenUsage
+      }))
+    };
+    const jsonPath = outputPath.replace(/\.md$/, ".run.json");
+    await writeFile2(jsonPath, JSON.stringify(runMeta, null, 2), "utf-8");
+    const runResult = {
+      lineName,
+      stationResults,
+      finalOutput,
+      totalTokens,
+      outputPath,
+      startTime,
+      endTime
+    };
+    callbacks.onComplete(runResult);
+    return runResult;
+  }
+};
+
+export {
+  HYPERCORE_DIR,
+  initializeWorkspace,
+  Engine
+};

package/dist/chunk-OPZYEVYR.js

@@ -0,0 +1,150 @@
+import {
+  listItems
+} from "./chunk-MGLJ53QN.js";
+
+// src/admin/roadmap.ts
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+var HYPERCORE_DIR = join(process.env.HOME || "~", ".hypercore");
+var ADMIN_DIR = join(HYPERCORE_DIR, "admin");
+var MILESTONES_FILE = join(ADMIN_DIR, "milestones.json");
+async function ensureDir() {
+  if (!existsSync(ADMIN_DIR)) {
+    await mkdir(ADMIN_DIR, { recursive: true });
+  }
+}
+async function loadStore() {
+  await ensureDir();
+  if (!existsSync(MILESTONES_FILE)) {
+    return { milestones: [] };
+  }
+  try {
+    const raw = await readFile(MILESTONES_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { milestones: [] };
+  }
+}
+async function saveStore(store) {
+  await ensureDir();
+  await writeFile(MILESTONES_FILE, JSON.stringify(store, null, 2), "utf-8");
+}
+async function addMilestone(version, name, description) {
+  const store = await loadStore();
+  if (store.milestones.find((m) => m.version === version)) {
+    throw new Error(`\u91CC\u7A0B\u7891 ${version} \u5DF2\u5B58\u5728`);
+  }
+  const milestone = {
+    version,
+    name,
+    description: description || "",
+    status: "planning",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    doneAt: null
+  };
+  store.milestones.push(milestone);
+  await saveStore(store);
+  return milestone;
+}
+async function doneMilestone(version) {
+  const store = await loadStore();
+  const ms = store.milestones.find((m) => m.version === version);
+  if (!ms) return null;
+  ms.status = "done";
+  ms.doneAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveStore(store);
+  return ms;
+}
+async function activateMilestone(version) {
+  const store = await loadStore();
+  const ms = store.milestones.find((m) => m.version === version);
+  if (!ms) return null;
+  ms.status = "active";
+  await saveStore(store);
+  return ms;
+}
+async function listMilestones() {
+  const store = await loadStore();
+  return store.milestones;
+}
+async function getMilestone(version) {
+  const store = await loadStore();
+  return store.milestones.find((m) => m.version === version) || null;
+}
+async function getRoadmap() {
+  const allItems = await listItems();
+  const milestones = await listMilestones();
+  const grouped = {};
+  const unversioned = [];
+  for (const item of allItems) {
+    if (item.targetVersion) {
+      if (!grouped[item.targetVersion]) grouped[item.targetVersion] = [];
+      grouped[item.targetVersion].push(item);
+    } else {
+      unversioned.push(item);
+    }
+  }
+  for (const ms of milestones) {
+    if (!grouped[ms.version]) grouped[ms.version] = [];
+  }
+  const versions = Object.keys(grouped).sort(compareVersions);
+  const roadmap = versions.map((ver) => {
+    const items = grouped[ver];
+    const milestone = milestones.find((m) => m.version === ver) || null;
+    const done = items.filter((i) => i.status === "done").length;
+    const developing = items.filter((i) => i.status === "developing").length;
+    const planned = items.filter((i) => i.status === "planned").length;
+    const idea = items.filter((i) => i.status === "idea").length;
+    const total = items.length;
+    return {
+      version: ver,
+      milestone,
+      items,
+      stats: {
+        total,
+        done,
+        developing,
+        planned,
+        idea,
+        progress: total > 0 ? Math.round(done / total * 100) : 0
+      }
+    };
+  });
+  if (unversioned.length > 0) {
+    const done = unversioned.filter((i) => i.status === "done").length;
+    roadmap.push({
+      version: "(\u672A\u5206\u914D)",
+      milestone: null,
+      items: unversioned,
+      stats: {
+        total: unversioned.length,
+        done,
+        developing: unversioned.filter((i) => i.status === "developing").length,
+        planned: unversioned.filter((i) => i.status === "planned").length,
+        idea: unversioned.filter((i) => i.status === "idea").length,
+        progress: unversioned.length > 0 ? Math.round(done / unversioned.length * 100) : 0
+      }
+    });
+  }
+  return roadmap;
+}
+function compareVersions(a, b) {
+  const normalize = (v) => v.replace(/^v/, "").split(".").map((n) => parseInt(n) || 0);
+  const aParts = normalize(a);
+  const bParts = normalize(b);
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    const diff = (aParts[i] || 0) - (bParts[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+export {
+  addMilestone,
+  doneMilestone,
+  activateMilestone,
+  listMilestones,
+  getMilestone,
+  getRoadmap
+};