@game_ryo/lsji 0.1.0 → 0.3.0

package/src/llm/memory/episodic.js

@@ -0,0 +1,312 @@
+/**
+ * Episodic Memory
+ * 
+ * Event-based memory for tracking agent actions and outcomes.
+ * Useful for learning from past experiences.
+ */
+
+import { createStorage } from '../../index.js';
+
+/**
+ * Episode record
+ * @typedef {Object} Episode
+ * @property {string} id - Unique ID
+ * @property {string} task - Task description
+ * @property {Array} steps - Steps taken
+ * @property {string} outcome - 'success' | 'failure' | 'partial'
+ * @property {Object} context - Initial context
+ * @property {Object} result - Final result
+ * @property {number} duration - Duration in ms
+ * @property {number} tokensUsed - Total tokens used
+ * @property {number} cost - Total cost
+ * @property {Date} startedAt
+ * @property {Date} completedAt
+ * @property {Array} [tags] - Tags for categorization
+ */
+
+/**
+ * Episodic Memory - Event-based experience storage
+ */
+export class EpisodicMemory {
+  constructor({ storage } = {}) {
+    this.storage = storage;
+    this.currentEpisode = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize episodes table
+   */
+  async initialize() {
+    if (this.initialized) return;
+    
+    if (this.storage.db) {
+      await this.storage.db.exec(`
+        CREATE TABLE IF NOT EXISTS episodes (
+          id TEXT PRIMARY KEY,
+          task TEXT NOT NULL,
+          steps TEXT NOT NULL,
+          outcome TEXT NOT NULL,
+          context TEXT NOT NULL,
+          result TEXT,
+          duration INTEGER,
+          tokens_used INTEGER,
+          cost REAL,
+          started_at TEXT NOT NULL,
+          completed_at TEXT,
+          tags TEXT
+        )
+      `);
+      
+      await this.storage.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_episodes_outcome ON episodes(outcome)
+      `);
+      
+      await this.storage.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_episodes_started ON episodes(started_at)
+      `);
+      
+      await this.storage.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_episodes_tags ON episodes(tags)
+      `);
+    }
+    
+    this.initialized = true;
+  }
+
+  /**
+   * Start a new episode
+   */
+  async startEpisode(task, context = {}, tags = []) {
+    await this.initialize();
+    
+    this.currentEpisode = {
+      id: `episode_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      task,
+      steps: [],
+      outcome: 'in_progress',
+      context,
+      result: null,
+      duration: 0,
+      tokensUsed: 0,
+      cost: 0,
+      startedAt: new Date().toISOString(),
+      completedAt: null,
+      tags,
+    };
+    
+    return this.currentEpisode.id;
+  }
+
+  /**
+   * Add a step to current episode
+   */
+  async addStep(step) {
+    if (!this.currentEpisode) {
+      throw new Error('No active episode. Call startEpisode() first.');
+    }
+    
+    this.currentEpisode.steps.push({
+      ...step,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /**
+   * End current episode
+   */
+  async endEpisode(outcome, result = null) {
+    if (!this.currentEpisode) {
+      throw new Error('No active episode. Call startEpisode() first.');
+    }
+    
+    const completedAt = new Date().toISOString();
+    const startedAt = new Date(this.currentEpisode.startedAt);
+    
+    this.currentEpisode.outcome = outcome;
+    this.currentEpisode.result = result;
+    this.currentEpisode.completedAt = completedAt;
+    this.currentEpisode.duration = new Date(completedAt).getTime() - startedAt.getTime();
+    
+    // Persist
+    if (this.storage.db) {
+      await this.storage.db.run(
+        `INSERT INTO episodes (id, task, steps, outcome, context, result, duration, tokens_used, cost, started_at, completed_at, tags)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          this.currentEpisode.id,
+          this.currentEpisode.task,
+          JSON.stringify(this.currentEpisode.steps),
+          this.currentEpisode.outcome,
+          JSON.stringify(this.currentEpisode.context),
+          JSON.stringify(this.currentEpisode.result),
+          this.currentEpisode.duration,
+          this.currentEpisode.tokensUsed,
+          this.currentEpisode.cost,
+          this.currentEpisode.startedAt,
+          this.currentEpisode.completedAt,
+          JSON.stringify(this.currentEpisode.tags),
+        ]
+      );
+    } else {
+      if (!this.memoryEpisodes) this.memoryEpisodes = new Map();
+      this.memoryEpisodes.set(this.currentEpisode.id, this.currentEpisode);
+    }
+    
+    const episode = this.currentEpisode;
+    this.currentEpisode = null;
+    return episode;
+  }
+
+  /**
+   * Record token usage for current episode
+   */
+  recordTokens(tokens) {
+    if (this.currentEpisode) {
+      this.currentEpisode.tokensUsed += tokens;
+    }
+  }
+
+  /**
+   * Record cost for current episode
+   */
+  recordCost(cost) {
+    if (this.currentEpisode) {
+      this.currentEpisode.cost += cost;
+    }
+  }
+
+  /**
+   * Get episode by ID
+   */
+  async getEpisode(id) {
+    await this.initialize();
+    
+    if (this.storage.db) {
+      const row = await this.storage.db.get('SELECT * FROM episodes WHERE id = ?', [id]);
+      if (!row) return null;
+      return this.rowToEpisode(row);
+    } else {
+      return this.memoryEpisodes?.get(id) || null;
+    }
+  }
+
+  /**
+   * Search episodes
+   */
+  async search({ outcome, tags = [], limit = 50, since = null } = {}) {
+    await this.initialize();
+    
+    let results = [];
+    
+    if (this.storage.db) {
+      let sql = 'SELECT * FROM episodes WHERE 1=1';
+      const params = [];
+      
+      if (outcome) {
+        sql += ' AND outcome = ?';
+        params.push(outcome);
+      }
+      
+      if (tags.length > 0) {
+        const tagConditions = tags.map(() => 'tags LIKE ?').join(' OR ');
+        sql += ` AND (${tagConditions})`;
+        for (const tag of tags) {
+          params.push(`%"${tag}"%`);
+        }
+      }
+      
+      if (since) {
+        sql += ' AND started_at >= ?';
+        params.push(since.toISOString());
+      }
+      
+      sql += ' ORDER BY started_at DESC LIMIT ?';
+      params.push(limit);
+      
+      const rows = await this.storage.db.all(sql, params);
+      results = rows.map(r => this.rowToEpisode(r));
+    } else {
+      for (const ep of this.memoryEpisodes?.values() || []) {
+        if (outcome && ep.outcome !== outcome) continue;
+        if (tags.length > 0 && !tags.some(t => ep.tags.includes(t))) continue;
+        if (since && new Date(ep.startedAt) < since) continue;
+        results.push(ep);
+      }
+      results.sort((a, b) => new Date(b.startedAt) - new Date(a.startedAt));
+      results = results.slice(0, limit);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Get successful episodes for a task type
+   */
+  async getSuccessfulEpisodes(taskPattern, limit = 10) {
+    const episodes = await this.search({ outcome: 'success', limit: 100 });
+    return episodes
+      .filter(e => e.task.includes(taskPattern))
+      .slice(0, limit);
+  }
+
+  /**
+   * Get failure episodes for analysis
+   */
+  async getFailures({ limit = 50, since = null } = {}) {
+    return this.search({ outcome: 'failure', limit, since });
+  }
+
+  /**
+   * Get episode statistics
+   */
+  async getStats() {
+    await this.initialize();
+    
+    if (this.storage.db) {
+      const row = await this.storage.db.get(`
+        SELECT 
+          COUNT(*) as total,
+          SUM(CASE WHEN outcome = 'success' THEN 1 ELSE 0 END) as successes,
+          SUM(CASE WHEN outcome = 'failure' THEN 1 ELSE 0 END) as failures,
+          SUM(CASE WHEN outcome = 'partial' THEN 1 ELSE 0 END) as partials,
+          AVG(duration) as avg_duration,
+          AVG(tokens_used) as avg_tokens,
+          AVG(cost) as avg_cost
+        FROM episodes
+      `);
+      return row;
+    }
+    
+    return { total: 0, successes: 0, failures: 0, partials: 0 };
+  }
+
+  rowToEpisode(row) {
+    return {
+      id: row.id,
+      task: row.task,
+      steps: JSON.parse(row.steps || '[]'),
+      outcome: row.outcome,
+      context: JSON.parse(row.context || '{}'),
+      result: row.result ? JSON.parse(row.result) : null,
+      duration: row.duration,
+      tokensUsed: row.tokens_used,
+      cost: row.cost,
+      startedAt: row.started_at,
+      completedAt: row.completed_at,
+      tags: JSON.parse(row.tags || '[]'),
+    };
+  }
+}
+
+/**
+ * Create episodic memory from config
+ */
+export async function createEpisodicMemory(config = {}) {
+  const storage = await createStorage(
+    config.storage?.type || 'sqlite',
+    config.storage?.options || {}
+  );
+  
+  return new EpisodicMemory({ storage });
+}

package/src/llm/memory/index.js

@@ -0,0 +1,12 @@
+/**
+ * Memory Systems
+ * 
+ * Exports all memory components:
+ * - ConversationMemory: Short-term conversation history
+ * - SemanticMemory: Long-term knowledge with retrieval
+ * - EpisodicMemory: Event-based experience tracking
+ */
+
+export { ConversationMemory, createConversationMemory } from './conversation.js';
+export { SemanticMemory, createSemanticMemory } from './semantic.js';
+export { EpisodicMemory, createEpisodicMemory } from './episodic.js';

package/src/llm/memory/semantic.js

@@ -0,0 +1,324 @@
+/**
+ * Semantic Memory
+ * 
+ * Long-term knowledge storage with vector embeddings for retrieval.
+ * Uses simple keyword-based retrieval (can be extended with vector DB).
+ */
+
+import { createStorage } from '../../index.js';
+
+/**
+ * Knowledge entry
+ * @typedef {Object} KnowledgeEntry
+ * @property {string} id - Unique ID
+ * @property {string} content - Knowledge content
+ * @property {Array<string>} tags - Tags for categorization
+ * @property {Object} metadata - Additional metadata
+ * @property {number} [embedding] - Vector embedding (placeholder)
+ * @property {Date} createdAt
+ * @property {Date} updatedAt
+ * @property {number} accessCount - Number of times accessed
+ */
+
+/**
+ * Semantic Memory - Long-term knowledge storage
+ */
+export class SemanticMemory {
+  constructor({ storage, embedder } = {}) {
+    this.storage = storage;
+    this.embedder = embedder; // Function to generate embeddings
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize knowledge table
+   */
+  async initialize() {
+    if (this.initialized) return;
+    
+    if (this.storage.db) {
+      await this.storage.db.exec(`
+        CREATE TABLE IF NOT EXISTS knowledge (
+          id TEXT PRIMARY KEY,
+          content TEXT NOT NULL,
+          tags TEXT NOT NULL,
+          metadata TEXT,
+          embedding TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          access_count INTEGER DEFAULT 0
+        )
+      `);
+      
+      await this.storage.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_knowledge_tags ON knowledge(tags)
+      `);
+      
+      await this.storage.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_knowledge_created ON knowledge(created_at)
+      `);
+    }
+    
+    this.initialized = true;
+  }
+
+  /**
+   * Store knowledge
+   */
+  async store(content, { tags = [], metadata = {}, id = null } = {}) {
+    await this.initialize();
+    
+    const entryId = id || `knowledge_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const now = new Date().toISOString();
+    
+    let embedding = null;
+    if (this.embedder) {
+      embedding = await this.embedder(content);
+    }
+    
+    const entry = {
+      id: entryId,
+      content,
+      tags: JSON.stringify(tags),
+      metadata: JSON.stringify(metadata),
+      embedding: embedding ? JSON.stringify(embedding) : null,
+      createdAt: now,
+      updatedAt: now,
+      accessCount: 0,
+    };
+    
+    if (this.storage.db) {
+      await this.storage.db.run(
+        `INSERT INTO knowledge (id, content, tags, metadata, embedding, created_at, updated_at, access_count)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        [entry.id, entry.content, entry.tags, entry.metadata, entry.embedding, entry.createdAt, entry.updatedAt, entry.accessCount]
+      );
+    } else {
+      if (!this.memoryKnowledge) this.memoryKnowledge = new Map();
+      this.memoryKnowledge.set(entryId, entry);
+    }
+    
+    return entry;
+  }
+
+  /**
+   * Retrieve knowledge by query
+   */
+  async retrieve(query, { limit = 10, tags = [] } = {}) {
+    await this.initialize();
+    
+    let results = [];
+    
+    if (this.storage.db) {
+      let sql = 'SELECT * FROM knowledge WHERE 1=1';
+      const params = [];
+      
+      // Add tag filter
+      if (tags.length > 0) {
+        const tagConditions = tags.map(() => 'tags LIKE ?').join(' OR ');
+        sql += ` AND (${tagConditions})`;
+        for (const tag of tags) {
+          params.push(`%"${tag}"%`);
+        }
+      }
+      
+      sql += ' ORDER BY access_count DESC, created_at DESC LIMIT ?';
+      params.push(limit);
+      
+      const rows = await this.storage.db.all(sql, params);
+      
+      for (const row of rows) {
+        results.push(this.rowToEntry(row));
+      }
+    } else {
+      for (const entry of this.memoryKnowledge?.values() || []) {
+        if (tags.length === 0 || tags.some(t => entry.tags.includes(t))) {
+          results.push(entry);
+        }
+      }
+      results.sort((a, b) => b.accessCount - a.accessCount);
+      results = results.slice(0, limit);
+    }
+    
+    // Simple keyword relevance scoring
+    const queryWords = query.toLowerCase().split(/\s+/);
+    for (const entry of results) {
+      const contentWords = entry.content.toLowerCase().split(/\s+/);
+      let score = 0;
+      for (const qw of queryWords) {
+        for (const cw of contentWords) {
+          if (cw.includes(qw) || qw.includes(cw)) score++;
+        }
+      }
+      entry.relevanceScore = score;
+    }
+    
+    // Sort by relevance
+    results.sort((a, b) => (b.relevanceScore || 0) - (a.relevanceScore || 0));
+    
+    // Update access count
+    for (const entry of results) {
+      await this.incrementAccess(entry.id);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Get knowledge by ID
+   */
+  async get(id) {
+    await this.initialize();
+    
+    if (this.storage.db) {
+      const row = await this.storage.db.get('SELECT * FROM knowledge WHERE id = ?', [id]);
+      if (!row) return null;
+      return this.rowToEntry(row);
+    } else {
+      return this.memoryKnowledge?.get(id) || null;
+    }
+  }
+
+  /**
+   * Update knowledge
+   */
+  async update(id, { content, tags, metadata } = {}) {
+    await this.initialize();
+    
+    const entry = await this.get(id);
+    if (!entry) throw new Error(`Knowledge not found: ${id}`);
+    
+    const updates = [];
+    const params = [];
+    
+    if (content !== undefined) {
+      entry.content = content;
+      updates.push('content = ?');
+      params.push(content);
+      
+      if (this.embedder) {
+        entry.embedding = JSON.stringify(await this.embedder(content));
+        updates.push('embedding = ?');
+        params.push(entry.embedding);
+      }
+    }
+    
+    if (tags !== undefined) {
+      entry.tags = JSON.stringify(tags);
+      updates.push('tags = ?');
+      params.push(entry.tags);
+    }
+    
+    if (metadata !== undefined) {
+      entry.metadata = JSON.stringify({ ...JSON.parse(entry.metadata), ...metadata });
+      updates.push('metadata = ?');
+      params.push(entry.metadata);
+    }
+    
+    entry.updatedAt = new Date().toISOString();
+    updates.push('updated_at = ?');
+    params.push(entry.updatedAt);
+    
+    params.push(id);
+    
+    if (this.storage.db) {
+      await this.storage.db.run(
+        `UPDATE knowledge SET ${updates.join(', ')} WHERE id = ?`,
+        params
+      );
+    } else {
+      this.memoryKnowledge.set(id, entry);
+    }
+    
+    return entry;
+  }
+
+  /**
+   * Delete knowledge
+   */
+  async delete(id) {
+    await this.initialize();
+    
+    if (this.storage.db) {
+      await this.storage.db.run('DELETE FROM knowledge WHERE id = ?', [id]);
+    } else {
+      this.memoryKnowledge?.delete(id);
+    }
+  }
+
+  /**
+   * Increment access count
+   */
+  async incrementAccess(id) {
+    await this.initialize();
+    
+    if (this.storage.db) {
+      await this.storage.db.run(
+        'UPDATE knowledge SET access_count = access_count + 1 WHERE id = ?',
+        [id]
+      );
+    } else {
+      const entry = this.memoryKnowledge?.get(id);
+      if (entry) {
+        entry.accessCount++;
+        this.memoryKnowledge.set(id, entry);
+      }
+    }
+  }
+
+  /**
+   * List all knowledge
+   */
+  async list({ limit = 100, tags = [] } = {}) {
+    await this.initialize();
+    
+    if (this.storage.db) {
+      let sql = 'SELECT * FROM knowledge WHERE 1=1';
+      const params = [];
+      
+      if (tags.length > 0) {
+        const tagConditions = tags.map(() => 'tags LIKE ?').join(' OR ');
+        sql += ` AND (${tagConditions})`;
+        for (const tag of tags) {
+          params.push(`%"${tag}"%`);
+        }
+      }
+      
+      sql += ' ORDER BY created_at DESC LIMIT ?';
+      params.push(limit);
+      
+      const rows = await this.storage.db.all(sql, params);
+      return rows.map(r => this.rowToEntry(r));
+    }
+    
+    return [];
+  }
+
+  rowToEntry(row) {
+    return {
+      id: row.id,
+      content: row.content,
+      tags: JSON.parse(row.tags || '[]'),
+      metadata: JSON.parse(row.metadata || '{}'),
+      embedding: row.embedding ? JSON.parse(row.embedding) : null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      accessCount: row.access_count || 0,
+    };
+  }
+}
+
+/**
+ * Create semantic memory from config
+ */
+export async function createSemanticMemory(config = {}) {
+  const storage = await createStorage(
+    config.storage?.type || 'sqlite',
+    config.storage?.options || {}
+  );
+  
+  return new SemanticMemory({
+    storage,
+    embedder: config.embedder,
+  });
+}