dino-spec 13.6.0 → 13.6.1

package/dist/core/context-repl/repl-environment.js

@@ -1,795 +0,0 @@
-/**
- * REPL Environment - v13.6.0
- *
- * RLM-style REPL environment for context management.
- * Provides programmatic access to context with controlled window growth.
- *
- * Key features:
- * - Peek: Reconnaissance of context structure without full loading
- * - Grep: Pattern matching within loaded context
- * - Execute: Run queries with result truncation
- * - Partition: Segment context by strategy
- *
- * Reference: RLM Paper (arxiv.org/abs/2512.24601v1)
- */
-import { DEFAULT_REPL_MAX_TOKENS, REPL_OPERATION_TIMEOUT_MS, PEEK_SAMPLE_COUNT, PEEK_MAX_DEPTH, VALID_VARIABLE_PATHS, } from './types.js';
-import { parseQuery } from './query-parser.js';
-import { executeQuery } from './query-executor.js';
-import { loadVariable as loadContextVariable } from './variable-loader.js';
-import { estimateTokens } from './condensation.js';
-import { computePartitions } from './partitioning/index.js';
-import { isFeatureEnabled } from '../config/feature-flags.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-// =============================================================================
-// Constants
-// =============================================================================
-const PREVIEW_LENGTH = 100;
-// =============================================================================
-// REPL Environment Implementation
-// =============================================================================
-/**
- * REPL Environment for context management
- *
- * Provides a programmatic interface for context exploration
- * with controlled context window growth.
- */
-export class REPLEnvironment {
-    state;
-    projectDir;
-    maxTokens;
-    constructor(options = {}) {
-        this.projectDir = options.projectDir || process.cwd();
-        this.maxTokens = options.maxTokens || DEFAULT_REPL_MAX_TOKENS;
-        this.state = this.createInitialState();
-    }
-    // ---------------------------------------------------------------------------
-    // State Management
-    // ---------------------------------------------------------------------------
-    createInitialState() {
-        return {
-            variables: new Map(),
-            totalTokens: 0,
-            startedAt: Date.now(),
-            operationCount: 0,
-            history: [],
-        };
-    }
-    getState() {
-        return { ...this.state };
-    }
-    clearState() {
-        const tokensBefore = this.state.totalTokens;
-        this.state = this.createInitialState();
-        this.addHistoryEntry('clear', tokensBefore, 0, true, 'Cleared all state');
-    }
-    // ---------------------------------------------------------------------------
-    // History Tracking
-    // ---------------------------------------------------------------------------
-    addHistoryEntry(operation, tokensBefore, tokensAfter, success, summary) {
-        this.state.history.push({
-            operation,
-            timestamp: Date.now(),
-            tokensBefore,
-            tokensAfter,
-            success,
-            summary,
-        });
-        // Keep history limited
-        if (this.state.history.length > 100) {
-            this.state.history = this.state.history.slice(-100);
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Execute Operation
-    // ---------------------------------------------------------------------------
-    async execute(code) {
-        const startTime = Date.now();
-        const tokensBefore = this.state.totalTokens;
-        this.state.operationCount++;
-        // Check feature flag
-        const enabled = await isFeatureEnabled('enableReplEnvironment', this.projectDir);
-        if (!enabled) {
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: 'REPL environment is disabled. Set enableReplEnvironment: true in .dino/config.json',
-            };
-        }
-        try {
-            // Parse query if string
-            let query;
-            if (typeof code === 'string') {
-                const parsed = parseQuery(code);
-                if (!parsed.success || !parsed.query) {
-                    this.addHistoryEntry('execute', tokensBefore, tokensBefore, false, `Parse error: ${parsed.error}`);
-                    return {
-                        success: false,
-                        data: null,
-                        tokensUsed: 0,
-                        executionTimeMs: Date.now() - startTime,
-                        error: parsed.error || 'Failed to parse query',
-                    };
-                }
-                query = parsed.query;
-            }
-            else {
-                query = code;
-            }
-            // Execute with timeout
-            const result = await this.executeWithTimeout(executeQuery(query, { projectDir: this.projectDir }), REPL_OPERATION_TIMEOUT_MS);
-            if (!result.success) {
-                this.addHistoryEntry('execute', tokensBefore, tokensBefore, false, `Execution error: ${result.error}`);
-                return {
-                    success: false,
-                    data: null,
-                    tokensUsed: 0,
-                    executionTimeMs: Date.now() - startTime,
-                    error: result.error,
-                };
-            }
-            // Estimate tokens and truncate if needed
-            const dataStr = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
-            const tokensUsed = estimateTokens(dataStr);
-            let data = result.data;
-            let warnings;
-            if (tokensUsed > this.maxTokens) {
-                data = this.truncateData(result.data, this.maxTokens);
-                warnings = [`Result truncated from ~${tokensUsed} to ~${this.maxTokens} tokens`];
-            }
-            const finalTokens = warnings ? this.maxTokens : tokensUsed;
-            this.state.totalTokens += finalTokens;
-            this.addHistoryEntry('execute', tokensBefore, this.state.totalTokens, true, `Executed query, ${result.count} results`);
-            return {
-                success: true,
-                data,
-                tokensUsed: finalTokens,
-                executionTimeMs: Date.now() - startTime,
-                warnings,
-            };
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.addHistoryEntry('execute', tokensBefore, tokensBefore, false, `Error: ${errorMsg}`);
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: errorMsg,
-            };
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Peek Operation
-    // ---------------------------------------------------------------------------
-    async peek(pattern) {
-        const startTime = Date.now();
-        const tokensBefore = this.state.totalTokens;
-        this.state.operationCount++;
-        // Check feature flag
-        const enabled = await isFeatureEnabled('enableReplEnvironment', this.projectDir);
-        if (!enabled) {
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: 'REPL environment is disabled. Set enableReplEnvironment: true in .dino/config.json',
-            };
-        }
-        try {
-            const metadata = await this.gatherPeekMetadata(pattern);
-            // Peek doesn't add to token count (read-only reconnaissance)
-            this.addHistoryEntry('peek', tokensBefore, tokensBefore, true, `Peeked ${metadata.totalFiles} files`);
-            return {
-                success: true,
-                data: metadata,
-                tokensUsed: 0, // Peek is free - no context loaded
-                executionTimeMs: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.addHistoryEntry('peek', tokensBefore, tokensBefore, false, `Error: ${errorMsg}`);
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: errorMsg,
-            };
-        }
-    }
-    async gatherPeekMetadata(pattern) {
-        const categories = {};
-        const samples = [];
-        let totalFiles = 0;
-        let totalTokens = 0;
-        // Check .dino directory for session state
-        const dinoDir = path.join(this.projectDir, '.dino');
-        try {
-            const dinoFiles = await this.listFilesRecursive(dinoDir, pattern, 2);
-            for (const file of dinoFiles) {
-                totalFiles++;
-                const category = this.categorizeFile(file);
-                categories[category] = (categories[category] || 0) + 1;
-                // Estimate tokens from file size
-                try {
-                    const stats = await fs.stat(file);
-                    const tokenEstimate = Math.ceil(stats.size / 4); // Rough estimate
-                    totalTokens += tokenEstimate;
-                    // Add sample if under limit
-                    if (samples.length < PEEK_SAMPLE_COUNT) {
-                        const preview = await this.getFilePreview(file);
-                        samples.push({
-                            path: path.relative(this.projectDir, file),
-                            type: category,
-                            sizeEstimate: tokenEstimate,
-                            preview,
-                        });
-                    }
-                }
-                catch {
-                    // Skip files we can't stat
-                }
-            }
-        }
-        catch {
-            // .dino directory might not exist
-        }
-        // Add memory variables info
-        const memoryCategories = ['memories.decisions', 'memories.patterns', 'memories.learnings'];
-        for (const varPath of memoryCategories) {
-            try {
-                const varResult = await loadContextVariable(varPath, this.projectDir);
-                if (!varResult.error && Array.isArray(varResult.data)) {
-                    const count = varResult.data.length;
-                    const cat = varPath.split('.')[1];
-                    categories[`memory:${cat}`] = count;
-                    totalFiles += count;
-                    const dataStr = JSON.stringify(varResult.data);
-                    totalTokens += estimateTokens(dataStr);
-                }
-            }
-            catch {
-                // Memory might not be available
-            }
-        }
-        // Build structure preview
-        const structure = await this.buildStructurePreview(this.projectDir, pattern, PEEK_MAX_DEPTH);
-        return {
-            totalFiles,
-            totalTokens,
-            categories,
-            samples,
-            structure,
-            filterPattern: pattern,
-        };
-    }
-    async listFilesRecursive(dir, pattern, maxDepth = 3, depth = 0) {
-        if (depth >= maxDepth)
-            return [];
-        const files = [];
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-                    const subFiles = await this.listFilesRecursive(fullPath, pattern, maxDepth, depth + 1);
-                    files.push(...subFiles);
-                }
-                else if (entry.isFile()) {
-                    if (!pattern || this.matchesPattern(fullPath, pattern)) {
-                        files.push(fullPath);
-                    }
-                }
-            }
-        }
-        catch {
-            // Directory might not be readable
-        }
-        return files;
-    }
-    matchesPattern(filePath, pattern) {
-        // Simple glob matching
-        const regex = pattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        return new RegExp(regex, 'i').test(filePath);
-    }
-    categorizeFile(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        const name = path.basename(filePath).toLowerCase();
-        if (name === 'session.md')
-            return 'session';
-        if (name === 'config.json')
-            return 'config';
-        if (name.includes('handoff'))
-            return 'handoff';
-        if (name.includes('research'))
-            return 'research';
-        if (name.includes('plan'))
-            return 'plan';
-        if (ext === '.md')
-            return 'documentation';
-        if (ext === '.json')
-            return 'data';
-        return 'other';
-    }
-    async getFilePreview(filePath) {
-        try {
-            const content = await fs.readFile(filePath, 'utf-8');
-            return content.substring(0, PREVIEW_LENGTH).replace(/\n/g, ' ');
-        }
-        catch {
-            return '(unable to read)';
-        }
-    }
-    async buildStructurePreview(dir, pattern, maxDepth = 3, depth = 0) {
-        const name = path.basename(dir) || dir;
-        const node = { name, isDirectory: true };
-        if (depth >= maxDepth) {
-            return node;
-        }
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            const children = [];
-            let childCount = 0;
-            for (const entry of entries) {
-                if (entry.name.startsWith('.') && entry.name !== '.dino')
-                    continue;
-                if (entry.name === 'node_modules' || entry.name === 'dist')
-                    continue;
-                childCount++;
-                if (children.length < 10) { // Limit children shown
-                    if (entry.isDirectory()) {
-                        const fullPath = path.join(dir, entry.name);
-                        const childNode = await this.buildStructurePreview(fullPath, pattern, maxDepth, depth + 1);
-                        children.push(childNode);
-                    }
-                    else {
-                        children.push({ name: entry.name, isDirectory: false });
-                    }
-                }
-            }
-            node.childCount = childCount;
-            if (children.length > 0) {
-                node.children = children;
-            }
-        }
-        catch {
-            // Can't read directory
-        }
-        return node;
-    }
-    // ---------------------------------------------------------------------------
-    // Grep Operation
-    // ---------------------------------------------------------------------------
-    async grep(query, options = {}) {
-        const startTime = Date.now();
-        const tokensBefore = this.state.totalTokens;
-        this.state.operationCount++;
-        // Check feature flag
-        const enabled = await isFeatureEnabled('enableReplEnvironment', this.projectDir);
-        if (!enabled) {
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: 'REPL environment is disabled. Set enableReplEnvironment: true in .dino/config.json',
-            };
-        }
-        try {
-            const { ignoreCase = true, filesOnly = false, maxMatches = 50, includeLineNumbers = true, } = options;
-            const matches = [];
-            const filesWithMatches = new Set();
-            let totalMatches = 0;
-            let truncated = false;
-            // Search in loaded variables first
-            for (const [name, variable] of this.state.variables) {
-                const varMatches = this.searchInData(variable.data, query, ignoreCase);
-                for (const match of varMatches) {
-                    totalMatches++;
-                    filesWithMatches.add(name);
-                    if (matches.length < maxMatches) {
-                        matches.push({
-                            file: name,
-                            line: match.line,
-                            column: match.column,
-                            match: match.text,
-                            context: match.context,
-                        });
-                    }
-                    else {
-                        truncated = true;
-                    }
-                }
-            }
-            // Search in .dino files
-            const dinoDir = path.join(this.projectDir, '.dino');
-            try {
-                const files = await this.listFilesRecursive(dinoDir, undefined, 3);
-                for (const file of files) {
-                    if (matches.length >= maxMatches) {
-                        truncated = true;
-                        break;
-                    }
-                    try {
-                        const content = await fs.readFile(file, 'utf-8');
-                        const fileMatches = this.searchInText(content, query, ignoreCase, includeLineNumbers);
-                        for (const match of fileMatches) {
-                            totalMatches++;
-                            filesWithMatches.add(file);
-                            if (matches.length < maxMatches) {
-                                matches.push({
-                                    file: path.relative(this.projectDir, file),
-                                    line: match.line,
-                                    column: match.column,
-                                    match: match.text,
-                                    context: match.context,
-                                });
-                            }
-                            else {
-                                truncated = true;
-                                break;
-                            }
-                        }
-                    }
-                    catch {
-                        // Skip files we can't read
-                    }
-                }
-            }
-            catch {
-                // .dino directory might not exist
-            }
-            const result = {
-                pattern: query,
-                totalMatches,
-                filesWithMatches: filesWithMatches.size,
-                matches: filesOnly ? [] : matches,
-                truncated,
-            };
-            // Grep is mostly read-only, small token cost for results
-            const resultStr = JSON.stringify(result);
-            const tokensUsed = estimateTokens(resultStr);
-            this.addHistoryEntry('grep', tokensBefore, tokensBefore, true, `Grep found ${totalMatches} matches in ${filesWithMatches.size} files`);
-            return {
-                success: true,
-                data: result,
-                tokensUsed,
-                executionTimeMs: Date.now() - startTime,
-                warnings: truncated ? [`Results truncated at ${maxMatches} matches`] : undefined,
-            };
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.addHistoryEntry('grep', tokensBefore, tokensBefore, false, `Error: ${errorMsg}`);
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: errorMsg,
-            };
-        }
-    }
-    searchInData(data, query, ignoreCase) {
-        const results = [];
-        const text = JSON.stringify(data, null, 2);
-        return this.searchInText(text, query, ignoreCase, true);
-    }
-    searchInText(text, query, ignoreCase, includeLineNumbers) {
-        const results = [];
-        const lines = text.split('\n');
-        const regex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), ignoreCase ? 'gi' : 'g');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            let match;
-            while ((match = regex.exec(line)) !== null) {
-                const contextStart = Math.max(0, match.index - 20);
-                const contextEnd = Math.min(line.length, match.index + match[0].length + 20);
-                const context = line.substring(contextStart, contextEnd);
-                results.push({
-                    line: includeLineNumbers ? i + 1 : 0,
-                    column: match.index,
-                    text: match[0],
-                    context,
-                });
-            }
-        }
-        return results;
-    }
-    // ---------------------------------------------------------------------------
-    // Partition Operation
-    // ---------------------------------------------------------------------------
-    async partition(strategy) {
-        const startTime = Date.now();
-        const tokensBefore = this.state.totalTokens;
-        this.state.operationCount++;
-        // Check feature flag
-        const enabled = await isFeatureEnabled('enableReplEnvironment', this.projectDir);
-        if (!enabled) {
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: 'REPL environment is disabled. Set enableReplEnvironment: true in .dino/config.json',
-            };
-        }
-        try {
-            // Validate strategy
-            const validStrategies = ['by-directory', 'by-feature', 'by-dependency', 'by-time'];
-            if (!validStrategies.includes(strategy)) {
-                return {
-                    success: false,
-                    data: null,
-                    tokensUsed: 0,
-                    executionTimeMs: Date.now() - startTime,
-                    error: `Invalid strategy: ${strategy}. Valid strategies: ${validStrategies.join(', ')}`,
-                };
-            }
-            // Get files to partition
-            const srcDir = path.join(this.projectDir, 'src');
-            let files = [];
-            try {
-                files = await this.listFilesRecursive(srcDir, '*.ts', 5);
-            }
-            catch {
-                // No src directory
-            }
-            if (files.length === 0) {
-                return {
-                    success: true,
-                    data: { strategy, partitions: [], message: 'No files found to partition' },
-                    tokensUsed: 0,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            // Convert to relative paths
-            const relativePaths = files.map(f => path.relative(this.projectDir, f));
-            // Compute partitions
-            const result = await computePartitions(strategy, relativePaths, { maxPartitions: 10 });
-            const resultStr = JSON.stringify(result);
-            const tokensUsed = estimateTokens(resultStr);
-            this.addHistoryEntry('partition', tokensBefore, tokensBefore, true, `Partitioned ${files.length} files into ${result.partitions.length} groups`);
-            return {
-                success: result.success,
-                data: result,
-                tokensUsed,
-                executionTimeMs: Date.now() - startTime,
-                error: result.error,
-            };
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            this.addHistoryEntry('partition', tokensBefore, tokensBefore, false, `Error: ${errorMsg}`);
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: errorMsg,
-            };
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Variable Management
-    // ---------------------------------------------------------------------------
-    async loadVariable(variablePath, name) {
-        const startTime = Date.now();
-        const tokensBefore = this.state.totalTokens;
-        // Check feature flag
-        const enabled = await isFeatureEnabled('enableReplEnvironment', this.projectDir);
-        if (!enabled) {
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: 'REPL environment is disabled',
-            };
-        }
-        // Validate variable path
-        if (!VALID_VARIABLE_PATHS.includes(variablePath)) {
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: `Invalid variable path: ${variablePath}. Valid paths: ${VALID_VARIABLE_PATHS.join(', ')}`,
-            };
-        }
-        try {
-            const result = await loadContextVariable(variablePath, this.projectDir);
-            if (result.error) {
-                return {
-                    success: false,
-                    data: null,
-                    tokensUsed: 0,
-                    executionTimeMs: Date.now() - startTime,
-                    error: result.error || `Failed to load variable: ${variablePath}`,
-                };
-            }
-            const varName = name || variablePath.split('.').pop() || variablePath;
-            const dataStr = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
-            const tokenEstimate = estimateTokens(dataStr);
-            const variable = {
-                name: varName,
-                path: variablePath,
-                data: result.data,
-                loadedAt: Date.now(),
-                tokenEstimate,
-                source: 'loadVariable',
-            };
-            this.state.variables.set(varName, variable);
-            this.state.totalTokens += tokenEstimate;
-            return {
-                success: true,
-                data: { name: varName, path: variablePath, tokenEstimate },
-                tokensUsed: tokenEstimate,
-                executionTimeMs: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            return {
-                success: false,
-                data: null,
-                tokensUsed: 0,
-                executionTimeMs: Date.now() - startTime,
-                error: errorMsg,
-            };
-        }
-    }
-    unloadVariable(name) {
-        const variable = this.state.variables.get(name);
-        if (!variable) {
-            return false;
-        }
-        this.state.totalTokens -= variable.tokenEstimate;
-        this.state.variables.delete(name);
-        return true;
-    }
-    // ---------------------------------------------------------------------------
-    // Utility Methods
-    // ---------------------------------------------------------------------------
-    async executeWithTimeout(promise, timeoutMs) {
-        let timeoutId;
-        const timeoutPromise = new Promise((_, reject) => {
-            timeoutId = setTimeout(() => {
-                reject(new Error(`Operation timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-        });
-        try {
-            const result = await Promise.race([promise, timeoutPromise]);
-            clearTimeout(timeoutId);
-            return result;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            throw error;
-        }
-    }
-    truncateData(data, maxTokens) {
-        if (Array.isArray(data)) {
-            const items = [];
-            let tokens = 0;
-            for (const item of data) {
-                const itemStr = JSON.stringify(item);
-                const itemTokens = estimateTokens(itemStr);
-                if (tokens + itemTokens > maxTokens) {
-                    break;
-                }
-                items.push(item);
-                tokens += itemTokens;
-            }
-            return items;
-        }
-        if (typeof data === 'string') {
-            const maxChars = maxTokens * 4;
-            return data.substring(0, maxChars);
-        }
-        if (typeof data === 'object' && data !== null) {
-            const truncated = {};
-            let tokens = 0;
-            for (const [key, value] of Object.entries(data)) {
-                const entryStr = JSON.stringify({ [key]: value });
-                const entryTokens = estimateTokens(entryStr);
-                if (tokens + entryTokens > maxTokens) {
-                    break;
-                }
-                truncated[key] = value;
-                tokens += entryTokens;
-            }
-            return truncated;
-        }
-        return data;
-    }
-}
-// =============================================================================
-// Factory Function
-// =============================================================================
-/**
- * Create a new REPL environment instance
- */
-export function createREPLEnvironment(options = {}) {
-    return new REPLEnvironment(options);
-}
-// =============================================================================
-// Formatting
-// =============================================================================
-/**
- * Format REPL result for display
- */
-export function formatREPLResult(result) {
-    const lines = [];
-    if (result.success) {
-        lines.push('## REPL Result');
-        lines.push('');
-        lines.push(`**Success:** Yes`);
-        lines.push(`**Tokens Used:** ~${result.tokensUsed}`);
-        lines.push(`**Execution Time:** ${result.executionTimeMs}ms`);
-        if (result.warnings && result.warnings.length > 0) {
-            lines.push('');
-            lines.push('### Warnings');
-            for (const warning of result.warnings) {
-                lines.push(`- ${warning}`);
-            }
-        }
-        lines.push('');
-        lines.push('### Data');
-        lines.push('```json');
-        const dataStr = JSON.stringify(result.data, null, 2);
-        if (dataStr.length > 2000) {
-            lines.push(dataStr.substring(0, 2000) + '\n... (truncated)');
-        }
-        else {
-            lines.push(dataStr);
-        }
-        lines.push('```');
-    }
-    else {
-        lines.push('## REPL Error');
-        lines.push('');
-        lines.push(`**Error:** ${result.error}`);
-        lines.push(`**Execution Time:** ${result.executionTimeMs}ms`);
-    }
-    return lines.join('\n');
-}
-/**
- * Format REPL state summary
- */
-export function formatREPLState(state) {
-    const lines = [];
-    lines.push('## REPL State');
-    lines.push('');
-    lines.push(`**Variables Loaded:** ${state.variables.size}`);
-    lines.push(`**Total Tokens:** ~${state.totalTokens}`);
-    lines.push(`**Operations:** ${state.operationCount}`);
-    lines.push(`**Uptime:** ${Math.round((Date.now() - state.startedAt) / 1000)}s`);
-    if (state.variables.size > 0) {
-        lines.push('');
-        lines.push('### Loaded Variables');
-        for (const [name, variable] of state.variables) {
-            lines.push(`- **${name}** (${variable.path}): ~${variable.tokenEstimate} tokens`);
-        }
-    }
-    if (state.history.length > 0) {
-        lines.push('');
-        lines.push('### Recent Operations');
-        const recent = state.history.slice(-5);
-        for (const entry of recent) {
-            const status = entry.success ? 'OK' : 'FAIL';
-            lines.push(`- [${status}] ${entry.operation}: ${entry.summary}`);
-        }
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=repl-environment.js.map