dsh-pick 0.0.0-stage → 0.2.0

package/lib/classify.js

@@ -0,0 +1,56 @@
+// lib/classify.js — DSH 插件分类
+//
+// 三级判定：关键词命中（权重 3） > 包名命中（2） > 描述命中（1）。
+// 得分低于阈值归「其他」。
+// 这套规则是兜底；P2 会由宿主端批量跑语义分类覆盖（准确率 65% → 90%+）。
+
+export const CATEGORIES = [
+  { label: '界面与主题',      keys: ['web-ui', 'theme', 'skin', 'ui', 'sidebar', 'wallpaper', 'appearance', 'visual', 'font', 'layout', 'render', 'css', 'design', 'widget', 'pet', 'dafeiyu', 'screenshot'] },
+  { label: '记忆与上下文',    keys: ['memory', 'context', 'session', 'rewind', 'palimpsest', 'mnemon', 'recall', 'archive', 'compact'] },
+  { label: '模型与网关',      keys: ['model-provider', 'llm-gateway', 'provider', 'llm', 'codex', 'claude-code', 'chatgpt', 'openai', 'model', 'gateway', 'router', 'proxy', 'subscription', 'token'] },
+  { label: '搜索与检索',      keys: ['web-search', 'search', 'retrieval', 'rag', 'find', 'index', 'crawl'] },
+  { label: '用量与计费',      keys: ['cost', 'usage', 'balance', 'quota', 'billing', 'price', 'credit', 'billing'] },
+  { label: '自动化与多智能体', keys: ['automation', 'agent', 'subagent', 'agent-teams', 'agent-preset', 'workflow', 'schedule', 'task', 'orchestr', 'team', 'cron'] },
+  { label: '远程与部署',      keys: ['vps', 'ssh', 'remote', 'deploy', 'tunnel', 'mobile', 'pocket', 'bridge', 'self-hosted', 'server', 'docker', 'home'] },
+  { label: '文档与办公',      keys: ['markdown', 'office', 'univer', 'tiddlywiki', 'doc', 'note', 'pdf', 'excel', 'paper', 'ocr', 'reader', 'write'] },
+  { label: '媒体与生成',      keys: ['image', 'vision', 'voice', 'video', 'audio', 'generation', 'tts', 'live', 'camera', 'draw', 'music'] },
+  { label: '集成与连接',      keys: ['mcp', 'im', 'feishu', 'wechat', 'wecom', 'github', 'connector', 'telegram', 'slack', 'discord', 'messenger', 'bot', 'notify', 'notification', 'message'] },
+  { label: '插件市场与工具链', keys: ['marketplace', 'market', 'plugin-manager', 'plugin-update', 'updates', 'bundle', 'cli', 'plugin-console', 'install', 'shop', 'share'] },
+  { label: '安全与权限',      keys: ['approval', 'gate', 'verify', 'permission', 'safety', 'sandbox', 'auth', 'secret', 'security', 'pentest'] },
+  { label: '代码与开发',      keys: ['git', 'code', 'review', 'test', 'lint', 'refactor', 'build', 'typescript', 'file', 'edit', 'patch', 'diff', 'repo', 'worktree'] },
+]
+
+export const OTHER = '其他'
+
+/**
+ * 分类单个插件
+ * @param {string} name 包名
+ * @param {string[]} kws 关键词
+ * @param {string} desc 描述
+ * @returns {string}
+ */
+export function classify(name, kws = [], desc = '') {
+  const kwLower = new Set(kws.map(k => String(k).toLowerCase()))
+  const text = (name + ' ' + (desc || '')).toLowerCase()
+  const scores = new Map()
+
+  for (const cat of CATEGORIES) {
+    let s = 0
+    for (const k of cat.keys) {
+      if (kwLower.has(k)) s += 3
+      if (text.includes(k)) s += 1
+    }
+    if (s > 0) scores.set(cat.label, s)
+  }
+
+  if (scores.size === 0) return OTHER
+  let best = null, bestScore = 0
+  for (const [label, s] of scores) {
+    if (s > bestScore) { best = label; bestScore = s }
+  }
+  return bestScore >= 2 ? best : OTHER
+}
+
+export function allCategories() {
+  return CATEGORIES.map(c => c.label).concat([OTHER])
+}

package/lib/engine.js

