// Extracted from newOS4 index.html — WebX11AIAssistantModule (Full Agent Loop) class WebX11AIAssistantModule { constructor() { this.commands = {}; this.terminal = null; this.systemPrompt = this.buildSystemPrompt(); this.context = []; this.maxContext = 10; this.maxContextTokens = 2000; this.MAX_TOOL_TURNS = 8; this._pendingConfirmation = null; this._confirmResolve = null; this._errorLog = []; this._commandFreq = {}; this._messageCount = 0; this._userProfile = {}; this._sessionMemoryLoaded = false; this._sessionSaved = false; this._thinkingTimer = null; this._thinkingStartTime = 0; this._toolDefs = null; try { const s = localStorage.getItem('webx11_ai_patterns'); if (s) this._commandFreq = JSON.parse(s); } catch (e) {} try { const p = localStorage.getItem('webx11_user_profile'); if (p) this._userProfile = JSON.parse(p); } catch (e) {} // Restore AI conversation context from localStorage try { const saved = localStorage.getItem('webx11_ai_context'); if (saved) { const parsed = JSON.parse(saved); if (parsed && Array.isArray(parsed.context)) { this.context = parsed.context; this._messageCount = parsed.messageCount || 0; } } } catch (e) {} } buildSystemPrompt() { const now = new Date(); const dateStr = now.toLocaleDateString('en-US', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }); const timeStr = now.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' }); return `Current date: ${dateStr}\nCurrent time: ${timeStr}\n\nYou are WebX11AI, the AI assistant embedded in the WebX11 browser terminal. You have direct access to read/write files, search the web, install packages, edit modules, and run terminal commands — all via tool calls. Use tools proactively. Keep responses concise.\n\n== TOOL REFERENCE == You have these tools available. Use them WITHOUT asking permission unless the tool description says (DESTRUCTIVE): FILESYSTEM: - list_files(path?) — List files in VFS directory (omit for current dir) - read_file(path) — Read file content (truncated past 8000 chars) - write_file(path, content) — Write to file (DESTRUCTIVE — confirm with user first) - make_directory(path) — Create a directory (DESTRUCTIVE — confirm first) - delete_file(path) — Delete file (DESTRUCTIVE — confirm first) - get_current_dir — Show current working directory SYSTEM: - get_status — Show filesystem, modules, Ollama, memory status - get_help — List all available terminal commands - run_command(command) — Execute any terminal command and capture output - font-size <8-32> — Change terminal font size (persists in localStorage) SEARCH: - web_search(query) — Search the web via proxy API (SearXNG + DDG fallback, results with title/url/snippet) - web_fetch(url) — Fetch and extract readable content from a URL via proxy API (returns title + clean text + word count) PACKAGES: - wpm_install(package) — Install WPM package by name (e.g. "widget", "calc") - wpm_search(keyword) — Search available WPM packages SKILLS (PERSISTENT PROCEDURAL MEMORY): - list_skills(category?) — Browse available skills, optionally filtered by category - load_skills(query) — Search skills relevant to current task. Call at START of every task. - create_skill(name, description, content, tags, category) — Save a new stored procedure. Call after completing complex multi-step tasks (3+ tool calls). - patch_skill(name, content) — Update an existing skill when the approach changes MODULE SELF-IMPROVEMENT: - view_module(name) — View source code of any loaded module - edit_module(name) — Copy module into editor. Opens editor for modifications. - test_module(name) — Load edited module from /_mods/ for live testing - reload_module(name) — Discard edits and reload from original URL - list_modified_modules — List modules with local edits pending - get_module_status — Full status of all modules (loaded, modified, URLs) == SKILLS WORKFLOW == 1. At the START of every task, call load_skills(query) to check if a stored procedure exists 2. Follow the skill's steps. If they're wrong, call patch_skill to fix them. 3. After a complex multi-step task (3+ tool calls), call create_skill to save the approach 4. Skills persist in /skills/ as markdown files with YAML frontmatter == MEMORY SYSTEM == - I maintain a conversation context (this.context) that persists across messages in this session - The last ${this.maxContext} exchanges are remembered - Type "ai-clear" to reset conversation memory - Type "ai-context" to see what I remember - Type "ai-model" to see/switch models - Type "ai-stop" to cancel a running AI request - Smart context profiles (set via "context ") adjust my temperature and system prompt style - Saved prompts (via "prompt", "prompt-save") let you reuse template with {variable} substitution == USER PROFILE == - Use user_get, user_set to read/write persistent user preferences across sessions - user_set dot-notation supported: user_set knownFacts.name "Alex" - Profile auto-stores known facts (name, project, preferences) - Use session_save after complex tasks to log what was done - Use session_load to review past sessions - Use session_recent at start of session to remember what was worked on before == SELF-IMPROVEMENT WORKFLOW == 1. User asks for module changes → call get_module_status to list modules 2. Call view_module(name) to read the module source 3. Call edit_module(name) to copy source into editor for modification 4. After editing, call test_module(name) to load and test the edit 5. If it works, the user keeps it. If not, call reload_module(name). == AUTO-IMPROVEMENT (SYSTEM-DRIVEN) == - If I encounter the same tool error 3+ times, a workaround skill is created automatically - After complex tasks (3+ tool calls), I run health checks and suggest improvements - I track conversation patterns and surface frequent topics - Every 20 messages, skills are audited for staleness - Use check_updates to verify module source URLs are reachable == RESPONSE STYLE == - Be concise. Use bullet points for lists. - When using tools, explain what you're doing briefly. - If a tool fails, try an alternative approach. - For web research tasks: search first, then analyze the results, then present findings. |- When the user says "update" or "improve" without specifics, use get_status + get_help to understand the current state first. == REACT PROTOCOL == For every task, follow this cycle: 1. **REASON** — Think about what you need next. What information is missing? 2. **ACT** — Call ONE tool at a time (unless multiple independent lookups are needed). 3. **OBSERVE** — Study the tool result carefully. Did it succeed? Is the data useful? 4. **DECIDE** — Do you have enough to answer? If not, go back to step 1. RULES: - Call tools in sequence when the second depends on the first result - Independent lookups (e.g. reading two unrelated files) can run in parallel - If a tool returns an error, try a different approach before giving up - After 6 tool turns, start synthesizing a final answer - Always provide a complete, helpful final answer — don't leave the user hanging`; } getToolDefinitions() { if (!this._toolDefs) this._toolDefs = this._buildToolDefs(); return this._toolDefs; } _buildToolDefs() { return [{ type: 'function', function: { name: 'list_files', description: 'List VFS directory contents', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Dir path ("" for root)' } }, required: [] } } }, { type: 'function', function: { name: 'read_file', description: 'Read VFS file', parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path' } }, required: ['path'] } } }, { type: 'function', function: { name: 'write_file', description: 'Write file (DESTRUCTIVE)', parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, content: { type: 'string', description: 'Content' } }, required: ['path', 'content'] } } }, { type: 'function', function: { name: 'make_directory', description: 'Create VFS directory', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Dir name' } }, required: ['path'] } } }, { type: 'function', function: { name: 'delete_file', description: 'Delete file or empty dir (DESTRUCTIVE)', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Path to delete' } }, required: ['path'] } } }, { type: 'function', function: { name: 'get_status', description: 'System status: FS, modules, memory', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'get_help', description: 'Command reference', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'web_search', description: 'Search web via SearXNG + DDG', parameters: { type: 'object', properties: { query: { type: 'string', description: 'Search query' } }, required: ['query'] } } }, { type: 'function', function: { name: 'web_fetch', description: 'Fetch & extract URL content', parameters: { type: 'object', properties: { url: { type: 'string', description: 'Full URL' } }, required: ['url'] } } }, { type: 'function', function: { name: 'wpm_install', description: 'Install WPM package', parameters: { type: 'object', properties: { package: { type: 'string', description: 'Package name' } }, required: ['package'] } } }, { type: 'function', function: { name: 'wpm_search', description: 'Search WPM packages', parameters: { type: 'object', properties: { keyword: { type: 'string', description: 'Keyword' } }, required: ['keyword'] } } }, { type: 'function', function: { name: 'run_command', description: 'Run terminal command', parameters: { type: 'object', properties: { command: { type: 'string', description: 'Command to run' } }, required: ['command'] } } }, { type: 'function', function: { name: 'get_current_dir', description: 'Current VFS directory', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'view_module', description: 'View module source code', parameters: { type: 'object', properties: { name: { type: 'string', description: 'Module class name' } }, required: ['name'] } } }, { type: 'function', function: { name: 'edit_module', description: 'Edit module source (DESTRUCTIVE)', parameters: { type: 'object', properties: { name: { type: 'string', description: 'Module class name' } }, required: ['name'] } } }, { type: 'function', function: { name: 'test_module', description: 'Test edited module from /_mods/', parameters: { type: 'object', properties: { name: { type: 'string', description: 'Module class name' } }, required: ['name'] } } }, { type: 'function', function: { name: 'reload_module', description: 'Reload module from original URL', parameters: { type: 'object', properties: { name: { type: 'string', description: 'Module class name' } }, required: ['name'] } } }, { type: 'function', function: { name: 'list_modified_modules', description: 'List modules with local edits', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'get_module_status', description: 'Module status: loaded, modified, URLs', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'load_skills', description: 'Search skills relevant to task', parameters: { type: 'object', properties: { query: { type: 'string', description: 'Task description' } }, required: ['query'] } } }, { type: 'function', function: { name: 'create_skill', description: 'Save a new skill', parameters: { type: 'object', properties: { name: { type: 'string', description: 'kebab-case name' }, description: { type: 'string', description: 'One-line description' }, content: { type: 'string', description: 'Markdown with YAML frontmatter' }, tags: { type: 'string', description: 'Comma-separated' }, category: { type: 'string', description: 'e.g. research, system, dev' } }, required: ['name', 'description', 'content'] } } }, { type: 'function', function: { name: 'patch_skill', description: 'Replace skill content', parameters: { type: 'object', properties: { name: { type: 'string', description: 'Skill name' }, content: { type: 'string', description: 'New markdown content' } }, required: ['name', 'content'] } } }, { type: 'function', function: { name: 'list_skills', description: 'Browse skills (optional filter)', parameters: { type: 'object', properties: { category: { type: 'string', description: 'Filter by category' } }, required: [] } } }, { type: 'function', function: { name: 'check_updates', description: 'Check module URLs are reachable', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'user_get', description: 'Read user profile key', parameters: { type: 'object', properties: { key: { type: 'string', description: 'e.g. preferredModel' } }, required: ['key'] } } }, { type: 'function', function: { name: 'user_set', description: 'Write user profile key', parameters: { type: 'object', properties: { key: { type: 'string', description: 'Profile key' }, value: { type: 'string', description: 'Value' } }, required: ['key', 'value'] } } }, { type: 'function', function: { name: 'user_list', description: 'List stored profile keys', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'user_forget', description: 'Delete profile key', parameters: { type: 'object', properties: { key: { type: 'string', description: 'Key to delete' } }, required: ['key'] } } }, { type: 'function', function: { name: 'session_save', description: 'Save session summary', parameters: { type: 'object', properties: { summary: { type: 'string', description: 'What was accomplished' } }, required: ['summary'] } } }, { type: 'function', function: { name: 'session_load', description: 'Load past session by date', parameters: { type: 'object', properties: { date: { type: 'string', description: 'YYYY-MM-DD' } }, required: ['date'] } } }, { type: 'function', function: { name: 'session_recent', description: 'Show recent sessions', parameters: { type: 'object', properties: { count: { type: 'number', description: 'Count (default 3)' } }, required: [] } } }, { type: 'function', function: { name: 'session_terminal', description: 'Read last terminal output', parameters: { type: 'object', properties: {}, required: [] } } }, { type: 'function', function: { name: 'session_stats', description: 'Session aggregate stats', parameters: { type: 'object', properties: {}, required: [] } } }]; } getHelpInfo() { return { 'ai': 'ai — Ask the AI assistant anything', 'ask': 'ask — Alias for ai command', 'ai-clear': 'ai-clear — Clear conversation context', 'ai-system': 'ai-system — Set system prompt', 'ai-context': 'ai-context — Show current conversation context', 'ai-allow': 'ai-allow — Confirm pending AI action', 'ai-deny': 'ai-deny — Deny pending AI action', 'ai-stop': 'ai-stop — Cancel current AI operation', 'ai-model': 'ai-model [model] — Show or set AI model' }; } registerCommands() { this.commands['ai'] = (args) => this.chat(args); this.commands['ask'] = (args) => this.chat(args); this.commands['ai-clear'] = () => this.clearContext(); this.commands['ai-system'] = (args) => this.setSystemPrompt(args); this.commands['ai-context'] = () => this.showContext(); this.commands['ai-allow'] = () => this.confirmPending(); this.commands['ai-deny'] = () => this.denyPending(); this.commands['ai-stop'] = () => this.cancelAi(); this.commands['ai-model'] = (args) => this.showModel(args); this.commands['ai-compress'] = () => this._manualCompress(); } async chat(args) { const userMessage = args.join(' '); if (!userMessage) { this.terminal.print('Usage: ai ', 'warning'); return; } this._cancelled = false; this.terminal.setAiBusy(true); while (this._chatLock) await new Promise(r => setTimeout(r, 50)); this._chatLock = true; this.terminal.markDirty(); // Re-read context from localStorage (auto-restore may have written it after init) this._loadContext(); // Compress context if it exceeds the token threshold this._compressContext(); let loopResult; try { const messages = [ { role: 'system', content: this.systemPrompt } ]; this.context.slice().forEach(msg => messages.push(msg)); messages.push({ role: 'user', content: userMessage }); this.terminal.print('🤖 WebX11AI thinking...', 'info'); // Ensure skills directory exists and seed defaults on first run this.terminal.fs.mkdirRecursive('/skills'); if (!this.terminal.fs.readFile('/skills/_seeded')) { try { await this._seedDefaultSkills(); } catch (e) { /* non-critical */ } } // Auto-load skills relevant to the user's query (awaited, not fire-and-forget) // Skip skill loading for trivial queries (< 10 chars, no actionable keywords) const isTrivial = userMessage.length < 10 && !/\b(search|write|install|edit|create|make|find|delete|remove|change|update|improve|add|fix|build|set|load|save|help)\b/i.test(userMessage); if (!isTrivial) { try { const skillRes = await this.runTool('load_skills', { query: userMessage }); const skillData = JSON.parse(skillRes); if (skillData && skillData.matches && skillData.matches.length > 0) { const skillNotes = skillData.matches.map(m => `[Skill: ${m.name}] ${m.content}`).join('\n\n---\n\n'); messages.push({ role: 'system', content: `Relevant skills for this task:\n\n${skillNotes}\n\nUse the steps above as guidance. If they're wrong or outdated, use patch_skill to fix them after the task.` }); this.terminal.print(`📚 Loaded ${skillData.count} relevant skill(s)`, 'info'); } } catch (e) { /* skills not available yet — first run */ } } // Track conversation patternsfor learning this._trackPattern(userMessage); // Extract facts from user message this._extractFacts(userMessage, ''); // On first message of session, auto-load recent memory if (!this._sessionMemoryLoaded) { this._sessionMemoryLoaded = true; this.terminal.fs.mkdirRecursive('/memory'); try { const recentRes = await this.runTool('session_recent', { count: 3 }); const rd = JSON.parse(recentRes); if (rd.sessions && rd.sessions.length > 0) { const memNotes = rd.sessions.map(s => '[' + s.date + '] ' + (s.tasks || 1) + ' tasks: ' + (s.summary || 'No summary')).join('\n'); messages.push({ role: 'system', content: 'Recent sessions:\n' + memNotes + '\nThis provides continuity. Refer to past work when relevant.' }); this.terminal.print('📖 Loaded ' + rd.sessions.length + ' recent session(s)', 'info'); } } catch (e) {} } loopResult = await this.agenticLoop(messages); this.context.push({ role: 'user', content: userMessage }); if (loopResult.finalAnswer) { this.context.push({ role: 'assistant', content: loopResult.finalAnswer }); } if (this.context.length > this.maxContext * 2) { this.context = this.context.slice(-this.maxContext * 2); } // Reflection: after complex tasks, run health scan and auto-skill creation if (loopResult.toolTurns >= 2 && !this._cancelled) { await this.afterActionReflection(userMessage, loopResult.toolTurns); } // Auto-create skills from repeated errors if (this._errorLog.length >= 3) { await this._autoCreateErrorSkill(); } // Skill quality audit every 20 messages this._messageCount++; if (this._messageCount % 20 === 0) { await this._auditSkills(); } // Sound notification on AI response if (this.terminal.playNotificationSound) { setTimeout(() => this.terminal.playNotificationSound(), 100); } } finally { this._chatLock = false; this.terminal.setAiBusy(false); // Persist conversation context after each exchange this._saveContext(); // Log the AI interaction this.terminal.log('INFO', 'AI', 'Query: ' + userMessage.substring(0, 100)); if (loopResult && loopResult.toolTurns) { this.terminal.log('INFO', 'AI', 'Used ' + loopResult.toolTurns + ' tool(s)'); } } // Register session save on page unload (runs once per session) if (!this._sessionSaved) { this._sessionSaved = true; window.addEventListener('beforeunload', () => { this.terminal.fs.mkdirRecursive('/memory'); const today = new Date().toISOString().split('T')[0]; const index = this.terminal.fs.fsReadJSON('/memory/index.json') || {}; index[today] = index[today] || { summary: 'Session in progress', tasks: 0 }; index[today].tasks = (index[today].tasks || 0) + 1; index[today].updated = new Date().toISOString(); this.terminal.fs.fsWriteJSON('/memory/index.json', index); // Also persist AI context on page close this._saveContext(); }); } } _summarizeObservation(result, maxLen) { if (!result || typeof result !== 'string' || result.length <= maxLen) return result || ''; const lines = result.split('\n'); if (lines.length > 5) { return lines.slice(0, 2).join('\n') + '\n...(' + (lines.length - 4) + ' more lines)...\n' + lines.slice(-2).join('\n'); } return result.substring(0, maxLen) + '...(truncated from ' + result.length + ' chars)'; } _isToolError(result) { if (!result || typeof result !== 'string') return null; const trimmed = result.trim(); if (trimmed.startsWith('{"error":') || trimmed.startsWith("{'error':")) { try { const parsed = JSON.parse(trimmed); return parsed.error || null; } catch (e) { return null; } } return null; } _trackToolFailure(toolName, error) { try { const key = 'webx11_tool_failures'; const raw = localStorage.getItem(key) || '{}'; const map = JSON.parse(raw); if (!map[toolName]) map[toolName] = { count: 0, last: '', errors: [] }; map[toolName].count++; map[toolName].last = new Date().toISOString(); map[toolName].errors.push(error); if (map[toolName].errors.length > 5) map[toolName].errors.shift(); localStorage.setItem(key, JSON.stringify(map)); if (map[toolName].count >= 3) { this.terminal.print(`⚠️ Tool '${toolName}' has failed ${map[toolName].count} times. Consider creating a workaround skill.`, 'warning'); } } catch (e) { /* ignore */ } } async agenticLoop(messages) { let toolTurns = 0; while (toolTurns < this.MAX_TOOL_TURNS) { if (this._cancelled) { this.terminal.print('AI loop cancelled', 'warning'); return { finalAnswer: null, toolTurns }; } toolTurns++; // On last turn, inject wrap-up prompt if (toolTurns === this.MAX_TOOL_TURNS) { this.terminal.print(`⏱ Final turn (${toolTurns}/${this.MAX_TOOL_TURNS}) — AI must provide final answer`, 'warning'); messages.push({ role: 'system', content: 'This is your last tool turn. You MUST provide a final answer after this tool call. Synthesize what you know.' }); } const thinkStart = Date.now(); const res = await this.terminal.ollamaManager.chatWithTools(messages, this.getToolDefinitions()); const thinkTime = Math.round((Date.now() - thinkStart) / 1000); if (this._cancelled) return { finalAnswer: null, toolTurns }; if (res.error) { this.terminal.print(`⚠️ AI model error (${thinkTime}s): ${res.error}`, 'error'); return { finalAnswer: null, toolTurns }; } if (res.message && !res.tool_calls) { const text = res.message.content || ''; this.terminal.printAIResponse(text || '(no response)'); if (text) this.terminal.ollamaManager.fireResponseHooks(text); this.terminal.print(`💬 AI answered (turn ${toolTurns}/${this.MAX_TOOL_TURNS}, ${thinkTime}s)`, 'info'); return { finalAnswer: text, toolTurns }; } if (res.tool_calls && res.tool_calls.length > 0) { this.terminal.print(`🔧 AI wants ${res.tool_calls.length} tool(s) — turn ${toolTurns}/${this.MAX_TOOL_TURNS} (${thinkTime}s)`, 'info'); messages.push(res.message); let pendingText = res.message?.content || null; const destructiveTools = res.tool_calls.filter(tc => this.isDestructive(tc.function.name)); const safeTools = res.tool_calls.filter(tc => !this.isDestructive(tc.function.name)); // Execute non-destructive tools in parallel (independent read-only operations) const safeResults = await Promise.all(safeTools.map(async (tc) => { const fn = tc.function; const t0 = Date.now(); const toolResult = await this.runTool(fn.name, fn.arguments); const t1 = Math.round((Date.now() - t0) / 1000); return { fn, toolResult, t1 }; })); for (const { fn, toolResult, t1 } of safeResults) { this.terminal.print(`🔧 Tool: ${fn.name}(${typeof fn.arguments === 'string' ? fn.arguments : JSON.stringify(fn.arguments)})`, 'info'); const obs = this._summarizeObservation(toolResult, 150); const err = this._isToolError(toolResult); if (err) { this.terminal.log('WARN', 'AI', `Tool ${fn.name} failed: ${err} (${t1}s)`); this._trackToolFailure(fn.name, err); this.terminal.print(`📊 Result (${t1}s): ⚠️ Error: ${err}`, 'warning'); } else { this.terminal.log('INFO', 'AI', `Tool ${fn.name} ok (${t1}s)`); this.terminal.print(`📊 Result (${t1}s): ${obs}`, 'info'); } messages.push({ role: 'tool', content: toolResult }); } // Only block on destructive tools if (destructiveTools.length > 0) { const approved = await this.confirmActionMulti(destructiveTools); if (approved) { for (const tc of destructiveTools) { const fn = tc.function; const t0 = Date.now(); this.terminal.print(`🔧 Tool: ${fn.name}(${typeof fn.arguments === 'string' ? fn.arguments : JSON.stringify(fn.arguments)})`, 'info'); const toolResult = await this.runTool(fn.name, fn.arguments); const t1 = Math.round((Date.now() - t0) / 1000); const dObs = this._summarizeObservation(toolResult, 150); const dErr = this._isToolError(toolResult); if (dErr) { this.terminal.log('WARN', 'AI', `Tool ${fn.name} failed: ${dErr} (${t1}s)`); this._trackToolFailure(fn.name, dErr); this.terminal.print(`📊 Result (${t1}s): ⚠️ Error: ${dErr}`, 'warning'); } else { this.terminal.log('INFO', 'AI', `Tool ${fn.name} ok (${t1}s)`); this.terminal.print(`📊 Result (${t1}s): ${dObs}`, 'info'); } messages.push({ role: 'tool', content: toolResult }); } } else { messages.push({ role: 'tool', content: `Destructive actions (${destructiveTools.map(tc => tc.function.name).join(', ')}) denied by user. Non-destructive actions already executed.` }); } } if (pendingText) { messages.push({ role: 'assistant', content: pendingText }); } continue; } return { finalAnswer: null, toolTurns }; } // Loop exited without final answer — auto-summary const toolNames = Object.keys(this._commandFreq).slice(-3).join(', '); this.terminal.print(`🤖 AI reached the ${toolTurns}/${this.MAX_TOOL_TURNS} tool limit.`, 'warning'); this.terminal.print('Tools were executed but no final answer was produced — try a more specific query.', 'info'); return { finalAnswer: null, toolTurns }; } async afterActionReflection(query, toolTurns) { // Debounce: only suggest skill creation once per 30 minutes const now = Date.now(); if (this._lastSkillSuggestion && (now - this._lastSkillSuggestion) < 1800000) { return; } const suggestions = []; const fs = this.terminal.fs; try { // Batch: read all status info in one VFS pass const reg = this.terminal.moduleManager.moduleRegistry || []; const total = reg.length; const loaded = Object.keys(this.terminal.moduleManager.modules).length; if (loaded < total) { suggestions.push(loaded + '/' + total + ' modules loaded — use loadmod to restore'); } } catch (e) {} try { const skillIdx = fs.fsReadJSON('/skills/index.json'); const skillCount = skillIdx ? Object.keys(skillIdx).length : 0; if (skillCount === 0 && toolTurns >= 4) { suggestions.push('Save this approach as a skill with create_skill'); this._lastSkillSuggestion = now; } } catch (e) {} try { const modsDir = fs.getCurrentDir(); const mc = modsDir.content['_mods']; const modCount = mc && mc.content ? Object.keys(mc.content).filter(k => k.endsWith('.js') && !k.endsWith('.orig.js')).length : 0; if (modCount > 0) { suggestions.push(modCount + ' pending module edit(s) in /_mods/ — use test_module to verify'); } } catch (e) {} try { if (performance.memory && performance.memory.usedJSHeapSize > 100 * 1048576) { suggestions.push('High memory (' + (performance.memory.usedJSHeapSize / 1048576).toFixed(0) + 'MB) — consider clearing terminal'); } } catch (e) {} if (toolTurns >= 4 && suggestions.length === 0) { suggestions.push('Used ' + toolTurns + ' tools — create a skill to save this workflow'); this._lastSkillSuggestion = now; } if (suggestions.length > 0) { this.terminal.print('💡 ' + suggestions.join(' | '), 'info'); } } async confirmActionMulti(toolCalls) { const names = toolCalls.map(tc => tc.function.name).join(', '); const args = toolCalls.map(tc => typeof tc.function.arguments === 'string' ? tc.function.arguments : JSON.stringify(tc.function.arguments)).join(' | '); const truncatedArgs = args.length > 60 ? args.substring(0, 60) + '...' : args; this.terminal.printHTML(`⚠️ AI wants to: ${names}(${truncatedArgs}). ai-allow to confirm, ai-deny to refuse. (Auto-denies in 120s)`); // Show confirm bar OUTSIDE scrollable output (always visible) const area = document.getElementById('ai-confirm-area'); if (!area) { // Fallback to promise resolve return true; } area.innerHTML = ` ⚠️ ${names}(${truncatedArgs}) Type: ai-allow or ai-deny `; area.classList.add('visible'); this._confirmArea = area; this._confirmBar = area; // Attach button handlers via both addEventListener + DOM property (inline onclick fallback) const allowBtn = document.getElementById('ai-confirm-allow'); const denyBtn = document.getElementById('ai-confirm-deny'); const onAllow = () => { this._resolveConfirm(true); }; const onDeny = () => { this._resolveConfirm(false); }; allowBtn.addEventListener('click', onAllow); denyBtn.addEventListener('click', onDeny); allowBtn.__allow = onAllow; denyBtn.__deny = onDeny; const startTime = Date.now(); return new Promise((resolve) => { this._pendingConfirmation = { names, args }; this._confirmResolve = resolve; this._confirmAllowBtn = allowBtn; this._confirmDenyBtn = denyBtn; this._confirmOnAllow = onAllow; this._confirmOnDeny = onDeny; // Countdown timer updates with escalating visibility const timerInterval = setInterval(() => { const elapsed = Math.round((Date.now() - startTime) / 1000); const remaining = Math.max(0, 120 - elapsed); const timerEl = document.getElementById('ai-confirm-timer'); if (timerEl) { timerEl.textContent = `⏱ ${remaining}s`; timerEl.className = 'confirm-timer'; if (remaining > 30) { timerEl.style.color = 'var(--warning-color)'; } else if (remaining > 10) { timerEl.classList.add('urgent'); } else { timerEl.classList.add('critical'); } } if (remaining === 60) { this.terminal.print(`⏱ 60s remaining to respond to AI confirmation for: ${names}`, 'warning'); } else if (remaining === 30) { this.terminal.print(`⏱ 30s — ${names} will be auto-denied soon!`, 'warning'); } else if (remaining === 10) { this.terminal.print(`⏱ 10s remaining! Type ai-allow or click Allow now!`, 'warning'); } }, 500); this._confirmTimerInterval = timerInterval; setTimeout(() => { clearInterval(timerInterval); if (this._confirmResolve) { this._confirmResolve(false); this._cleanupConfirmBar(); this.terminal.print('⏱ Confirmation timed out — tool not executed', 'warning'); } }, 120000); }); } _resolveConfirm(approved) { if (this._confirmResolve) { this._confirmResolve(approved); this._cleanupConfirmBar(); if (approved) { this.terminal.print('Action allowed', 'success'); } else { this.terminal.print('Action denied', 'warning'); } } } _cleanupConfirmBar() { clearInterval(this._confirmTimerInterval); this._confirmTimerInterval = null; this._confirmResolve = null; this._pendingConfirmation = null; this._confirmAllowBtn = null; this._confirmDenyBtn = null; this._confirmOnAllow = null; this._confirmOnDeny = null; const area = document.getElementById('ai-confirm-area'); if (area) { area.classList.remove('visible'); area.innerHTML = ''; } this._confirmArea = null; this._confirmBar = null; const timerEl = document.getElementById('ai-confirm-timer'); if (timerEl) timerEl.style.animation = ''; } confirmPending() { this._resolveConfirm(true); } denyPending() { this._resolveConfirm(false); } cancelAi() { this._cancelled = true; this.terminal.print('⏹ Cancelling AI...', 'warning'); // Abort any in-flight HTTP request if (this.terminal.ollamaManager) { this.terminal.ollamaManager.abort(); } // Clear any pending confirmation if (this._confirmResolve) { this._resolveConfirm(false); } // Immediately reset UI so user knows it stopped this.terminal.setAiBusy(false); } isDestructive(name) { return name === 'write_file' || name === 'delete_file' || name === 'run_command' || name === 'make_directory' || name === 'edit_module'; } async runTool(name, argsStr) { let a = {}; try { a = typeof argsStr === 'object' ? argsStr : (argsStr ? JSON.parse(argsStr) : {}); switch (name) { case 'list_files': { const originalPath = a.path || ''; const p = originalPath.replace(/^\//, ''); const saved = [...this.terminal.fs.currentPath]; if (originalPath.startsWith('/')) { this.terminal.fs.currentPath = []; } if (p) { const parts = p.split('/'); const dir = this.terminal.fs.root; let cur = dir; for (const part of parts) { if (part === '..') { saved.pop(); continue; } if (part && cur.content[part] && cur.content[part].type === 'dir') cur = cur.content[part]; else return JSON.stringify({ error: `Directory not found: ${p}` }); } this.terminal.fs.currentPath = saved.concat(parts.filter(x => x !== '..')); } const files = this.terminal.fs.ls(); this.terminal.fs.currentPath = saved; return JSON.stringify(files.map(f => ({ name: f.name, type: f.type, size: f.size }))); } case 'read_file': { const rp = a.path || ''; const savedR = [...this.terminal.fs.currentPath]; if (rp.startsWith('/')) this.terminal.fs.currentPath = []; const path = rp.replace(/^\//, ''); const content = this.terminal.fs.readFile(path); this.terminal.fs.currentPath = savedR; if (content === null) return JSON.stringify({ error: `File not found: ${path}` }); return content.length > 8000 ? content.substring(0, 8000) + '\n...(truncated)' : content; } case 'write_file': { const wp = a.path || ''; const savedW = [...this.terminal.fs.currentPath]; if (wp.startsWith('/')) this.terminal.fs.currentPath = []; const path = wp.replace(/^\//, ''); const content = a.content || ''; this.terminal.fs.writeFile(path, content); this.terminal.fs.currentPath = savedW; return `File written: ${path} (${content.length} chars)`; } case 'make_directory': { const mp = a.path || ''; const savedM = [...this.terminal.fs.currentPath]; if (mp.startsWith('/')) this.terminal.fs.currentPath = []; const path = mp.replace(/^\//, ''); const ok = this.terminal.fs.mkdir(path); this.terminal.fs.currentPath = savedM; if (ok) return `Directory created: ${path}`; return JSON.stringify({ error: `Cannot create: ${path}` }); } case 'delete_file': { const dp = a.path || ''; const savedD = [...this.terminal.fs.currentPath]; if (dp.startsWith('/')) this.terminal.fs.currentPath = []; const path = dp.replace(/^\//, ''); const delOk = this.terminal.fs.deleteFile(path); this.terminal.fs.currentPath = savedD; if (delOk) return `Deleted: ${path}`; return JSON.stringify({ error: `Cannot delete: ${path}` }); } case 'get_status': { const fs = this.terminal.fs; const mm = this.terminal.moduleManager; const om = this.terminal.ollamaManager; return JSON.stringify({ files: fs.ls().length, dirs: fs.currentPath.length ? '/' + fs.currentPath.join('/') : '/', modules: Object.keys(mm.modules).length, ollama: om.connected ? `Connected (${om.currentModel})` : 'Disconnected', memory: performance.memory ? (performance.memory.usedJSHeapSize / 1048576).toFixed(1) + 'MB' : 'N/A' }); } case 'get_help': { const cmds = this.terminal.moduleManager.getAllCommands(); return JSON.stringify(Object.keys(cmds).sort()); } case 'get_current_dir': { return '/' + this.terminal.fs.currentPath.join('/'); } case 'web_search': { const query = a.query || ''; if (!query) return JSON.stringify({ error: 'No query provided' }); try { const resp = await fetch('/api/search?q=' + encodeURIComponent(query)); if (!resp.ok) { return JSON.stringify({ error: 'Search API returned HTTP ' + resp.status }); } const data = await resp.json(); const results = data.results || []; if (results.length === 0) return JSON.stringify({ message: 'No results found' }); return JSON.stringify({ count: results.length, source: data.source, results: results.map(r => ({ title: r.title, url: r.url, content: (r.content || '').substring(0, 300) })) }); } catch (e) { return JSON.stringify({ error: 'Search failed: ' + e.message }); } } case 'web_fetch': { const url = a.url || ''; if (!url) return JSON.stringify({ error: 'No URL provided' }); try { const resp = await fetch('/api/extract?url=' + encodeURIComponent(url)); if (resp.status === 403) return JSON.stringify({ error: 'URL blocked — internal network' }); if (!resp.ok) { return JSON.stringify({ error: 'Fetch API returned HTTP ' + resp.status }); } const data = await resp.json(); return JSON.stringify({ title: data.title || '', content: (data.content || '').substring(0, 4000), word_count: data.word_count || 0, method: data.method || 'extract' }); } catch (e) { return JSON.stringify({ error: 'Fetch failed: ' + e.message }); } } case 'wpm_install': { const pkg = a.package || ''; if (!pkg) return JSON.stringify({ error: 'No package name' }); const mod = this.terminal.moduleManager.modules['WpmModule']; if (mod) { await mod.install(pkg); return `Package "${pkg}" installation attempted`; } return JSON.stringify({ error: 'WPM module not available' }); } case 'wpm_search': { const kw = a.keyword || ''; if (!kw) return JSON.stringify({ error: 'No keyword' }); const mod = this.terminal.moduleManager.modules['WpmModule']; if (mod) { const originalPrint = this.terminal.print.bind(this.terminal); let output = ''; this.terminal.print = (text, type) => { output += text + '\n'; }; try { await mod.search(kw); } finally { this.terminal.print = originalPrint; } return output.trim() || 'Search completed'; } return JSON.stringify({ error: 'WPM module not available' }); } case 'run_command': { const cmd = a.command || ''; if (!cmd) return JSON.stringify({ error: 'No command provided' }); const originalPrint = this.terminal.print.bind(this.terminal); let output = ''; this.terminal.print = (text, type) => { output += text + '\n'; }; try { await this.terminal.dispatchCommand(cmd.split(' ')[0].toLowerCase(), cmd.split(' ').slice(1)); } finally { this.terminal.print = originalPrint; } return output.trim() || '(no output)'; } case 'check_updates': { const reg = this.terminal.moduleManager.moduleRegistry; const results = []; for (const mod of reg) { if (mod.url && mod.url.startsWith('http')) { try { const resp = await fetch(mod.url, { method: 'HEAD' }); results.push({ name: mod.name, url: mod.url, status: resp.ok ? 'reachable' : 'error (' + resp.status + ')' }); } catch (e) { results.push({ name: mod.name, url: mod.url, status: 'unreachable' }); } } } return JSON.stringify({ checked: results.length, modules: results }); } case 'user_get': { const key = a.key || ''; if (!key) return JSON.stringify({ error: 'Key is required' }); const val = key.split('.').reduce((o, k) => (o && typeof o === 'object') ? o[k] : undefined, this._userProfile); return JSON.stringify({ key, value: val !== undefined ? val : null }); } case 'user_set': { const ukey = a.key || ''; if (!ukey) return JSON.stringify({ error: 'Key and value are required' }); const uval = a.value || ''; const keys = ukey.split('.'); let obj = this._userProfile; for (let i = 0; i < keys.length - 1; i++) { if (!obj[keys[i]] || typeof obj[keys[i]] !== 'object') obj[keys[i]] = {}; obj = obj[keys[i]]; } obj[keys[keys.length - 1]] = uval; try { localStorage.setItem('webx11_user_profile', JSON.stringify(this._userProfile)); } catch (e) {} return JSON.stringify({ success: true, key: ukey, value: uval }); } case 'user_list': { return JSON.stringify({ profile: this._userProfile, keys: Object.keys(this._userProfile) }); } case 'user_forget': { const fkey = a.key || ''; if (!fkey) return JSON.stringify({ error: 'Key is required' }); if (fkey.includes('.')) { const parts = fkey.split('.'); let obj = this._userProfile; for (let i = 0; i < parts.length - 1; i++) { if (!obj[parts[i]]) return JSON.stringify({ error: 'Key not found' }); obj = obj[parts[i]]; } delete obj[parts[parts.length - 1]]; } else { delete this._userProfile[fkey]; } try { localStorage.setItem('webx11_user_profile', JSON.stringify(this._userProfile)); } catch (e) {} return JSON.stringify({ success: true, key: fkey }); } case 'session_save': { const summary = a.summary || 'No summary provided'; const fs = this.terminal.fs; fs.mkdirRecursive('/memory'); const today = new Date().toISOString().split('T')[0]; const log = { date: today, summary, toolCallCount: 0, skillsCreated: [], modulesEdited: [], timestamp: new Date().toISOString() }; fs.fsWriteJSON('/memory/' + today + '.json', log); const index = fs.fsReadJSON('/memory/index.json') || {}; index[today] = { summary, tasks: (index[today]?.tasks || 0) + 1, updated: new Date().toISOString() }; fs.fsWriteJSON('/memory/index.json', index); return JSON.stringify({ success: true, date: today }); } case 'session_load': { const sdate = a.date || ''; if (!sdate) return JSON.stringify({ error: 'Date required (YYYY-MM-DD)' }); const sfs = this.terminal.fs; const slog = sfs.fsReadJSON('/memory/' + sdate + '.json'); if (!slog) return JSON.stringify({ error: 'No session log for ' + sdate }); return JSON.stringify(slog); } case 'session_recent': { const count = a.count || 3; const rfs = this.terminal.fs; const rindex = rfs.fsReadJSON('/memory/index.json') || {}; const dates = Object.keys(rindex).sort().reverse().slice(0, count); const sessions = dates.map(d => ({ date: d, ...rindex[d] })); return JSON.stringify({ sessions, count: sessions.length }); } case 'session_terminal': { const tfs = this.terminal.fs; try { const raw = tfs.readFile('_sessions/_auto.json'); if (!raw) return JSON.stringify({ error: 'No auto-saved session found' }); const data = JSON.parse(raw); const lines = (data.terminalLines || []).slice(-50); const text = lines.map(l => { const ts = l.t ? '[' + l.t + '] ' : ''; return ts + l.l; }).join('\n'); return JSON.stringify({ lines: lines.length, output: text, savedAt: data.savedAt || '' }); } catch (e) { return JSON.stringify({ error: 'Could not read terminal history: ' + e.message }); } } case 'session_stats': { const sfs = this.terminal.fs; const sindex = sfs.fsReadJSON('/memory/index.json') || {}; const entries = Object.entries(sindex); let totalTasks = 0; for (const [, meta] of entries) totalTasks += meta.tasks || 0; return JSON.stringify({ totalSessions: entries.length, totalTasks, dates: entries.map(([d]) => d) }); } case 'load_skills': { const query = (a && a.query || '').toLowerCase(); const fs = this.terminal.fs; const index = fs.fsReadJSON('/skills/index.json') || {}; if (!query) { const names = Object.keys(index); return JSON.stringify({ skills: names, count: names.length, message: 'No query provided — showing all skill names. Call again with a query to load content.' }); } const matches = []; for (const [name, meta] of Object.entries(index)) { const score = (name.includes(query) ? 3 : 0) + (meta.description.toLowerCase().includes(query) ? 2 : 0) + ((meta.tags || []).some(t => t.toLowerCase().includes(query)) ? 2 : 0); if (score > 0) { const content = fs.readFile(`/skills/${name}.md`) || ''; matches.push({ name, description: meta.description, category: meta.category, score, content: content.substring(0, 2000) }); } } matches.sort((a, b) => b.score - a.score); const top = matches.slice(0, 3); return JSON.stringify(top.length > 0 ? { matches: top.map(m => ({ name: m.name, description: m.description, content: m.content })), count: top.length } : { matches: [], count: 0, message: 'No matching skills found. You can create one after this task.' }); } case 'create_skill': { const name = (a.name || '').trim().replace(/\s+/g, '-').toLowerCase(); if (!name) return JSON.stringify({ error: 'Skill name is required' }); const description = a.description || ''; let content = a.content || ''; const tags = (a.tags || '').split(',').map(t => t.trim()).filter(Boolean); const category = a.category || 'general'; if (!content.startsWith('---')) { content = `---\nname: ${name}\ndescription: ${description}\ntags: [${tags.join(', ')}]\ncategory: ${category}\n---\n## Steps\n${content}`; } const fs = this.terminal.fs; fs.mkdirRecursive('/skills'); fs.writeFile(`/skills/${name}.md`, content); const index = fs.fsReadJSON('/skills/index.json') || {}; index[name] = { name, description, tags, category, created: index[name]?.created || new Date().toISOString(), updated: new Date().toISOString() }; fs.fsWriteJSON('/skills/index.json', index); this.terminal.print(`💡 Skill saved: ${name}`, 'success'); return JSON.stringify({ success: true, name, message: `Skill "${name}" created (${content.length} chars)` }); } case 'patch_skill': { const pname = (a.name || '').trim(); if (!pname) return JSON.stringify({ error: 'Skill name is required' }); const pcontent = a.content || ''; if (!pcontent) return JSON.stringify({ error: 'Skill content is required' }); const fs = this.terminal.fs; const index = fs.fsReadJSON('/skills/index.json') || {}; if (!index[pname]) return JSON.stringify({ error: `Skill "${pname}" not found` }); fs.writeFile(`/skills/${pname}.md`, pcontent); index[pname].updated = new Date().toISOString(); // Re-parse frontmatter for metadata updates const metaMatch = pcontent.match(/^---\n([\s\S]*?)\n---/); if (metaMatch) { const metaLines = metaMatch[1].split('\n'); metaLines.forEach(line => { const [k, ...v] = line.split(':'); if (k === 'description') index[pname].description = v.join(':').trim(); if (k === 'tags') index[pname].tags = v.join(':').trim().replace(/[\[\]]/g, '').split(',').map(t => t.trim()); if (k === 'category') index[pname].category = v.join(':').trim(); }); } fs.fsWriteJSON('/skills/index.json', index); this.terminal.print(`💡 Skill patched: ${pname}`, 'success'); return JSON.stringify({ success: true, name: pname, message: `Skill "${pname}" updated` }); } case 'list_skills': { const filterCat = (a.category || '').toLowerCase(); const fs = this.terminal.fs; const index = fs.fsReadJSON('/skills/index.json') || {}; const list = Object.entries(index).map(([name, meta]) => ({ name, description: meta.description, category: meta.category || 'general', tags: meta.tags || [], updated: meta.updated })) .filter(s => !filterCat || (s.category || '').toLowerCase() === filterCat); return JSON.stringify({ skills: list, count: list.length }); } case 'view_module': case 'edit_module': case 'test_module': case 'reload_module': case 'list_modified_modules': case 'get_module_status': return await this.runModuleTool(name, argsStr); default: return JSON.stringify({ error: `Unknown tool: ${name}` }); } } catch (e) { this._errorLog.push({ tool: name, args: a, error: e.message, timestamp: Date.now() }); return JSON.stringify({ error: e.message, stack: e.stack?.substring(0, 200) }); } } async runModuleTool(name, argsStr) { let a = {}; try { a = typeof argsStr === 'object' ? argsStr : (argsStr ? JSON.parse(argsStr) : {}); switch (name) { case 'view_module': { const modName = a.name || ''; const entry = this.terminal.moduleManager.moduleRegistry.find(m => m.name === modName); const code = this.terminal.fs.readFile(`_mods/${modName}.js`); if (code) return code; const url = entry ? entry.url : null; if (!url) return JSON.stringify({ error: `No source URL for ${modName}` }); try { const resp = await fetch(url); if (resp.ok) { const src = await resp.text(); this.terminal.fs.writeFile(`_mods/${modName}.orig.js`, src); return src.substring(0, 8000); } return JSON.stringify({ error: `HTTP ${resp.status}` }); } catch (e) { return JSON.stringify({ error: e.message }); } } case 'edit_module': { const modName = a.name || ''; const entry = this.terminal.moduleManager.moduleRegistry.find(m => m.name === modName); const url = entry ? entry.url : null; let code = this.terminal.fs.readFile(`_mods/${modName}.js`); if (!code && url) { try { const resp = await fetch(url); if (resp.ok) { code = await resp.text(); this.terminal.fs.writeFile(`_mods/${modName}.orig.js`, code); this.terminal.fs.writeFile(`_mods/${modName}.js`, code); this.terminal.fs.writeFile(`_mods/${modName}.meta.json`, JSON.stringify({ originalUrl: url, modifiedAt: new Date().toISOString(), editCount: 0 })); } } catch (e) {} } if (code) this.terminal.openCodeEditor(modName, url || '', code); return code ? `Editor opened for ${modName} (${code.length} chars)` : JSON.stringify({ error: `Could not load source for ${modName}` }); } case 'test_module': { const modName = a.name || ''; const code = this.terminal.fs.readFile(`_mods/${modName}.js`); if (!code) return JSON.stringify({ error: `No local edit for ${modName}` }); this.terminal.moduleManager.loadModuleFromCode(code, `blob://_mods/${modName}.js`); return `Module "${modName}" loaded from local edit for testing`; } case 'reload_module': { const modName = a.name || ''; const entry = this.terminal.moduleManager.moduleRegistry.find(m => m.name === modName); this.terminal.fs.deleteFile(`_mods/${modName}.js`); this.terminal.fs.deleteFile(`_mods/${modName}.orig.js`); this.terminal.fs.deleteFile(`_mods/${modName}.meta.json`); if (entry && entry.url) { this.terminal.moduleManager.unloadModule(modName); await this.terminal.moduleManager.loadModuleFromURL(entry.url); return `Module "${modName}" reloaded from ${entry.url}`; } return JSON.stringify({ error: `No original URL for ${modName}` }); } case 'list_modified_modules': { const modsDir = this.terminal.fs.getCurrentDir(); const mc = modsDir.content['_mods']; if (!mc || Object.keys(mc.content).length === 0) return JSON.stringify({ modified: [], message: 'No local edits' }); const files = Object.keys(mc.content).filter(k => k.endsWith('.js') && !k.endsWith('.orig.js')); return JSON.stringify({ modified: files.map(f => f.replace('.js', '')), count: files.length }); } case 'get_module_status': { const mm = this.terminal.moduleManager; const modsDir = this.terminal.fs.getCurrentDir(); const hasMods = modsDir.content['_mods'] ? !!Object.keys(modsDir.content['_mods'].content).length : false; const modules = mm.moduleRegistry.map(m => ({ name: m.name, url: m.url, enabled: m.enabled, loaded: !!mm.modules[m.name], modified: !!this.terminal.fs.readFile(`_mods/${m.name}.js`) })); return JSON.stringify({ modules, total: modules.length, hasLocalEdits: hasMods }); } default: return JSON.stringify({ error: `Unknown module tool: ${name}` }); } } catch (e) { this._errorLog.push({ tool: name, args: a, error: e.message, timestamp: Date.now() }); return JSON.stringify({ error: e.message, stack: e.stack?.substring(0, 200) }); } } clearContext() { this.context = []; localStorage.removeItem('webx11_ai_context'); this.terminal.print('AI conversation context cleared', 'success'); } _saveContext() { try { const data = JSON.stringify({ context: this.context.slice(-20), messageCount: this._messageCount, savedAt: Date.now() }); localStorage.setItem('webx11_ai_context', data); // Also persist to VFS for crash survival try { const fs = this.terminal.fs; if (fs) { fs.mkdirRecursive('_sessions'); fs.writeFile('_sessions/_auto-context.json', data); } } catch (e) {} } catch (e) { // localStorage quota exceeded — silently ignore } } _loadContext() { try { const saved = localStorage.getItem('webx11_ai_context'); if (saved) { const data = JSON.parse(saved); if (data && data.context) { this.context = data.context.slice(-20); this._messageCount = data.messageCount || 0; } } } catch (e) {} } setSystemPrompt(args) { if (!args[0]) { this.terminal.print(`Current system prompt: ${this.systemPrompt.substring(0, 50)}...`, 'info'); return; } this.systemPrompt = args.join(' '); this.terminal.print('System prompt updated', 'success'); } showModel(args) { const om = this.terminal.ollamaManager; if (args.length > 0) { const name = args.join(' '); if (om.models && om.models.some(m => m.name === name)) { om.currentModel = name; localStorage.setItem('webx11_ollama_model', name); this.terminal.print(`AI model set to: ${name}`, 'success'); } else { this.terminal.print(`Model "${name}" not found in available models. Use ai-model to list.`, 'warning'); } return; } this.terminal.print(`Current AI model: ${om.currentModel || 'none'}`, 'info'); if (om.models && om.models.length > 0) { const maxShow = 20; const names = om.models.slice(0, maxShow).map(m => m.name).join(', '); this.terminal.print(`Available (${om.models.length}): ${names}${om.models.length > maxShow ? `... +${om.models.length - maxShow} more` : ''}`, 'info'); } else { this.terminal.print('No models available. Use ollamaconnect first.', 'warning'); } } showContext() { if (this.context.length === 0) { this.terminal.print('No conversation context', 'info'); return; } this.terminal.print(`=== Context (${this.context.length} messages) ===`, 'info'); this.context.forEach(msg => { const icon = msg.role === 'user' ? '👤' : msg.role === 'assistant' ? '🤖' : '🔧'; const content = typeof msg.content === 'string' ? msg.content.substring(0, 60) : JSON.stringify(msg).substring(0, 60); this.terminal.print(`${icon} ${content}...`); }); } _extractFacts(userMsg, aiResp) { const patterns = [ { re: /my name is (\w+)/i, key: 'name' }, { re: /call me (\w+)/i, key: 'name' }, { re: /i(?:'m| am) working on (.+)/i, key: 'project' }, { re: /(?:my|the) project is (.+)/i, key: 'project' }, { re: /i have a server at (.+)/i, key: 'server' }, { re: /i use (\w+).*?(?:editor|ide|text)/i, key: 'preferredEditor' }, { re: /i (?:like|prefer|love) (.+)/i, key: 'preference' }, ]; let changed = false; for (const { re, key } of patterns) { const m = (userMsg + ' ' + (aiResp || '')).match(re); if (m && m[1]) { if (!this._userProfile.knownFacts) this._userProfile.knownFacts = {}; if (this._userProfile.knownFacts[key] !== m[1].trim()) { this._userProfile.knownFacts[key] = m[1].trim(); changed = true; } } } if (changed) { try { localStorage.setItem('webx11_user_profile', JSON.stringify(this._userProfile)); } catch (e) {} } } async _seedDefaultSkills() { const fs = this.terminal.fs; const mindmapSkill = `--- name: mindmap-user-guide description: How to create, view, and manage brainstorming mindmaps using the mindmap terminal module tags: [mindmap, brainstorming, organization, planning] category: productivity --- ## Steps 1. **Create a new mindmap:** - \`mindmap new "" -t tag1,tag2\` — creates a root node - Tags are optional (e.g. planning, research, dev) - Root gets auto-assigned a color 2. **Add child nodes:** - \`mindmap add "" -t tag\` — add a child - Get the parent-id from \`mindmap show\` - IDs are 4-char random strings (e.g. a3f8, x7k2) 3. **View the mindmap:** - \`mindmap show\` — full tree with Unicode box-drawing - \`mindmap show \` — subtree starting at that node 4. **Edit nodes:** - \`mindmap rename ""\` — change text - \`mindmap color \` — set color (red/green/yellow/blue/cyan/magenta/white) - \`mindmap tag \` — add a tag 5. **Persistence:** - \`mindmap save \` — save to localStorage - \`mindmap load \` — restore - \`mindmap list\` — show saved mindmaps - \`mindmap delete \` — remove saved 6. **Export:** - \`mindmap export [id]\` — Markdown bullet list output ## When to use - User wants to brainstorm, organize ideas, plan features - User says "map out", "diagram", "brainstorm", "organize thoughts" - Visualizing project structure or task decomposition`; fs.writeFile('/skills/mindmap-user-guide.md', mindmapSkill); const existingIndex = fs.fsReadJSON('/skills/index.json') || {}; existingIndex['mindmap-user-guide'] = { name: 'mindmap-user-guide', description: 'How to create, view, and manage brainstorming mindmaps using the mindmap terminal module', tags: ['mindmap', 'brainstorming', 'organization', 'planning'], category: 'productivity', created: existingIndex['mindmap-user-guide']?.created || new Date().toISOString(), updated: new Date().toISOString() }; fs.fsWriteJSON('/skills/index.json', existingIndex); fs.writeFile('/skills/_seeded', '1'); } _trackPattern(userMessage) { const lower = userMessage.toLowerCase(); const patterns = ['font size','bigger text','smaller text','export','backup','save','install','load module','search','find','color','theme','skill','learn','remember','mindmap','brainstorm']; for (const p of patterns) { if (lower.includes(p)) this._commandFreq[p] = (this._commandFreq[p] || 0) + 1; } try { localStorage.setItem('webx11_ai_patterns', JSON.stringify(this._commandFreq)); } catch (e) {} } async _autoCreateErrorSkill() { const grouped = {}; for (const e of this._errorLog) { if (!grouped[e.tool]) grouped[e.tool] = []; grouped[e.tool].push(e); } for (const [tool, errors] of Object.entries(grouped)) { if (errors.length >= 3) { const skillName = 'tool-' + tool + '-workaround'; const existing = this.terminal.fs.readFile('/skills/' + skillName + '.md'); if (existing) continue; const steps = errors.map((e, i) => (i + 1) + '. When calling ' + tool + ', avoid: "' + JSON.stringify(e.args) + '" which caused: ' + e.error).join('\n'); const content = '---\nname: ' + skillName + '\ndescription: Workarounds for ' + tool + ' failures\ntags: [' + tool + ', error, workaround]\ncategory: system\n---\n## Steps\n' + steps; await this.runTool('create_skill', { name: skillName, description: 'Workarounds for ' + tool + ' failures', content: content, tags: tool + ',error,workaround', category: 'system' }); this.terminal.print('🤖 Auto-created skill from repeated errors: ' + skillName, 'info'); } } this._errorLog = []; } async _auditSkills() { const fs = this.terminal.fs; const index = fs.fsReadJSON('/skills/index.json') || {}; const now = Date.now(); const issues = []; for (const [name, meta] of Object.entries(index)) { const content = fs.readFile('/skills/' + name + '.md'); if (!content || content.length < 50) { issues.push({ name, issue: 'empty or too short' }); continue; } const updated = new Date(meta.updated || 0).getTime(); const ageDays = (now - updated) / 86400000; if (ageDays > 30) issues.push({ name, issue: 'not updated in ' + Math.round(ageDays) + ' days' }); } if (issues.length > 0) { this.terminal.print('📋 Skill audit: ' + issues.length + ' issue(s) found', 'info'); issues.slice(0, 3).forEach(i => this.terminal.print(' - ' + i.name + ': ' + i.issue, 'warning')); } } _estimateTokens(text) { if (!text || typeof text !== 'string') return 0; return Math.ceil(text.length / 4); } _estimateContextTokens() { let total = 0; for (const msg of this.context) { total += this._estimateTokens(msg.content || ''); } return total; } async _compressContext() { if (this.context.length <= 6) return; const totalTokens = this._estimateContextTokens(); if (totalTokens < this.maxContextTokens) return; const keepCount = 3; const oldMsgs = this.context.slice(0, -keepCount * 2); if (oldMsgs.length < 2) return; const recentMsgs = this.context.slice(-keepCount * 2); const summaryText = oldMsgs.map(m => (m.role === 'user' ? '👤' : m.role === 'assistant' ? '🤖' : '⚙️') + ': ' + (m.content || '').substring(0, 150) ).join(' | '); let compressed = `[Earlier context (${oldMsgs.length} messages): ${summaryText}]`; // Try AI summarization, fallback to truncation try { if (this.terminal.ollamaManager && this.terminal.ollamaManager.connected) { const sumPrompt = 'Summarize these conversation exchanges into a single compact sentence. Focus on what the user asked and what actions were taken. Keep it under 200 characters.\n\n' + JSON.stringify(oldMsgs.map(m => ({ role: m.role, content: (m.content || '').substring(0, 200) }))); const sumRes = await this.terminal.ollamaManager.chat(sumPrompt); if (sumRes && sumRes.length < 300) { compressed = '[Earlier context: ' + sumRes.trim() + ']'; } } } catch (e) { /* fallback to truncation */ } this.context = [{ role: 'system', content: compressed }, ...recentMsgs]; this.terminal.print('📦 Context compressed (' + oldMsgs.length + ' messages → 1 summary, ~' + totalTokens + ' tokens)', 'info'); } _manualCompress() { this._compressContext().then(() => { this.terminal.print('Context: ' + this.context.length + ' message(s), ~' + this._estimateContextTokens() + ' estimated tokens', 'info'); }).catch(e => { this.terminal.print('Compression error: ' + e.message, 'error'); }); } }