tt-help-cli-ycl 1.3.84 → 1.3.85

package/src/watch/server.js

@@ -93,7 +93,11 @@ function inferClientType(routePath) {
   if (routePath.startsWith("/api/redo-job")) return "refresh";
   if (routePath.startsWith("/api/user-update-tasks")) return "attach";
   if (routePath.startsWith("/api/comment-task")) return "comments";
-  if (routePath.startsWith("/api/job") || routePath.startsWith("/api/explore-new")) return "explore";
+  if (
+    routePath.startsWith("/api/job") ||
+    routePath.startsWith("/api/explore-new")
+  )
+    return "explore";
   return null;
 }
 
@@ -165,6 +169,21 @@ export function startWatchServer(
         return;
       }
 
+      if (req.method === "POST" && routePath === "/api/raw-users") {
+        try {
+          const body = await readBody(req);
+          if (!Array.isArray(body.users) || body.users.length === 0) {
+            sendJSON(res, 400, { error: "users 数组不能为空" });
+            return;
+          }
+          const result = store.addRawUsers(body.users);
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 400, { error: e.message });
+        }
+        return;
+      }
+
       if (req.method === "POST" && routePath === "/api/user") {
         try {
           const userData = await readBody(req);
@@ -948,6 +967,150 @@ export function startWatchServer(
         return;
       }
 
+      // ====== Tag 发现与打分 API ======
+
+      // GET /api/tags/discover?country=ES&count=4&prompt=...
+      if (req.method === "GET" && routePath === "/api/tags/discover") {
+        const country = (params.country || "").toUpperCase();
+        if (!country || !/^[A-Z]{2}$/.test(country)) {
+          sendJSON(res, 400, { error: "country 参数无效，需为两位国家代码" });
+          return;
+        }
+        const count = Math.min(Math.max(parseInt(params.count) || 4, 1), 20);
+        const prompt = params.prompt || null;
+
+        try {
+          const { discoverTagsForCountry } = await import("./tag-service.js");
+          const result = await discoverTagsForCountry(
+            store,
+            country,
+            count,
+            prompt,
+          );
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/claim  { tag } — 锁定 tag 状态为 scoring（防并发冲突）
+      if (req.method === "POST" && routePath === "/api/tags/claim") {
+        try {
+          const body = await readBody(req);
+          const tag = (body.tag || "").trim().toLowerCase();
+          if (!tag) {
+            sendJSON(res, 400, { error: "tag 不能为空" });
+            return;
+          }
+          const result = store.claimTag(tag);
+          sendJSON(res, result.ok ? 200 : 409, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/score-result  { tag, status, score, totalPosts, authorCount, matchedAuthors, matchedCountries, pushedUsers, error }
+      if (req.method === "POST" && routePath === "/api/tags/score-result") {
+        try {
+          const body = await readBody(req);
+          const tag = (body.tag || "").trim().toLowerCase();
+          if (!tag) {
+            sendJSON(res, 400, { error: "tag 不能为空" });
+            return;
+          }
+          const result = store.reportTagScore(tag, body);
+          sendJSON(res, result.ok ? 200 : 400, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/score  { tag, countries: ["ES","FR"], serverUrl? } (保留兼容，服务端内置打分)
+      if (req.method === "POST" && routePath === "/api/tags/score") {
+        try {
+          const body = await readBody(req);
+          const tag = (body.tag || "").trim().toLowerCase();
+          if (!tag) {
+            sendJSON(res, 400, { error: "tag 不能为空" });
+            return;
+          }
+          const targetCountries = Array.isArray(body.countries)
+            ? body.countries
+            : ["ES"];
+          const serverUrl = body.serverUrl || null;
+
+          const { scoreTag } = await import("./tag-service.js");
+          const result = await scoreTag(store, {
+            tag,
+            targetCountries,
+            serverUrl,
+          });
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // POST /api/tags/score-batch  { limit: 10, countries: ["ES"], serverUrl? }
+      if (req.method === "POST" && routePath === "/api/tags/score-batch") {
+        try {
+          const body = await readBody(req);
+          const limit = Math.min(parseInt(body.limit) || 10, 50);
+          const targetCountries = Array.isArray(body.countries)
+            ? body.countries
+            : ["ES"];
+          const serverUrl = body.serverUrl || null;
+
+          const pendingTags = store.getTagsByStatus("new", limit);
+          if (pendingTags.length === 0) {
+            sendJSON(res, 200, { results: [], message: "no pending tags" });
+            return;
+          }
+
+          const { scoreTag } = await import("./tag-service.js");
+          const results = [];
+          for (const t of pendingTags) {
+            const r = await scoreTag(store, {
+              tag: t.tag,
+              targetCountries,
+              serverUrl,
+            });
+            results.push(r);
+          }
+          sendJSON(res, 200, { results, total: results.length });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        return;
+      }
+
+      // GET /api/tags?status=&country=&limit=
+      if (req.method === "GET" && routePath === "/api/tags") {
+        const status = params.status || null;
+        const country = params.country || null;
+        const limit = Math.min(parseInt(params.limit) || 100, 500);
+
+        let tags;
+        if (status) {
+          tags = store.getTagsByStatus(status, limit);
+        } else {
+          tags = store.getAllTags(limit);
+        }
+
+        if (country) {
+          tags = tags.filter((t) =>
+            t.countries.includes(country.toUpperCase()),
+          );
+        }
+
+        sendJSON(res, 200, { tags, total: tags.length });
+        return;
+      }
+
       if (
         req.method === "GET" &&
         (routePath === "/" || routePath === "/index.html")

package/src/watch/tag-service.js

@@ -0,0 +1,334 @@
+/**
+ * Tag 发现与打分服务
+ * - LLM 调用与 prompt 组装
+ * - 单国家标签发现（discoverTagsForCountry）
+ * - 标签打分（scoreTag / scoreTagBatch）
+ */
+
+// 国家 → 语言映射
+const COUNTRY_LANG = {
+  CZ: "cs",
+  GR: "el",
+  HU: "hu",
+  PT: "pt",
+  ES: "es",
+  PL: "pl",
+  NL: "nl",
+  BE: "nl",
+  DE: "de",
+  FR: "fr",
+  IT: "it",
+  IE: "en",
+  AT: "de",
+};
+
+const LLM_URL = "http://82.156.52.214:18000/v1/chat/completions";
+const LLM_MODEL = "zc-fast";
+
+function getLang(country) {
+  return COUNTRY_LANG[country] || "en";
+}
+
+// ====== LLM 调用 ======
+
+async function callLLM(prompt) {
+  const apiKey = process.env.APIKEY || "";
+  const { fetch } = await import("undici");
+
+  const response = await fetch(LLM_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: LLM_MODEL,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 1024,
+      temperature: 0.7,
+    }),
+  });
+
+  const result = await response.json();
+  return result.choices?.[0]?.message?.content || "";
+}
+
+function parseTagsFromResponse(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) return parsed;
+    if (Array.isArray(parsed.tags)) return parsed.tags;
+  } catch {}
+
+  const lines = content.split(/[\n,]+/);
+  const tags = [];
+  for (const line of lines) {
+    const cleaned = line
+      .replace(/^[-\d.\s#]+/, "")
+      .trim()
+      .toLowerCase();
+    if (cleaned && /^[a-z0-9_]+$/.test(cleaned) && cleaned.length >= 2) {
+      tags.push(cleaned);
+    }
+  }
+  return tags;
+}
+
+// ====== Prompt 组装 ======
+
+function buildDiscoverPrompt(country, count, history, userPrompt) {
+  const lang = getLang(country);
+  const langNames = {
+    cs: "Czech",
+    el: "Greek",
+    hu: "Hungarian",
+    pt: "Portuguese",
+    es: "Spanish",
+    pl: "Polish",
+    nl: "Dutch",
+    de: "German",
+    fr: "French",
+    it: "Italian",
+    en: "English",
+  };
+  const langName = langNames[lang] || lang;
+
+  // 正样本：该国高分 tag
+  const productive = history.productive || [];
+  const productiveHint =
+    productive.length > 0
+      ? `\nHigh-performing tags for ${country}: ${productive.map((t) => t.tag).join(", ")}. Generate new tags in similar patterns.`
+      : "";
+
+  // 负样本：该国 dead tag
+  const dead = history.dead || [];
+  const deadHint =
+    dead.length > 0
+      ? `\nAvoid these tags and similar patterns (they found no matching users): ${dead.map((t) => t.tag).join(", ")}.`
+      : "";
+
+  // 死因分析
+  const errorPatterns = [
+    ...new Set(dead.filter((t) => t.last_error).map((t) => t.last_error)),
+  ];
+  const errorHint =
+    errorPatterns.length > 0
+      ? `\nReasons previous tags failed: ${errorPatterns.join("; ")}. Avoid generating tags likely to have same issues.`
+      : "";
+
+  const userHint = userPrompt
+    ? `\nAdditional focus: ${userPrompt}. Generate tags specifically for this niche.`
+    : "";
+
+  return `Generate ${count} TikTok hashtags in ${langName} language for e-commerce sellers, shop owners, and small business merchants in ${country}.
+
+Requirements:
+- Tags must be in ${langName} language (or widely used in ${country})
+- Focus on tags that sellers/merchants actually use to promote their products
+- Include local language commerce tags (sell, shop, store, online, vendor, etc.)
+- Prefer specific/niche tags over generic ones (e.g., "vendozapatos" not "vender")${productiveHint}${deadHint}${errorHint}${userHint}
+
+Return ONLY a JSON array of tag strings, nothing else. Example: ["ventas","tiendaonline","vender"]`;
+}
+
+// ====== discover: 单国家标签发现 ======
+
+export async function discoverTagsForCountry(
+  store,
+  country,
+  count = 4,
+  userPrompt = null,
+) {
+  if (!COUNTRY_LANG[country]) {
+    return { country, error: `不支持的国家代码: ${country}` };
+  }
+
+  // 读取历史打分记录
+  const productive = store.getTagsByCountry(country, 50);
+  const dead = store.getDeadTags(country);
+  const history = { productive, dead };
+
+  // 组装 prompt 并调用 LLM
+  const prompt = buildDiscoverPrompt(country, count, history, userPrompt);
+  console.error(
+    `[tag-service] LLM discover ${country} (lang=${getLang(country)}, count=${count})`,
+  );
+  const content = await callLLM(prompt);
+  const tags = parseTagsFromResponse(content);
+  const unique = [...new Set(tags)].slice(0, count);
+
+  console.error(
+    `[tag-service] LLM generated ${unique.length} tags: ${unique.join(", ")}`,
+  );
+
+  // 去重写入数据库
+  const inserted = [];
+  for (const tag of unique) {
+    const result = store.insertTag(tag, [country], "llm");
+    if (result.inserted) inserted.push(tag);
+  }
+
+  return {
+    country,
+    added: inserted.length,
+    tags: inserted,
+    total: unique.length,
+  };
+}
+
+// ====== score: 单标签打分 ======
+
+export async function scoreTag(store, { tag, targetCountries, serverUrl }) {
+  // 动态导入 tag-fetcher（避免循环依赖，仅在服务端调用）
+  const { fetchTagData, enrichVideosWithLocation } =
+    await import("../lib/tag-fetcher.js");
+  const { isLocationInList } = await import("../lib/target-locations.js");
+
+  const result = {
+    tag,
+    status: "error",
+    score: 0,
+    totalPosts: 0,
+    authorCount: 0,
+    matchedAuthors: 0,
+    matchedCountries: [],
+    pushedUsers: 0,
+    error: null,
+  };
+
+  try {
+    // Step 1: 抓取 tag 数据
+    console.error(
+      `[tag-service] Scoring #${tag} for [${targetCountries.join(",")}]`,
+    );
+    const tagResult = await fetchTagData(tag, {
+      onProgress: ({ videos, authors }) => {
+        console.error(`  #${tag}: ${videos} videos, ${authors} authors`);
+      },
+    });
+
+    result.totalPosts = tagResult.totalPosts || 0;
+    result.authorCount = tagResult.uniqueAuthorCount || 0;
+
+    if (!tagResult.videos || tagResult.videos.length === 0) {
+      result.status = "dead";
+      result.error = "no videos found";
+      store.reportTagScore(tag, {
+        status: "dead",
+        error: "no videos found",
+      });
+      return result;
+    }
+
+    let videos = tagResult.videos;
+    let uniqueAuthors = tagResult.uniqueAuthors || [];
+
+    // Step 2: enrich 国家信息
+    console.error(`  Enriching locations for ${videos.length} videos...`);
+    const enriched = await enrichVideosWithLocation(videos, {
+      mode: "users",
+      onProgress: ({ done, total, current, locationCreated }) => {
+        if (done % 10 === 0) {
+          console.error(
+            `  [${done}/${total}] @${current} → ${locationCreated || "-"}`,
+          );
+        }
+      },
+    });
+    videos = enriched.videos;
+
+    // Step 3: 按目标国家过滤
+    const filtered = videos.filter((v) =>
+      isLocationInList(v.locationCreated, targetCountries),
+    );
+    const matchedAuthorSet = new Set(
+      filtered.map((v) => v.authorUniqueId).filter(Boolean),
+    );
+    result.matchedAuthors = matchedAuthorSet.size;
+
+    // 按国家统计
+    const countryStats = {};
+    for (const v of filtered) {
+      if (v.locationCreated) {
+        countryStats[v.locationCreated] =
+          (countryStats[v.locationCreated] || 0) + 1;
+      }
+    }
+    result.matchedCountries = Object.entries(countryStats).map(([c, n]) => ({
+      c,
+      n,
+    }));
+
+    console.error(
+      `  Filtered: ${videos.length} → ${filtered.length} videos, ${result.matchedAuthors} authors`,
+    );
+
+    // Step 4: 计算分数
+    const densityScore =
+      result.authorCount > 0
+        ? (result.matchedAuthors / result.authorCount) * 50
+        : 0;
+    const absoluteScore = Math.min(result.matchedAuthors / 10, 1) * 30;
+    const videoBonus =
+      filtered.length > 0 ? Math.min(filtered.length / 20, 1) * 20 : 0;
+    result.score = Math.round(
+      Math.min(densityScore + absoluteScore + videoBonus, 100),
+    );
+
+    // 判定状态
+    if (result.score >= 70) result.status = "productive";
+    else if (result.score >= 50) result.status = "scored";
+    else if (result.score < 10) result.status = "dead";
+    else result.status = "scored";
+
+    // Step 5: 推送用户到服务端
+    if (serverUrl && result.matchedAuthors > 0) {
+      const users = [...matchedAuthorSet].map((author) => {
+        const video = filtered.find((v) => v.authorUniqueId === author);
+        return {
+          uniqueId: author,
+          sources: ["tag"],
+          locationCreated: video?.locationCreated || null,
+        };
+      });
+
+      try {
+        const { fetch } = await import("undici");
+        const res = await fetch(`${serverUrl}/api/raw-users`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ users }),
+        });
+        const data = await res.json();
+        result.pushedUsers = data.added || 0;
+        console.error(
+          `  Pushed ${result.pushedUsers} users to ${serverUrl}/api/raw-users`,
+        );
+      } catch (e) {
+        console.error(`  [tag-service] Push users failed: ${e.message}`);
+      }
+    }
+
+    // Step 6: 更新数据库
+    store.reportTagScore(tag, {
+      score: result.score,
+      status: result.status,
+      totalPosts: result.totalPosts,
+      authorCount: result.authorCount,
+      matchedAuthors: result.matchedAuthors,
+      matchedCountries: result.matchedCountries,
+      pushedUsers: result.pushedUsers,
+    });
+
+    console.error(
+      `  #${tag} scored: ${result.score} (${result.status}), ${result.matchedAuthors} matched authors`,
+    );
+  } catch (e) {
+    result.status = "error";
+    result.error = e.message;
+    store.reportTagScore(tag, { status: "error", error: e.message });
+    console.error(`  #${tag} score error: ${e.message}`);
+  }
+
+  return result;
+}