@auxiora/memory 1.0.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auxiora/memory",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,10 +14,16 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@auxiora/logger": "1.0.0",
-    "@auxiora/audit": "1.0.0",
-    "@auxiora/core": "1.0.0"
+    "@auxiora/logger": "1.3.0",
+    "@auxiora/core": "1.3.0",
+    "@auxiora/audit": "1.3.0"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",

package/src/extractor.ts

@@ -1,212 +0,0 @@
-import { getLogger } from '@auxiora/logger';
-import type { MemoryEntry, PersonalityAdaptation, SentimentResult } from './types.js';
-import type { MemoryStore } from './store.js';
-import { SentimentAnalyzer } from './sentiment.js';
-
-const logger = getLogger('memory:extractor');
-
-export interface ExtractionResult {
-  factsExtracted: MemoryEntry[];
-  patternsDetected: MemoryEntry[];
-  relationshipsFound: MemoryEntry[];
-  contradictionsFound: Array<{ existing: MemoryEntry; new: string; resolution: string }>;
-  personalitySignals: PersonalityAdaptation[];
-  sentiment?: SentimentResult;
-}
-
-export interface AIProvider {
-  complete(messages: Array<{ role: string; content: string }>, options?: { systemPrompt?: string; temperature?: number }): Promise<{ content: string }>;
-}
-
-const EXTRACTION_PROMPT = `Analyze this conversation exchange and extract structured information.
-
-User: {userMessage}
-Assistant: {assistantResponse}
-
-Respond ONLY with valid JSON (no markdown fences) with these sections:
-{
-  "facts": [{"content": "...", "category": "preference|fact|context", "importance": 0.0}],
-  "relationships": [{"content": "...", "type": "inside_joke|shared_experience|milestone|callback"}],
-  "patterns": [{"pattern": "...", "type": "communication|schedule|topic|mood"}],
-  "contradictions": [{"existingFact": "...", "newFact": "...", "resolution": "update|keep_both|ignore"}],
-  "personalitySignals": [{"trait": "humor|formality|verbosity|directness", "direction": "increase|decrease", "reason": "..."}]
-}
-
-Only extract if there's clear signal. Empty arrays are fine. Be conservative.`;
-
-interface RawFact {
-  content: string;
-  category: 'preference' | 'fact' | 'context';
-  importance: number;
-}
-
-interface RawRelationship {
-  content: string;
-  type: string;
-}
-
-interface RawPattern {
-  pattern: string;
-  type: string;
-}
-
-interface RawContradiction {
-  existingFact: string;
-  newFact: string;
-  resolution: string;
-}
-
-interface RawPersonalitySignal {
-  trait: string;
-  direction: 'increase' | 'decrease';
-  reason: string;
-}
-
-interface RawExtraction {
-  facts?: RawFact[];
-  relationships?: RawRelationship[];
-  patterns?: RawPattern[];
-  contradictions?: RawContradiction[];
-  personalitySignals?: RawPersonalitySignal[];
-}
-
-export class MemoryExtractor {
-  private sentimentAnalyzer = new SentimentAnalyzer();
-
-  constructor(
-    private store: MemoryStore,
-    private provider: AIProvider,
-  ) {}
-
-  async extract(
-    userMessage: string,
-    assistantResponse: string,
-    _sessionContext?: { messageCount: number; sessionAge: number },
-    options?: { sourceUserId?: string; partitionId?: string },
-  ): Promise<ExtractionResult> {
-    const result: ExtractionResult = {
-      factsExtracted: [],
-      patternsDetected: [],
-      relationshipsFound: [],
-      contradictionsFound: [],
-      personalitySignals: [],
-    };
-
-    // Run heuristic sentiment analysis on user message
-    result.sentiment = this.sentimentAnalyzer.analyzeSentiment(userMessage);
-
-    try {
-      const prompt = EXTRACTION_PROMPT
-        .replace('{userMessage}', userMessage)
-        .replace('{assistantResponse}', assistantResponse);
-
-      const response = await this.provider.complete(
-        [{ role: 'user', content: prompt }],
-        { temperature: 0.1 },
-      );
-
-      const parsed = this.parseResponse(response.content);
-      if (!parsed) return result;
-
-      const extraFields = {
-        ...(options?.sourceUserId ? { sourceUserId: options.sourceUserId } : {}),
-        ...(options?.partitionId ? { partitionId: options.partitionId } : {}),
-      };
-
-      // Process facts
-      if (parsed.facts) {
-        for (const fact of parsed.facts) {
-          if (!fact.content || typeof fact.content !== 'string') continue;
-          const entry = await this.store.add(
-            fact.content,
-            fact.category ?? 'fact',
-            'extracted',
-            { importance: clampNumber(fact.importance ?? 0.5, 0, 1), ...extraFields },
-          );
-          result.factsExtracted.push(entry);
-        }
-      }
-
-      // Process relationships
-      if (parsed.relationships) {
-        for (const rel of parsed.relationships) {
-          if (!rel.content || typeof rel.content !== 'string') continue;
-          const entry = await this.store.add(
-            rel.content,
-            'relationship',
-            'extracted',
-            { importance: 0.7, ...extraFields },
-          );
-          result.relationshipsFound.push(entry);
-        }
-      }
-
-      // Process patterns
-      if (parsed.patterns) {
-        for (const pat of parsed.patterns) {
-          if (!pat.pattern || typeof pat.pattern !== 'string') continue;
-          const entry = await this.store.add(
-            pat.pattern,
-            'pattern',
-            'observed',
-            { importance: 0.5, confidence: 0.4, ...extraFields },
-          );
-          result.patternsDetected.push(entry);
-        }
-      }
-
-      // Process contradictions
-      if (parsed.contradictions) {
-        for (const contra of parsed.contradictions) {
-          if (!contra.existingFact || !contra.newFact) continue;
-          const existingMemories = await this.store.search(contra.existingFact);
-          if (existingMemories.length > 0) {
-            result.contradictionsFound.push({
-              existing: existingMemories[0],
-              new: contra.newFact,
-              resolution: contra.resolution ?? 'keep_both',
-            });
-
-            if (contra.resolution === 'update' && existingMemories[0]) {
-              await this.store.update(existingMemories[0].id, {
-                content: contra.newFact,
-              });
-            }
-          }
-        }
-      }
-
-      // Process personality signals
-      if (parsed.personalitySignals) {
-        for (const sig of parsed.personalitySignals) {
-          if (!sig.trait || !sig.direction) continue;
-          result.personalitySignals.push({
-            trait: sig.trait,
-            adjustment: sig.direction === 'increase' ? 0.1 : -0.1,
-            reason: sig.reason ?? '',
-            signalCount: 1,
-          });
-        }
-      }
-    } catch (error) {
-      logger.debug('Memory extraction failed', { error: error as Error });
-    }
-
-    return result;
-  }
-
-  private parseResponse(content: string): RawExtraction | undefined {
-    try {
-      // Strip markdown code fences if present
-      const cleaned = content.replace(/^```(?:json)?\s*\n?/m, '').replace(/\n?```\s*$/m, '').trim();
-      return JSON.parse(cleaned) as RawExtraction;
-    } catch {
-      logger.debug('Failed to parse extraction response', {});
-      return undefined;
-    }
-  }
-}
-
-function clampNumber(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}

