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

package/README.md

@@ -84,9 +84,60 @@ npx a3m-router cost
 
 ---
 
+## LLM Providers (14 Supported)
+
+| Provider | Best For | Speed | Cost |
+|----------|----------|-------|------|
+| **OpenAI** | GPT-4o, GPT-4o-mini | Fast | $ |
+| **OpenRouter** | 100+ models | Varies | $$ |
+| **Groq** | Llama-3.3-70B | **Fastest** | Free tier |
+| **Cerebras** | Llama-3.3-70B | Ultra-fast | Free tier |
+| **Anthropic** | Claude-3.5-Sonnet | Fast | $$$ |
+| **Google** | Gemini-Pro/Flash | Fast | $ |
+| **DeepSeek** | Coding, Math | Fast | $ |
+| **Fireworks** | Mixtral-8x7B | Fast | $ |
+| **Perplexity** | Real-time search | Fast | $ |
+| **Cohere** | RAG, Embeddings | Fast | $ |
+| **Mistral** | Large/Small | Fast | $ |
+| **AWS Bedrock** | Claude/Llama | Fast | $$$ |
+| **xAI** | Grok-2 | Fast | $ |
+| **Ollama** | Local models | Varies | **Free** |
+
+---
+
+## Agent & Tool Integrations (10)
+
+```javascript
+import { createIntegration } from 'adaptive-memory-multi-model-router/integrations';
+
+// GitHub - PRs, Issues, Repos
+const github = createIntegration('github', { apiKey: 'ghp_...' });
+await github.createIssue('owner', 'repo', 'Bug fix', 'Description');
+
+// Slack - Messaging
+const slack = createIntegration('slack', { webhookUrl: 'https://hooks.slack.com/...' });
+await slack.sendMessage('#dev-team', 'Build complete!');
+
+// Telegram - Bots
+const telegram = createIntegration('telegram', { botToken: '...' });
+await telegram.sendMessage(chatId, 'Hello from A3M Router!');
+
+// Notion - Docs & Databases
+const notion = createIntegration('notion', { apiKey: 'secret_...' });
+await notion.queryDatabase('database-id');
+
+// Linear - Project Management
+const linear = createIntegration('linear', { apiKey: 'lin_api_' });
+await linear.createIssue('Fix auth bug', 'Critical', 'team-id');
+
+// And more: Jira, Gmail, Discord, Airtable, Google Calendar
+```
+
+---
+
 ## For Python Developers
 
-**LangChain, LlamaIndex, AutoGen, CrewAI** — all supported.
+**LangChain, LlamaIndex, AutoGen, CrewAI, HuggingFace** — all supported.
 
 ```python
 from langchain import LLMChain
@@ -98,16 +149,6 @@ chain = LLMChain(llm=router, prompt=my_prompt)
 result = chain.run("your query")
 ```
 
-### Supported Providers
-
-| Provider | Models | Notes |
-|----------|--------|-------|
-| OpenAI | gpt-4, gpt-3.5 | ✅ Production ready |
-| Anthropic | claude-3.5, claude-3 | ✅ Production ready |
-| Ollama | llama3, mistral | ✅ Local, zero cost |
-| vLLM | Any HuggingFace | ✅ Self-hosted |
-| LM Studio | Any GGUF | ✅ Local privacy |
-
 ---
 
 ## Research-Backed
