tt-help-cli-ycl 1.4.2 → 1.4.4

package/src/watch/public/app.js

@@ -991,6 +991,33 @@ async function resetJob(uniqueId) {
   }
 }
 
+async function moveRestrictedToBase() {
+  const count = currentStats?.restrictedUsers || 0;
+  if (count === 0) {
+    showToast("没有受限用户");
+    return;
+  }
+  if (!confirm(`确定将 ${count} 个受限用户移到 jobs_base 吗？`)) return;
+  showLoading("迁移中...");
+  try {
+    const res = await fetch("/api/jobs/move-restricted-to-base", {
+      method: "POST",
+    });
+    const data = await res.json();
+    if (data.error) {
+      showToast(data.error, true);
+      return;
+    }
+    showToast(`已迁移 ${data.moved} 个受限用户`);
+    fetchStats();
+    fetchUsers();
+  } catch (e) {
+    showToast("迁移失败: " + e.message, true);
+  } finally {
+    hideLoading();
+  }
+}
+
 async function batchResetErrors() {
   const errorUsers = currentUsers.filter((u) => u.status === "error");
   if (errorUsers.length === 0) {

package/src/watch/public/index.html

@@ -41,7 +41,7 @@
         <div class="label">错误</div>
         <div class="value error" id="statError">0</div>
       </div>
-      <div class="stat-card">
+      <div class="stat-card clickable" onclick="moveRestrictedToBase()">
         <div class="label">受限</div>
         <div class="value error" id="statRestricted">0</div>
       </div>

package/src/watch/server.js

@@ -122,6 +122,93 @@ export function startWatchServer(
       console.error(`[JOB ${ts}] ${action}${d}`);
     }
 
+    // ── 标签发现机制（定时 + 按需双保险） ──
+    const DISCOVER_INTERVAL_MS = Math.max(
+      180000,
+      parseInt(process.env.TAG_DISCOVER_INTERVAL_MS || "300000", 10) || 300000,
+    );
+    const DISCOVER_COUNT_PER_COUNTRY = Math.max(
+      2,
+      parseInt(process.env.TAG_DISCOVER_COUNT || "6", 10) || 6,
+    );
+    // 按需触发阈值：new 标签总数低于此值时立即触发发现
+    const DISCOVER_LOW_THRESHOLD =
+      parseInt(process.env.TAG_DISCOVER_LOW_THRESHOLD || "5", 10) || 5;
+    // 冷却期：两次发现之间最小间隔（防止频繁触发 LLM）
+    const DISCOVER_COOLDOWN_MS = Math.max(
+      60000,
+      parseInt(process.env.TAG_DISCOVER_COOLDOWN_MS || "120000", 10) || 120000,
+    );
+    let discoverRunning = false;
+    let lastDiscoverTime = 0;
+
+    // 标签池充足阈值：new 标签总数超过此值时，定时触发直接跳过（不浪费 LLM token）
+    const DISCOVER_SUFFICIENT_TOTAL =
+      parseInt(process.env.TAG_DISCOVER_SUFFICIENT || "30", 10) || 30;
+
+    async function runAutoDiscover(trigger = "timer") {
+      if (discoverRunning) return;
+      const elapsed = Date.now() - lastDiscoverTime;
+      if (elapsed < DISCOVER_COOLDOWN_MS) {
+        const remainSec = Math.ceil((DISCOVER_COOLDOWN_MS - elapsed) / 1000);
+        console.error(
+          `[discover] 冷却中（还需 ${remainSec}s），跳过本次触发 (${trigger})`,
+        );
+        return;
+      }
+      // 先看全局总量：标签池充足时直接跳过，不浪费 LLM token
+      const globalStats = store.getTagStats();
+      const totalNew = globalStats?.new || 0;
+      if (totalNew >= DISCOVER_SUFFICIENT_TOTAL) {
+        console.error(
+          `[discover] 标签池充足 (${totalNew} 个 new ≥ ${DISCOVER_SUFFICIENT_TOTAL})，跳过 [触发: ${trigger}]`,
+        );
+        return;
+      }
+      discoverRunning = true;
+      try {
+        // 只为 new 标签不足的国家发现
+        const countriesToDiscover = [];
+        const { getTagsByStatus } = await import("./db-tags.js");
+        for (const country of DEFAULT_TARGET_LOCATIONS) {
+          const newTags = getTagsByStatus("new", 100, 0, country);
+          if (newTags.length < 10) {
+            countriesToDiscover.push(country);
+          }
+        }
+        if (countriesToDiscover.length === 0) {
+          console.error("[discover] 所有国家标签充足，跳过本轮");
+          return;
+        }
+        console.error(
+          `[discover] 开始为 ${countriesToDiscover.length} 个国家发现标签 (${countriesToDiscover.join(",")}) [触发: ${trigger}]...`,
+        );
+        const { discoverTagsForCountry } = await import("./tag-service.js");
+        let totalAdded = 0;
+        for (const country of countriesToDiscover) {
+          try {
+            const result = await discoverTagsForCountry(
+              store,
+              country,
+              DISCOVER_COUNT_PER_COUNTRY,
+            );
+            totalAdded += result.added || 0;
+            console.error(
+              `[discover] ${country}: 新增 ${result.added || 0} 个标签`,
+            );
+          } catch (e) {
+            console.error(`[discover] ${country}: 失败 - ${e.message}`);
+          }
+        }
+        console.error(`[discover] 本轮完成，共新增 ${totalAdded} 个标签`);
+        lastDiscoverTime = Date.now();
+      } catch (e) {
+        console.error(`[discover] 异常: ${e.message}`);
+      } finally {
+        discoverRunning = false;
+      }
+    }
+
     const server = http.createServer(async (req, res) => {
       const { path: routePath, params } = parseQuery(req.url);
 
@@ -274,6 +361,19 @@ export function startWatchServer(
         return;
       }
 
+      if (
+        req.method === "POST" &&
+        routePath === "/api/jobs/move-restricted-to-base"
+      ) {
+        try {
+          const result = store.moveRestrictedJobsToBase();
+          sendJSON(res, result.ok ? 200 : 400, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
       // 将 jobs/raw_jobs 中 tt_seller=1 且 video_count=0 的记录移动到 jobs_base
       if (
         req.method === "POST" &&
@@ -1169,9 +1269,28 @@ export function startWatchServer(
           tags = store.getAllTags(limit, offset, upperCountry);
         }
 
-        // 获取总数（带国家过滤）
+        // 获取总数（带国家过滤，按 status 返回对应计数）
         const stats = store.getTagStats(upperCountry);
-        const total = stats ? stats.total : tags.length;
+        let total;
+        if (stats) {
+          if (status === "new") total = stats.new;
+          else if (status === "productive") total = stats.productive;
+          else if (status === "dead") total = stats.dead;
+          else if (status === "scoring") total = stats.scoring;
+          else total = stats.total;
+        } else {
+          total = tags.length;
+        }
+
+        // 按需发现：客户端取 new 标签时，如果池子低于阈值，立即触发发现
+        if (
+          status === "new" &&
+          total < DISCOVER_LOW_THRESHOLD &&
+          !discoverRunning
+        ) {
+          runAutoDiscover("low-pool"); // 异步触发，不阻塞响应
+        }
+
         sendJSON(res, 200, { tags, total, offset, limit });
         return;
       }
@@ -1199,6 +1318,24 @@ export function startWatchServer(
         return;
       }
 
+      // GET /api/tags/recent-generated?country=ES&lookback=10 — 最近N轮生成的标签（去重）
+      if (req.method === "GET" && routePath === "/api/tags/recent-generated") {
+        try {
+          const { getRecentGeneratedTags } = await import("./db-tags.js");
+          const country = params.country;
+          const lookback = parseInt(params.lookback) || 10;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const tags = getRecentGeneratedTags(country, lookback);
+          sendJSON(res, 200, { tags, total: tags.length });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
       // POST /api/tags/batch-add — 批量添加关键词
       if (req.method === "POST" && routePath === "/api/tags/batch-add") {
         try {
@@ -1226,6 +1363,112 @@ export function startWatchServer(
         return;
       }
 
+      // GET /api/tags/health?country=ES — 自闭环：获取国家 tag 健康指标
+      if (req.method === "GET" && routePath === "/api/tags/health") {
+        try {
+          const { getCountryHealth } = await import("./db-tags.js");
+          const country = params.country;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const health = getCountryHealth(country);
+          if (!health) {
+            sendJSON(res, 404, { error: "未找到该国家的数据" });
+            return;
+          }
+          sendJSON(res, 200, health);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/cleanup — 自闭环：触发数据清理
+      if (req.method === "POST" && routePath === "/api/tags/cleanup") {
+        try {
+          const {
+            cleanupLowScoredTags,
+            cleanupStaleScoringTags,
+            cleanupErrorTags,
+          } = await import("./db-tags.js");
+          const body = await readBody(req);
+          const actions = body || {};
+          const result = {};
+
+          if (actions.staleScoringReset) {
+            const r = cleanupStaleScoringTags();
+            result.staleScoringReset = r.reset;
+          }
+          if (actions.errorReset) {
+            const r = cleanupErrorTags();
+            result.errorReset = r.reset;
+          }
+          if (actions.lowScoredCleanup) {
+            const r = cleanupLowScoredTags(20);
+            result.lowScoredCleanup = r.cleaned;
+          }
+
+          sendJSON(res, 200, { ok: true, ...result });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/reflect?country=DE — 自闭环：手动触发反思
+      if (req.method === "POST" && routePath === "/api/tags/reflect") {
+        try {
+          const { reflectAndLearn } = await import("./tag-service.js");
+          const country = params.country;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const result = await reflectAndLearn(store, country);
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags/rules?country=DE — 查看当前活跃的反思规则
+      if (req.method === "GET" && routePath === "/api/tags/rules") {
+        try {
+          const { getActiveRules, shouldTriggerReflection } =
+            await import("./db-tags.js");
+          const country = params.country;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const rules = getActiveRules(country);
+          const triggerCheck = shouldTriggerReflection(country);
+          sendJSON(res, 200, { country, rules, triggerCheck });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags/reflection-data?country=DE — 查看反思所需的全量数据
+      if (req.method === "GET" && routePath === "/api/tags/reflection-data") {
+        try {
+          const { getReflectionData } = await import("./db-tags.js");
+          const country = params.country;
+          if (!country) {
+            sendJSON(res, 400, { error: "country 参数必填" });
+            return;
+          }
+          const data = getReflectionData(country);
+          sendJSON(res, 200, data);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
       // POST /api/tags/productive — CLI 模式上报 productive tag
       if (req.method === "POST" && routePath === "/api/tags/productive") {
         try {
@@ -1335,6 +1578,16 @@ export function startWatchServer(
         console.error(`[启动] 清理 scoring 标签失败: ${e.message}`);
       }
 
+      // 启动后 30 秒首次发现（给服务启动缓冲），之后定时执行
+      const discoverTimer = setInterval(
+        () => runAutoDiscover("timer"),
+        DISCOVER_INTERVAL_MS,
+      );
+      setTimeout(() => runAutoDiscover("startup"), 30000);
+      console.error(
+        `[discover] 定时+按需发现已启动: 定时间隔 ${DISCOVER_INTERVAL_MS / 60000} 分钟, 每国 ${DISCOVER_COUNT_PER_COUNTRY} 个标签, 按需阈值 ${DISCOVER_LOW_THRESHOLD}, 冷却期 ${DISCOVER_COOLDOWN_MS / 1000}s`,
+      );
+
       _resolve({ server, port });
     });