tt-help-cli-ycl 1.4.11 → 1.4.13

package/src/watch/server.js

@@ -683,9 +683,18 @@ export function startWatchServer(
 
       if (req.method === "GET" && routePath === "/api/comment-tasks") {
         const limit = parseInt(params.limit) || 1;
-        const tasks = store.getPendingCommentTasks(limit);
+        const locationsParam = params.locations || "";
+        const locations = locationsParam
+          ? locationsParam
+              .split(",")
+              .map((s) => s.trim().toUpperCase())
+              .filter(Boolean)
+          : null;
+        const tasks = store.getPendingCommentTasks(limit, locations);
         const ts = new Date().toISOString().slice(11, 19);
-        console.error(`[JOB ${ts}] COMMENT-TASKS: ${tasks.length} tasks`);
+        console.error(
+          `[JOB ${ts}] COMMENT-TASKS: ${tasks.length} tasks${locations ? " (locations: " + locations.join(",") + ")" : ""}`,
+        );
         sendJSON(res, 200, { total: tasks.length, tasks });
         return;
       }
@@ -1491,6 +1500,327 @@ export function startWatchServer(
         return;
       }
 
+      // ====== 自学习系统 API ======
+
+      // GET /api/tags/selflearn/status — 自学习系统状态总览
+      if (req.method === "GET" && routePath === "/api/tags/selflearn/status") {
+        try {
+          const { getSelfLearnStatus } = await import("./tag-selflearn.js");
+          const status = getSelfLearnStatus();
+          sendJSON(res, 200, status);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/classify-dead — 分类所有 dead tag
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/classify-dead"
+      ) {
+        try {
+          const { classifyDeadTags } = await import("./tag-selflearn.js");
+          const body = await readBody(req);
+          const result = classifyDeadTags(body?.country || null);
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/cleanup-truly-dead — 删除真正不存在的 dead tag
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/cleanup-truly-dead"
+      ) {
+        try {
+          const { cleanupTrulyDeadTags } = await import("./tag-selflearn.js");
+          const result = cleanupTrulyDeadTags();
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags/selflearn/dead-stats?country=DE — dead tag 分类统计
+      if (
+        req.method === "GET" &&
+        routePath === "/api/tags/selflearn/dead-stats"
+      ) {
+        try {
+          const { getDeadTagStats } = await import("./tag-selflearn.js");
+          const country = params.country || null;
+          const stats = getDeadTagStats(country);
+          sendJSON(res, 200, stats || {});
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/init-directions — 初始化某国的探索方向
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/init-directions"
+      ) {
+        try {
+          const { initDefaultDirections } = await import("./tag-selflearn.js");
+          const body = await readBody(req);
+          const country = body?.country;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const result = initDefaultDirections(country);
+          sendJSON(res, 200, {
+            ok: true,
+            count: result.length,
+            directions: result,
+          });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags/selflearn/directions?country=DE&level=1 — 获取方向列表
+      if (
+        req.method === "GET" &&
+        routePath === "/api/tags/selflearn/directions"
+      ) {
+        try {
+          const { getDirections } = await import("./tag-selflearn.js");
+          const country = params.country;
+          const level = parseInt(params.level) || 1;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const directions = getDirections(country, level);
+          sendJSON(res, 200, directions);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags/selflearn/cross-country?country=ES — 跨国家推荐
+      if (
+        req.method === "GET" &&
+        routePath === "/api/tags/selflearn/cross-country"
+      ) {
+        try {
+          const { getCrossCountryRecommendations } =
+            await import("./tag-selflearn.js");
+          const country = params.country;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const limit = parseInt(params.limit) || 20;
+          const recommendations = getCrossCountryRecommendations(
+            country,
+            limit,
+          );
+          sendJSON(res, 200, recommendations);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/record-cross-country — 记录跨国家学习结果
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/record-cross-country"
+      ) {
+        try {
+          const { recordCrossCountryLearning } =
+            await import("./tag-selflearn.js");
+          const body = await readBody(req);
+          const {
+            sourceCountry,
+            sourceTag,
+            targetCountry,
+            targetTag,
+            resultStatus,
+            score,
+          } = body || {};
+          recordCrossCountryLearning(
+            sourceCountry,
+            sourceTag,
+            targetCountry,
+            targetTag,
+            resultStatus,
+            score,
+          );
+          sendJSON(res, 200, { ok: true });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/record-experiment — 记录实验
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/record-experiment"
+      ) {
+        try {
+          const { recordExperiment } = await import("./tag-selflearn.js");
+          const body = await readBody(req);
+          const result = recordExperiment(body);
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags/selflearn/experiments?country=DE&limit=10 — 获取实验历史
+      if (
+        req.method === "GET" &&
+        routePath === "/api/tags/selflearn/experiments"
+      ) {
+        try {
+          const { getExperimentHistory } = await import("./tag-selflearn.js");
+          const country = params.country;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const limit = parseInt(params.limit) || 10;
+          const experiments = getExperimentHistory(country, limit);
+          sendJSON(res, 200, experiments);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/analyst — 运行 LLM 分析师
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/analyst"
+      ) {
+        try {
+          const { runLLMAnalyst } = await import("./tag-selflearn.js");
+          const body = await readBody(req);
+          const countries = body?.countries || null;
+          const report = await runLLMAnalyst(countries);
+          sendJSON(res, 200, report);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags/selflearn/analyst/latest — 获取最新分析师报告
+      if (
+        req.method === "GET" &&
+        routePath === "/api/tags/selflearn/analyst/latest"
+      ) {
+        try {
+          const { getLatestAnalystReport } = await import("./tag-selflearn.js");
+          const report = getLatestAnalystReport();
+          sendJSON(res, 200, report || {});
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/analyst/execute-cleanup — 执行分析师建议的清理
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/analyst/execute-cleanup"
+      ) {
+        try {
+          const { executeAnalystCleanup } = await import("./tag-selflearn.js");
+          const result = executeAnalystCleanup();
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/selflearn/discover-layered — 分层探索生成 tag
+      if (
+        req.method === "POST" &&
+        routePath === "/api/tags/selflearn/discover-layered"
+      ) {
+        try {
+          const {
+            buildLayeredDiscoverPrompt,
+            getCrossCountryRecommendations,
+            getExperimentHistory,
+          } = await import("./tag-selflearn.js");
+          const { callLLM, parseTagsFromResponse, normalizeTag } =
+            await import("./tag-service.js");
+          const body = await readBody(req);
+          const { country, level = 1, directionName, count = 10 } = body || {};
+
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+
+          // 收集分层探索所需数据
+          const storeTags = store.getTagsByCountry(country, 50);
+          const storeDead = store.getDeadTags(country);
+          const crossCountryTips = getCrossCountryRecommendations(country, 5);
+          const experimentHistory = getExperimentHistory(country, 5);
+
+          const prompt = buildLayeredDiscoverPrompt(country, {
+            level,
+            existingProductive: storeTags,
+            existingDead: storeDead,
+            directionName,
+            experimentHistory,
+            crossCountryTips,
+          });
+
+          console.error(
+            `[selflearn] ${country} L${level} discover (direction: ${directionName || "auto"})`,
+          );
+          const content = await callLLM(prompt, 0.7);
+          const tags = parseTagsFromResponse(content);
+
+          // 全局去重
+          const { getAllExistingTagNames } = await import("./db-tags.js");
+          const allExisting = getAllExistingTagNames();
+          const unique = [...new Set(tags)]
+            .filter((t) => !allExisting.has(t))
+            .slice(0, count);
+
+          // 入库
+          const inserted = [];
+          for (const tag of unique) {
+            const result = store.insertTag(tag, [country], "llm");
+            if (result.inserted) inserted.push(result.tag);
+          }
+
+          sendJSON(res, 200, {
+            country,
+            level,
+            directionName,
+            generated: tags.length,
+            afterDedup: unique.length,
+            inserted: inserted.length,
+            tags: inserted,
+          });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // ====== 原有静态资源 ======
+
       if (
         req.method === "GET" &&
         (routePath === "/" || routePath === "/index.html")