tt-help-cli-ycl 1.4.21 → 1.4.22

package/src/watch/llm-config.js

@@ -0,0 +1,269 @@
+/**
+ * LLM 配置持久化模块
+ *
+ * 运行时动态读写 LLM 配置（Provider、Model、URL、APIKey），
+ * 优先从 SQLite 读取，fallback 到环境变量。
+ * 通过 API 修改后立即生效，无需重启。
+ *
+ * 结构：Provider（服务商） → Models（模型列表）
+ * 选择 Provider 自动填入对应 URL，选择 Model 使用对应 model id。
+ */
+
+import { getDb } from "./db-schema.js";
+
+// ====== Provider + Model 定义 ======
+
+export const LLM_PROVIDERS = [
+  {
+    id: "legacy",
+    name: "旧 LLM (zc-fast)",
+    url: "http://82.156.52.214:18000/v1/chat/completions",
+    models: [{ id: "zc-fast", label: "zc-fast" }],
+  },
+  {
+    id: "dashscope",
+    name: "阿里云 DashScope",
+    url: "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
+    models: [
+      { id: "auto", label: "🤖 自动（程序选择）" },
+      { id: "qwen3.7-max", label: "Qwen3.7-Max" },
+      { id: "qwen3.7-max-2026-06-08", label: "Qwen3.7-Max-2026-06-08" },
+      { id: "qwen3.7-max-2026-05-20", label: "Qwen3.7-Max-2026-05-20" },
+      { id: "qwen3.7-max-2026-05-17", label: "Qwen3.7-Max-2026-05-17" },
+      { id: "qwen3.7-max-preview", label: "Qwen3.7-Max-Preview" },
+      { id: "qwen3.7-plus", label: "Qwen3.7-Plus" },
+      { id: "qwen3.7-plus-2026-05-26", label: "Qwen3.7-Plus-2026-05-26" },
+      { id: "qwen3.6-plus", label: "Qwen3.6-Plus" },
+      { id: "qwen3.6-plus-2026-04-02", label: "Qwen3.6-Plus-2026-04-02" },
+      { id: "qwen3.6-max-preview", label: "Qwen3.6-Max-Preview" },
+      { id: "qwen3.6-flash", label: "Qwen3.6-Flash" },
+      { id: "qwen3.6-flash-2026-04-16", label: "Qwen3.6-Flash-2026-04-16" },
+      { id: "qwen3.6-35b-a3b", label: "Qwen3.6-35B-A3B" },
+      { id: "qwen3.6-27b", label: "Qwen3.6-27B" },
+      { id: "qwen3.5-plus", label: "Qwen3.5-Plus" },
+      { id: "qwen3.5-plus-2026-04-20", label: "Qwen3.5-Plus-2026-04-20" },
+      { id: "qwen3.5-ocr", label: "Qwen3.5-OCR" },
+      { id: "qwen-plus", label: "Qwen-Plus" },
+      { id: "qwen-turbo", label: "Qwen-Turbo（即将下线）" },
+      { id: "qwen-max", label: "Qwen-Max" },
+      { id: "deepseek-v4-flash", label: "DeepSeek-V4-Flash" },
+      { id: "deepseek-v4-pro", label: "DeepSeek-V4-Pro" },
+      { id: "glm-5.2", label: "GLM-5.2" },
+      { id: "kimi-k2.7-code", label: "Kimi-K2.7-Code" },
+      { id: "kimi-k2.6", label: "Kimi-K2.6" },
+    ],
+  },
+];
+
+/** 根据 providerId 查找 provider */
+export function findProvider(providerId) {
+  return LLM_PROVIDERS.find((p) => p.id === providerId) || LLM_PROVIDERS[0];
+}
+
+/** 根据 providerId + modelId 查找模型 */
+export function findModel(providerId, modelId) {
+  const provider = findProvider(providerId);
+  return provider.models.find((m) => m.id === modelId) || provider.models[0];
+}
+
+// 兼容旧接口：扁平模型选项列表
+export const LLM_MODEL_OPTIONS = LLM_PROVIDERS.flatMap((p) =>
+  p.models.map((m) => ({
+    id: m.id,
+    label: `${m.label} (${p.name})`,
+    url: p.url,
+  })),
+);
+
+// ====== 内存缓存 ======
+
+let _cachedProvider = null;
+let _cachedModel = null;
+let _cachedUrl = null;
+let _cachedApiKey = null;
+let _loaded = false;
+
+function ensureTable() {
+  const db = getDb();
+  if (!db) return;
+  db.prepare(
+    `CREATE TABLE IF NOT EXISTS _llm_config (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )`,
+  ).run();
+}
+
+function loadFromDb() {
+  const db = getDb();
+  if (!db) return {};
+  ensureTable();
+  try {
+    const rows = db.prepare("SELECT key, value FROM _llm_config").all();
+    const config = {};
+    for (const row of rows) {
+      config[row.key] = row.value;
+    }
+    return config;
+  } catch {
+    return {};
+  }
+}
+
+function saveToDb(key, value) {
+  const db = getDb();
+  if (!db) return;
+  ensureTable();
+  db.prepare(
+    `INSERT INTO _llm_config (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+  ).run(key, String(value));
+}
+
+/**
+ * 加载配置（服务启动时调用一次）
+ * 优先级：SQLite > 环境变量 > 默认值
+ */
+export function loadLlmConfig() {
+  if (_loaded) return;
+  const dbConfig = loadFromDb();
+
+  _cachedUrl = dbConfig.llm_url || process.env.LLM_URL || LLM_PROVIDERS[0].url;
+  _cachedModel =
+    dbConfig.llm_model ||
+    process.env.LLM_MODEL ||
+    LLM_PROVIDERS[0].models[0].id;
+  _cachedProvider = dbConfig.llm_provider || LLM_PROVIDERS[0].id;
+  _cachedApiKey = dbConfig.llm_apikey || process.env.APIKEY || "";
+  _loaded = true;
+
+  console.error(
+    `[llm-config] 加载完成: provider=${_cachedProvider}, model=${_cachedModel}, url=${_cachedUrl}, hasKey=${!!_cachedApiKey}`,
+  );
+}
+
+/**
+ * 获取当前 LLM 配置（供前端 API 使用）
+ */
+export function getLlmConfig() {
+  if (!_loaded) loadLlmConfig();
+  return {
+    provider: _cachedProvider,
+    model: _cachedModel,
+    url: _cachedUrl,
+    hasApiKey: !!_cachedApiKey,
+    apiKeyHint: _cachedApiKey
+      ? _cachedApiKey.slice(0, 6) + "..." + _cachedApiKey.slice(-4)
+      : "",
+  };
+}
+
+/** 获取当前 LLM URL（内部调用） */
+export function getLlmUrl() {
+  if (!_loaded) loadLlmConfig();
+  return _cachedUrl;
+}
+
+// Auto 模式的候选模型池（按优先级排列，优先用快的）
+const AUTO_POOL = [
+  "qwen-turbo",
+  "qwen-plus",
+  "qwen3.6-flash",
+  "qwen3.6-27b",
+  "qwen3.5-plus",
+  "qwen3.6-plus",
+];
+let _lastAutoSuccess = null; // 上次成功的模型，下次优先用它
+
+/** 是否处于 auto 模式 */
+export function isAutoMode() {
+  if (!_loaded) loadLlmConfig();
+  return _cachedModel === "auto";
+}
+
+/** 记录 auto 模式下成功调用的模型 */
+export function recordAutoSuccess(model) {
+  _lastAutoSuccess = model;
+}
+
+/** 获取 auto 模式候选池（上次成功的排最前，失败时依次尝试） */
+export function getAutoPool() {
+  const pool = [...AUTO_POOL];
+  if (_lastAutoSuccess) {
+    const idx = pool.indexOf(_lastAutoSuccess);
+    if (idx > 0) {
+      // 把上次成功的移到第一位，其余保持相对顺序
+      pool.splice(idx, 1);
+      pool.unshift(_lastAutoSuccess);
+    }
+  }
+  return pool;
+}
+
+/** 解析当前实际使用的 model（auto 模式下轮询选一个） */
+function resolveModel() {
+  if (_cachedModel !== "auto") return _cachedModel;
+  const idx = _autoRoundIdx % AUTO_POOL.length;
+  _autoRoundIdx++;
+  return AUTO_POOL[idx];
+}
+
+/** 获取当前 LLM Model（内部调用，auto 模式自动轮询） */
+export function getLlmModel() {
+  if (!_loaded) loadLlmConfig();
+  return resolveModel();
+}
+
+/** 获取当前 API Key（内部调用） */
+export function getLlmApiKey() {
+  if (!_loaded) loadLlmConfig();
+  return _cachedApiKey;
+}
+
+/**
+ * 更新 LLM 配置（通过 API 调用）
+ * @param {{ provider?: string, model?: string, url?: string, apiKey?: string }} updates
+ */
+export function updateLlmConfig(updates = {}) {
+  if (!_loaded) loadLlmConfig();
+
+  // Provider 变更：切换 URL，Model 用指定的或默认第一个
+  if (updates.provider !== undefined) {
+    const provider = findProvider(updates.provider);
+    _cachedProvider = provider.id;
+    _cachedUrl = provider.url;
+    // 如果同时传了 model 且在 provider 中存在，用指定的；否则用第一个
+    const specifiedModel =
+      updates.model !== undefined
+        ? provider.models.find((m) => m.id === updates.model)
+        : null;
+    _cachedModel = specifiedModel ? specifiedModel.id : provider.models[0].id;
+    saveToDb("llm_provider", provider.id);
+    saveToDb("llm_url", provider.url);
+    saveToDb("llm_model", _cachedModel);
+  } else if (updates.model !== undefined) {
+    // Model 单独变更（同 provider 内切换）
+    _cachedModel = updates.model;
+    saveToDb("llm_model", updates.model);
+  }
+
+  // URL 手动覆盖
+  if (updates.url !== undefined) {
+    _cachedUrl = updates.url;
+    saveToDb("llm_url", updates.url);
+  }
+
+  // API Key（跳过提示字符串：含 "..." 且长度 < 20 的视为 hint，不覆盖）
+  if (updates.apiKey !== undefined && updates.apiKey !== "") {
+    const isHint = updates.apiKey.includes("...") && updates.apiKey.length < 20;
+    if (!isHint) {
+      _cachedApiKey = updates.apiKey;
+      saveToDb("llm_apikey", updates.apiKey);
+    }
+  }
+
+  console.error(
+    `[llm-config] 配置已更新: provider=${_cachedProvider}, model=${_cachedModel}, url=${_cachedUrl}, hasKey=${!!_cachedApiKey}`,
+  );
+
+  return getLlmConfig();
+}

package/src/watch/llm-scoring.js

@@ -42,104 +42,144 @@ Standards: 90-100=clear match, 70-89=likely, 50-69=possible, 20-49=low, 0-19=unl
 `;
 
   try {
-    const apiKey = process.env.APIKEY || "";
-    const response = await undiciFetch(
-      "http://82.156.52.214:18000/v1/chat/completions",
-      {
+    const { getLlmUrl, getLlmApiKey, isAutoMode, getAutoPool } =
+      await import("./llm-config.js");
+    const llmUrl = getLlmUrl();
+    const apiKey = getLlmApiKey();
+
+    // auto 模式：依次尝试候选池中的模型
+    const models = isAutoMode() ? getAutoPool() : [null];
+
+    let lastError = "";
+    for (let i = 0; i < models.length; i++) {
+      const llmModel =
+        models[i] !== null
+          ? models[i]
+          : (await import("./llm-config.js")).getLlmModel();
+
+      const response = await undiciFetch(llmUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${apiKey}`,
         },
         body: JSON.stringify({
-          model: "zc-fast",
+          model: llmModel,
           messages: [{ role: "user", content: prompt }],
           max_tokens: 512,
           temperature: 0.1,
+          enable_thinking: false,
         }),
-      },
-    );
+      });
+
+      const result = await response.json().catch(() => null);
+      const content = result?.choices?.[0]?.message?.content || "";
+
+      if (!content) {
+        const errMsg = result?.error?.message || `HTTP ${response.status}`;
+        lastError = errMsg;
+        console.error(
+          `[scoreJobLocation] ${llmModel} 失败: ${errMsg}，尝试下一个`,
+        );
+        continue;
+      }
+
+      if (i > 0) {
+        console.error(`[scoreJobLocation] ✅ auto 切换成功: ${llmModel}`);
+      }
+
+      let parsed = null;
 
-    const result = await response.json();
-    const content = result.choices?.[0]?.message?.content || "";
-
-    let parsed = null;
-
-    // 尝试 1: 直接解析
-    try {
-      parsed = JSON.parse(content);
-    } catch {
-      // 尝试 2: 提取 {} 包裹的内容
-      const match = content.match(/\{[\s\S]*\}/);
-      if (match) {
-        try {
-          parsed = JSON.parse(match[0]);
-        } catch {
-          // 尝试 3: 清理常见问题后解析
-          const cleaned = match[0]
-            .replace(/"/g, '"')
-            .replace(/\s+/g, " ")
-            .trim();
+      // 尝试 1: 直接解析
+      try {
+        parsed = JSON.parse(content);
+      } catch {
+        // 尝试 2: 提取 {} 包裹的内容
+        const match = content.match(/\{[\s\S]*\}/);
+        if (match) {
           try {
-            parsed = JSON.parse(cleaned);
+            parsed = JSON.parse(match[0]);
           } catch {
-            // 尝试 4: 从文本中提取 score 和 reason
-            const scoreMatch = content.match(/"?score"?\s*:\s*(\d+)/i);
-            if (scoreMatch) {
-              let reason = "解析降级";
-              const reasonKeyPos = content.search(/"?reason"?\s*:\s*"/i);
-              if (reasonKeyPos !== -1) {
-                const afterKey = content.substring(reasonKeyPos);
-                const colonPos = afterKey.indexOf(":");
-                const valueStart = afterKey.indexOf('"', colonPos + 1) + 1;
-                const rawValue = afterKey.substring(valueStart);
-                const lastBrace = content.lastIndexOf("}");
-                const reasonEnd = lastBrace - reasonKeyPos - valueStart;
-                if (reasonEnd > 0) {
-                  reason = rawValue.substring(0, reasonEnd).trim();
-                  if (reason.startsWith('"')) reason = reason.substring(1);
-                  if (reason.endsWith('"'))
-                    reason = reason.substring(0, reason.length - 1);
+            // 尝试 3: 清理常见问题后解析
+            const cleaned = match[0]
+              .replace(/"/g, '"')
+              .replace(/\s+/g, " ")
+              .trim();
+            try {
+              parsed = JSON.parse(cleaned);
+            } catch {
+              // 尝试 4: 从文本中提取 score 和 reason
+              const scoreMatch = content.match(/"?score"?\s*:\s*(\d+)/i);
+              if (scoreMatch) {
+                let reason = "解析降级";
+                const reasonKeyPos = content.search(/"?reason"?\s*:\s*"/i);
+                if (reasonKeyPos !== -1) {
+                  const afterKey = content.substring(reasonKeyPos);
+                  const colonPos = afterKey.indexOf(":");
+                  const valueStart = afterKey.indexOf('"', colonPos + 1) + 1;
+                  const rawValue = afterKey.substring(valueStart);
+                  const lastBrace = content.lastIndexOf("}");
+                  const reasonEnd = lastBrace - reasonKeyPos - valueStart;
+                  if (reasonEnd > 0) {
+                    reason = rawValue.substring(0, reasonEnd).trim();
+                    if (reason.startsWith('"')) reason = reason.substring(1);
+                    if (reason.endsWith('"'))
+                      reason = reason.substring(0, reason.length - 1);
+                  }
                 }
+                parsed = { score: parseInt(scoreMatch[1]) || 50, reason };
               }
-              parsed = { score: parseInt(scoreMatch[1]) || 50, reason };
             }
           }
         }
+
+        // 尝试 5: 更宽松的正则提取
+        if (!parsed) {
+          const scoreMatch = content.match(/"score"\s*:\s*(\d+)/);
+          const reasonMatch = content.match(/"reason"\s*:\s*"([^"]*)"/);
+          if (scoreMatch) {
+            parsed = {
+              score: parseInt(scoreMatch[1]) || 50,
+              reason: reasonMatch ? reasonMatch[1] : "解析降级 - 宽松模式",
+            };
+          }
+        }
       }
 
-      // 尝试 5: 更宽松的正则提取
-      if (!parsed) {
-        const scoreMatch = content.match(/"score"\s*:\s*(\d+)/);
-        const reasonMatch = content.match(/"reason"\s*:\s*"([^"]*)"/);
-        if (scoreMatch) {
-          parsed = {
-            score: parseInt(scoreMatch[1]) || 50,
-            reason: reasonMatch ? reasonMatch[1] : "解析降级 - 宽松模式",
-          };
+      if (parsed && typeof parsed.score === "number") {
+        if (isAutoMode()) {
+          const { recordAutoSuccess } = await import("./llm-config.js");
+          recordAutoSuccess(llmModel);
         }
+        return {
+          uniqueId: job.unique_id,
+          score: Math.max(0, Math.min(100, parsed.score)),
+          reason: parsed.reason || "",
+        };
       }
-    }
 
-    if (parsed && typeof parsed.score === "number") {
+      console.error(
+        `[scoreJobLocation] JSON 解析失败 (${job.unique_id}): ${content.substring(0, 100)}`,
+      );
       return {
         uniqueId: job.unique_id,
-        score: Math.max(0, Math.min(100, parsed.score)),
-        reason: parsed.reason || "",
+        score: 50,
+        reason: "LLM 响应解析失败，使用默认分",
       };
-    }
+    } // end for
 
+    // 全部模型均失败
     console.error(
-      `[scoreJobLocation] JSON 解析失败 (${job.unique_id}): ${content.substring(0, 100)}`,
+      `[scoreJobLocation] ❌ ${models.length} 个模型均失败 (${job.unique_id}): ${lastError}`,
     );
     return {
       uniqueId: job.unique_id,
       score: 50,
-      reason: "LLM 响应解析失败，使用默认分",
+      reason: `全部模型失败: ${lastError}`,
     };
   } catch (e) {
     console.error(
-      `[scoreJobLocation] LLM 调用失败 (${job.unique_id}): ${e.message}`,
+      `[scoreJobLocation] LLM 调用异常 (${job.unique_id}): ${e.message}`,
     );
     return {
       uniqueId: job.unique_id,