erosolar-cli 1.7.414 → 1.7.415

package/dist/core/toolValidation.js

@@ -0,0 +1,282 @@
+/**
+ * Comprehensive Tool Validation System
+ *
+ * Provides proactive validation for AI tool usage with:
+ * - Pre-flight validation before tool execution
+ * - Real-time AI flow guidance
+ * - Pattern-based anti-pattern detection
+ * - Recovery suggestions for common failures
+ */
+import { analyzeBashFlow } from './bashCommandGuidance.js';
+/**
+ * Comprehensive tool validator
+ */
+export class ToolValidator {
+    patterns = [
+        {
+            pattern: 'edit_without_read',
+            description: 'Attempting Edit tool without first reading the file',
+            guidance: 'ALWAYS use Read tool before Edit tool to get exact text including whitespace and indentation',
+            examples: [
+                'Edit tool called without preceding Read tool',
+                'old_string contains guessed content instead of exact file content'
+            ]
+        },
+        {
+            pattern: 'broad_search_pattern',
+            description: 'Using overly broad search patterns that may cause context overflow',
+            guidance: 'Use specific search patterns like "**/*.ts" or "src/**/*.js" instead of "*" or "."',
+            examples: [
+                'Glob(".") or Glob("*") without head_limit',
+                'Search patterns that could return thousands of files'
+            ]
+        },
+        {
+            pattern: 'redundant_git_operations',
+            description: 'Running multiple git status calls or inefficient git command chains',
+            guidance: 'Use single combined commands: "git add -A && git commit -m msg && git push"',
+            examples: [
+                'git status → git add → git status → git commit → git push',
+                'Multiple git status calls in sequence'
+            ]
+        },
+        {
+            pattern: 'incomplete_npm_publish',
+            description: 'npm publish detected without confirming release prerequisites',
+            guidance: 'Ensure auth, version bump, build/tests, publish, and git push follow the project release process; automation (npm_publish) is preferred but not required',
+            examples: [
+                'Running npm publish before bumping version',
+                'Publishing without build/test steps required by the project'
+            ]
+        },
+        {
+            pattern: 'sequential_file_reads',
+            description: 'Reading files sequentially when parallel execution is possible',
+            guidance: 'Use parallel tool calls for independent file reads to improve performance',
+            examples: [
+                'Multiple Read calls in separate tool calls',
+                'Sequential file operations that could be parallelized'
+            ]
+        },
+        {
+            pattern: 'validation_after_each_edit',
+            description: 'Running validation after each individual edit',
+            guidance: 'Complete ALL edits first, run ONE validation at the end only if needed',
+            examples: [
+                'Running type-check after each file edit',
+                'Running build/test after every small change'
+            ]
+        }
+    ];
+    /**
+     * Validate tool usage before execution
+     */
+    validateToolUsage(tool, context) {
+        const warnings = [];
+        const suggestions = [];
+        const criticalErrors = [];
+        // Tool-specific validation
+        this.validateToolSpecific(tool, context, warnings, suggestions, criticalErrors);
+        // AI flow pattern validation
+        this.validateAIFlowPatterns(tool, context, warnings, suggestions);
+        // Performance optimization validation
+        this.validatePerformance(tool, context, warnings, suggestions);
+        return {
+            valid: criticalErrors.length === 0,
+            warnings,
+            suggestions,
+            criticalErrors
+        };
+    }
+    /**
+     * Validate tool-specific patterns
+     */
+    validateToolSpecific(tool, context, warnings, suggestions, criticalErrors) {
+        switch (tool.name) {
+            case 'Edit':
+                this.validateEditTool(tool, context, warnings, criticalErrors);
+                break;
+            case 'Glob':
+            case 'Grep':
+                this.validateSearchTools(tool, context, warnings, suggestions);
+                break;
+            case 'execute_bash':
+                this.validateBashCommands(tool, context, warnings, suggestions);
+                break;
+        }
+    }
+    /**
+     * Validate Edit tool usage
+     */
+    validateEditTool(tool, context, warnings, criticalErrors) {
+        const params = tool.parameters;
+        // Check for placeholder patterns in old_string
+        if (params.old_string && this.containsPlaceholderPattern(params.old_string)) {
+            warnings.push({
+                code: 'EDIT_PLACEHOLDER_DETECTED',
+                message: 'Edit tool old_string contains placeholder patterns',
+                severity: 'high',
+                suggestion: 'Use Read tool first to get exact file content instead of guessing'
+            });
+        }
+        // Check for long single lines (likely guessed content)
+        if (params.old_string && this.isLongSingleLine(params.old_string)) {
+            warnings.push({
+                code: 'EDIT_LONG_SINGLE_LINE',
+                message: 'Edit tool old_string is a long single line (likely guessed content)',
+                severity: 'medium',
+                suggestion: 'Read the file first to get exact multi-line content'
+            });
+        }
+        // Check for indentation mismatches
+        if (params.old_string && params.new_string && this.hasIndentationMismatch(params.old_string, params.new_string)) {
+            warnings.push({
+                code: 'EDIT_INDENTATION_MISMATCH',
+                message: 'Edit tool old_string and new_string have indentation mismatches',
+                severity: 'high',
+                suggestion: 'Ensure exact whitespace matching between old and new strings'
+            });
+        }
+    }
+    /**
+     * Validate search tools (Glob, Grep)
+     */
+    validateSearchTools(tool, context, warnings, suggestions) {
+        const params = tool.parameters;
+        // Check for overly broad patterns
+        if (params.pattern && this.isOverlyBroadPattern(params.pattern)) {
+            warnings.push({
+                code: 'SEARCH_OVERLY_BROAD',
+                message: `Search pattern "${params.pattern}" is overly broad`,
+                severity: 'medium',
+                suggestion: 'Use specific patterns like "**/*.ts" or add head_limit parameter'
+            });
+        }
+        // Suggest head_limit for broad patterns
+        if (params.pattern && this.isBroadPattern(params.pattern) && !params.head_limit) {
+            suggestions.push({
+                code: 'SEARCH_SUGGEST_HEAD_LIMIT',
+                message: 'Broad search pattern detected without head_limit',
+                action: 'Add head_limit parameter to prevent context overflow'
+            });
+        }
+    }
+    /**
+     * Validate bash commands
+     */
+    validateBashCommands(tool, context, warnings, suggestions) {
+        const params = tool.parameters;
+        if (!params.command)
+            return;
+        const flowWarnings = analyzeBashFlow(params.command);
+        for (const flow of flowWarnings) {
+            warnings.push({
+                code: flow.code,
+                message: flow.message,
+                severity: this.mapFlowSeverity(flow.severity),
+                suggestion: flow.suggestion,
+            });
+            if (flow.suggestion) {
+                suggestions.push({
+                    code: flow.code,
+                    message: flow.message,
+                    action: flow.suggestion,
+                });
+            }
+        }
+    }
+    /**
+     * Validate AI flow patterns
+     */
+    validateAIFlowPatterns(tool, context, warnings, suggestions) {
+        // Check for sequential file reads
+        if (tool.name === 'read_file' && context.workspaceContext?.recentOperations) {
+            const recentReads = context.workspaceContext.recentOperations
+                .filter(op => op === 'read_file')
+                .length;
+            if (recentReads > 2) {
+                suggestions.push({
+                    code: 'PARALLEL_READ_SUGGESTION',
+                    message: 'Multiple sequential file reads detected',
+                    action: 'Use parallel tool calls (e.g., read_files) for independent file reads to improve performance'
+                });
+            }
+        }
+    }
+    /**
+     * Validate performance optimizations
+     */
+    validatePerformance(tool, context, warnings, suggestions) {
+        // Add performance optimization suggestions
+        if (tool.name === 'execute_bash' && context.workspaceContext?.recentOperations) {
+            const recentValidations = context.workspaceContext.recentOperations
+                .filter(op => op.includes('validate') || op.includes('test') || op.includes('build'))
+                .length;
+            if (recentValidations > 1) {
+                warnings.push({
+                    code: 'EXCESSIVE_VALIDATION',
+                    message: 'Multiple validation operations detected',
+                    severity: 'low',
+                    suggestion: 'Complete ALL edits first, run ONE validation at the end only if needed'
+                });
+            }
+        }
+    }
+    // Helper methods
+    containsPlaceholderPattern(text) {
+        const patterns = [
+            /\.\.\./,
+            /\[.*\]/,
+            /\/\/.*\.\.\./,
+            /TODO/,
+            /FIXME/
+        ];
+        return patterns.some(pattern => pattern.test(text));
+    }
+    isLongSingleLine(text) {
+        const lines = text.split('\n');
+        return lines.length === 1 && text.length > 100;
+    }
+    hasIndentationMismatch(oldString, newString) {
+        const oldIndent = this.detectIndentation(oldString);
+        const newIndent = this.detectIndentation(newString);
+        return oldIndent !== newIndent;
+    }
+    detectIndentation(text) {
+        const firstLine = text.split('\n')[0] || '';
+        const match = firstLine.match(/^(\s+)/);
+        return match?.[1] ?? '';
+    }
+    isOverlyBroadPattern(pattern) {
+        const broadPatterns = ['.', '*', '**'];
+        return broadPatterns.includes(pattern);
+    }
+    isBroadPattern(pattern) {
+        return pattern.includes('*') && !pattern.includes('.');
+    }
+    mapFlowSeverity(severity) {
+        switch (severity) {
+            case 'critical':
+                return 'high';
+            case 'info':
+                return 'low';
+            default:
+                return 'medium';
+        }
+    }
+    /**
+     * Get AI flow guidance for a specific pattern
+     */
+    getAIFlowGuidance(patternId) {
+        return this.patterns.find(p => p.pattern === patternId);
+    }
+    /**
+     * Get all AI flow patterns
+     */
+    getAllAIFlowPatterns() {
+        return [...this.patterns];
+    }
+}
+// Global tool validator instance
+export const globalToolValidator = new ToolValidator();
+//# sourceMappingURL=toolValidation.js.map

