@symerian/symi 3.0.18 → 3.0.19

package/extensions/learning-loop/index.ts

@@ -1,159 +0,0 @@
-import path from "node:path";
-import { resolveMemorySearchConfig } from "../../src/agents/memory-search.js";
-import { createEmbeddingProvider } from "../../src/memory/embeddings.js";
-import type { SymiPluginApi } from "../../src/plugins/types.js";
-import { registerGatewayMethods } from "./src/analytics/gateway-methods.js";
-import { createMetricsAggregator } from "./src/analytics/metrics-aggregator.js";
-import { createRunTracker } from "./src/capture/run-tracker.js";
-import { createDatabaseManager } from "./src/db.js";
-import { createImplicitSignals } from "./src/feedback/implicit-signals.js";
-import { createEdgeInference } from "./src/graph/edge-inference.js";
-import { createGraphRetrieval } from "./src/graph/graph-retrieval.js";
-import { createGraphStore } from "./src/graph/graph-store.js";
-import { registerHooks } from "./src/hooks.js";
-import { createContextInjector } from "./src/injection/context-injector.js";
-import { createEmbeddingBridge, type EmbeddingBridge } from "./src/learning/embedding-bridge.js";
-import { createLearningExtractor } from "./src/learning/learning-extractor.js";
-import { createLearningStore } from "./src/learning/learning-store.js";
-import { createQualityEngine } from "./src/scoring/quality-engine.js";
-import { resolveConfig } from "./src/types.js";
-
-const plugin = {
-  id: "learning-loop",
-  name: "Learning Loop",
-  description:
-    "Closed-loop learning with deterministic quality scoring, pattern extraction, and context injection",
-
-  register(api: SymiPluginApi) {
-    const config = resolveConfig(api.pluginConfig);
-    const logger = api.logger;
-    const rootStateDir = api.runtime.state.resolveStateDir();
-    const stateDir = path.join(rootStateDir, "learning-loop");
-
-    const db = createDatabaseManager({ stateDir, config, logger });
-    const tracker = createRunTracker();
-    const qualityEngine = createQualityEngine({ config, db });
-    const graphStore = createGraphStore({ db });
-    const learningStore = createLearningStore({ db, graphStore });
-    const edgeInference = createEdgeInference({ graphStore, learningStore });
-    const graphRetrieval = createGraphRetrieval({ graphStore, learningStore, config });
-
-    // Lazy embedding bridge: initializes on first use, avoids blocking sync register()
-    let bridgePromise: Promise<EmbeddingBridge> | null = null;
-    let bridgeResolved = false;
-    let bridgeHasProvider = false;
-
-    async function initBridge(): Promise<EmbeddingBridge> {
-      try {
-        const memCfg = resolveMemorySearchConfig(api.config, "main");
-        const result = await createEmbeddingProvider({
-          config: api.config,
-          provider: memCfg?.provider ?? "auto",
-          model: memCfg?.model ?? "",
-          fallback: memCfg?.fallback ?? "none",
-          local: memCfg?.local,
-          remote: memCfg?.remote,
-        });
-        return createEmbeddingBridge({ provider: result.provider, logger });
-      } catch (err) {
-        logger.warn(`[learning-loop] embedding bridge init failed: ${String(err)}`);
-        return createEmbeddingBridge({ provider: null, logger });
-      }
-    }
-
-    async function initAndTrack(): Promise<EmbeddingBridge> {
-      const bridge = await initBridge();
-      bridgeResolved = true;
-      bridgeHasProvider = bridge.available();
-      return bridge;
-    }
-
-    const lazyBridge: EmbeddingBridge = {
-      async embed(text) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embed(text);
-      },
-      async embedBatch(texts) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embedBatch(texts);
-      },
-      available: () => (bridgeResolved ? bridgeHasProvider : true),
-    };
-
-    const extractor = createLearningExtractor({
-      db,
-      learningStore,
-      config,
-      edgeInference,
-      embeddingBridge: lazyBridge,
-    });
-    const injector = createContextInjector({
-      db,
-      learningStore,
-      config,
-      embeddingBridge: lazyBridge,
-      graphRetrieval,
-    });
-    const metrics = createMetricsAggregator({ db });
-    const implicit = createImplicitSignals({ db, config });
-
-    registerHooks(api, {
-      config,
-      logger,
-      db,
-      tracker,
-      qualityEngine,
-      learningStore,
-      extractor,
-      injector,
-      metrics,
-      implicit,
-      edgeInference,
-    });
-
-    registerGatewayMethods(api, {
-      db,
-      learningStore,
-      metrics,
-      injector,
-      qualityEngine,
-      graphStore,
-    });
-
-    // One-time async backfill: embed historical learnings that have no embeddings
-    async function backfillEmbeddings(): Promise<void> {
-      const BATCH_SIZE = 50;
-      let totalBackfilled = 0;
-
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        const rows = db.getLearningsWithoutEmbeddings(BATCH_SIZE);
-        if (rows.length === 0) break;
-
-        const texts = rows.map((r) => r.content);
-        const embeddings = await lazyBridge.embedBatch(texts);
-
-        for (let i = 0; i < rows.length; i++) {
-          const emb = embeddings[i];
-          if (emb) {
-            db.updateLearningEmbedding(rows[i]!.id, emb);
-            totalBackfilled++;
-          }
-        }
-
-        if (rows.length < BATCH_SIZE) break;
-      }
-
-      if (totalBackfilled > 0) {
-        logger.debug?.(`[learning-loop] backfilled embeddings for ${totalBackfilled} learnings`);
-      }
-    }
-
-    // Fire-and-forget: backfill after bridge is ready
-    backfillEmbeddings().catch((err) => {
-      logger.warn(`[learning-loop] embedding backfill failed: ${String(err)}`);
-    });
-  },
-};
-
-export default plugin;

