@symerian/symi 3.0.17 → 3.0.19

package/extensions/learning-loop/src/feedback/implicit-signals.ts

@@ -1,89 +0,0 @@
-/**
- * Implicit feedback detection from user behavior.
- *
- * Analyzes the message_received hook to detect:
- * - Re-ask: next message within 60s with Jaccard similarity > 0.5 => negative signal
- * - Topic change: Jaccard similarity < 0.2 => positive signal (user moved on)
- * - Follow-up continuation: similarity 0.2-0.5 => neutral
- */
-
-import crypto from "node:crypto";
-import { jaccardSimilarity, tokenize } from "../../../../src/memory/mmr.js";
-import type { DatabaseManager } from "../db.js";
-import type { LearningLoopConfig, FeedbackRecord } from "../types.js";
-
-export type ImplicitSignals = ReturnType<typeof createImplicitSignals>;
-
-type RecentPrompt = {
-  runId: string;
-  content: string;
-  tokens: Set<string>;
-  timestamp: number;
-};
-
-const RE_ASK_WINDOW_MS = 60_000;
-const RE_ASK_SIMILARITY_THRESHOLD = 0.5;
-const TOPIC_CHANGE_THRESHOLD = 0.2;
-
-export function createImplicitSignals(params: { db: DatabaseManager; config: LearningLoopConfig }) {
-  const { db } = params;
-  const recentPrompts: RecentPrompt[] = [];
-  const MAX_RECENT = 20;
-
-  /**
-   * Record a prompt that was just sent to the LLM, for later comparison.
-   */
-  function recordPrompt(runId: string, content: string): void {
-    recentPrompts.push({
-      runId,
-      content,
-      tokens: tokenize(content),
-      timestamp: Date.now(),
-    });
-
-    // Keep bounded
-    while (recentPrompts.length > MAX_RECENT) {
-      recentPrompts.shift();
-    }
-  }
-
-  /**
-   * Analyze an incoming user message against recent prompts.
-   * Returns a feedback record if an implicit signal is detected, null otherwise.
-   */
-  function analyzeMessage(content: string, timestamp: number): FeedbackRecord | null {
-    if (recentPrompts.length === 0) return null;
-
-    const messageTokens = tokenize(content);
-    const lastPrompt = recentPrompts[recentPrompts.length - 1]!;
-    const timeDelta = timestamp - lastPrompt.timestamp;
-
-    const similarity = jaccardSimilarity(messageTokens, lastPrompt.tokens);
-
-    let score: number | null = null;
-
-    if (timeDelta <= RE_ASK_WINDOW_MS && similarity > RE_ASK_SIMILARITY_THRESHOLD) {
-      // Re-ask: user is repeating themselves => bad signal
-      score = 0.0;
-    } else if (similarity < TOPIC_CHANGE_THRESHOLD) {
-      // Topic change: user moved on => good signal
-      score = 1.0;
-    } else {
-      // Continuation: neutral, no signal
-      return null;
-    }
-
-    const feedback: FeedbackRecord = {
-      id: `fb_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`,
-      runId: lastPrompt.runId,
-      source: "implicit",
-      score,
-      createdAt: timestamp,
-    };
-
-    db.insertFeedback(feedback);
-    return feedback;
-  }
-
-  return { recordPrompt, analyzeMessage };
-}

package/extensions/learning-loop/src/graph/edge-inference.ts

