@sochdb/sochdb 0.4.0 → 0.4.1

package/README.md

@@ -1,8 +1,202 @@
-# SochDB Node.js SDK v0.4.0
+# SochDB Node.js SDK
 
 **Dual-mode architecture: Embedded (FFI) + Server (gRPC/IPC)**  
 Choose the deployment mode that fits your needs.
 
+## Features
+
+### Memory System - LLM-Native Memory for AI Agents
+Complete memory system with extraction, consolidation, and hybrid retrieval:
+
+```typescript
+import {
+  EmbeddedDatabase,
+  ExtractionPipeline,
+  Consolidator,
+  HybridRetriever,
+  AllowedSet,
+} from '@sochdb/sochdb';
+
+const db = await EmbeddedDatabase.open('./memory_db');
+
+// Extract entities and relations from text
+const pipeline = ExtractionPipeline.fromDatabase(db, 'user_123', {
+  entityTypes: ['person', 'organization', 'location'],
+  minConfidence: 0.7,
+});
+
+const result = await pipeline.extractAndCommit(
+  'Alice works at Acme Corp',
+  myLLMExtractor  // Your LLM integration
+);
+console.log(`Extracted ${result.entities.length} entities`);
+
+// Consolidate facts with event sourcing
+const consolidator = Consolidator.fromDatabase(db, 'user_123');
+await consolidator.add({
+  fact: { subject: 'Alice', predicate: 'lives_in', object: 'SF' },
+  source: 'conversation_1',
+  confidence: 0.9,
+});
+
+const updated = await consolidator.consolidate();
+const facts = await consolidator.getCanonicalFacts();
+
+// Hybrid retrieval with RRF fusion
+const retriever = HybridRetriever.fromDatabase(db, 'user_123', 'documents');
+await retriever.indexDocuments(docs);
+
+const results = await retriever.retrieve(
+  'machine learning papers',
+  queryEmbedding,
+  AllowedSet.fromNamespace('user_123')
+);
+```
+
+**[→ See Full Example](./examples/memory-system-example.ts)**
+
+**Key Features:**
+- ✅ Extraction Pipeline: Compile LLM outputs into typed facts
+- ✅ Event-Sourced Consolidation: Append-only with temporal updates
+- ✅ Hybrid Retrieval: RRF fusion of vector + keyword search
+- ✅ Namespace Isolation: Multi-tenant security with pre-filtering
+- ✅ Schema Validation: Type checking and confidence thresholds
+
+### Semantic Cache - LLM Response Caching
+Vector similarity-based caching for LLM responses to reduce costs and latency:
+
+```typescript
+import { EmbeddedDatabase, SemanticCache } from '@sochdb/sochdb';
+
+const db = await EmbeddedDatabase.open('./mydb');
+const cache = new SemanticCache(db, 'llm_responses');
+
+// Store LLM response with embedding
+await cache.put(
+  'What is machine learning?',
+  'Machine learning is a subset of AI...',
+  embedding,  // 384-dim vector
+  3600,       // TTL in seconds
+  { model: 'gpt-4', tokens: 150 }
+);
+
+// Check cache before calling LLM
+const hit = await cache.get(queryEmbedding, 0.85);
+if (hit) {
+  console.log(`Cache HIT! Similarity: ${hit.score.toFixed(4)}`);
+  console.log(`Response: ${hit.value}`);
+}
+
+// Get statistics
+const stats = await cache.stats();
+console.log(`Hit rate: ${(stats.hitRate * 100).toFixed(1)}%`);
+```
+
+**[→ See Full Example](./examples/semantic-cache-example.ts)**
+
+**Key Benefits:**
+- ✅ Cosine similarity matching (0-1 threshold)
+- ✅ TTL-based expiration
+- ✅ Hit/miss statistics tracking
+- ✅ Memory usage monitoring
+- ✅ Automatic expired entry purging
+
+### Context Query Builder - Token-Aware LLM Context
+Assemble LLM context with priority-based truncation and token budgeting:
+
+```typescript
+import { ContextQueryBuilder, ContextOutputFormat, TruncationStrategy } from '@sochdb/sochdb';
+
+const builder = new ContextQueryBuilder()
+  .withBudget(4096)  // Token limit
+  .setFormat(ContextOutputFormat.TOON)
+  .setTruncation(TruncationStrategy.TAIL_DROP);
+
+builder
+  .literal('SYSTEM', 0, 'You are a helpful AI assistant.')
+  .literal('USER_PROFILE', 1, 'User: Alice, Role: Engineer')
+  .literal('HISTORY', 2, 'Recent conversation context...')
+  .literal('KNOWLEDGE', 3, 'Retrieved documents...');
+
+const result = builder.execute();
+console.log(`Tokens: ${result.tokenCount}/${4096}`);
+console.log(`Context:\n${result.text}`);
+```
+
+**[→ See Full Example](./examples/context-builder-example.ts)**
+
+**Key Benefits:**
+- ✅ Priority-based section ordering (lower = higher priority)
+- ✅ Token budget enforcement
+- ✅ Multiple truncation strategies (tail drop, head drop, proportional)
+- ✅ Multiple output formats (TOON, JSON, Markdown)
+- ✅ Token count estimation
+
+### Namespace API - Multi-Tenant Isolation
+First-class namespace handles for secure multi-tenancy and data isolation:
+
+```typescript
+import { Database, Namespace, Collection, DistanceMetric } from '@sochdb/sochdb';
+
+const db = await Database.open('./mydb');
+
+// Create isolated namespace for each tenant
+const namespace = new Namespace(db, 'tenant_acme', {
+  name: 'tenant_acme',
+  displayName: 'ACME Corporation',
+  labels: { plan: 'enterprise', region: 'us-west' }
+});
+
+// Create vector collection
+const collection = await namespace.createCollection({
+  name: 'documents',
+  dimension: 384,
+  metric: DistanceMetric.Cosine,
+  indexed: true
+});
+
+// Insert and search vectors
+await collection.insert([1.0, 2.0, ...], { title: 'Doc 1' });
+const results = await collection.search({ queryVector: [...], k: 10 });
+```
+
+**[→ See Full Example](./examples/namespace-example.ts)**
+
+### Priority Queue API - Task Processing
+Efficient priority queue with ordered-key storage (no O(N) blob rewrites):
+
+```typescript
+import { Database, PriorityQueue } from '@sochdb/sochdb';
+
+const db = await Database.open('./queue_db');
+const queue = PriorityQueue.fromDatabase(db, 'tasks');
+
+// Enqueue with priority (lower = higher urgency)
+await queue.enqueue(1, Buffer.from('urgent task'), { type: 'payment' });
+
+// Worker processes tasks
+const task = await queue.dequeue('worker-1');
+if (task) {
+  // Process task...
+  await queue.ack(task.taskId);
+}
+
+// Get statistics
+const stats = await queue.stats();
+console.log(`Pending: ${stats.pending}, Completed: ${stats.completed}`);
+```
+
+**[→ See Full Example](./examples/queue-example.ts)**
+
+**Key Benefits:**
+- ✅ O(log N) enqueue/dequeue with ordered scans
+- ✅ Atomic claim protocol for concurrent workers
+- ✅ Visibility timeout for crash recovery
+- ✅ Dead letter queue for failed tasks
+- ✅ Multiple queues per database
+
+---
+
 ## Architecture: Flexible Deployment
 
 ```
@@ -67,40 +261,33 @@ npm install
 
 1. [Quick Start](#1-quick-start)
 2. [Installation](#2-installation)
-3. [Architecture Overview](#3-architecture-overview)
-4. [Core Key-Value Operations](#4-core-key-value-operations)
-5. [Transactions (ACID with SSI)](#5-transactions-acid-with-ssi)
-6. [Query Builder](#6-query-builder)
-7. [Prefix Scanning](#7-prefix-scanning)
-8. [SQL Operations](#8-sql-operations)
-9. [Table Management & Index Policies](#9-table-management--index-policies)
-10. [Namespaces & Multi-Tenancy](#10-namespaces--multi-tenancy)
-11. [Collections & Vector Search](#11-collections--vector-search)
-12. [Hybrid Search (Vector + BM25)](#12-hybrid-search-vector--bm25)
-13. [Graph Operations](#13-graph-operations)
-14. [Temporal Graph (Time-Travel)](#14-temporal-graph-time-travel)
-15. [Semantic Cache](#15-semantic-cache)
-16. [Context Query Builder (LLM Optimization) and Session](#16-context-query-builder-llm-optimization)
-17. [Atomic Multi-Index Writes](#17-atomic-multi-index-writes)
-18. [Recovery & WAL Management](#18-recovery--wal-management)
-19. [Checkpoints & Snapshots](#19-checkpoints--snapshots)
-20. [Compression & Storage](#20-compression--storage)
-21. [Statistics & Monitoring](#21-statistics--monitoring)
-22. [Distributed Tracing](#22-distributed-tracing)
-23. [Workflow & Run Tracking](#23-workflow--run-tracking)
+3. [Features](#3-features)
+   - [Namespace API](#namespace-api---multi-tenant-isolation)
+   - [Priority Queue API](#priority-queue-api---task-processing)
+4. [Architecture Overview](#4-architecture-overview)
+5. [Core Key-Value Operations](#5-core-key-value-operations)
+6. [Transactions (ACID with SSI)](#6-transactions-acid-with-ssi)
+7. [Query Builder](#7-query-builder)
+8. [Prefix Scanning](#8-prefix-scanning)
+9. [SQL Operations](#9-sql-operations)
+10. [Table Management & Index Policies](#10-table-management--index-policies)
+11. [Namespaces & Collections](#11-namespaces--collections)
+12. [Priority Queues](#12-priority-queues)
+13. [Vector Search](#13-vector-search)
+14. [Hybrid Search (Vector + BM25)](#14-hybrid-search-vector--bm25)
+15. [Graph Operations](#15-graph-operations)
+16. [Temporal Graph (Time-Travel)](#16-temporal-graph-time-travel)
+17. [Semantic Cache](#17-semantic-cache)
+18. [Context Query Builder (LLM Optimization)](#18-context-query-builder-llm-optimization)
+19. [Atomic Multi-Index Writes](#19-atomic-multi-index-writes)
+20. [Recovery & WAL Management](#20-recovery--wal-management)
+21. [Checkpoints & Snapshots](#21-checkpoints--snapshots)
+22. [Compression & Storage](#22-compression--storage)
+23. [Statistics & Monitoring](#23-statistics--monitoring)
 24. [Server Mode (gRPC Client)](#24-server-mode-grpc-client)
 25. [IPC Client (Unix Sockets)](#25-ipc-client-unix-sockets)
-26. [Standalone VectorIndex](#26-standalone-vectorindex)
-27. [Vector Utilities](#27-vector-utilities)
-28. [Data Formats (TOON/JSON/Columnar)](#28-data-formats-toonjsoncolumnar)
-29. [Policy Service](#29-policy-service)
-30. [MCP (Model Context Protocol)](#30-mcp-model-context-protocol)
-31. [Configuration Reference](#31-configuration-reference)
-32. [Error Handling](#32-error-handling)
-33. [Async Support](#33-async-support)
-34. [Building & Development](#34-building--development)
-35. [Complete Examples](#35-complete-examples)
-36. [Migration Guide](#36-migration-guide)
+26. [Error Handling](#26-error-handling)
+27. [Complete Examples](#27-complete-examples)
 
 ---
 

package/bin/sochdb-bulk.js

@@ -46,7 +46,7 @@ sochdb-bulk binary not found!
 Searched at: ${bundledPath}
 
 To fix:
-1. Reinstall the package: npm install --force @sushanth/sochdb
+1. Reinstall the package: npm install --force @sochdb/sochdb
 2. Or set SOCHDB_BULK_PATH environment variable
     `);
 }

