aiden-runtime 3.16.0

package/dist/core/executionLoop.js

@@ -0,0 +1,309 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGoalLoop = runGoalLoop;
+// core/executionLoop.ts — Outer goal-level execution loop.
+// Plans → Executes → Replans → Reports to EvolutionAnalyzer.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const executor_1 = require("./executor");
+const truthCheck_1 = require("./truthCheck");
+const faultEngine_1 = require("./faultEngine");
+const memoryLayers_1 = require("../memory/memoryLayers");
+const evolutionAnalyzer_1 = require("./evolutionAnalyzer");
+const livePulse_1 = require("../coordination/livePulse");
+// ── Payload parser ────────────────────────────────────────────
+function parsePayload(skill, command) {
+    // Try JSON first (for compound payloads like file_write)
+    try {
+        return JSON.parse(command);
+    }
+    catch { }
+    // Skill-specific scalar mappings
+    switch (skill) {
+        case 'open_browser': return { url: command };
+        case 'web_search': return { query: command };
+        case 'shell_exec': return { command };
+        case 'run_powershell': return { script: command };
+        case 'file_read': return { path: command };
+        case 'file_list': return { path: command };
+        case 'system_info': return {};
+        case 'notify': return { message: command };
+        default: return { command };
+    }
+}
+// ── Planner ───────────────────────────────────────────────────
+async function generatePlan(goal, goalId) {
+    livePulse_1.livePulse.thinking('CEO', `Planning: ${goal}`);
+    const lower = goal.toLowerCase();
+    // ── Direct tool mapping — no LLM needed for common patterns ──
+    const urlMatch = goal.match(/https?:\/\/[^\s]+/) ||
+        goal.match(/([a-zA-Z0-9-]+\.(com|org|net|io|dev|co|uk))/i);
+    if (urlMatch && /open|go to|browse|show|navigate|launch/.test(lower)) {
+        const url = urlMatch[0].startsWith('http') ? urlMatch[0] : `https://${urlMatch[0]}`;
+        return {
+            goalId, goal, complete: false,
+            steps: [{ id: 'step_0', skill: 'open_browser', description: `Open ${url}`, command: url, status: 'pending' }],
+        };
+    }
+    if (/system info|my pc|computer specs|my ram|my cpu|disk space/i.test(lower)) {
+        return {
+            goalId, goal, complete: false,
+            steps: [{ id: 'step_0', skill: 'system_info', description: 'Get system info', command: '', status: 'pending' }],
+        };
+    }
+    if (/(create|write|make).+(file|txt|py|js|html|md)/i.test(lower)) {
+        const nameMatch = goal.match(/called?\s+["']?([^\s"',]+\.?\w*)["']?/i);
+        const fileName = nameMatch?.[1] || 'devos-file.txt';
+        const contentMatch = goal.match(/(?:with|containing|content)[:\s]+["']?(.+?)["']?$/i);
+        const content = contentMatch?.[1] || `Created by DevOS on ${new Date().toLocaleDateString()}`;
+        const desktopPath = path.join(os.homedir(), 'Desktop', fileName);
+        return {
+            goalId, goal, complete: false,
+            steps: [{
+                    id: 'step_0', skill: 'file_write',
+                    description: `Create ${fileName} on Desktop`,
+                    command: JSON.stringify({ path: desktopPath, content }),
+                    status: 'pending',
+                }],
+        };
+    }
+    if (/^(search|find|look up|search for|find me)/i.test(lower)) {
+        const query = goal.replace(/^(search|find|look up|search for|find me)/i, '').trim();
+        return {
+            goalId, goal, complete: false,
+            steps: [{ id: 'step_0', skill: 'web_search', description: `Search: ${query}`, command: query, status: 'pending' }],
+        };
+    }
+    if (/notify|notification|alert/i.test(lower)) {
+        const msg = goal.replace(/^(notify|send notification|alert|send alert)[:\s]*/i, '').trim();
+        return {
+            goalId, goal, complete: false,
+            steps: [{ id: 'step_0', skill: 'notify', description: `Notify: ${msg}`, command: JSON.stringify({ message: msg }), status: 'pending' }],
+        };
+    }
+    // ── LLM planning for complex tasks (tries Groq first, then Ollama) ──
+    try {
+        const { loadConfig } = await Promise.resolve().then(() => __importStar(require('../providers/index')));
+        const config = loadConfig();
+        const api = config.providers.apis.find((a) => a.enabled && !a.rateLimited && a.provider === 'groq');
+        if (api) {
+            const prompt = `Plan this task on Windows: "${goal}"
+Respond ONLY with JSON (no markdown):
+{"steps":[{"skill":"open_browser","description":"what this does","command":"https://example.com"}]}
+Skills: open_browser(command=url), file_write(command=json{path,content}), shell_exec(command=powershell), web_search(command=query), run_python(command=json{script}), system_info(command=""), notify(command=json{message})
+Max 3 steps.`;
+            const r = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${api.key}` },
+                body: JSON.stringify({
+                    model: api.model || 'llama-3.3-70b-versatile',
+                    messages: [{ role: 'user', content: prompt }],
+                    max_tokens: 300,
+                }),
+                signal: AbortSignal.timeout(10000),
+            });
+            const d = await r.json();
+            const raw = d?.choices?.[0]?.message?.content || '';
+            const parsed = JSON.parse(raw.replace(/```json|```/g, '').trim());
+            if (parsed.steps?.length) {
+                return {
+                    goalId, goal, complete: false,
+                    steps: parsed.steps.map((s, i) => ({
+                        id: `step_${i}`, skill: s.skill, description: s.description, command: s.command, status: 'pending',
+                    })),
+                };
+            }
+        }
+    }
+    catch { /* fall through to Ollama */ }
+    // ── Ollama fallback ───────────────────────────────────────────
+    try {
+        let ollamaModel = 'mistral:7b';
+        try {
+            const cfg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'config/model-selection.json'), 'utf-8'));
+            ollamaModel = cfg.reasoning || cfg.chat || ollamaModel;
+        }
+        catch { }
+        const res = await fetch('http://localhost:11434/api/chat', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: ollamaModel,
+                stream: false,
+                messages: [{ role: 'user', content: `Plan this Windows task in JSON only (no markdown): "${goal}"\n{"steps":[{"skill":"shell_exec","description":"step","command":"command"}]}` }],
+            }),
+        });
+        const data = await res.json();
+        const raw = data?.message?.content || '';
+        const parsed = JSON.parse(raw.replace(/```json|```/g, '').trim());
+        if (parsed.steps?.length) {
+            return {
+                goalId, goal, complete: false,
+                steps: parsed.steps.map((s, i) => ({
+                    id: `step_${i}`, skill: s.skill, description: s.description, command: s.command, status: 'pending',
+                })),
+            };
+        }
+    }
+    catch { }
+    // Last resort
+    return {
+        goalId, goal, complete: false,
+        steps: [{ id: 'step_0', skill: 'notify', description: 'Could not plan', command: JSON.stringify({ message: `Could not plan: ${goal.slice(0, 40)}` }), status: 'pending' }],
+    };
+}
+// ── Replanner ─────────────────────────────────────────────────
+async function replan(plan, _lastResult) {
+    const remaining = plan.steps.filter(s => s.status === 'pending');
+    // If nothing left, mark complete
+    if (!remaining.length)
+        return { ...plan, complete: true };
+    // Otherwise keep going with remaining steps
+    return plan;
+}
+// ── Main execution loop ───────────────────────────────────────
+async function runGoalLoop(goal) {
+    const goalId = `goal_${Date.now()}`;
+    const startTime = Date.now();
+    const report = {
+        goalId, goal, success: false, totalDuration: 0,
+        steps: [], timestamp: startTime,
+    };
+    livePulse_1.livePulse.act('CEO', `Starting goal: ${goal}`);
+    let plan = await generatePlan(goal, goalId);
+    let iterations = 0;
+    const MAX_ITER = 10;
+    while (!plan.complete && iterations < MAX_ITER) {
+        iterations++;
+        const nextStep = plan.steps.find(s => s.status === 'pending');
+        if (!nextStep) {
+            plan.complete = true;
+            break;
+        }
+        nextStep.status = 'running';
+        // Emit thinking before we run — lets UI show "planning this step"
+        livePulse_1.livePulse.thinking('CEO', `Next: ${nextStep.description}`);
+        // Emit tool event so UI knows exactly what will run
+        livePulse_1.livePulse.tool('Engineer', nextStep.skill, nextStep.command);
+        const stepStart = Date.now();
+        let stepResult;
+        let stepSuccess = false;
+        let stepError;
+        try {
+            const stepPayload = parsePayload(nextStep.skill, nextStep.command);
+            const execResult = await executor_1.executor.execute({
+                id: nextStep.id,
+                type: nextStep.skill,
+                confidence: 0.9,
+                description: nextStep.description,
+                payload: stepPayload,
+                retries: 1,
+                timeoutMs: 30000,
+            });
+            stepResult = execResult;
+            stepSuccess = execResult.status === 'success' || execResult.status === 'retried';
+            if (stepSuccess) {
+                // Verify with TruthCheck (uses actual signature)
+                const verified = await truthCheck_1.truthCheck.verifyAction(nextStep.skill, { expected: nextStep.description, actual: execResult });
+                if (verified) {
+                    nextStep.status = 'done';
+                    nextStep.result = execResult;
+                    const toolOutput = typeof execResult.data === 'string'
+                        ? execResult.data.slice(0, 120)
+                        : undefined;
+                    // Emit tool event with output so UI can show result
+                    livePulse_1.livePulse.tool('Engineer', nextStep.skill, nextStep.command, toolOutput);
+                    livePulse_1.livePulse.done('Engineer', `${nextStep.description}${toolOutput ? ` → ${toolOutput}` : ''}`);
+                }
+                else {
+                    stepSuccess = false;
+                    stepError = 'TruthCheck failed';
+                    // Log fault classification for diagnostics
+                    faultEngine_1.faultEngine.classify(stepError);
+                    nextStep.status = 'failed';
+                    livePulse_1.livePulse.error('Engineer', `${nextStep.description}: TruthCheck failed`);
+                }
+            }
+            else {
+                nextStep.status = 'failed';
+                stepError = execResult.error?.message;
+                livePulse_1.livePulse.error('Engineer', `${nextStep.description}: ${stepError}`);
+            }
+        }
+        catch (err) {
+            nextStep.status = 'failed';
+            stepError = err.message;
+            stepSuccess = false;
+            livePulse_1.livePulse.error('Engineer', `${nextStep.skill} threw: ${err.message}`);
+        }
+        // Record step in evolution report
+        report.steps.push({
+            skill: nextStep.skill,
+            success: stepSuccess,
+            duration: Date.now() - stepStart,
+            error: stepError,
+        });
+        // Store result in memory (sync — await is a no-op on void)
+        memoryLayers_1.memoryLayers.write(`Goal ${goalId} step ${nextStep.id}: ${nextStep.description} → ${stepSuccess ? 'success' : 'failed'}`, ['goal', 'execution', nextStep.skill]);
+        // Replan after each successful step
+        if (stepSuccess) {
+            plan = await replan(plan, stepResult);
+        }
+        // Stop if too many failures
+        const failures = plan.steps.filter(s => s.status === 'failed').length;
+        if (failures >= 3) {
+            livePulse_1.livePulse.error('CEO', 'Too many failures — stopping goal');
+            break;
+        }
+    }
+    // Finalise report
+    const successSteps = report.steps.filter(s => s.success).length;
+    report.success = successSteps > 0 && successSteps >= report.steps.length * 0.6;
+    report.totalDuration = Date.now() - startTime;
+    // Send to evolution analyzer
+    evolutionAnalyzer_1.evolutionAnalyzer.collect(report);
+    const summary = report.success
+        ? `Goal complete in ${Math.round(report.totalDuration / 1000)}s — ${successSteps}/${report.steps.length} steps succeeded`
+        : `Goal incomplete — ${successSteps}/${report.steps.length} steps succeeded`;
+    livePulse_1.livePulse.done('CEO', summary);
+    memoryLayers_1.memoryLayers.write(`Goal complete: ${goal} → ${summary}`, ['goal', 'complete']);
+    return { success: report.success, summary };
+}

package/dist/core/executor.js

@@ -0,0 +1,224 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executor = void 0;
+const screenAgent_1 = require("../integrations/computerUse/screenAgent");
+const apiRegistry_1 = require("../integrations/computerUse/apiRegistry");
+const faultEngine_1 = require("./faultEngine");
+const truthCheck_1 = require("./truthCheck");
+const memoryLayers_1 = require("../memory/memoryLayers");
+const toolRegistry_1 = require("./toolRegistry");
+// ── Executor ──────────────────────────────────────────────────
+class Executor {
+    constructor() {
+        /** Exposed as a getter so the API route can read live progress. */
+        this.currentSession = null;
+    }
+    // ── Session management ────────────────────────────────────────
+    startSession(goal) {
+        const sessionId = `exec_${Date.now()}`;
+        this.currentSession = {
+            sessionId,
+            goal,
+            startedAt: new Date().toISOString(),
+            results: [],
+            totalDurationMs: 0,
+            successRate: 0,
+        };
+        return sessionId;
+    }
+    endSession() {
+        if (!this.currentSession)
+            return null;
+        const s = this.currentSession;
+        s.totalDurationMs = s.results.reduce((acc, r) => acc + r.durationMs, 0);
+        const successes = s.results.filter(r => r.status === 'success' || r.status === 'fallback' || r.status === 'retried').length;
+        s.successRate = s.results.length ? successes / s.results.length : 0;
+        this.currentSession = null;
+        return s;
+    }
+    // ── Main execute ──────────────────────────────────────────────
+    /**
+     * Execute a single ComputerUseAction with:
+     *   - configurable retry loop with exponential backoff
+     *   - timeout wrapper per attempt
+     *   - TruthCheck verification on success
+     *   - FaultEngine error classification on failure
+     *   - fallback action when all retries exhausted
+     */
+    async execute(action) {
+        const start = Date.now();
+        let retriesUsed = 0;
+        let usedFallback = false;
+        let verifiedByTruthCheck = false;
+        const maxRetries = action.retries ?? 2;
+        const timeoutMs = action.timeoutMs ?? 15000;
+        // ── Retry loop ────────────────────────────────────────────
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                // Per-attempt timeout
+                const data = await Promise.race([
+                    this.route(action),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeoutMs)),
+                ]);
+                // TruthCheck verification
+                verifiedByTruthCheck = await truthCheck_1.truthCheck.verifyAction(action.type, { actionId: action.id });
+                const result = {
+                    actionId: action.id,
+                    status: retriesUsed > 0 ? 'retried' : 'success',
+                    data,
+                    durationMs: Date.now() - start,
+                    retriesUsed,
+                    usedFallback,
+                    verifiedByTruthCheck,
+                };
+                await this.audit(action, result);
+                this.currentSession?.results.push(result);
+                return result;
+            }
+            catch (err) {
+                const classified = this.classifyError(err);
+                // Retry if retryable and attempts remain
+                if (classified.retryable && attempt < maxRetries) {
+                    retriesUsed++;
+                    console.warn(`[Executor] Retry ${retriesUsed}/${maxRetries} for action ${action.id} — ${classified.message}`);
+                    await new Promise(r => setTimeout(r, 800 * retriesUsed)); // linear backoff
+                    continue;
+                }
+                // Attempt fallback action
+                if (action.fallback && !usedFallback) {
+                    usedFallback = true;
+                    console.warn(`[Executor] Running fallback for action ${action.id}`);
+                    try {
+                        const fallbackData = await this.route(action.fallback);
+                        const result = {
+                            actionId: action.id,
+                            status: 'fallback',
+                            data: fallbackData,
+                            durationMs: Date.now() - start,
+                            retriesUsed,
+                            usedFallback: true,
+                            verifiedByTruthCheck: false,
+                        };
+                        await this.audit(action, result);
+                        this.currentSession?.results.push(result);
+                        return result;
+                    }
+                    catch {
+                        // Fallback also failed — fall through to fail result
+                    }
+                }
+                // All attempts and fallback exhausted
+                const result = {
+                    actionId: action.id,
+                    status: 'failed',
+                    error: classified,
+                    durationMs: Date.now() - start,
+                    retriesUsed,
+                    usedFallback,
+                    verifiedByTruthCheck,
+                };
+                await this.audit(action, result);
+                this.currentSession?.results.push(result);
+                return result;
+            }
+        }
+        // Should never be reached
+        return {
+            actionId: action.id,
+            status: 'skipped',
+            durationMs: Date.now() - start,
+            retriesUsed: 0,
+            usedFallback: false,
+            verifiedByTruthCheck: false,
+        };
+    }
+    // ── Smart routing ─────────────────────────────────────────────
+    async route(action) {
+        switch (action.type) {
+            case 'api_call': {
+                const a = action;
+                const { result } = await apiRegistry_1.apiRegistry.execute(a.service, {
+                    endpoint: a.endpoint,
+                    method: a.method,
+                    payload: a.payload,
+                    headers: a.headers,
+                });
+                return result;
+            }
+            case 'click':
+            case 'type':
+            case 'scroll':
+            case 'keypress':
+            case 'screenshot':
+                return screenAgent_1.screenAgent.execute(action);
+            default: {
+                // Real tool execution via centralized toolRegistry
+                const a = action;
+                const payload = a.payload || { command: a.command || a.description };
+                const result = await (0, toolRegistry_1.executeTool)(a.type, payload);
+                if (!result.success)
+                    throw new Error(result.error || 'Tool execution failed');
+                return result.output;
+            }
+        }
+    }
+    // ── Error classification ──────────────────────────────────────
+    /**
+     * Map a raw error to a typed ExecutorError.
+     * Uses FaultEngine for the repair suggestion, then performs pattern
+     * matching on the message to determine ExecutorErrorType.
+     */
+    classifyError(err) {
+        const msg = err?.message ?? String(err);
+        // FaultEngine for repair suggestion (sync call)
+        let repairSuggestion;
+        try {
+            const fault = faultEngine_1.faultEngine.classify(msg);
+            repairSuggestion = fault.repairCommand ?? fault.manualFix;
+        }
+        catch { /* non-fatal */ }
+        let type = 'UNKNOWN';
+        let retryable = true;
+        if (msg.includes('timeout')) {
+            type = 'TIMEOUT';
+            retryable = true;
+        }
+        else if (/API|fetch|ECONNREFUSED|ENOTFOUND/i.test(msg)) {
+            type = 'API_ERROR';
+            retryable = true;
+        }
+        else if (/selector|element|visible/i.test(msg)) {
+            type = 'UI_ERROR';
+            retryable = true;
+        }
+        else if (/screen|mouse|keyboard/i.test(msg)) {
+            type = 'SCREEN_ERROR';
+            retryable = true;
+        }
+        else if (/Rejected by|CommandGate/i.test(msg)) {
+            type = 'REJECTED_BY_USER';
+            retryable = false;
+        }
+        else if (/confidence/i.test(msg)) {
+            type = 'CONFIDENCE_TOO_LOW';
+            retryable = false;
+        }
+        else if (/Unknown action/i.test(msg)) {
+            type = 'VALIDATION_ERROR';
+            retryable = false;
+        }
+        return { type, message: msg, retryable, repairSuggestion };
+    }
+    // ── Audit ─────────────────────────────────────────────────────
+    async audit(action, result) {
+        const entry = `[${new Date().toISOString()}] ${action.type} → ${result.status}` +
+            ` (${result.durationMs}ms, retries:${result.retriesUsed})` +
+            (result.error ? ` | ERROR: ${result.error.message}` : '');
+        memoryLayers_1.memoryLayers.write(entry, ['computer_use', 'audit', result.status]);
+    }
+}
+exports.executor = new Executor();