@nick848/sf-cli 1.0.15 → 1.0.16

package/dist/cli/index.js

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 'use strict';
 
-var fs7 = require('fs/promises');
-var fs9 = require('fs');
-var path7 = require('path');
-var crypto = require('crypto');
-var os = require('os');
 var tiktoken = require('tiktoken');
-require('@modelcontextprotocol/sdk/client/index.js');
-require('@modelcontextprotocol/sdk/client/stdio.js');
 var chalk9 = require('chalk');
 var enquirer = require('enquirer');
 var child_process = require('child_process');
+var fs7 = require('fs');
+var path5 = require('path');
+var fs5 = require('fs/promises');
 var commander = require('commander');
 var readline = require('readline');
 require('uuid');
+var crypto = require('crypto');
+var os = require('os');
+require('@modelcontextprotocol/sdk/client/index.js');
+require('@modelcontextprotocol/sdk/client/stdio.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -36,13 +36,13 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var chalk9__default = /*#__PURE__*/_interopDefault(chalk9);
 var fs7__namespace = /*#__PURE__*/_interopNamespace(fs7);
-var fs9__namespace = /*#__PURE__*/_interopNamespace(fs9);
-var path7__namespace = /*#__PURE__*/_interopNamespace(path7);
+var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
+var fs5__namespace = /*#__PURE__*/_interopNamespace(fs5);
+var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var chalk9__default = /*#__PURE__*/_interopDefault(chalk9);
-var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -59,138 +59,6 @@ var init_cjs_shims = __esm({
   "node_modules/tsup/assets/cjs_shims.js"() {
   }
 });
-function getOrCreateEncryptionKey() {
-  const keyPath = path7__namespace.join(os__namespace.homedir(), KEY_DIR, KEY_FILE);
-  try {
-    if (fs9__namespace.existsSync(keyPath)) {
-      const keyBase64 = fs9__namespace.readFileSync(keyPath, "utf-8").trim();
-      return Buffer.from(keyBase64, "base64");
-    }
-  } catch {
-  }
-  const key = crypto__namespace.randomBytes(32);
-  try {
-    const keyDir = path7__namespace.dirname(keyPath);
-    if (!fs9__namespace.existsSync(keyDir)) {
-      fs9__namespace.mkdirSync(keyDir, { recursive: true, mode: 448 });
-    }
-    fs9__namespace.writeFileSync(keyPath, key.toString("base64"), {
-      mode: 384,
-      // 仅所有者可读写
-      encoding: "utf-8"
-    });
-    return key;
-  } catch {
-    const machineId = [
-      os__namespace.hostname(),
-      os__namespace.platform(),
-      os__namespace.arch(),
-      process.env.USERNAME || process.env.USER || "default"
-    ].join("-");
-    return crypto__namespace.createHash("sha256").update(machineId).digest();
-  }
-}
-var DEFAULT_CONFIG, ALGORITHM, IV_LENGTH, KEY_DIR, KEY_FILE, ConfigManager;
-var init_config = __esm({
-  "src/services/config.ts"() {
-    init_cjs_shims();
-    DEFAULT_CONFIG = {
-      model: "GLM-5",
-      apiKey: "",
-      yolo: false,
-      locale: "zh-CN",
-      theme: "auto"
-    };
-    ALGORITHM = "aes-256-gcm";
-    IV_LENGTH = 16;
-    KEY_DIR = ".sf-cli";
-    KEY_FILE = ".key";
-    ConfigManager = class {
-      config;
-      configPath = "";
-      projectPath = "";
-      encryptionKey;
-      constructor() {
-        this.config = { ...DEFAULT_CONFIG };
-        this.encryptionKey = getOrCreateEncryptionKey();
-      }
-      async load(projectPath) {
-        this.projectPath = projectPath;
-        this.configPath = path7__namespace.join(projectPath, ".sf-cli", "config.json");
-        try {
-          const content = await fs7__namespace.readFile(this.configPath, "utf-8");
-          const loaded = JSON.parse(content);
-          if (loaded.apiKey && loaded.apiKeyEncrypted) {
-            loaded.apiKey = this.decrypt(loaded.apiKey);
-            delete loaded.apiKeyEncrypted;
-          }
-          this.config = { ...DEFAULT_CONFIG, ...loaded };
-        } catch {
-          this.config = { ...DEFAULT_CONFIG };
-        }
-      }
-      async save() {
-        if (!this.configPath) return;
-        const configToSave = { ...this.config };
-        if (configToSave.apiKey) {
-          const encrypted = this.encrypt(configToSave.apiKey);
-          configToSave.apiKey = encrypted;
-          configToSave.apiKeyEncrypted = true;
-        }
-        await fs7__namespace.mkdir(path7__namespace.dirname(this.configPath), { recursive: true });
-        await fs7__namespace.writeFile(
-          this.configPath,
-          JSON.stringify(configToSave, null, 2),
-          "utf-8"
-        );
-      }
-      get(key) {
-        return this.config[key];
-      }
-      set(key, value) {
-        this.config[key] = value;
-      }
-      getAll() {
-        return { ...this.config };
-      }
-      update(updates) {
-        this.config = { ...this.config, ...updates };
-      }
-      /**
-       * 加密敏感数据
-       */
-      encrypt(text) {
-        const iv = crypto__namespace.randomBytes(IV_LENGTH);
-        const cipher = crypto__namespace.createCipheriv(ALGORITHM, this.encryptionKey, iv);
-        let encrypted = cipher.update(text, "utf8", "base64");
-        encrypted += cipher.final("base64");
-        const authTag = cipher.getAuthTag();
-        return `${iv.toString("base64")}:${authTag.toString("base64")}:${encrypted}`;
-      }
-      /**
-       * 解密敏感数据
-       */
-      decrypt(encryptedData) {
-        try {
-          const parts = encryptedData.split(":");
-          if (parts.length !== 3) {
-            return encryptedData;
-          }
-          const [ivBase64, authTagBase64, encrypted] = parts;
-          const iv = Buffer.from(ivBase64, "base64");
-          const authTag = Buffer.from(authTagBase64, "base64");
-          const decipher = crypto__namespace.createDecipheriv(ALGORITHM, this.encryptionKey, iv);
-          decipher.setAuthTag(authTag);
-          let decrypted = decipher.update(encrypted, "base64", "utf8");
-          decrypted += decipher.final("utf8");
-          return decrypted;
-        } catch {
-          return "";
-        }
-      }
-    };
-  }
-});
 
 // src/types/model.ts
 function getModelInfo(modelId) {
@@ -1078,312 +946,6 @@ var init_adapters = __esm({
     DEEPSEEK_API_ENDPOINT = "https://api.deepseek.com/v1";
   }
 });
-var ModelService;
-var init_model2 = __esm({
-  "src/services/model.ts"() {
-    init_cjs_shims();
-    init_model();
-    init_adapters();
-    ModelService = class {
-      adapters = /* @__PURE__ */ new Map();
-      currentConfig = null;
-      stats;
-      configManager;
-      statsPath = "";
-      constructor(configManager) {
-        this.configManager = configManager;
-        this.stats = {
-          totalInput: 0,
-          totalOutput: 0,
-          byModel: {},
-          byAgent: {},
-          byDate: {}
-        };
-      }
-      /**
-       * 初始化服务
-       */
-      async initialize(statsDir) {
-        this.statsPath = path7__namespace.join(statsDir, "tokens");
-        await this.loadStats();
-        const model = this.configManager.get("model");
-        const apiKey = this.configManager.get("apiKey");
-        if (model && apiKey) {
-          await this.configureModel({
-            provider: this.getProviderFromModel(model),
-            model,
-            apiKey
-          });
-        }
-      }
-      /**
-       * 配置模型
-       */
-      async configureModel(config) {
-        let adapter = this.adapters.get(config.provider);
-        if (!adapter) {
-          adapter = createAdapter(config.provider);
-          this.adapters.set(config.provider, adapter);
-        }
-        await adapter.initialize(config);
-        this.currentConfig = config;
-        this.configManager.set("model", config.model);
-        this.configManager.set("apiKey", config.apiKey);
-        await this.configManager.save();
-      }
-      /**
-       * 发送消息
-       */
-      async sendMessage(messages, options) {
-        if (!this.currentConfig) {
-          throw new Error("\u6A21\u578B\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u6267\u884C /model \u547D\u4EE4");
-        }
-        const adapter = this.adapters.get(this.currentConfig.provider);
-        if (!adapter || !adapter.isInitialized()) {
-          throw new Error("\u6A21\u578B\u9002\u914D\u5668\u672A\u521D\u59CB\u5316");
-        }
-        try {
-          const response = await adapter.sendMessage(messages, options);
-          this.updateStats(response.usage, {
-            model: this.currentConfig.model,
-            agent: options?.agent
-          });
-          this.saveStats().catch(() => {
-          });
-          return response;
-        } catch (error) {
-          throw this.wrapError(error);
-        }
-      }
-      /**
-       * 流式发送消息
-       */
-      async *streamMessage(messages, options) {
-        if (!this.currentConfig) {
-          throw new Error("\u6A21\u578B\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u6267\u884C /model \u547D\u4EE4");
-        }
-        const adapter = this.adapters.get(this.currentConfig.provider);
-        if (!adapter || !adapter.isInitialized()) {
-          throw new Error("\u6A21\u578B\u9002\u914D\u5668\u672A\u521D\u59CB\u5316");
-        }
-        let totalTokens = 0;
-        try {
-          for await (const chunk of adapter.streamMessage(messages, options)) {
-            totalTokens += chunk.delta.length;
-            yield chunk;
-          }
-          const inputTokens = adapter.countTokens(
-            messages.map((m) => m.content).join("\n")
-          );
-          this.updateStats(
-            { inputTokens, outputTokens: Math.ceil(totalTokens / 4), totalTokens: 0 },
-            { model: this.currentConfig.model, agent: options?.agent }
-          );
-          this.saveStats().catch(() => {
-          });
-        } catch (error) {
-          throw this.wrapError(error);
-        }
-      }
-      /**
-       * 计算Token数量
-       */
-      countTokens(text) {
-        if (!this.currentConfig) {
-          return Math.ceil(text.length / 4);
-        }
-        const adapter = this.adapters.get(this.currentConfig.provider);
-        return adapter?.countTokens(text) || Math.ceil(text.length / 4);
-      }
-      /**
-       * 获取当前模型
-       */
-      getCurrentModel() {
-        return this.currentConfig?.model || null;
-      }
-      /**
-       * 获取当前提供商
-       */
-      getCurrentProvider() {
-        return this.currentConfig?.provider || null;
-      }
-      /**
-       * 获取Token统计
-       */
-      getStats() {
-        return { ...this.stats };
-      }
-      /**
-       * 获取今日统计
-       */
-      getTodayStats() {
-        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        return this.stats.byDate[today] || { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-      }
-      /**
-       * 重置统计
-       */
-      resetStats() {
-        this.stats = {
-          totalInput: 0,
-          totalOutput: 0,
-          byModel: {},
-          byAgent: {},
-          byDate: {}
-        };
-        this.saveStats().catch(() => {
-        });
-      }
-      /**
-       * 验证API Key
-       */
-      async validateApiKey(provider, apiKey) {
-        let adapter = this.adapters.get(provider);
-        if (!adapter) {
-          adapter = createAdapter(provider);
-        }
-        return adapter.validateApiKey(apiKey);
-      }
-      // ==================== 私有方法 ====================
-      getProviderFromModel(modelId) {
-        const info = getModelInfo(modelId);
-        return info?.provider || "openai";
-      }
-      updateStats(usage, context) {
-        this.stats.totalInput += usage.inputTokens;
-        this.stats.totalOutput += usage.outputTokens;
-        if (!this.stats.byModel[context.model]) {
-          this.stats.byModel[context.model] = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-        }
-        this.stats.byModel[context.model].inputTokens += usage.inputTokens;
-        this.stats.byModel[context.model].outputTokens += usage.outputTokens;
-        this.stats.byModel[context.model].totalTokens += usage.totalTokens;
-        if (context.agent) {
-          if (!this.stats.byAgent[context.agent]) {
-            this.stats.byAgent[context.agent] = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-          }
-          this.stats.byAgent[context.agent].inputTokens += usage.inputTokens;
-          this.stats.byAgent[context.agent].outputTokens += usage.outputTokens;
-          this.stats.byAgent[context.agent].totalTokens += usage.totalTokens;
-        }
-        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        if (!this.stats.byDate[today]) {
-          this.stats.byDate[today] = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-        }
-        this.stats.byDate[today].inputTokens += usage.inputTokens;
-        this.stats.byDate[today].outputTokens += usage.outputTokens;
-        this.stats.byDate[today].totalTokens += usage.totalTokens;
-      }
-      async loadStats() {
-        if (!this.statsPath) return;
-        try {
-          const dailyPath = path7__namespace.join(this.statsPath, "daily.json");
-          const totalPath = path7__namespace.join(this.statsPath, "total.json");
-          const [daily, total] = await Promise.all([
-            fs7__namespace.readFile(dailyPath, "utf-8").catch(() => "{}"),
-            fs7__namespace.readFile(totalPath, "utf-8").catch(() => '{"totalInput":0,"totalOutput":0}')
-          ]);
-          const dailyData = JSON.parse(daily);
-          const totalData = JSON.parse(total);
-          this.stats.byDate = dailyData;
-          this.stats.totalInput = totalData.totalInput || 0;
-          this.stats.totalOutput = totalData.totalOutput || 0;
-        } catch {
-        }
-      }
-      async saveStats() {
-        if (!this.statsPath) return;
-        try {
-          await fs7__namespace.mkdir(this.statsPath, { recursive: true });
-          const dailyPath = path7__namespace.join(this.statsPath, "daily.json");
-          const totalPath = path7__namespace.join(this.statsPath, "total.json");
-          await Promise.all([
-            fs7__namespace.writeFile(dailyPath, JSON.stringify(this.stats.byDate, null, 2)),
-            fs7__namespace.writeFile(totalPath, JSON.stringify({
-              totalInput: this.stats.totalInput,
-              totalOutput: this.stats.totalOutput
-            }))
-          ]);
-        } catch {
-        }
-      }
-      wrapError(error) {
-        if (error instanceof ModelError) {
-          return error;
-        }
-        const err = error;
-        if (err.message.includes("timeout")) {
-          return new ModelError("TIMEOUT", err.message, { retryable: true });
-        }
-        if (err.message.includes("network") || err.message.includes("ECONNREFUSED")) {
-          return new ModelError("NETWORK_ERROR", err.message, { retryable: true });
-        }
-        return new ModelError("UNKNOWN_ERROR", err.message, { retryable: false });
-      }
-    };
-  }
-});
-
-// src/types/mcp.ts
-var init_mcp = __esm({
-  "src/types/mcp.ts"() {
-    init_cjs_shims();
-  }
-});
-var init_base2 = __esm({
-  "src/services/mcp/base.ts"() {
-    init_cjs_shims();
-  }
-});
-
-// src/services/mcp/lanhu.ts
-var init_lanhu = __esm({
-  "src/services/mcp/lanhu.ts"() {
-    init_cjs_shims();
-    init_base2();
-  }
-});
-
-// src/services/mcp/figma.ts
-var init_figma = __esm({
-  "src/services/mcp/figma.ts"() {
-    init_cjs_shims();
-    init_base2();
-  }
-});
-
-// src/services/mcp/manager.ts
-var init_manager = __esm({
-  "src/services/mcp/manager.ts"() {
-    init_cjs_shims();
-    init_base2();
-    init_lanhu();
-    init_figma();
-  }
-});
-
-// src/services/mcp/index.ts
-var init_mcp2 = __esm({
-  "src/services/mcp/index.ts"() {
-    init_cjs_shims();
-    init_mcp();
-    init_base2();
-    init_lanhu();
-    init_figma();
-    init_manager();
-  }
-});
-
-// src/services/index.ts
-var init_services = __esm({
-  "src/services/index.ts"() {
-    init_cjs_shims();
-    init_config();
-    init_model2();
-    init_adapters();
-    init_mcp2();
-  }
-});
 
 // src/commands/model.ts
 var model_exports = {};
@@ -1399,17 +961,18 @@ __export(model_exports, {
 async function handleModel(args, ctx) {
   const subCommand = args[0];
   const configManager = ctx.configManager;
+  const modelService = ctx.modelService;
   switch (subCommand) {
     case "list":
       return listModels();
     case "current":
       return showCurrentModel(configManager);
     case "set":
-      return setModelDirectly(args[1], configManager);
+      return setModelDirectly(args[1], configManager, modelService);
     case "verify":
       return verifyCurrentModel(configManager);
     default:
-      return selectModel(configManager);
+      return selectModel(configManager, modelService);
   }
 }
 async function listModels() {
@@ -1450,7 +1013,7 @@ async function showCurrentModel(configManager) {
   ];
   return { output: lines.join("\n") };
 }
-async function setModelDirectly(modelId, configManager) {
+async function setModelDirectly(modelId, configManager, modelService) {
   if (!modelId) {
     return {
       output: chalk9__default.default.red("\u8BF7\u6307\u5B9A\u6A21\u578BID\uFF0C\u4F8B\u5982: /model set gpt-4o")
@@ -1465,11 +1028,22 @@ async function setModelDirectly(modelId, configManager) {
   }
   configManager.set("model", modelId);
   await configManager.save();
+  const apiKey = configManager.get("apiKey");
+  if (apiKey) {
+    try {
+      await modelService.configureModel({
+        provider: modelInfo.provider,
+        model: modelId,
+        apiKey
+      });
+    } catch {
+    }
+  }
   return {
     output: chalk9__default.default.green(`\u2713 \u5DF2\u5207\u6362\u5230\u6A21\u578B: ${modelInfo.name} (${modelInfo.provider})`)
   };
 }
-async function verifyCurrentModel(configManager) {
+async function verifyCurrentModel(configManager, modelService) {
   const currentModel = configManager.get("model");
   const apiKey = configManager.get("apiKey");
   if (!apiKey) {
@@ -1502,7 +1076,7 @@ async function verifyCurrentModel(configManager) {
     };
   }
 }
-async function selectModel(configManager) {
+async function selectModel(configManager, modelService) {
   try {
     const currentModel = configManager.get("model");
     const currentApiKey = configManager.get("apiKey");
@@ -1566,6 +1140,11 @@ async function selectModel(configManager) {
     configManager.set("model", modelResponse.model);
     configManager.set("apiKey", apiKeyResponse.apiKey);
     await configManager.save();
+    await modelService.configureModel({
+      provider: selectedModel.provider,
+      model: modelResponse.model,
+      apiKey: apiKeyResponse.apiKey
+    });
     return {
       output: chalk9__default.default.green(`
 \u2713 \u6A21\u578B\u914D\u7F6E\u5B8C\u6210
@@ -1614,10 +1193,10 @@ function createSpinner(message) {
   };
 }
 var model_default;
-var init_model3 = __esm({
+var init_model2 = __esm({
   "src/commands/model.ts"() {
     init_cjs_shims();
-    init_services();
+    init_adapters();
     init_model();
     model_default = selectModel;
   }
@@ -1633,13 +1212,13 @@ __export(update_exports, {
 });
 function getPackageInfo() {
   const possiblePaths = [
-    path7__namespace.resolve(__dirname, "..", "..", "package.json"),
-    path7__namespace.resolve(__dirname, "..", "..", "..", "package.json")
+    path5__namespace.resolve(__dirname, "..", "..", "package.json"),
+    path5__namespace.resolve(__dirname, "..", "..", "..", "package.json")
   ];
   for (const pkgPath of possiblePaths) {
     try {
-      if (fs9__namespace.existsSync(pkgPath)) {
-        const content = fs9__namespace.readFileSync(pkgPath, "utf-8");
+      if (fs7__namespace.existsSync(pkgPath)) {
+        const content = fs7__namespace.readFileSync(pkgPath, "utf-8");
         return JSON.parse(content);
       }
     } catch {
@@ -2321,18 +1900,18 @@ ${session.context.devStandards.slice(0, 2e3)}` : ""}`
     });
     const codeBlocks = parseCodeBlocks(response.content);
     for (const block of codeBlocks) {
-      const filePath = path7__namespace.join(workingDir, block.filename);
-      const dir = path7__namespace.dirname(filePath);
-      await fs7__namespace.mkdir(dir, { recursive: true });
-      await fs7__namespace.writeFile(filePath, block.code, "utf-8");
+      const filePath = path5__namespace.join(workingDir, block.filename);
+      const dir = path5__namespace.dirname(filePath);
+      await fs5__namespace.mkdir(dir, { recursive: true });
+      await fs5__namespace.writeFile(filePath, block.code, "utf-8");
       files.push(block.filename);
     }
     if (files.length === 0) {
-      const implDir = path7__namespace.join(workingDir, "src", "features");
-      await fs7__namespace.mkdir(implDir, { recursive: true });
+      const implDir = path5__namespace.join(workingDir, "src", "features");
+      await fs5__namespace.mkdir(implDir, { recursive: true });
       const featureName = session.specItems[0]?.title || "feature";
       const fileName = `${featureName.replace(/[^a-zA-Z0-9]/g, "_")}.ts`;
-      const filePath = path7__namespace.join(implDir, fileName);
+      const filePath = path5__namespace.join(implDir, fileName);
       const stubCode = `/**
  * ${session.requirement}
  * 
@@ -2344,7 +1923,7 @@ export function ${featureName.replace(/[^a-zA-Z0-9]/g, "")}() {
   console.log('${featureName} - \u5F85\u5B9E\u73B0');
 }
 `;
-      await fs7__namespace.writeFile(filePath, stubCode, "utf-8");
+      await fs5__namespace.writeFile(filePath, stubCode, "utf-8");
       files.push(`src/features/${fileName}`);
     }
     return { success: true, files };
@@ -2399,7 +1978,7 @@ async function executeReview(ctx, session) {
     const codeContents = [];
     for (const file of session.implFiles) {
       try {
-        const content = await fs7__namespace.readFile(path7__namespace.join(workingDir, file), "utf-8");
+        const content = await fs5__namespace.readFile(path5__namespace.join(workingDir, file), "utf-8");
         codeContents.push(`// ${file}
 ${content}`);
       } catch {
@@ -2408,7 +1987,7 @@ ${content}`);
     const testContents = [];
     for (const file of session.testFiles) {
       try {
-        const content = await fs7__namespace.readFile(path7__namespace.join(workingDir, file), "utf-8");
+        const content = await fs5__namespace.readFile(path5__namespace.join(workingDir, file), "utf-8");
         testContents.push(`// ${file}
 ${content}`);
       } catch {
@@ -2487,7 +2066,7 @@ ${testContents.join("\n\n") || "\uFF08\u65E0\u6D4B\u8BD5\u6587\u4EF6\uFF09"}
 }
 async function readProjectContext(workingDir) {
   const context = {
-    name: path7__namespace.basename(workingDir),
+    name: path5__namespace.basename(workingDir),
     type: "unknown",
     framework: null,
     techStack: [],
@@ -2496,11 +2075,11 @@ async function readProjectContext(workingDir) {
     agentsMd: "",
     configYaml: ""
   };
-  const agentsPath = path7__namespace.join(workingDir, "AGENTS.md");
+  const agentsPath = path5__namespace.join(workingDir, "AGENTS.md");
   try {
-    const stats = await fs7__namespace.stat(agentsPath);
+    const stats = await fs5__namespace.stat(agentsPath);
     if (stats.size <= MAX_FILE_SIZE2) {
-      context.agentsMd = await fs7__namespace.readFile(agentsPath, "utf-8");
+      context.agentsMd = await fs5__namespace.readFile(agentsPath, "utf-8");
       const nameMatch = context.agentsMd.match(/\|\s*项目名称\s*\|\s*([^\s|]+)/);
       if (nameMatch) context.name = nameMatch[1];
       const typeMatch = context.agentsMd.match(/\|\s*项目类型\s*\|\s*([^\s|]+)/);
@@ -2512,11 +2091,11 @@ async function readProjectContext(workingDir) {
     }
   } catch {
   }
-  const configPath = path7__namespace.join(workingDir, "openspec", "config.yaml");
+  const configPath = path5__namespace.join(workingDir, "openspec", "config.yaml");
   try {
-    const stats = await fs7__namespace.stat(configPath);
+    const stats = await fs5__namespace.stat(configPath);
     if (stats.size <= MAX_FILE_SIZE2) {
-      context.configYaml = await fs7__namespace.readFile(configPath, "utf-8");
+      context.configYaml = await fs5__namespace.readFile(configPath, "utf-8");
       const nameMatch = context.configYaml.match(/name:\s*(.+)/);
       if (nameMatch) context.name = nameMatch[1].trim();
       const typeMatch = context.configYaml.match(/type:\s*(.+)/);
@@ -2535,11 +2114,11 @@ async function readProjectContext(workingDir) {
     }
   } catch {
   }
-  const devStandardsPath = path7__namespace.join(workingDir, ".sf-cli", "norms", "devstanded.md");
+  const devStandardsPath = path5__namespace.join(workingDir, ".sf-cli", "norms", "devstanded.md");
   try {
-    const stats = await fs7__namespace.stat(devStandardsPath);
+    const stats = await fs5__namespace.stat(devStandardsPath);
     if (stats.size <= MAX_FILE_SIZE2) {
-      context.devStandards = await fs7__namespace.readFile(devStandardsPath, "utf-8");
+      context.devStandards = await fs5__namespace.readFile(devStandardsPath, "utf-8");
     }
   } catch {
   }
@@ -2669,11 +2248,11 @@ function generateSpecItems(requirement, context, bddScenarios, questions) {
   return items;
 }
 async function saveSpecFile(workingDir, session) {
-  const specDir = path7__namespace.join(workingDir, "openspec", "changes");
-  await fs7__namespace.mkdir(specDir, { recursive: true });
-  const specPath = path7__namespace.join(specDir, `${session.id}-spec.md`);
+  const specDir = path5__namespace.join(workingDir, "openspec", "changes");
+  await fs5__namespace.mkdir(specDir, { recursive: true });
+  const specPath = path5__namespace.join(specDir, `${session.id}-spec.md`);
   const content = formatSpecFile(session);
-  await fs7__namespace.writeFile(specPath, content, "utf-8");
+  await fs5__namespace.writeFile(specPath, content, "utf-8");
   return specPath;
 }
 function formatSpecFile(session) {
@@ -2734,14 +2313,14 @@ function formatSpecFile(session) {
   return lines.join("\n");
 }
 async function generateTests(workingDir, session) {
-  const testDir = path7__namespace.join(workingDir, "tests");
-  await fs7__namespace.mkdir(testDir, { recursive: true });
+  const testDir = path5__namespace.join(workingDir, "tests");
+  await fs5__namespace.mkdir(testDir, { recursive: true });
   const testFiles = [];
   for (const scenario of session.bddScenarios) {
     const testName = scenario.feature.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]/g, "_");
-    const testPath = path7__namespace.join(testDir, `${testName}.test.ts`);
+    const testPath = path5__namespace.join(testDir, `${testName}.test.ts`);
     const content = generateTestFile(scenario);
-    await fs7__namespace.writeFile(testPath, content, "utf-8");
+    await fs5__namespace.writeFile(testPath, content, "utf-8");
     testFiles.push(`tests/${testName}.test.ts`);
   }
   return testFiles;
@@ -2765,9 +2344,9 @@ function generateTestFile(scenario) {
 }
 async function archiveWorkflow(workingDir) {
   if (!activeSession) return;
-  const archiveDir = path7__namespace.join(workingDir, "openspec", "spec");
-  await fs7__namespace.mkdir(archiveDir, { recursive: true });
-  const archivePath = path7__namespace.join(archiveDir, `${activeSession.id}.md`);
+  const archiveDir = path5__namespace.join(workingDir, "openspec", "spec");
+  await fs5__namespace.mkdir(archiveDir, { recursive: true });
+  const archivePath = path5__namespace.join(archiveDir, `${activeSession.id}.md`);
   const content = `# \u5F52\u6863: ${activeSession.requirement.slice(0, 50)}
 
 > \u5F52\u6863\u65F6\u95F4: ${(/* @__PURE__ */ new Date()).toISOString()}
@@ -2793,7 +2372,7 @@ ${activeSession.refinedRequirement}
 
 ${activeSession.testFiles.map((f) => `- ${f}`).join("\n") || "\u65E0"}
 `;
-  await fs7__namespace.writeFile(archivePath, content, "utf-8");
+  await fs5__namespace.writeFile(archivePath, content, "utf-8");
 }
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -3051,11 +2630,11 @@ var NormsManager = class {
       const files = await this.collectProjectFiles(projectPath);
       for (const filePath of files.slice(0, MAX_FILES_TO_SCAN)) {
         try {
-          const stats = await fs7__namespace.stat(filePath);
+          const stats = await fs5__namespace.stat(filePath);
           if (stats.size > MAX_FILE_SIZE) {
             continue;
           }
-          const content = await fs7__namespace.readFile(filePath, "utf-8");
+          const content = await fs5__namespace.readFile(filePath, "utf-8");
           const patterns = await this.learnFromFile(filePath, content);
           result.patternsFound += patterns.length;
           result.filesScanned++;
@@ -3078,7 +2657,7 @@ var NormsManager = class {
    * 从单个文件学习规范
    */
   async learnFromFile(filePath, content) {
-    const ext = path7__namespace.extname(filePath);
+    const ext = path5__namespace.extname(filePath);
     const patterns = this.extractPatterns(filePath, content, ext);
     for (const pattern of patterns) {
       await this.recordOccurrence({
@@ -3681,16 +3260,16 @@ ${response}`;
     const files = [];
     async function scan(dir) {
       try {
-        const entries = await fs7__namespace.readdir(dir, { withFileTypes: true });
+        const entries = await fs5__namespace.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
             if (!IGNORED_DIRS.includes(entry.name)) {
-              await scan(path7__namespace.join(dir, entry.name));
+              await scan(path5__namespace.join(dir, entry.name));
             }
           } else if (entry.isFile()) {
-            const ext = path7__namespace.extname(entry.name);
+            const ext = path5__namespace.extname(entry.name);
             if (SCAN_EXTENSIONS.includes(ext)) {
-              files.push(path7__namespace.join(dir, entry.name));
+              files.push(path5__namespace.join(dir, entry.name));
             }
           }
         }
@@ -3724,16 +3303,16 @@ ${response}`;
    * 确保规范目录存在
    */
   async ensureNormsDir() {
-    await fs7__namespace.mkdir(this.config.normsDir, { recursive: true });
-    await fs7__namespace.mkdir(path7__namespace.join(this.config.normsDir, "weekly"), { recursive: true });
+    await fs5__namespace.mkdir(this.config.normsDir, { recursive: true });
+    await fs5__namespace.mkdir(path5__namespace.join(this.config.normsDir, "weekly"), { recursive: true });
   }
   /**
    * 加载已有规范
    */
   async loadStandards() {
-    const standardsPath = path7__namespace.join(this.config.normsDir, "patterns.json");
+    const standardsPath = path5__namespace.join(this.config.normsDir, "patterns.json");
     try {
-      const content = await fs7__namespace.readFile(standardsPath, "utf-8");
+      const content = await fs5__namespace.readFile(standardsPath, "utf-8");
       const data = JSON.parse(content);
       for (const standard of data) {
         this.standards.set(standard.id, {
@@ -3749,9 +3328,9 @@ ${response}`;
    * 加载权重数据
    */
   async loadWeights() {
-    const weightsPath = path7__namespace.join(this.config.normsDir, "weights.json");
+    const weightsPath = path5__namespace.join(this.config.normsDir, "weights.json");
     try {
-      const content = await fs7__namespace.readFile(weightsPath, "utf-8");
+      const content = await fs5__namespace.readFile(weightsPath, "utf-8");
       const data = JSON.parse(content);
       for (const weight of data) {
         this.weights.set(weight.standardId, {
@@ -3766,8 +3345,8 @@ ${response}`;
    * 保存规范
    */
   async saveStandards() {
-    const standardsPath = path7__namespace.join(this.config.normsDir, "patterns.json");
-    await fs7__namespace.writeFile(
+    const standardsPath = path5__namespace.join(this.config.normsDir, "patterns.json");
+    await fs5__namespace.writeFile(
       standardsPath,
       JSON.stringify(Array.from(this.standards.values()), null, 2),
       "utf-8"
@@ -3777,8 +3356,8 @@ ${response}`;
    * 保存权重
    */
   async saveWeights() {
-    const weightsPath = path7__namespace.join(this.config.normsDir, "weights.json");
-    await fs7__namespace.writeFile(
+    const weightsPath = path5__namespace.join(this.config.normsDir, "weights.json");
+    await fs5__namespace.writeFile(
       weightsPath,
       JSON.stringify(Array.from(this.weights.values()), null, 2),
       "utf-8"
@@ -3805,8 +3384,8 @@ ${response}`;
    * 保存周报
    */
   async saveWeeklyReport(weekId, report) {
-    const reportPath = path7__namespace.join(this.config.normsDir, "weekly", `${weekId}.json`);
-    await fs7__namespace.writeFile(reportPath, JSON.stringify(report, null, 2), "utf-8");
+    const reportPath = path5__namespace.join(this.config.normsDir, "weekly", `${weekId}.json`);
+    await fs5__namespace.writeFile(reportPath, JSON.stringify(report, null, 2), "utf-8");
   }
   /**
    * 更新 devstanded.md
@@ -3814,8 +3393,8 @@ ${response}`;
   async updateDevStandedMd() {
     const standards = this.getEffectiveStandards();
     const content = this.generateDevStandedMd(standards);
-    const mdPath = path7__namespace.join(this.config.normsDir, "devstanded.md");
-    await fs7__namespace.writeFile(mdPath, content, "utf-8");
+    const mdPath = path5__namespace.join(this.config.normsDir, "devstanded.md");
+    await fs5__namespace.writeFile(mdPath, content, "utf-8");
   }
   /**
    * 生成 devstanded.md 内容
@@ -3954,7 +3533,7 @@ async function handleInit(args, ctx) {
 async function initProject(options = {}, workingDir) {
   const cwd = workingDir || process.cwd();
   try {
-    const stats = await fs7__namespace.stat(cwd);
+    const stats = await fs5__namespace.stat(cwd);
     if (!stats.isDirectory()) {
       return {
         output: chalk9__default.default.red(`\u9519\u8BEF: ${cwd} \u4E0D\u662F\u6709\u6548\u76EE\u5F55`)
@@ -3965,9 +3544,9 @@ async function initProject(options = {}, workingDir) {
       output: chalk9__default.default.red(`\u9519\u8BEF: \u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u65E0\u6743\u9650\u8BBF\u95EE ${cwd}`)
     };
   }
-  const sfCliDir = path7__namespace.join(cwd, ".sf-cli");
-  const openspecDir = path7__namespace.join(cwd, "openspec");
-  const agentsMdPath = path7__namespace.join(cwd, "AGENTS.md");
+  const sfCliDir = path5__namespace.join(cwd, ".sf-cli");
+  const openspecDir = path5__namespace.join(cwd, "openspec");
+  const agentsMdPath = path5__namespace.join(cwd, "AGENTS.md");
   try {
     const agentsExists = await fileExists(agentsMdPath);
     if (agentsExists && !options.force) {
@@ -3986,7 +3565,7 @@ async function initProject(options = {}, workingDir) {
     await normsManager.initialize();
     const scanResult = await normsManager.scanProject(cwd);
     const agentsContent = generateAgentsMd(projectInfo, scanResult);
-    await fs7__namespace.writeFile(agentsMdPath, agentsContent, "utf-8");
+    await fs5__namespace.writeFile(agentsMdPath, agentsContent, "utf-8");
     await generateOpenSpecConfig(openspecDir, projectInfo);
     return {
       output: chalk9__default.default.green("\u2713 \u9879\u76EE\u521D\u59CB\u5316\u5B8C\u6210\n") + chalk9__default.default.gray(`  \u9879\u76EE\u7C7B\u578B: ${projectInfo.type}
@@ -4027,7 +3606,7 @@ async function createSfCliDirectory(basePath) {
     "logs"
   ];
   for (const dir of dirs) {
-    await fs7__namespace.mkdir(path7__namespace.join(basePath, dir), { recursive: true });
+    await fs5__namespace.mkdir(path5__namespace.join(basePath, dir), { recursive: true });
   }
   const config = {
     version: "1.0.0",
@@ -4035,37 +3614,37 @@ async function createSfCliDirectory(basePath) {
     yolo: false,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs7__namespace.writeFile(
-    path7__namespace.join(basePath, "config.json"),
+  await fs5__namespace.writeFile(
+    path5__namespace.join(basePath, "config.json"),
     JSON.stringify(config, null, 2),
     "utf-8"
   );
-  await fs7__namespace.writeFile(
-    path7__namespace.join(basePath, "agents", "registry.json"),
+  await fs5__namespace.writeFile(
+    path5__namespace.join(basePath, "agents", "registry.json"),
     JSON.stringify({ version: "1.0.0", agents: {} }, null, 2),
     "utf-8"
   );
-  await fs7__namespace.writeFile(
-    path7__namespace.join(basePath, "skills", "registry.json"),
+  await fs5__namespace.writeFile(
+    path5__namespace.join(basePath, "skills", "registry.json"),
     JSON.stringify({ version: "1.0.0", skills: {} }, null, 2),
     "utf-8"
   );
-  await fs7__namespace.writeFile(
-    path7__namespace.join(basePath, "health", "health.md"),
+  await fs5__namespace.writeFile(
+    path5__namespace.join(basePath, "health", "health.md"),
     generateHealthTemplate(),
     "utf-8"
   );
 }
 async function createOpenSpecDirectory(basePath) {
-  const changesDir = path7__namespace.join(basePath, "changes");
-  const archiveDir = path7__namespace.join(changesDir, "archive");
-  const specDir = path7__namespace.join(basePath, "spec");
-  await fs7__namespace.mkdir(archiveDir, { recursive: true });
-  await fs7__namespace.mkdir(specDir, { recursive: true });
+  const changesDir = path5__namespace.join(basePath, "changes");
+  const archiveDir = path5__namespace.join(changesDir, "archive");
+  const specDir = path5__namespace.join(basePath, "spec");
+  await fs5__namespace.mkdir(archiveDir, { recursive: true });
+  await fs5__namespace.mkdir(specDir, { recursive: true });
 }
 async function analyzeProject(cwd) {
   const result = {
-    name: path7__namespace.basename(cwd),
+    name: path5__namespace.basename(cwd),
     type: "unknown",
     framework: null,
     techStack: [],
@@ -4084,9 +3663,9 @@ async function analyzeProject(cwd) {
     hasEslint: false,
     hasPrettier: false
   };
-  const pkgPath = path7__namespace.join(cwd, "package.json");
+  const pkgPath = path5__namespace.join(cwd, "package.json");
   try {
-    const pkgContent = await fs7__namespace.readFile(pkgPath, "utf-8");
+    const pkgContent = await fs5__namespace.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     result.name = pkg.name || result.name;
     result.dependencies = pkg.dependencies || {};
@@ -4169,7 +3748,7 @@ async function analyzeDirectoryStructure(cwd) {
     others: []
   };
   try {
-    const entries = await fs7__namespace.readdir(cwd, { withFileTypes: true });
+    const entries = await fs5__namespace.readdir(cwd, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const name = entry.name;
@@ -4205,7 +3784,7 @@ async function findEntryPoints(cwd) {
     "index.js"
   ];
   for (const entry of possibleEntries) {
-    const fullPath = path7__namespace.join(cwd, entry);
+    const fullPath = path5__namespace.join(cwd, entry);
     if (await fileExists(fullPath)) {
       entryPoints.push(entry);
     }
@@ -4213,15 +3792,15 @@ async function findEntryPoints(cwd) {
   return entryPoints;
 }
 async function saveProjectAnalysis(sfCliDir, analysis) {
-  const analysisPath = path7__namespace.join(sfCliDir, "cache", "analysis", "project-analysis.json");
-  await fs7__namespace.writeFile(
+  const analysisPath = path5__namespace.join(sfCliDir, "cache", "analysis", "project-analysis.json");
+  await fs5__namespace.writeFile(
     analysisPath,
     JSON.stringify(analysis, null, 2),
     "utf-8"
   );
 }
 async function generateOpenSpecConfig(openspecDir, analysis) {
-  const configPath = path7__namespace.join(openspecDir, "config.yaml");
+  const configPath = path5__namespace.join(openspecDir, "config.yaml");
   const content = `# OpenSpec \u9879\u76EE\u914D\u7F6E
 # \u6B64\u6587\u4EF6\u5B9A\u4E49\u9879\u76EE\u7684\u57FA\u672C\u4FE1\u606F\uFF0C\u7528\u4E8E\u6307\u5BFC AI \u7406\u89E3\u9879\u76EE\u4E0A\u4E0B\u6587
 
@@ -4255,7 +3834,7 @@ architecture:
 # \u5F00\u53D1\u89C4\u8303 (\u4ECE\u4EE3\u7801\u4E2D\u5B66\u4E60)
 standards: []
 `;
-  await fs7__namespace.writeFile(configPath, content, "utf-8");
+  await fs5__namespace.writeFile(configPath, content, "utf-8");
 }
 function generateAgentsMd(info, scanResult) {
   const techStackList = info.techStack.length > 0 ? info.techStack.map((t) => `| ${t} | \u2713 |`).join("\n") : "| \u5F85\u8BC6\u522B | - |";
@@ -4377,7 +3956,7 @@ function generateHealthTemplate() {
 }
 async function fileExists(filePath) {
   try {
-    await fs7__namespace.access(filePath);
+    await fs5__namespace.access(filePath);
     return true;
   } catch {
     return false;
@@ -4541,7 +4120,7 @@ ${chalk9__default.default.yellow("\u793A\u4F8B:")}
 }
 
 // src/commands/runner.ts
-init_model3();
+init_model2();
 init_update();
 
 // src/commands/clear.ts
@@ -4832,7 +4411,7 @@ var WorkflowEngine = class {
    */
   async initialize(projectPath) {
     this.projectPath = projectPath;
-    this.openspecPath = path7__namespace.join(projectPath, "openspec");
+    this.openspecPath = path5__namespace.join(projectPath, "openspec");
     await this.ensureDirectories();
     await this.loadProjectContext();
     await this.restoreState();
@@ -4842,21 +4421,21 @@ var WorkflowEngine = class {
    * 加载项目上下文（AGENTS.md 和 config.yaml）
    */
   async loadProjectContext() {
-    const agentsMdPath = path7__namespace.join(this.projectPath, "AGENTS.md");
+    const agentsMdPath = path5__namespace.join(this.projectPath, "AGENTS.md");
     try {
-      this.projectContext = await fs7__namespace.readFile(agentsMdPath, "utf-8");
+      this.projectContext = await fs5__namespace.readFile(agentsMdPath, "utf-8");
     } catch {
       this.projectContext = "";
     }
-    const configPath = path7__namespace.join(this.openspecPath, "config.yaml");
+    const configPath = path5__namespace.join(this.openspecPath, "config.yaml");
     try {
-      this.projectConfig = await fs7__namespace.readFile(configPath, "utf-8");
+      this.projectConfig = await fs5__namespace.readFile(configPath, "utf-8");
     } catch {
       this.projectConfig = "";
     }
-    const devstandedPath = path7__namespace.join(this.projectPath, ".sf-cli", "norms", "devstanded.md");
+    const devstandedPath = path5__namespace.join(this.projectPath, ".sf-cli", "norms", "devstanded.md");
     try {
-      this.devStandards = await fs7__namespace.readFile(devstandedPath, "utf-8");
+      this.devStandards = await fs5__namespace.readFile(devstandedPath, "utf-8");
     } catch {
       this.devStandards = "";
     }
@@ -4876,7 +4455,7 @@ var WorkflowEngine = class {
    */
   getSpecFilePath() {
     if (!this.state) return null;
-    return path7__namespace.join(this.openspecPath, "changes", `${this.state.id}-spec.md`);
+    return path5__namespace.join(this.openspecPath, "changes", `${this.state.id}-spec.md`);
   }
   /**
    * 检查规格文件是否存在
@@ -4885,7 +4464,7 @@ var WorkflowEngine = class {
     const specPath = this.getSpecFilePath();
     if (!specPath) return false;
     try {
-      await fs7__namespace.access(specPath);
+      await fs5__namespace.access(specPath);
       return true;
     } catch {
       return false;
@@ -5117,13 +4696,13 @@ var WorkflowEngine = class {
    */
   async getAllActiveWorkflows() {
     const workflows = [];
-    const changesDir = path7__namespace.join(this.openspecPath, "changes");
+    const changesDir = path5__namespace.join(this.openspecPath, "changes");
     try {
-      const files = await fs7__namespace.readdir(changesDir);
+      const files = await fs5__namespace.readdir(changesDir);
       for (const file of files) {
         if (!file.endsWith(".md") || file.includes("-spec.md")) continue;
-        const filePath = path7__namespace.join(changesDir, file);
-        const content = await fs7__namespace.readFile(filePath, "utf-8");
+        const filePath = path5__namespace.join(changesDir, file);
+        const content = await fs5__namespace.readFile(filePath, "utf-8");
         const state = this.parseChangeRecord(content);
         if (state && state.status === "running") {
           workflows.push(state);
@@ -5172,9 +4751,9 @@ var WorkflowEngine = class {
     if (this.state) {
       await this.saveState();
     }
-    const statePath = path7__namespace.join(this.openspecPath, ".workflow-states", `${changeId}.json`);
+    const statePath = path5__namespace.join(this.openspecPath, ".workflow-states", `${changeId}.json`);
     try {
-      const content = await fs7__namespace.readFile(statePath, "utf-8");
+      const content = await fs5__namespace.readFile(statePath, "utf-8");
       this.state = JSON.parse(content, (key, value) => {
         if (key.endsWith("At") && typeof value === "string") {
           return new Date(value);
@@ -5184,10 +4763,10 @@ var WorkflowEngine = class {
       await this.restoreSnapshots();
       return true;
     } catch {
-      const changesDir = path7__namespace.join(this.openspecPath, "changes");
-      const changeFile = path7__namespace.join(changesDir, `${changeId}.md`);
+      const changesDir = path5__namespace.join(this.openspecPath, "changes");
+      const changeFile = path5__namespace.join(changesDir, `${changeId}.md`);
       try {
-        const content = await fs7__namespace.readFile(changeFile, "utf-8");
+        const content = await fs5__namespace.readFile(changeFile, "utf-8");
         const parsed = this.parseChangeRecord(content);
         if (parsed && parsed.status === "running") {
           this.state = parsed;
@@ -5248,12 +4827,12 @@ var WorkflowEngine = class {
     await this.createSpecDocument(summary);
     await this.updateChangeRecord("archived");
     await this.saveState();
-    const changesDir = path7__namespace.join(this.openspecPath, "changes");
-    const archiveDir = path7__namespace.join(changesDir, "archive");
-    const changeFile = path7__namespace.join(changesDir, `${changeId}.md`);
-    const archiveFile = path7__namespace.join(archiveDir, `${changeId}.md`);
-    await fs7__namespace.mkdir(archiveDir, { recursive: true });
-    await fs7__namespace.rename(changeFile, archiveFile).catch(() => {
+    const changesDir = path5__namespace.join(this.openspecPath, "changes");
+    const archiveDir = path5__namespace.join(changesDir, "archive");
+    const changeFile = path5__namespace.join(changesDir, `${changeId}.md`);
+    const archiveFile = path5__namespace.join(archiveDir, `${changeId}.md`);
+    await fs5__namespace.mkdir(archiveDir, { recursive: true });
+    await fs5__namespace.rename(changeFile, archiveFile).catch(() => {
     });
     this.state = null;
     this.snapshots.clear();
@@ -5275,27 +4854,27 @@ var WorkflowEngine = class {
   }
   // ==================== 私有方法 ====================
   async ensureDirectories() {
-    const changesDir = path7__namespace.join(this.openspecPath, "changes");
-    const archiveDir = path7__namespace.join(changesDir, "archive");
-    const specDir = path7__namespace.join(this.openspecPath, "spec");
-    const statesDir = path7__namespace.join(this.openspecPath, ".workflow-states");
-    await fs7__namespace.mkdir(archiveDir, { recursive: true });
-    await fs7__namespace.mkdir(specDir, { recursive: true });
-    await fs7__namespace.mkdir(statesDir, { recursive: true });
+    const changesDir = path5__namespace.join(this.openspecPath, "changes");
+    const archiveDir = path5__namespace.join(changesDir, "archive");
+    const specDir = path5__namespace.join(this.openspecPath, "spec");
+    const statesDir = path5__namespace.join(this.openspecPath, ".workflow-states");
+    await fs5__namespace.mkdir(archiveDir, { recursive: true });
+    await fs5__namespace.mkdir(specDir, { recursive: true });
+    await fs5__namespace.mkdir(statesDir, { recursive: true });
   }
   async restoreState() {
-    const activePath = path7__namespace.join(this.openspecPath, ".workflow-active.json");
+    const activePath = path5__namespace.join(this.openspecPath, ".workflow-active.json");
     let activeId = null;
     try {
-      const activeContent = await fs7__namespace.readFile(activePath, "utf-8");
+      const activeContent = await fs5__namespace.readFile(activePath, "utf-8");
       const activeData = JSON.parse(activeContent);
       activeId = activeData.activeId;
     } catch {
     }
     if (activeId) {
-      const statePath = path7__namespace.join(this.openspecPath, ".workflow-states", `${activeId}.json`);
+      const statePath = path5__namespace.join(this.openspecPath, ".workflow-states", `${activeId}.json`);
       try {
-        const content = await fs7__namespace.readFile(statePath, "utf-8");
+        const content = await fs5__namespace.readFile(statePath, "utf-8");
         this.state = JSON.parse(content, (key, value) => {
           if (key.endsWith("At") && typeof value === "string") {
             return new Date(value);
@@ -5306,9 +4885,9 @@ var WorkflowEngine = class {
       } catch {
       }
     }
-    const oldStatePath = path7__namespace.join(this.openspecPath, ".workflow-state.json");
+    const oldStatePath = path5__namespace.join(this.openspecPath, ".workflow-state.json");
     try {
-      const content = await fs7__namespace.readFile(oldStatePath, "utf-8");
+      const content = await fs5__namespace.readFile(oldStatePath, "utf-8");
       this.state = JSON.parse(content, (key, value) => {
         if (key.endsWith("At") && typeof value === "string") {
           return new Date(value);
@@ -5317,7 +4896,7 @@ var WorkflowEngine = class {
       });
       if (this.state) {
         await this.saveState();
-        await fs7__namespace.unlink(oldStatePath).catch(() => {
+        await fs5__namespace.unlink(oldStatePath).catch(() => {
         });
       }
     } catch (e) {
@@ -5330,17 +4909,17 @@ var WorkflowEngine = class {
   }
   async saveState() {
     if (!this.state) return;
-    const statesDir = path7__namespace.join(this.openspecPath, ".workflow-states");
-    await fs7__namespace.mkdir(statesDir, { recursive: true });
-    const statePath = path7__namespace.join(statesDir, `${this.state.id}.json`);
-    await fs7__namespace.writeFile(statePath, JSON.stringify(this.state, null, 2));
-    const activePath = path7__namespace.join(this.openspecPath, ".workflow-active.json");
-    await fs7__namespace.writeFile(activePath, JSON.stringify({ activeId: this.state.id }, null, 2));
+    const statesDir = path5__namespace.join(this.openspecPath, ".workflow-states");
+    await fs5__namespace.mkdir(statesDir, { recursive: true });
+    const statePath = path5__namespace.join(statesDir, `${this.state.id}.json`);
+    await fs5__namespace.writeFile(statePath, JSON.stringify(this.state, null, 2));
+    const activePath = path5__namespace.join(this.openspecPath, ".workflow-active.json");
+    await fs5__namespace.writeFile(activePath, JSON.stringify({ activeId: this.state.id }, null, 2));
   }
   async restoreSnapshots() {
-    const snapshotsPath = path7__namespace.join(this.openspecPath, ".workflow-snapshots.json");
+    const snapshotsPath = path5__namespace.join(this.openspecPath, ".workflow-snapshots.json");
     try {
-      const content = await fs7__namespace.readFile(snapshotsPath, "utf-8");
+      const content = await fs5__namespace.readFile(snapshotsPath, "utf-8");
       const data = JSON.parse(content, (key, value) => {
         if (key === "timestamp" && typeof value === "string") {
           return new Date(value);
@@ -5355,9 +4934,9 @@ var WorkflowEngine = class {
     }
   }
   async saveSnapshots() {
-    const snapshotsPath = path7__namespace.join(this.openspecPath, ".workflow-snapshots.json");
+    const snapshotsPath = path5__namespace.join(this.openspecPath, ".workflow-snapshots.json");
     const data = Array.from(this.snapshots.values());
-    await fs7__namespace.writeFile(snapshotsPath, JSON.stringify(data, null, 2));
+    await fs5__namespace.writeFile(snapshotsPath, JSON.stringify(data, null, 2));
   }
   async createSnapshot() {
     if (!this.state) return;
@@ -5377,16 +4956,16 @@ var WorkflowEngine = class {
   }
   async createChangeRecord() {
     if (!this.state) return;
-    const changePath = path7__namespace.join(this.openspecPath, "changes", `${this.state.id}.md`);
-    await fs7__namespace.writeFile(changePath, this.formatChangeRecord());
+    const changePath = path5__namespace.join(this.openspecPath, "changes", `${this.state.id}.md`);
+    await fs5__namespace.writeFile(changePath, this.formatChangeRecord());
   }
   async updateChangeRecord(status) {
     if (!this.state) return;
     if (status) {
       this.state.status = status;
     }
-    const changePath = path7__namespace.join(this.openspecPath, "changes", `${this.state.id}.md`);
-    await fs7__namespace.writeFile(changePath, this.formatChangeRecord());
+    const changePath = path5__namespace.join(this.openspecPath, "changes", `${this.state.id}.md`);
+    await fs5__namespace.writeFile(changePath, this.formatChangeRecord());
   }
   formatChangeRecord() {
     if (!this.state) return "";
@@ -5425,7 +5004,7 @@ ${this.state.artifacts.map((a) => `- ${a}`).join("\n") || "\u6682\u65E0"}
   }
   async createSpecDocument(summary) {
     if (!this.state) return;
-    const specPath = path7__namespace.join(this.openspecPath, "spec", `${this.state.id}.md`);
+    const specPath = path5__namespace.join(this.openspecPath, "spec", `${this.state.id}.md`);
     const content = `# Spec: ${this.state.title}
 
 > \u53D8\u66F4ID: ${this.state.id}
@@ -5450,7 +5029,7 @@ ${this.state.steps.map((s) => `- [${s.status === "completed" ? "x" : " "}] ${s.s
 
 ${this.state.artifacts.map((a) => `- ${a}`).join("\n") || "\u6682\u65E0"}
 `;
-    await fs7__namespace.writeFile(specPath, content);
+    await fs5__namespace.writeFile(specPath, content);
   }
 };
 var ConfirmationRequiredError = class extends Error {
@@ -5947,15 +5526,15 @@ async function loadProjectContext(workingDirectory) {
     devStandards: ""
   };
   try {
-    context.agentsMd = await fs7__namespace.readFile(path7__namespace.join(workingDirectory, "AGENTS.md"), "utf-8");
+    context.agentsMd = await fs5__namespace.readFile(path5__namespace.join(workingDirectory, "AGENTS.md"), "utf-8");
   } catch {
   }
   try {
-    context.configYaml = await fs7__namespace.readFile(path7__namespace.join(workingDirectory, "openspec", "config.yaml"), "utf-8");
+    context.configYaml = await fs5__namespace.readFile(path5__namespace.join(workingDirectory, "openspec", "config.yaml"), "utf-8");
   } catch {
   }
   try {
-    context.devStandards = await fs7__namespace.readFile(path7__namespace.join(workingDirectory, ".sf-cli", "norms", "devstanded.md"), "utf-8");
+    context.devStandards = await fs5__namespace.readFile(path5__namespace.join(workingDirectory, ".sf-cli", "norms", "devstanded.md"), "utf-8");
   } catch {
   }
   return context;
@@ -6422,11 +6001,11 @@ ${generateConfirmationPrompt(confirmation.point)}`) + chalk9__default.default.cy
 }
 async function updateChangelog(workingDirectory, summary, changeId) {
   try {
-    const changelogPath = path7__namespace.join(workingDirectory, "CHANGELOG.md");
-    const pkgPath = path7__namespace.join(workingDirectory, "package.json");
+    const changelogPath = path5__namespace.join(workingDirectory, "CHANGELOG.md");
+    const pkgPath = path5__namespace.join(workingDirectory, "package.json");
     let version = "1.0.0";
     try {
-      const pkgContent = fs9__namespace.readFileSync(pkgPath, "utf-8");
+      const pkgContent = fs7__namespace.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       version = pkg.version || "1.0.0";
     } catch {
@@ -6440,22 +6019,22 @@ async function updateChangelog(workingDirectory, summary, changeId) {
 
 - ${summary} (${changeId})
 `;
-    if (fs9__namespace.existsSync(changelogPath)) {
-      const content = fs9__namespace.readFileSync(changelogPath, "utf-8");
+    if (fs7__namespace.existsSync(changelogPath)) {
+      const content = fs7__namespace.readFileSync(changelogPath, "utf-8");
       const versionPattern = /^## v\d+\.\d+\.\d+/m;
       const match = content.match(versionPattern);
       if (match && match.index !== void 0) {
         const newContent = content.slice(0, match.index) + entry + content.slice(match.index);
-        fs9__namespace.writeFileSync(changelogPath, newContent, "utf-8");
+        fs7__namespace.writeFileSync(changelogPath, newContent, "utf-8");
       } else {
-        fs9__namespace.appendFileSync(changelogPath, entry, "utf-8");
+        fs7__namespace.appendFileSync(changelogPath, entry, "utf-8");
       }
     } else {
       const header = `# Changelog
 
 All notable changes to this project will be documented in this file.
 `;
-      fs9__namespace.writeFileSync(changelogPath, header + entry, "utf-8");
+      fs7__namespace.writeFileSync(changelogPath, header + entry, "utf-8");
     }
   } catch (error) {
   }
@@ -6585,7 +6164,7 @@ async function handleRegenerateSpec(workflow, ctx) {
     return { output: chalk9__default.default.red("\u6CA1\u6709\u6D3B\u8DC3\u7684\u5DE5\u4F5C\u6D41") };
   }
   const workingDir = ctx.options.workingDirectory;
-  const specPath = path7__namespace.join(workingDir, "openspec", "changes", `${state.id}-spec.md`);
+  const specPath = path5__namespace.join(workingDir, "openspec", "changes", `${state.id}-spec.md`);
   workflow.confirm("spec-review", "regenerate");
   const lines = [];
   lines.push(chalk9__default.default.cyan("\u{1F504} \u91CD\u65B0\u751F\u6210\u89C4\u683C..."));
@@ -6594,7 +6173,7 @@ async function handleRegenerateSpec(workflow, ctx) {
   const context = await readProjectContext2(workingDir);
   const analysis = analyzeComplexity2(state.requirement, context);
   const specContent = await generateSpecContent(state.id, state.requirement, analysis, context);
-  await fs9__namespace.promises.writeFile(specPath, specContent, "utf-8");
+  await fs7__namespace.promises.writeFile(specPath, specContent, "utf-8");
   lines.push(chalk9__default.default.green("\u2713 \u89C4\u683C\u5DF2\u91CD\u65B0\u751F\u6210"));
   lines.push(chalk9__default.default.gray(`\u8DEF\u5F84: ${specPath}`));
   lines.push("");
@@ -6688,9 +6267,9 @@ ${generateConfirmationPrompt(e.point)}`) + chalk9__default.default.cyan(`
   return { output: lines.join("\n") };
 }
 async function checkPendingSpec(workingDirectory, changeId) {
-  const specPath = path7__namespace.join(workingDirectory, "openspec", "changes", `${changeId}-spec.md`);
+  const specPath = path5__namespace.join(workingDirectory, "openspec", "changes", `${changeId}-spec.md`);
   try {
-    await fs9__namespace.promises.access(specPath);
+    await fs7__namespace.promises.access(specPath);
     return specPath;
   } catch {
     return null;
@@ -6804,13 +6383,13 @@ async function handleSwitch(workflow, args, ctx) {
 // src/commands/runner.ts
 function getVersion2() {
   const possiblePaths = [
-    path7__namespace.resolve(__dirname, "..", "..", "package.json"),
-    path7__namespace.resolve(__dirname, "..", "..", "..", "package.json")
+    path5__namespace.resolve(__dirname, "..", "..", "package.json"),
+    path5__namespace.resolve(__dirname, "..", "..", "..", "package.json")
   ];
   for (const pkgPath of possiblePaths) {
     try {
-      if (fs9__namespace.existsSync(pkgPath)) {
-        const content = fs9__namespace.readFileSync(pkgPath, "utf-8");
+      if (fs7__namespace.existsSync(pkgPath)) {
+        const content = fs7__namespace.readFileSync(pkgPath, "utf-8");
         const pkg = JSON.parse(content);
         return pkg.version;
       }
@@ -6867,7 +6446,7 @@ function normalizeCommand(command) {
 }
 
 // src/commands/index.ts
-init_model3();
+init_model2();
 init_update();
 init_new();
 
@@ -6875,11 +6454,11 @@ init_new();
 init_cjs_shims();
 async function handleFileReference(filePath, ctx) {
   const cwd = ctx.options.workingDirectory;
-  const absolutePath = path7__namespace.isAbsolute(filePath) ? filePath : path7__namespace.join(cwd, filePath);
+  const absolutePath = path5__namespace.isAbsolute(filePath) ? filePath : path5__namespace.join(cwd, filePath);
   try {
-    const stats = await fs7__namespace.stat(absolutePath);
+    const stats = await fs5__namespace.stat(absolutePath);
     if (stats.isDirectory()) {
-      const files = await fs7__namespace.readdir(absolutePath);
+      const files = await fs5__namespace.readdir(absolutePath);
       return {
         output: chalk9__default.default.cyan(`\u{1F4C1} ${filePath}/`) + chalk9__default.default.gray(`
 ${files.slice(0, 20).join("\n")}`) + (files.length > 20 ? chalk9__default.default.gray(`
@@ -6887,7 +6466,7 @@ ${files.slice(0, 20).join("\n")}`) + (files.length > 20 ? chalk9__default.defaul
         contextUsed: 0
       };
     }
-    const content = await fs7__namespace.readFile(absolutePath, "utf-8");
+    const content = await fs5__namespace.readFile(absolutePath, "utf-8");
     const lines = content.split("\n");
     ctx.contextManager.addMessage({
       role: "user",
@@ -7197,7 +6776,7 @@ var ContextManager = class {
   }
   async initialize(projectPath) {
     this.projectPath = projectPath;
-    this.persistPath = path7__namespace.join(projectPath, ".sf-cli", "cache", "context", "context.json");
+    this.persistPath = path5__namespace.join(projectPath, ".sf-cli", "cache", "context", "context.json");
     await this.loadPersistedContext();
   }
   /**
@@ -7438,15 +7017,15 @@ ${summary}`,
    */
   async persist() {
     if (!this.persistPath) return;
-    const dir = path7__namespace.dirname(this.persistPath);
-    await fs7__namespace.mkdir(dir, { recursive: true });
+    const dir = path5__namespace.dirname(this.persistPath);
+    await fs5__namespace.mkdir(dir, { recursive: true });
     const data = {
       messages: this.state.messages,
       totalTokens: this.state.totalTokens,
       limit: this.state.limit,
       savedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs7__namespace.writeFile(this.persistPath, JSON.stringify(data, null, 2), "utf-8");
+    await fs5__namespace.writeFile(this.persistPath, JSON.stringify(data, null, 2), "utf-8");
   }
   /**
    * 加载持久化的上下文
@@ -7454,7 +7033,7 @@ ${summary}`,
   async loadPersistedContext() {
     if (!this.persistPath) return;
     try {
-      const content = await fs7__namespace.readFile(this.persistPath, "utf-8");
+      const content = await fs5__namespace.readFile(this.persistPath, "utf-8");
       const data = JSON.parse(content);
       this.state.messages = data.messages || [];
       this.state.totalTokens = data.totalTokens || 0;
@@ -7483,8 +7062,400 @@ ${summary}`,
   }
 };
 
-// src/cli/repl.ts
-init_services();
+// src/services/index.ts
+init_cjs_shims();
+
+// src/services/config.ts
+init_cjs_shims();
+var DEFAULT_CONFIG = {
+  model: "GLM-5",
+  apiKey: "",
+  yolo: false,
+  locale: "zh-CN",
+  theme: "auto"
+};
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var KEY_DIR = ".sf-cli";
+var KEY_FILE = ".key";
+function getOrCreateEncryptionKey() {
+  const keyPath = path5__namespace.join(os__namespace.homedir(), KEY_DIR, KEY_FILE);
+  try {
+    if (fs7__namespace.existsSync(keyPath)) {
+      const keyBase64 = fs7__namespace.readFileSync(keyPath, "utf-8").trim();
+      return Buffer.from(keyBase64, "base64");
+    }
+  } catch {
+  }
+  const key = crypto__namespace.randomBytes(32);
+  try {
+    const keyDir = path5__namespace.dirname(keyPath);
+    if (!fs7__namespace.existsSync(keyDir)) {
+      fs7__namespace.mkdirSync(keyDir, { recursive: true, mode: 448 });
+    }
+    fs7__namespace.writeFileSync(keyPath, key.toString("base64"), {
+      mode: 384,
+      // 仅所有者可读写
+      encoding: "utf-8"
+    });
+    return key;
+  } catch {
+    const machineId = [
+      os__namespace.hostname(),
+      os__namespace.platform(),
+      os__namespace.arch(),
+      process.env.USERNAME || process.env.USER || "default"
+    ].join("-");
+    return crypto__namespace.createHash("sha256").update(machineId).digest();
+  }
+}
+var ConfigManager = class {
+  config;
+  configPath = "";
+  projectPath = "";
+  encryptionKey;
+  constructor() {
+    this.config = { ...DEFAULT_CONFIG };
+    this.encryptionKey = getOrCreateEncryptionKey();
+  }
+  async load(projectPath) {
+    this.projectPath = projectPath;
+    this.configPath = path5__namespace.join(projectPath, ".sf-cli", "config.json");
+    try {
+      const content = await fs5__namespace.readFile(this.configPath, "utf-8");
+      const loaded = JSON.parse(content);
+      if (loaded.apiKey && loaded.apiKeyEncrypted) {
+        loaded.apiKey = this.decrypt(loaded.apiKey);
+        delete loaded.apiKeyEncrypted;
+      }
+      this.config = { ...DEFAULT_CONFIG, ...loaded };
+    } catch {
+      this.config = { ...DEFAULT_CONFIG };
+    }
+  }
+  async save() {
+    if (!this.configPath) return;
+    const configToSave = { ...this.config };
+    if (configToSave.apiKey) {
+      const encrypted = this.encrypt(configToSave.apiKey);
+      configToSave.apiKey = encrypted;
+      configToSave.apiKeyEncrypted = true;
+    }
+    await fs5__namespace.mkdir(path5__namespace.dirname(this.configPath), { recursive: true });
+    await fs5__namespace.writeFile(
+      this.configPath,
+      JSON.stringify(configToSave, null, 2),
+      "utf-8"
+    );
+  }
+  get(key) {
+    return this.config[key];
+  }
+  set(key, value) {
+    this.config[key] = value;
+  }
+  getAll() {
+    return { ...this.config };
+  }
+  update(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  /**
+   * 加密敏感数据
+   */
+  encrypt(text) {
+    const iv = crypto__namespace.randomBytes(IV_LENGTH);
+    const cipher = crypto__namespace.createCipheriv(ALGORITHM, this.encryptionKey, iv);
+    let encrypted = cipher.update(text, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    const authTag = cipher.getAuthTag();
+    return `${iv.toString("base64")}:${authTag.toString("base64")}:${encrypted}`;
+  }
+  /**
+   * 解密敏感数据
+   */
+  decrypt(encryptedData) {
+    try {
+      const parts = encryptedData.split(":");
+      if (parts.length !== 3) {
+        return encryptedData;
+      }
+      const [ivBase64, authTagBase64, encrypted] = parts;
+      const iv = Buffer.from(ivBase64, "base64");
+      const authTag = Buffer.from(authTagBase64, "base64");
+      const decipher = crypto__namespace.createDecipheriv(ALGORITHM, this.encryptionKey, iv);
+      decipher.setAuthTag(authTag);
+      let decrypted = decipher.update(encrypted, "base64", "utf8");
+      decrypted += decipher.final("utf8");
+      return decrypted;
+    } catch {
+      return "";
+    }
+  }
+};
+
+// src/services/model.ts
+init_cjs_shims();
+init_model();
+init_adapters();
+var ModelService = class {
+  adapters = /* @__PURE__ */ new Map();
+  currentConfig = null;
+  stats;
+  configManager;
+  statsPath = "";
+  constructor(configManager) {
+    this.configManager = configManager;
+    this.stats = {
+      totalInput: 0,
+      totalOutput: 0,
+      byModel: {},
+      byAgent: {},
+      byDate: {}
+    };
+  }
+  /**
+   * 初始化服务
+   */
+  async initialize(statsDir) {
+    this.statsPath = path5__namespace.join(statsDir, "tokens");
+    await this.loadStats();
+    const model = this.configManager.get("model");
+    const apiKey = this.configManager.get("apiKey");
+    if (model && apiKey) {
+      await this.configureModel({
+        provider: this.getProviderFromModel(model),
+        model,
+        apiKey
+      });
+    }
+  }
+  /**
+   * 配置模型
+   */
+  async configureModel(config) {
+    let adapter = this.adapters.get(config.provider);
+    if (!adapter) {
+      adapter = createAdapter(config.provider);
+      this.adapters.set(config.provider, adapter);
+    }
+    await adapter.initialize(config);
+    this.currentConfig = config;
+    this.configManager.set("model", config.model);
+    this.configManager.set("apiKey", config.apiKey);
+    await this.configManager.save();
+  }
+  /**
+   * 发送消息
+   */
+  async sendMessage(messages, options) {
+    if (!this.currentConfig) {
+      throw new Error("\u6A21\u578B\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u6267\u884C /model \u547D\u4EE4");
+    }
+    const adapter = this.adapters.get(this.currentConfig.provider);
+    if (!adapter || !adapter.isInitialized()) {
+      throw new Error("\u6A21\u578B\u9002\u914D\u5668\u672A\u521D\u59CB\u5316");
+    }
+    try {
+      const response = await adapter.sendMessage(messages, options);
+      this.updateStats(response.usage, {
+        model: this.currentConfig.model,
+        agent: options?.agent
+      });
+      this.saveStats().catch(() => {
+      });
+      return response;
+    } catch (error) {
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * 流式发送消息
+   */
+  async *streamMessage(messages, options) {
+    if (!this.currentConfig) {
+      throw new Error("\u6A21\u578B\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u6267\u884C /model \u547D\u4EE4");
+    }
+    const adapter = this.adapters.get(this.currentConfig.provider);
+    if (!adapter || !adapter.isInitialized()) {
+      throw new Error("\u6A21\u578B\u9002\u914D\u5668\u672A\u521D\u59CB\u5316");
+    }
+    let totalTokens = 0;
+    try {
+      for await (const chunk of adapter.streamMessage(messages, options)) {
+        totalTokens += chunk.delta.length;
+        yield chunk;
+      }
+      const inputTokens = adapter.countTokens(
+        messages.map((m) => m.content).join("\n")
+      );
+      this.updateStats(
+        { inputTokens, outputTokens: Math.ceil(totalTokens / 4), totalTokens: 0 },
+        { model: this.currentConfig.model, agent: options?.agent }
+      );
+      this.saveStats().catch(() => {
+      });
+    } catch (error) {
+      throw this.wrapError(error);
+    }
+  }
+  /**
+   * 计算Token数量
+   */
+  countTokens(text) {
+    if (!this.currentConfig) {
+      return Math.ceil(text.length / 4);
+    }
+    const adapter = this.adapters.get(this.currentConfig.provider);
+    return adapter?.countTokens(text) || Math.ceil(text.length / 4);
+  }
+  /**
+   * 获取当前模型
+   */
+  getCurrentModel() {
+    return this.currentConfig?.model || null;
+  }
+  /**
+   * 获取当前提供商
+   */
+  getCurrentProvider() {
+    return this.currentConfig?.provider || null;
+  }
+  /**
+   * 获取Token统计
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * 获取今日统计
+   */
+  getTodayStats() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    return this.stats.byDate[today] || { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  }
+  /**
+   * 重置统计
+   */
+  resetStats() {
+    this.stats = {
+      totalInput: 0,
+      totalOutput: 0,
+      byModel: {},
+      byAgent: {},
+      byDate: {}
+    };
+    this.saveStats().catch(() => {
+    });
+  }
+  /**
+   * 验证API Key
+   */
+  async validateApiKey(provider, apiKey) {
+    let adapter = this.adapters.get(provider);
+    if (!adapter) {
+      adapter = createAdapter(provider);
+    }
+    return adapter.validateApiKey(apiKey);
+  }
+  // ==================== 私有方法 ====================
+  getProviderFromModel(modelId) {
+    const info = getModelInfo(modelId);
+    return info?.provider || "openai";
+  }
+  updateStats(usage, context) {
+    this.stats.totalInput += usage.inputTokens;
+    this.stats.totalOutput += usage.outputTokens;
+    if (!this.stats.byModel[context.model]) {
+      this.stats.byModel[context.model] = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    }
+    this.stats.byModel[context.model].inputTokens += usage.inputTokens;
+    this.stats.byModel[context.model].outputTokens += usage.outputTokens;
+    this.stats.byModel[context.model].totalTokens += usage.totalTokens;
+    if (context.agent) {
+      if (!this.stats.byAgent[context.agent]) {
+        this.stats.byAgent[context.agent] = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+      }
+      this.stats.byAgent[context.agent].inputTokens += usage.inputTokens;
+      this.stats.byAgent[context.agent].outputTokens += usage.outputTokens;
+      this.stats.byAgent[context.agent].totalTokens += usage.totalTokens;
+    }
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (!this.stats.byDate[today]) {
+      this.stats.byDate[today] = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    }
+    this.stats.byDate[today].inputTokens += usage.inputTokens;
+    this.stats.byDate[today].outputTokens += usage.outputTokens;
+    this.stats.byDate[today].totalTokens += usage.totalTokens;
+  }
+  async loadStats() {
+    if (!this.statsPath) return;
+    try {
+      const dailyPath = path5__namespace.join(this.statsPath, "daily.json");
+      const totalPath = path5__namespace.join(this.statsPath, "total.json");
+      const [daily, total] = await Promise.all([
+        fs5__namespace.readFile(dailyPath, "utf-8").catch(() => "{}"),
+        fs5__namespace.readFile(totalPath, "utf-8").catch(() => '{"totalInput":0,"totalOutput":0}')
+      ]);
+      const dailyData = JSON.parse(daily);
+      const totalData = JSON.parse(total);
+      this.stats.byDate = dailyData;
+      this.stats.totalInput = totalData.totalInput || 0;
+      this.stats.totalOutput = totalData.totalOutput || 0;
+    } catch {
+    }
+  }
+  async saveStats() {
+    if (!this.statsPath) return;
+    try {
+      await fs5__namespace.mkdir(this.statsPath, { recursive: true });
+      const dailyPath = path5__namespace.join(this.statsPath, "daily.json");
+      const totalPath = path5__namespace.join(this.statsPath, "total.json");
+      await Promise.all([
+        fs5__namespace.writeFile(dailyPath, JSON.stringify(this.stats.byDate, null, 2)),
+        fs5__namespace.writeFile(totalPath, JSON.stringify({
+          totalInput: this.stats.totalInput,
+          totalOutput: this.stats.totalOutput
+        }))
+      ]);
+    } catch {
+    }
+  }
+  wrapError(error) {
+    if (error instanceof ModelError) {
+      return error;
+    }
+    const err = error;
+    if (err.message.includes("timeout")) {
+      return new ModelError("TIMEOUT", err.message, { retryable: true });
+    }
+    if (err.message.includes("network") || err.message.includes("ECONNREFUSED")) {
+      return new ModelError("NETWORK_ERROR", err.message, { retryable: true });
+    }
+    return new ModelError("UNKNOWN_ERROR", err.message, { retryable: false });
+  }
+};
+
+// src/services/index.ts
+init_adapters();
+
+// src/services/mcp/index.ts
+init_cjs_shims();
+
+// src/types/mcp.ts
+init_cjs_shims();
+
+// src/services/mcp/base.ts
+init_cjs_shims();
+
+// src/services/mcp/lanhu.ts
+init_cjs_shims();
+
+// src/services/mcp/figma.ts
+init_cjs_shims();
+
+// src/services/mcp/manager.ts
+init_cjs_shims();
 
 // src/cli/status.ts
 init_cjs_shims();
@@ -7649,17 +7620,17 @@ var Completer = class {
       prefix = filePath;
     } else {
       const dir = filePath.slice(0, lastSlash);
-      dirPath = path7__namespace.resolve(this.workingDirectory, dir);
+      dirPath = path5__namespace.resolve(this.workingDirectory, dir);
       prefix = filePath.slice(lastSlash + 1);
     }
     try {
-      const entries = await fs7__namespace.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs5__namespace.readdir(dirPath, { withFileTypes: true });
       const matches = [];
       for (const entry of entries) {
         if (entry.name.startsWith(prefix)) {
           const isDir = entry.isDirectory();
           matches.push({
-            text: "@" + path7__namespace.relative(this.workingDirectory, path7__namespace.join(dirPath, entry.name)).replace(/\\/g, "/") + (isDir ? "/" : ""),
+            text: "@" + path5__namespace.relative(this.workingDirectory, path5__namespace.join(dirPath, entry.name)).replace(/\\/g, "/") + (isDir ? "/" : ""),
             displayText: entry.name + (isDir ? "/" : ""),
             description: isDir ? "\u76EE\u5F55" : "\u6587\u4EF6",
             type: isDir ? "directory" : "file"
@@ -7732,10 +7703,10 @@ var Completer = class {
 // src/cli/repl.ts
 init_new();
 async function startInteractiveMode(options) {
-  const historyFile = path7__namespace.join(options.workingDirectory, ".sf-cli", "history.json");
+  const historyFile = path5__namespace.join(options.workingDirectory, ".sf-cli", "history.json");
   let history = [];
   try {
-    const historyData = await fs7__namespace.readFile(historyFile, "utf-8");
+    const historyData = await fs5__namespace.readFile(historyFile, "utf-8");
     history = JSON.parse(historyData);
   } catch {
   }
@@ -7768,11 +7739,11 @@ async function startInteractiveMode(options) {
   const modelService = new ModelService(configManager);
   const normsManager = new NormsManager({
     projectPath: options.workingDirectory,
-    normsDir: path7__namespace.join(options.workingDirectory, ".sf-cli", "norms")
+    normsDir: path5__namespace.join(options.workingDirectory, ".sf-cli", "norms")
   });
   await configManager.load(options.workingDirectory);
   await contextManager.initialize(options.workingDirectory);
-  const statsDir = path7__namespace.join(options.workingDirectory, ".sf-cli");
+  const statsDir = path5__namespace.join(options.workingDirectory, ".sf-cli");
   await modelService.initialize(statsDir);
   await normsManager.initialize();
   const state = {
@@ -7822,8 +7793,8 @@ async function startInteractiveMode(options) {
   }
   const saveHistory = async () => {
     try {
-      await fs7__namespace.mkdir(path7__namespace.dirname(historyFile), { recursive: true });
-      await fs7__namespace.writeFile(historyFile, JSON.stringify(history.slice(-500)));
+      await fs5__namespace.mkdir(path5__namespace.dirname(historyFile), { recursive: true });
+      await fs5__namespace.writeFile(historyFile, JSON.stringify(history.slice(-500)));
     } catch {
     }
   };
@@ -7894,16 +7865,15 @@ async function startInteractiveMode(options) {
 }
 
 // src/cli/index.ts
-init_config();
 function getPackageJson() {
   const possiblePaths = [
-    path7__namespace.resolve(__dirname, "..", "..", "package.json"),
-    path7__namespace.resolve(__dirname, "..", "..", "..", "package.json")
+    path5__namespace.resolve(__dirname, "..", "..", "package.json"),
+    path5__namespace.resolve(__dirname, "..", "..", "..", "package.json")
   ];
   for (const pkgPath of possiblePaths) {
     try {
-      if (fs9__namespace.existsSync(pkgPath)) {
-        const content = fs9__namespace.readFileSync(pkgPath, "utf-8");
+      if (fs7__namespace.existsSync(pkgPath)) {
+        const content = fs7__namespace.readFileSync(pkgPath, "utf-8");
         return JSON.parse(content);
       }
     } catch {
@@ -7932,7 +7902,7 @@ commander.program.command("init").description("\u521D\u59CB\u5316\u63A5\u7BA1\u9
 commander.program.command("model").description("\u9009\u62E9AI\u6A21\u578B").action(async () => {
   const configManager = new ConfigManager();
   await configManager.load(process.cwd());
-  const { selectModel: selectModel2 } = await Promise.resolve().then(() => (init_model3(), model_exports));
+  const { selectModel: selectModel2 } = await Promise.resolve().then(() => (init_model2(), model_exports));
   await selectModel2(configManager);
 });
 commander.program.command("update").description("\u66F4\u65B0CLI\u5230\u6700\u65B0\u7248\u672C").action(async () => {