audrey 0.15.0 → 0.16.1

package/src/causal.js

@@ -1,95 +1,95 @@
-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,
-  };
-}
+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 +1,120 @@
-/** @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));
-}
+/** @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));
+}