erosolar-cli 1.5.2 → 1.5.4

package/dist/bin/ui/toolDisplayAdapter.js

@@ -0,0 +1,357 @@
+/**
+ * Tool Display Adapter - Integrates Claude Code style display with ShellUIAdapter
+ *
+ * Provides high-level interface for displaying tool executions with
+ * Claude Code's clean formatting.
+ */
+import { formatToolCall, formatToolResult, formatDiff, formatDiffSummary, formatThinking, formatDuration, } from './toolDisplay.js';
+import { theme } from './theme.js';
+export class ToolDisplayAdapter {
+    constructor(display) {
+        this.activeTools = new Map();
+        this.display = display;
+    }
+    /**
+     * Show tool call starting
+     */
+    showToolStart(call) {
+        this.activeTools.set(call.id, {
+            call,
+            startTime: Date.now(),
+        });
+        const display = {
+            name: call.name,
+            args: call.arguments ?? {},
+            timestamp: Date.now(),
+        };
+        const formatted = formatToolCall(display, { includePrefix: false });
+        // Claude Code style: show tool call with ⏺ prefix (handled by showAction)
+        this.display.showAction(formatted);
+    }
+    /**
+     * Show tool result
+     */
+    showToolResult(callId, output, status = 'success') {
+        const active = this.activeTools.get(callId);
+        const duration = active ? Date.now() - active.startTime : undefined;
+        // Analyze output to create summary
+        const summary = this.createResultSummary(active?.call.name ?? 'tool', output, status);
+        const lines = output.split('\n');
+        const nonEmptyLines = lines.filter(l => l.trim());
+        const result = {
+            summary,
+            fullOutput: output,
+            linesShown: Math.min(nonEmptyLines.length, 3),
+            totalLines: nonEmptyLines.length,
+            status,
+            duration,
+        };
+        const formatted = formatToolResult(result, { includePrefix: false });
+        // Claude Code style: show result with ⎿ prefix (using showSubAction)
+        // Add duration if available
+        if (duration !== undefined && duration > 100) {
+            const durationStr = formatDuration(duration);
+            this.display.showSubAction(`${formatted} ${theme.ui.muted(`(${durationStr})`)}`, status === 'success' ? 'success' : 'error');
+        }
+        else {
+            this.display.showSubAction(formatted, status === 'success' ? 'success' : 'error');
+        }
+        // Show preview of output if it's substantial
+        if (nonEmptyLines.length > 0 && this.shouldShowPreview(active?.call.name)) {
+            const preview = this.formatOutputPreview(output, active?.call.name, 4);
+            if (preview) {
+                // Show preview as continuation (more indented)
+                this.display.showSystemMessage(preview);
+            }
+        }
+        this.activeTools.delete(callId);
+    }
+    /**
+     * Determine if we should show output preview for this tool
+     */
+    shouldShowPreview(toolName) {
+        if (!toolName)
+            return false;
+        // Tools that should show previews
+        const showPreviewFor = new Set([
+            'Bash', 'bash', 'execute_bash',
+            'Grep', 'grep_search',
+            'Glob', 'list_files',
+        ]);
+        return showPreviewFor.has(toolName);
+    }
+    /**
+     * Format output preview with proper indentation
+     * Handles JSON, structured data, and plain text intelligently
+     */
+    formatOutputPreview(output, _toolName, maxLines) {
+        const lines = output.split('\n').filter(l => l.trim());
+        if (lines.length === 0)
+            return null;
+        // Try to detect and format JSON
+        const jsonFormatted = this.tryFormatJSON(output);
+        if (jsonFormatted) {
+            return jsonFormatted;
+        }
+        // Show fewer lines for long content
+        const previewLines = lines.slice(0, Math.min(maxLines, lines.length));
+        const remaining = lines.length - previewLines.length;
+        // Format with indentation (continuing from ⎿ symbol)
+        const formatted = previewLines.map(line => {
+            // Truncate very long lines
+            if (line.length > 100) {
+                return `  ${line.slice(0, 97)}...`;
+            }
+            return `  ${line}`;
+        });
+        // Add ellipsis if there are more lines
+        if (remaining > 0) {
+            formatted.push(`  ${theme.ui.muted(`… +${remaining} line${remaining === 1 ? '' : 's'} ${theme.ui.muted('(ctrl+o to expand)')}`)}`.trim());
+        }
+        return formatted.join('\n');
+    }
+    /**
+     * Try to parse and format output as JSON
+     */
+    tryFormatJSON(output) {
+        const trimmed = output.trim();
+        if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            const formatted = JSON.stringify(parsed, null, 2);
+            // Add basic syntax highlighting
+            const highlighted = formatted
+                .split('\n')
+                .slice(0, 10) // Limit to 10 lines for preview
+                .map(line => {
+                // Color keys
+                line = line.replace(/"([^"]+)":/g, (_, key) => `${theme.info(`"${key}"`)}: `);
+                // Color string values
+                line = line.replace(/: "([^"]*)"/g, (_, value) => `: ${theme.success(`"${value}"`)}`);
+                // Color numbers
+                line = line.replace(/: (\d+\.?\d*)/g, (_, num) => `: ${theme.warning(num)}`);
+                // Color booleans/null
+                line = line.replace(/: (true|false|null)/g, (_, bool) => `: ${theme.secondary(bool)}`);
+                return `  ${line}`;
+            })
+                .join('\n');
+            const totalLines = formatted.split('\n').length;
+            if (totalLines > 10) {
+                return `${highlighted}\n  ${theme.ui.muted(`… +${totalLines - 10} lines (ctrl+o to expand)`)}`;
+            }
+            return highlighted;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Show tool error
+     */
+    showToolError(callId, error) {
+        this.showToolResult(callId, error, 'error');
+    }
+    /**
+     * Show diff output (for Edit/Write tools)
+     */
+    showDiff(file, additions, removals, diff) {
+        // Show summary first (Claude Code style)
+        const summary = formatDiffSummary(file, additions, removals);
+        this.display.showSubAction(summary);
+        // Show formatted diff
+        const formatted = formatDiff(diff);
+        this.display.showSystemMessage(formatted);
+    }
+    /**
+     * Show thinking indicator
+     */
+    showThinking(durationMs) {
+        const formatted = formatThinking(durationMs, false);
+        this.display.showAction(formatted);
+    }
+    /**
+     * Create a concise summary from tool output
+     * Parses output intelligently to extract meaningful information
+     */
+    createResultSummary(toolName, output, status) {
+        if (status === 'error') {
+            return 'Error';
+        }
+        if (!toolName) {
+            return 'Completed';
+        }
+        const lines = output.split('\n');
+        const nonEmptyLines = lines.filter(l => l.trim());
+        // Tool-specific summaries
+        switch (toolName) {
+            case 'Read':
+            case 'read_file': {
+                const lineCount = nonEmptyLines.length;
+                return `Read ${lineCount} line${lineCount === 1 ? '' : 's'}`;
+            }
+            case 'Write':
+            case 'write_file':
+                return 'Wrote file';
+            case 'Edit':
+            case 'edit_file': {
+                // Try to extract addition/removal counts from output
+                const addMatch = output.match(/(\d+) addition/);
+                const remMatch = output.match(/(\d+) removal/);
+                if (addMatch || remMatch) {
+                    const parts = ['Updated'];
+                    if (addMatch)
+                        parts.push(`${addMatch[1]} addition${addMatch[1] === '1' ? '' : 's'}`);
+                    if (remMatch) {
+                        if (addMatch)
+                            parts.push('and');
+                        parts.push(`${remMatch[1]} removal${remMatch[1] === '1' ? '' : 's'}`);
+                    }
+                    return parts.join(' ');
+                }
+                return 'Updated file';
+            }
+            case 'Glob':
+            case 'list_files': {
+                const fileCount = nonEmptyLines.length;
+                if (fileCount === 0) {
+                    return 'No files found';
+                }
+                return `Found ${fileCount} file${fileCount === 1 ? '' : 's'}`;
+            }
+            case 'Grep':
+            case 'grep_search': {
+                // Check output mode from result
+                if (output.includes(':')) {
+                    // Content mode - count lines
+                    const matchCount = nonEmptyLines.length;
+                    return `Found ${matchCount} line${matchCount === 1 ? '' : 's'}`;
+                }
+                else {
+                    // Files mode - count files
+                    const fileCount = nonEmptyLines.length;
+                    return `Found ${fileCount} file${fileCount === 1 ? '' : 's'}`;
+                }
+            }
+            case 'Bash':
+            case 'bash':
+            case 'execute_bash': {
+                // Try to parse command output for meaningful summary
+                if (nonEmptyLines.length === 0) {
+                    return 'Completed';
+                }
+                // Check for common command patterns
+                const firstLine = nonEmptyLines[0];
+                if (!firstLine) {
+                    return 'Completed';
+                }
+                // Git commands
+                if (firstLine.includes('On branch')) {
+                    return 'Git status';
+                }
+                if (firstLine.includes('commit') || firstLine.includes('Author:')) {
+                    return 'Git log';
+                }
+                // Build/test commands
+                if (output.includes('error TS') || output.includes('error:')) {
+                    const errorCount = (output.match(/error/gi) || []).length;
+                    return `${errorCount} error${errorCount === 1 ? '' : 's'}`;
+                }
+                if (output.includes('passing') || output.includes('✓')) {
+                    return 'Tests passed';
+                }
+                // Default to first line or "Completed"
+                if (firstLine.length <= 40) {
+                    return firstLine;
+                }
+                return 'Completed';
+            }
+            case 'WebFetch':
+            case 'web_fetch':
+                return 'Content fetched';
+            case 'WebSearch':
+            case 'web_search': {
+                // Count search results
+                const resultMatch = output.match(/(\d+) results?/i);
+                if (resultMatch) {
+                    return `Found ${resultMatch[1]} results`;
+                }
+                return 'Results retrieved';
+            }
+            case 'Task':
+            case 'SubAgent': {
+                // For task/subagent, try to extract completion message
+                const lastLine = nonEmptyLines[nonEmptyLines.length - 1];
+                if (lastLine && lastLine.length <= 50) {
+                    return lastLine;
+                }
+                return 'Task completed';
+            }
+            default:
+                // Generic fallback - try to use first meaningful line
+                if (nonEmptyLines.length > 0) {
+                    const firstLine = nonEmptyLines[0];
+                    if (firstLine && firstLine.length <= 40) {
+                        return firstLine;
+                    }
+                }
+                return 'Completed';
+        }
+    }
+    /**
+     * Parse diff output into structured format
+     */
+    static parseDiffOutput(diffText) {
+        const lines = [];
+        let additions = 0;
+        let removals = 0;
+        const diffLines = diffText.split('\n');
+        let currentLineNum = 0;
+        for (const line of diffLines) {
+            // Check for line number prefix (e.g., "   42→" or "   42 ")
+            const lineNumMatch = line.match(/^\s*(\d+)[→\s]/);
+            if (lineNumMatch && lineNumMatch[1]) {
+                currentLineNum = parseInt(lineNumMatch[1], 10);
+            }
+            // Detect diff type
+            if (line.trim().startsWith('+') && !line.startsWith('+++')) {
+                additions++;
+                lines.push({
+                    lineNumber: currentLineNum,
+                    type: 'add',
+                    content: line.replace(/^\s*\d+[→\s]\s*\+\s*/, ''),
+                });
+            }
+            else if (line.trim().startsWith('-') && !line.startsWith('---')) {
+                removals++;
+                lines.push({
+                    lineNumber: currentLineNum,
+                    type: 'remove',
+                    content: line.replace(/^\s*\d+[→\s]\s*-\s*/, ''),
+                });
+            }
+            else if (line.trim().startsWith('@@')) {
+                lines.push({
+                    type: 'info',
+                    content: line,
+                });
+            }
+            else if (lineNumMatch) {
+                lines.push({
+                    lineNumber: currentLineNum,
+                    type: 'context',
+                    content: line.replace(/^\s*\d+[→\s]\s*/, ''),
+                });
+            }
+        }
+        return { additions, removals, lines };
+    }
+}
+/**
+ * Enhanced display for tool executions
+ * Wraps Display with Claude Code style formatting
+ */
+export function createToolDisplayAdapter(display) {
+    return new ToolDisplayAdapter(display);
+}