package/dist/core/toolValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolValidation.js","sourceRoot":"","sources":["../../src/core/toolValidation.ts"],"names":[],"mappings":"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"}

package/dist/shell/systemPrompt.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderToolDefinition } from '../core/types.js';
+export declare function buildInteractiveSystemPrompt(basePrompt: string, profileLabel: string, tools: ProviderToolDefinition[], workspaceDir?: string): string;
+//# sourceMappingURL=systemPrompt.d.ts.map

package/dist/shell/systemPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemPrompt.d.ts","sourceRoot":"","sources":["../../src/shell/systemPrompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE/D,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,sBAAsB,EAAE,EAC/B,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CA8DR"}

package/dist/shell/systemPrompt.js

@@ -0,0 +1,81 @@
+export function buildInteractiveSystemPrompt(basePrompt, profileLabel, tools, workspaceDir) {
+    const name = profileLabel || 'Active Agent';
+    const toolSummary = formatToolSummary(tools, { maxDescriptionLength: 80 });
+    const workspace = workspaceDir || process.cwd();
+    const identityBlock = `
+CRITICAL IDENTITY: You ARE ${name}, an autonomous coding agent running INSIDE the erosolar-cli tool.
+You have FULL ACCESS to the workspace at: ${workspace}
+You are NOT a chatbot - you are an agent with tools. When users ask you to modify code, UI, or features, you CAN and MUST do so using your tools.
+The erosolar-cli IS your codebase. When users ask to change "the UI" or "this tool", they mean this workspace.
+`;
+    const capabilityLines = [
+        '✓ Full file system read/write access',
+        '✓ Bash command execution (including git commands)',
+        '✓ Git operations: status, diff, add, commit, push, branch management',
+        '✓ Advanced code search and analysis',
+        '✓ Workspace snapshot is guaranteed and immutable',
+        '✓ Tool usage is narrated to the operator in real time',
+    ];
+    const behaviorGuidelines = [
+        'AMBIGUOUS REQUESTS: If user input is vague, single-word, or could mean multiple things (e.g., "typing", "fix it", "help", "update"), ASK for clarification FIRST before doing any exploration. Do NOT guess. Example response: "I can help with that. Could you clarify what you mean by [X]? For example: [option A], [option B], or [option C]?"',
+        'CLAUDE CODE PACE: Move fast in tight read/edit/test loops. After each tool result, immediately decide the next action; avoid long monologues.',
+        'RAPID HYPOTHESIS TESTING: For bugs, list 2–3 likely root causes ordered by speed to check. Try the fastest, pivot quickly if evidence does not support it.',
+        'SOLUTION FORKING: For complex changes, note 2–3 viable approaches, pick the simplest that can ship now, and be ready to switch if blockers appear.',
+        'Keep responses CONCISE - avoid lengthy explanations, bullet lists, and markdown headers unless explicitly asked',
+        'Execute continuously until complete: analyze → plan → implement → report',
+        'Use README, package.json, and workspace context as evidence',
+        'Read before editing; re-read after to confirm',
+        'VALIDATION: Do NOT run type-check, build, test, health-check, lint, or quality-gate after each tool. Complete ALL edits first, run ONE validation at the end only if needed',
+        'GIT EFFICIENCY: Do NOT run redundant git commands. Use single combined commands: "git add -A && git commit -m msg && git push" instead of separate status/add/status/commit/push calls',
+        'NPM PUBLISH: For npm releases, ensure the full flow (auth, version bump, build/tests, publish, git push) using npm_publish or project-specific steps—avoid rigid command chains',
+        'PYPI PUBLISH: When user says "push to pypi", "publish to pypi", "release python package", or similar, use the python_publish tool',
+        'CARGO PUBLISH: When user says "push to crates.io", "publish crate", "release rust package", or similar, use the cargo_publish tool',
+        'TOOL USAGE: ALWAYS use tools to complete tasks. Do NOT describe what you would do - actually DO it by calling tools. If you need to read a file, call read_file. If you need to edit, call Edit. Never output "I will..." or "Let me..." without immediately following with a tool call.',
+        'FILE EDITING: ALWAYS use the Edit tool for file modifications. The Edit tool performs exact string replacements - you must provide the exact text to replace (old_string) and the replacement text (new_string). To create new files, use Edit with an empty old_string. The edit will FAIL if old_string is not unique unless replace_all is true.',
+        'TYPESCRIPT ENGINEERING: Use strict TypeScript patterns - prefer interfaces over types for object shapes, use readonly for immutable data, leverage discriminated unions for complex state, and use utility types for better type safety.',
+        'ERROR HANDLING: Use structured error handling with Result types for functional error handling, implement recovery strategies for common failures, and provide actionable error messages with recovery suggestions.',
+        'PERFORMANCE OPTIMIZATION: Use parallel tool calls for independent operations, avoid sequential file reads when parallel execution is possible, and use targeted search patterns with head_limit to prevent context overflow.',
+        'AI FLOW DESIGN: Follow the complete AI flow: analyze (read/search) → plan (describe changes) → implement (edit/write) → validate (single final check). Do not skip phases or mix them.',
+        'TOOL VALIDATION: Use the tool validation system to detect anti-patterns before execution - check for Edit without Read, broad search patterns, redundant git operations, and incomplete workflows.',
+    ];
+    const behaviorSection = behaviorGuidelines
+        .map((line, index) => `${index + 1}. ${line}`)
+        .join('\n');
+    return `${basePrompt}
+${identityBlock}
+You are ${name}, running in an interactive shell with full capabilities:
+
+AVAILABLE TOOLS:
+${toolSummary}
+
+CAPABILITIES:
+${capabilityLines.join('\n')}
+
+BEHAVIOR GUIDELINES:
+${behaviorSection}
+
+Remember: answer truthfully, ground everything in the workspace, and let the logs show what you actually did. You CAN modify this codebase.`;
+}
+function formatToolSummary(tools, options = {}) {
+    if (!tools.length) {
+        return '- (no tools are registered in this session)';
+    }
+    return tools
+        .map((tool) => {
+        const description = tool.description ? sanitizeWhitespace(tool.description) : 'No description provided.';
+        const summary = truncate(description, options.maxDescriptionLength);
+        return `- ${tool.name}: ${summary}`;
+    })
+        .join('\n');
+}
+function sanitizeWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function truncate(value, maxLength) {
+    if (!maxLength || value.length <= maxLength) {
+        return value;
+    }
+    const safeLength = Math.max(0, maxLength - 3);
+    return `${value.slice(0, safeLength).trimEnd()}...`;
+}
+//# sourceMappingURL=systemPrompt.js.map

