promptgraph-mcp 2.8.1 → 2.8.3

package/src/filter/hard-filter.js

@@ -1,62 +1,62 @@
-import fs from 'fs';
-
-const SKIP_FILENAMES = new Set([
-  'readme', 'changelog', 'license', 'contributing', 'code-of-conduct',
-  'security', 'authors', 'credits', 'install', 'installation', 'usage',
-  'engagements', 'contributors', 'maintainers', 'acknowledgements',
-  'faq', 'glossary', 'index', 'overview', 'summary', 'roadmap', 'todo',
-  'notes', 'template', 'example', 'sample', 'demo', 'getting-started',
-  'quickstart', 'guide', 'tutorial', 'walkthrough', 'architecture',
-  'design', 'spec', 'specification', 'requirements', 'privacy', 'terms',
-  'disclaimer', 'notice', 'copying', 'warranty', 'codeofconduct',
-  'pull_request_template', 'issue_template', 'funding',
-  'claude', 'bugs', 'bug_report', 'bug-report', 'feature_request',
-  'feature-request',
-]);
-
-const SKIP_FILENAME_RE = /^(_|\.)|^v?\d+[\.\-]\d+|^\d{4}[\-_]\d{2}|^readme|^license|^changelog|^contributing|^code.of.conduct|^security|^authors|^credits|^disclaimer|^notice|^copying|^warranty|^promotion|^funding|^claude|^bugs?\b|^feature.?request/i;
-
-const SKIP_DIRS = new Set([
-  '.github', 'docs', 'doc', 'documentation', 'examples', 'example',
-  'tests', 'test', '__tests__', 'spec', 'fixtures', 'assets', 'images',
-  'img', 'screenshots', 'media', 'static', 'public', 'dist', 'build',
-  'node_modules', 'vendor', 'third_party',
-  'references', 'reference', 'refs', 'cheatsheet', 'cheat-sheet',
-  'cheatsheets', 'resources',
-  'src', 'cli', 'lib', 'bin',
-]);
-
-const BADGE_RE = /!\[.*\]\(https?:\/\/(img\.shields\.io|badge\.fury|travis-ci|github\.com\/[^)]+\/badge)/i;
-const README_HEADER_RE = /^#\s*readme\b/i;
-
-export function hardFilter(filePath, raw) {
-  const parts = filePath.replace(/\\/g, '/').split('/');
-  const filename = parts[parts.length - 1];
-  const base = filename.replace(/\.md$/i, '').toLowerCase();
-
-  if (SKIP_FILENAMES.has(base)) {
-    return { pass: false, reason: `skip filename: ${base}` };
-  }
-
-  if (SKIP_FILENAME_RE.test(base)) {
-    return { pass: false, reason: `skip filename pattern: ${base}` };
-  }
-
-  for (const part of parts.slice(0, -1)) {
-    if (SKIP_DIRS.has(part.toLowerCase())) {
-      return { pass: false, reason: `skip dir: ${part}` };
-    }
-  }
-
-  if (raw) {
-    const firstLines = raw.trimStart().slice(0, 300);
-    if (README_HEADER_RE.test(firstLines)) {
-      return { pass: false, reason: 'starts with # Readme' };
-    }
-    if (BADGE_RE.test(firstLines)) {
-      return { pass: false, reason: 'badge-only content' };
-    }
-  }
-
-  return { pass: true };
-}
+import fs from 'fs';
+
+const SKIP_FILENAMES = new Set([
+  'readme', 'changelog', 'license', 'contributing', 'code-of-conduct',
+  'security', 'authors', 'credits', 'install', 'installation', 'usage',
+  'engagements', 'contributors', 'maintainers', 'acknowledgements',
+  'faq', 'glossary', 'index', 'overview', 'summary', 'roadmap', 'todo',
+  'notes', 'template', 'example', 'sample', 'demo', 'getting-started',
+  'quickstart', 'guide', 'tutorial', 'walkthrough', 'architecture',
+  'design', 'spec', 'specification', 'requirements', 'privacy', 'terms',
+  'disclaimer', 'notice', 'copying', 'warranty', 'codeofconduct',
+  'pull_request_template', 'issue_template', 'funding',
+  'claude', 'bugs', 'bug_report', 'bug-report', 'feature_request',
+  'feature-request',
+]);
+
+const SKIP_FILENAME_RE = /^(_|\.)|^v?\d+[\.\-]\d+|^\d{4}[\-_]\d{2}|^readme|^license|^changelog|^contributing|^code.of.conduct|^security|^authors|^credits|^disclaimer|^notice|^copying|^warranty|^promotion|^funding|^claude|^bugs?\b|^feature.?request/i;
+
+const SKIP_DIRS = new Set([
+  '.github', 'docs', 'doc', 'documentation', 'examples', 'example',
+  'tests', 'test', '__tests__', 'spec', 'fixtures', 'assets', 'images',
+  'img', 'screenshots', 'media', 'static', 'public', 'dist', 'build',
+  'node_modules', 'vendor', 'third_party',
+  'references', 'reference', 'refs', 'cheatsheet', 'cheat-sheet',
+  'cheatsheets', 'resources',
+  'src', 'cli', 'lib', 'bin',
+]);
+
+const BADGE_RE = /!\[.*\]\(https?:\/\/(img\.shields\.io|badge\.fury|travis-ci|github\.com\/[^)]+\/badge)/i;
+const README_HEADER_RE = /^#\s*readme\b/i;
+
+export function hardFilter(filePath, raw) {
+  const parts = filePath.replace(/\\/g, '/').split('/');
+  const filename = parts[parts.length - 1];
+  const base = filename.replace(/\.md$/i, '').toLowerCase();
+
+  if (SKIP_FILENAMES.has(base)) {
+    return { pass: false, reason: `skip filename: ${base}` };
+  }
+
+  if (SKIP_FILENAME_RE.test(base)) {
+    return { pass: false, reason: `skip filename pattern: ${base}` };
+  }
+
+  for (const part of parts.slice(0, -1)) {
+    if (SKIP_DIRS.has(part.toLowerCase())) {
+      return { pass: false, reason: `skip dir: ${part}` };
+    }
+  }
+
+  if (raw) {
+    const firstLines = raw.trimStart().slice(0, 300);
+    if (README_HEADER_RE.test(firstLines)) {
+      return { pass: false, reason: 'starts with # Readme' };
+    }
+    if (BADGE_RE.test(firstLines)) {
+      return { pass: false, reason: 'badge-only content' };
+    }
+  }
+
+  return { pass: true };
+}

