promptgraph-mcp 2.5.0 → 2.6.1

package/marketplace.js

@@ -561,9 +561,38 @@ export function pruneInvalidRepos() {
 
 // ── Trust level system ─────────────────────────────────────────────────────────
 const VALID_TRUST_LEVELS = ['verified', 'official', 'community', 'trusted', 'unknown']
+const TRUST_LEVEL_BOOST = { verified: 1.15, official: 1.10, trusted: 1.05, community: 1.0, unknown: 0.95 }
+
+// Popularity = log(downloads+1) × (rating+1), then decayed by age (days since last_update, halved every 180 days)
+function calcPopularity(downloads = 0, rating = 0, lastUpdateStr = null) {
+  const logDownloads = Math.log10((downloads || 0) + 1)
+  const ratingFactor = ((rating || 0) + 1) / 6  // normalised to 0–1
+  let pop = logDownloads * ratingFactor * 100
+
+  if (lastUpdateStr) {
+    const daysSince = (Date.now() - new Date(lastUpdateStr + 'Z').getTime()) / 86400000
+    if (daysSince > 0) {
+      pop *= Math.pow(0.5, daysSince / 180)  // half-life 180 days
+    }
+  }
+  return Math.round(pop * 100) / 100
+}
 
-function calcPopularity(downloads = 0, rating = 0) {
-  return Math.round((downloads || 0) * ((rating || 0) + 1) * 100) / 100
+// Auto-promote threshold: downloads at which a skill graduates to the next trust level
+const AUTO_PROMOTE_THRESHOLDS = [
+  { minDownloads: 10000, level: 'verified' },
+  { minDownloads: 1000,  level: 'official' },
+  { minDownloads: 100,   level: 'trusted' },
+]
+
+function autoPromote(downloads, currentLevel) {
+  const rank = VALID_TRUST_LEVELS.indexOf(currentLevel || 'unknown')
+  for (const t of AUTO_PROMOTE_THRESHOLDS) {
+    if (downloads >= t.minDownloads && VALID_TRUST_LEVELS.indexOf(t.level) > rank) {
+      return t.level
+    }
+  }
+  return null
 }
 
 export async function setTrustLevel(name, level) {
@@ -586,28 +615,36 @@ export async function getByTrustLevel(level) {
     return { error: `Invalid trust level "${level}". Must be one of: ${VALID_TRUST_LEVELS.join(', ')}` }
   }
   if (level) {
-    return db.prepare('SELECT * FROM registry_entries WHERE trust_level = ? ORDER BY id').all(level)
+    return db.prepare('SELECT * FROM registry_entries WHERE trust_level = ? ORDER BY downloads DESC, popularity DESC').all(level)
   }
-  return db.prepare('SELECT * FROM registry_entries ORDER BY id').all()
+  return db.prepare('SELECT * FROM registry_entries ORDER BY downloads DESC, popularity DESC').all()
 }
 
 export async function incrementDownloads(name) {
   const db = getDb()
   const id = String(name)
-  const existing = db.prepare('SELECT downloads, rating FROM registry_entries WHERE id = ?').get(id)
+  const existing = db.prepare('SELECT downloads, rating, last_update, trust_level FROM registry_entries WHERE id = ?').get(id)
   if (existing) {
     const newDownloads = (existing.downloads || 0) + 1
-    const pop = calcPopularity(newDownloads, existing.rating || 0)
+    const pop = calcPopularity(newDownloads, existing.rating || 0, existing.last_update)
     db.prepare('UPDATE registry_entries SET downloads = ?, popularity = ?, last_update = datetime(\'now\') WHERE id = ?')
       .run(newDownloads, pop, id)
+
+    // Auto-promote if threshold crossed
+    const newLevel = autoPromote(newDownloads, existing.trust_level)
+    if (newLevel) {
+      db.prepare('UPDATE registry_entries SET trust_level = ? WHERE id = ?').run(newLevel, id)
+    }
   } else {
     const pop = calcPopularity(1, 0)
-    db.prepare('INSERT INTO registry_entries (id, downloads, popularity, last_update) VALUES (?, 1, ?, datetime(\'now\'))')
+    db.prepare('INSERT INTO registry_entries (id, downloads, popularity, trust_level, last_update) VALUES (?, 1, ?, \'unknown\', datetime(\'now\'))')
       .run(id, pop)
   }
   return { ok: true }
 }
 
+export { VALID_TRUST_LEVELS, TRUST_LEVEL_BOOST, calcPopularity, autoPromote }
+
 export async function rateSkill(name, rating) {
   const db = getDb()
   if (typeof rating !== 'number' || rating < 0 || rating > 5) {

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "promptgraph-mcp",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "files": [
     "*.js",
-    "src/**/*.js",
+    "commands/",
+    "src/",
     "README.md"
   ],
   "main": "index.js",

package/search.js

@@ -1,6 +1,7 @@
 import { embed, cosineSimilarity } from './embedder.js';
 import { getDb, blobToVec } from './db.js';
 import { annSearch } from './ann.js';
+import { TRUST_LEVEL_BOOST } from './marketplace.js';
 
 function getHybridWeights(query) {
   const hasTechTerms = /[A-Z]|\d/.test(query);
@@ -10,11 +11,25 @@ function getHybridWeights(query) {
 
 function applyRatingBoost(db, id, score) {
   const r = db.prepare('SELECT success, fail FROM ratings WHERE skill_id = ?').get(id);
+  let boost = 1.0;
   if (r && (r.success + r.fail) > 3) {
-    const rating = r.success / (r.success + r.fail);
-    return score * (0.85 + 0.15 * rating);
+    boost *= (0.85 + 0.15 * (r.success / (r.success + r.fail)));
   }
-  return score;
+
+  // Trust level boost (verified/official/trusted rank higher)
+  const re = db.prepare('SELECT trust_level, popularity FROM registry_entries WHERE id = ?').get(id);
+  if (re) {
+    boost *= (TRUST_LEVEL_BOOST[re.trust_level] || 1.0);
+    // Popularity bump: top 20% of skills get +5%, rest unchanged
+    if (re.popularity > 0) {
+      const top20 = db.prepare('SELECT popularity FROM registry_entries ORDER BY popularity DESC LIMIT 1').get();
+      if (top20 && re.popularity >= top20.popularity * 0.2) {
+        boost *= 1.05;
+      }
+    }
+  }
+
+  return score * boost;
 }
 
 function normalizeBM25(raw) {
@@ -114,13 +129,13 @@ export async function search(query, topK = 5) {
   if (rerankerEnabled) {
     const { Reranker } = await import('./src/reranker/reranker.js')
     const reranker = new Reranker()
-    const topN = ordered.slice(0, 20)
+    const topN = ordered.slice(0, Math.max(50, topK * 6))
       .map(({ id, score }) => {
         const s = skillWithSnippet(db, id, score)
         return s ? { id, text: s.snippet, score } : null
       })
       .filter(Boolean)
-    const reranked = await reranker.rerank(query, topN)
+    const reranked = await reranker.rerank(query, topN, topK)
     return reranked.map(r => skillWithSnippet(db, r.id, applyRatingBoost(db, r.id, r.score))).filter(Boolean)
   }
 

package/src/reranker/reranker.js

@@ -1,27 +1,92 @@
+// Term-overlap reranker with phrase matching and IDF-like weighting.
+// Replace `rerank()` with a cross-encoder (BGE Reranker / MiniLM via ONNX)
+// for deeper semantic reranking. This class is the plug-in point.
 export class Reranker {
   constructor(modelName = 'default', device = 'cpu') {
     this.modelName = modelName
     this.device = device
   }
 
-  // Cross-encoder style reranker
-  // Plug-in point for BGE Reranker / MiniLM Reranker via ONNX
-  async rerank(query, results) {
+  rerank(query, results, topK = 5) {
     if (!results || results.length === 0) return []
 
-    const queryTerms = (query.toLowerCase().match(/\w+/g) || [])
-    const queryTermCount = queryTerms.length || 1
+    const rawTerms = (query.toLowerCase().match(/\w+/g) || [])
+    if (rawTerms.length === 0) return results.slice(0, topK)
 
-    const scored = results.map(r => {
-      const text = (r.text || '').toLowerCase()
-      const termOverlap = queryTerms.filter(t => text.includes(t)).length / queryTermCount
+    const unigrams = rawTerms
+    const bigrams = []
+    const trigrams = []
+    for (let i = 0; i < rawTerms.length - 1; i++) bigrams.push(rawTerms[i] + ' ' + rawTerms[i + 1])
+    for (let i = 0; i < rawTerms.length - 2; i++) trigrams.push(rawTerms[i] + ' ' + rawTerms[i + 1] + ' ' + rawTerms[i + 2])
+
+    const texts = results.map(r => (r.text || '').toLowerCase())
+
+    // Term doc-frequency
+    const termDf = {}
+    for (const t of unigrams) {
+      termDf[t] = texts.filter(txt => txt.includes(t)).length
+    }
+    const nResults = results.length
+
+    // First pass: compute raw tfIdf for each result
+    const tfIdfValues = texts.map(text => {
+      let sum = 0
+      for (const term of unigrams) {
+        const df = termDf[term] || 1
+        const idf = 1 + Math.log10((nResults + 1) / df)
+        let idx = -1
+        let count = 0
+        while ((idx = text.indexOf(term, idx + 1)) !== -1) count++
+        sum += count * idf
+      }
+      return sum
+    })
+
+    const maxTfIdf = Math.max(...tfIdfValues, 1)
+
+    const scored = results.map((r, idx) => {
+      const text = texts[idx]
+      const lines = text.split('\n')
+
+      // 1. N-gram overlap
+      const unigramMatch = unigrams.filter(t => text.includes(t)).length / unigrams.length
+      const bigramMatch = bigrams.length > 0 ? bigrams.filter(b => text.includes(b)).length / bigrams.length : 0
+      const trigramMatch = trigrams.length > 0 ? trigrams.filter(t => text.includes(t)).length / trigrams.length : 0
+      const ngramScore = 0.4 * unigramMatch + 0.35 * bigramMatch + 0.25 * trigramMatch
+
+      // 2. IDF-weighted TF (normalised by max across results)
+      const tfIdfScore = tfIdfValues[idx] / maxTfIdf
+
+      // 3. Exact phrase proximity — consecutive same-order term matches
+      let phraseBoost = 0
+      if (rawTerms.length >= 2) {
+        const textWords = text.split(/\s+/)
+        let bestRun = 0
+        for (let i = 0; i < textWords.length - rawTerms.length + 1; i++) {
+          let matchLen = 0
+          for (let j = 0; j < rawTerms.length; j++) {
+            if (textWords[i + j] === rawTerms[j]) matchLen++
+            else break
+          }
+          if (matchLen >= 2) bestRun = Math.max(bestRun, matchLen)
+        }
+        phraseBoost = bestRun / rawTerms.length
+      }
+
+      // 4. Header position boost
+      const headerText = lines.slice(0, 3).join(' ').toLowerCase()
+      const headerOverlap = unigrams.filter(t => headerText.includes(t)).length / unigrams.length
+
+      // Blend
+      const overlapScore = 0.25 * ngramScore + 0.25 * tfIdfScore + 0.25 * phraseBoost + 0.15 * headerOverlap + 0.10 * unigramMatch
 
       return {
-        ...r,
-        score: 0.8 * (r.score || 0) + 0.2 * termOverlap,
+        id: r.id,
+        text: r.text,
+        score: 0.70 * (r.score || 0) + 0.30 * overlapScore,
       }
     })
 
-    return scored.sort((a, b) => b.score - a.score).slice(0, 5)
+    return scored.sort((a, b) => b.score - a.score).slice(0, topK)
   }
 }

package/src/store/index.js

@@ -7,7 +7,7 @@ export function getStore(type = null) {
   if (_store) return _store;
 
   if (!type) {
-    type = process.env.PG_VECTOR_STORE || 'flat';
+    type = process.env.PG_VECTOR_STORE || 'hnsw';
   }
 
   _store = type === 'hnsw' ? new HNSWVectorStore() : new FlatVectorStore();