thumbgate 1.14.1 → 1.16.0

package/scripts/lesson-retrieval.js

@@ -1,148 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Per-action lesson retrieval.
- * v3: bi-encoder retrieval → cross-encoder reranking
- *
- * Stage 1 (bi-encoder): score all memories independently using token overlap,
- *   bigram Jaccard, tool-name matching, and recency decay.  Retrieve top-50.
- * Stage 2 (cross-encoder): rerank the top-50 candidates by computing a
- *   field-weighted BM25 score that processes (query, lesson) jointly, then
- *   blend with the original bi-encoder score.  Return top-maxResults.
- */
-
-const RECENCY_DECAY_DAYS = 30;
-const RERANK_CANDIDATE_POOL = 50; // bi-encoder retrieves this many; reranker picks topK
-
-function retrieveRelevantLessons(toolName, actionContext, options = {}) {
-  const { maxResults = 5, feedbackDir } = options;
-  const { getFeedbackPaths, readJSONL } = require('./feedback-loop');
-  const { rerankLessons } = require('./lesson-reranker');
-  const pathMod = require('path');
-  const paths = feedbackDir
-    ? { MEMORY_LOG_PATH: pathMod.join(feedbackDir, 'memory-log.jsonl') }
-    : getFeedbackPaths();
-
-  const memories = readJSONL(paths.MEMORY_LOG_PATH, { maxLines: 200 });
-  if (memories.length === 0) return [];
-
-  const actionSig = buildActionSignature(toolName, actionContext);
-
-  // Stage 1 — bi-encoder: score all memories independently, take top-50 candidates
-  const candidates = memories
-    .map((mem) => ({
-      ...mem,
-      relevanceScore: scoreRelevance(mem, toolName, actionContext, actionSig),
-    }))
-    .filter((m) => m.relevanceScore > 0.1)
-    .sort((a, b) => b.relevanceScore - a.relevanceScore)
-    .slice(0, RERANK_CANDIDATE_POOL);
-
-  if (candidates.length === 0) return [];
-
-  // Stage 2 — cross-encoder reranker: rerank candidates by joint (query, lesson) score
-  const reranked = rerankLessons(actionContext, candidates, {
-    topK: maxResults,
-    toolName,
-  });
-
-  return reranked.map((m) => ({
-    id: m.id,
-    title: m.title,
-    content: m.content,
-    signal: m.tags?.includes('negative') ? 'negative' : 'positive',
-    rule: m.structuredRule || null,
-    relevanceScore: m.rerankedScore ?? m.relevanceScore,
-    timestamp: m.timestamp,
-  }));
-}
-
-function buildActionSignature(toolName, actionContext) {
-  const toolLower = (toolName || '').toLowerCase();
-  const contextLower = (actionContext || '').toLowerCase();
-  const sigPaths = extractPaths(actionContext);
-  const tokens = tokenize(contextLower);
-  const ngramSet = textBigrams(contextLower);
-  return { toolLower, contextLower, paths: sigPaths, tokens, ngramSet };
-}
-
-function textBigrams(text) {
-  const normalized = (text || '')
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-  const set = new Set();
-  for (let i = 0; i < normalized.length - 1; i++) {
-    set.add(normalized.slice(i, i + 2));
-  }
-  return set;
-}
-
-function bigramJaccard(setA, setB) {
-  if (setA.size === 0 && setB.size === 0) return 1;
-  if (setA.size === 0 || setB.size === 0) return 0;
-  let intersection = 0;
-  for (const item of setA) {
-    if (setB.has(item)) intersection++;
-  }
-  const union = setA.size + setB.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-
-function scoreRelevance(memory, toolName, actionContext, actionSig) {
-  const sig = actionSig || buildActionSignature(toolName, actionContext);
-  let score = 0;
-
-  const memText = ((memory.title || '') + ' ' + (memory.content || '') + ' ' + (memory.tags || []).join(' ')).toLowerCase();
-
-  if (memory.metadata?.toolsUsed?.some((t) => t.toLowerCase() === sig.toolLower)) score += 0.4;
-  if (memText.includes(sig.toolLower)) score += 0.2;
-
-  const memPaths = memory.metadata?.filesInvolved || extractPaths(memText);
-  const pathOverlap = sig.paths.filter((p) =>
-    memPaths.some((mp) => mp.includes(p) || p.includes(mp)),
-  );
-  if (pathOverlap.length > 0) score += 0.3;
-
-  const memTokens = tokenize(memText);
-  const overlap = sig.tokens.filter((t) => memTokens.includes(t));
-  score += Math.min(overlap.length * 0.05, 0.3);
-
-  // Fuzzy n-gram matching (only when there is already signal)
-  if (score > 0) {
-    const memBigrams = textBigrams(memText);
-    const fuzzyScore = bigramJaccard(sig.ngramSet, memBigrams);
-    score += fuzzyScore * 0.2;
-  }
-
-  if (memory.tags?.includes('negative')) score += 0.1;
-
-  if (memory.timestamp) {
-    const ageMs = Date.now() - new Date(memory.timestamp).getTime();
-    const ageDays = ageMs / (1000 * 60 * 60 * 24);
-    const decay = Math.max(0, 1 - ageDays / RECENCY_DECAY_DAYS);
-    score *= 0.5 + 0.5 * decay;
-  }
-
-  if (memory.structuredRule) score += 0.15;
-
-  return score;
-}
-
-function extractPaths(text) {
-  return [...new Set((text || '').match(/(?:src\/|scripts\/|tests\/)[^\s,)'"<>]+/g) || [])];
-}
-
-function tokenize(text) {
-  return (text || '').split(/[\s.,;:!?()\[\]{}"'`]+/).filter((t) => t.length > 3);
-}
-
-module.exports = {
-  retrieveRelevantLessons,
-  scoreRelevance,
-  buildActionSignature,
-  textBigrams,
-  bigramJaccard,
-};

package/scripts/managed-lesson-agent.js

@@ -1,183 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { resolveFeedbackDir } = require('./feedback-paths');
-const { parseFeedbackFile, classifySignal, analyzeWithLLM, analyze, promoteToGates } = require('./feedback-to-rules');
-const { inferStructuredLessonLLM, inferStructuredLesson, createLesson } = require('./lesson-inference');
-const { isAvailable } = require('./llm-client');
-
-const MAX_ENTRIES_PER_RUN = 20;
-const DELAY_BETWEEN_CALLS_MS = 500;
-const MANIFEST_DIR = path.join(os.homedir(), '.thumbgate');
-const MANIFEST_PATH = path.join(MANIFEST_DIR, 'managed-agent-runs.jsonl');
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function getProcessedIds() {
-  if (!fs.existsSync(MANIFEST_PATH)) return new Set();
-  const ids = new Set();
-  for (const line of fs.readFileSync(MANIFEST_PATH, 'utf8').split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const run = JSON.parse(trimmed);
-      if (Array.isArray(run.processedIds)) {
-        for (const id of run.processedIds) ids.add(id);
-      }
-    } catch { /* skip */ }
-  }
-  return ids;
-}
-
-function writeManifest(manifest) {
-  fs.mkdirSync(MANIFEST_DIR, { recursive: true });
-  fs.appendFileSync(MANIFEST_PATH, JSON.stringify(manifest) + '\n');
-}
-
-function getManagedAgentStatus() {
-  if (!fs.existsSync(MANIFEST_PATH)) return null;
-  const lines = fs.readFileSync(MANIFEST_PATH, 'utf8').split('\n').filter(Boolean);
-  if (lines.length === 0) return null;
-  try {
-    const last = JSON.parse(lines[lines.length - 1]);
-    return {
-      lastRun: last.runAt,
-      entriesProcessed: last.entriesProcessed,
-      lessonsCreated: last.lessonsCreated,
-      gatesPromoted: last.gatesPromoted,
-      model: last.model,
-      durationMs: last.durationMs,
-      totalRuns: lines.length,
-    };
-  } catch {
-    return null;
-  }
-}
-
-async function runManagedAgent({ dryRun = false, limit, model } = {}) {
-  const startTime = Date.now();
-  const feedbackDir = resolveFeedbackDir();
-  const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
-  const entries = parseFeedbackFile(logPath);
-
-  if (entries.length === 0) {
-    return { entriesProcessed: 0, lessonsCreated: 0, gatesPromoted: 0, model: 'none', durationMs: 0, message: 'No feedback entries found' };
-  }
-
-  const processedIds = getProcessedIds();
-  const pending = entries
-    .filter((e) => {
-      const id = e.id || e.feedbackId || e.timestamp;
-      return id && !processedIds.has(id);
-    })
-    .slice(0, limit || MAX_ENTRIES_PER_RUN);
-
-  if (pending.length === 0) {
-    return { entriesProcessed: 0, lessonsCreated: 0, gatesPromoted: 0, model: 'none', durationMs: Date.now() - startTime, message: 'All entries already processed' };
-  }
-
-  const useLLM = isAvailable();
-  const modelUsed = useLLM ? 'claude-haiku-4-5' : 'heuristic';
-  let lessonsCreated = 0;
-  const newProcessedIds = [];
-
-  for (const entry of pending) {
-    const id = entry.id || entry.feedbackId || entry.timestamp;
-    const signal = classifySignal(entry);
-    if (!signal) {
-      newProcessedIds.push(id);
-      continue;
-    }
-
-    const window = Array.isArray(entry.conversationWindow) ? entry.conversationWindow : [];
-    const context = entry.context || '';
-
-    let structuredLesson = null;
-    if (useLLM) {
-      structuredLesson = await inferStructuredLessonLLM(window, signal, context);
-      if (structuredLesson && !dryRun) {
-        await sleep(DELAY_BETWEEN_CALLS_MS);
-      }
-    }
-
-    if (!structuredLesson) {
-      structuredLesson = inferStructuredLesson(window, signal, context);
-    }
-
-    if (!dryRun && structuredLesson) {
-      try {
-        createLesson({
-          feedbackId: id,
-          signal,
-          inferredLesson: structuredLesson.action?.description || '',
-          triggerMessage: structuredLesson.examples?.[0]?.assistantAction || '',
-          priorSummary: '',
-          confidence: structuredLesson.confidence || 0.5,
-          tags: structuredLesson.tags || entry.tags || [],
-          metadata: { ...structuredLesson.metadata, managedAgent: true, format: structuredLesson.format },
-        });
-        lessonsCreated++;
-      } catch { /* lesson creation is best-effort */ }
-    } else if (dryRun && structuredLesson) {
-      lessonsCreated++;
-    }
-
-    newProcessedIds.push(id);
-  }
-
-  // Rule generation pass
-  let gatesPromoted = 0;
-  if (useLLM) {
-    const llmIssues = await analyzeWithLLM(entries);
-    if (llmIssues && llmIssues.length > 0) {
-      if (!dryRun) {
-        promoteToGates(llmIssues);
-      }
-      gatesPromoted = llmIssues.filter((i) => i.severity === 'critical').length;
-    }
-  } else {
-    const report = analyze(entries);
-    gatesPromoted = report.recurringIssues.filter((i) => i.severity === 'critical').length;
-  }
-
-  const manifest = {
-    runAt: new Date().toISOString(),
-    entriesProcessed: pending.length,
-    lessonsCreated,
-    gatesPromoted,
-    model: modelUsed,
-    dryRun,
-    durationMs: Date.now() - startTime,
-    processedIds: newProcessedIds,
-  };
-
-  if (!dryRun) {
-    writeManifest(manifest);
-  }
-
-  return manifest;
-}
-
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const dryRun = args.includes('--dry-run');
-  const limitFlag = args.find((a) => a.startsWith('--limit'));
-  const limit = limitFlag ? Number(args[args.indexOf(limitFlag) + 1]) || MAX_ENTRIES_PER_RUN : undefined;
-
-  runManagedAgent({ dryRun, limit })
-    .then((result) => {
-      console.log(JSON.stringify(result, null, 2));
-      process.exit(0);
-    })
-    .catch((err) => {
-      console.error('Managed agent error:', err.message);
-      process.exit(1);
-    });
-}
-
-module.exports = { runManagedAgent, getManagedAgentStatus };

package/scripts/operational-dashboard.js

@@ -1,103 +0,0 @@
-'use strict';
-
-const { resolveAnalyticsWindow } = require('./analytics-window');
-const { getBillingSummaryLive } = require('./billing');
-const { generateDashboard } = require('./dashboard');
-const { getFeedbackPaths } = require('./feedback-loop');
-const { resolveHostedBillingConfig } = require('./hosted-config');
-
-function normalizeText(value) {
-  if (value === undefined || value === null) return null;
-  const text = String(value).trim();
-  return text || null;
-}
-
-function shouldPreferHostedDashboard() {
-  return String(process.env.THUMBGATE_METRICS_SOURCE || '').trim().toLowerCase() !== 'local';
-}
-
-function resolveHostedDashboardConfig() {
-  const runtimeConfig = resolveHostedBillingConfig();
-  const apiBaseUrl = normalizeText(process.env.THUMBGATE_BILLING_API_BASE_URL) || runtimeConfig.billingApiBaseUrl;
-  const apiKey = normalizeText(process.env.THUMBGATE_API_KEY);
-  return {
-    apiBaseUrl,
-    apiKey,
-  };
-}
-
-async function buildOperationalDashboard(options = {}) {
-  const analyticsWindow = resolveAnalyticsWindow(options);
-  const feedbackDir = options.feedbackDir || getFeedbackPaths().FEEDBACK_DIR;
-  const billingSummary = await getBillingSummaryLive(analyticsWindow);
-
-  return generateDashboard(feedbackDir, {
-    analyticsWindow,
-    billingSummary,
-    billingSource: 'live',
-    billingFallbackReason: null,
-  });
-}
-
-async function fetchHostedDashboard(options = {}, config = resolveHostedDashboardConfig()) {
-  const analyticsWindow = resolveAnalyticsWindow(options);
-  if (!shouldPreferHostedDashboard()) {
-    const err = new Error('Hosted operational dashboard is disabled.');
-    err.code = 'hosted_dashboard_disabled';
-    throw err;
-  }
-  if (!config.apiBaseUrl || !config.apiKey) {
-    const err = new Error('Hosted operational dashboard is not configured.');
-    err.code = 'hosted_dashboard_unconfigured';
-    throw err;
-  }
-
-  const requestUrl = new URL('/v1/dashboard', config.apiBaseUrl);
-  requestUrl.searchParams.set('window', analyticsWindow.window);
-  requestUrl.searchParams.set('timezone', analyticsWindow.timeZone);
-  requestUrl.searchParams.set('now', analyticsWindow.now);
-
-  const response = await fetch(requestUrl, {
-    method: 'GET',
-    headers: {
-      authorization: `Bearer ${config.apiKey}`,
-      accept: 'application/json',
-    },
-  });
-
-  if (!response.ok) {
-    const detail = await response.text().catch(() => '');
-    const err = new Error(`Hosted operational dashboard request failed (${response.status}): ${detail || 'unknown error'}`);
-    err.code = 'hosted_dashboard_http_error';
-    err.status = response.status;
-    throw err;
-  }
-
-  return response.json();
-}
-
-async function getOperationalDashboard(options = {}) {
-  const analyticsWindow = resolveAnalyticsWindow(options);
-  try {
-    const data = await fetchHostedDashboard(analyticsWindow);
-    return {
-      source: 'hosted',
-      data,
-      fallbackReason: null,
-    };
-  } catch (err) {
-    return {
-      source: 'local',
-      data: await buildOperationalDashboard(analyticsWindow),
-      fallbackReason: err && err.message ? err.message : 'hosted_dashboard_unavailable',
-    };
-  }
-}
-
-module.exports = {
-  buildOperationalDashboard,
-  fetchHostedDashboard,
-  getOperationalDashboard,
-  resolveHostedDashboardConfig,
-  shouldPreferHostedDashboard,
-};

package/scripts/operational-summary.js

@@ -1,129 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const { getBillingSummaryLive } = require('./billing');
-const { resolveAnalyticsWindow } = require('./analytics-window');
-const { resolveHostedBillingConfig } = require('./hosted-config');
-
-// Configure fetch proxy when running behind a corporate/sandbox proxy
-(function configureProxy() {
-  const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy
-    || process.env.HTTP_PROXY || process.env.http_proxy;
-  if (!proxyUrl) return;
-  try {
-    const { ProxyAgent, setGlobalDispatcher } = require('undici');
-    setGlobalDispatcher(new ProxyAgent(proxyUrl));
-  } catch {
-    // undici not available — fetch will use default dispatcher
-  }
-}());
-
-const OPERATOR_CONFIG_PATH = path.join(os.homedir(), '.config', 'thumbgate', 'operator.json');
-
-function normalizeText(value) {
-  if (value === undefined || value === null) return null;
-  const text = String(value).trim();
-  return text || null;
-}
-
-function loadOperatorConfig(configPath = OPERATOR_CONFIG_PATH) {
-  try {
-    const raw = fs.readFileSync(configPath, 'utf8');
-    const parsed = JSON.parse(raw);
-    return {
-      operatorKey: normalizeText(parsed.operatorKey),
-      baseUrl: normalizeText(parsed.baseUrl),
-    };
-  } catch {
-    return { operatorKey: null, baseUrl: null };
-  }
-}
-
-function shouldPreferHostedSummary() {
-  return String(process.env.THUMBGATE_METRICS_SOURCE || '').trim().toLowerCase() !== 'local';
-}
-
-function resolveHostedSummaryConfig() {
-  const runtimeConfig = resolveHostedBillingConfig();
-  const operatorConfig = loadOperatorConfig();
-  // Priority: env THUMBGATE_OPERATOR_KEY > local config file > env THUMBGATE_API_KEY
-  const apiKey = normalizeText(process.env.THUMBGATE_OPERATOR_KEY)
-    || operatorConfig.operatorKey
-    || normalizeText(process.env.THUMBGATE_API_KEY);
-  const apiBaseUrl = normalizeText(process.env.THUMBGATE_BILLING_API_BASE_URL)
-    || operatorConfig.baseUrl
-    || runtimeConfig.billingApiBaseUrl;
-  return {
-    apiBaseUrl,
-    apiKey,
-  };
-}
-
-async function fetchHostedBillingSummary(options = {}, config = resolveHostedSummaryConfig()) {
-  const analyticsWindow = resolveAnalyticsWindow(options);
-  if (!shouldPreferHostedSummary()) {
-    const err = new Error('Hosted operational summary is disabled.');
-    err.code = 'hosted_summary_disabled';
-    throw err;
-  }
-  if (!config.apiBaseUrl || !config.apiKey) {
-    const err = new Error('Hosted operational summary is not configured.');
-    err.code = 'hosted_summary_unconfigured';
-    throw err;
-  }
-
-  const requestUrl = new URL('/v1/billing/summary', config.apiBaseUrl);
-  requestUrl.searchParams.set('window', analyticsWindow.window);
-  requestUrl.searchParams.set('timezone', analyticsWindow.timeZone);
-  if (options.now !== undefined && options.now !== null && options.now !== '') {
-    requestUrl.searchParams.set('now', analyticsWindow.now);
-  }
-
-  const response = await fetch(requestUrl, {
-    method: 'GET',
-    headers: {
-      authorization: `Bearer ${config.apiKey}`,
-      accept: 'application/json',
-    },
-  });
-
-  if (!response.ok) {
-    const detail = await response.text().catch(() => '');
-    const err = new Error(`Hosted operational summary request failed (${response.status}): ${detail || 'unknown error'}`);
-    err.code = 'hosted_summary_http_error';
-    err.status = response.status;
-    throw err;
-  }
-
-  return response.json();
-}
-
-async function getOperationalBillingSummary(options = {}) {
-  const analyticsWindow = resolveAnalyticsWindow(options);
-  try {
-    const summary = await fetchHostedBillingSummary(analyticsWindow);
-    return {
-      source: 'hosted',
-      summary,
-      fallbackReason: null,
-    };
-  } catch (err) {
-    const reason = err && err.message ? err.message : 'hosted_summary_unavailable';
-    console.warn(`[operational-summary] Hosted billing unavailable — falling back to local state. Reason: ${reason}`);
-    return {
-      source: 'local',
-      summary: await getBillingSummaryLive(analyticsWindow),
-      fallbackReason: reason,
-    };
-  }
-}
-
-module.exports = {
-  fetchHostedBillingSummary,
-  getOperationalBillingSummary,
-  resolveHostedSummaryConfig,
-  shouldPreferHostedSummary,
-  loadOperatorConfig,
-};