package/src/index.ts

@@ -1,22 +0,0 @@
-export type {
-  MemoryEntry,
-  MemoryCategory,
-  MemorySource,
-  MemoryPartition,
-  RelationshipMemory,
-  PatternMemory,
-  PersonalityAdaptation,
-  LivingMemoryState,
-  SentimentLabel,
-  SentimentResult,
-  SentimentSnapshot,
-} from './types.js';
-export { MemoryStore } from './store.js';
-export { MemoryRetriever } from './retriever.js';
-export { MemoryExtractor } from './extractor.js';
-export type { ExtractionResult, AIProvider } from './extractor.js';
-export { MemoryPartitionManager } from './partition.js';
-export { PatternDetector } from './pattern-detector.js';
-export type { PatternSignal } from './pattern-detector.js';
-export { PersonalityAdapter } from './personality-adapter.js';
-export { SentimentAnalyzer } from './sentiment.js';

package/src/partition.ts

@@ -1,123 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as crypto from 'node:crypto';
-import { getLogger } from '@auxiora/logger';
-import { getMemoryDir } from '@auxiora/core';
-import type { MemoryPartition } from './types.js';
-
-const logger = getLogger('memory:partition');
-
-export class MemoryPartitionManager {
-  private filePath: string;
-
-  constructor(options?: { dir?: string }) {
-    const dir = options?.dir ?? getMemoryDir();
-    this.filePath = path.join(dir, 'partitions.json');
-  }
-
-  async createPartition(
-    name: string,
-    type: MemoryPartition['type'],
-    options?: { ownerId?: string; memberIds?: string[] },
-  ): Promise<MemoryPartition> {
-    const partitions = await this.readFile();
-
-    const partition: MemoryPartition = {
-      id: type === 'global' ? 'global' : `part-${crypto.randomUUID().slice(0, 8)}`,
-      name,
-      type,
-      ownerId: options?.ownerId,
-      memberIds: options?.memberIds ?? [],
-      createdAt: Date.now(),
-    };
-
-    partitions.push(partition);
-    await this.writeFile(partitions);
-    logger.debug('Created partition', { id: partition.id, type });
-    return partition;
-  }
-
-  async getPartition(id: string): Promise<MemoryPartition | undefined> {
-    // Always have the implicit global partition
-    if (id === 'global') {
-      const partitions = await this.readFile();
-      const existing = partitions.find(p => p.id === 'global');
-      return existing ?? { id: 'global', name: 'Global', type: 'global', createdAt: 0 };
-    }
-
-    const partitions = await this.readFile();
-    return partitions.find(p => p.id === id);
-  }
-
-  async listPartitions(userId?: string): Promise<MemoryPartition[]> {
-    const partitions = await this.readFile();
-
-    // Always include the implicit global partition
-    if (!partitions.some(p => p.id === 'global')) {
-      partitions.unshift({ id: 'global', name: 'Global', type: 'global', createdAt: 0 });
-    }
-
-    if (!userId) return partitions;
-
-    // Return partitions accessible to this user
-    return partitions.filter(p =>
-      p.type === 'global' ||
-      p.ownerId === userId ||
-      p.memberIds?.includes(userId),
-    );
-  }
-
-  async deletePartition(id: string): Promise<boolean> {
-    if (id === 'global') return false;
-
-    const partitions = await this.readFile();
-    const filtered = partitions.filter(p => p.id !== id);
-    if (filtered.length === partitions.length) return false;
-
-    await this.writeFile(filtered);
-    logger.debug('Deleted partition', { id });
-    return true;
-  }
-
-  /**
-   * Check if a user has access to a partition.
-   */
-  async hasAccess(partitionId: string, userId: string): Promise<boolean> {
-    if (partitionId === 'global') return true;
-
-    const partition = await this.getPartition(partitionId);
-    if (!partition) return false;
-
-    if (partition.type === 'global') return true;
-    if (partition.ownerId === userId) return true;
-    if (partition.memberIds?.includes(userId)) return true;
-
-    return false;
-  }
-
-  /**
-   * Get all partition IDs accessible to a user.
-   */
-  async getAccessiblePartitionIds(userId: string): Promise<string[]> {
-    const accessible = await this.listPartitions(userId);
-    return accessible.map(p => p.id);
-  }
-
-  private async readFile(): Promise<MemoryPartition[]> {
-    try {
-      const content = await fs.readFile(this.filePath, 'utf-8');
-      return JSON.parse(content) as MemoryPartition[];
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  private async writeFile(partitions: MemoryPartition[]): Promise<void> {
-    const dir = path.dirname(this.filePath);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(this.filePath, JSON.stringify(partitions, null, 2), 'utf-8');
-  }
-}

package/src/pattern-detector.ts

@@ -1,304 +0,0 @@
-import type { SentimentSnapshot, SentimentLabel } from './types.js';
-
-export interface PatternSignal {
-  type: 'communication' | 'schedule' | 'topic' | 'mood';
-  pattern: string;
-  confidence: number;
-}
-
-interface MessageInfo {
-  content: string;
-  role: string;
-  timestamp: number;
-}
-
-const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-
-export class PatternDetector {
-  private sentimentHistory: SentimentSnapshot[] = [];
-
-  recordSentiment(snapshot: SentimentSnapshot): void {
-    this.sentimentHistory.push(snapshot);
-    // Keep only the last 200 snapshots
-    if (this.sentimentHistory.length > 200) {
-      this.sentimentHistory = this.sentimentHistory.slice(-200);
-    }
-  }
-
-  getSentimentHistory(): SentimentSnapshot[] {
-    return [...this.sentimentHistory];
-  }
-
-  detectMoodByTime(): PatternSignal[] {
-    if (this.sentimentHistory.length < 3) return [];
-
-    const signals: PatternSignal[] = [];
-
-    // Group by time period
-    const periodSentiments = new Map<string, SentimentLabel[]>();
-    for (const snap of this.sentimentHistory) {
-      const period = this.getTimePeriodName(snap.hour);
-      const list = periodSentiments.get(period) ?? [];
-      list.push(snap.sentiment);
-      periodSentiments.set(period, list);
-    }
-
-    for (const [period, sentiments] of periodSentiments) {
-      if (sentiments.length < 3) continue;
-      const dominant = this.getDominantSentiment(sentiments);
-      if (dominant && dominant.label !== 'neutral' && dominant.ratio > 0.6) {
-        signals.push({
-          type: 'mood',
-          pattern: `User tends to be ${dominant.label} in the ${period}`,
-          confidence: Math.min(0.4 + dominant.ratio * 0.4, 0.85),
-        });
-      }
-    }
-
-    // Group by day of week
-    const daySentiments = new Map<number, SentimentLabel[]>();
-    for (const snap of this.sentimentHistory) {
-      const list = daySentiments.get(snap.dayOfWeek) ?? [];
-      list.push(snap.sentiment);
-      daySentiments.set(snap.dayOfWeek, list);
-    }
-
-    for (const [day, sentiments] of daySentiments) {
-      if (sentiments.length < 3) continue;
-      const dominant = this.getDominantSentiment(sentiments);
-      if (dominant && dominant.label !== 'neutral' && dominant.ratio > 0.7) {
-        signals.push({
-          type: 'mood',
-          pattern: `User tends to be ${dominant.label} on ${DAY_NAMES[day]}s`,
-          confidence: Math.min(0.4 + dominant.ratio * 0.4, 0.85),
-        });
-      }
-    }
-
-    return signals;
-  }
-
-  private getDominantSentiment(sentiments: SentimentLabel[]): { label: SentimentLabel; ratio: number } | null {
-    const counts: Record<SentimentLabel, number> = { positive: 0, negative: 0, neutral: 0 };
-    for (const s of sentiments) {
-      counts[s]++;
-    }
-    const total = sentiments.length;
-    const entries: Array<[SentimentLabel, number]> = [
-      ['positive', counts.positive],
-      ['negative', counts.negative],
-      ['neutral', counts.neutral],
-    ];
-    entries.sort((a, b) => b[1] - a[1]);
-    return { label: entries[0][0], ratio: entries[0][1] / total };
-  }
-
-  private getTimePeriodName(hour: number): string {
-    if (hour >= 5 && hour < 12) return 'morning';
-    if (hour >= 12 && hour < 17) return 'afternoon';
-    if (hour >= 17 && hour < 21) return 'evening';
-    return 'night';
-  }
-
-  detect(messages: MessageInfo[]): PatternSignal[] {
-    if (messages.length < 3) return [];
-
-    const userMessages = messages.filter(m => m.role === 'user');
-    if (userMessages.length === 0) return [];
-
-    const signals: PatternSignal[] = [];
-
-    signals.push(...this.detectCommunicationPatterns(userMessages));
-    signals.push(...this.detectSchedulePatterns(userMessages));
-    signals.push(...this.detectTopicPatterns(userMessages));
-    signals.push(...this.detectMoodPatterns(userMessages));
-
-    return signals;
-  }
-
-  private detectCommunicationPatterns(messages: MessageInfo[]): PatternSignal[] {
-    const signals: PatternSignal[] = [];
-    const lengths = messages.map(m => m.content.length);
-    const avgLength = lengths.reduce((a, b) => a + b, 0) / lengths.length;
-
-    if (avgLength < 50 && messages.length >= 5) {
-      signals.push({
-        type: 'communication',
-        pattern: 'User prefers brief messages',
-        confidence: Math.min(0.5 + messages.length * 0.05, 0.9),
-      });
-    } else if (avgLength > 200 && messages.length >= 5) {
-      signals.push({
-        type: 'communication',
-        pattern: 'User writes detailed messages',
-        confidence: Math.min(0.5 + messages.length * 0.05, 0.9),
-      });
-    }
-
-    // Question frequency
-    const questionMessages = messages.filter(m => m.content.includes('?'));
-    const questionRatio = questionMessages.length / messages.length;
-    if (questionRatio > 0.6 && messages.length >= 5) {
-      signals.push({
-        type: 'communication',
-        pattern: 'User frequently asks questions',
-        confidence: Math.min(0.4 + questionRatio * 0.5, 0.9),
-      });
-    }
-
-    // Code-heavy detection
-    const codeMessages = messages.filter(m =>
-      m.content.includes('```') || m.content.includes('function ') || m.content.includes('const ') || m.content.includes('import '),
-    );
-    const codeRatio = codeMessages.length / messages.length;
-    if (codeRatio > 0.3 && messages.length >= 5) {
-      signals.push({
-        type: 'communication',
-        pattern: 'User frequently shares code snippets',
-        confidence: Math.min(0.4 + codeRatio * 0.5, 0.9),
-      });
-    }
-
-    return signals;
-  }
-
-  private detectSchedulePatterns(messages: MessageInfo[]): PatternSignal[] {
-    const signals: PatternSignal[] = [];
-    if (messages.length < 5) return signals;
-
-    const hours = messages.map(m => new Date(m.timestamp).getHours());
-    const hourCounts = new Map<number, number>();
-    for (const h of hours) {
-      hourCounts.set(h, (hourCounts.get(h) ?? 0) + 1);
-    }
-
-    // Find the peak 3-hour window
-    let peakStart = 0;
-    let peakCount = 0;
-    for (let h = 0; h < 24; h++) {
-      const count =
-        (hourCounts.get(h) ?? 0) +
-        (hourCounts.get((h + 1) % 24) ?? 0) +
-        (hourCounts.get((h + 2) % 24) ?? 0);
-      if (count > peakCount) {
-        peakCount = count;
-        peakStart = h;
-      }
-    }
-
-    const peakRatio = peakCount / messages.length;
-    if (peakRatio > 0.5) {
-      const peakEnd = (peakStart + 2) % 24;
-      const period = this.getTimePeriod(peakStart);
-      signals.push({
-        type: 'schedule',
-        pattern: `User is most active in the ${period} (${peakStart}:00-${peakEnd}:59)`,
-        confidence: Math.min(0.4 + peakRatio * 0.5, 0.9),
-      });
-    }
-
-    return signals;
-  }
-
-  private detectTopicPatterns(messages: MessageInfo[]): PatternSignal[] {
-    const signals: PatternSignal[] = [];
-    if (messages.length < 5) return signals;
-
-    const wordCounts = new Map<string, number>();
-    const stopWords = new Set([
-      'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-      'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-      'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
-      'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during',
-      'and', 'but', 'or', 'not', 'so', 'yet', 'i', 'me', 'my', 'we', 'you',
-      'your', 'he', 'she', 'they', 'it', 'what', 'which', 'who', 'when',
-      'where', 'how', 'that', 'this', 'just', 'like', 'also', 'about',
-      'than', 'too', 'very', 'its', 'them', 'their', 'our',
-    ]);
-
-    for (const msg of messages) {
-      const words = msg.content
-        .toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, '')
-        .split(/\s+/)
-        .filter(w => w.length > 2 && !stopWords.has(w));
-
-      for (const word of words) {
-        wordCounts.set(word, (wordCounts.get(word) ?? 0) + 1);
-      }
-    }
-
-    const topWords = Array.from(wordCounts.entries())
-      .filter(([, count]) => count >= 3)
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 5);
-
-    if (topWords.length >= 2) {
-      const topics = topWords.map(([word]) => word).join(', ');
-      signals.push({
-        type: 'topic',
-        pattern: `User frequently discusses: ${topics}`,
-        confidence: Math.min(0.5 + topWords.length * 0.05, 0.85),
-      });
-    }
-
-    return signals;
-  }
-
-  private detectMoodPatterns(messages: MessageInfo[]): PatternSignal[] {
-    const signals: PatternSignal[] = [];
-    if (messages.length < 5) return signals;
-
-    let enthusiastic = 0;
-    let frustrated = 0;
-    let casual = 0;
-
-    for (const msg of messages) {
-      const text = msg.content;
-      if (text.includes('!') || /\b(great|awesome|love|amazing|excellent|perfect)\b/i.test(text)) {
-        enthusiastic++;
-      }
-      if (/\b(ugh|damn|broken|bug|error|fail|wrong|issue|problem)\b/i.test(text)) {
-        frustrated++;
-      }
-      if (/\b(lol|haha|heh|lmao|tbh|imo|btw|gonna|wanna)\b/i.test(text)) {
-        casual++;
-      }
-    }
-
-    const total = messages.length;
-
-    if (enthusiastic / total > 0.3) {
-      signals.push({
-        type: 'mood',
-        pattern: 'User tends to be enthusiastic and positive',
-        confidence: Math.min(0.4 + (enthusiastic / total) * 0.5, 0.85),
-      });
-    }
-
-    if (frustrated / total > 0.3) {
-      signals.push({
-        type: 'mood',
-        pattern: 'User may be experiencing frustration',
-        confidence: Math.min(0.4 + (frustrated / total) * 0.5, 0.85),
-      });
-    }
-
-    if (casual / total > 0.3) {
-      signals.push({
-        type: 'mood',
-        pattern: 'User uses casual, informal language',
-        confidence: Math.min(0.4 + (casual / total) * 0.5, 0.85),
-      });
-    }
-
-    return signals;
-  }
-
-  private getTimePeriod(hour: number): string {
-    if (hour >= 5 && hour < 12) return 'morning';
-    if (hour >= 12 && hour < 17) return 'afternoon';
-    if (hour >= 17 && hour < 21) return 'evening';
-    return 'night';
-  }
-}