package/dist/bin/workspace.js

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { safeWorkspaceContext, validateWorkspaceOptions } from './workspace.validator.js';
+const PRIORITY_DOCS = ['README.md']; // Removed package.json to save context
+const IGNORED_DIRS = new Set([
+    '.git', 'node_modules', 'dist', '.erosolar', 'build', 'coverage', '.next', 'out',
+    '__pycache__', '.pytest_cache', '.mypy_cache', 'venv', '.venv', 'env',
+    'target', 'bin', 'obj', '.idea', '.vscode', '.DS_Store'
+]);
+const DEFAULT_TREE_DEPTH = 1; // Reduced from 2 to 1 for critical context savings
+const DEFAULT_MAX_ENTRIES = 30; // Further reduced from 50 to 30 - emergency reduction
+const DEFAULT_DOC_LIMIT = 200; // Further reduced from 300 to 200 - emergency reduction
+export function resolveWorkspaceCaptureOptions(env = process.env) {
+    return {
+        treeDepth: parsePositiveInt(env['EROSOLAR_CONTEXT_TREE_DEPTH']),
+        maxEntries: parsePositiveInt(env['EROSOLAR_CONTEXT_MAX_ENTRIES']),
+        docExcerptLimit: parsePositiveInt(env['EROSOLAR_CONTEXT_DOC_LIMIT']),
+    };
+}
+export function buildWorkspaceContext(root, options = {}) {
+    // CRITICAL: Validate options BEFORE building context
+    const optionsValidation = validateWorkspaceOptions(options);
+    if (!optionsValidation.valid) {
+        console.error('[Workspace Context] Invalid options:', optionsValidation.errors);
+        throw new Error(`Invalid workspace options: ${optionsValidation.errors.join(', ')}`);
+    }
+    // Log warnings if any
+    if (optionsValidation.warnings.length > 0) {
+        console.warn('[Workspace Context] Warnings:', optionsValidation.warnings);
+    }
+    const treeDepth = options.treeDepth ?? DEFAULT_TREE_DEPTH;
+    const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const docLimit = options.docExcerptLimit ?? DEFAULT_DOC_LIMIT;
+    try {
+        const treeLines = formatFileTree(root, treeDepth, maxEntries);
+        const docSnippets = capturePriorityDocs(root, docLimit);
+        // REMOVED: Rulebook duplication - rulebooks are already in system prompt
+        const sections = [`cwd: ${root}`, 'files:', ...treeLines];
+        if (docSnippets.length) {
+            sections.push(docSnippets.join('\n\n'));
+        }
+        // REMOVED: Rulebook duplication
+        // if (rulebooks.length) {
+        //   sections.push(rulebooks.join('\n\n'));
+        // }
+        const rawContent = sections.filter((section) => section.trim().length > 0).join('\n');
+        // CRITICAL: Validate and enforce limits on final output
+        const safe = safeWorkspaceContext(rawContent, {
+            truncate: true, // Auto-truncate if too large
+            throwOnError: false // Don't throw, just truncate
+        });
+        // Log stats for monitoring
+        if (process.env['DEBUG_CONTEXT']) {
+            console.log('[Workspace Context] Stats:', safe.stats);
+        }
+        return safe.content;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Workspace context unavailable (${message}).`;
+    }
+}
+function capturePriorityDocs(root, docLimit) {
+    return PRIORITY_DOCS.filter((name) => existsSync(join(root, name))).map((name) => {
+        try {
+            const content = readFileSync(join(root, name), 'utf8');
+            // Safety: Hard limit to prevent context explosion
+            const safeLimit = Math.min(docLimit, 300);
+            const snippet = content.length > safeLimit ? `${content.slice(0, safeLimit)}\n...` : content;
+            return `--- ${name} ---\n${snippet.trim()}`;
+        }
+        catch {
+            return `--- ${name} ---\n[Could not read file]`;
+        }
+    });
+}
+function formatFileTree(root, maxDepth, maxEntries) {
+    const lines = [];
+    const walk = (dir, depth, prefix) => {
+        if (depth > maxDepth || lines.length >= maxEntries) {
+            return;
+        }
+        const entries = readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => !IGNORED_DIRS.has(entry.name))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (lines.length >= maxEntries) {
+                break;
+            }
+            const isDir = entry.isDirectory();
+            lines.push(`${prefix}${entry.name}${isDir ? '/' : ''}`);
+            if (isDir && depth < maxDepth) {
+                walk(join(dir, entry.name), depth + 1, `${prefix}  `);
+            }
+        }
+    };
+    walk(root, 0, '');
+    return lines;
+}
+function parsePositiveInt(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}

package/dist/bin/workspace.validator.js

@@ -0,0 +1,213 @@
+/**
+ * Workspace Context Validator - Enforces strict safety limits
+ *
+ * CRITICAL: Prevents context explosion by validating all workspace context
+ * before it's sent to the LLM. Multiple safety layers ensure we never
+ * exceed token limits.
+ */
+import { ContextOverflowError, ResourceLimitError } from './core/errors/errorTypes.js';
+// ABSOLUTE MAXIMUM LIMITS - Never exceed these under any circumstances
+const ABSOLUTE_MAX_CHARS = 5000; // ~1,250 tokens (4 chars per token)
+const ABSOLUTE_MAX_LINES = 100; // Maximum lines in any context
+const ABSOLUTE_MAX_FILE_ENTRIES = 50; // Maximum files in tree
+const ABSOLUTE_MAX_DOC_CHARS = 300; // Maximum chars per priority doc
+const WARNING_THRESHOLD = 0.7; // Warn at 70% of max
+/**
+ * Estimate token count (rough: 1 token ≈ 4 characters)
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Validate workspace context options BEFORE building context
+ */
+export function validateWorkspaceOptions(options) {
+    const errors = [];
+    const warnings = [];
+    // Validate tree depth
+    if (options.treeDepth !== undefined) {
+        if (options.treeDepth < 0) {
+            errors.push('treeDepth cannot be negative');
+        }
+        if (options.treeDepth > 2) {
+            errors.push(`treeDepth ${options.treeDepth} exceeds maximum of 2`);
+        }
+        if (options.treeDepth > 1) {
+            warnings.push('treeDepth > 1 can significantly increase context size');
+        }
+    }
+    // Validate max entries
+    if (options.maxEntries !== undefined) {
+        if (options.maxEntries < 0) {
+            errors.push('maxEntries cannot be negative');
+        }
+        if (options.maxEntries > ABSOLUTE_MAX_FILE_ENTRIES) {
+            errors.push(`maxEntries ${options.maxEntries} exceeds maximum of ${ABSOLUTE_MAX_FILE_ENTRIES}`);
+        }
+        if (options.maxEntries > 40) {
+            warnings.push('maxEntries > 40 may use significant context');
+        }
+    }
+    // Validate doc excerpt limit
+    if (options.docExcerptLimit !== undefined) {
+        if (options.docExcerptLimit < 0) {
+            errors.push('docExcerptLimit cannot be negative');
+        }
+        if (options.docExcerptLimit > ABSOLUTE_MAX_DOC_CHARS) {
+            errors.push(`docExcerptLimit ${options.docExcerptLimit} exceeds maximum of ${ABSOLUTE_MAX_DOC_CHARS}`);
+        }
+        if (options.docExcerptLimit > 250) {
+            warnings.push('docExcerptLimit > 250 may use significant context');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        stats: {
+            totalChars: 0,
+            totalLines: 0,
+            estimatedTokens: 0,
+            fileEntries: options.maxEntries ?? 0,
+            docChars: options.docExcerptLimit ?? 0,
+        },
+    };
+}
+/**
+ * Validate workspace context AFTER building - CRITICAL SAFETY CHECK
+ * This is the final line of defense against context explosion
+ */
+export function validateWorkspaceContext(content) {
+    const errors = [];
+    const warnings = [];
+    // Count basic metrics
+    const totalChars = content.length;
+    const lines = content.split('\n');
+    const totalLines = lines.length;
+    const estimatedTokens = estimateTokens(content);
+    // Count file entries (lines that look like file paths)
+    const fileEntries = lines.filter(line => line.trim() && !line.startsWith('---') && !line.startsWith('cwd:')).length;
+    // Count chars in priority docs section
+    const docMatch = content.match(/--- .* ---[\s\S]*?(?=\n\n|$)/g);
+    const docChars = docMatch ? docMatch.join('').length : 0;
+    const stats = {
+        totalChars,
+        totalLines,
+        estimatedTokens,
+        fileEntries,
+        docChars,
+    };
+    // CRITICAL: Check absolute maximum character limit
+    if (totalChars > ABSOLUTE_MAX_CHARS) {
+        const error = new ContextOverflowError(totalChars, ABSOLUTE_MAX_CHARS, 'chars', true);
+        errors.push(`Context exceeds ABSOLUTE maximum: ${error.message}`);
+    }
+    // CRITICAL: Check absolute maximum line limit
+    if (totalLines > ABSOLUTE_MAX_LINES) {
+        const error = new ContextOverflowError(totalLines, ABSOLUTE_MAX_LINES, 'lines', true);
+        errors.push(`Context exceeds ABSOLUTE maximum: ${error.message}`);
+    }
+    // CRITICAL: Check absolute maximum file entries
+    if (fileEntries > ABSOLUTE_MAX_FILE_ENTRIES) {
+        const error = new ResourceLimitError('file entries', fileEntries, ABSOLUTE_MAX_FILE_ENTRIES, false);
+        errors.push(`Context exceeds ABSOLUTE maximum: ${error.message}`);
+    }
+    // WARNING: Approaching limits
+    if (totalChars > ABSOLUTE_MAX_CHARS * WARNING_THRESHOLD) {
+        warnings.push(`Context size ${totalChars} chars is ${Math.round(totalChars / ABSOLUTE_MAX_CHARS * 100)}% of maximum. ` +
+            `Consider reducing treeDepth, maxEntries, or docExcerptLimit.`);
+    }
+    if (estimatedTokens > 1000) {
+        warnings.push(`Estimated ${estimatedTokens} tokens in workspace context. This is high and may impact performance.`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        stats,
+    };
+}
+/**
+ * Safe truncation - if content exceeds limits, truncate intelligently
+ */
+export function truncateWorkspaceContext(content) {
+    const validation = validateWorkspaceContext(content);
+    // If valid, return as-is
+    if (validation.valid) {
+        return {
+            content,
+            stats: validation.stats,
+        };
+    }
+    // CRITICAL: Content exceeds limits, must truncate
+    const lines = content.split('\n');
+    const truncatedLines = [];
+    let charCount = 0;
+    // Keep up to absolute maximums
+    for (const line of lines) {
+        if (truncatedLines.length >= ABSOLUTE_MAX_LINES) {
+            break;
+        }
+        if (charCount + line.length > ABSOLUTE_MAX_CHARS) {
+            break;
+        }
+        truncatedLines.push(line);
+        charCount += line.length + 1; // +1 for newline
+    }
+    // Add truncation notice
+    if (truncatedLines.length < lines.length) {
+        truncatedLines.push('');
+        truncatedLines.push('[Workspace context truncated to prevent context overflow]');
+        truncatedLines.push(`[Showing ${truncatedLines.length} of ${lines.length} lines]`);
+    }
+    const truncatedContent = truncatedLines.join('\n');
+    const stats = validateWorkspaceContext(truncatedContent).stats;
+    return {
+        content: truncatedContent,
+        stats,
+    };
+}
+/**
+ * Validate and enforce limits in a single call - RECOMMENDED USAGE
+ */
+export function safeWorkspaceContext(content, options) {
+    const { truncate = true, throwOnError = false } = options ?? {};
+    if (!content) {
+        return {
+            content: '',
+            stats: {
+                totalChars: 0,
+                totalLines: 0,
+                estimatedTokens: 0,
+                fileEntries: 0,
+                docChars: 0,
+            },
+        };
+    }
+    const validation = validateWorkspaceContext(content);
+    // Log warnings to console
+    if (validation.warnings.length > 0) {
+        console.warn('[Workspace Context Validator] Warnings:');
+        for (const warning of validation.warnings) {
+            console.warn(`  - ${warning}`);
+        }
+    }
+    // Handle errors
+    if (!validation.valid) {
+        console.error('[Workspace Context Validator] CRITICAL ERRORS:');
+        for (const error of validation.errors) {
+            console.error(`  - ${error}`);
+        }
+        if (throwOnError) {
+            throw new Error(`Workspace context validation failed:\n${validation.errors.join('\n')}`);
+        }
+        if (truncate) {
+            console.warn('[Workspace Context Validator] Auto-truncating to safe limits...');
+            return truncateWorkspaceContext(content);
+        }
+    }
+    return {
+        content,
+        stats: validation.stats,
+    };
+}

package/dist/capabilities/cloudCapability.d.ts

@@ -0,0 +1,13 @@
+import type { CapabilityContribution, CapabilityContext, CapabilityModule } from '../runtime/agentHost.js';
+export interface CloudCapabilityOptions {
+    workingDir?: string;
+    id?: string;
+    description?: string;
+}
+export declare class CloudCapabilityModule implements CapabilityModule {
+    readonly id = "capability.cloud";
+    private readonly options;
+    constructor(options?: CloudCapabilityOptions);
+    create(context: CapabilityContext): Promise<CapabilityContribution>;
+}
+//# sourceMappingURL=cloudCapability.d.ts.map

package/dist/capabilities/cloudCapability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudCapability.d.ts","sourceRoot":"","sources":["../../src/capabilities/cloudCapability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3G,MAAM,WAAW,sBAAsB;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,qBAAsB,YAAW,gBAAgB;IAC5D,QAAQ,CAAC,EAAE,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;gBAErC,OAAO,GAAE,sBAA2B;IAI1C,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,sBAAsB,CAAC;CA8B1E"}