@vibecheck-ai/mcp 24.6.8 → 24.6.11

package/dist/chunk-J52EUKKW.js

@@ -0,0 +1,196 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFile, mkdir, writeFile, stat } from 'fs/promises';
+
+createRequire(import.meta.url);
+const __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);
+var PROVENANCE_PATH = ".vibecheck/provenance/edits.jsonl";
+var MS_PER_MIN = 6e4;
+async function readProvenance(rootDir) {
+  const p = join(rootDir, PROVENANCE_PATH);
+  try {
+    const raw = await readFile(p, "utf-8");
+    return raw.trim().split("\n").filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+  } catch {
+    return [];
+  }
+}
+function extractCoEdits(edits, sessionWindowMinutes = 30) {
+  const windowMs = sessionWindowMinutes * MS_PER_MIN;
+  const pairCounts = /* @__PURE__ */ new Map();
+  const sorted = [...edits].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  for (let i = 0; i < sorted.length; i++) {
+    const t1 = new Date(sorted[i].timestamp).getTime();
+    for (let j = i + 1; j < sorted.length; j++) {
+      const t2 = new Date(sorted[j].timestamp).getTime();
+      if (t2 - t1 > windowMs) break;
+      const [f1, f2] = [sorted[i].file, sorted[j].file].sort();
+      if (f1 === f2) continue;
+      const key = `${f1}\0${f2}`;
+      const cur = pairCounts.get(key) ?? { count: 0, lastSeen: 0 };
+      pairCounts.set(key, { count: cur.count + 1, lastSeen: Math.max(cur.lastSeen, t2) });
+    }
+  }
+  const pairs = [];
+  for (const [key, { count, lastSeen }] of pairCounts) {
+    const [f1, f2] = key.split("\0");
+    const weight = Math.min(1, count / 10);
+    pairs.push({ files: [f1, f2], weight, count, lastSeen: new Date(lastSeen).toISOString() });
+  }
+  return pairs.sort((a, b) => b.count - a.count);
+}
+function extractSequences(edits, sessionWindowMinutes = 30) {
+  const windowMs = sessionWindowMinutes * MS_PER_MIN;
+  const sequenceCounts = /* @__PURE__ */ new Map();
+  const sorted = [...edits].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  let sessionFiles = [];
+  let sessionLastTs = 0;
+  for (const e of sorted) {
+    const t = new Date(e.timestamp).getTime();
+    if (sessionFiles.length > 0 && t - sessionLastTs > windowMs) {
+      if (sessionFiles.length >= 3) {
+        const key = sessionFiles.join("\0");
+        const cur = sequenceCounts.get(key) ?? { count: 0 };
+        sequenceCounts.set(key, { count: cur.count + 1 });
+      }
+      sessionFiles = [];
+    }
+    if (!sessionFiles.includes(e.file)) {
+      sessionFiles.push(e.file);
+    }
+    sessionLastTs = t;
+  }
+  if (sessionFiles.length >= 3) {
+    const key = sessionFiles.join("\0");
+    const cur = sequenceCounts.get(key) ?? { count: 0 };
+    sequenceCounts.set(key, { count: cur.count + 1 });
+  }
+  const sequences = [];
+  for (const [key, { count }] of sequenceCounts) {
+    const files = key.split("\0");
+    const weight = Math.min(1, count / 5);
+    sequences.push({ files, weight, count });
+  }
+  return sequences.sort((a, b) => b.count - a.count);
+}
+var LEARNED_FILE = "learned.json";
+var STALE_MS = 60 * 60 * 1e3;
+function computeOutcomeScores(edits) {
+  const byFile = /* @__PURE__ */ new Map();
+  const isAiEdit = (e) => e.editSource === "ai-completion" || e.editSource === "ai-chat-insert";
+  for (const e of edits) {
+    const cur = byFile.get(e.file) ?? { total: 0, ai: 0 };
+    cur.total++;
+    if (isAiEdit(e)) cur.ai++;
+    byFile.set(e.file, cur);
+  }
+  const scores = {};
+  for (const [file, { total, ai }] of byFile) {
+    scores[file] = total > 0 ? 0.5 + 0.5 * (ai / total) : 0.5;
+  }
+  return scores;
+}
+async function evolve(rootPath) {
+  const existing = await loadLearned(rootPath);
+  const edits = await readProvenance(rootPath);
+  const coEdits = extractCoEdits(edits, 30);
+  const sequences = extractSequences(edits, 30);
+  const outcomeScores = computeOutcomeScores(edits);
+  const data = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    coEdits,
+    sequences,
+    outcomeScores,
+    explicitFeedback: existing?.explicitFeedback ?? []
+  };
+  const outDir = join(rootPath, ".vibecheck", "context-evolution");
+  await mkdir(outDir, { recursive: true });
+  await writeFile(join(outDir, LEARNED_FILE), JSON.stringify(data, null, 2), "utf-8");
+  return data;
+}
+async function loadLearned(rootPath) {
+  const p = join(rootPath, ".vibecheck", "context-evolution", LEARNED_FILE);
+  try {
+    const raw = await readFile(p, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function loadLearnedOrEvolveIfStale(rootPath, maxAgeMs = STALE_MS) {
+  const p = join(rootPath, ".vibecheck", "context-evolution", LEARNED_FILE);
+  try {
+    const st = await stat(p);
+    const age = Date.now() - st.mtimeMs;
+    if (age > maxAgeMs) {
+      return evolve(rootPath);
+    }
+    return loadLearned(rootPath);
+  } catch {
+    return evolve(rootPath);
+  }
+}
+async function getBoostedFiles(rootPath, focusedFile) {
+  const learned = await loadLearnedOrEvolveIfStale(rootPath);
+  if (!learned) return [];
+  const results = [];
+  for (const pair of learned.coEdits) {
+    if (pair.files[0] === focusedFile) results.push({ file: pair.files[1], weight: pair.weight });
+    else if (pair.files[1] === focusedFile) results.push({ file: pair.files[0], weight: pair.weight });
+  }
+  return results.sort((a, b) => b.weight - a.weight);
+}
+async function getSequentialFiles(rootPath, focusedFile) {
+  const learned = await loadLearnedOrEvolveIfStale(rootPath);
+  if (!learned || learned.sequences.length === 0) return [];
+  const scored = /* @__PURE__ */ new Map();
+  for (const seq of learned.sequences) {
+    const idx = seq.files.indexOf(focusedFile);
+    if (idx < 0 || idx >= seq.files.length - 1) continue;
+    for (let i = idx + 1; i < seq.files.length; i++) {
+      const f = seq.files[i];
+      scored.set(f, Math.max(scored.get(f) ?? 0, seq.weight));
+    }
+  }
+  return [...scored.entries()].map(([file, weight]) => ({ file, weight })).sort((a, b) => b.weight - a.weight);
+}
+async function getOutcomeBoost(rootPath, file) {
+  const learned = await loadLearned(rootPath);
+  if (!learned) return 0.5;
+  return learned.outcomeScores[file] ?? 0.5;
+}
+async function recordFeedback(rootPath, file, outcome) {
+  const learned = await loadLearned(rootPath);
+  const outDir = join(rootPath, ".vibecheck", "context-evolution");
+  await mkdir(outDir, { recursive: true });
+  const data = learned ?? {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    coEdits: [],
+    sequences: [],
+    outcomeScores: {},
+    explicitFeedback: []
+  };
+  data.explicitFeedback.push({
+    file,
+    outcome,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await writeFile(join(outDir, LEARNED_FILE), JSON.stringify(data, null, 2), "utf-8");
+}
+var VERSION = "0.1.0";
+
+export { VERSION, evolve, extractCoEdits, extractSequences, getBoostedFiles, getOutcomeBoost, getSequentialFiles, loadLearned, loadLearnedOrEvolveIfStale, readProvenance, recordFeedback };