@riotprompt/riotprompt 0.0.8 → 0.0.10

package/dist/context-manager.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Dynamic content item with enhanced tracking and lifecycle
+ */
+export interface DynamicContentItem {
+    content: string;
+    title?: string;
+    weight?: number;
+    id?: string;
+    category?: string;
+    source?: string;
+    priority?: 'high' | 'medium' | 'low';
+    timestamp?: Date;
+}
+/**
+ * Tracked context item with metadata
+ */
+export interface TrackedContextItem extends DynamicContentItem {
+    id: string;
+    hash: string;
+    position: number;
+    injectedAt: Date;
+}
+/**
+ * Context statistics
+ */
+export interface ContextStats {
+    totalItems: number;
+    byCategory: Map<string, number>;
+    byPriority: Map<string, number>;
+    bySource: Map<string, number>;
+    oldestTimestamp?: Date;
+    newestTimestamp?: Date;
+}
+/**
+ * ContextManager tracks and manages dynamically injected context.
+ *
+ * Features:
+ * - Track all injected context with metadata
+ * - Deduplication by ID, hash, or content
+ * - Category-based organization
+ * - Query context state
+ * - Context statistics
+ *
+ * @example
+ * ```typescript
+ * const manager = new ContextManager();
+ *
+ * // Track injected context
+ * manager.track({
+ *   id: 'file:main.ts',
+ *   content: fileContent,
+ *   title: 'Main File',
+ *   category: 'source-code'
+ * }, 5);
+ *
+ * // Check for duplicates
+ * if (manager.hasContext('file:main.ts')) {
+ *   console.log('Already provided');
+ * }
+ *
+ * // Query by category
+ * const sourceFiles = manager.getByCategory('source-code');
+ * ```
+ */
+export declare class ContextManager {
+    private items;
+    private hashes;
+    private logger;
+    constructor(logger?: any);
+    /**
+     * Track a context item (with deduplication by content hash for items without ID)
+     */
+    track(item: DynamicContentItem, position: number): void;
+    /**
+     * Check if context with given ID exists
+     */
+    hasContext(id: string): boolean;
+    /**
+     * Check if content with given hash exists
+     */
+    hasContentHash(content: string): boolean;
+    /**
+     * Check if similar content exists (fuzzy match)
+     * Uses similarity threshold to avoid overly aggressive deduplication
+     */
+    hasSimilarContent(content: string, similarityThreshold?: number): boolean;
+    /**
+     * Get context item by ID
+     */
+    get(id: string): TrackedContextItem | undefined;
+    /**
+     * Get all tracked context items
+     */
+    getAll(): TrackedContextItem[];
+    /**
+     * Get context items by category
+     */
+    getByCategory(category: string): TrackedContextItem[];
+    /**
+     * Get context items by priority
+     */
+    getByPriority(priority: 'high' | 'medium' | 'low'): TrackedContextItem[];
+    /**
+     * Get context items by source
+     */
+    getBySource(source: string): TrackedContextItem[];
+    /**
+     * Get all categories
+     */
+    getCategories(): string[];
+    /**
+     * Get context statistics
+     */
+    getStats(): ContextStats;
+    /**
+     * Remove context item by ID
+     */
+    remove(id: string): boolean;
+    /**
+     * Clear all tracked context
+     */
+    clear(): void;
+    /**
+     * Generate unique ID for context item
+     */
+    private generateId;
+    /**
+     * Hash content for deduplication
+     */
+    private hashContent;
+    /**
+     * Normalize content for comparison
+     */
+    private normalizeContent;
+}
+export default ContextManager;

package/dist/context-manager.js