package/dist/shell/systemPrompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemPrompt.js","sourceRoot":"","sources":["../../src/shell/systemPrompt.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,4BAA4B,CAC1C,UAAkB,EAClB,YAAoB,EACpB,KAA+B,EAC/B,YAAqB;IAErB,MAAM,IAAI,GAAG,YAAY,IAAI,cAAc,CAAC;IAC5C,MAAM,WAAW,GAAG,iBAAiB,CAAC,KAAK,EAAE,EAAE,oBAAoB,EAAE,EAAE,EAAE,CAAC,CAAC;IAC3E,MAAM,SAAS,GAAG,YAAY,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAEhD,MAAM,aAAa,GAAG;6BACK,IAAI;4CACW,SAAS;;;CAGpD,CAAC;IAEA,MAAM,eAAe,GAAG;QACtB,sCAAsC;QACtC,mDAAmD;QACnD,sEAAsE;QACtE,qCAAqC;QACrC,kDAAkD;QAClD,uDAAuD;KACxD,CAAC;IAEF,MAAM,kBAAkB,GAAG;QACzB,oVAAoV;QACpV,+IAA+I;QAC/I,4JAA4J;QAC5J,oJAAoJ;QACpJ,iHAAiH;QACjH,0EAA0E;QAC1E,6DAA6D;QAC7D,+CAA+C;QAC/C,6KAA6K;QAC7K,wLAAwL;QACxL,iLAAiL;QACjL,mIAAmI;QACnI,oIAAoI;QACpI,0RAA0R;QAC1R,qVAAqV;QACrV,0OAA0O;QAC1O,oNAAoN;QACpN,8NAA8N;QAC9N,wLAAwL;QACxL,oMAAoM;KACrM,CAAC;IAEF,MAAM,eAAe,GAAG,kBAAkB;SACvC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;SAC7C,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,OAAO,GAAG,UAAU;EACpB,aAAa;UACL,IAAI;;;EAGZ,WAAW;;;EAGX,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;;;EAG1B,eAAe;;4IAE2H,CAAC;AAC7I,CAAC;AAMD,SAAS,iBAAiB,CAAC,KAA+B,EAAE,UAA8B,EAAE;IAC1F,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QAClB,OAAO,6CAA6C,CAAC;IACvD,CAAC;IACD,OAAO,KAAK;SACT,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACZ,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC;QACzG,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;QACpE,OAAO,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;IACtC,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAa;IACvC,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AAC3C,CAAC;AAED,SAAS,QAAQ,CAAC,KAAa,EAAE,SAAkB;IACjD,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,IAAI,SAAS,EAAE,CAAC;QAC5C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC;IAC9C,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC;AACtD,CAAC"}

