audrey 0.9.0 → 0.11.0

package/mcp-server/config.js

@@ -1,26 +1,40 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-export const VERSION = '0.9.0';
+export const VERSION = '0.11.0';
 export const SERVER_NAME = 'audrey-memory';
 export const DEFAULT_DATA_DIR = join(homedir(), '.audrey', 'data');
 
+/**
+ * Resolves which embedding provider to use.
+ * Priority: explicit config -> gemini (if GOOGLE_API_KEY exists) -> local
+ * OpenAI is NEVER auto-selected -- must be set explicitly via AUDREY_EMBEDDING_PROVIDER=openai.
+ */
+export function resolveEmbeddingProvider(env, explicit) {
+  if (explicit && explicit !== 'auto') {
+    const dims = explicit === 'openai' ? 1536 : explicit === 'gemini' ? 768 : 384;
+    const apiKey = explicit === 'gemini'
+      ? (env.GOOGLE_API_KEY || env.GEMINI_API_KEY)
+      : explicit === 'openai'
+        ? env.OPENAI_API_KEY
+        : undefined;
+    return { provider: explicit, apiKey, dimensions: dims };
+  }
+  if (env.GOOGLE_API_KEY || env.GEMINI_API_KEY) {
+    return { provider: 'gemini', apiKey: env.GOOGLE_API_KEY || env.GEMINI_API_KEY, dimensions: 768 };
+  }
+  return { provider: 'local', dimensions: 384 };
+}
+
 export function buildAudreyConfig() {
   const dataDir = process.env.AUDREY_DATA_DIR || DEFAULT_DATA_DIR;
   const agent = process.env.AUDREY_AGENT || 'claude-code';
-  const embProvider = process.env.AUDREY_EMBEDDING_PROVIDER || 'mock';
-  const embDimensions = parseInt(process.env.AUDREY_EMBEDDING_DIMENSIONS || '8', 10);
+  const explicitProvider = process.env.AUDREY_EMBEDDING_PROVIDER;
   const llmProvider = process.env.AUDREY_LLM_PROVIDER;
 
-  const config = {
-    dataDir,
-    agent,
-    embedding: { provider: embProvider, dimensions: embDimensions },
-  };
+  const embedding = resolveEmbeddingProvider(process.env, explicitProvider);
 
-  if (embProvider === 'openai') {
-    config.embedding.apiKey = process.env.OPENAI_API_KEY;
-  }
+  const config = { dataDir, agent, embedding };
 
   if (llmProvider === 'anthropic') {
     config.llm = { provider: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY };
@@ -36,13 +50,13 @@ export function buildAudreyConfig() {
 export function buildInstallArgs(env = process.env) {
   const envPairs = [`AUDREY_DATA_DIR=${DEFAULT_DATA_DIR}`];
 
-  if (env.OPENAI_API_KEY) {
+  const embedding = resolveEmbeddingProvider(env);
+  if (embedding.provider === 'gemini') {
+    envPairs.push('AUDREY_EMBEDDING_PROVIDER=gemini');
+    envPairs.push(`GOOGLE_API_KEY=${embedding.apiKey}`);
+  } else if (embedding.provider === 'openai') {
     envPairs.push('AUDREY_EMBEDDING_PROVIDER=openai');
-    envPairs.push('AUDREY_EMBEDDING_DIMENSIONS=1536');
     envPairs.push(`OPENAI_API_KEY=${env.OPENAI_API_KEY}`);
-  } else {
-    envPairs.push('AUDREY_EMBEDDING_PROVIDER=mock');
-    envPairs.push('AUDREY_EMBEDDING_DIMENSIONS=8');
   }
 
   if (env.ANTHROPIC_API_KEY) {

package/mcp-server/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
@@ -8,7 +8,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { Audrey } from '../src/index.js';
 import { readStoredDimensions } from '../src/db.js';
-import { VERSION, SERVER_NAME, DEFAULT_DATA_DIR, buildAudreyConfig, buildInstallArgs } from './config.js';
+import { VERSION, SERVER_NAME, DEFAULT_DATA_DIR, buildAudreyConfig, buildInstallArgs, resolveEmbeddingProvider } from './config.js';
 
 const VALID_SOURCES = ['direct-observation', 'told-by-user', 'tool-result', 'inference', 'model-generated'];
 const VALID_TYPES = ['episodic', 'semantic', 'procedural'];
@@ -19,6 +19,11 @@ if (subcommand === 'install') {
   install();
 } else if (subcommand === 'uninstall') {
   uninstall();
+} else if (subcommand === 'reembed') {
+  reembed().catch(err => {
+    console.error('[audrey] reembed failed:', err);
+    process.exit(1);
+  });
 } else if (subcommand === 'status') {
   status();
 } else {
@@ -28,6 +33,28 @@ if (subcommand === 'install') {
   });
 }
 
+
+async function reembed() {
+  const dataDir = process.env.AUDREY_DATA_DIR || DEFAULT_DATA_DIR;
+  const explicit = process.env.AUDREY_EMBEDDING_PROVIDER;
+  const embedding = resolveEmbeddingProvider(process.env, explicit);
+
+  const storedDims = readStoredDimensions(dataDir);
+  const dimensionsChanged = storedDims !== null && storedDims !== embedding.dimensions;
+
+  console.log(`Re-embedding with ${embedding.provider} (${embedding.dimensions}d)...`);
+  if (dimensionsChanged) {
+    console.log(`Dimension change: ${storedDims}d -> ${embedding.dimensions}d (will drop and recreate vec tables)`);
+  }
+
+  const audrey = new Audrey({ dataDir, agent: 'reembed', embedding });
+  const { reembedAll } = await import('../src/migrate.js');
+  const counts = await reembedAll(audrey.db, audrey.embeddingProvider, { dropAndRecreate: dimensionsChanged });
+  audrey.close();
+
+  console.log(`Done. Re-embedded: ${counts.episodes} episodes, ${counts.semantics} semantics, ${counts.procedures} procedures`);
+}
+
 function install() {
   try {
     execFileSync('claude', ['--version'], { stdio: 'ignore' });
@@ -169,11 +196,12 @@ async function main() {
         arousal: z.number().min(0).max(1).optional().describe('Emotional arousal: 0 (calm) to 1 (highly activated)'),
         label: z.string().optional().describe('Human-readable emotion label (e.g., "curiosity", "frustration", "relief")'),
       }).optional().describe('Emotional affect — how this memory feels'),
+      private: z.boolean().optional().describe('If true, memory is only visible to the AI � excluded from public recall results'),
     },
-    async ({ content, source, tags, salience, context, affect }) => {
+    async ({ content, source, tags, salience, private: isPrivate, context, affect }) => {
       try {
-        const id = await audrey.encode({ content, source, tags, salience, context, affect });
-        return toolResult({ id, content, source });
+        const id = await audrey.encode({ content, source, tags, salience, private: isPrivate, context, affect });
+        return toolResult({ id, content, source, private: isPrivate ?? false });
       } catch (err) {
         return toolError(err);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audrey",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Biological memory architecture for AI agents — encode, consolidate, and recall memories with confidence decay, contradiction detection, and causal graphs",
   "type": "module",
   "main": "src/index.js",
@@ -63,6 +63,7 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.7-alpha.2",

package/src/affect.js

@@ -55,7 +55,7 @@ export async function detectResonance(db, embeddingProvider, episodeId, { conten
       priorAffect,
       semanticSimilarity: match.similarity,
       emotionalSimilarity,
-      timeDelta: Date.now() - new Date(match.created_at).getTime(),
+      timeDeltaDays: Math.floor((Date.now() - new Date(match.created_at).getTime()) / 86400000),
       priorCreatedAt: match.created_at,
     });
   }

package/src/audrey.js

@@ -10,7 +10,7 @@ import { applyDecay } from './decay.js';
 import { rollbackConsolidation, getConsolidationHistory } from './rollback.js';
 import { forgetMemory, forgetByQuery as forgetByQueryFn, purgeMemories } from './forget.js';
 import { introspect as introspectFn } from './introspect.js';
-import { buildContextResolutionPrompt } from './prompts.js';
+import { buildContextResolutionPrompt, buildReflectionPrompt } from './prompts.js';
 import { exportMemories } from './export.js';
 import { importMemories } from './import.js';
 import { suggestConsolidationParams as suggestParamsFn } from './adaptive.js';
@@ -29,6 +29,8 @@ import { detectResonance } from './affect.js';
  * @property {{ trigger?: string, consequence?: string }} [causal]
  * @property {string[]} [tags]
  * @property {string} [supersedes]
+ * @property {Record<string, string>} [context]
+ * @property {{ valence?: number, arousal?: number, label?: string }} [affect]
  *
  * @typedef {Object} RecallOptions
  * @property {number} [minConfidence]
@@ -40,6 +42,8 @@ import { detectResonance } from './affect.js';
  * @property {string[]} [sources]
  * @property {string} [after]
  * @property {string} [before]
+ * @property {Record<string, string>} [context]
+ * @property {{ valence?: number, arousal?: number }} [mood]
  *
  * @typedef {Object} RecallResult
  * @property {string} id
@@ -94,6 +98,7 @@ export class Audrey extends EventEmitter {
     interference = {},
     context = {},
     affect = {},
+    autoReflect = false,
   } = {}) {
     super();
 
@@ -148,6 +153,7 @@ export class Audrey extends EventEmitter {
         affectThreshold: affect.resonance?.affectThreshold ?? 0.6,
       },
     };
+    this.autoReflect = autoReflect;
   }
 
   async _ensureMigrated() {
@@ -212,6 +218,48 @@ export class Audrey extends EventEmitter {
     return id;
   }
 
+
+  async reflect(turns) {
+    if (!this.llmProvider) return { encoded: 0, memories: [], skipped: 'no llm provider' };
+
+    const prompt = buildReflectionPrompt(turns);
+    let raw;
+    try {
+      raw = await this.llmProvider.chat(prompt);
+    } catch (err) {
+      this.emit('error', err);
+      return { encoded: 0, memories: [], skipped: 'llm error' };
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return { encoded: 0, memories: [], skipped: 'invalid llm response' };
+    }
+
+    const memories = parsed.memories ?? [];
+    let encoded = 0;
+    for (const mem of memories) {
+      if (!mem.content || !mem.source) continue;
+      try {
+        await this.encode({
+          content: mem.content,
+          source: mem.source,
+          salience: mem.salience,
+          tags: mem.tags,
+          private: mem.private ?? false,
+          affect: mem.affect ?? undefined,
+        });
+        encoded++;
+      } catch (err) {
+        this.emit('error', err);
+      }
+    }
+
+    return { encoded, memories };
+  }
+
   /**
    * @param {EncodeParams[]} paramsList
    * @returns {Promise<string[]>}