package/extensions/learning-loop/node_modules/.bin/symi

@@ -1,21 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*)
-        if command -v cygpath > /dev/null 2>&1; then
-            basedir=`cygpath -w "$basedir"`
-        fi
-    ;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/symi/projects/symi/node_modules:/home/symi/projects/node_modules:/home/symi/node_modules:/home/node_modules:/node_modules:/home/symi/projects/symi/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/home/symi/projects/symi/node_modules:/home/symi/projects/node_modules:/home/symi/node_modules:/home/node_modules:/node_modules:/home/symi/projects/symi/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../@symerian/symi/symi.mjs" "$@"
-else
-  exec node  "$basedir/../@symerian/symi/symi.mjs" "$@"
-fi

package/extensions/learning-loop/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@symi/learning-loop",
-  "version": "3.0.9",
-  "private": true,
-  "description": "Closed-loop learning extension with deterministic quality scoring and vector-indexed learning storage",
-  "type": "module",
-  "devDependencies": {
-    "@symerian/symi": "workspace:*"
-  },
-  "peerDependencies": {
-    "@symerian/symi": ">=2026.1.26"
-  },
-  "symi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  }
-}

package/extensions/learning-loop/src/analytics/gateway-methods.ts

@@ -1,230 +0,0 @@
-/**
- * Gateway RPC methods for the Glass UI.
- */
-
-import type { SymiPluginApi } from "../../../../src/plugins/types.js";
-import type { DatabaseManager } from "../db.js";
-import { createExplicitFeedbackHandler } from "../feedback/explicit-feedback.js";
-import type { GraphStore } from "../graph/graph-store.js";
-import type { ContextInjector } from "../injection/context-injector.js";
-import type { LearningStore } from "../learning/learning-store.js";
-import type { QualityEngine } from "../scoring/quality-engine.js";
-import type { LearningCategory, EdgeType } from "../types.js";
-import type { MetricsAggregator } from "./metrics-aggregator.js";
-
-export function registerGatewayMethods(
-  api: SymiPluginApi,
-  deps: {
-    db: DatabaseManager;
-    learningStore: LearningStore;
-    metrics: MetricsAggregator;
-    injector: ContextInjector;
-    qualityEngine?: QualityEngine;
-    graphStore?: GraphStore;
-  },
-) {
-  const { db, learningStore, metrics, injector, qualityEngine, graphStore } = deps;
-  const feedbackHandler = createExplicitFeedbackHandler({ db, qualityEngine });
-
-  // learning.metrics.models
-  api.registerGatewayMethod("learning.metrics.models", (opts) => {
-    try {
-      const params = opts.params as { provider?: string; model?: string };
-      const result = metrics.getModelMetrics(params.provider, params.model);
-      opts.respond(true, result);
-    } catch (err) {
-      opts.respond(false, undefined, { code: 500, message: String(err) });
-    }
-  });
-
-  // learning.metrics.timeseries
-  api.registerGatewayMethod("learning.metrics.timeseries", (opts) => {
-    try {
-      const params = opts.params as {
-        provider?: string;
-        model?: string;
-        fromHour?: string;
-        toHour?: string;
-      };
-      const result = metrics.getTimeseries(params);
-      opts.respond(true, result);
-    } catch (err) {
-      opts.respond(false, undefined, { code: 500, message: String(err) });
-    }
-  });
-
-  // learning.metrics.leaderboard
-  api.registerGatewayMethod("learning.metrics.leaderboard", (opts) => {
-    try {
-      const result = metrics.getLeaderboard();
-      opts.respond(true, result);
-    } catch (err) {
-      opts.respond(false, undefined, { code: 500, message: String(err) });
-    }
-  });
-
-  // learning.learnings.list
-  api.registerGatewayMethod("learning.learnings.list", (opts) => {
-    try {
-      const params = opts.params as { category?: string; limit?: number };
-      const result = learningStore.listLearnings({
-        category: params.category as LearningCategory | undefined,
-        limit: params.limit,
-      });
-      opts.respond(true, result);
-    } catch (err) {
-      opts.respond(false, undefined, { code: 500, message: String(err) });
-    }
-  });
-
-  // learning.learnings.search
-  api.registerGatewayMethod("learning.learnings.search", (opts) => {
-    try {
-      const params = opts.params as { query: string; limit?: number };
-      if (!params.query) {
-        opts.respond(false, undefined, { code: 400, message: "query is required" });
-        return;
-      }
-      const result = learningStore.searchByText(params.query, params.limit ?? 20);
-      opts.respond(true, result);
-    } catch (err) {
-      opts.respond(false, undefined, { code: 500, message: String(err) });
-    }
-  });
-
-  // learning.feedback.submit
-  api.registerGatewayMethod("learning.feedback.submit", (opts) => {
-    try {
-      const params = opts.params as { runId: string; score: number };
-      if (!params.runId || params.score == null) {
-        opts.respond(false, undefined, {
-          code: 400,
-          message: "runId and score (1-5) are required",
-        });
-        return;
-      }
-      const result = feedbackHandler.submitFeedback(params.runId, params.score);
-      if (!result) {
-        opts.respond(false, undefined, { code: 404, message: "Run not found" });
-        return;
-      }
-      opts.respond(true, result);
-    } catch (err) {
-      opts.respond(false, undefined, { code: 500, message: String(err) });
-    }
-  });
-
-  // learning.status
-  api.registerGatewayMethod("learning.status", (opts) => {
-    try {
-      const stats = db.getStats();
-      const cacheStats = injector.getCacheStats();
-      opts.respond(true, {
-        ...stats,
-        cache: cacheStats,
-      });
-    } catch (err) {
-      opts.respond(false, undefined, { code: 500, message: String(err) });
-    }
-  });
-
-  // --- Graph methods ---
-
-  if (graphStore) {
-    // learning.graph.edges
-    api.registerGatewayMethod("learning.graph.edges", (opts) => {
-      try {
-        const params = opts.params as { learningId: string; typeFilter?: EdgeType[] };
-        if (!params.learningId) {
-          opts.respond(false, undefined, { code: 400, message: "learningId is required" });
-          return;
-        }
-        const edges = graphStore.getEdges(params.learningId, {
-          typeFilter: params.typeFilter,
-        });
-        opts.respond(true, edges);
-      } catch (err) {
-        opts.respond(false, undefined, { code: 500, message: String(err) });
-      }
-    });
-
-    // learning.graph.neighbors
-    api.registerGatewayMethod("learning.graph.neighbors", (opts) => {
-      try {
-        const params = opts.params as {
-          learningId: string;
-          hops?: number;
-          typeFilter?: EdgeType[];
-        };
-        if (!params.learningId) {
-          opts.respond(false, undefined, { code: 400, message: "learningId is required" });
-          return;
-        }
-        const neighbors = graphStore.getNeighbors(
-          params.learningId,
-          params.hops ?? 1,
-          params.typeFilter,
-        );
-        // Convert Map to serializable object
-        const result: Array<{ id: string; weight: number }> = [];
-        for (const [id, weight] of neighbors) {
-          result.push({ id, weight });
-        }
-        opts.respond(true, result);
-      } catch (err) {
-        opts.respond(false, undefined, { code: 500, message: String(err) });
-      }
-    });
-
-    // learning.graph.contradictions
-    api.registerGatewayMethod("learning.graph.contradictions", (opts) => {
-      try {
-        const params = opts.params as { learningId?: string } | undefined;
-        const contradictions = graphStore.getContradictions(params?.learningId);
-        opts.respond(true, contradictions);
-      } catch (err) {
-        opts.respond(false, undefined, { code: 500, message: String(err) });
-      }
-    });
-
-    // learning.graph.stats
-    api.registerGatewayMethod("learning.graph.stats", (opts) => {
-      try {
-        const edgeTypes: EdgeType[] = ["T", "S", "C", "U", "X", "R"];
-        const countsByType: Record<string, number> = {};
-        let totalEdges = 0;
-        for (const t of edgeTypes) {
-          const edges = db.getEdgesByType(t);
-          countsByType[t] = edges.length;
-          totalEdges += edges.length;
-        }
-
-        const learnings = db.getAllLearnings(10000);
-        let centralitySum = 0;
-        let centralityCount = 0;
-        for (const l of learnings) {
-          const score = db.getCentralityScore(l.id);
-          if (score > 0) {
-            centralitySum += score;
-            centralityCount++;
-          }
-        }
-
-        const avgCentrality = centralityCount > 0 ? centralitySum / centralityCount : 0;
-        const nodeCount = learnings.length;
-        const maxEdges = nodeCount > 1 ? (nodeCount * (nodeCount - 1)) / 2 : 0;
-        const density = maxEdges > 0 ? totalEdges / maxEdges : 0;
-
-        opts.respond(true, {
-          totalEdges,
-          countsByType,
-          avgCentrality,
-          nodeCount,
-          density,
-        });
-      } catch (err) {
-        opts.respond(false, undefined, { code: 500, message: String(err) });
-      }
-    });
-  }
-}