package/dist/tools/bashTools.d.ts

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from '../core/toolRuntime.js';
+export declare function createBashTools(workingDir: string): ToolDefinition[];
+interface SandboxEnvOptions {
+    preserveHome?: boolean;
+}
+export declare function buildSandboxEnv(workingDir: string, options?: SandboxEnvOptions): Promise<NodeJS.ProcessEnv>;
+export {};
+//# sourceMappingURL=bashTools.d.ts.map

package/dist/tools/bashTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bashTools.d.ts","sourceRoot":"","sources":["../../src/tools/bashTools.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAyF7D,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,EAAE,CA2KpE;AAED,UAAU,iBAAiB;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,wBAAsB,eAAe,CACnC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CA6B5B"}

package/dist/tools/bashTools.js

@@ -0,0 +1,240 @@
+import { exec } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { createBackgroundBashTools, startBackgroundShell } from './backgroundBashTools.js';
+import { validateBashCommand, SmartFixer } from '../core/errors/safetyValidator.js';
+import { toStructuredError } from '../core/errors/errorTypes.js';
+import { analyzeBashFlow } from '../core/bashCommandGuidance.js';
+import { verifiedSuccess, verifiedFailure, analyzeOutput, OutputPatterns, createCommandCheck, } from '../core/resultVerification.js';
+import { createErrorFixer } from '../core/aiErrorFixer.js';
+const execAsync = promisify(exec);
+// Shared error fixer instance (lazy initialized per working dir)
+const errorFixerCache = new Map();
+function getErrorFixer(workingDir) {
+    let fixer = errorFixerCache.get(workingDir);
+    if (!fixer) {
+        fixer = createErrorFixer({ workingDir });
+        errorFixerCache.set(workingDir, fixer);
+    }
+    return fixer;
+}
+const sandboxCache = new Map();
+/**
+ * Smart timeout detection for bash commands.
+ * Returns appropriate timeout based on command type.
+ * - npm install/ci: 5 minutes
+ * - npm build/test: 5 minutes
+ * - npx create-*: 5 minutes
+ * - docker build/pull: 10 minutes
+ * - git clone: 3 minutes
+ * - Default: 30 seconds
+ */
+function getSmartTimeout(command) {
+    const cmd = command.toLowerCase().trim();
+    // NPM/Yarn/PNPM package operations (5 minutes)
+    if (/\b(npm|yarn|pnpm)\s+(install|ci|i|add|update|upgrade)\b/.test(cmd)) {
+        return 300000;
+    }
+    // NPM/Yarn build and test operations (5 minutes)
+    if (/\b(npm|yarn|pnpm)\s+(run\s+)?(build|test|lint|start|dev)\b/.test(cmd)) {
+        return 300000;
+    }
+    // NPX create commands (5 minutes)
+    if (/\bnpx\s+(create-|degit|giget)\b/.test(cmd)) {
+        return 300000;
+    }
+    // Prisma operations (3 minutes)
+    if (/\b(prisma|npx prisma)\s+(generate|migrate|db push|db pull)\b/.test(cmd)) {
+        return 180000;
+    }
+    // Docker operations (10 minutes)
+    if (/\bdocker\s+(build|pull|push|compose)\b/.test(cmd)) {
+        return 600000;
+    }
+    // Git clone (3 minutes)
+    if (/\bgit\s+clone\b/.test(cmd)) {
+        return 180000;
+    }
+    // Pip install (3 minutes)
+    if (/\bpip\s+install\b/.test(cmd)) {
+        return 180000;
+    }
+    // Default timeout
+    return 30000;
+}
+export function createBashTools(workingDir) {
+    const backgroundTools = createBackgroundBashTools(workingDir);
+    return [
+        {
+            name: 'execute_bash',
+            description: 'Execute a bash command in the working directory. Commands auto-timeout based on type: npm/docker/git commands get extended timeouts. Exit code 0 = success, non-zero = failure. Use run_in_background: true for long-running servers/watchers. IMPORTANT: Always check command output for errors even if exit code is 0.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: {
+                        type: 'string',
+                        description: 'The bash command to execute (e.g., "npm test", "git status", "ls -la"). Will be validated for safety before execution.',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in milliseconds. Default is smart: 30s for most commands, 5min for npm/docker, 3min for git clone. Not used when run_in_background is true.',
+                    },
+                    run_in_background: {
+                        type: 'boolean',
+                        description: 'Set to true to run this command in the background (for servers, watchers, long-running processes). Returns a shell ID that can be used with BashOutput to monitor output.',
+                    },
+                },
+                required: ['command'],
+            },
+            handler: async (args) => {
+                const command = args['command'];
+                const runInBackground = args['run_in_background'] === true;
+                // Smart timeout: auto-extend for known long-running commands
+                const userTimeout = args['timeout'];
+                const timeout = userTimeout ?? getSmartTimeout(command);
+                // Lightweight flow guidance (publish/git) without blocking execution
+                const flowWarnings = analyzeBashFlow(command);
+                for (const warning of flowWarnings) {
+                    const suffix = warning.suggestion ? ` — ${warning.suggestion}` : '';
+                    console.warn(`[Bash Flow] ${warning.message}${suffix}`);
+                }
+                // Enhanced safety validation with structured errors
+                const validation = validateBashCommand(command);
+                if (!validation.valid) {
+                    const structuredError = validation.error ? toStructuredError(validation.error) : null;
+                    if (structuredError) {
+                        // Return formatted error with suggestions
+                        let errorMsg = structuredError.toDisplayString();
+                        // Add auto-fix suggestion if available
+                        if (validation.autoFix?.available) {
+                            const { fixed, changes } = SmartFixer.fixDangerousCommand(command);
+                            if (changes.length > 0) {
+                                errorMsg += '\n\nAuto-fix available:';
+                                for (const change of changes) {
+                                    errorMsg += `\n  - ${change}`;
+                                }
+                                errorMsg += `\n\nFixed command: ${fixed}`;
+                            }
+                        }
+                        return errorMsg;
+                    }
+                    return 'Error: Command validation failed';
+                }
+                // Log warnings if any
+                if (validation.warnings.length > 0) {
+                    for (const warning of validation.warnings) {
+                        console.warn(`[Bash Safety] ${warning}`);
+                    }
+                }
+                // Handle background execution
+                if (runInBackground) {
+                    const shellId = startBackgroundShell(command, workingDir);
+                    return `Background shell started: ${shellId}\n\nUse BashOutput with bash_id="${shellId}" to monitor output.\nUse KillShell with shell_id="${shellId}" to terminate.`;
+                }
+                // Handle foreground execution
+                const startTime = Date.now();
+                try {
+                    const env = await buildSandboxEnv(workingDir);
+                    const { stdout, stderr } = await execAsync(command, {
+                        cwd: workingDir,
+                        timeout,
+                        maxBuffer: 1024 * 1024 * 10, // 10MB
+                        env,
+                    });
+                    const durationMs = Date.now() - startTime;
+                    const combinedOutput = [stdout, stderr].filter(Boolean).join('\n');
+                    // Select appropriate patterns based on command type
+                    const commandLower = command.toLowerCase().trim();
+                    let patterns = OutputPatterns.command;
+                    if (commandLower.startsWith('git ') || commandLower === 'git') {
+                        patterns = OutputPatterns.git;
+                    }
+                    else if (commandLower.startsWith('npm ') || commandLower.startsWith('npx ')) {
+                        patterns = OutputPatterns.npm;
+                    }
+                    // Analyze the output to determine actual success
+                    const analysis = analyzeOutput(combinedOutput, patterns, 0);
+                    const commandCheck = createCommandCheck('Command execution', 0, combinedOutput);
+                    // Check for explicit failure patterns in output despite exit code 0
+                    // Some commands exit 0 but print errors (e.g., "error:" in output)
+                    if (analysis.isFailure) {
+                        return verifiedFailure(`Command completed with exit code 0 but output indicates failure`, `Command: ${command}\n\nOutput:\n${combinedOutput || '(no output)'}`, ['Review the error message in the output', 'Fix the underlying issue and retry'], [commandCheck, { check: 'Output analysis', passed: false, details: `Failure pattern matched: ${analysis.matchedPattern}` }], durationMs);
+                    }
+                    // Exit code 0 + no failure patterns = success
+                    // This is how Unix commands work - exit code 0 means success
+                    // We don't require explicit "success" words in output
+                    return verifiedSuccess(combinedOutput.trim() ? `Command executed successfully` : `Command executed successfully (no output)`, `Command: ${command}${combinedOutput.trim() ? `\n\nOutput:\n${combinedOutput}` : ''}`, [commandCheck, ...(analysis.isSuccess ? [{ check: 'Output analysis', passed: true, details: `Success pattern matched` }] : [])], durationMs);
+                }
+                catch (error) {
+                    const durationMs = Date.now() - startTime;
+                    const exitCode = error.code ?? 1;
+                    const combinedError = [error.stdout, error.stderr, error.message].filter(Boolean).join('\n');
+                    if (error.killed) {
+                        return verifiedFailure(`Command timed out after ${timeout}ms`, `Command: ${command}\n\nThe command was killed after exceeding the timeout.\nPartial output:\n${combinedError || '(none)'}`, ['Increase timeout if command legitimately needs more time', 'Check if command is hanging on input'], [{ check: 'Timeout', passed: false, details: `Exceeded ${timeout}ms` }], durationMs);
+                    }
+                    // AI Error Analysis - automatically analyze failures
+                    const errorFixer = getErrorFixer(workingDir);
+                    const aiErrors = errorFixer.analyzeOutput(combinedError, command);
+                    const aiGuidance = aiErrors.length > 0 ? errorFixer.formatForAI(aiErrors) : '';
+                    // Build suggestions with AI help
+                    const suggestions = ['Review the error message', 'Fix the issue and retry the command'];
+                    const firstError = aiErrors[0];
+                    if (firstError && firstError.suggestedFixes.length > 0) {
+                        const bestFix = firstError.suggestedFixes[0];
+                        if (bestFix) {
+                            suggestions.unshift(`AI Suggestion: ${bestFix.description}`);
+                        }
+                    }
+                    return verifiedFailure(`Command failed with exit code ${exitCode}`, `Command: ${command}\n\nError output:\n${combinedError || '(none)'}${aiGuidance}`, suggestions, [createCommandCheck('Command execution', exitCode, combinedError)], durationMs);
+                }
+            },
+        },
+        ...backgroundTools,
+    ];
+}
+export async function buildSandboxEnv(workingDir, options) {
+    const envPreference = process.env['EROSOLAR_PRESERVE_HOME'];
+    const preserveHome = envPreference === '1'
+        ? true
+        : envPreference === '0'
+            ? false
+            : Boolean(options?.preserveHome);
+    const paths = await ensureSandboxPaths(workingDir);
+    const env = {
+        ...process.env,
+        EROSOLAR_SANDBOX_ROOT: paths.root,
+        EROSOLAR_SANDBOX_HOME: paths.home,
+        EROSOLAR_SANDBOX_TMP: paths.tmp,
+    };
+    if (!preserveHome) {
+        env['HOME'] = paths.home;
+    }
+    env['XDG_CACHE_HOME'] = paths.cache;
+    env['XDG_CONFIG_HOME'] = paths.config;
+    env['XDG_DATA_HOME'] = paths.data;
+    env['TMPDIR'] = paths.tmp;
+    env['TMP'] = paths.tmp;
+    env['TEMP'] = paths.tmp;
+    return env;
+}
+async function ensureSandboxPaths(workingDir) {
+    const key = workingDir;
+    let pending = sandboxCache.get(key);
+    if (!pending) {
+        pending = createSandboxPaths(workingDir);
+        sandboxCache.set(key, pending);
+    }
+    return pending;
+}
+async function createSandboxPaths(workingDir) {
+    const root = join(workingDir, '.erosolar', 'shell-sandbox');
+    const home = join(root, 'home');
+    const cache = join(root, 'cache');
+    const config = join(root, 'config');
+    const data = join(root, 'data');
+    const tmp = join(root, 'tmp');
+    await Promise.all([home, cache, config, data, tmp].map((dir) => mkdir(dir, { recursive: true })));
+    return { root, home, cache, config, data, tmp };
+}
+//# sourceMappingURL=bashTools.js.map