@@ -0,0 +1,243 @@
+import crypto from 'crypto';
+import { wrapLogger, DEFAULT_LOGGER } from './logger.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * ContextManager tracks and manages dynamically injected context.
+ *
+ * Features:
+ * - Track all injected context with metadata
+ * - Deduplication by ID, hash, or content
+ * - Category-based organization
+ * - Query context state
+ * - Context statistics
+ *
+ * @example
+ * ```typescript
+ * const manager = new ContextManager();
+ *
+ * // Track injected context
+ * manager.track({
+ *   id: 'file:main.ts',
+ *   content: fileContent,
+ *   title: 'Main File',
+ *   category: 'source-code'
+ * }, 5);
+ *
+ * // Check for duplicates
+ * if (manager.hasContext('file:main.ts')) {
+ *   console.log('Already provided');
+ * }
+ *
+ * // Query by category
+ * const sourceFiles = manager.getByCategory('source-code');
+ * ```
+ */ class ContextManager {
+    /**
+     * Track a context item (with deduplication by content hash for items without ID)
+     */ track(item, position) {
+        const hash = this.hashContent(item.content);
+        // If item has no ID and we already have this content hash, skip tracking
+        if (!item.id && this.hashes.has(hash)) {
+            this.logger.debug('Skipping duplicate context item by hash', {
+                hash
+            });
+            return;
+        }
+        const id = item.id || this.generateId();
+        const trackedItem = {
+            ...item,
+            id,
+            hash,
+            position,
+            injectedAt: new Date(),
+            timestamp: item.timestamp || new Date(),
+            priority: item.priority || 'medium'
+        };
+        this.items.set(id, trackedItem);
+        this.hashes.add(hash);
+        this.logger.debug('Tracked context item', {
+            id,
+            category: item.category,
+            position
+        });
+    }
+    /**
+     * Check if context with given ID exists
+     */ hasContext(id) {
+        return this.items.has(id);
+    }
+    /**
+     * Check if content with given hash exists
+     */ hasContentHash(content) {
+        const hash = this.hashContent(content);
+        return this.hashes.has(hash);
+    }
+    /**
+     * Check if similar content exists (fuzzy match)
+     * Uses similarity threshold to avoid overly aggressive deduplication
+     */ hasSimilarContent(content, similarityThreshold = 0.9) {
+        // Warn if checking against a large number of items (performance consideration)
+        const MAX_ITEMS_WARNING = 1000;
+        if (this.items.size > MAX_ITEMS_WARNING) {
+            this.logger.warn('Large number of context items, similarity check may be slow', {
+                count: this.items.size,
+                threshold: MAX_ITEMS_WARNING
+            });
+        }
+        const normalized = this.normalizeContent(content);
+        for (const item of this.items.values()){
+            const itemNormalized = this.normalizeContent(item.content || '');
+            // Exact match
+            if (normalized === itemNormalized) {
+                return true;
+            }
+            // Calculate similarity ratio (Jaccard-like)
+            const longer = normalized.length > itemNormalized.length ? normalized : itemNormalized;
+            const shorter = normalized.length <= itemNormalized.length ? normalized : itemNormalized;
+            // Only consider substring match if the shorter is at least 90% of longer
+            const lengthRatio = shorter.length / longer.length;
+            if (lengthRatio >= similarityThreshold) {
+                // Check if one is contained in the other
+                if (longer.includes(shorter)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Get context item by ID
+     */ get(id) {
+        return this.items.get(id);
+    }
+    /**
+     * Get all tracked context items
+     */ getAll() {
+        return Array.from(this.items.values());
+    }
+    /**
+     * Get context items by category
+     */ getByCategory(category) {
+        return this.getAll().filter((item)=>item.category === category);
+    }
+    /**
+     * Get context items by priority
+     */ getByPriority(priority) {
+        return this.getAll().filter((item)=>item.priority === priority);
+    }
+    /**
+     * Get context items by source
+     */ getBySource(source) {
+        return this.getAll().filter((item)=>item.source === source);
+    }
+    /**
+     * Get all categories
+     */ getCategories() {
+        const categories = new Set();
+        this.items.forEach((item)=>{
+            if (item.category) {
+                categories.add(item.category);
+            }
+        });
+        return Array.from(categories).sort();
+    }
+    /**
+     * Get context statistics
+     */ getStats() {
+        const byCategory = new Map();
+        const byPriority = new Map();
+        const bySource = new Map();
+        let oldestTimestamp;
+        let newestTimestamp;
+        this.items.forEach((item)=>{
+            // Category stats
+            if (item.category) {
+                byCategory.set(item.category, (byCategory.get(item.category) || 0) + 1);
+            }
+            // Priority stats
+            const priority = item.priority || 'medium';
+            byPriority.set(priority, (byPriority.get(priority) || 0) + 1);
+            // Source stats
+            if (item.source) {
+                bySource.set(item.source, (bySource.get(item.source) || 0) + 1);
+            }
+            // Timestamp stats
+            if (item.timestamp) {
+                if (!oldestTimestamp || item.timestamp < oldestTimestamp) {
+                    oldestTimestamp = item.timestamp;
+                }
+                if (!newestTimestamp || item.timestamp > newestTimestamp) {
+                    newestTimestamp = item.timestamp;
+                }
+            }
+        });
+        return {
+            totalItems: this.items.size,
+            byCategory,
+            byPriority,
+            bySource,
+            oldestTimestamp,
+            newestTimestamp
+        };
+    }
+    /**
+     * Remove context item by ID
+     */ remove(id) {
+        const item = this.items.get(id);
+        if (item) {
+            this.items.delete(id);
+            this.hashes.delete(item.hash);
+            this.logger.debug('Removed context item', {
+                id
+            });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Clear all tracked context
+     */ clear() {
+        this.items.clear();
+        this.hashes.clear();
+        this.logger.debug('Cleared all context');
+    }
+    /**
+     * Generate unique ID for context item
+     */ generateId() {
+        return `ctx-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Hash content for deduplication
+     */ hashContent(content) {
+        return crypto.createHash('sha256').update(content).digest('hex').substring(0, 16);
+    }
+    /**
+     * Normalize content for comparison
+     */ normalizeContent(content) {
+        return content.replace(/\s+/g, ' ').trim().toLowerCase();
+    }
+    constructor(logger){
+        _define_property(this, "items", void 0);
+        _define_property(this, "hashes", void 0);
+        _define_property(this, "logger", void 0);
+        this.items = new Map();
+        this.hashes = new Set();
+        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ContextManager');
+    }
+}
+
+export { ContextManager, ContextManager as default };
+//# sourceMappingURL=context-manager.js.map

package/dist/context-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-manager.js","sources":["../src/context-manager.ts"],"sourcesContent":["import crypto from 'crypto';\nimport { DEFAULT_LOGGER, wrapLogger } from \"./logger\";\n\n// ===== TYPE DEFINITIONS =====\n\n/**\n * Dynamic content item with enhanced tracking and lifecycle\n */\nexport interface DynamicContentItem {\n    content: string;\n    title?: string;\n    weight?: number;\n\n    // Unique identifier for deduplication\n    id?: string;\n\n    // Category for grouping\n    category?: string;\n\n    // Source of context\n    source?: string;\n\n    // Priority level\n    priority?: 'high' | 'medium' | 'low';\n\n    // Timestamp\n    timestamp?: Date;\n}\n\n/**\n * Tracked context item with metadata\n */\nexport interface TrackedContextItem extends DynamicContentItem {\n    id: string;\n    hash: string;\n    position: number;\n    injectedAt: Date;\n}\n\n/**\n * Context statistics\n */\nexport interface ContextStats {\n    totalItems: number;\n    byCategory: Map<string, number>;\n    byPriority: Map<string, number>;\n    bySource: Map<string, number>;\n    oldestTimestamp?: Date;\n    newestTimestamp?: Date;\n}\n\n/**\n * ContextManager tracks and manages dynamically injected context.\n *\n * Features:\n * - Track all injected context with metadata\n * - Deduplication by ID, hash, or content\n * - Category-based organization\n * - Query context state\n * - Context statistics\n *\n * @example\n * ```typescript\n * const manager = new ContextManager();\n *\n * // Track injected context\n * manager.track({\n *   id: 'file:main.ts',\n *   content: fileContent,\n *   title: 'Main File',\n *   category: 'source-code'\n * }, 5);\n *\n * // Check for duplicates\n * if (manager.hasContext('file:main.ts')) {\n *   console.log('Already provided');\n * }\n *\n * // Query by category\n * const sourceFiles = manager.getByCategory('source-code');\n * ```\n */\nexport class ContextManager {\n    private items: Map<string, TrackedContextItem>;\n    private hashes: Set<string>;\n    private logger: any;\n\n    constructor(logger?: any) {\n        this.items = new Map();\n        this.hashes = new Set();\n        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ContextManager');\n    }\n\n    /**\n     * Track a context item (with deduplication by content hash for items without ID)\n     */\n    track(item: DynamicContentItem, position: number): void {\n        const hash = this.hashContent(item.content);\n\n        // If item has no ID and we already have this content hash, skip tracking\n        if (!item.id && this.hashes.has(hash)) {\n            this.logger.debug('Skipping duplicate context item by hash', { hash });\n            return;\n        }\n\n        const id = item.id || this.generateId();\n\n        const trackedItem: TrackedContextItem = {\n            ...item,\n            id,\n            hash,\n            position,\n            injectedAt: new Date(),\n            timestamp: item.timestamp || new Date(),\n            priority: item.priority || 'medium',\n        };\n\n        this.items.set(id, trackedItem);\n        this.hashes.add(hash);\n\n        this.logger.debug('Tracked context item', { id, category: item.category, position });\n    }\n\n    /**\n     * Check if context with given ID exists\n     */\n    hasContext(id: string): boolean {\n        return this.items.has(id);\n    }\n\n    /**\n     * Check if content with given hash exists\n     */\n    hasContentHash(content: string): boolean {\n        const hash = this.hashContent(content);\n        return this.hashes.has(hash);\n    }\n\n    /**\n     * Check if similar content exists (fuzzy match)\n     * Uses similarity threshold to avoid overly aggressive deduplication\n     */\n    hasSimilarContent(content: string, similarityThreshold: number = 0.9): boolean {\n        // Warn if checking against a large number of items (performance consideration)\n        const MAX_ITEMS_WARNING = 1000;\n        if (this.items.size > MAX_ITEMS_WARNING) {\n            this.logger.warn('Large number of context items, similarity check may be slow', {\n                count: this.items.size,\n                threshold: MAX_ITEMS_WARNING\n            });\n        }\n\n        const normalized = this.normalizeContent(content);\n\n        for (const item of this.items.values()) {\n            const itemNormalized = this.normalizeContent(item.content || '');\n\n            // Exact match\n            if (normalized === itemNormalized) {\n                return true;\n            }\n\n            // Calculate similarity ratio (Jaccard-like)\n            const longer = normalized.length > itemNormalized.length ? normalized : itemNormalized;\n            const shorter = normalized.length <= itemNormalized.length ? normalized : itemNormalized;\n\n            // Only consider substring match if the shorter is at least 90% of longer\n            const lengthRatio = shorter.length / longer.length;\n\n            if (lengthRatio >= similarityThreshold) {\n                // Check if one is contained in the other\n                if (longer.includes(shorter)) {\n                    return true;\n                }\n            }\n        }\n\n        return false;\n    }\n\n    /**\n     * Get context item by ID\n     */\n    get(id: string): TrackedContextItem | undefined {\n        return this.items.get(id);\n    }\n\n    /**\n     * Get all tracked context items\n     */\n    getAll(): TrackedContextItem[] {\n        return Array.from(this.items.values());\n    }\n\n    /**\n     * Get context items by category\n     */\n    getByCategory(category: string): TrackedContextItem[] {\n        return this.getAll().filter(item => item.category === category);\n    }\n\n    /**\n     * Get context items by priority\n     */\n    getByPriority(priority: 'high' | 'medium' | 'low'): TrackedContextItem[] {\n        return this.getAll().filter(item => item.priority === priority);\n    }\n\n    /**\n     * Get context items by source\n     */\n    getBySource(source: string): TrackedContextItem[] {\n        return this.getAll().filter(item => item.source === source);\n    }\n\n    /**\n     * Get all categories\n     */\n    getCategories(): string[] {\n        const categories = new Set<string>();\n        this.items.forEach(item => {\n            if (item.category) {\n                categories.add(item.category);\n            }\n        });\n        return Array.from(categories).sort();\n    }\n\n    /**\n     * Get context statistics\n     */\n    getStats(): ContextStats {\n        const byCategory = new Map<string, number>();\n        const byPriority = new Map<string, number>();\n        const bySource = new Map<string, number>();\n        let oldestTimestamp: Date | undefined;\n        let newestTimestamp: Date | undefined;\n\n        this.items.forEach(item => {\n            // Category stats\n            if (item.category) {\n                byCategory.set(item.category, (byCategory.get(item.category) || 0) + 1);\n            }\n\n            // Priority stats\n            const priority = item.priority || 'medium';\n            byPriority.set(priority, (byPriority.get(priority) || 0) + 1);\n\n            // Source stats\n            if (item.source) {\n                bySource.set(item.source, (bySource.get(item.source) || 0) + 1);\n            }\n\n            // Timestamp stats\n            if (item.timestamp) {\n                if (!oldestTimestamp || item.timestamp < oldestTimestamp) {\n                    oldestTimestamp = item.timestamp;\n                }\n                if (!newestTimestamp || item.timestamp > newestTimestamp) {\n                    newestTimestamp = item.timestamp;\n                }\n            }\n        });\n\n        return {\n            totalItems: this.items.size,\n            byCategory,\n            byPriority,\n            bySource,\n            oldestTimestamp,\n            newestTimestamp,\n        };\n    }\n\n    /**\n     * Remove context item by ID\n     */\n    remove(id: string): boolean {\n        const item = this.items.get(id);\n        if (item) {\n            this.items.delete(id);\n            this.hashes.delete(item.hash);\n            this.logger.debug('Removed context item', { id });\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Clear all tracked context\n     */\n    clear(): void {\n        this.items.clear();\n        this.hashes.clear();\n        this.logger.debug('Cleared all context');\n    }\n\n    /**\n     * Generate unique ID for context item\n     */\n    private generateId(): string {\n        return `ctx-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;\n    }\n\n    /**\n     * Hash content for deduplication\n     */\n    private hashContent(content: string): string {\n        return crypto\n            .createHash('sha256')\n            .update(content)\n            .digest('hex')\n            .substring(0, 16);\n    }\n\n    /**\n     * Normalize content for comparison\n     */\n    private normalizeContent(content: string): string {\n        return content.replace(/\\s+/g, ' ').trim().toLowerCase();\n    }\n}\n\nexport default ContextManager;\n\n"],"names":["ContextManager","track","item","position","hash","hashContent","content","id","hashes","has","logger","debug","generateId","trackedItem","injectedAt","Date","timestamp","priority","items","set","add","category","hasContext","hasContentHash","hasSimilarContent","similarityThreshold","MAX_ITEMS_WARNING","size","warn","count","threshold","normalized","normalizeContent","values","itemNormalized","longer","length","shorter","lengthRatio","includes","get","getAll","Array","from","getByCategory","filter","getByPriority","getBySource","source","getCategories","categories","Set","forEach","sort","getStats","byCategory","Map","byPriority","bySource","oldestTimestamp","newestTimestamp","totalItems","remove","delete","clear","now","Math","random","toString","substring","crypto","createHash","update","digest","replace","trim","toLowerCase","wrapLogger","DEFAULT_LOGGER"],"mappings":"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"}

package/dist/conversation-logger.d.ts

@@ -0,0 +1,285 @@
+import { ConversationMessage, ToolCall } from './conversation';
+/**
+ * Log format
+ */
+export type LogFormat = 'json' | 'markdown' | 'jsonl';
+/**
+ * Log configuration
+ */
+export interface LogConfig {
+    enabled: boolean;
+    outputPath?: string;
+    format?: LogFormat;
+    filenameTemplate?: string;
+    includeMetadata?: boolean;
+    includePrompt?: boolean;
+    redactSensitive?: boolean;
+    redactPatterns?: RegExp[];
+    onSaved?: (path: string) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Logged conversation structure
+ */
+export interface LoggedConversation {
+    id: string;
+    metadata: ConversationLogMetadata;
+    prompt?: PromptSnapshot;
+    messages: LoggedMessage[];
+    summary: ConversationSummary;
+}
+/**
+ * Conversation metadata for logging
+ */
+export interface ConversationLogMetadata {
+    startTime: Date;
+    endTime?: Date;
+    duration?: number;
+    model: string;
+    template?: string;
+    userContext?: Record<string, any>;
+}
+/**
+ * Snapshot of prompt configuration
+ */
+export interface PromptSnapshot {
+    persona?: string;
+    instructions?: string;
+    content?: string[];
+    context?: string[];
+}
+/**
+ * Logged message with metadata
+ */
+export interface LoggedMessage {
+    index: number;
+    timestamp: string;
+    role: string;
+    content: string | null;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    metadata?: MessageLogMetadata;
+}
+/**
+ * Message metadata for logging
+ */
+export interface MessageLogMetadata {
+    tokens?: number;
+    source?: string;
+    latency?: number;
+    tool?: string;
+    duration?: number;
+    success?: boolean;
+    [key: string]: any;
+}
+/**
+ * Conversation summary
+ */
+export interface ConversationSummary {
+    totalMessages: number;
+    totalTokens?: number;
+    toolCallsExecuted: number;
+    iterations: number;
+    finalOutput?: string;
+    success: boolean;
+}
+/**
+ * Tool call log entry
+ */
+export interface ToolCallLog {
+    callId: string;
+    toolName: string;
+    timestamp: string;
+    iteration: number;
+    arguments: any;
+    result: any;
+    duration: number;
+    success: boolean;
+    error?: string;
+}
+/**
+ * ConversationLogger logs conversations to various formats.
+ *
+ * Features:
+ * - Multiple formats (JSON, Markdown, JSONL)
+ * - Automatic timestamping
+ * - Metadata tracking
+ * - Sensitive data redaction
+ * - Streaming support (JSONL)
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConversationLogger({
+ *   enabled: true,
+ *   outputPath: 'logs/conversations',
+ *   format: 'json',
+ *   includeMetadata: true
+ * });
+ *
+ * logger.onConversationStart({ model: 'gpt-4o', startTime: new Date() });
+ * logger.onMessageAdded(message);
+ * const path = await logger.save();
+ * ```
+ */
+export declare class ConversationLogger {
+    private config;
+    private conversationId;
+    private metadata;
+    private messages;
+    private toolCalls;
+    private startTime;
+    private logger;
+    private messageIndex;
+    private cachedOutputPath?;
+    private writeQueue;
+    constructor(config: LogConfig, logger?: any);
+    /**
+     * Start conversation logging
+     */
+    onConversationStart(metadata: Partial<ConversationLogMetadata>): void;
+    /**
+     * Log a message
+     */
+    onMessageAdded(message: ConversationMessage, metadata?: MessageLogMetadata): void;
+    /**
+     * Log a tool call
+     */
+    onToolCall(callId: string, toolName: string, iteration: number, args: any, result: any, duration: number, success: boolean, error?: string): void;
+    /**
+     * End conversation logging
+     */
+    onConversationEnd(_summary: ConversationSummary): void;
+    /**
+     * Save conversation to disk
+     */
+    save(): Promise<string>;
+    /**
+     * Get logged conversation object
+     */
+    getConversation(): LoggedConversation;
+    /**
+     * Generate unique conversation ID
+     */
+    private generateId;
+    /**
+     * Get output file path (cached for JSONL to avoid recalculation)
+     */
+    private getOutputPath;
+    /**
+     * Save as JSON
+     */
+    private saveAsJSON;
+    /**
+     * Save as Markdown
+     */
+    private saveAsMarkdown;
+    /**
+     * Append to JSONL file (streaming)
+     */
+    private appendToJSONL;
+    /**
+     * Redact sensitive content
+     */
+    private redactContent;
+}
+/**
+ * Replay options
+ */
+export interface ReplayOptions {
+    model?: string;
+    maxIterations?: number;
+    retryFailedTools?: boolean;
+    toolTimeout?: number;
+    expectSimilarOutput?: boolean;
+}
+/**
+ * Replay result
+ */
+export interface ReplayResult {
+    success: boolean;
+    conversation: LoggedConversation;
+    errors?: Error[];
+}
+/**
+ * Comparison result
+ */
+export interface ComparisonResult {
+    messageDiff: number;
+    toolCallDiff: number;
+    tokenDiff?: number;
+    outputSimilarity: number;
+    costSavings?: number;
+}
+/**
+ * ConversationReplayer loads and replays logged conversations.
+ *
+ * Features:
+ * - Load from various formats
+ * - Replay conversations
+ * - Compare replays with originals
+ * - Export to different formats
+ *
+ * @example
+ * ```typescript
+ * const replayer = await ConversationReplayer.load('logs/conv.json');
+ *
+ * console.log('Messages:', replayer.messages.length);
+ * console.log('Tool calls:', replayer.getToolCalls().length);
+ *
+ * const timeline = replayer.getTimeline();
+ * console.log('Events:', timeline.length);
+ * ```
+ */
+export declare class ConversationReplayer {
+    private conversation;
+    private logger;
+    private constructor();
+    /**
+     * Load conversation from file
+     */
+    static load(filePath: string, logger?: any): Promise<ConversationReplayer>;
+    /**
+     * Load latest conversation from directory
+     */
+    static loadLatest(directory: string, logger?: any): Promise<ConversationReplayer>;
+    /**
+     * Get all messages
+     */
+    get messages(): LoggedMessage[];
+    /**
+     * Get conversation metadata
+     */
+    getMetadata(): ConversationLogMetadata;
+    /**
+     * Get tool calls
+     */
+    getToolCalls(): ToolCallLog[];
+    /**
+     * Get message at index
+     */
+    getMessageAt(index: number): LoggedMessage | undefined;
+    /**
+     * Get timeline of events
+     */
+    getTimeline(): TimelineEvent[];
+    /**
+     * Export to format
+     */
+    exportToFormat(format: LogFormat, outputPath: string): Promise<string>;
+    /**
+     * Export as markdown
+     */
+    private exportMarkdown;
+}
+/**
+ * Timeline event interface
+ */
+interface TimelineEvent {
+    timestamp: string;
+    iteration: number;
+    type: string;
+    description: string;
+    duration?: number;
+    success?: boolean;
+}
+export default ConversationLogger;