vektor-slipstream 1.4.4 → 2.0.0

package/cloak-pattern-store.js

@@ -1,471 +0,0 @@
-'use strict';
-
-/**
- * cloak-pattern-store.js — Tiered self-improving pattern library
- * ─────────────────────────────────────────────────────────────────────────────
- * Stores behaviour patterns in SQLite with win/loss scoring, tier management,
- * auto-pruning, and duplicate detection. Patterns get smarter over time.
- *
- * Tiers:
- *   elite      (max 10)  — 3+ wins, 0 losses. Used 70% of sessions.
- *   active     (max 30)  — Positive score, in rotation. Used 25% of sessions.
- *   probation  (max 20)  — New or declining. Used 5% of sessions.
- *   retired    (deleted) — Score < -3, stale, or duplicate.
- *
- * Pruning rules:
- *   - Score drops to -3             → immediate retirement
- *   - No win in 30 days + score ≤ 0 → retirement
- *   - Pattern age > 90 days + score < 5 → retirement (sites change)
- *   - Active tier > 30              → prune lowest scored
- *   - Duplicate (>92% similarity)   → discard on arrival
- *   - Elite tier full + new 3-win   → bump lowest elite to active
- * ─────────────────────────────────────────────────────────────────────────────
- */
-
-const path   = require('path');
-const os     = require('os');
-const fs     = require('fs');
-const crypto = require('crypto');
-
-const DB_PATH = process.env.VEKTOR_PATTERN_DB || path.join(os.homedir(), '.vektor', 'pattern-store.db');
-
-// Tier weights for random selection (elite gets most traffic)
-const TIER_WEIGHTS = { elite: 0.70, active: 0.25, probation: 0.05 };
-
-// Tier size caps
-const TIER_CAPS = { elite: 10, active: 30, probation: 20 };
-
-// Pruning thresholds
-const PRUNE = {
-  minScore:          -3,   // retire immediately below this
-  staleDays:         30,   // retire if no win in this many days AND score ≤ 0
-  ageDays:           90,   // retire if older than this AND score < 5
-  similarityThresh:  0.92, // discard new pattern if >92% similar to existing elite
-};
-
-let _db = null;
-
-// ── DB initialisation ─────────────────────────────────────────────────────────
-
-function getDB() {
-  if (_db) return _db;
-
-  const Database = require('better-sqlite3');
-  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
-  _db = new Database(DB_PATH);
-
-  _db.pragma('journal_mode = WAL');
-  _db.pragma('synchronous = NORMAL');
-
-  _db.exec(`
-    CREATE TABLE IF NOT EXISTS patterns (
-      id           TEXT PRIMARY KEY,
-      name         TEXT NOT NULL,
-      category     TEXT NOT NULL DEFAULT 'custom',
-      tier         TEXT NOT NULL DEFAULT 'probation',
-      score        INTEGER NOT NULL DEFAULT 0,
-      wins         INTEGER NOT NULL DEFAULT 0,
-      losses       INTEGER NOT NULL DEFAULT 0,
-      sessions     INTEGER NOT NULL DEFAULT 0,
-      created_at   INTEGER NOT NULL,
-      last_win_at  INTEGER,
-      last_used_at INTEGER,
-      description  TEXT,
-      profile      TEXT NOT NULL,
-      fingerprint  TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS pattern_log (
-      id          INTEGER PRIMARY KEY AUTOINCREMENT,
-      pattern_id  TEXT NOT NULL,
-      outcome     TEXT NOT NULL,
-      site        TEXT,
-      score_delta INTEGER NOT NULL,
-      logged_at   INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_tier      ON patterns(tier);
-    CREATE INDEX IF NOT EXISTS idx_category  ON patterns(category);
-    CREATE INDEX IF NOT EXISTS idx_score     ON patterns(score DESC);
-  `);
-
-  return _db;
-}
-
-// ── Fingerprint for duplicate detection ───────────────────────────────────────
-// Summarises a pattern's velocity/scroll profile as a compact vector
-// so we can detect near-duplicates before adding to the store.
-
-function _fingerprintPattern(events) {
-  if (!events?.length) return '0'.repeat(32);
-
-  // Build a 16-bucket histogram of: scroll velocity, move speed, pause frequency
-  const buckets = new Float32Array(16);
-  let   prev    = null;
-  let   scrollCount = 0, moveCount = 0, pauseCount = 0;
-  let   totalScrollDy = 0;
-
-  for (const e of events) {
-    if (e.type === 'scroll') {
-      scrollCount++;
-      totalScrollDy += Math.abs(e.dy || 0);
-      // Bucket by scroll velocity (dy / dt)
-      const vel = prev ? Math.abs(e.dy || 0) / Math.max(1, e.dt - (prev.dt || 0)) : 0;
-      const b   = Math.min(7, Math.floor(vel / 10));
-      buckets[b]++;
-    } else if (e.type === 'move') {
-      moveCount++;
-      buckets[8 + Math.min(7, Math.floor(Math.random() * 8))]++;
-    } else if (e.type === 'pause') {
-      pauseCount++;
-    }
-    prev = e;
-  }
-
-  // Normalise buckets
-  const total = events.length || 1;
-  for (let i = 0; i < 16; i++) buckets[i] /= total;
-
-  // Pack into hex string
-  return Buffer.from(buckets.buffer).toString('hex').slice(0, 32);
-}
-
-function _similarityScore(fpA, fpB) {
-  if (fpA === fpB) return 1.0;
-  // Simple hamming-based similarity on hex fingerprints
-  let matches = 0;
-  const len   = Math.min(fpA.length, fpB.length);
-  for (let i = 0; i < len; i++) {
-    if (fpA[i] === fpB[i]) matches++;
-  }
-  return matches / len;
-}
-
-// ── Core operations ───────────────────────────────────────────────────────────
-
-/**
- * Add a new pattern to the store (starts in probation).
- * Runs duplicate check — returns null if too similar to existing elite.
- *
- * @param {object} pattern  — { name, category, description, events, viewport }
- * @returns {{ id, tier, duplicate } | null}
- */
-function addPattern(pattern) {
-  const db = getDB();
-
-  const events      = pattern.events || [];
-  const fingerprint = _fingerprintPattern(events);
-  const id          = crypto.randomUUID();
-
-  // Duplicate check against elite + active patterns
-  const existing = db.prepare(
-    `SELECT fingerprint FROM patterns WHERE tier IN ('elite','active')`
-  ).all();
-
-  for (const row of existing) {
-    const sim = _similarityScore(fingerprint, row.fingerprint);
-    if (sim >= PRUNE.similarityThresh) {
-      return { id: null, tier: null, duplicate: true, similarity: sim };
-    }
-  }
-
-  db.prepare(`
-    INSERT INTO patterns
-      (id, name, category, tier, score, wins, losses, sessions,
-       created_at, last_win_at, last_used_at, description, profile, fingerprint)
-    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
-  `).run(
-    id,
-    pattern.name || 'unnamed-' + Date.now(),
-    pattern.category || 'custom',
-    'probation',
-    0, 0, 0, 0,
-    Date.now(), null, null,
-    pattern.description || '',
-    JSON.stringify({ events, viewport: pattern.viewport }),
-    fingerprint
-  );
-
-  _prune(db);
-
-  return { id, tier: 'probation', duplicate: false };
-}
-
-/**
- * Record an outcome for a pattern after a session.
- * Updates score, tier, win/loss counts, triggers pruning.
- *
- * @param {string} patternId
- * @param {'pass'|'block'|'captcha'|'unknown'} outcome
- * @param {string} site  — hostname of the target
- */
-function recordOutcome(patternId, outcome, site = '') {
-  const db    = getDB();
-  const row   = db.prepare('SELECT * FROM patterns WHERE id = ?').get(patternId);
-  if (!row) return null;
-
-  const delta = outcome === 'pass'    ?  2 :
-                outcome === 'block'   ? -2 :
-                outcome === 'captcha' ? -1 : 0;
-
-  const newScore   = row.score + delta;
-  const newWins    = outcome === 'pass'  ? row.wins   + 1 : row.wins;
-  const newLosses  = (outcome === 'block' || outcome === 'captcha') ? row.losses + 1 : row.losses;
-  const lastWinAt  = outcome === 'pass'  ? Date.now() : row.last_win_at;
-
-  // Determine new tier
-  let tier = row.tier;
-  if (newScore <= PRUNE.minScore) {
-    tier = 'retired';
-  } else if (newWins >= 3 && newLosses === 0 && tier === 'active') {
-    // Promote to elite if elite has room
-    const eliteCount = db.prepare(`SELECT COUNT(*) as n FROM patterns WHERE tier = 'elite'`).get().n;
-    if (eliteCount < TIER_CAPS.elite) tier = 'elite';
-    else {
-      // Bump lowest-scored elite to active to make room
-      const lowestElite = db.prepare(
-        `SELECT id FROM patterns WHERE tier = 'elite' ORDER BY score ASC LIMIT 1`
-      ).get();
-      if (lowestElite && newScore > row.score) {
-        db.prepare(`UPDATE patterns SET tier = 'active' WHERE id = ?`).run(lowestElite.id);
-        tier = 'elite';
-      }
-    }
-  } else if (tier === 'probation' && newScore > 0 && row.sessions >= 3) {
-    tier = 'active';
-  }
-
-  db.prepare(`
-    UPDATE patterns SET
-      score = ?, wins = ?, losses = ?, sessions = sessions + 1,
-      last_win_at = ?, last_used_at = ?, tier = ?
-    WHERE id = ?
-  `).run(newScore, newWins, newLosses, lastWinAt, Date.now(), tier, patternId);
-
-  db.prepare(`
-    INSERT INTO pattern_log (pattern_id, outcome, site, score_delta, logged_at)
-    VALUES (?,?,?,?,?)
-  `).run(patternId, outcome, site, delta, Date.now());
-
-  // If retired, remove immediately
-  if (tier === 'retired') {
-    db.prepare('DELETE FROM patterns WHERE id = ?').run(patternId);
-  }
-
-  _prune(db);
-
-  return { id: patternId, tier, score: newScore, wins: newWins, losses: newLosses };
-}
-
-/**
- * Pick a pattern for use, weighted by tier.
- * @param {string} category  — filter by category (optional)
- * @returns {{ id, name, events, viewport, tier } | null}
- */
-function pickPattern(category = null) {
-  const db = getDB();
-
-  // Roll for tier
-  const roll = Math.random();
-  let   tier;
-  if      (roll < TIER_WEIGHTS.elite)                              tier = 'elite';
-  else if (roll < TIER_WEIGHTS.elite + TIER_WEIGHTS.active)        tier = 'active';
-  else                                                              tier = 'probation';
-
-  // Try preferred tier first, fall back up if empty
-  const tierOrder = tier === 'elite'     ? ['elite', 'active', 'probation'] :
-                    tier === 'active'    ? ['active', 'elite', 'probation'] :
-                                          ['probation', 'active', 'elite'];
-
-  for (const t of tierOrder) {
-    const where = category
-      ? `tier = '${t}' AND category = '${category.replace(/'/g,"''")}'`
-      : `tier = '${t}'`;
-
-    const rows = db.prepare(
-      `SELECT * FROM patterns WHERE ${where} ORDER BY score DESC`
-    ).all();
-
-    if (!rows.length) continue;
-
-    // Weighted random within tier — higher score = higher probability
-    const minScore = Math.min(...rows.map(r => r.score));
-    const weights  = rows.map(r => Math.max(0.1, r.score - minScore + 1));
-    const total    = weights.reduce((a, b) => a + b, 0);
-    let   pick     = Math.random() * total;
-    for (let i = 0; i < rows.length; i++) {
-      pick -= weights[i];
-      if (pick <= 0) {
-        const profile = JSON.parse(rows[i].profile);
-        return {
-          id:       rows[i].id,
-          name:     rows[i].name,
-          tier:     rows[i].tier,
-          score:    rows[i].score,
-          events:   profile.events,
-          viewport: profile.viewport,
-        };
-      }
-    }
-
-    // Fallback: return last row
-    const last    = rows[rows.length - 1];
-    const profile = JSON.parse(last.profile);
-    return { id: last.id, name: last.name, tier: last.tier, score: last.score,
-             events: profile.events, viewport: profile.viewport };
-  }
-
-  return null; // no patterns in store
-}
-
-/**
- * Get all patterns summary (for MCP tool / stats).
- */
-function storeStats() {
-  const db = getDB();
-  const counts = db.prepare(`
-    SELECT tier, COUNT(*) as n, AVG(score) as avg_score,
-           SUM(wins) as total_wins, SUM(losses) as total_losses
-    FROM patterns GROUP BY tier
-  `).all();
-
-  const total = db.prepare('SELECT COUNT(*) as n FROM patterns').get().n;
-  const log   = db.prepare(
-    'SELECT COUNT(*) as n FROM pattern_log WHERE logged_at > ?'
-  ).get(Date.now() - 7 * 24 * 3600 * 1000).n;
-
-  return {
-    total,
-    tiers:          counts,
-    sessionsLast7d: log,
-    caps:           TIER_CAPS,
-    pruneRules:     PRUNE,
-  };
-}
-
-/**
- * List patterns with full stats.
- */
-function listPatterns(tier = null) {
-  const db  = getDB();
-  const sql = tier
-    ? `SELECT id,name,category,tier,score,wins,losses,sessions,created_at,last_win_at,description FROM patterns WHERE tier = ? ORDER BY score DESC`
-    : `SELECT id,name,category,tier,score,wins,losses,sessions,created_at,last_win_at,description FROM patterns ORDER BY tier, score DESC`;
-  return tier ? db.prepare(sql).all(tier) : db.prepare(sql).all();
-}
-
-// ── Auto-pruning ──────────────────────────────────────────────────────────────
-
-function _prune(db) {
-  const now = Date.now();
-
-  // 1. Retire stale: no win in 30 days AND score ≤ 0
-  const staleThresh = now - PRUNE.staleDays * 24 * 3600 * 1000;
-  db.prepare(`
-    DELETE FROM patterns
-    WHERE score <= 0
-      AND tier != 'retired'
-      AND (last_win_at IS NULL OR last_win_at < ?)
-      AND created_at < ?
-  `).run(staleThresh, staleThresh);
-
-  // 2. Retire aged: > 90 days old AND score < 5
-  const ageThresh = now - PRUNE.ageDays * 24 * 3600 * 1000;
-  db.prepare(`
-    DELETE FROM patterns WHERE created_at < ? AND score < 5
-  `).run(ageThresh);
-
-  // 3. Cap active tier — keep top 30 by score
-  const activeCount = db.prepare(`SELECT COUNT(*) as n FROM patterns WHERE tier = 'active'`).get().n;
-  if (activeCount > TIER_CAPS.active) {
-    const toDelete = activeCount - TIER_CAPS.active;
-    db.prepare(`
-      DELETE FROM patterns WHERE id IN (
-        SELECT id FROM patterns WHERE tier = 'active' ORDER BY score ASC LIMIT ?
-      )
-    `).run(toDelete);
-  }
-
-  // 4. Cap probation tier — keep top 20 by score, prefer newer
-  const probCount = db.prepare(`SELECT COUNT(*) as n FROM patterns WHERE tier = 'probation'`).get().n;
-  if (probCount > TIER_CAPS.probation) {
-    const toDelete = probCount - TIER_CAPS.probation;
-    db.prepare(`
-      DELETE FROM patterns WHERE id IN (
-        SELECT id FROM patterns WHERE tier = 'probation'
-        ORDER BY score ASC, created_at ASC LIMIT ?
-      )
-    `).run(toDelete);
-  }
-
-  // 5. Prune log table — keep last 1000 entries
-  const logCount = db.prepare('SELECT COUNT(*) as n FROM pattern_log').get().n;
-  if (logCount > 1000) {
-    db.prepare(`
-      DELETE FROM pattern_log WHERE id IN (
-        SELECT id FROM pattern_log ORDER BY logged_at ASC LIMIT ?
-      )
-    `).run(logCount - 1000);
-  }
-}
-
-/**
- * Force a full prune pass (callable from MCP tool).
- */
-function pruneNow() {
-  const db     = getDB();
-  const before = db.prepare('SELECT COUNT(*) as n FROM patterns').get().n;
-  _prune(db);
-  const after  = db.prepare('SELECT COUNT(*) as n FROM patterns').get().n;
-  return { removed: before - after, remaining: after };
-}
-
-/**
- * Seed the store with built-in patterns from cloak-behaviour.js.
- * Only seeds if store is empty. Built-ins start in 'active' tier with score 1.
- */
-function seedBuiltins() {
-  const db = getDB();
-  const existing = db.prepare('SELECT COUNT(*) as n FROM patterns').get().n;
-  if (existing > 0) return { seeded: 0, reason: 'store already has patterns' };
-
-  const { PATTERN_LIBRARY } = require('./cloak-behaviour');
-  let seeded = 0;
-
-  for (const [name, pattern] of Object.entries(PATTERN_LIBRARY)) {
-    const fingerprint = _fingerprintPattern(pattern.events);
-    const id          = crypto.randomUUID();
-    db.prepare(`
-      INSERT INTO patterns
-        (id, name, category, tier, score, wins, losses, sessions,
-         created_at, last_win_at, last_used_at, description, profile, fingerprint)
-      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
-    `).run(
-      id, name, pattern.category,
-      'active',  // built-ins start active, not probation
-      1, 0, 0, 0,
-      Date.now(), null, null,
-      pattern.description || '',
-      JSON.stringify({ events: pattern.events, viewport: pattern.viewport }),
-      fingerprint
-    );
-    seeded++;
-  }
-
-  return { seeded };
-}
-
-module.exports = {
-  addPattern,
-  recordOutcome,
-  pickPattern,
-  storeStats,
-  listPatterns,
-  pruneNow,
-  seedBuiltins,
-};
-
-/** @internal — test use only. Resets the cached DB connection. */
-function _resetDB() { _db = null; }
-
-module.exports._resetDB = _resetDB;