package/extensions/learning-loop/src/analytics/metrics-aggregator.ts

@@ -1,153 +0,0 @@
-/**
- * Pre-aggregated time bucket metrics.
- *
- * Uses O(1) upsert per run via SQLite's ON CONFLICT UPDATE.
- * Variance computed via: var = sum_sq/n - (sum/n)^2
- */
-
-import type { DatabaseManager } from "../db.js";
-import { wilsonScoreLowerBound } from "../math/confidence-intervals.js";
-import type { CompletedRun, QualityScore, MetricsBucketRow } from "../types.js";
-
-export type MetricsAggregator = ReturnType<typeof createMetricsAggregator>;
-
-export function createMetricsAggregator(params: { db: DatabaseManager }) {
-  const { db } = params;
-
-  /**
-   * Record a completed run in the metrics buckets. O(1) upsert.
-   */
-  function recordRun(run: CompletedRun, score: QualityScore): void {
-    db.upsertMetricsBucket(
-      run.provider,
-      run.model,
-      run.completedAt,
-      score.score,
-      run.durationMs,
-      run.success,
-      run.usage.input ?? 0,
-      run.usage.output ?? 0,
-    );
-  }
-
-  /**
-   * Get per-model quality, success rate, latency, and token efficiency.
-   */
-  function getModelMetrics(
-    provider?: string,
-    model?: string,
-  ): Array<{
-    provider: string;
-    model: string;
-    runCount: number;
-    successRate: number;
-    successRateLowerBound: number;
-    avgQuality: number;
-    qualityVariance: number;
-    avgLatency: number;
-    latencyVariance: number;
-    avgTokenInput: number;
-    avgTokenOutput: number;
-  }> {
-    const buckets = db.getMetricsBuckets(provider, model);
-    const grouped = new Map<string, MetricsBucketRow[]>();
-
-    for (const b of buckets) {
-      const key = `${b.provider}:${b.model}`;
-      const group = grouped.get(key) ?? [];
-      group.push(b);
-      grouped.set(key, group);
-    }
-
-    const results: Array<{
-      provider: string;
-      model: string;
-      runCount: number;
-      successRate: number;
-      successRateLowerBound: number;
-      avgQuality: number;
-      qualityVariance: number;
-      avgLatency: number;
-      latencyVariance: number;
-      avgTokenInput: number;
-      avgTokenOutput: number;
-    }> = [];
-
-    for (const [, group] of grouped) {
-      const totalRuns = group.reduce((s, b) => s + b.run_count, 0);
-      if (totalRuns === 0) continue;
-
-      const totalSuccess = group.reduce((s, b) => s + b.success_count, 0);
-      const qualitySum = group.reduce((s, b) => s + b.quality_sum, 0);
-      const qualitySumSq = group.reduce((s, b) => s + b.quality_sum_sq, 0);
-      const latencySum = group.reduce((s, b) => s + b.latency_sum, 0);
-      const latencySumSq = group.reduce((s, b) => s + b.latency_sum_sq, 0);
-      const tokenInputSum = group.reduce((s, b) => s + b.token_input_sum, 0);
-      const tokenOutputSum = group.reduce((s, b) => s + b.token_output_sum, 0);
-
-      const avgQuality = qualitySum / totalRuns;
-      const avgLatency = latencySum / totalRuns;
-      const successRate = totalSuccess / totalRuns;
-
-      results.push({
-        provider: group[0]!.provider,
-        model: group[0]!.model,
-        runCount: totalRuns,
-        successRate,
-        successRateLowerBound: wilsonScoreLowerBound(totalSuccess, totalRuns),
-        avgQuality,
-        qualityVariance: Math.max(0, qualitySumSq / totalRuns - avgQuality ** 2),
-        avgLatency,
-        latencyVariance: Math.max(0, latencySumSq / totalRuns - avgLatency ** 2),
-        avgTokenInput: tokenInputSum / totalRuns,
-        avgTokenOutput: tokenOutputSum / totalRuns,
-      });
-    }
-
-    return results.sort((a, b) => b.avgQuality - a.avgQuality);
-  }
-
-  /**
-   * Get time-bucketed quality trends.
-   */
-  function getTimeseries(params?: {
-    provider?: string;
-    model?: string;
-    fromHour?: string;
-    toHour?: string;
-  }): Array<{
-    bucketHour: string;
-    provider: string;
-    model: string;
-    runCount: number;
-    avgQuality: number;
-    successRate: number;
-    avgLatency: number;
-  }> {
-    const buckets = db.getMetricsBuckets(
-      params?.provider,
-      params?.model,
-      params?.fromHour,
-      params?.toHour,
-    );
-
-    return buckets.map((b) => ({
-      bucketHour: b.bucket_hour,
-      provider: b.provider,
-      model: b.model,
-      runCount: b.run_count,
-      avgQuality: b.run_count > 0 ? b.quality_sum / b.run_count : 0,
-      successRate: b.run_count > 0 ? b.success_count / b.run_count : 0,
-      avgLatency: b.run_count > 0 ? b.latency_sum / b.run_count : 0,
-    }));
-  }
-
-  /**
-   * Get model comparison leaderboard.
-   */
-  function getLeaderboard() {
-    return db.getModelLeaderboard();
-  }
-
-  return { recordRun, getModelMetrics, getTimeseries, getLeaderboard };
-}