package/bin/sochdb-grpc-server.js

@@ -46,7 +46,7 @@ sochdb-grpc-server binary not found!
 Searched at: ${bundledPath}
 
 To fix:
-1. Reinstall the package: npm install --force @sushanth/sochdb
+1. Reinstall the package: npm install --force @sochdb/sochdb
 2. Or set SOCHDB_GRPC_SERVER_PATH environment variable
     `);
 }

package/bin/sochdb-server.js

@@ -46,7 +46,7 @@ sochdb-server binary not found!
 Searched at: ${bundledPath}
 
 To fix:
-1. Reinstall the package: npm install --force @sushanth/sochdb
+1. Reinstall the package: npm install --force @sochdb/sochdb
 2. Or set SOCHDB_SERVER_PATH environment variable
     `);
 }

package/dist/cjs/context-builder.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Context Query Builder for LLM Context Assembly
+ *
+ * Token-aware context assembly with priority-based truncation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextQueryBuilder = exports.TruncationStrategy = exports.ContextOutputFormat = void 0;
+exports.createContextBuilder = createContextBuilder;
+var ContextOutputFormat;
+(function (ContextOutputFormat) {
+    ContextOutputFormat["TOON"] = "toon";
+    ContextOutputFormat["JSON"] = "json";
+    ContextOutputFormat["MARKDOWN"] = "markdown";
+})(ContextOutputFormat || (exports.ContextOutputFormat = ContextOutputFormat = {}));
+var TruncationStrategy;
+(function (TruncationStrategy) {
+    TruncationStrategy["TAIL_DROP"] = "tail_drop";
+    TruncationStrategy["HEAD_DROP"] = "head_drop";
+    TruncationStrategy["PROPORTIONAL"] = "proportional";
+})(TruncationStrategy || (exports.TruncationStrategy = TruncationStrategy = {}));
+/**
+ * Context Query Builder for assembling LLM context
+ */
+class ContextQueryBuilder {
+    constructor() {
+        this.tokenBudget = 4096;
+        this.format = ContextOutputFormat.TOON;
+        this.truncation = TruncationStrategy.TAIL_DROP;
+        this.sections = [];
+    }
+    /**
+     * Set session ID for context
+     */
+    forSession(sessionId) {
+        this.sessionId = sessionId;
+        return this;
+    }
+    /**
+     * Set token budget
+     */
+    withBudget(tokens) {
+        this.tokenBudget = tokens;
+        return this;
+    }
+    /**
+     * Set output format
+     */
+    setFormat(format) {
+        this.format = format;
+        return this;
+    }
+    /**
+     * Set truncation strategy
+     */
+    setTruncation(strategy) {
+        this.truncation = strategy;
+        return this;
+    }
+    /**
+     * Add literal text section
+     */
+    literal(name, priority, text) {
+        const tokenCount = this.estimateTokens(text);
+        this.sections.push({
+            name,
+            priority,
+            content: text,
+            tokenCount,
+        });
+        return this;
+    }
+    /**
+     * Start a new section
+     */
+    section(name, priority) {
+        this.currentSection = {
+            name,
+            priority,
+            content: '',
+            tokenCount: 0,
+        };
+        return this;
+    }
+    /**
+     * Add content to current section
+     */
+    get(path) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `GET ${path}\n`;
+        return this;
+    }
+    /**
+     * Add last N records query
+     */
+    last(n, table) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `LAST ${n} FROM ${table}\n`;
+        return this;
+    }
+    /**
+     * Add where equals condition
+     */
+    whereEq(field, value) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `WHERE ${field} = ${JSON.stringify(value)}\n`;
+        return this;
+    }
+    /**
+     * Add vector search
+     */
+    search(collection, embedding, k) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `SEARCH ${collection} WITH ${embedding} LIMIT ${k}\n`;
+        return this;
+    }
+    /**
+     * Add SQL query
+     */
+    sql(query) {
+        if (!this.currentSection) {
+            throw new Error('No active section. Call section() first.');
+        }
+        this.currentSection.content += `SQL: ${query}\n`;
+        return this;
+    }
+    /**
+     * Finish current section
+     */
+    done() {
+        if (this.currentSection) {
+            this.currentSection.tokenCount = this.estimateTokens(this.currentSection.content);
+            this.sections.push(this.currentSection);
+            this.currentSection = undefined;
+        }
+        return this;
+    }
+    /**
+     * Execute and build context
+     */
+    execute() {
+        // Finish any pending section
+        if (this.currentSection) {
+            this.done();
+        }
+        // Sort sections by priority (lower = higher priority)
+        const sortedSections = [...this.sections].sort((a, b) => a.priority - b.priority);
+        // Calculate total tokens
+        let totalTokens = sortedSections.reduce((sum, s) => sum + s.tokenCount, 0);
+        // Truncate if needed
+        const truncatedSections = [];
+        const includedSections = [];
+        if (totalTokens <= this.tokenBudget) {
+            // No truncation needed
+            for (const section of sortedSections) {
+                includedSections.push(section);
+                truncatedSections.push({
+                    name: section.name,
+                    tokenCount: section.tokenCount,
+                    truncated: false,
+                });
+            }
+        }
+        else {
+            // Apply truncation strategy
+            let remainingBudget = this.tokenBudget;
+            if (this.truncation === TruncationStrategy.TAIL_DROP) {
+                // Include sections in priority order until budget exhausted
+                for (const section of sortedSections) {
+                    if (section.tokenCount <= remainingBudget) {
+                        includedSections.push(section);
+                        remainingBudget -= section.tokenCount;
+                        truncatedSections.push({
+                            name: section.name,
+                            tokenCount: section.tokenCount,
+                            truncated: false,
+                        });
+                    }
+                    else {
+                        truncatedSections.push({
+                            name: section.name,
+                            tokenCount: 0,
+                            truncated: true,
+                        });
+                    }
+                }
+            }
+            else if (this.truncation === TruncationStrategy.PROPORTIONAL) {
+                // Proportionally reduce all sections
+                const ratio = this.tokenBudget / totalTokens;
+                for (const section of sortedSections) {
+                    const allocatedTokens = Math.floor(section.tokenCount * ratio);
+                    const truncatedContent = this.truncateText(section.content, allocatedTokens);
+                    includedSections.push({
+                        ...section,
+                        content: truncatedContent,
+                        tokenCount: allocatedTokens,
+                    });
+                    truncatedSections.push({
+                        name: section.name,
+                        tokenCount: allocatedTokens,
+                        truncated: allocatedTokens < section.tokenCount,
+                    });
+                }
+            }
+        }
+        // Build final context based on format
+        let text = '';
+        let actualTokens = 0;
+        if (this.format === ContextOutputFormat.TOON) {
+            text = this.buildToonFormat(includedSections);
+        }
+        else if (this.format === ContextOutputFormat.JSON) {
+            text = this.buildJsonFormat(includedSections);
+        }
+        else {
+            text = this.buildMarkdownFormat(includedSections);
+        }
+        actualTokens = this.estimateTokens(text);
+        return {
+            text,
+            tokenCount: actualTokens,
+            sections: truncatedSections,
+        };
+    }
+    // Helper methods
+    estimateTokens(text) {
+        // Rough estimate: ~4 characters per token for English
+        return Math.ceil(text.length / 4);
+    }
+    truncateText(text, maxTokens) {
+        const maxChars = maxTokens * 4;
+        if (text.length <= maxChars) {
+            return text;
+        }
+        return text.substring(0, maxChars) + '...';
+    }
+    buildToonFormat(sections) {
+        const lines = [];
+        for (const section of sections) {
+            lines.push(`[${section.name}]`);
+            lines.push(section.content);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    buildJsonFormat(sections) {
+        const obj = {};
+        for (const section of sections) {
+            obj[section.name] = section.content;
+        }
+        return JSON.stringify(obj, null, 2);
+    }
+    buildMarkdownFormat(sections) {
+        const lines = [];
+        for (const section of sections) {
+            lines.push(`## ${section.name}`);
+            lines.push('');
+            lines.push(section.content);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+exports.ContextQueryBuilder = ContextQueryBuilder;
+/**
+ * Create a context query builder
+ */
+function createContextBuilder() {
+    return new ContextQueryBuilder();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-builder.js","sourceRoot":"","sources":["../../src/context-builder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Context Query Builder for LLM Context Assembly\n * \n * Token-aware context assembly with priority-based truncation.\n */\n\nexport enum ContextOutputFormat {\n  TOON = 'toon',\n  JSON = 'json',\n  MARKDOWN = 'markdown',\n}\n\nexport enum TruncationStrategy {\n  TAIL_DROP = 'tail_drop',       // Drop from end\n  HEAD_DROP = 'head_drop',       // Drop from beginning\n  PROPORTIONAL = 'proportional', // Proportional across sections\n}\n\ninterface Section {\n  name: string;\n  priority: number;\n  content: string;\n  tokenCount: number;\n}\n\nexport interface ContextResult {\n  text: string;\n  tokenCount: number;\n  sections: Array<{ name: string; tokenCount: number; truncated: boolean }>;\n}\n\n/**\n * Context Query Builder for assembling LLM context\n */\nexport class ContextQueryBuilder {\n  private sessionId?: string;\n  private tokenBudget: number = 4096;\n  private format: ContextOutputFormat = ContextOutputFormat.TOON;\n  private truncation: TruncationStrategy = TruncationStrategy.TAIL_DROP;\n  private sections: Section[] = [];\n  private currentSection?: Section;\n\n  /**\n   * Set session ID for context\n   */\n  forSession(sessionId: string): this {\n    this.sessionId = sessionId;\n    return this;\n  }\n\n  /**\n   * Set token budget\n   */\n  withBudget(tokens: number): this {\n    this.tokenBudget = tokens;\n    return this;\n  }\n\n  /**\n   * Set output format\n   */\n  setFormat(format: ContextOutputFormat): this {\n    this.format = format;\n    return this;\n  }\n\n  /**\n   * Set truncation strategy\n   */\n  setTruncation(strategy: TruncationStrategy): this {\n    this.truncation = strategy;\n    return this;\n  }\n\n  /**\n   * Add literal text section\n   */\n  literal(name: string, priority: number, text: string): this {\n    const tokenCount = this.estimateTokens(text);\n    this.sections.push({\n      name,\n      priority,\n      content: text,\n      tokenCount,\n    });\n    return this;\n  }\n\n  /**\n   * Start a new section\n   */\n  section(name: string, priority: number): this {\n    this.currentSection = {\n      name,\n      priority,\n      content: '',\n      tokenCount: 0,\n    };\n    return this;\n  }\n\n  /**\n   * Add content to current section\n   */\n  get(path: string): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `GET ${path}\\n`;\n    return this;\n  }\n\n  /**\n   * Add last N records query\n   */\n  last(n: number, table: string): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `LAST ${n} FROM ${table}\\n`;\n    return this;\n  }\n\n  /**\n   * Add where equals condition\n   */\n  whereEq(field: string, value: any): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `WHERE ${field} = ${JSON.stringify(value)}\\n`;\n    return this;\n  }\n\n  /**\n   * Add vector search\n   */\n  search(collection: string, embedding: string, k: number): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `SEARCH ${collection} WITH ${embedding} LIMIT ${k}\\n`;\n    return this;\n  }\n\n  /**\n   * Add SQL query\n   */\n  sql(query: string): this {\n    if (!this.currentSection) {\n      throw new Error('No active section. Call section() first.');\n    }\n    this.currentSection.content += `SQL: ${query}\\n`;\n    return this;\n  }\n\n  /**\n   * Finish current section\n   */\n  done(): this {\n    if (this.currentSection) {\n      this.currentSection.tokenCount = this.estimateTokens(this.currentSection.content);\n      this.sections.push(this.currentSection);\n      this.currentSection = undefined;\n    }\n    return this;\n  }\n\n  /**\n   * Execute and build context\n   */\n  execute(): ContextResult {\n    // Finish any pending section\n    if (this.currentSection) {\n      this.done();\n    }\n\n    // Sort sections by priority (lower = higher priority)\n    const sortedSections = [...this.sections].sort((a, b) => a.priority - b.priority);\n\n    // Calculate total tokens\n    let totalTokens = sortedSections.reduce((sum, s) => sum + s.tokenCount, 0);\n\n    // Truncate if needed\n    const truncatedSections: Array<{ name: string; tokenCount: number; truncated: boolean }> = [];\n    const includedSections: Section[] = [];\n\n    if (totalTokens <= this.tokenBudget) {\n      // No truncation needed\n      for (const section of sortedSections) {\n        includedSections.push(section);\n        truncatedSections.push({\n          name: section.name,\n          tokenCount: section.tokenCount,\n          truncated: false,\n        });\n      }\n    } else {\n      // Apply truncation strategy\n      let remainingBudget = this.tokenBudget;\n\n      if (this.truncation === TruncationStrategy.TAIL_DROP) {\n        // Include sections in priority order until budget exhausted\n        for (const section of sortedSections) {\n          if (section.tokenCount <= remainingBudget) {\n            includedSections.push(section);\n            remainingBudget -= section.tokenCount;\n            truncatedSections.push({\n              name: section.name,\n              tokenCount: section.tokenCount,\n              truncated: false,\n            });\n          } else {\n            truncatedSections.push({\n              name: section.name,\n              tokenCount: 0,\n              truncated: true,\n            });\n          }\n        }\n      } else if (this.truncation === TruncationStrategy.PROPORTIONAL) {\n        // Proportionally reduce all sections\n        const ratio = this.tokenBudget / totalTokens;\n        for (const section of sortedSections) {\n          const allocatedTokens = Math.floor(section.tokenCount * ratio);\n          const truncatedContent = this.truncateText(section.content, allocatedTokens);\n          includedSections.push({\n            ...section,\n            content: truncatedContent,\n            tokenCount: allocatedTokens,\n          });\n          truncatedSections.push({\n            name: section.name,\n            tokenCount: allocatedTokens,\n            truncated: allocatedTokens < section.tokenCount,\n          });\n        }\n      }\n    }\n\n    // Build final context based on format\n    let text = '';\n    let actualTokens = 0;\n\n    if (this.format === ContextOutputFormat.TOON) {\n      text = this.buildToonFormat(includedSections);\n    } else if (this.format === ContextOutputFormat.JSON) {\n      text = this.buildJsonFormat(includedSections);\n    } else {\n      text = this.buildMarkdownFormat(includedSections);\n    }\n\n    actualTokens = this.estimateTokens(text);\n\n    return {\n      text,\n      tokenCount: actualTokens,\n      sections: truncatedSections,\n    };\n  }\n\n  // Helper methods\n  private estimateTokens(text: string): number {\n    // Rough estimate: ~4 characters per token for English\n    return Math.ceil(text.length / 4);\n  }\n\n  private truncateText(text: string, maxTokens: number): string {\n    const maxChars = maxTokens * 4;\n    if (text.length <= maxChars) {\n      return text;\n    }\n    return text.substring(0, maxChars) + '...';\n  }\n\n  private buildToonFormat(sections: Section[]): string {\n    const lines: string[] = [];\n    \n    for (const section of sections) {\n      lines.push(`[${section.name}]`);\n      lines.push(section.content);\n      lines.push('');\n    }\n    \n    return lines.join('\\n');\n  }\n\n  private buildJsonFormat(sections: Section[]): string {\n    const obj: Record<string, string> = {};\n    \n    for (const section of sections) {\n      obj[section.name] = section.content;\n    }\n    \n    return JSON.stringify(obj, null, 2);\n  }\n\n  private buildMarkdownFormat(sections: Section[]): string {\n    const lines: string[] = [];\n    \n    for (const section of sections) {\n      lines.push(`## ${section.name}`);\n      lines.push('');\n      lines.push(section.content);\n      lines.push('');\n    }\n    \n    return lines.join('\\n');\n  }\n}\n\n/**\n * Create a context query builder\n */\nexport function createContextBuilder(): ContextQueryBuilder {\n  return new ContextQueryBuilder();\n}\n"]}