package/src/filter/train.js

@@ -1,66 +1,66 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { fileURLToPath } from 'url';
-import { globSync } from 'glob';
-import { embedBatch } from '../../embedder.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TRAINING_DIR = path.resolve(__dirname, '../../registry/training');
-const MODEL_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'model.json');
-
-function readAllMd(dir) {
-  const files = globSync(`${dir}/**/*.md`);
-  return files.map(f => fs.readFileSync(f, 'utf8'));
-}
-
-function meanVector(vectors) {
-  if (!vectors.length) return null;
-  const dim = vectors[0].length;
-  const centroid = new Float32Array(dim);
-  for (const v of vectors) {
-    for (let i = 0; i < dim; i++) centroid[i] += v[i];
-  }
-  for (let i = 0; i < dim; i++) centroid[i] /= vectors.length;
-  return Array.from(centroid);
-}
-
-export async function train() {
-  const goodDir = path.join(TRAINING_DIR, 'good');
-  const badDir = path.join(TRAINING_DIR, 'bad');
-
-  const goodTexts = readAllMd(goodDir);
-  const badTexts = readAllMd(badDir);
-
-  if (goodTexts.length < 1 || badTexts.length < 1) {
-    throw new Error(`Need at least 1 good and 1 bad training example (good: ${goodTexts.length}, bad: ${badTexts.length})`);
-  }
-
-  const allTexts = [...goodTexts, ...badTexts];
-  const allVecs = await embedBatch(allTexts);
-
-  const goodVecs = allVecs.slice(0, goodTexts.length);
-  const badVecs = allVecs.slice(goodTexts.length);
-
-  const model = {
-    version: 1,
-    good: meanVector(goodVecs),
-    bad: meanVector(badVecs),
-    counts: { good: goodTexts.length, bad: badTexts.length },
-  };
-
-  fs.mkdirSync(path.dirname(MODEL_PATH), { recursive: true });
-  fs.writeFileSync(MODEL_PATH, JSON.stringify(model));
-  return model;
-}
-
-export function loadModel() {
-  try {
-    const raw = fs.readFileSync(MODEL_PATH, 'utf8');
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-export { MODEL_PATH };
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { globSync } from 'glob';
+import { embedBatch } from '../../embedder.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TRAINING_DIR = path.resolve(__dirname, '../../registry/training');
+const MODEL_PATH = path.join(os.homedir(), '.claude', '.promptgraph', 'model.json');
+
+function readAllMd(dir) {
+  const files = globSync(`${dir}/**/*.md`);
+  return files.map(f => fs.readFileSync(f, 'utf8'));
+}
+
+function meanVector(vectors) {
+  if (!vectors.length) return null;
+  const dim = vectors[0].length;
+  const centroid = new Float32Array(dim);
+  for (const v of vectors) {
+    for (let i = 0; i < dim; i++) centroid[i] += v[i];
+  }
+  for (let i = 0; i < dim; i++) centroid[i] /= vectors.length;
+  return Array.from(centroid);
+}
+
+export async function train() {
+  const goodDir = path.join(TRAINING_DIR, 'good');
+  const badDir = path.join(TRAINING_DIR, 'bad');
+
+  const goodTexts = readAllMd(goodDir);
+  const badTexts = readAllMd(badDir);
+
+  if (goodTexts.length < 1 || badTexts.length < 1) {
+    throw new Error(`Need at least 1 good and 1 bad training example (good: ${goodTexts.length}, bad: ${badTexts.length})`);
+  }
+
+  const allTexts = [...goodTexts, ...badTexts];
+  const allVecs = await embedBatch(allTexts);
+
+  const goodVecs = allVecs.slice(0, goodTexts.length);
+  const badVecs = allVecs.slice(goodTexts.length);
+
+  const model = {
+    version: 1,
+    good: meanVector(goodVecs),
+    bad: meanVector(badVecs),
+    counts: { good: goodTexts.length, bad: badTexts.length },
+  };
+
+  fs.mkdirSync(path.dirname(MODEL_PATH), { recursive: true });
+  fs.writeFileSync(MODEL_PATH, JSON.stringify(model));
+  return model;
+}
+
+export function loadModel() {
+  try {
+    const raw = fs.readFileSync(MODEL_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export { MODEL_PATH };

package/src/reranker/reranker.js

@@ -1,92 +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
-  }
-
-  rerank(query, results, topK = 5) {
-    if (!results || results.length === 0) return []
-
-    const rawTerms = (query.toLowerCase().match(/\w+/g) || [])
-    if (rawTerms.length === 0) return results.slice(0, topK)
-
-    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 {
-        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, topK)
-  }
-}
+// 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
+  }
+
+  rerank(query, results, topK = 5) {
+    if (!results || results.length === 0) return []
+
+    const rawTerms = (query.toLowerCase().match(/\w+/g) || [])
+    if (rawTerms.length === 0) return results.slice(0, topK)
+
+    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 {
+        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, topK)
+  }
+}

package/src/store/flat-store.js

@@ -1,61 +1,61 @@
-import { VectorStore } from './vector-store.js';
-
-export class FlatVectorStore extends VectorStore {
-  constructor() {
-    super();
-    this._items = [];
-  }
-
-  async add(id, vector) {
-    this._items.push({ skill_id: id, vec: new Float32Array(vector) });
-  }
-
-  async addBatch(entries) {
-    for (const { id, vector } of entries) {
-      this._items.push({ skill_id: id, vec: new Float32Array(vector) });
-    }
-  }
-
-  async remove(id) {
-    this._items = this._items.filter(item => item.skill_id !== id);
-  }
-
-  async search(vector, topK = 20) {
-    const qArr = new Float32Array(vector);
-    const bestBySkill = new Map();
-    for (const entry of this._items) {
-      const score = cosineSim(qArr, entry.vec);
-      const prev = bestBySkill.get(entry.skill_id);
-      if (!prev || score > prev) bestBySkill.set(entry.skill_id, score);
-    }
-    return [...bestBySkill.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, topK)
-      .map(([skill_id, score]) => ({ skill_id, score }));
-  }
-
-  async build(entries) {
-    this._items = [];
-    for (const { skill_id, vector } of entries) {
-      this._items.push({ skill_id, vec: new Float32Array(vector) });
-    }
-  }
-
-  async clear() {
-    this._items = [];
-  }
-
-  get size() {
-    return this._items.length;
-  }
-}
-
-function cosineSim(a, b) {
-  let dot = 0, na = 0, nb = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
-  }
-  return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-8);
-}
+import { VectorStore } from './vector-store.js';
+
+export class FlatVectorStore extends VectorStore {
+  constructor() {
+    super();
+    this._items = [];
+  }
+
+  async add(id, vector) {
+    this._items.push({ skill_id: id, vec: new Float32Array(vector) });
+  }
+
+  async addBatch(entries) {
+    for (const { id, vector } of entries) {
+      this._items.push({ skill_id: id, vec: new Float32Array(vector) });
+    }
+  }
+
+  async remove(id) {
+    this._items = this._items.filter(item => item.skill_id !== id);
+  }
+
+  async search(vector, topK = 20) {
+    const qArr = new Float32Array(vector);
+    const bestBySkill = new Map();
+    for (const entry of this._items) {
+      const score = cosineSim(qArr, entry.vec);
+      const prev = bestBySkill.get(entry.skill_id);
+      if (!prev || score > prev) bestBySkill.set(entry.skill_id, score);
+    }
+    return [...bestBySkill.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, topK)
+      .map(([skill_id, score]) => ({ skill_id, score }));
+  }
+
+  async build(entries) {
+    this._items = [];
+    for (const { skill_id, vector } of entries) {
+      this._items.push({ skill_id, vec: new Float32Array(vector) });
+    }
+  }
+
+  async clear() {
+    this._items = [];
+  }
+
+  get size() {
+    return this._items.length;
+  }
+}
+
+function cosineSim(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-8);
+}