@webpresso/agent-kit 0.21.0

package/commands/test.md

@@ -0,0 +1,4 @@
+---
+description: Run tests via the webpresso MCP server
+---
+Use the `mcp__webpresso__wp_test` tool to run tests. Pass `packages` or `files` as arguments based on what the user asks for.

package/dist/esm/ai-memory/checkpoint/saver.d.ts

@@ -0,0 +1,14 @@
+import type { Checkpoint, CheckpointConfig, CheckpointId, CheckpointResult, CheckpointState, CheckpointTuple, ListCheckpointsOptions, ThreadId } from './types.js';
+export declare abstract class BaseCheckpointSaver {
+    abstract save(config: CheckpointConfig, state: CheckpointState, parentId?: CheckpointId): Promise<CheckpointResult>;
+    abstract loadLatest(threadId: ThreadId): Promise<Checkpoint | null>;
+    abstract load(checkpointId: CheckpointId): Promise<Checkpoint | null>;
+    abstract list(options?: ListCheckpointsOptions): Promise<Checkpoint[]>;
+    abstract delete(checkpointId: CheckpointId): Promise<CheckpointResult>;
+    abstract clearThread(threadId: ThreadId): Promise<CheckpointResult>;
+    getTuple(config: CheckpointConfig): Promise<CheckpointTuple | null>;
+    put(config: CheckpointConfig, checkpoint: Omit<Checkpoint, 'id' | 'createdAt'>): Promise<CheckpointResult>;
+}
+export declare function generateCheckpointId(): CheckpointId;
+export declare function generateThreadId(): ThreadId;
+//# sourceMappingURL=saver.d.ts.map

package/dist/esm/ai-memory/checkpoint/saver.js

@@ -0,0 +1,28 @@
+export class BaseCheckpointSaver {
+    async getTuple(config) {
+        const checkpoint = await this.loadLatest(config.threadId);
+        if (!checkpoint)
+            return null;
+        return {
+            config,
+            checkpoint,
+            parentConfig: checkpoint.parentId
+                ? { ...config, threadId: checkpoint.parentId }
+                : undefined,
+        };
+    }
+    put(config, checkpoint) {
+        return this.save(config, checkpoint.state, checkpoint.parentId);
+    }
+}
+export function generateCheckpointId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 10);
+    return `ckpt_${timestamp}_${random}`;
+}
+export function generateThreadId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 10);
+    return `thrd_${timestamp}_${random}`;
+}
+//# sourceMappingURL=saver.js.map

package/dist/esm/ai-memory/checkpoint/types.d.ts