@@ -1,189 +0,0 @@
-/**
- * Automatic edge creation from learning-loop events.
- * No manual edge management -- edges are inferred from:
- * - Temporal co-occurrence (same run)
- * - Semantic similarity (embedding cosine)
- * - Supersession (same category, higher confidence)
- * - Contradiction (opposing categories with similar content)
- * - Reinforcement (co-applied learnings)
- * - Causation (injected learnings -> extracted learnings)
- */
-
-import { cosineSimilarity } from "../../../../src/memory/internal.js";
-import type { LearningStore } from "../learning/learning-store.js";
-import type { LearningRecord } from "../types.js";
-import type { GraphStore } from "./graph-store.js";
-
-export type EdgeInference = ReturnType<typeof createEdgeInference>;
-
-const NEGATION_TOKENS = new Set([
-  "not",
-  "avoid",
-  "never",
-  "don't",
-  "dont",
-  "fails",
-  "instead",
-  "shouldn't",
-  "shouldnt",
-  "won't",
-  "wont",
-  "cannot",
-  "can't",
-  "cant",
-]);
-
-function tokenize(text: string): string[] {
-  return text
-    .toLowerCase()
-    .replace(/[^\w\s]/g, " ")
-    .split(/\s+/)
-    .filter(Boolean);
-}
-
-function jaccardSimilarity(a: Set<string>, b: Set<string>): number {
-  let intersection = 0;
-  for (const token of a) {
-    if (b.has(token)) intersection++;
-  }
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-
-export function createEdgeInference(params: {
-  graphStore: GraphStore;
-  learningStore: LearningStore;
-}) {
-  const { graphStore, learningStore } = params;
-
-  /**
-   * Called after a new learning is created. Infers T, S, U, X edges.
-   */
-  function onLearningCreated(newLearning: LearningRecord, runId: string): void {
-    const recentLearnings = learningStore.listLearnings({ limit: 100 });
-
-    // 1. Temporal edges (T): other learnings from same run
-    for (const existing of recentLearnings) {
-      if (existing.id === newLearning.id) continue;
-      if (existing.runId === runId) {
-        graphStore.addEdge(existing.id, newLearning.id, "T", 0.5);
-      }
-    }
-
-    // 2-4 require comparing against recent learnings
-    for (const existing of recentLearnings) {
-      if (existing.id === newLearning.id) continue;
-
-      // 2. Semantic edges (S): cosine similarity between embeddings
-      if (newLearning.embedding && existing.embedding) {
-        const similarity = cosineSimilarity(newLearning.embedding, existing.embedding);
-
-        if (similarity >= 0.6 && similarity < 0.92) {
-          // Canonical ordering for bidirectional edges
-          const [a, b] =
-            existing.id < newLearning.id
-              ? [existing.id, newLearning.id]
-              : [newLearning.id, existing.id];
-          graphStore.addEdge(a, b, "S", similarity);
-        }
-
-        // 3. Supersession edges (U): same category + high similarity + higher confidence
-        if (
-          similarity >= 0.8 &&
-          existing.category === newLearning.category &&
-          newLearning.confidence > existing.confidence
-        ) {
-          graphStore.addEdge(existing.id, newLearning.id, "U", 1.0);
-        }
-      }
-
-      // 4. Contradiction edges (X)
-      if (detectContradiction(newLearning, existing)) {
-        const [a, b] =
-          existing.id < newLearning.id
-            ? [existing.id, newLearning.id]
-            : [newLearning.id, existing.id];
-        const weight =
-          newLearning.embedding && existing.embedding
-            ? Math.max(0.5, cosineSimilarity(newLearning.embedding, existing.embedding))
-            : 0.7;
-        graphStore.addEdge(a, b, "X", weight);
-      }
-    }
-  }
-
-  /**
-   * Called after a run is scored. Infers R and C edges.
-   * @param runId - The run that was scored
-   * @param appliedIds - Learning IDs that were injected into this run
-   * @param extractedIds - Learning IDs that were extracted from this run
-   */
-  function onRunScored(runId: string, appliedIds: string[], extractedIds: string[]): void {
-    // 1. Reinforcement edges (R): between co-applied learnings
-    for (let i = 0; i < appliedIds.length; i++) {
-      for (let j = i + 1; j < appliedIds.length; j++) {
-        const a = appliedIds[i]!;
-        const b = appliedIds[j]!;
-        const [source, target] = a < b ? [a, b] : [b, a];
-
-        // Check existing edge weight to increment
-        const existing = graphStore
-          .getEdges(source, { typeFilter: ["R"] })
-          .find((e) => e.sourceId === source && e.targetId === target);
-
-        if (existing) {
-          const newWeight = Math.min(0.8, existing.weight + 0.1);
-          graphStore.upsertEdge(source, target, "R", newWeight);
-        } else {
-          graphStore.addEdge(source, target, "R", 0.3);
-        }
-      }
-    }
-
-    // 2. Causal edges (C): from injected learnings to extracted learnings
-    for (const injectedId of appliedIds) {
-      for (const extractedId of extractedIds) {
-        graphStore.addEdge(injectedId, extractedId, "C", 0.6);
-      }
-    }
-  }
-
-  /**
-   * Detect contradiction between two learnings via two heuristics:
-   * 1. Category opposition (tool_pattern vs anti_pattern) with semantic similarity
-   * 2. Negation density with high non-negation token overlap
-   */
-  function detectContradiction(a: LearningRecord, b: LearningRecord): boolean {
-    // Heuristic 1: Category opposition
-    const opposingCategories =
-      (a.category === "tool_pattern" && b.category === "anti_pattern") ||
-      (a.category === "anti_pattern" && b.category === "tool_pattern");
-
-    if (opposingCategories && a.embedding && b.embedding) {
-      const sim = cosineSimilarity(a.embedding, b.embedding);
-      if (sim >= 0.7) return true;
-    }
-
-    // Heuristic 2: Negation density
-    const tokensA = tokenize(a.content);
-    const tokensB = tokenize(b.content);
-
-    const negationsA = tokensA.filter((t) => NEGATION_TOKENS.has(t));
-    const negationsB = tokensB.filter((t) => NEGATION_TOKENS.has(t));
-
-    // One has negations, the other doesn't (or significantly fewer)
-    const hasNegationAsymmetry =
-      (negationsA.length > 0 && negationsB.length === 0) ||
-      (negationsB.length > 0 && negationsA.length === 0);
-
-    if (hasNegationAsymmetry) {
-      const nonNegA = new Set(tokensA.filter((t) => !NEGATION_TOKENS.has(t)));
-      const nonNegB = new Set(tokensB.filter((t) => !NEGATION_TOKENS.has(t)));
-      if (jaccardSimilarity(nonNegA, nonNegB) >= 0.5) return true;
-    }
-
-    return false;
-  }
-
-  return { onLearningCreated, onRunScored };
-}

package/extensions/learning-loop/src/graph/graph-retrieval.ts

@@ -1,144 +0,0 @@
-/**
- * Hop expansion integrated into the retrieval pipeline.
- *
- * Takes seed results from vector/FTS retrieval, expands via graph neighbors,
- * computes expanded scores with hop decay and type multipliers, then merges
- * and re-applies MMR for diversity.
- */
-
-import { mmrRerank, type MMRItem } from "../../../../src/memory/mmr.js";
-import type { LearningStore } from "../learning/learning-store.js";
-import type { RetrievalResult } from "../learning/retrieval.js";
-import type { EdgeType, LearningLoopConfig } from "../types.js";
-import type { GraphStore } from "./graph-store.js";
-
-export type GraphRetrieval = ReturnType<typeof createGraphRetrieval>;
-
-const HOP_DECAY = 0.6;
-const CENTRALITY_HIGH_THRESHOLD = 2.0;
-
-const TYPE_MULTIPLIERS: Record<EdgeType, number> = {
-  C: 1.0,
-  S: 0.8,
-  R: 0.7,
-  T: 0.5,
-  U: 0.3,
-  X: 0.0, // Contradictions excluded from expansion
-};
-
-export function createGraphRetrieval(params: {
-  graphStore: GraphStore;
-  learningStore: LearningStore;
-  config: LearningLoopConfig;
-}) {
-  const { graphStore, learningStore } = params;
-
-  /**
-   * Expand seed retrieval results with graph neighbors.
-   *
-   * 1. Take top-5 seeds
-   * 2. 1-hop expansion (2-hop for high-centrality seeds)
-   * 3. Compute expanded scores with decay, type multiplier, centrality boost
-   * 4. Merge with seeds, dedup, re-apply MMR
-   * 5. Annotate contested results (X-edges)
-   */
-  function expandWithGraph(seeds: RetrievalResult[], limit: number): RetrievalResult[] {
-    if (seeds.length === 0) return seeds;
-
-    const topSeeds = seeds.slice(0, 5);
-    const expanded = new Map<string, RetrievalResult>();
-
-    // Keep all original seeds
-    for (const seed of seeds) {
-      expanded.set(seed.learning.id, seed);
-    }
-
-    // Expand each top seed
-    for (const seed of topSeeds) {
-      const seedId = seed.learning.id;
-      const seedCentrality = graphStore.getCentrality(seedId);
-      const maxHops = seedCentrality > CENTRALITY_HIGH_THRESHOLD ? 2 : 1;
-
-      // Check for contradictions and annotate seed
-      const contradictions = graphStore.getContradictions(seedId);
-      if (contradictions.length > 0) {
-        const existing = expanded.get(seedId)!;
-        expanded.set(seedId, { ...existing, contested: true });
-      }
-
-      // Get edges for expansion
-      const edges = graphStore.getEdges(seedId);
-
-      for (const edge of edges) {
-        if (TYPE_MULTIPLIERS[edge.edgeType] === 0) continue; // Skip contradictions
-
-        const neighborId = edge.sourceId === seedId ? edge.targetId : edge.sourceId;
-        const neighborLearning = learningStore.getLearning(neighborId);
-        if (!neighborLearning) continue;
-
-        const neighborCentrality = graphStore.getCentrality(neighborId);
-        const centralityBoost = 1.0 + 0.1 * Math.log2(1 + neighborCentrality);
-        const expandedScore =
-          seed.decayedScore * HOP_DECAY * TYPE_MULTIPLIERS[edge.edgeType] * centralityBoost;
-
-        const existing = expanded.get(neighborId);
-        if (!existing || existing.decayedScore < expandedScore) {
-          expanded.set(neighborId, {
-            learning: neighborLearning,
-            score: expandedScore,
-            decayedScore: expandedScore,
-          });
-        }
-
-        // 2-hop expansion for high-centrality seeds
-        if (maxHops >= 2) {
-          const hop2Edges = graphStore.getEdges(neighborId);
-          for (const hop2Edge of hop2Edges) {
-            if (TYPE_MULTIPLIERS[hop2Edge.edgeType] === 0) continue;
-
-            const hop2Id = hop2Edge.sourceId === neighborId ? hop2Edge.targetId : hop2Edge.sourceId;
-            if (hop2Id === seedId) continue;
-
-            const hop2Learning = learningStore.getLearning(hop2Id);
-            if (!hop2Learning) continue;
-
-            const hop2Centrality = graphStore.getCentrality(hop2Id);
-            const hop2CentralityBoost = 1.0 + 0.1 * Math.log2(1 + hop2Centrality);
-            const hop2Score =
-              seed.decayedScore *
-              HOP_DECAY *
-              HOP_DECAY *
-              TYPE_MULTIPLIERS[hop2Edge.edgeType] *
-              hop2CentralityBoost;
-
-            const existingHop2 = expanded.get(hop2Id);
-            if (!existingHop2 || existingHop2.decayedScore < hop2Score) {
-              expanded.set(hop2Id, {
-                learning: hop2Learning,
-                score: hop2Score,
-                decayedScore: hop2Score,
-              });
-            }
-          }
-        }
-      }
-    }
-
-    // Convert to array and sort by score
-    const allResults = Array.from(expanded.values());
-    allResults.sort((a, b) => b.decayedScore - a.decayedScore);
-
-    // Re-apply MMR reranking
-    const mmrItems: (MMRItem & { original: RetrievalResult })[] = allResults.map((r) => ({
-      id: r.learning.id,
-      score: r.decayedScore,
-      content: r.learning.content,
-      original: r,
-    }));
-
-    const reranked = mmrRerank(mmrItems, { enabled: true, lambda: 0.7 });
-    return reranked.slice(0, limit).map((item) => item.original);
-  }
-
-  return { expandWithGraph };
-}

package/extensions/learning-loop/src/graph/graph-store.ts

@@ -1,183 +0,0 @@
-/**
- * Graph store: edge CRUD + incremental centrality tracking.
- *
- * Centrality model: log-weighted degree centrality.
- *   centrality(node) = sum over edges(node): log2(1 + weight)
- *
- * Updated O(1) per edge add via delta. Log dampening prevents
- * high-degree nodes from dominating.
- */
-
-import type { DatabaseManager } from "../db.js";
-import type { EdgeType, LearningEdge, EdgeRow } from "../types.js";
-
-export type GraphStore = ReturnType<typeof createGraphStore>;
-
-function rowToEdge(row: EdgeRow): LearningEdge {
-  return {
-    id: row.id,
-    sourceId: row.source_id,
-    targetId: row.target_id,
-    edgeType: row.edge_type as EdgeType,
-    weight: row.weight,
-    createdAt: row.created_at,
-  };
-}
-
-export function createGraphStore(params: { db: DatabaseManager }) {
-  const { db } = params;
-
-  /**
-   * Add an edge and incrementally update centrality for both endpoints.
-   */
-  function addEdge(source: string, target: string, type: EdgeType, weight: number): void {
-    db.insertEdge(source, target, type, weight);
-    const delta = Math.log2(1 + weight);
-    updateCentralityDelta(source, delta);
-    updateCentralityDelta(target, delta);
-  }
-
-  /**
-   * Upsert an edge (update weight if exists). Adjusts centrality accordingly.
-   */
-  function upsertEdge(source: string, target: string, type: EdgeType, newWeight: number): void {
-    // Check if edge already exists to compute delta
-    const existing = db
-      .getEdgesByNode(source)
-      .find((e) => e.source_id === source && e.target_id === target && e.edge_type === type);
-
-    if (existing) {
-      const oldDelta = Math.log2(1 + existing.weight);
-      const newDelta = Math.log2(1 + newWeight);
-      const diff = newDelta - oldDelta;
-      db.upsertEdge(source, target, type, newWeight);
-      updateCentralityDelta(source, diff);
-      updateCentralityDelta(target, diff);
-    } else {
-      db.upsertEdge(source, target, type, newWeight);
-      const delta = Math.log2(1 + newWeight);
-      updateCentralityDelta(source, delta);
-      updateCentralityDelta(target, delta);
-    }
-  }
-
-  /**
-   * Get all edges for a learning, optionally filtered by type.
-   */
-  function getEdges(learningId: string, opts?: { typeFilter?: EdgeType[] }): LearningEdge[] {
-    const rows = db.getEdgesByNode(learningId);
-    let edges = rows.map(rowToEdge);
-    if (opts?.typeFilter && opts.typeFilter.length > 0) {
-      const allowed = new Set(opts.typeFilter);
-      edges = edges.filter((e) => allowed.has(e.edgeType));
-    }
-    return edges;
-  }
-
-  /**
-   * Get N-hop neighbors with accumulated weights.
-   * Returns Map<learningId, accumulatedWeight>.
-   */
-  function getNeighbors(
-    learningId: string,
-    hops: number = 1,
-    typeFilter?: EdgeType[],
-  ): Map<string, number> {
-    const result = new Map<string, number>();
-    const visited = new Set<string>([learningId]);
-    let frontier = new Map<string, number>([[learningId, 1.0]]);
-
-    for (let hop = 0; hop < hops; hop++) {
-      const nextFrontier = new Map<string, number>();
-
-      for (const [nodeId, parentWeight] of frontier) {
-        const edges = getEdges(nodeId, { typeFilter });
-        for (const edge of edges) {
-          const neighborId = edge.sourceId === nodeId ? edge.targetId : edge.sourceId;
-          if (visited.has(neighborId)) continue;
-
-          const weight = parentWeight * edge.weight;
-          const existing = nextFrontier.get(neighborId) ?? 0;
-          nextFrontier.set(neighborId, Math.max(existing, weight));
-        }
-      }
-
-      for (const [nodeId, weight] of nextFrontier) {
-        visited.add(nodeId);
-        const existing = result.get(nodeId) ?? 0;
-        result.set(nodeId, Math.max(existing, weight));
-      }
-
-      frontier = nextFrontier;
-      if (frontier.size === 0) break;
-    }
-
-    return result;
-  }
-
-  /**
-   * Get centrality score for a learning.
-   */
-  function getCentrality(learningId: string): number {
-    return db.getCentralityScore(learningId);
-  }
-
-  /**
-   * Remove all edges for a learning and recompute affected neighbors' centrality.
-   */
-  function removeEdgesFor(learningId: string): void {
-    const edges = db.getEdgesByNode(learningId);
-
-    // Collect affected neighbors
-    const affected = new Set<string>();
-    for (const edge of edges) {
-      if (edge.source_id !== learningId) affected.add(edge.source_id);
-      if (edge.target_id !== learningId) affected.add(edge.target_id);
-    }
-
-    // Delete all edges
-    db.deleteEdgesForLearning(learningId);
-    db.deleteCentralityScore(learningId);
-
-    // Recompute centrality for affected neighbors
-    for (const neighborId of affected) {
-      recomputeCentrality(neighborId);
-    }
-  }
-
-  /**
-   * Get all contradiction edges, optionally for a specific learning.
-   */
-  function getContradictions(learningId?: string): LearningEdge[] {
-    if (learningId) {
-      return getEdges(learningId, { typeFilter: ["X"] });
-    }
-    return db.getEdgesByType("X").map(rowToEdge);
-  }
-
-  // --- Internal helpers ---
-
-  function updateCentralityDelta(id: string, delta: number): void {
-    const current = db.getCentralityScore(id);
-    db.upsertCentralityScore(id, current + delta);
-  }
-
-  function recomputeCentrality(id: string): void {
-    const edges = db.getEdgesByNode(id);
-    let score = 0;
-    for (const edge of edges) {
-      score += Math.log2(1 + edge.weight);
-    }
-    db.upsertCentralityScore(id, score);
-  }
-
-  return {
-    addEdge,
-    upsertEdge,
-    getEdges,
-    getNeighbors,
-    getCentrality,
-    removeEdgesFor,
-    getContradictions,
-  };
-}