audrey 0.17.0 → 0.20.0

package/src/causal.js

@@ -1,95 +0,0 @@
-import { generateId } from './ulid.js';
-import { buildCausalArticulationPrompt } from './prompts.js';
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {{ causeId: string, effectId: string, linkType?: string, mechanism?: string, confidence?: number }} params
- * @returns {string}
- */
-export function addCausalLink(db, { causeId, effectId, linkType = 'causal', mechanism, confidence }) {
-  const id = generateId();
-  const now = new Date().toISOString();
-
-  db.prepare(`
-    INSERT INTO causal_links (id, cause_id, effect_id, link_type, mechanism, confidence, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `).run(id, causeId, effectId, linkType, mechanism, confidence, now);
-
-  return id;
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {string} memoryId
- * @param {{ depth?: number }} [options]
- * @returns {Object[]}
- */
-export function getCausalChain(db, memoryId, options = {}) {
-  const { depth = 10 } = options;
-  const results = [];
-  const visited = new Set();
-  const queue = [memoryId];
-  let currentDepth = 0;
-
-  while (queue.length > 0 && currentDepth < depth) {
-    const nextQueue = [];
-    for (const nodeId of queue) {
-      if (visited.has(nodeId)) continue;
-      visited.add(nodeId);
-
-      const links = db.prepare(
-        'SELECT * FROM causal_links WHERE cause_id = ?'
-      ).all(nodeId);
-
-      for (const link of links) {
-        if (!visited.has(link.effect_id)) {
-          results.push(link);
-          nextQueue.push(link.effect_id);
-        }
-      }
-    }
-    queue.length = 0;
-    queue.push(...nextQueue);
-    currentDepth++;
-  }
-
-  return results;
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {import('./llm.js').LLMProvider} llmProvider
- * @param {{ id: string, content: string, source: string }} cause
- * @param {{ id: string, content: string, source: string }} effect
- * @returns {Promise<{ linkId: string|null, mechanism: string, linkType: string, confidence: number, spurious: boolean }>}
- */
-export async function articulateCausalLink(db, llmProvider, cause, effect) {
-  const messages = buildCausalArticulationPrompt(cause, effect);
-  const result = await llmProvider.json(messages);
-
-  if (result.spurious) {
-    return {
-      linkId: null,
-      mechanism: result.mechanism,
-      linkType: result.linkType,
-      confidence: result.confidence,
-      spurious: true,
-    };
-  }
-
-  const linkId = addCausalLink(db, {
-    causeId: cause.id,
-    effectId: effect.id,
-    linkType: result.linkType || 'correlational',
-    mechanism: result.mechanism,
-    confidence: result.confidence,
-  });
-
-  return {
-    linkId,
-    mechanism: result.mechanism,
-    linkType: result.linkType,
-    confidence: result.confidence,
-    spurious: false,
-  };
-}

package/src/confidence.js

@@ -1,120 +0,0 @@
-/** @type {Record<string, number>} */
-export const DEFAULT_SOURCE_RELIABILITY = {
-  'direct-observation': 0.95,
-  'told-by-user': 0.90,
-  'tool-result': 0.85,
-  'inference': 0.60,
-  'model-generated': 0.40,
-};
-
-/** @type {{ source: number, evidence: number, recency: number, retrieval: number }} */
-export const DEFAULT_WEIGHTS = {
-  source: 0.30,
-  evidence: 0.35,
-  recency: 0.20,
-  retrieval: 0.15,
-};
-
-/** @type {{ episodic: number, semantic: number, procedural: number }} */
-export const DEFAULT_HALF_LIVES = {
-  episodic: 7,
-  semantic: 30,
-  procedural: 90,
-};
-
-/** @type {number} */
-export const MODEL_GENERATED_CONFIDENCE_CAP = 0.6;
-
-/**
- * @param {string} sourceType
- * @param {Record<string, number>} [customReliability]
- * @returns {number}
- */
-export function sourceReliability(sourceType, customReliability) {
-  const table = customReliability || DEFAULT_SOURCE_RELIABILITY;
-  const value = table[sourceType];
-  if (value === undefined) {
-    throw new Error(`Unknown source type: ${sourceType}. Valid types: ${Object.keys(table).join(', ')}`);
-  }
-  return value;
-}
-
-/**
- * @param {number} supportingCount
- * @param {number} contradictingCount
- * @returns {number}
- */
-export function evidenceAgreement(supportingCount, contradictingCount) {
-  const total = supportingCount + contradictingCount;
-  if (total === 0) return 1.0;
-  return supportingCount / total;
-}
-
-/**
- * @param {number} ageDays
- * @param {number} halfLifeDays
- * @returns {number}
- */
-export function recencyDecay(ageDays, halfLifeDays) {
-  const lambda = Math.LN2 / halfLifeDays;
-  return Math.exp(-lambda * ageDays);
-}
-
-/**
- * @param {number} retrievalCount
- * @param {number} daysSinceRetrieval
- * @returns {number}
- */
-export function retrievalReinforcement(retrievalCount, daysSinceRetrieval) {
-  if (retrievalCount === 0) return 0;
-  const lambdaRet = Math.LN2 / 14;
-  const baseReinforcement = 0.3 * Math.log(1 + retrievalCount);
-  const recencyWeight = Math.exp(-lambdaRet * daysSinceRetrieval);
-  const spacedBonus = Math.min(0.15, 0.02 * Math.log(1 + daysSinceRetrieval));
-  return Math.min(1.0, baseReinforcement * recencyWeight + spacedBonus);
-}
-
-export function salienceModifier(salience) {
-  const s = salience ?? 0.5;
-  return 0.5 + s;
-}
-
-/**
- * @param {object} params
- * @param {string} params.sourceType
- * @param {number} params.supportingCount
- * @param {number} params.contradictingCount
- * @param {number} params.ageDays
- * @param {number} params.halfLifeDays
- * @param {number} params.retrievalCount
- * @param {number} params.daysSinceRetrieval
- * @param {{ source: number, evidence: number, recency: number, retrieval: number }} [params.weights]
- * @param {Record<string, number>} [params.customSourceReliability]
- * @returns {number}
- */
-export function computeConfidence({
-  sourceType,
-  supportingCount,
-  contradictingCount,
-  ageDays,
-  halfLifeDays,
-  retrievalCount,
-  daysSinceRetrieval,
-  weights,
-  customSourceReliability,
-}) {
-  const w = weights || DEFAULT_WEIGHTS;
-
-  const s = sourceReliability(sourceType, customSourceReliability);
-  const e = evidenceAgreement(supportingCount, contradictingCount);
-  const r = recencyDecay(ageDays, halfLifeDays);
-  const ret = retrievalReinforcement(retrievalCount, daysSinceRetrieval);
-
-  let confidence = w.source * s + w.evidence * e + w.recency * r + w.retrieval * ret;
-
-  if (sourceType === 'model-generated') {
-    confidence = Math.min(confidence, MODEL_GENERATED_CONFIDENCE_CAP);
-  }
-
-  return Math.max(0, Math.min(1, confidence));
-}

package/src/consolidate.js

@@ -1,281 +0,0 @@
-import { generateId } from './ulid.js';
-import { buildPrincipleExtractionPrompt } from './prompts.js';
-
-function clusterViaKNN(db, episodes, similarityThreshold, minClusterSize) {
-  const n = episodes.length;
-  const k = Math.min(50, n);
-  const idToIndex = new Map(episodes.map((ep, i) => [ep.id, i]));
-
-  const parent = new Array(n);
-  for (let i = 0; i < n; i++) parent[i] = i;
-
-  function find(x) {
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]];
-      x = parent[x];
-    }
-    return x;
-  }
-
-  function union(a, b) {
-    const ra = find(a);
-    const rb = find(b);
-    if (ra !== rb) parent[ra] = rb;
-  }
-
-  const getEmbedding = db.prepare('SELECT embedding FROM vec_episodes WHERE id = ?');
-  const knnQuery = db.prepare(`
-    SELECT id, distance
-    FROM vec_episodes
-    WHERE embedding MATCH ? AND k = ? AND consolidated = 0
-  `);
-
-  for (let i = 0; i < n; i++) {
-    const ep = episodes[i];
-    const vecRow = getEmbedding.get(ep.id);
-    if (!vecRow) continue;
-
-    const neighbors = knnQuery.all(vecRow.embedding, k);
-    for (const neighbor of neighbors) {
-      if (neighbor.id === ep.id) continue;
-      const j = idToIndex.get(neighbor.id);
-      if (j === undefined) continue;
-      const similarity = 1.0 - neighbor.distance;
-      if (similarity >= similarityThreshold) {
-        union(i, j);
-      }
-    }
-  }
-
-  const groups = new Map();
-  for (let i = 0; i < n; i++) {
-    const root = find(i);
-    if (!groups.has(root)) groups.set(root, []);
-    groups.get(root).push(episodes[i]);
-  }
-
-  const clusters = [];
-  for (const group of groups.values()) {
-    if (group.length >= minClusterSize) {
-      clusters.push(group);
-    }
-  }
-  return clusters;
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {import('./embedding.js').EmbeddingProvider} embeddingProvider
- * @param {{ similarityThreshold?: number, minClusterSize?: number }} [options]
- * @returns {Array<Array<Object>>}
- */
-export function clusterEpisodes(db, embeddingProvider, options = {}) {
-  const {
-    similarityThreshold = 0.85,
-    minClusterSize = 3,
-  } = options;
-
-  const episodes = db.prepare(
-    'SELECT * FROM episodes WHERE consolidated = 0 AND superseded_by IS NULL AND embedding IS NOT NULL'
-  ).all();
-
-  if (episodes.length === 0) return [];
-
-  return clusterViaKNN(db, episodes, similarityThreshold, minClusterSize);
-}
-
-function defaultExtractPrinciple(episodes) {
-  const uniqueContents = [...new Set(episodes.map(e => e.content))];
-  return {
-    content: `Recurring pattern: ${uniqueContents.join('; ')}`,
-    type: 'semantic',
-  };
-}
-
-async function llmExtractPrinciple(llmProvider, episodes) {
-  const messages = buildPrincipleExtractionPrompt(episodes);
-  return llmProvider.json(messages);
-}
-
-function inClause(ids) {
-  return ids.map(() => '?').join(',');
-}
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {import('./embedding.js').EmbeddingProvider} embeddingProvider
- * @param {{ similarityThreshold?: number, minClusterSize?: number, extractPrinciple?: function, llmProvider?: Object }} [options]
- * @returns {Promise<{ runId: string, episodesEvaluated: number, clustersFound: number, principlesExtracted: number }>}
- */
-export async function runConsolidation(db, embeddingProvider, options = {}) {
-  const {
-    similarityThreshold = 0.85,
-    minClusterSize = 3,
-    extractPrinciple,
-    llmProvider,
-  } = options;
-
-  const runId = generateId();
-  const now = new Date().toISOString();
-
-  db.prepare(`
-    INSERT INTO consolidation_runs (
-      id, started_at, status, input_episode_ids, output_memory_ids, consolidation_model, checkpoint_cursor
-    )
-    VALUES (?, ?, 'running', '[]', '[]', ?, ?)
-  `).run(runId, now, llmProvider?.modelName || null, now);
-
-  try {
-    const clusters = clusterEpisodes(db, embeddingProvider, { similarityThreshold, minClusterSize });
-
-    const episodesEvaluated = db.prepare(
-      'SELECT COUNT(*) as count FROM episodes WHERE consolidated = 0 AND superseded_by IS NULL AND embedding IS NOT NULL'
-    ).get().count;
-
-    const allInputIds = [];
-    const allOutputIds = [];
-    let principlesExtracted = 0;
-    let proceduresExtracted = 0;
-    const preparedClusters = [];
-    const insertProcedure = db.prepare(`
-      INSERT INTO procedures (
-        id, content, embedding, state, trigger_conditions,
-        evidence_episode_ids, success_count, failure_count,
-        embedding_model, embedding_version, created_at, salience
-      ) VALUES (?, ?, ?, 'active', ?, ?, 0, 0, ?, ?, ?, ?)
-    `);
-    const insertVecProcedure = db.prepare('INSERT INTO vec_procedures(id, embedding, state) VALUES (?, ?, ?)');
-    const insertSemantic = db.prepare(`
-      INSERT INTO semantics (
-        id, content, embedding, state, evidence_episode_ids,
-        evidence_count, supporting_count, source_type_diversity,
-        consolidation_checkpoint, embedding_model, embedding_version,
-        consolidation_model, created_at, salience
-      ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    const insertVecSemantic = db.prepare('INSERT INTO vec_semantics(id, embedding, state) VALUES (?, ?, ?)');
-    const updateRunCompleted = db.prepare(`
-      UPDATE consolidation_runs
-      SET status = 'completed',
-          completed_at = ?,
-          input_episode_ids = ?,
-          output_memory_ids = ?
-      WHERE id = ?
-    `);
-    const insertMetrics = db.prepare(`
-      INSERT INTO consolidation_metrics (id, run_id, min_cluster_size, similarity_threshold,
-        episodes_evaluated, clusters_found, principles_extracted, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-
-    for (const cluster of clusters) {
-      let principle;
-      if (extractPrinciple) {
-        principle = await extractPrinciple(cluster);
-      } else if (llmProvider) {
-        principle = await llmExtractPrinciple(llmProvider, cluster);
-      } else {
-        principle = defaultExtractPrinciple(cluster);
-      }
-
-      if (!principle || !principle.content) continue;
-
-      const vector = await embeddingProvider.embed(principle.content);
-      const clusterIds = cluster.map(ep => ep.id);
-      preparedClusters.push({
-        principle,
-        clusterIds,
-        sourceTypeDiversity: new Set(cluster.map(ep => ep.source)).size,
-        embeddingBuffer: embeddingProvider.vectorToBuffer(vector),
-        memoryId: generateId(),
-        createdAt: new Date().toISOString(),
-        maxSalience: Math.max(...cluster.map(ep => ep.salience ?? 0.5)),
-      });
-    }
-
-    const writeConsolidation = db.transaction(() => {
-      for (const prepared of preparedClusters) {
-        const placeholders = inClause(prepared.clusterIds);
-        const eligibleCount = db.prepare(`
-          SELECT COUNT(*) AS count
-          FROM episodes
-          WHERE id IN (${placeholders})
-            AND consolidated = 0
-            AND superseded_by IS NULL
-        `).get(...prepared.clusterIds).count;
-
-        if (eligibleCount !== prepared.clusterIds.length) {
-          continue;
-        }
-
-        if (prepared.principle.type === 'procedural') {
-          insertProcedure.run(
-            prepared.memoryId,
-            prepared.principle.content,
-            prepared.embeddingBuffer,
-            prepared.principle.conditions ? JSON.stringify(prepared.principle.conditions) : null,
-            JSON.stringify(prepared.clusterIds),
-            embeddingProvider.modelName,
-            embeddingProvider.modelVersion,
-            prepared.createdAt,
-            prepared.maxSalience,
-          );
-          insertVecProcedure.run(prepared.memoryId, prepared.embeddingBuffer, 'active');
-          proceduresExtracted++;
-        } else {
-          insertSemantic.run(
-            prepared.memoryId,
-            prepared.principle.content,
-            prepared.embeddingBuffer,
-            JSON.stringify(prepared.clusterIds),
-            prepared.clusterIds.length,
-            prepared.clusterIds.length,
-            prepared.sourceTypeDiversity,
-            runId,
-            embeddingProvider.modelName,
-            embeddingProvider.modelVersion,
-            llmProvider?.modelName || null,
-            prepared.createdAt,
-            prepared.maxSalience,
-          );
-          insertVecSemantic.run(prepared.memoryId, prepared.embeddingBuffer, 'active');
-        }
-
-        db.prepare(`UPDATE episodes SET consolidated = 1 WHERE id IN (${placeholders})`).run(...prepared.clusterIds);
-        db.prepare(`UPDATE vec_episodes SET consolidated = ? WHERE id IN (${placeholders})`).run(
-          BigInt(1),
-          ...prepared.clusterIds,
-        );
-
-        allInputIds.push(...prepared.clusterIds);
-        allOutputIds.push(prepared.memoryId);
-        principlesExtracted++;
-      }
-
-      const completedAt = new Date().toISOString();
-      updateRunCompleted.run(completedAt, JSON.stringify(allInputIds), JSON.stringify(allOutputIds), runId);
-      insertMetrics.run(
-        generateId(), runId, minClusterSize, similarityThreshold,
-        episodesEvaluated, clusters.length, principlesExtracted, completedAt,
-      );
-    });
-    writeConsolidation.immediate();
-
-    return {
-      runId,
-      episodesEvaluated,
-      clustersFound: clusters.length,
-      principlesExtracted,
-      semanticsCreated: principlesExtracted - proceduresExtracted,
-      proceduresCreated: proceduresExtracted,
-    };
-  } catch (err) {
-    const failedAt = new Date().toISOString();
-    db.prepare(`
-      UPDATE consolidation_runs
-      SET status = 'failed', completed_at = ?
-      WHERE id = ?
-    `).run(failedAt, runId);
-    throw err;
-  }
-}

package/src/context.js

@@ -1,15 +0,0 @@
-export function contextMatchRatio(encodingContext, retrievalContext) {
-  if (!encodingContext || !retrievalContext) return 0;
-  const retrievalKeys = Object.keys(retrievalContext);
-  if (retrievalKeys.length === 0) return 0;
-  const sharedKeys = retrievalKeys.filter(k => k in encodingContext);
-  if (sharedKeys.length === 0) return 0;
-  const matches = sharedKeys.filter(k => encodingContext[k] === retrievalContext[k]).length;
-  return matches / retrievalKeys.length;
-}
-
-export function contextModifier(encodingContext, retrievalContext, weight = 0.3) {
-  if (!encodingContext || !retrievalContext) return 1.0;
-  const ratio = contextMatchRatio(encodingContext, retrievalContext);
-  return 1.0 + (weight * ratio);
-}