@@ -0,0 +1,409 @@
+// lib/engine.js — dsh-pick 数据引擎
+//
+// 一个引擎，三个入口（设置页面板 / `/pick-` 命令 / AI 工具）都走这里。
+//
+// 目录构建在宿主端（Node）跑，没有 CORS、可以并发，所以能全量抓；
+// 页面只读 catalog.json，秒开。
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { classify } from './classify.js'
+import { expandWords } from './words.js'
+import { baselineWithStart, growth, cadence, ageDays, score, sum } from './metrics.js'
+
+const PKG_ROOT = fileURLToPath(new URL('..', import.meta.url))
+export const CATALOG_PATH = join(PKG_ROOT, 'data', 'catalog.json')
+
+const SEARCH_API = 'https://registry.npmjs.org/-/v1/search'
+const DL_API = 'https://api.npmjs.org/downloads'
+const REG_API = 'https://registry.npmjs.org'
+
+/* ---------------------------------------------------------------- 网络 */
+
+async function jget(url, tries = 4) {
+  for (let i = 0; i < tries; i++) {
+    try {
+      const r = await fetch(url, { headers: { accept: 'application/json' } })
+      if (r.status === 429 || r.status === 503) {
+        await sleep(800 * (i + 1))
+        continue
+      }
+      if (!r.ok) return null
+      return await r.json()
+    } catch {
+      await sleep(400 * (i + 1))
+    }
+  }
+  return null
+}
+
+const sleep = ms => new Promise(r => setTimeout(r, ms))
+
+const enc = s => String(s).replace(/\//g, '%2f')
+
+async function pool(items, limit, fn) {
+  const out = new Array(items.length)
+  let idx = 0
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (idx < items.length) {
+      const i = idx++
+      out[i] = await fn(items[i], i)
+    }
+  }))
+  return out
+}
+
+const shiftDate = (iso, d) => {
+  const t = new Date(iso + 'T00:00:00Z')
+  t.setUTCDate(t.getUTCDate() + d)
+  return t.toISOString().slice(0, 10)
+}
+
+/** npm 统计滞后约 5 天，先探测最后一个已汇总的完整日 */
+async function resolveAnchor() {
+  const probe = await jget(`${DL_API}/point/last-day/dsh-market`)
+  return (probe && probe.end) || shiftDate(new Date().toISOString().slice(0, 10), -5)
+}
+
+/* ---------------------------------------------------------------- 目录构建 */
+
+/**
+ * 抓取 DSH 插件目录
+ * @param {object} opt
+ * @param {number} opt.deep 对周下载 Top N 抓日序列 + 发布历史，算出噪指标
+ * @param {number} opt.max 最多抓多少个包（search 深分页上限约 2250）
+ * @param {boolean} opt.deepOnly 只补算去噪指标，不重新抓目录（省 5 分钟）
+ * @param {(msg:string)=>void} opt.onProgress 进度回调
+ */
+export async function buildCatalog({ deep = 200, max = 2250, pages = 9, deepOnly = false, onProgress = () => {} } = {}) {
+  const today = new Date().toISOString().slice(0, 10)
+  const anchor = await resolveAnchor()
+  const start = shiftDate(anchor, -29)
+  onProgress(`统计截止日 ${anchor}，${deepOnly ? '只补算去噪指标' : '开始抓取目录'}…`)
+
+  const records = new Map()
+
+  if (deepOnly) {
+    const prev = await loadCatalog()
+    if (!prev.total) throw new Error('还没有目录，先跑一次不带 --deep-only 的 build')
+    for (const rec of Object.values(prev.packages)) records.set(rec.n, rec)
+    onProgress(`沿用已有目录 ${records.size} 个包`)
+  } else {
+    for (let p = 0; p < pages; p++) {
+      const from = p * 250
+      onProgress(`抓取目录 ${from + 1}–${from + 250} / ${max}…`)
+      const d = await jget(`${SEARCH_API}?text=${encodeURIComponent('keywords:dsh-plugin')}&size=250&from=${from}`)
+      const objs = (d && d.objects) || []
+      for (const o of objs) {
+        const pkg = o.package
+        if (records.has(pkg.name)) continue
+        records.set(pkg.name, {
+          n: pkg.name,
+          v: pkg.version,
+          d: (pkg.description || '').slice(0, 160),
+          kw: pkg.keywords || [],
+          w: (o.downloads && o.downloads.weekly) || 0,
+          m: (o.downloads && o.downloads.monthly) || 0,
+          pub: (pkg.date || '').slice(0, 10),
+          // search API 直接给 links，不额外花请求
+          home: (pkg.links && pkg.links.homepage) || '',
+          repo: (pkg.links && pkg.links.repository) || '',
+        })
+      }
+      if (records.size >= max) break
+      if (objs.length < 250) break
+      await sleep(220)
+    }
+  }
+
+  // 分类：**全部**目录都要有（v1 只给深挖目标分了类，导致其余全是 undefined）
+  for (const rec of records.values()) {
+    rec.cat = classify(rec.n, rec.kw, rec.d)
+  }
+
+  onProgress(`目录 ${records.size} 个包已分类，开始算去噪指标 Top ${deep}…`)
+
+  // 深挖：日序列 + 发布历史 → 日常基线 / 增速 / 版本节奏 / 新鲜度
+  // 注意：api.npmjs.org 并发稍高就开始 429，所以下载量请求必须低并发；
+  //      registry.npmjs.org 宽松得多，可以并发。两段分开抓。
+  // deepOnly 时只补缺失的；全量时按周下载取 Top N
+  const targets = [...records.values()]
+    .filter(r => (deepOnly ? !r.deep : true))
+    .sort((a, b) => b.w - a.w)
+    .slice(0, deep)
+
+  let deepOk = 0
+  let pending = targets.slice()
+
+  // 最多 3 轮：最后一轮降到并发 1，专治偶发 429
+  for (let round = 1; round <= 3 && pending.length; round++) {
+    const conc = round >= 3 ? 1 : 2
+    onProgress(`  日序列 第 ${round} 轮，${pending.length} 个（并发 ${conc}）…`)
+
+    const ranges = await pool(pending, conc, async rec => {
+      const r = await jget(`${DL_API}/range/${start}:${anchor}/${enc(rec.n)}`)
+      await sleep(round >= 3 ? 420 : 180)
+      return (r && Array.isArray(r.downloads)) ? r.downloads.map(x => x.downloads) : null
+    })
+
+    const ok = pending.filter((_, i) => ranges[i])
+
+    if (ok.length) {
+      onProgress(`  发布历史 ${ok.length} 个…`)
+      const metas = await pool(ok, 8, async rec => jget(`${REG_API}/${enc(rec.n)}`))
+      ok.forEach((rec, i) => {
+        const daily = ranges[pending.indexOf(rec)]
+        const meta = metas[i]
+        const releaseDates = (meta && meta.time)
+          ? Object.entries(meta.time)
+              .filter(([k]) => k !== 'created' && k !== 'modified')
+              .map(([, v]) => String(v).slice(0, 10))
+          : []
+
+        const b = baselineWithStart(daily, releaseDates, start)
+        const g = growth(daily)
+        const vd = releaseDates.slice().sort()
+        const lastRelease = vd.length ? vd[vd.length - 1] : rec.pub
+        const age = ageDays(lastRelease, today)
+        const c = cadence(releaseDates)
+
+        rec.deep = {
+          daily,
+          base: b,
+          growth: g,
+          cadence: c,
+          age,
+          lastRelease,
+          versions: releaseDates.length,
+          s: score({ baseline: b, growth: g, age, cadence: c }),
+        }
+        rec.rel = releaseDates
+        deepOk++
+      })
+    }
+
+    pending = pending.filter((_, i) => !ranges[i])
+  }
+
+  const catalog = {
+    tool: 'dsh-pick',
+    asOf: today,
+    anchor,
+    windowStart: start,
+    total: records.size,
+    deepCount: [...records.values()].filter(r => r.deep).length,
+    packages: Object.fromEntries([...records.entries()]),
+  }
+
+  await mkdir(dirname(CATALOG_PATH), { recursive: true })
+  await writeFile(CATALOG_PATH, JSON.stringify(catalog), 'utf8')
+  onProgress(`完成：${records.size} 个包，其中 ${deepOk} 个算出去噪指标 → ${CATALOG_PATH}`)
+  return catalog
+}
+
+/* ---------------------------------------------------------------- 查询 */
+
+let cache = null
+
+export async function loadCatalog() {
+  if (cache) return cache
+  try {
+    cache = normalize(JSON.parse(await readFile(CATALOG_PATH, 'utf8')))
+  } catch {
+    cache = { asOf: null, anchor: null, packages: {}, total: 0 }
+  }
+  return cache
+}
+
+export function reloadCatalog(cat) {
+  cache = normalize(cat)
+}
+
+/**
+ * 归一化：补上 npm 地址、GitHub 地址、总排行、分类排行
+ * 排名字段不落盘，加载时算一次（2,250 个包一次排序，毫秒级），
+ * 这样 catalog.json 重建与否都不影响排名显示。
+ */
+export function normalize(cat) {
+  if (!cat || !cat.packages) return cat
+  const all = Object.values(cat.packages).filter(r => r && r.n)
+  const byName = new Map(all.map(r => [r.n, r]))
+
+  // 总排行：按周下载
+  const byWeekly = all.slice().sort((a, b) => (b.w || 0) - (a.w || 0))
+  byWeekly.forEach((r, i) => { r.rank = i + 1 })
+
+  // 分类排行：同类内按周下载
+  const byCat = new Map()
+  byWeekly.forEach(r => {
+    if (!r.cat) return
+    const n = (byCat.get(r.cat) || 0) + 1
+    byCat.set(r.cat, n)
+    r.crank = n
+  })
+
+  // 规范化 links（scoped 包名要编码）
+  for (const r of all) {
+    r.npmUrl = 'https://www.npmjs.com/package/' + r.n.replace('/', '%2F')
+    let repo = (r.repo || '').replace(/^git\+/, '').replace(/\.git$/, '')
+    if (repo && !/^https?:\/\//.test(repo)) repo = ''
+    r.repoUrl = repo
+    // GitHub 地址优先取 repo，其次 homepage（很多包装配的是 github.io）
+    const gh = (repo || r.home || '')
+    r.ghUrl = /github\.com/.test(gh) ? gh : ''
+  }
+
+  return cat
+}
+
+/* 同义词词典与中文二元切分见 lib/words.js（引擎与面板共用同一份） */
+
+/**
+ * 选型主流程第 2 步：按需求描述找候选
+ * 三层词法匹配 + 下载量微弱加权，返回带相关性与下载量的候选
+ */
+export function searchByNeed(catalog, need, { limit = 12, category = null } = {}) {
+  const terms = expandWords(need)
+  if (!terms.length) return []
+
+  const maxWeight = terms.reduce((s, t) => s + t.weight, 0)
+  const scored = []
+  for (const rec of Object.values(catalog.packages || {})) {
+    if (category && rec.cat !== category) continue
+    const hay = [(rec.n || ''), ...(rec.kw || []), rec.d || ''].join(' ').toLowerCase()
+    let hit = 0
+    let any = false
+    for (const t of terms) {
+      if (hay.includes(t.w)) { hit += t.weight; any = true }
+    }
+    if (!any) continue
+    const relevance = hit / maxWeight
+    // 下载量只做微弱加权，避免「发版本最勤」挤掉真正相关的
+    const pop = Math.log10(Math.max(rec.w, 1)) / 6
+    scored.push({ rec, relevance, score: relevance * 0.85 + pop * 0.15 })
+  }
+
+  scored.sort((a, b) => b.score - a.score)
+  return scored.slice(0, limit).map(x => ({
+    name: x.rec.n,
+    version: x.rec.v,
+    category: x.rec.cat,
+    description: x.rec.d,
+    weekly: x.rec.w,
+    monthly: x.rec.m,
+    deep: x.rec.deep
+      ? {
+          baseline: x.rec.deep.base,
+          growth: x.rec.deep.growth,
+          cadence: x.rec.deep.cadence,
+          ageDays: x.rec.deep.age,
+          lastRelease: x.rec.deep.lastRelease,
+          versions: x.rec.deep.versions,
+          score: x.rec.deep.s,
+        }
+      : null,
+    relevance: Math.round(x.relevance * 100),
+  }))
+}
+
+/** 排行 */
+export function rank(catalog, { metric = 'weekly', category = null, limit = 50, from = 0 } = {}) {
+  const all = Object.values(catalog.packages || {}).filter(r => !category || r.cat === category)
+  const val = r => metric === 'score' ? (r.deep ? r.deep.s : -1)
+                : metric === 'baseline' ? (r.deep ? r.deep.base : -1)
+                : metric === 'growth' ? (r.deep && r.deep.growth !== null ? r.deep.growth : -Infinity)
+                : metric === 'monthly' ? r.m : r.w
+  all.sort((a, b) => val(b) - val(a))
+  return all.slice(from, from + limit)
+}
+
+/** 获取单个/多个包的完整数据（含目录里没有时实时查） */
+export async function stats(catalog, names) {
+  const out = []
+  for (const name of names) {
+    const rec = catalog.packages[name]
+    if (rec && rec.deep) {
+      out.push({ source: 'catalog', ...serialize(rec) })
+      continue
+    }
+    const live = await fetchLive(name)
+    out.push(live ? { source: 'live', ...live } : { source: 'not-found', name })
+  }
+  return out
+}
+
+async function fetchLive(name) {
+  const today = new Date().toISOString().slice(0, 10)
+  const anchor = await resolveAnchor()
+  const start = shiftDate(anchor, -29)
+  const [range, total, meta] = await Promise.all([
+    jget(`${DL_API}/range/${start}:${anchor}/${enc(name)}`),
+    jget(`${DL_API}/point/2015-01-01:${today}/${enc(name)}`),
+    jget(`${REG_API}/${enc(name)}`),
+  ])
+  if (!range || !Array.isArray(range.downloads) || !range.downloads.length) return null
+
+  const daily = range.downloads.map(x => x.downloads)
+  let releaseDates = []
+  if (meta && meta.time) {
+    releaseDates = Object.entries(meta.time)
+      .filter(([k]) => k !== 'created' && k !== 'modified')
+      .map(([, v]) => String(v).slice(0, 10))
+  }
+  const b = baselineWithStart(daily, releaseDates, start)
+  const g = growth(daily)
+  const last = releaseDates.slice().sort().pop() || ''
+  const age = ageDays(last, today)
+
+  return {
+    name,
+    description: (meta && meta.description) || '',
+    keywords: (meta && meta.keywords) || [],
+    latest: meta && meta['dist-tags'] ? meta['dist-tags'].latest : null,
+    weekly: sum(daily.slice(-7)),
+    monthly: sum(daily),
+    total: total && typeof total.downloads === 'number' ? total.downloads : null,
+    daily,
+    deep: {
+      baseline: b,
+      growth: g,
+      cadence: cadence(releaseDates),
+      ageDays: age,
+      lastRelease: last,
+      versions: releaseDates.length,
+      score: score({ baseline: b, growth: g, age, cadence: cadence(releaseDates) }),
+    },
+  }
+}
+
+function serialize(rec) {
+  return {
+    name: rec.n,
+    version: rec.v,
+    description: rec.d,
+    keywords: rec.kw,
+    category: rec.cat,
+    weekly: rec.w,
+    monthly: rec.m,
+    rank: rec.rank || null,
+    crank: rec.crank || null,
+    npmUrl: rec.npmUrl || null,
+    ghUrl: rec.ghUrl || null,
+    repoUrl: rec.repoUrl || null,
+    deep: rec.deep
+      ? {
+          baseline: rec.deep.base,
+          growth: rec.deep.growth,
+          cadence: rec.deep.cadence,
+          ageDays: rec.deep.age,
+          lastRelease: rec.deep.lastRelease,
+          versions: rec.deep.versions,
+          score: rec.deep.s,
+        }
+      : null,
+  }
+}
+
+
+export default { buildCatalog, loadCatalog, reloadCatalog, searchByNeed, rank, stats, CATALOG_PATH, resolveAnchor }

package/lib/metrics.js

@@ -0,0 +1,105 @@
+// lib/metrics.js — 去噪指标
+//
+// 为什么要有这一层：npm 下载量是噪声极大的指标。我们自己的 5 个包统计里，
+// 单日峰值全部落在版本发布日（dsh-vps 于 10-02 连发 7 个版本，单日 1,068）。
+// 按原始下载量排序，排出来的是「发版本最勤的那个」，不是「最值得装的那个」。
+//
+// 所以结论要建立在去噪后的指标上。
+
+export function median(arr) {
+  if (!arr || !arr.length) return 0
+  const a = [...arr].sort((x, y) => x - y)
+  const m = a.length >> 1
+  return a.length % 2 ? a[m] : Math.round((a[m - 1] + a[m]) / 2)
+}
+
+export function mean(arr) {
+  if (!arr || !arr.length) return 0
+  return Math.round(arr.reduce((x, y) => x + y, 0) / arr.length)
+}
+
+export function sum(arr) {
+  if (!arr || !arr.length) return 0
+  return arr.reduce((x, y) => x + y, 0)
+}
+
+const dayMs = 86400000
+const toDay = iso => Math.floor(new Date(iso + 'T00:00:00Z').getTime() / dayMs)
+
+/**
+ * 日常基线：扣掉发布日影响后的每日中位数
+ * 发布日当天 + 后一天很可能是拉取安装产生的虚高，剔除后再取中位数。
+ * 中位数本身对尖峰不敏感，再剔一次发布日就更接近真实使用量。
+ * @param {number[]} daily 近 30 天每日下载
+ * @param {string[]} releaseDates 该窗口内发布过版本的日期（ISO）
+ * @param {string} startISO 窗口首日（ISO）
+ * @returns {number}
+ */
+export function baselineWithStart(daily = [], releaseDates = [], startISO = '') {
+  if (!daily.length) return 0
+  if (!releaseDates.length || !startISO) return median(daily)
+
+  const spikes = new Set()
+  const s = toDay(startISO)
+  for (const d of releaseDates) {
+    const n = toDay(d)
+    if (n >= s && n <= s + daily.length) {
+      spikes.add(n - s)        // 发布当天
+      spikes.add(n - s + 1)    // 发布次日
+    }
+  }
+  const kept = daily.filter((_, i) => !spikes.has(i))
+  return kept.length >= 5 ? median(kept) : median(daily)
+}
+
+/**
+ * 增速：最近 7 天 ÷ 之前 7 天 - 1
+ * 序列长度不足 14 天返回 null（发布时间太短，增速没意义）
+ * @returns {number|null}
+ */
+export function growth(daily = []) {
+  if (daily.length < 14) return null
+  const last7 = sum(daily.slice(-7))
+  const prev7 = sum(daily.slice(-14, -7))
+  if (prev7 === 0) return last7 > 0 ? 1 : null
+  return (last7 - prev7) / prev7
+}
+
+/**
+ * 版本节奏：平均几天发一个版本
+ * @param {string[]} versionDates 已按时间排序的版本发布时间（ISO 日期）
+ * @returns {number|null}
+ */
+export function cadence(versionDates = []) {
+  if (!versionDates || versionDates.length < 2) return null
+  const first = toDay(versionDates[0])
+  const last = toDay(versionDates[versionDates.length - 1])
+  const span = last - first
+  if (span <= 0) return 0.1 // 同一天发多个
+  return Math.round((span / (versionDates.length - 1)) * 10) / 10
+}
+
+/** 距今天数 */
+export function ageDays(iso = '', todayISO = '') {
+  if (!iso) return null
+  const ref = todayISO || new Date().toISOString().slice(0, 10)
+  return toDay(ref) - toDay(iso)
+}
+
+/**
+ * 综合评分 0~100，用于「首选 / 备选」的默认排序依据
+ * 权重：日常基线 40% + 增速 25% + 新鲜度 20% + 版本节奏 15%
+ * 注意：这是给面板用的默认口径，AI 拿到同样的字段可以自行调整权重并解释
+ */
+export function score({ baseline: b = 0, growth: g = null, age = null, cadence: c = null }) {
+  const baselinePart = clamp01(Math.log10(Math.max(b, 1)) / 4)                    // 1 → 0, 1万 → 1
+  const growthPart = g === null ? 0.5 : clamp01((g + 0.5) / 1.5)                  // -50% → 0, +100% → 1
+  const agePart = age === null ? 0.4 : clamp01(1 - age / 180)                     // 今天 → 1, 180 天前 → 0
+  const cadencePart = c === null ? 0.4 : clamp01(1 - (c - 1) / 21)                // 1天/版 → 1, 22天/版 → 0
+
+  return Math.round(
+    baselinePart * 40 + growthPart * 25 + agePart * 20 + cadencePart * 15
+  )
+}
+
+function clamp01(x) { return x < 0 ? 0 : x > 1 ? 1 : x }

package/lib/words.js

@@ -0,0 +1,71 @@
+// lib/words.js — 需求 → 搜索词
+//
+// 这一层是纯函数，不依赖 Node，所以 lib/engine.js（CLI/宿主端）和
+// web/panel.js（浏览器）都能 import 同一份，避免两套实现各自漂移。
+//
+// 三层展开，否则中文需求在英文关键词面前命中率极低：
+//   1) 用户原词（权重 3）
+//   2) 同义词词典：「数据库」→ sql/database/postgres…（权重 2）
+//   3) 长中文词二元切分：「数据库管理」→ 数据/据库/管理（权重 1，兜底词典没覆盖的说法）
+
+export const STOP = new Set(['什么', '怎么', '如何', '可以', '一个', '我想', '我要', '需要', '有没有',
+  'what', 'how', 'the', 'and', 'for', 'with', 'can', 'you', 'help', 'please', '插件', '东西', '工具', '功能'])
+
+export const SYNONYMS = {
+  '数据库': ['sql', 'database', 'db', 'postgres', 'mysql', 'sqlite', 'redis', 'mongo'],
+  '微信': ['wechat', 'wecom', 'weixin'],
+  '企业微信': ['wecom', 'wechat'],
+  '飞书': ['feishu', 'lark'],
+  '通知': ['notify', 'notification', 'message', 'im'],
+  '记忆': ['memory', 'context', 'recall', 'session'],
+  '搜索': ['search', 'web-search', 'retrieval'],
+  '远程': ['remote', 'ssh', 'vps', 'server'],
+  '服务器': ['server', 'vps', 'ssh', 'host'],
+  '部署': ['deploy', 'install', 'setup', 'self-hosted'],
+  '美化': ['theme', 'skin', 'wallpaper', 'appearance', 'ui'],
+  '界面': ['web-ui', 'ui', 'sidebar', 'theme', 'appearance'],
+  '终端': ['terminal', 'tui', 'shell', 'cli'],
+  '费用': ['cost', 'billing', 'usage', 'price', 'quota'],
+  '统计': ['stats', 'meter', 'usage', 'audit'],
+  '图片': ['image', 'vision', 'generation'],
+  '视频': ['video', 'live', 'camera'],
+  '语音': ['voice', 'audio', 'tts'],
+  '安全': ['security', 'sandbox', 'auth', 'permission', 'safety'],
+  '权限': ['permission', 'auth', 'approval'],
+  '审查': ['review', 'audit', 'lint', 'diff'],
+  '代码': ['code', 'git', 'diff', 'review', 'repo'],
+  '文档': ['markdown', 'office', 'pdf', 'doc', 'note'],
+  '模型': ['model', 'llm', 'provider', 'gateway'],
+  '网关': ['gateway', 'router', 'proxy'],
+  '插件': ['plugin', 'marketplace', 'install'],
+  '智能体': ['agent', 'subagent', 'team'],
+  '自动化': ['automation', 'workflow', 'schedule', 'task'],
+  '备份': ['backup', 'archive', 'restore'],
+  '导入': ['import', 'export', 'migrate'],
+  '翻译': ['translate', 'i18n', 'lang'],
+  '墙纸': ['wallpaper', 'background', 'skin'],
+  '文件': ['file', 'fs', 'edit'],
+  '管理': ['manager', 'manage', 'admin'],
+}
+
+/**
+ * @param {string} need 用户原话
+ * @returns {{w:string, weight:number}[]}
+ */
+export function expandWords(need) {
+  const raw = String(need || '').toLowerCase()
+    .split(/[\s,，、。？?！!/；;：:()（）"'《》【】\[\]+]+/).map(w => w.trim())
+    .filter(w => w.length >= 2 && !STOP.has(w))
+
+  const out = []
+  for (const w of raw) {
+    out.push({ w, weight: 3 })
+    const syn = SYNONYMS[w]
+    if (syn) for (const s of syn) out.push({ w: s, weight: 2 })
+    // 长中文词切二元，兜底同义词词典没覆盖的说法
+    if (/[\u4e00-\u9fa5]/.test(w) && w.length >= 4) {
+      for (let i = 0; i + 2 <= w.length; i++) out.push({ w: w.slice(i, i + 2), weight: 1 })
+    }
+  }
+  return out
+}

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "dsh-pick",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "帮你在 DSH 生态里选对插件：说需求 → 找候选 → 多维比较 → 出结论。下载量是证据，AI 是推理。",
+  "type": "module",
+  "bin": { "dsh-pick": "bin/dsh-pick.js" },
+  "files": ["bin", "lib", "plugin", "web", "data", "README.md"],
+  "keywords": [
+    "dsh-plugin",
+    "dsh-plugins",
+    "dsh",
+    "deepseek-harness",
+    "deepseek-harness-plugin",
+    "deepseek",
+    "cordis",
+    "plugin",
+    "plugin-directory",
+    "plugin-advisor",
+    "pick",
+    "npm-stats",
+    "plugin-market"
+  ],
+  "license": "MIT",
+  "engines": { "node": ">=20" }
+}