@@ -0,0 +1,75 @@
+export type CheckpointId = string;
+export type ThreadId = string;
+export interface CheckpointMetadata {
+    source: 'auto' | 'user' | 'system';
+    step: number;
+    createdAt: Date;
+    description?: string;
+    custom?: Record<string, unknown>;
+}
+export interface SerializedMessage {
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    toolCallId?: string;
+    timestamp?: string;
+}
+export interface SerializedToolCall {
+    id?: string;
+    name: string;
+    input?: Record<string, unknown>;
+    args?: Record<string, unknown>;
+    output?: unknown;
+    result?: unknown;
+    status?: 'pending' | 'completed' | 'failed';
+    durationMs?: number;
+}
+export interface SerializedCodeBlock {
+    toolCallId: string;
+    code: string;
+    result?: unknown;
+    consoleLogs?: readonly string[];
+}
+export interface CheckpointState {
+    messages: SerializedMessage[];
+    toolCalls?: SerializedToolCall[];
+    codeBlocks?: readonly SerializedCodeBlock[];
+    context?: Record<string, unknown>;
+    tokenUsage?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+}
+export interface Checkpoint {
+    id: CheckpointId;
+    threadId: ThreadId;
+    parentId?: CheckpointId;
+    state: CheckpointState;
+    metadata?: CheckpointMetadata;
+    createdAt: Date;
+}
+export interface CheckpointConfig {
+    threadId: ThreadId;
+    userId?: string;
+    saveInterval?: number;
+    maxCheckpoints?: number;
+    saveOnEnd?: boolean;
+}
+export interface ListCheckpointsOptions {
+    threadId?: ThreadId;
+    limit?: number;
+    offset?: number;
+    orderBy?: 'createdAt' | 'step';
+    order?: 'asc' | 'desc';
+}
+export interface CheckpointResult {
+    success: boolean;
+    checkpointId?: CheckpointId;
+    error?: string;
+}
+export interface CheckpointTuple {
+    config: CheckpointConfig;
+    checkpoint: Checkpoint;
+    parentConfig?: CheckpointConfig;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/ai-memory/checkpoint/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/ai-memory/facts/consolidator.d.ts

@@ -0,0 +1,23 @@
+import type { Fact, FactConsolidationOptions, FactConsolidationResult, FactId } from './types.js';
+export interface FactDatabase {
+    findByThread(threadId: string): Promise<Fact[]>;
+    update(id: FactId, updates: Partial<Fact>): Promise<void>;
+    delete(id: FactId): Promise<void>;
+    insert(fact: Fact): Promise<void>;
+}
+export declare class FactConsolidator {
+    private db;
+    constructor(db: FactDatabase);
+    consolidate(options: FactConsolidationOptions): Promise<FactConsolidationResult>;
+    private consolidateCategory;
+    private groupByCategory;
+    private checkFactPair;
+    private sortPairsBySimilarity;
+    private findSimilarPairs;
+    private calculateSimilarity;
+    private cosineSimilarity;
+    private textSimilarity;
+    private selectKeeper;
+}
+export declare function createFactConsolidator(db: FactDatabase): FactConsolidator;
+//# sourceMappingURL=consolidator.d.ts.map

package/dist/esm/ai-memory/facts/consolidator.js

@@ -0,0 +1,134 @@
+export class FactConsolidator {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async consolidate(options) {
+        const facts = await this.db.findByThread(options.threadId);
+        if (!facts.length) {
+            return { merged: 0, invalidated: 0, remaining: 0 };
+        }
+        const threshold = options.similarityThreshold ?? 0.85;
+        const invalidateSuperseded = options.invalidateSuperseded ?? true;
+        const byCategory = this.groupByCategory(facts);
+        let merged = 0;
+        let invalidated = 0;
+        for (const [, categoryFacts] of Object.entries(byCategory)) {
+            const result = await this.consolidateCategory(categoryFacts, threshold, invalidateSuperseded);
+            merged += result.merged;
+            invalidated += result.invalidated;
+        }
+        const remainingFacts = await this.db.findByThread(options.threadId);
+        const remaining = remainingFacts.filter((fact) => !fact.invalidated).length;
+        return { merged, invalidated, remaining };
+    }
+    async consolidateCategory(facts, threshold, invalidateSuperseded) {
+        if (facts.length <= 1) {
+            return { merged: 0, invalidated: 0 };
+        }
+        const similarPairs = this.findSimilarPairs(facts, threshold);
+        let merged = 0;
+        let invalidated = 0;
+        const processed = new Set();
+        for (const [fact1, fact2] of similarPairs) {
+            if (processed.has(fact1.id) || processed.has(fact2.id))
+                continue;
+            const [keeper, superseded] = this.selectKeeper(fact1, fact2);
+            if (invalidateSuperseded) {
+                await this.db.update(superseded.id, {
+                    invalidated: true,
+                    invalidationReason: `Superseded by ${keeper.id}`,
+                });
+                invalidated++;
+            }
+            else {
+                await this.db.delete(superseded.id);
+            }
+            await this.db.update(keeper.id, {
+                accessCount: keeper.accessCount + superseded.accessCount,
+            });
+            processed.add(fact1.id);
+            processed.add(fact2.id);
+            merged++;
+        }
+        return { merged, invalidated };
+    }
+    groupByCategory(facts) {
+        const groups = {};
+        for (const fact of facts) {
+            if (fact.invalidated)
+                continue;
+            if (!groups[fact.category]) {
+                groups[fact.category] = [];
+            }
+            groups[fact.category]?.push(fact);
+        }
+        return groups;
+    }
+    checkFactPair(fact1, fact2, threshold) {
+        if (!fact1 || !fact2)
+            return null;
+        const similarity = this.calculateSimilarity(fact1, fact2);
+        return similarity >= threshold ? [fact1, fact2] : null;
+    }
+    sortPairsBySimilarity(pairs) {
+        return pairs.toSorted((a, b) => {
+            const simA = this.calculateSimilarity(a[0], a[1]);
+            const simB = this.calculateSimilarity(b[0], b[1]);
+            return simB - simA;
+        });
+    }
+    findSimilarPairs(facts, threshold) {
+        const pairs = [];
+        for (let i = 0; i < facts.length; i++) {
+            for (let j = i + 1; j < facts.length; j++) {
+                const pair = this.checkFactPair(facts[i], facts[j], threshold);
+                if (pair)
+                    pairs.push(pair);
+            }
+        }
+        return this.sortPairsBySimilarity(pairs);
+    }
+    calculateSimilarity(fact1, fact2) {
+        if (fact1.embedding && fact2.embedding) {
+            return this.cosineSimilarity(fact1.embedding, fact2.embedding);
+        }
+        return this.textSimilarity(fact1.content, fact2.content);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            const aVal = a[i] ?? 0;
+            const bVal = b[i] ?? 0;
+            dotProduct += aVal * bVal;
+            normA += aVal * aVal;
+            normB += bVal * bVal;
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    textSimilarity(text1, text2) {
+        const words1 = new Set(text1.toLowerCase().split(/\s+/));
+        const words2 = new Set(text2.toLowerCase().split(/\s+/));
+        const intersection = new Set([...words1].filter((word) => words2.has(word)));
+        const union = new Set([...words1, ...words2]);
+        return union.size === 0 ? 0 : intersection.size / union.size;
+    }
+    selectKeeper(fact1, fact2) {
+        const confidenceOrder = { high: 3, medium: 2, low: 1 };
+        const conf1 = confidenceOrder[fact1.confidence] ?? 0;
+        const conf2 = confidenceOrder[fact2.confidence] ?? 0;
+        if (conf1 !== conf2) {
+            return conf1 > conf2 ? [fact1, fact2] : [fact2, fact1];
+        }
+        return fact1.createdAt > fact2.createdAt ? [fact1, fact2] : [fact2, fact1];
+    }
+}
+export function createFactConsolidator(db) {
+    return new FactConsolidator(db);
+}
+//# sourceMappingURL=consolidator.js.map

package/dist/esm/ai-memory/facts/extractor.d.ts

@@ -0,0 +1,28 @@
+import type { ConfidenceLevel, FactCategory, FactExtractionOptions, FactExtractionResult, FactId } from './types.js';
+export interface FactExtractionLLM {
+    extractFacts(text: string, options: {
+        categories?: FactCategory[];
+        maxFacts?: number;
+    }): Promise<ExtractedFactData[]>;
+    embed(text: string): Promise<number[]>;
+    countTokens(text: string): number;
+}
+export interface ExtractedFactData {
+    category: FactCategory;
+    content: string;
+    confidence: ConfidenceLevel;
+}
+export declare class FactExtractor {
+    private llm;
+    constructor(llm: FactExtractionLLM);
+    extractFromMessage(message: string, options: FactExtractionOptions): Promise<FactExtractionResult>;
+    extractFromConversation(messages: string[], options: FactExtractionOptions): Promise<FactExtractionResult>;
+    private filterByConfidence;
+    private createFacts;
+    private deduplicateFacts;
+    private calculateCompressedTokens;
+}
+export declare function generateFactId(): FactId;
+export declare const FACT_EXTRACTION_PROMPT = "Extract key facts from the following conversation message.\n\nFor each fact, provide:\n- category: one of preference, context, decision, constraint, entity, relationship, event\n- content: a concise statement of the fact\n- confidence: high, medium, or low\n\nFocus on:\n- User preferences and requirements\n- Project context and constraints\n- Technical decisions made\n- Named entities (files, databases, APIs)\n- Relationships between entities\n\nReturn as JSON array:\n[\n  {\"category\": \"preference\", \"content\": \"User prefers TypeScript over JavaScript\", \"confidence\": \"high\"},\n  ...\n]\n\nMessage:\n{{message}}";
+export declare function createFactExtractor(llm: FactExtractionLLM): FactExtractor;
+//# sourceMappingURL=extractor.d.ts.map

package/dist/esm/ai-memory/facts/extractor.js

@@ -0,0 +1,119 @@
+export class FactExtractor {
+    llm;
+    constructor(llm) {
+        this.llm = llm;
+    }
+    async extractFromMessage(message, options) {
+        const sourceTokens = this.llm.countTokens(message);
+        const extractedFacts = await this.llm.extractFacts(message, {
+            categories: options.categories,
+            maxFacts: options.maxFacts ?? 10,
+        });
+        const filteredFacts = options.minConfidence
+            ? this.filterByConfidence(extractedFacts, options.minConfidence)
+            : extractedFacts;
+        const facts = await this.createFacts(filteredFacts, options.threadId);
+        const compressedTokens = this.calculateCompressedTokens(facts);
+        const compressionRatio = sourceTokens > 0 ? 1 - compressedTokens / sourceTokens : 0;
+        return {
+            facts,
+            sourceTokens,
+            compressedTokens,
+            compressionRatio,
+        };
+    }
+    async extractFromConversation(messages, options) {
+        const allFacts = [];
+        let totalSourceTokens = 0;
+        let totalCompressedTokens = 0;
+        for (const message of messages) {
+            const result = await this.extractFromMessage(message, options);
+            allFacts.push(...result.facts);
+            totalSourceTokens += result.sourceTokens;
+            totalCompressedTokens += result.compressedTokens;
+        }
+        const dedupedFacts = this.deduplicateFacts(allFacts);
+        return {
+            facts: dedupedFacts,
+            sourceTokens: totalSourceTokens,
+            compressedTokens: this.calculateCompressedTokens(dedupedFacts),
+            compressionRatio: totalSourceTokens > 0 ? 1 - totalCompressedTokens / totalSourceTokens : 0,
+        };
+    }
+    filterByConfidence(facts, minConfidence) {
+        const confidenceLevels = {
+            high: 3,
+            medium: 2,
+            low: 1,
+        };
+        const minLevel = confidenceLevels[minConfidence];
+        return facts.filter((fact) => confidenceLevels[fact.confidence] >= minLevel);
+    }
+    async createFacts(extractedFacts, threadId) {
+        const now = new Date();
+        const facts = [];
+        for (const data of extractedFacts) {
+            const embedding = await this.llm.embed(data.content);
+            facts.push({
+                id: generateFactId(),
+                threadId,
+                category: data.category,
+                content: data.content,
+                confidence: data.confidence,
+                embedding,
+                accessCount: 0,
+                lastAccessedAt: now,
+                createdAt: now,
+                invalidated: false,
+            });
+        }
+        return facts;
+    }
+    deduplicateFacts(facts) {
+        const seen = new Set();
+        const unique = [];
+        for (const fact of facts) {
+            const normalized = fact.content.toLowerCase().trim();
+            if (!seen.has(normalized)) {
+                seen.add(normalized);
+                unique.push(fact);
+            }
+        }
+        return unique;
+    }
+    calculateCompressedTokens(facts) {
+        const totalChars = facts.reduce((sum, fact) => sum + fact.content.length, 0);
+        return Math.ceil(totalChars / 4);
+    }
+}
+export function generateFactId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `fact_${timestamp}_${random}`;
+}
+export const FACT_EXTRACTION_PROMPT = `Extract key facts from the following conversation message.
+
+For each fact, provide:
+- category: one of preference, context, decision, constraint, entity, relationship, event
+- content: a concise statement of the fact
+- confidence: high, medium, or low
+
+Focus on:
+- User preferences and requirements
+- Project context and constraints
+- Technical decisions made
+- Named entities (files, databases, APIs)
+- Relationships between entities
+
+Return as JSON array:
+[
+  {"category": "preference", "content": "User prefers TypeScript over JavaScript", "confidence": "high"},
+  ...
+]
+
+Message:
+{{message}}`;
+export function createFactExtractor(llm) {
+    return new FactExtractor(llm);
+}
+//# sourceMappingURL=extractor.js.map

package/dist/esm/ai-memory/facts/types.d.ts

@@ -0,0 +1,61 @@
+export type FactId = string;
+export type FactCategory = 'preference' | 'context' | 'decision' | 'constraint' | 'entity' | 'relationship' | 'event';
+export type ConfidenceLevel = 'high' | 'medium' | 'low';
+export interface Fact {
+    id: FactId;
+    threadId: string;
+    category: FactCategory;
+    content: string;
+    confidence: ConfidenceLevel;
+    sourceId?: string;
+    embedding?: number[];
+    accessCount: number;
+    lastAccessedAt: Date;
+    createdAt: Date;
+    invalidated: boolean;
+    invalidationReason?: string;
+}
+export interface FactExtractionOptions {
+    threadId: string;
+    categories?: FactCategory[];
+    minConfidence?: ConfidenceLevel;
+    maxFacts?: number;
+}
+export interface FactExtractionResult {
+    facts: Fact[];
+    sourceTokens: number;
+    compressedTokens: number;
+    compressionRatio: number;
+}
+export interface FactRetrievalOptions {
+    threadId: string;
+    query?: string;
+    categories?: FactCategory[];
+    limit?: number;
+    minRelevance?: number;
+    includeInvalidated?: boolean;
+}
+export interface RetrievedFact extends Fact {
+    relevance: number;
+}
+export interface FactConsolidationOptions {
+    threadId: string;
+    similarityThreshold?: number;
+    invalidateSuperseded?: boolean;
+}
+export interface FactConsolidationResult {
+    merged: number;
+    invalidated: number;
+    remaining: number;
+}
+export type MemoryTier = 'short_term' | 'long_term' | 'archived';
+export interface MemoryEntry {
+    id: string;
+    content: string;
+    tier: MemoryTier;
+    facts: FactId[];
+    tokenCount: number;
+    createdAt: Date;
+    expiresAt?: Date;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/ai-memory/facts/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/ai-memory/hierarchy/retriever.d.ts

@@ -0,0 +1,47 @@
+import type { Checkpoint, CheckpointState } from '#ai-memory/checkpoint/types';
+import type { FactRetrievalOptions, RetrievedFact } from '#ai-memory/facts/types';
+export interface MemoryRetrievalConfig {
+    shortTermMaxTokens: number;
+    longTermMaxTokens: number;
+    minRelevance: number;
+    includeRecentMessages: boolean;
+    recentMessageCount: number;
+}
+export declare const DEFAULT_RETRIEVAL_CONFIG: MemoryRetrievalConfig;
+export interface RetrievedContext {
+    shortTerm: {
+        messages: CheckpointState['messages'];
+        tokenCount: number;
+    };
+    longTerm: {
+        facts: RetrievedFact[];
+        tokenCount: number;
+    };
+    totalTokens: number;
+    compressionRatio: number;
+}
+export interface MemoryStore {
+    getLatestCheckpoint(threadId: string): Promise<Checkpoint | null>;
+    getFacts(options: FactRetrievalOptions): Promise<RetrievedFact[]>;
+    touchFact(factId: string): Promise<void>;
+}
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+}
+export declare class HierarchicalRetriever {
+    private store;
+    private embedder;
+    private config;
+    constructor(store: MemoryStore, embedder: EmbeddingProvider, config?: Partial<MemoryRetrievalConfig>);
+    retrieve(threadId: string, query: string): Promise<RetrievedContext>;
+    private retrieveShortTerm;
+    private retrieveLongTerm;
+    private selectRecentMessages;
+    private selectFactsWithinLimit;
+    private estimateOriginalTokens;
+    private estimateTokens;
+    private cosineSimilarity;
+}
+export declare function formatContextForPrompt(context: RetrievedContext): string;
+export declare function createHierarchicalRetriever(store: MemoryStore, embedder: EmbeddingProvider, config?: Partial<MemoryRetrievalConfig>): HierarchicalRetriever;
+//# sourceMappingURL=retriever.d.ts.map

package/dist/esm/ai-memory/hierarchy/retriever.js

@@ -0,0 +1,139 @@
+export const DEFAULT_RETRIEVAL_CONFIG = {
+    shortTermMaxTokens: 2000,
+    longTermMaxTokens: 1000,
+    minRelevance: 0.5,
+    includeRecentMessages: true,
+    recentMessageCount: 5,
+};
+export class HierarchicalRetriever {
+    store;
+    embedder;
+    config;
+    constructor(store, embedder, config = {}) {
+        this.store = store;
+        this.embedder = embedder;
+        this.config = { ...DEFAULT_RETRIEVAL_CONFIG, ...config };
+    }
+    async retrieve(threadId, query) {
+        const shortTerm = await this.retrieveShortTerm(threadId);
+        const longTerm = await this.retrieveLongTerm(threadId, query);
+        const totalTokens = shortTerm.tokenCount + longTerm.tokenCount;
+        const estimatedOriginalTokens = await this.estimateOriginalTokens(threadId);
+        const compressionRatio = estimatedOriginalTokens > 0 ? 1 - totalTokens / estimatedOriginalTokens : 0;
+        return {
+            shortTerm,
+            longTerm,
+            totalTokens,
+            compressionRatio,
+        };
+    }
+    async retrieveShortTerm(threadId) {
+        if (!this.config.includeRecentMessages) {
+            return { messages: [], tokenCount: 0 };
+        }
+        const checkpoint = await this.store.getLatestCheckpoint(threadId);
+        if (!checkpoint) {
+            return { messages: [], tokenCount: 0 };
+        }
+        const messages = this.selectRecentMessages(checkpoint.state.messages, this.config.recentMessageCount, this.config.shortTermMaxTokens);
+        const tokenCount = this.estimateTokens(messages.map((message) => message.content).join(' '));
+        return { messages, tokenCount };
+    }
+    async retrieveLongTerm(threadId, query) {
+        const queryEmbedding = await this.embedder.embed(query);
+        const facts = await this.store.getFacts({
+            threadId,
+            query,
+            minRelevance: this.config.minRelevance,
+            limit: 50,
+        });
+        const scoredFacts = facts.map((fact) => Object.assign({}, fact, {
+            relevance: fact.embedding
+                ? this.cosineSimilarity(queryEmbedding, fact.embedding)
+                : fact.relevance,
+        }));
+        scoredFacts.sort((a, b) => b.relevance - a.relevance);
+        const selectedFacts = this.selectFactsWithinLimit(scoredFacts, this.config.longTermMaxTokens);
+        for (const fact of selectedFacts) {
+            await this.store.touchFact(fact.id);
+        }
+        const tokenCount = this.estimateTokens(selectedFacts.map((fact) => fact.content).join(' '));
+        return { facts: selectedFacts, tokenCount };
+    }
+    selectRecentMessages(messages, maxCount, maxTokens) {
+        const recent = messages.slice(-maxCount);
+        const selected = [];
+        let tokens = 0;
+        for (let i = recent.length - 1; i >= 0; i--) {
+            const message = recent[i];
+            if (!message)
+                continue;
+            const messageTokens = this.estimateTokens(message.content);
+            if (tokens + messageTokens > maxTokens)
+                break;
+            selected.unshift(message);
+            tokens += messageTokens;
+        }
+        return selected;
+    }
+    selectFactsWithinLimit(facts, maxTokens) {
+        const selected = [];
+        let tokens = 0;
+        for (const fact of facts) {
+            const factTokens = this.estimateTokens(fact.content);
+            if (tokens + factTokens > maxTokens)
+                break;
+            selected.push(fact);
+            tokens += factTokens;
+        }
+        return selected;
+    }
+    async estimateOriginalTokens(threadId) {
+        const checkpoint = await this.store.getLatestCheckpoint(threadId);
+        if (!checkpoint)
+            return 0;
+        const allContent = checkpoint.state.messages
+            .map((message) => message.content)
+            .join(' ');
+        return this.estimateTokens(allContent);
+    }
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            const aVal = a[i] ?? 0;
+            const bVal = b[i] ?? 0;
+            dotProduct += aVal * bVal;
+            normA += aVal * aVal;
+            normB += bVal * bVal;
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+}
+export function formatContextForPrompt(context) {
+    const sections = [];
+    if (context.shortTerm.messages.length > 0) {
+        sections.push('## Recent Conversation');
+        for (const message of context.shortTerm.messages) {
+            sections.push(`${message.role}: ${message.content}`);
+        }
+    }
+    if (context.longTerm.facts.length > 0) {
+        sections.push('\n## Relevant Context');
+        for (const fact of context.longTerm.facts) {
+            sections.push(`- [${fact.category}] ${fact.content}`);
+        }
+    }
+    return sections.join('\n');
+}
+export function createHierarchicalRetriever(store, embedder, config) {
+    return new HierarchicalRetriever(store, embedder, config);
+}
+//# sourceMappingURL=retriever.js.map