tt-help-cli-ycl 1.4.3 → 1.4.4

package/src/lib/tag-discover.js

@@ -3,6 +3,7 @@
  *
  * 使用 tag-service 的公共函数（LLM 调用、prompt 组装、解析）。
  * 历史 tag 数据通过 API 从服务端获取，不再读写 productive-tags.json。
+ * 自闭环：从服务端获取健康数据 → 自动 niche 切换 → 动态温度调整
  */
 import {
   COUNTRY_LANG,
@@ -10,7 +11,9 @@ import {
   callLLM,
   normalizeTag,
   parseTagsFromResponse,
+  parseDiscoverResponse,
   buildDiscoverPrompt,
+  reflectAndLearn,
 } from "../watch/tag-service.js";
 
 const DEFAULT_SERVER = "http://127.0.0.1:3000";
@@ -52,7 +55,87 @@ async function fetchTagHistory(serverUrl, country) {
 }
 
 /**
- * 为单个国家生成 tag（CLI 模式，通过 API 获取历史数据）
+ * 从服务端获取某国的 tag 健康指标
+ */
+async function fetchCountryHealth(serverUrl, country) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/health?country=${country}`);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 从服务端触发数据清理（自闭环）
+ */
+async function triggerCleanup(serverUrl, actions = {}) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/cleanup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(actions),
+    });
+    if (!res.ok) return {};
+    return await res.json();
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * 从服务端获取某国的活跃反思规则
+ */
+async function fetchActiveRules(serverUrl, country) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/rules?country=${country}`);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.rules || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 从服务端触发反思（自闭环）
+ */
+async function triggerReflection(serverUrl, country) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(`${baseUrl}/api/tags/reflect?country=${country}`, {
+      method: "POST",
+    });
+    if (!res.ok) return { reflected: false, error: `HTTP ${res.status}` };
+    return await res.json();
+  } catch (e) {
+    return { reflected: false, error: e.message };
+  }
+}
+
+/**
+ * 从服务端获取最近生成的标签（去重）
+ */
+async function fetchRecentGenerated(serverUrl, country, lookback = 10) {
+  const baseUrl = serverUrl || DEFAULT_SERVER;
+  try {
+    const res = await fetch(
+      `${baseUrl}/api/tags/recent-generated?country=${country}&lookback=${lookback}`,
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.tags || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 为单个国家生成 tag（CLI 模式，通过 API 获取历史数据 + 自闭环）
  */
 async function discoverTagsForCountryCli(
   country,
@@ -64,24 +147,112 @@ async function discoverTagsForCountryCli(
     return { country, error: `不支持的国家代码: ${country}` };
   }
 
+  // ====== 自闭环 Step 1: 获取健康数据 ======
+  const health = await fetchCountryHealth(serverUrl, country);
+  let nicheRecommendation = null;
+  let autoNichePrompt = null;
+  let temperature = 0.7;
+
+  if (health) {
+    process.stderr.write(
+      `  🏥 ${country} health: ${health.healthStatus} | deadRatio=${health.deadRatio}% | productiveRatio=${health.productiveRatio}% | saturation=${health.saturation}%\n`,
+    );
+
+    // 动态温度调整
+    if (health.healthStatus === "critical") {
+      temperature = 0.3;
+    } else if (health.healthStatus === "warning") {
+      temperature = 0.5;
+    }
+
+    // 自动 niche 切换
+    nicheRecommendation = health.nicheRecommendation;
+    if (
+      health.healthStatus !== "healthy" &&
+      nicheRecommendation &&
+      nicheRecommendation.uncovered &&
+      nicheRecommendation.uncovered.length > 0
+    ) {
+      const targetNiche = nicheRecommendation.uncovered[0];
+      const nicheDescriptions = {
+        fashion:
+          "clothing, shoes, accessories, vintage fashion, secondhand clothes",
+        food: "bakery, food delivery, local food, restaurant, cooking supplies",
+        handmade_crafts:
+          "handmade items, DIY crafts, ceramics, candles, resin art",
+        home_living:
+          "home decoration, furniture, interior design, cleaning services",
+        electronics_tech:
+          "electronics, gadgets, phones, computers, tech accessories",
+        pets_animals: "pet supplies, dog accessories, cat food, animal care",
+        beauty_health:
+          "beauty products, cosmetics, skincare, hair care, wellness",
+        books_collectibles:
+          "books, collectibles, vinyl records, trading cards, antiques",
+        services_professional:
+          "professional services, repair, cleaning, photography, florist",
+        marketplace_local:
+          "local market, marketplace, shop, boutique, online store",
+      };
+      autoNichePrompt = `Focus on the "${targetNiche.niche}" niche: ${nicheDescriptions[targetNiche.niche] || targetNiche.niche}. We have only ${targetNiche.currentCoverage} productive tags in this category — explore more hashtags in this direction.`;
+      process.stderr.write(
+        `  🎯 ${country} auto niche switch → ${targetNiche.niche} (coverage: ${targetNiche.currentCoverage})\n`,
+      );
+    }
+
+    // 触发服务端数据清理
+    const cleanupActions = {};
+    if (health.lowScored > health.productive * 2) {
+      cleanupActions.lowScoredCleanup = true;
+    }
+    cleanupActions.staleScoringReset = true;
+    cleanupActions.errorReset = true;
+
+    const cleanupResult = await triggerCleanup(serverUrl, cleanupActions);
+    if (cleanupResult && Object.keys(cleanupResult).length > 0) {
+      process.stderr.write(`  🧹 Cleanup: ${JSON.stringify(cleanupResult)}\n`);
+    }
+  }
+
+  // 合并用户 prompt 和自动 niche prompt
+  const effectiveUserPrompt = autoNichePrompt || userPrompt;
+
+  // ====== 原有 discover 流程 ======
   // 从服务端获取历史 tag
   const history = await fetchTagHistory(serverUrl, country);
   const { productive, dead, allExisting: existingSet } = history;
   const existingArr = Array.isArray(existingSet) ? existingSet : [];
 
-  // 使用统一的 prompt 组装（不传 allExisting，由应用层去重）
+  // 获取最近生成的标签（用于检测重复）
+  const recentGenerated = await fetchRecentGenerated(serverUrl, country);
+
+  // ====== 自闭环 Step 4: 获取硬规则（反思产出） ======
+  const hardRules = await fetchActiveRules(serverUrl, country);
+  if (hardRules.length > 0) {
+    process.stderr.write(
+      `  ⛔ ${country} 注入 ${hardRules.length} 条硬规则到 prompt\n`,
+    );
+  }
+
+  // 使用统一的 prompt 组装（加入健康指标、niche 推荐、硬规则）
   const prompt = buildDiscoverPrompt(
     country,
     count,
-    { productive, dead },
-    userPrompt,
+    { productive, dead, recentGenerated },
+    effectiveUserPrompt,
+    null, // pastStrategies（CLI 模式暂不传）
+    health,
+    nicheRecommendation,
+    hardRules,
   );
 
   process.stderr.write(
-    `  [LLM] 正在生成标签 (国家: ${country}, 语言: ${getLang(country)}, 目标: ${count} 个)...\n`,
+    `  [LLM] 正在生成标签 (国家: ${country}, 语言: ${getLang(country)}, 目标: ${count} 个, temp=${temperature}, health=${health?.healthStatus || "unknown"})...\n`,
   );
-  const content = await callLLM(prompt);
-  const tags = parseTagsFromResponse(content);
+  const content = await callLLM(prompt, temperature);
+  const parsed = parseDiscoverResponse(content);
+  const tags = parsed.tags || parseTagsFromResponse(content);
+  const niche = parsed.niche || null;
   // 两阶段筛选：先内部去重，再过滤已存在，最后取 count 个
   const unique = [...new Set(tags)]
     .filter((t) => !existingArr.includes(t))
@@ -90,7 +261,42 @@ async function discoverTagsForCountryCli(
   process.stderr.write(
     `  [LLM] 生成 ${unique.length} 个标签: ${unique.join(", ")}\n`,
   );
-  return unique;
+  if (niche) {
+    process.stderr.write(`  [LLM] niche focus: ${niche}\n`);
+  }
+
+  // ====== 自闭环 Step 5: 反思触发（本轮结束后检查） ======
+  let reflectionResult = null;
+  try {
+    reflectionResult = await triggerReflection(serverUrl, country);
+    if (reflectionResult.reflected) {
+      process.stderr.write(
+        `  🔄 ${country} 反思完成: 新增 ${reflectionResult.rulesAdded} 条规则\n`,
+      );
+    }
+  } catch (e) {
+    process.stderr.write(`  反思异常: ${e.message}\n`);
+    reflectionResult = { reflected: false, error: e.message };
+  }
+
+  return {
+    country,
+    tags: unique,
+    niche,
+    health: health
+      ? {
+          status: health.healthStatus,
+          deadRatio: health.deadRatio,
+          productiveRatio: health.productiveRatio,
+          saturation: health.saturation,
+          issues: health.issues || [],
+        }
+      : null,
+    autoNiche: autoNichePrompt ? nicheRecommendation.uncovered[0].niche : null,
+    temperature,
+    hardRulesInjected: hardRules.length,
+    reflection: reflectionResult,
+  };
 }
 
 /**
@@ -108,13 +314,15 @@ export async function discoverTags(countries, options = {}) {
   const allTags = [];
 
   for (const country of countryList) {
-    const tags = await discoverTagsForCountryCli(
+    const result = await discoverTagsForCountryCli(
       country,
       count,
       userPrompt,
       serverUrl,
     );
-    allTags.push(...tags);
+    if (result.tags) {
+      allTags.push(...result.tags);
+    }
   }
 
   return allTags;

package/src/watch/data-store.js

@@ -3203,6 +3203,7 @@ export function createStore(filePath, options = {}) {
     trackClient,
     getActiveClients,
     moveSellerJobsToBase, // 将 jobs/raw_jobs 中 tt_seller=1 且 video_count=0 的记录移动到 jobs_base
+    moveRestrictedJobsToBase, // 将 jobs 中 status='restricted' 的记录移动到 jobs_base
     registerVideos,
     getVideo,
     getVideos,
@@ -3354,4 +3355,45 @@ export function createStore(filePath, options = {}) {
       availableInBase: available,
     };
   }
+
+  function moveRestrictedJobsToBase() {
+    const db = getDb();
+    if (!db) return { ok: false, error: "db not ready" };
+
+    const now = Date.now();
+    const countRow = db
+      .prepare("SELECT COUNT(*) as c FROM jobs WHERE status = 'restricted'")
+      .get();
+    if (!countRow?.c) return { ok: true, moved: 0 };
+
+    db.prepare(
+      `
+      INSERT OR REPLACE INTO jobs_base (
+        unique_id, nickname, sources, pinned, no_video, user_update_count,
+        tt_seller, verified, video_count, comment_count, guessed_location,
+        location_created, follower_count, following_count, heart_count,
+        refresh_time, region, signature, sec_uid, status_code,
+        latest_video_time, bio_link, status, restricted, error, claimed_by,
+        claimed_at, processed, processed_at, created_at, updated_at
+      )
+      SELECT
+        unique_id, nickname, sources, pinned, no_video, 0,
+        CASE WHEN tt_seller = 0 THEN NULL ELSE tt_seller END,
+        verified, video_count, comment_count, guessed_location,
+        location_created, follower_count, following_count, heart_count,
+        refresh_time, region, signature, sec_uid, status_code,
+        latest_video_time, bio_link,
+        'pending', 0, NULL, NULL, NULL, 0, NULL,
+        COALESCE(created_at, ?), ?
+      FROM jobs WHERE status = 'restricted'
+    `,
+    ).run(now, now);
+
+    const deleted = db
+      .prepare("DELETE FROM jobs WHERE status = 'restricted'")
+      .run();
+
+    markStatsDirty();
+    return { ok: true, moved: deleted.changes || 0 };
+  }
 }

package/src/watch/db-schema.js

@@ -297,6 +297,24 @@ export function initDb(filePath) {
     )
   `);
 
+  // ===== reflection_rules 表（反思闭环：LLM 自我学习规则） =====
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS reflection_rules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      country TEXT NOT NULL,
+      rule_type TEXT NOT NULL DEFAULT 'hard',
+      rule_text TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'reflection',
+      trigger_reason TEXT,
+      productive_sample TEXT,
+      dead_sample TEXT,
+      analysis_summary TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      superseded_at TEXT,
+      is_active INTEGER NOT NULL DEFAULT 1
+    )
+  `);
+
   // ===== 索引 =====
   const indexes = [
     `CREATE INDEX IF NOT EXISTS idx_jobs_status_video ON jobs(status, video_count DESC)`,
@@ -315,6 +333,7 @@ export function initDb(filePath) {
     `CREATE INDEX IF NOT EXISTS idx_tags_status ON tags(status)`,
     `CREATE INDEX IF NOT EXISTS idx_tags_score ON tags(score DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_discover_log_country ON discover_log(country, round DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_reflection_rules_active ON reflection_rules(country, is_active)`,
   ];
   for (const sql of indexes) {
     db.exec(sql);