adaptive-memory-multi-model-router 1.3.0 → 1.4.0

package/src/memory/memoryTree.ts

@@ -0,0 +1,242 @@
+/**
+ * Memory Tree Hierarchy
+ * 
+ * Canonicalizes data into ≤3k-token chunks, scores them,
+ * and builds hierarchical summary trees.
+ */
+
+export interface MemoryChunk {
+  id: string;
+  content: string;
+  score: number;
+  parentId?: string;
+  depth: number;
+  createdAt: number;
+  accessCount: number;
+}
+
+export interface TreeNode {
+  id: string;
+  chunks: MemoryChunk[];
+  summary: string;
+  children: TreeNode[];
+  depth: number;
+}
+
+export class MemoryTree {
+  private maxChunkSize: number;
+  private root: TreeNode;
+  private chunks: Map<string, MemoryChunk>;
+  private idCounter: number;
+
+  constructor(maxChunkSize = 3000) {
+    this.maxChunkSize = maxChunkSize;
+    this.root = this.createNode('root');
+    this.chunks = new Map();
+    this.idCounter = 0;
+  }
+
+  private createNode(id: string, depth = 0): TreeNode {
+    return { id, chunks: [], summary: '', children: [], depth };
+  }
+
+  private generateId(): string {
+    return `chunk_${Date.now()}_${this.idCounter++}`;
+  }
+
+  /**
+   * Add data to the memory tree
+   */
+  async add(data: string): Promise<MemoryChunk[]> {
+    const textChunks = this.chunk(data);
+    const addedChunks: MemoryChunk[] = [];
+
+    for (const text of textChunks) {
+      const score = await this.scoreChunk(text);
+      const chunk: MemoryChunk = {
+        id: this.generateId(),
+        content: text,
+        score,
+        depth: 0,
+        createdAt: Date.now(),
+        accessCount: 0
+      };
+
+      this.chunks.set(chunk.id, chunk);
+      this.root.chunks.push(chunk);
+      this.insertIntoTree(chunk);
+      addedChunks.push(chunk);
+    }
+
+    await this.updateSummaries();
+    return addedChunks;
+  }
+
+  /**
+   * Split text into chunks of maxChunkSize
+   */
+  private chunk(text: string): string[] {
+    const chunks: string[] = [];
+    const words = text.split(/\s+/);
+    let current: string[] = [];
+    let currentSize = 0;
+
+    for (const word of words) {
+      currentSize += word.length + 1;
+      if (currentSize > this.maxChunkSize) {
+        chunks.push(current.join(' '));
+        current = [word];
+        currentSize = word.length + 1;
+      } else {
+        current.push(word);
+      }
+    }
+
+    if (current.length > 0) {
+      chunks.push(current.join(' '));
+    }
+
+    return chunks;
+  }
+
+  /**
+   * Score a chunk by relevance
+   */
+  private async scoreChunk(content: string): Promise<number> {
+    // Simple scoring: length + unique words ratio
+    const words = content.split(/\s+/);
+    const uniqueWords = new Set(words.map(w => w.toLowerCase()));
+    const uniqueRatio = uniqueWords.size / words.length;
+    
+    // Base score + bonus for high unique ratio
+    return Math.min(1, (content.length / this.maxChunkSize) * uniqueRatio * 1.5);
+  }
+
+  /**
+   * Insert chunk into tree hierarchy
+   */
+  private insertIntoTree(chunk: MemoryChunk) {
+    let parent = this.root;
+    
+    while (parent.children.length > 0 && chunk.score < 0.5) {
+      // Find best matching child
+      let bestChild = parent.children[0];
+      let bestScore = 0;
+
+      for (const child of parent.children) {
+        const avgScore = this.getAverageScore(child);
+        if (avgScore > bestScore && avgScore >= chunk.score) {
+          bestScore = avgScore;
+          bestChild = child;
+        }
+      }
+
+      if (bestScore >= chunk.score) {
+        parent = bestChild;
+        chunk.depth = parent.depth + 1;
+        chunk.parentId = parent.id;
+      } else {
+        break;
+      }
+    }
+
+    parent.chunks.push(chunk);
+  }
+
+  private getAverageScore(node: TreeNode): number {
+    if (node.chunks.length === 0) return 0;
+    return node.chunks.reduce((sum, c) => sum + c.score, 0) / node.chunks.length;
+  }
+
+  /**
+   * Update summaries for tree nodes
+   */
+  private async updateSummaries() {
+    this.summarizeNode(this.root);
+  }
+
+  private summarizeNode(node: TreeNode) {
+    const allContent = node.chunks.map(c => c.content).join(' ');
+    node.summary = allContent.slice(0, 200) + (allContent.length > 200 ? '...' : '');
+
+    for (const child of node.children) {
+      this.summarizeNode(child);
+    }
+  }
+
+  /**
+   * Search chunks by content
+   */
+  search(query: string): MemoryChunk[] {
+    const results: MemoryChunk[] = [];
+    const queryLower = query.toLowerCase();
+
+    for (const chunk of this.chunks.values()) {
+      if (chunk.content.toLowerCase().includes(queryLower)) {
+        chunk.accessCount++;
+        results.push(chunk);
+      }
+    }
+
+    return results.sort((a, b) => b.score - a.score);
+  }
+
+  /**
+   * Get context for routing
+   */
+  getContext(maxTokens = 3000): string {
+    const allChunks = Array.from(this.chunks.values())
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 10);
+
+    let context = allChunks.map(c => c.content).join('\n\n');
+    
+    if (context.length > maxTokens) {
+      context = context.slice(0, maxTokens) + '...';
+    }
+
+    return context;
+  }
+
+  /**
+   * Export as markdown for Obsidian
+   */
+  toMarkdown(): string {
+    const lines: string[] = ['# Memory Tree\n'];
+
+    const traverse = (node: TreeNode, prefix = '') => {
+      for (const chunk of node.chunks) {
+        lines.push(`${prefix}## ${chunk.id} (score: ${chunk.score.toFixed(2)})`);
+        lines.push(chunk.content);
+        lines.push('');
+      }
+
+      for (const child of node.children) {
+        lines.push(`${prefix}### ${child.id}`);
+        traverse(child, prefix + '#');
+      }
+    };
+
+    traverse(this.root);
+    return lines.join('\n');
+  }
+
+  /**
+   * Get tree stats
+   */
+  getStats() {
+    return {
+      totalChunks: this.chunks.size,
+      maxDepth: this.getMaxDepth(this.root),
+      rootChunks: this.root.chunks.length,
+      treeSize: JSON.stringify(this.root).length
+    };
+  }
+
+  private getMaxDepth(node: TreeNode): number {
+    if (node.children.length === 0) return node.depth;
+    return Math.max(...node.children.map(c => this.getMaxDepth(c)));
+  }
+}
+
+export default MemoryTree;

