@lightcone-ai/daemon 0.15.52 → 0.15.54

package/mcp-servers/official/keyword-research/index.js

@@ -1,331 +1,24 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs';
+// Thin-proxy. Real impl on lightcone server.
+// Source of truth: src/mcp-services/keyword-research.js
 import { z } from 'zod';
-import { startFixtureServer } from '../../official-common/server.js';
+import { startThinProxy } from '../../_thin-proxy/forward.js';
 
-const KEYWORD_FIXTURES = loadKeywordFixtures();
-const FIXTURE_META = KEYWORD_FIXTURES.fixtureMeta;
-const PLATFORM_ALIAS = KEYWORD_FIXTURES.platformAliases;
-const PLATFORM_HINTS = KEYWORD_FIXTURES.platformHints;
-const INTENT_BRANCHES = KEYWORD_FIXTURES.intentBranches;
-
-function isPlainObject(value) {
-  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-
-function deepFreeze(value) {
-  if (!value || typeof value !== 'object') return value;
-  if (Object.isFrozen(value)) return value;
-  if (Array.isArray(value)) {
-    value.forEach(item => deepFreeze(item));
-    return Object.freeze(value);
-  }
-  for (const key of Object.keys(value)) {
-    deepFreeze(value[key]);
-  }
-  return Object.freeze(value);
-}
-
-function toToken(value) {
-  return String(value ?? '').trim();
-}
-
-function normalizeAliasMap(rawAliases) {
-  if (!isPlainObject(rawAliases)) return { all: 'all' };
-  const aliases = {};
-  for (const [key, value] of Object.entries(rawAliases)) {
-    const alias = toToken(key).toLowerCase();
-    const target = toToken(value).toLowerCase();
-    if (!alias || !target) continue;
-    aliases[alias] = target;
-  }
-  if (!Object.hasOwn(aliases, 'all')) aliases.all = 'all';
-  return aliases;
-}
-
-function normalizePlatformHints(rawHints) {
-  if (!isPlainObject(rawHints)) return { all: [] };
-  const hints = {};
-  for (const [key, value] of Object.entries(rawHints)) {
-    const platform = toToken(key).toLowerCase();
-    if (!platform || !Array.isArray(value)) continue;
-    hints[platform] = value.map(item => toToken(item)).filter(Boolean);
-  }
-  if (!Array.isArray(hints.all)) hints.all = [];
-  return hints;
-}
-
-function normalizeIntentBranches(rawBranches) {
-  if (!Array.isArray(rawBranches)) return [];
-  return rawBranches
-    .map((branch) => {
-      if (!isPlainObject(branch)) return null;
-      const id = toToken(branch.id);
-      const suffix = toToken(branch.suffix);
-      const weight = Number(branch.weight);
-      const childTemplates = Array.isArray(branch.child_templates)
-        ? branch.child_templates.map(item => toToken(item)).filter(Boolean)
-        : [];
-      if (!id || !suffix || !Number.isFinite(weight) || childTemplates.length === 0) return null;
-      return {
-        id,
-        suffix,
-        weight,
-        child_templates: childTemplates,
-      };
-    })
-    .filter(Boolean);
-}
-
-function loadKeywordFixtures() {
-  let parsed = null;
-  try {
-    parsed = JSON.parse(
-      readFileSync(new URL('./keyword-fixtures.json', import.meta.url), 'utf8')
-    );
-  } catch (error) {
-    throw new Error(`keyword_fixture_load_failed:${error.message}`);
-  }
-  if (!isPlainObject(parsed)) {
-    throw new Error('keyword_fixture_invalid:root_object_required');
-  }
-  const intentBranches = normalizeIntentBranches(parsed.intent_branches);
-  if (intentBranches.length === 0) {
-    throw new Error('keyword_fixture_invalid:intent_branches_required');
-  }
-  return deepFreeze({
-    fixtureMeta: isPlainObject(parsed.fixture_meta) ? parsed.fixture_meta : {},
-    platformAliases: normalizeAliasMap(parsed.platform_aliases),
-    platformHints: normalizePlatformHints(parsed.platform_hints),
-    intentBranches,
-  });
-}
-
-function normalizePlatform(value) {
-  const raw = String(value ?? '').trim().toLowerCase();
-  if (!raw) return 'all';
-  return PLATFORM_ALIAS[raw] ?? raw;
-}
-
-function clampInt(value, min, max, fallback) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return fallback;
-  return Math.max(min, Math.min(max, Math.trunc(n)));
-}
-
-function deterministicRatio(seed, salt) {
-  const text = `${seed}#${salt}`;
-  let hash = 2166136261;
-  for (let i = 0; i < text.length; i += 1) {
-    hash ^= text.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0) / 4294967295;
-}
-
-function computeMetrics({ keyword, seedKeyword, depth, intentWeight }) {
-  const base = deterministicRatio(keyword, seedKeyword);
-  const searchVolume = Math.round((2200 + base * 8200) * (1 - depth * 0.18) * intentWeight);
-  const competitionRaw = 0.28 + deterministicRatio(seedKeyword, keyword) * 0.58 + depth * 0.06;
-  const competition = Math.max(0.1, Math.min(0.95, Number(competitionRaw.toFixed(2))));
-  const relevanceRaw = 0.62 + deterministicRatio(`${seedKeyword}:${keyword}`, depth) * 0.33 - depth * 0.05;
-  const relevance = Math.max(0.4, Math.min(1, Number(relevanceRaw.toFixed(2))));
-
-  return {
-    search_volume: Math.max(120, searchVolume),
-    competition,
-    relevance,
-  };
-}
-
-function computePriority(metrics) {
-  const volumeScore = Math.min(100, 20 + metrics.search_volume / 120);
-  const competitionScore = (1 - metrics.competition) * 100;
-  const relevanceScore = metrics.relevance * 100;
-  const score = Math.round(volumeScore * 0.45 + competitionScore * 0.35 + relevanceScore * 0.2);
-
-  let tier = 'P4';
-  if (score >= 82) tier = 'P1';
-  else if (score >= 68) tier = 'P2';
-  else if (score >= 55) tier = 'P3';
-
-  return { score, tier };
-}
-
-function buildNode({ keyword, seedKeyword, depth, intent, intentWeight }) {
-  const metrics = computeMetrics({ keyword, seedKeyword, depth, intentWeight });
-  const priority = computePriority(metrics);
-  return {
-    keyword,
-    depth,
-    intent,
-    metrics,
-    priority_score: priority.score,
-    priority_tier: priority.tier,
-    children: [],
-  };
-}
-
-function renderTemplate(template, seedKeyword) {
-  return String(template ?? '').replaceAll('{seed}', seedKeyword);
-}
-
-function uniqueKeywords(items) {
-  const seen = new Set();
-  const output = [];
-  for (const item of items) {
-    const key = String(item ?? '').trim();
-    if (!key || seen.has(key)) continue;
-    seen.add(key);
-    output.push(key);
-  }
-  return output;
-}
-
-function flattenTree(root) {
-  const output = [];
-  const stack = [root];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    output.push(current);
-    for (let i = current.children.length - 1; i >= 0; i -= 1) {
-      stack.push(current.children[i]);
-    }
-  }
-  return output;
-}
-
-function buildKeywordTree({ seedKeyword, platform, maxDepth, branchLimit }) {
-  const normalizedSeed = String(seedKeyword).trim();
-  const hints = PLATFORM_HINTS[platform] ?? PLATFORM_HINTS.all;
-
-  const root = buildNode({
-    keyword: normalizedSeed,
-    seedKeyword: normalizedSeed,
-    depth: 0,
-    intent: 'seed',
-    intentWeight: 1.04,
-  });
-
-  if (maxDepth < 1) return root;
-
-  const selectedBranches = INTENT_BRANCHES.slice(0, branchLimit);
-
-  for (const branch of selectedBranches) {
-    const branchKeyword = `${normalizedSeed} ${branch.suffix}`;
-    const branchNode = buildNode({
-      keyword: branchKeyword,
-      seedKeyword: normalizedSeed,
-      depth: 1,
-      intent: branch.id,
-      intentWeight: branch.weight,
-    });
-
-    if (maxDepth >= 2) {
-      const baseChildren = branch.child_templates.map((template) => renderTemplate(template, normalizedSeed));
-      const hintChildren = hints.map((hint) => `${normalizedSeed} ${hint}`);
-      const childKeywords = uniqueKeywords([...baseChildren, ...hintChildren]).slice(0, 3);
-
-      for (const childKeyword of childKeywords) {
-        branchNode.children.push(buildNode({
-          keyword: childKeyword,
-          seedKeyword: normalizedSeed,
-          depth: 2,
-          intent: `${branch.id}_longtail`,
-          intentWeight: Math.max(0.65, branch.weight - 0.1),
-        }));
-      }
-    }
-
-    root.children.push(branchNode);
-  }
-
-  return root;
-}
-
-await startFixtureServer({
+await startThinProxy({
   serverId: 'keyword-research',
   serverName: 'official-keyword-research',
-  toolName: 'keyword_research',
-  toolDescription: 'Generate fixture-mode keyword tree with priority ranking using seed keyword and platform context.',
-  inputSchema: {
-    seed_keyword: z.string().min(1).describe('Seed keyword/topic, e.g. \"\u5c0f\u7ea2\u4e66\u8d77\u53f7\".'),
-    platform: z.enum(['all', 'xhs', 'douyin', 'wechat-mp']).optional()
-      .describe('Optional platform hint for long-tail expansion.'),
-    locale: z.string().optional().describe('Locale hint, default zh-CN.'),
-    max_depth: z.number().int().min(1).max(2).optional()
-      .describe('Tree depth, default 2.'),
-    branch_limit: z.number().int().min(2).max(5).optional()
-      .describe('Max first-level branches, default 4.'),
-    top_k: z.number().int().min(3).max(30).optional()
-      .describe('Top K keywords in priority ranking, default 12.'),
-  },
-  handler: ({
-    seed_keyword,
-    platform = 'all',
-    locale = 'zh-CN',
-    max_depth = 2,
-    branch_limit = 4,
-    top_k = 12,
-  }) => {
-    const seedKeyword = String(seed_keyword ?? '').trim();
-    if (!seedKeyword) throw new Error('seed_keyword_required');
-
-    const normalizedPlatform = normalizePlatform(platform);
-    const normalizedLocale = String(locale ?? 'zh-CN').trim() || 'zh-CN';
-    const safeDepth = clampInt(max_depth, 1, 2, 2);
-    const safeBranchLimit = clampInt(branch_limit, 2, 5, 4);
-    const safeTopK = clampInt(top_k, 3, 30, 12);
-
-    const keywordTree = buildKeywordTree({
-      seedKeyword,
-      platform: normalizedPlatform,
-      maxDepth: safeDepth,
-      branchLimit: safeBranchLimit,
-    });
-
-    const flatNodes = flattenTree(keywordTree);
-    const ranked = flatNodes
-      .map((node) => ({
-        keyword: node.keyword,
-        depth: node.depth,
-        intent: node.intent,
-        priority_score: node.priority_score,
-        priority_tier: node.priority_tier,
-        search_volume: node.metrics.search_volume,
-        competition: node.metrics.competition,
-        relevance: node.metrics.relevance,
-      }))
-      .sort((a, b) => {
-        if (b.priority_score !== a.priority_score) return b.priority_score - a.priority_score;
-        if (b.search_volume !== a.search_volume) return b.search_volume - a.search_volume;
-        return a.keyword.localeCompare(b.keyword, 'zh-Hans-CN');
-      });
-
-    const priorityRanking = ranked.slice(0, safeTopK);
-
-    return {
-      ...FIXTURE_META,
-      seed_keyword: seedKeyword,
-      platform: normalizedPlatform,
-      locale: normalizedLocale,
-      priority_model: {
-        score_formula: '0.45*volume + 0.35*(1-competition) + 0.20*relevance',
-        tiers: {
-          P1: 'score >= 82',
-          P2: '68-81',
-          P3: '55-67',
-          P4: '< 55',
-        },
+  tools: [
+    {
+      name: 'keyword_research',
+      description: 'Generate fixture-mode keyword tree with priority ranking using seed keyword and platform context.',
+      inputSchema: {
+        seed_keyword: z.string().min(1),
+        platform: z.enum(['all', 'xhs', 'douyin', 'wechat-mp']).optional(),
+        locale: z.string().optional(),
+        max_depth: z.number().int().min(1).max(2).optional(),
+        branch_limit: z.number().int().min(2).max(5).optional(),
+        top_k: z.number().int().min(3).max(30).optional(),
       },
-      node_count: ranked.length,
-      keyword_tree: keywordTree,
-      priority_ranking: priorityRanking,
-      related_keywords: priorityRanking
-        .map((item) => item.keyword)
-        .filter((item) => item !== seedKeyword)
-        .slice(0, 12),
-      generated_at: new Date().toISOString(),
-    };
-  },
+    },
+  ],
 });

package/mcp-servers/official/page-understanding/index.js

@@ -1,41 +1,8 @@
 #!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+// Thin-proxy. Real impl on lightcone server.
+// Source of truth: src/mcp-services/page-understanding.js (wraps src/video/understanding/).
 import { z } from 'zod';
-
-import {
-  analyzePage,
-  analyzePageFromHtmlFixture,
-  validatePageUnderstanding,
-} from '../../../src/_vendor/video/understanding/index.js';
-import {
-  findToolBlockRule,
-  loadToolBlockRulesFromManifest,
-} from '../../official-common/tool-access-policy.js';
-
-const TOOL_BLOCK_RULES = loadToolBlockRulesFromManifest(new URL('./manifest.json', import.meta.url));
-
-function resolveAnalyzePageBlockMessage(env = process.env) {
-  const matchedRule = findToolBlockRule(TOOL_BLOCK_RULES, {
-    toolName: 'analyze_page',
-    workspaceId: env?.WORKSPACE_ID,
-    agentId: env?.AGENT_ID,
-  });
-  return matchedRule?.message ?? null;
-}
-
-function toText(payload) {
-  return {
-    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
-  };
-}
-
-function toError(message) {
-  return {
-    isError: true,
-    content: [{ type: 'text', text: `Error: ${message}` }],
-  };
-}
+import { startThinProxy } from '../../_thin-proxy/forward.js';
 
 const AnalyzePageOptionsSchema = z.object({
   settleMs: z.number().int().min(500).max(30000).optional(),
@@ -49,64 +16,18 @@ const AnalyzePageOptionsSchema = z.object({
   fixture_mode: z.boolean().optional(),
 }).passthrough();
 
-const server = new McpServer({
-  name: 'official-page-understanding',
-  version: '0.1.0',
+await startThinProxy({
+  serverId: 'page-understanding',
+  serverName: 'official-page-understanding',
+  tools: [
+    {
+      name: 'analyze_page',
+      description: 'Analyze webpage structure for short-video narration planning. Returns page_understanding schema.',
+      inputSchema: {
+        url: z.string().url(),
+        persona: z.string().optional(),
+        options: AnalyzePageOptionsSchema.optional(),
+      },
+    },
+  ],
 });
-
-server.tool(
-  'analyze_page',
-  'Analyze webpage structure for short-video narration planning. Returns page_understanding schema.',
-  {
-    url: z.string().url().describe('Target page URL.'),
-    persona: z.string().optional().describe('Audience persona, e.g. "校招求职学生".'),
-    options: AnalyzePageOptionsSchema.optional(),
-  },
-  async ({ url, persona = '', options = {} }) => {
-    try {
-      const blockedMessage = resolveAnalyzePageBlockMessage();
-      if (blockedMessage) {
-        return toError(blockedMessage);
-      }
-      let payload;
-      if (options?.fixture_mode) {
-        payload = await analyzePageFromHtmlFixture({
-          url,
-          hostname: new URL(url).hostname,
-          persona,
-          bins: [
-            { y_center: 380, text: '这是一个用于 smoke test 的结构化 bin 内容。' },
-            { y_center: 980, text: '该页面包含若干重点段落，用于验证 schema 输出。' },
-          ],
-          hotspots: [
-            { y: 420, reason: '标题区域', weight: 9, type: 'h1' },
-            { y: 1100, reason: '正文重点', weight: 8, type: 'h2' },
-          ],
-          meta: {
-            title: 'Fixture Page',
-            og_title: 'Fixture Page',
-            og_description: 'Fixture mode output for analyze_page smoke test.',
-          },
-        });
-      } else {
-        payload = await analyzePage({
-          url,
-          persona,
-          options,
-        });
-      }
-
-      const validation = validatePageUnderstanding(payload);
-      if (!validation.ok) {
-        return toError(`page_understanding_validation_failed: ${validation.errors.join('; ')}`);
-      }
-      return toText(payload);
-    } catch (error) {
-      return toError(error?.message ?? 'analyze_page_failed');
-    }
-  }
-);
-
-const transport = new StdioServerTransport();
-await server.connect(transport);
-console.error('[page-understanding] MCP Server started');