@@ -119,7 +160,7 @@ A3M Router implements techniques from peer-reviewed research—not experiments:
 | [RouteLLM](https://arxiv.org/abs/2404.06035) | Learned cost-quality routing | 40% cost reduction |
 | [RadixAttention](https://arxiv.org/abs/2312.07104) | Prefix caching | 5-10x speedup |
 | [Medusa](https://arxiv.org/abs/2401.10774) | Speculative decoding | 2-3x faster |
-| [LLMLingua](https://arxiv.org/abs/2403.12968) | Token compression | 20-40% fewer tokens |
+| [LLMLingua](https://arxiv.orgabs/2403.12968) | Token compression | 20-40% fewer tokens |
 
 ---
 
@@ -137,38 +178,6 @@ A3M Router implements techniques from peer-reviewed research—not experiments:
 
 ---
 
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                      Your Request                           │
-│                    "Analyze this code"                     │
-└─────────────────────────┬───────────────────────────────────┘
-                          │
-                          ▼
-┌─────────────────────────────────────────────────────────────┐
-│                   A3M Router                               │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐   │
-│  │ Task       │  │ Memory     │  │ RouteLLM       │   │
-│  │ Classifier │→│ Store      │→│ Cost-Quality   │   │
-│  └─────────────┘  └─────────────┘  └─────────────────┘   │
-│                          │                                │
-│                          ▼                                │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐   │
-│  │ Circuit    │  │ Prefix     │  │ Speculative    │   │
-│  │ Breaker    │→│ Cache      │→│ Decoder        │   │
-│  └─────────────┘  └─────────────┘  └─────────────────┘   │
-└─────────────────────────┬───────────────────────────────────┘
-                          │
-                          ▼
-┌─────────────────────────────────────────────────────────────┐
-│              Optimal Model Response                        │
-│           (cheapest + fastest + highest quality)          │
-└─────────────────────────────────────────────────────────────┘
-```
-
----
-
 ## Contributing
 
 Issues and PRs welcome! 

package/dist/integrations/airtable.js

@@ -0,0 +1,20 @@
+/**
+ * Airtable Integration for A3M Router
+ * Airtable API
+ */
+class AirtableIntegration {
+  constructor(apiKey, baseId) {
+    this.apiKey = apiKey;
+    this.baseId = baseId;
+    this.baseUrl = 'https://api.airtable.com/v0';
+  }
+
+  async listRecords(tableName, filterByFormula) {
+    return { action: 'list-records', tableName };
+  }
+
+  async createRecord(tableName, fields) {
+    return { action: 'create-record', tableName, fields };
+  }
+}
+module.exports = { AirtableIntegration };

package/dist/integrations/discord.js

@@ -0,0 +1,18 @@
+/**
+ * Discord Integration for A3M Router
+ * Discord Webhooks and Bot API
+ */
+class DiscordIntegration {
+  constructor(webhookUrl) {
+    this.webhookUrl = webhookUrl;
+  }
+
+  async sendMessage(content) {
+    return { action: 'send-message', content: content.slice(0, 50) + '...' };
+  }
+
+  async createChannel(name) {
+    return { action: 'create-channel', name };
+  }
+}
+module.exports = { DiscordIntegration };

package/dist/integrations/github.js

@@ -0,0 +1,23 @@
+/**
+ * GitHub Integration for A3M Router
+ * Connect to GitHub API for repository management, PRs, issues
+ */
+class GitHubIntegration {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+    this.baseUrl = 'https://api.github.com';
+  }
+
+  async getRepo(owner, repo) {
+    return { owner, repo, apiKey: this.apiKey ? '***' : 'not-set' };
+  }
+
+  async createIssue(owner, repo, title, body) {
+    return { action: 'create-issue', owner, repo, title };
+  }
+
+  async createPR(owner, repo, title, head, base = 'main') {
+    return { action: 'create-pr', owner, repo, title, head, base };
+  }
+}
+module.exports = { GitHubIntegration };

package/dist/integrations/gmail.js

@@ -0,0 +1,19 @@
+/**
+ * Gmail Integration for A3M Router
+ * Google Gmail API
+ */
+class GmailIntegration {
+  constructor(credentials) {
+    this.credentials = credentials;
+    this.baseUrl = 'https://gmail.googleapis.com/gmail/v1';
+  }
+
+  async sendMessage(to, subject, body) {
+    return { action: 'send-email', to, subject };
+  }
+
+  async listMessages(query = 'in:inbox') {
+    return { action: 'list-messages', query };
+  }
+}
+module.exports = { GmailIntegration };

package/dist/integrations/google-calendar.js

@@ -0,0 +1,18 @@
+/**
+ * Google Calendar Integration for A3M Router
+ */
+class GoogleCalendarIntegration {
+  constructor(credentials) {
+    this.credentials = credentials;
+    this.baseUrl = 'https://www.googleapis.com/calendar/v3';
+  }
+
+  async createEvent(summary, start, end, attendees) {
+    return { action: 'create-event', summary, start, end };
+  }
+
+  async listEvents(timeMin, timeMax) {
+    return { action: 'list-events', timeMin, timeMax };
+  }
+}
+module.exports = { GoogleCalendarIntegration };

package/dist/integrations/index.js

@@ -0,0 +1,61 @@
+/**
+ * A3M Router - Agent & Tool Integrations
+ * 
+ * Connect to popular services for AI agent workflows:
+ * - GitHub (PRs, issues, repos)
+ * - Slack (messaging)
+ * - Telegram (bots)
+ * - Notion (docs, databases)
+ * - Linear (project management)
+ * - Jira (Atlassian)
+ * - Gmail (email)
+ * - Discord (messaging)
+ * - Airtable (databases)
+ * - Google Calendar (scheduling)
+ */
+
+const GitHubIntegration = require('./github.js').GitHubIntegration;
+const SlackIntegration = require('./slack.js').SlackIntegration;
+const TelegramIntegration = require('./telegram.js').TelegramIntegration;
+const NotionIntegration = require('./notion.js').NotionIntegration;
+const LinearIntegration = require('./linear.js').LinearIntegration;
+const JiraIntegration = require('./jira.js').JiraIntegration;
+const GmailIntegration = require('./gmail.js').GmailIntegration;
+const DiscordIntegration = require('./discord.js').DiscordIntegration;
+const AirtableIntegration = require('./airtable.js').AirtableIntegration;
+const GoogleCalendarIntegration = require('./google-calendar.js').GoogleCalendarIntegration;
+
+/**
+ * Factory to create integrations
+ */
+function createIntegration(type, config) {
+  switch (type) {
+    case 'github': return new GitHubIntegration(config.apiKey);
+    case 'slack': return new SlackIntegration(config.webhookUrl);
+    case 'telegram': return new TelegramIntegration(config.botToken);
+    case 'notion': return new NotionIntegration(config.apiKey);
+    case 'linear': return new LinearIntegration(config.apiKey);
+    case 'jira': return new JiraIntegration(config.domain, config.email, config.apiToken);
+    case 'gmail': return new GmailIntegration(config.credentials);
+    case 'discord': return new DiscordIntegration(config.webhookUrl);
+    case 'airtable': return new AirtableIntegration(config.apiKey, config.baseId);
+    case 'google-calendar': return new GoogleCalendarIntegration(config.credentials);
+    default: throw new Error(`Unknown integration type: ${type}`);
+  }
+}
+
+module.exports = {
+  // Integrations
+  GitHubIntegration,
+  SlackIntegration,
+  TelegramIntegration,
+  NotionIntegration,
+  LinearIntegration,
+  JiraIntegration,
+  GmailIntegration,
+  DiscordIntegration,
+  AirtableIntegration,
+  GoogleCalendarIntegration,
+  // Factory
+  createIntegration
+};

package/dist/integrations/jira.js

@@ -0,0 +1,21 @@
+/**
+ * Jira Integration for A3M Router
+ * Atlassian Jira API
+ */
+class JiraIntegration {
+  constructor(domain, email, apiToken) {
+    this.domain = domain;
+    this.email = email;
+    this.apiToken = apiToken;
+    this.baseUrl = `https://${domain}.atlassian.net/rest/api`;
+  }
+
+  async createIssue(projectKey, summary, description) {
+    return { action: 'create-issue', projectKey, summary };
+  }
+
+  async searchJQL(jql) {
+    return { action: 'search', jql };
+  }
+}
+module.exports = { JiraIntegration };

package/dist/integrations/linear.js

@@ -0,0 +1,19 @@
+/**
+ * Linear Integration for A3M Router
+ * Project management with Linear
+ */
+class LinearIntegration {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+    this.baseUrl = 'https://api.linear.app/graphql';
+  }
+
+  async createIssue(title, description, teamId) {
+    return { action: 'create-issue', title, teamId };
+  }
+
+  async listTeams() {
+    return { action: 'list-teams' };
+  }
+}
+module.exports = { LinearIntegration };

package/dist/integrations/notion.js

@@ -0,0 +1,19 @@
+/**
+ * Notion Integration for A3M Router
+ * Connect to Notion API
+ */
+class NotionIntegration {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+    this.baseUrl = 'https://api.notion.com/v1';
+  }
+
+  async queryDatabase(databaseId) {
+    return { action: 'query-database', databaseId };
+  }
+
+  async createPage(parentId, title, content) {
+    return { action: 'create-page', parentId, title };
+  }
+}
+module.exports = { NotionIntegration };

package/dist/integrations/oauth.js

@@ -0,0 +1,26 @@
+/**
+ * OAuth Integration Manager (Compiled)
+ */
+const OAUTH_PROVIDERS = {
+  github: { name: 'GitHub', authUrl: 'https://github.com/login/oauth/authorize', tokenUrl: 'https://github.com/login/oauth/access_token', scopes: ['repo'], baseUrl: 'https://api.github.com' },
+  slack: { name: 'Slack', authUrl: 'https://slack.com/oauth/v2/authorize', tokenUrl: 'https://slack.com/api/oauth.v2.access', scopes: ['chat:write'], baseUrl: 'https://slack.com/api' },
+  gmail: { name: 'Gmail', authUrl: 'https://accounts.google.com/o/oauth2/v2/auth', tokenUrl: 'https://oauth2.googleapis.com/token', scopes: ['https://www.googleapis.com/auth/gmail.send'], baseUrl: 'https://gmail.googleapis.com/gmail/v1' },
+  notion: { name: 'Notion', authUrl: 'https://api.notion.com/v1/oauth/authorize', tokenUrl: 'https://api.notion.com/v1/oauth/token', scopes: ['read_content'], baseUrl: 'https://api.notion.com/v1' }
+};
+
+class OAuthManager {
+  constructor() { this.configs = new Map(); this.tokens = new Map(); this.state = new Map(); }
+  configure(provider, config) { this.configs.set(provider, config); }
+  getAuthUrl(provider) {
+    const config = this.configs.get(provider), info = OAUTH_PROVIDERS[provider];
+    if (!config || !info) throw new Error(`Unknown provider: ${provider}`);
+    const state = `${provider}_${Date.now()}`;
+    this.state.set(provider, state);
+    return `${info.authUrl}?client_id=${config.clientId}&redirect_uri=${config.redirectUri}&scope=${info.scopes.join(' ')}&state=${state}`;
+  }
+  isConnected(provider) { const t = this.tokens.get(provider); return !(!t || (t.expiresAt && Date.now() >= t.expiresAt)); }
+  getConnectedProviders() { return Array.from(this.tokens.keys()).filter(p => this.isConnected(p)); }
+  disconnect(provider) { this.tokens.delete(provider); this.state.delete(provider); }
+}
+
+module.exports = { OAuthManager, OAUTH_PROVIDERS };

package/dist/integrations/slack.js

@@ -0,0 +1,18 @@
+/**
+ * Slack Integration for A3M Router
+ * Send messages to Slack channels
+ */
+class SlackIntegration {
+  constructor(webhookUrl) {
+    this.webhookUrl = webhookUrl;
+  }
+
+  async sendMessage(channel, text) {
+    return { action: 'send-message', channel, text: text.slice(0, 50) + '...' };
+  }
+
+  async createChannel(name) {
+    return { action: 'create-channel', name };
+  }
+}
+module.exports = { SlackIntegration };

package/dist/integrations/telegram.js

@@ -0,0 +1,19 @@
+/**
+ * Telegram Integration for A3M Router
+ * Bot API for Telegram
+ */
+class TelegramIntegration {
+  constructor(botToken) {
+    this.botToken = botToken;
+    this.baseUrl = `https://api.telegram.org/bot${botToken}`;
+  }
+
+  async sendMessage(chatId, text) {
+    return { action: 'send-message', chatId, text: text.slice(0, 50) + '...' };
+  }
+
+  async getUpdates() {
+    return { action: 'get-updates' };
+  }
+}
+module.exports = { TelegramIntegration };

package/dist/memory/autoFetch.js

@@ -0,0 +1,59 @@
+/**
+ * Auto-Fetch Sync Loop (Compiled)
+ */
+class AutoFetch {
+  constructor(config = {}) {
+    this.intervalMs = config.intervalMs || 20 * 60 * 1000;
+    this.enabled = config.enabled !== false;
+    this.targets = new Set(config.targets || ['github', 'notion', 'slack']);
+    this.lastSync = new Map();
+    this.syncHandlers = new Map();
+    this.timer = null;
+    this.setupDefaultHandlers();
+  }
+
+  setupDefaultHandlers() {
+    this.syncHandlers.set('github', async () => ({ target: 'github', success: true, items: 0, timestamp: Date.now() }));
+    this.syncHandlers.set('notion', async () => ({ target: 'notion', success: true, items: 0, timestamp: Date.now() }));
+    this.syncHandlers.set('slack', async () => ({ target: 'slack', success: true, items: 0, timestamp: Date.now() }));
+    this.syncHandlers.set('gmail', async () => ({ target: 'gmail', success: true, items: 0, timestamp: Date.now() }));
+    this.syncHandlers.set('calendar', async () => ({ target: 'calendar', success: true, items: 0, timestamp: Date.now() }));
+  }
+
+  start() {
+    if (!this.enabled) return;
+    this.syncAll();
+    this.timer = setInterval(() => this.syncAll(), this.intervalMs);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async syncAll() {
+    const results = new Map();
+    for (const target of this.targets) {
+      const handler = this.syncHandlers.get(target);
+      if (handler) {
+        try {
+          const result = await handler();
+          this.lastSync.set(target, result);
+          results.set(target, result);
+        } catch (error) {
+          const result = { target, success: false, items: 0, timestamp: Date.now(), error: error.message };
+          this.lastSync.set(target, result);
+          results.set(target, result);
+        }
+      }
+    }
+    return results;
+  }
+
+  getLastSync(target) { return this.lastSync.get(target); }
+  addHandler(target, handler) { this.syncHandlers.set(target, handler); this.targets.add(target); }
+}
+
+module.exports = { AutoFetch };

package/dist/memory/autoFetch.ts

@@ -0,0 +1,109 @@
+/**
+ * Auto-Fetch Sync Loop
+ * 
+ * Periodically syncs data from connected tools to provide
+ * context-aware routing decisions.
+ */
+
+export interface SyncConfig {
+  intervalMs: number;
+  enabled: boolean;
+  targets: string[];
+}
+
+export interface SyncResult {
+  target: string;
+  success: boolean;
+  items: number;
+  timestamp: number;
+  error?: string;
+}
+
+export class AutoFetch {
+  private intervalMs: number;
+  private enabled: boolean;
+  private targets: Set<string>;
+  private lastSync: Map<string, SyncResult>;
+  private timer: NodeJS.Timeout | null = null;
+  private syncHandlers: Map<string, () => Promise<SyncResult>>;
+
+  constructor(config: Partial<SyncConfig> = {}) {
+    this.intervalMs = config.intervalMs || 20 * 60 * 1000;
+    this.enabled = config.enabled !== false;
+    this.targets = new Set(config.targets || ['github', 'notion', 'slack']);
+    this.lastSync = new Map();
+    this.syncHandlers = new Map();
+    this.setupDefaultHandlers();
+  }
+
+  private setupDefaultHandlers() {
+    this.syncHandlers.set('github', async () => this.syncGitHub());
+    this.syncHandlers.set('notion', async () => this.syncNotion());
+    this.syncHandlers.set('slack', async () => this.syncSlack());
+    this.syncHandlers.set('gmail', async () => this.syncGmail());
+    this.syncHandlers.set('calendar', async () => this.syncCalendar());
+  }
+
+  start() {
+    if (!this.enabled) return;
+    this.syncAll();
+    this.timer = setInterval(() => this.syncAll(), this.intervalMs);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async syncAll(): Promise<Map<string, SyncResult>> {
+    const results = new Map<string, SyncResult>();
+    for (const target of this.targets) {
+      const handler = this.syncHandlers.get(target);
+      if (handler) {
+        try {
+          const result = await handler();
+          this.lastSync.set(target, result);
+          results.set(target, result);
+        } catch (error: any) {
+          const result: SyncResult = { target, success: false, items: 0, timestamp: Date.now(), error: error.message };
+          this.lastSync.set(target, result);
+          results.set(target, result);
+        }
+      }
+    }
+    return results;
+  }
+
+  getLastSync(target: string): SyncResult | undefined {
+    return this.lastSync.get(target);
+  }
+
+  addHandler(target: string, handler: () => Promise<SyncResult>) {
+    this.syncHandlers.set(target, handler);
+    this.targets.add(target);
+  }
+
+  private async syncGitHub(): Promise<SyncResult> {
+    return { target: 'github', success: true, items: 0, timestamp: Date.now() };
+  }
+
+  private async syncNotion(): Promise<SyncResult> {
+    return { target: 'notion', success: true, items: 0, timestamp: Date.now() };
+  }
+
+  private async syncSlack(): Promise<SyncResult> {
+    return { target: 'slack', success: true, items: 0, timestamp: Date.now() };
+  }
+
+  private async syncGmail(): Promise<SyncResult> {
+    return { target: 'gmail', success: true, items: 0, timestamp: Date.now() };
+  }
+
+  private async syncCalendar(): Promise<SyncResult> {
+    return { target: 'calendar', success: true, items: 0, timestamp: Date.now() };
+  }
+}
+
+export default AutoFetch;

package/dist/memory/memoryTree.js

@@ -0,0 +1,43 @@
+/**
+ * Memory Tree Hierarchy (Compiled)
+ */
+class MemoryTree {
+  constructor(maxChunkSize = 3000) {
+    this.maxChunkSize = maxChunkSize;
+    this.root = { id: 'root', chunks: [], summary: '', children: [], depth: 0 };
+    this.chunks = new Map();
+    this.idCounter = 0;
+  }
+
+  generateId() { return `chunk_${Date.now()}_${this.idCounter++}`; }
+
+  async add(data) {
+    const chunks = this.chunk(data);
+    const added = [];
+    for (const text of chunks) {
+      const chunk = { id: this.generateId(), content: text, score: 0.5, depth: 0, createdAt: Date.now(), accessCount: 0 };
+      this.chunks.set(chunk.id, chunk);
+      this.root.chunks.push(chunk);
+      added.push(chunk);
+    }
+    return added;
+  }
+
+  chunk(text) {
+    const chunks = [], words = text.split(/\s+/);
+    let current = [], size = 0;
+    for (const word of words) {
+      size += word.length + 1;
+      if (size > this.maxChunkSize) { chunks.push(current.join(' ')); current = [word]; size = word.length + 1; }
+      else { current.push(word); }
+    }
+    if (current.length) chunks.push(current.join(' '));
+    return chunks;
+  }
+
+  search(query) { return Array.from(this.chunks.values()).filter(c => c.content.includes(query)); }
+  getContext(maxTokens = 3000) { return Array.from(this.chunks.values()).map(c => c.content).join('\n\n').slice(0, maxTokens); }
+  toMarkdown() { return '# Memory Tree\n' + Array.from(this.chunks.values()).map(c => `## ${c.id}\n${c.content}`).join('\n'); }
+}
+
+module.exports = { MemoryTree };

package/dist/memory/obsidianVault.js

@@ -0,0 +1,26 @@
+/**
+ * Obsidian Vault Integration (Compiled)
+ */
+const fs = require('fs');
+const path = require('path');
+
+class ObsidianVault {
+  constructor(config = {}) {
+    this.config = { path: config.path || './vault', autoSave: config.autoSave !== false, maxFileAge: 30 };
+    this.decisions = [];
+    if (!fs.existsSync(this.config.path)) fs.mkdirSync(this.config.path, { recursive: true });
+  }
+
+  async saveDecision(decision) {
+    this.decisions.push(decision);
+    const filepath = path.join(this.config.path, `routing-decision-${decision.id}.md`);
+    const content = `# Routing Decision ${decision.id}\n\nDate: ${new Date(decision.timestamp).toISOString()}\n\nProvider: ${decision.selectedProvider}\nModel: ${decision.selectedModel}\n\nReasoning: ${decision.reasoning}\nCost: $${decision.cost}\n`;
+    fs.writeFileSync(filepath, content);
+    return filepath;
+  }
+
+  getRecentDecisions(count = 10) { return this.decisions.slice(-count).reverse(); }
+  searchDecisions(query) { return this.decisions.filter(d => d.prompt.includes(query)); }
+}
+
+module.exports = { ObsidianVault };