@symerian/symi 3.0.18 → 3.0.19

package/extensions/learning-loop/src/db.ts

@@ -1,583 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { DatabaseSync } from "node:sqlite";
-import { requireNodeSqlite } from "../../../src/memory/sqlite.js";
-import type { PluginLogger } from "../../../src/plugins/types.js";
-import { type EWMAState, updateEWMA, getEWMAValue } from "./math/ewma.js";
-import { initializeSchema } from "./schema.js";
-import type {
-  LearningLoopConfig,
-  RunRow,
-  ToolCallRow,
-  LearningRow,
-  FeedbackRow,
-  MetricsBucketRow,
-  CompletedRun,
-  QualityScore,
-  LearningRecord,
-  FeedbackRecord,
-  EdgeRow,
-} from "./types.js";
-import { ALGORITHM_VERSION } from "./types.js";
-
-export type DatabaseManager = ReturnType<typeof createDatabaseManager>;
-
-export function createDatabaseManager(params: {
-  stateDir: string;
-  config: LearningLoopConfig;
-  logger: PluginLogger;
-}) {
-  const { stateDir, config, logger } = params;
-  const dbPath = path.join(stateDir, "learning-loop.db");
-
-  // Ensure state directory exists
-  fs.mkdirSync(stateDir, { recursive: true });
-
-  const { DatabaseSync } = requireNodeSqlite();
-  const db = new DatabaseSync(dbPath);
-  initializeSchema(db);
-
-  // --- Runs ---
-
-  function insertRun(run: CompletedRun, score: QualityScore): void {
-    db.prepare(`
-      INSERT INTO runs (
-        run_id, session_id, session_key, agent_id,
-        provider, model, prompt_hash, prompt_length,
-        response_length, response_tool_call_count,
-        usage_input, usage_output, usage_cache_read, usage_cache_write, usage_total,
-        success, error, duration_ms,
-        quality_score, algorithm_version,
-        started_at, completed_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      run.runId,
-      run.sessionId,
-      run.sessionKey,
-      run.agentId,
-      run.provider,
-      run.model,
-      run.promptHash,
-      run.promptLength,
-      run.responseLength,
-      run.responseToolCallCount,
-      run.usage.input ?? 0,
-      run.usage.output ?? 0,
-      run.usage.cacheRead ?? 0,
-      run.usage.cacheWrite ?? 0,
-      run.usage.total ?? 0,
-      run.success ? 1 : 0,
-      run.error,
-      run.durationMs,
-      score.score,
-      score.algorithmVersion,
-      run.startedAt,
-      run.completedAt,
-    );
-
-    // Insert tool calls
-    if (run.toolCalls.length > 0) {
-      const stmt = db.prepare(`
-        INSERT INTO tool_calls (run_id, tool_name, duration_ms, success, error, param_hash)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `);
-      for (const tc of run.toolCalls) {
-        stmt.run(run.runId, tc.toolName, tc.durationMs, tc.success ? 1 : 0, tc.error, tc.paramHash);
-      }
-    }
-
-    // Insert quality signals
-    if (score.signals.length > 0) {
-      const stmt = db.prepare(`
-        INSERT INTO quality_signals (run_id, signal_name, value, confidence, weight)
-        VALUES (?, ?, ?, ?, ?)
-      `);
-      for (const sig of score.signals) {
-        stmt.run(run.runId, sig.name, sig.value, sig.confidence, sig.weight);
-      }
-    }
-  }
-
-  function getRun(runId: string): RunRow | undefined {
-    return db.prepare(`SELECT * FROM runs WHERE run_id = ?`).get(runId) as RunRow | undefined;
-  }
-
-  function getRunCount(): number {
-    const row = db
-      .prepare(`SELECT COUNT(*) as cnt FROM runs WHERE run_id != '__pruned__'`)
-      .get() as { cnt: number };
-    return row.cnt;
-  }
-
-  function getToolCalls(runId: string): ToolCallRow[] {
-    return db.prepare(`SELECT * FROM tool_calls WHERE run_id = ?`).all(runId) as ToolCallRow[];
-  }
-
-  function getRecentRuns(limit: number = 100): RunRow[] {
-    return db
-      .prepare(`SELECT * FROM runs ORDER BY completed_at DESC LIMIT ?`)
-      .all(limit) as RunRow[];
-  }
-
-  function getRunsByModel(provider: string, model: string, limit: number = 100): RunRow[] {
-    return db
-      .prepare(
-        `SELECT * FROM runs WHERE provider = ? AND model = ? ORDER BY completed_at DESC LIMIT ?`,
-      )
-      .all(provider, model, limit) as RunRow[];
-  }
-
-  // --- EWMA State ---
-
-  function getEwmaState(provider: string, model: string, metric: string): EWMAState {
-    const row = db
-      .prepare(
-        `SELECT value, count FROM ewma_state WHERE provider = ? AND model = ? AND metric = ?`,
-      )
-      .get(provider, model, metric) as { value: number; count: number } | undefined;
-    return row ?? { value: 0, count: 0 };
-  }
-
-  function updateEwmaState(
-    provider: string,
-    model: string,
-    metric: string,
-    observation: number,
-    alpha: number = 0.1,
-  ): EWMAState {
-    const current = getEwmaState(provider, model, metric);
-    const updated = updateEWMA(current, observation, alpha);
-    db.prepare(`
-      INSERT INTO ewma_state (provider, model, metric, value, count)
-      VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(provider, model, metric) DO UPDATE SET
-        value = excluded.value,
-        count = excluded.count
-    `).run(provider, model, metric, updated.value, updated.count);
-    return updated;
-  }
-
-  // --- Learnings ---
-
-  function insertLearning(learning: LearningRecord): void {
-    db.prepare(`
-      INSERT INTO learnings (id, run_id, category, content, embedding, confidence, applied_count, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      learning.id,
-      learning.runId,
-      learning.category,
-      learning.content,
-      learning.embedding ? JSON.stringify(learning.embedding) : null,
-      learning.confidence,
-      learning.appliedCount,
-      learning.createdAt,
-      learning.updatedAt,
-    );
-  }
-
-  function getLearning(id: string): LearningRow | undefined {
-    return db.prepare(`SELECT * FROM learnings WHERE id = ?`).get(id) as LearningRow | undefined;
-  }
-
-  function getAllLearnings(limit: number = 1000): LearningRow[] {
-    return db
-      .prepare(`SELECT * FROM learnings ORDER BY updated_at DESC LIMIT ?`)
-      .all(limit) as LearningRow[];
-  }
-
-  function getLearningsByCategory(category: string, limit: number = 100): LearningRow[] {
-    return db
-      .prepare(`SELECT * FROM learnings WHERE category = ? ORDER BY updated_at DESC LIMIT ?`)
-      .all(category, limit) as LearningRow[];
-  }
-
-  function searchLearningsFts(query: string, limit: number = 20): LearningRow[] {
-    return db
-      .prepare(`
-      SELECT l.* FROM learnings l
-      JOIN learnings_fts fts ON l.rowid = fts.rowid
-      WHERE learnings_fts MATCH ?
-      ORDER BY rank
-      LIMIT ?
-    `)
-      .all(query, limit) as LearningRow[];
-  }
-
-  function incrementAppliedCount(id: string): void {
-    db.prepare(
-      `UPDATE learnings SET applied_count = applied_count + 1, updated_at = ? WHERE id = ?`,
-    ).run(Date.now(), id);
-  }
-
-  function deleteLearning(id: string): void {
-    db.prepare(`DELETE FROM learnings WHERE id = ?`).run(id);
-  }
-
-  function getLearningsWithoutEmbeddings(limit: number): LearningRow[] {
-    return db
-      .prepare(`SELECT * FROM learnings WHERE embedding IS NULL LIMIT ?`)
-      .all(limit) as LearningRow[];
-  }
-
-  function updateLearningEmbedding(id: string, embedding: number[]): void {
-    db.prepare(`UPDATE learnings SET embedding = ? WHERE id = ?`).run(
-      JSON.stringify(embedding),
-      id,
-    );
-  }
-
-  // --- Feedback ---
-
-  function insertFeedback(feedback: FeedbackRecord): void {
-    db.prepare(`
-      INSERT INTO feedback (id, run_id, source, score, created_at)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(feedback.id, feedback.runId, feedback.source, feedback.score, feedback.createdAt);
-  }
-
-  function getFeedback(runId: string): FeedbackRow[] {
-    return db.prepare(`SELECT * FROM feedback WHERE run_id = ?`).all(runId) as FeedbackRow[];
-  }
-
-  // --- Metrics Buckets ---
-
-  function upsertMetricsBucket(
-    provider: string,
-    model: string,
-    completedAt: number,
-    qualityScore: number,
-    durationMs: number,
-    success: boolean,
-    usageInput: number,
-    usageOutput: number,
-  ): void {
-    const bucketHour = new Date(completedAt).toISOString().slice(0, 13);
-    db.prepare(`
-      INSERT INTO metrics_buckets (
-        provider, model, bucket_hour,
-        run_count, success_count,
-        quality_sum, quality_sum_sq,
-        latency_sum, latency_sum_sq,
-        token_input_sum, token_output_sum
-      ) VALUES (?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(provider, model, bucket_hour) DO UPDATE SET
-        run_count = run_count + 1,
-        success_count = success_count + ?,
-        quality_sum = quality_sum + ?,
-        quality_sum_sq = quality_sum_sq + ?,
-        latency_sum = latency_sum + ?,
-        latency_sum_sq = latency_sum_sq + ?,
-        token_input_sum = token_input_sum + ?,
-        token_output_sum = token_output_sum + ?
-    `).run(
-      provider,
-      model,
-      bucketHour,
-      success ? 1 : 0,
-      qualityScore,
-      qualityScore * qualityScore,
-      durationMs,
-      durationMs * durationMs,
-      usageInput,
-      usageOutput,
-      // ON CONFLICT values
-      success ? 1 : 0,
-      qualityScore,
-      qualityScore * qualityScore,
-      durationMs,
-      durationMs * durationMs,
-      usageInput,
-      usageOutput,
-    );
-  }
-
-  function getMetricsBuckets(
-    provider?: string,
-    model?: string,
-    fromHour?: string,
-    toHour?: string,
-  ): MetricsBucketRow[] {
-    const conditions: string[] = [];
-    const params: unknown[] = [];
-
-    if (provider) {
-      conditions.push("provider = ?");
-      params.push(provider);
-    }
-    if (model) {
-      conditions.push("model = ?");
-      params.push(model);
-    }
-    if (fromHour) {
-      conditions.push("bucket_hour >= ?");
-      params.push(fromHour);
-    }
-    if (toHour) {
-      conditions.push("bucket_hour <= ?");
-      params.push(toHour);
-    }
-
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    return db
-      .prepare(`SELECT * FROM metrics_buckets ${where} ORDER BY bucket_hour DESC`)
-      .all(...params) as MetricsBucketRow[];
-  }
-
-  function getModelLeaderboard(): Array<{
-    provider: string;
-    model: string;
-    runCount: number;
-    successRate: number;
-    avgQuality: number;
-    avgLatency: number;
-  }> {
-    return db
-      .prepare(`
-      SELECT
-        provider,
-        model,
-        SUM(run_count) as runCount,
-        CASE WHEN SUM(run_count) > 0
-          THEN CAST(SUM(success_count) AS REAL) / SUM(run_count)
-          ELSE 0 END as successRate,
-        CASE WHEN SUM(run_count) > 0
-          THEN SUM(quality_sum) / SUM(run_count)
-          ELSE 0 END as avgQuality,
-        CASE WHEN SUM(run_count) > 0
-          THEN SUM(latency_sum) / SUM(run_count)
-          ELSE 0 END as avgLatency
-      FROM metrics_buckets
-      GROUP BY provider, model
-      ORDER BY avgQuality DESC
-    `)
-      .all() as Array<{
-      provider: string;
-      model: string;
-      runCount: number;
-      successRate: number;
-      avgQuality: number;
-      avgLatency: number;
-    }>;
-  }
-
-  // --- Graph Edges ---
-
-  function insertEdge(sourceId: string, targetId: string, edgeType: string, weight: number): void {
-    db.prepare(`
-      INSERT INTO learning_edges (source_id, target_id, edge_type, weight, created_at)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(sourceId, targetId, edgeType, weight, Date.now());
-  }
-
-  function upsertEdge(sourceId: string, targetId: string, edgeType: string, weight: number): void {
-    db.prepare(`
-      INSERT INTO learning_edges (source_id, target_id, edge_type, weight, created_at)
-      VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(source_id, target_id, edge_type) DO UPDATE SET
-        weight = excluded.weight,
-        created_at = excluded.created_at
-    `).run(sourceId, targetId, edgeType, weight, Date.now());
-  }
-
-  function getEdgesBySource(id: string): EdgeRow[] {
-    return db.prepare(`SELECT * FROM learning_edges WHERE source_id = ?`).all(id) as EdgeRow[];
-  }
-
-  function getEdgesByTarget(id: string): EdgeRow[] {
-    return db.prepare(`SELECT * FROM learning_edges WHERE target_id = ?`).all(id) as EdgeRow[];
-  }
-
-  function getEdgesByNode(id: string): EdgeRow[] {
-    return db
-      .prepare(`SELECT * FROM learning_edges WHERE source_id = ? OR target_id = ?`)
-      .all(id, id) as EdgeRow[];
-  }
-
-  function getEdgesByType(edgeType: string, limit: number = 1000): EdgeRow[] {
-    return db
-      .prepare(`SELECT * FROM learning_edges WHERE edge_type = ? LIMIT ?`)
-      .all(edgeType, limit) as EdgeRow[];
-  }
-
-  function deleteEdgesForLearning(id: string): void {
-    db.prepare(`DELETE FROM learning_edges WHERE source_id = ? OR target_id = ?`).run(id, id);
-  }
-
-  function getCentralityScore(id: string): number {
-    const row = db.prepare(`SELECT score FROM centrality_scores WHERE learning_id = ?`).get(id) as
-      | { score: number }
-      | undefined;
-    return row?.score ?? 0;
-  }
-
-  function upsertCentralityScore(id: string, score: number): void {
-    db.prepare(`
-      INSERT INTO centrality_scores (learning_id, score, updated_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(learning_id) DO UPDATE SET
-        score = excluded.score,
-        updated_at = excluded.updated_at
-    `).run(id, score, Date.now());
-  }
-
-  function deleteCentralityScore(id: string): void {
-    db.prepare(`DELETE FROM centrality_scores WHERE learning_id = ?`).run(id);
-  }
-
-  // --- Pruning ---
-
-  function ensurePrunedSentinel(): void {
-    const exists = db.prepare(`SELECT 1 FROM runs WHERE run_id = '__pruned__'`).get();
-    if (!exists) {
-      db.prepare(`
-        INSERT INTO runs (
-          run_id, session_id, session_key, agent_id,
-          provider, model, prompt_hash, prompt_length,
-          response_length, response_tool_call_count,
-          usage_input, usage_output, usage_cache_read, usage_cache_write, usage_total,
-          success, error, duration_ms,
-          quality_score, algorithm_version,
-          started_at, completed_at
-        ) VALUES ('__pruned__','','','','','','',0,0,0,0,0,0,0,0,1,NULL,0,NULL,NULL,0,0)
-      `).run();
-    }
-  }
-
-  function pruneOldRuns(maxRuns: number): number {
-    const count = getRunCount();
-    if (count <= maxRuns) return 0;
-
-    const toDelete = count - maxRuns;
-    const oldestRuns = db
-      .prepare(
-        `SELECT run_id FROM runs WHERE run_id != '__pruned__' ORDER BY completed_at ASC LIMIT ?`,
-      )
-      .all(toDelete) as Array<{ run_id: string }>;
-
-    if (oldestRuns.length === 0) return 0;
-
-    db.exec("BEGIN");
-    try {
-      ensurePrunedSentinel();
-      for (const row of oldestRuns) {
-        db.prepare(`DELETE FROM tool_calls WHERE run_id = ?`).run(row.run_id);
-        db.prepare(`DELETE FROM quality_signals WHERE run_id = ?`).run(row.run_id);
-        db.prepare(`DELETE FROM feedback WHERE run_id = ?`).run(row.run_id);
-        db.prepare(`UPDATE learnings SET run_id = '__pruned__' WHERE run_id = ?`).run(row.run_id);
-        db.prepare(`DELETE FROM runs WHERE run_id = ?`).run(row.run_id);
-      }
-      db.exec("COMMIT");
-    } catch (err) {
-      db.exec("ROLLBACK");
-      throw err;
-    }
-
-    return oldestRuns.length;
-  }
-
-  /**
-   * Remove learnings that are genuinely unused: never applied, low confidence,
-   * and older than maxAge (ms). Also cleans up associated graph edges.
-   */
-  function pruneStaleLearnings(maxAge: number): number {
-    const cutoff = Date.now() - maxAge;
-    const stale = db
-      .prepare(
-        `SELECT id FROM learnings WHERE applied_count = 0 AND confidence < 0.5 AND updated_at < ?`,
-      )
-      .all(cutoff) as Array<{ id: string }>;
-
-    if (stale.length === 0) return 0;
-
-    db.exec("BEGIN");
-    try {
-      for (const row of stale) {
-        deleteEdgesForLearning(row.id);
-        deleteCentralityScore(row.id);
-        db.prepare(`DELETE FROM learnings WHERE id = ?`).run(row.id);
-      }
-      db.exec("COMMIT");
-    } catch (err) {
-      db.exec("ROLLBACK");
-      throw err;
-    }
-
-    return stale.length;
-  }
-
-  /**
-   * Update the stored quality score for a run (used when feedback arrives after initial scoring).
-   */
-  function updateRunScore(runId: string, score: number): void {
-    db.prepare(`UPDATE runs SET quality_score = ? WHERE run_id = ?`).run(score, runId);
-  }
-
-  // --- Utility ---
-
-  function getStats(): {
-    runCount: number;
-    learningCount: number;
-    feedbackCount: number;
-  } {
-    const runs = (db.prepare(`SELECT COUNT(*) as cnt FROM runs`).get() as { cnt: number }).cnt;
-    const learnings = (db.prepare(`SELECT COUNT(*) as cnt FROM learnings`).get() as { cnt: number })
-      .cnt;
-    const feedbacks = (db.prepare(`SELECT COUNT(*) as cnt FROM feedback`).get() as { cnt: number })
-      .cnt;
-    return { runCount: runs, learningCount: learnings, feedbackCount: feedbacks };
-  }
-
-  function close(): void {
-    try {
-      db.close();
-    } catch {
-      // Already closed
-    }
-  }
-
-  function raw(): DatabaseSync {
-    return db;
-  }
-
-  return {
-    insertRun,
-    getRun,
-    getRunCount,
-    getToolCalls,
-    getRecentRuns,
-    getRunsByModel,
-    getEwmaState,
-    updateEwmaState,
-    insertLearning,
-    getLearning,
-    getAllLearnings,
-    getLearningsByCategory,
-    searchLearningsFts,
-    incrementAppliedCount,
-    deleteLearning,
-    getLearningsWithoutEmbeddings,
-    updateLearningEmbedding,
-    insertFeedback,
-    getFeedback,
-    upsertMetricsBucket,
-    getMetricsBuckets,
-    getModelLeaderboard,
-    pruneOldRuns,
-    pruneStaleLearnings,
-    updateRunScore,
-    getStats,
-    close,
-    raw,
-    insertEdge,
-    upsertEdge,
-    getEdgesBySource,
-    getEdgesByTarget,
-    getEdgesByNode,
-    getEdgesByType,
-    deleteEdgesForLearning,
-    getCentralityScore,
-    upsertCentralityScore,
-    deleteCentralityScore,
-  };
-}

package/extensions/learning-loop/src/feedback/explicit-feedback.ts

@@ -1,58 +0,0 @@
-/**
- * Explicit feedback handler for user-submitted ratings.
- * Accepts a 1-5 score via gateway RPC and stores it as feedback.
- */
-
-import crypto from "node:crypto";
-import { reconstructCompletedRun } from "../capture/serializer.js";
-import type { DatabaseManager } from "../db.js";
-import type { QualityEngine } from "../scoring/quality-engine.js";
-import type { FeedbackRecord } from "../types.js";
-
-export type ExplicitFeedbackHandler = ReturnType<typeof createExplicitFeedbackHandler>;
-
-export function createExplicitFeedbackHandler(params: {
-  db: DatabaseManager;
-  qualityEngine?: QualityEngine;
-}) {
-  const { db, qualityEngine } = params;
-
-  /**
-   * Submit explicit user feedback for a run.
-   *
-   * @param runId - The run to provide feedback for
-   * @param score - Rating from 1 to 5
-   * @returns The created feedback record, or null if the run doesn't exist
-   */
-  function submitFeedback(runId: string, score: number): FeedbackRecord | null {
-    const runRow = db.getRun(runId);
-    if (!runRow) return null;
-
-    const clampedScore = Math.max(1, Math.min(5, Math.round(score)));
-
-    const feedback: FeedbackRecord = {
-      id: `fb_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`,
-      runId,
-      source: "explicit",
-      score: clampedScore,
-      createdAt: Date.now(),
-    };
-
-    db.insertFeedback(feedback);
-
-    // Close the feedback loop: rescore the run with explicit feedback
-    if (qualityEngine) {
-      const toolCalls = db.getToolCalls(runId);
-      const completedRun = reconstructCompletedRun(runRow, toolCalls);
-      const newScore = qualityEngine.rescoreWithFeedback(completedRun, {
-        source: "explicit",
-        score: clampedScore,
-      });
-      db.updateRunScore(runId, newScore.score);
-    }
-
-    return feedback;
-  }
-
-  return { submitFeedback };
-}