package/src/memory/obsidianVault.ts

@@ -0,0 +1,224 @@
+/**
+ * Obsidian Vault Integration
+ * 
+ * Stores routing decisions and context as markdown files
+ * compatible with Obsidian note-taking app.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface VaultConfig {
+  path: string;
+  autoSave: boolean;
+  maxFileAge: number; // days
+}
+
+export interface RoutingDecision {
+  id: string;
+  timestamp: number;
+  prompt: string;
+  context: any;
+  selectedProvider: string;
+  selectedModel: string;
+  reasoning: string;
+  cost: number;
+  latency: number;
+}
+
+export class ObsidianVault {
+  private config: VaultConfig;
+  private decisions: RoutingDecision[];
+
+  constructor(config: Partial<VaultConfig> = {}) {
+    this.config = {
+      path: config.path || './vault',
+      autoSave: config.autoSave !== false,
+      maxFileAge: config.maxFileAge || 30
+    };
+    this.decisions = [];
+    this.ensureDirectory();
+  }
+
+  private ensureDirectory() {
+    if (!fs.existsSync(this.config.path)) {
+      fs.mkdirSync(this.config.path, { recursive: true });
+    }
+  }
+
+  /**
+   * Save a routing decision
+   */
+  async saveDecision(decision: RoutingDecision): Promise<string> {
+    this.decisions.push(decision);
+    
+    const filename = `routing-decision-${decision.id}.md`;
+    const filepath = path.join(this.config.path, filename);
+    const content = this.formatDecisionAsMarkdown(decision);
+    
+    fs.writeFileSync(filepath, content, 'utf-8');
+    
+    // Update index
+    await this.updateIndex();
+    
+    return filepath;
+  }
+
+  /**
+   * Format decision as markdown
+   */
+  private formatDecisionAsMarkdown(decision: RoutingDecision): string {
+    const date = new Date(decision.timestamp).toISOString();
+    
+    return `# Routing Decision ${decision.id}
+
+**Date:** ${date}
+**Prompt:** ${this.escapeMarkdown(decision.prompt.substring(0, 200))}
+
+## Decision
+
+| Field | Value |
+|-------|-------|
+| Provider | ${decision.selectedProvider} |
+| Model | ${decision.selectedModel} |
+| Reasoning | ${this.escapeMarkdown(decision.reasoning)} |
+| Cost | $${decision.cost.toFixed(4)} |
+| Latency | ${decision.latency}ms |
+
+## Context
+
+\`\`\`json
+${JSON.stringify(decision.context, null, 2)}
+\`\`\`
+
+## Prompt (Full)
+
+${decision.prompt}
+
+---
+*Generated by A3M Router*
+`;
+  }
+
+  /**
+   * Escape markdown special characters
+   */
+  private escapeMarkdown(text: string): string {
+    return text
+      .replace(/\*/g, '\\*')
+      .replace(/#/g, '\\#')
+      .replace(/\|/g, '\\|')
+      .replace(/`/g, '\\`');
+  }
+
+  /**
+   * Update the vault index
+   */
+  private async updateIndex() {
+    const indexPath = path.join(this.config.path, 'routing-index.md');
+    
+    const lines = [
+      '# Routing Decisions Index',
+      '',
+      `Last updated: ${new Date().toISOString()}`,
+      '',
+      `Total decisions: ${this.decisions.length}`,
+      '',
+      '## Recent Decisions',
+      ''
+    ];
+
+    for (const decision of this.decisions.slice(-20).reverse()) {
+      const date = new Date(decision.timestamp).toLocaleDateString();
+      lines.push(`- [${decision.id}](./routing-decision-${decision.id}.md) - ${date} - ${decision.selectedProvider}/${decision.selectedModel}`);
+    }
+
+    fs.writeFileSync(indexPath, lines.join('\n'), 'utf-8');
+  }
+
+  /**
+   * Get recent decisions
+   */
+  getRecentDecisions(count = 10): RoutingDecision[] {
+    return this.decisions.slice(-count).reverse();
+  }
+
+  /**
+   * Search decisions
+   */
+  searchDecisions(query: string): RoutingDecision[] {
+    const queryLower = query.toLowerCase();
+    return this.decisions.filter(d => 
+      d.prompt.toLowerCase().includes(queryLower) ||
+      d.selectedProvider.toLowerCase().includes(queryLower) ||
+      d.selectedModel.toLowerCase().includes(queryLower)
+    );
+  }
+
+  /**
+   * Export all decisions
+   */
+  async exportAll(filepath: string) {
+    const content = this.decisions.map(d => 
+      this.formatDecisionAsMarkdown(d)
+    ).join('\n\n---\n\n');
+
+    fs.writeFileSync(filepath, content, 'utf-8');
+  }
+
+  /**
+   * Get vault statistics
+   */
+  getStats() {
+    return {
+      totalDecisions: this.decisions.length,
+      vaultPath: this.config.path,
+      fileCount: fs.readdirSync(this.config.path).filter(f => f.endsWith('.md')).length,
+      totalSize: this.getDirectorySize(this.config.path)
+    };
+  }
+
+  private getDirectorySize(dir: string): number {
+    let size = 0;
+    const files = fs.readdirSync(dir);
+    
+    for (const file of files) {
+      const filepath = path.join(dir, file);
+      const stat = fs.statSync(filepath);
+      
+      if (stat.isDirectory()) {
+        size += this.getDirectorySize(filepath);
+      } else {
+        size += stat.size;
+      }
+    }
+    
+    return size;
+  }
+
+  /**
+   * Clean old files
+   */
+  async cleanOldFiles() {
+    const maxAge = this.config.maxFileAge * 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    const files = fs.readdirSync(this.config.path);
+    let cleaned = 0;
+
+    for (const file of files) {
+      if (!file.endsWith('.md') || file === 'routing-index.md') continue;
+      
+      const filepath = path.join(this.config.path, file);
+      const stat = fs.statSync(filepath);
+      
+      if (now - stat.mtimeMs > maxAge) {
+        fs.unlinkSync(filepath);
+        cleaned++;
+      }
+    }
+
+    return cleaned;
+  }
+}
+
+export default ObsidianVault;