aiden-runtime 3.16.0

package/dist/core/aidenSdk.js

@@ -0,0 +1,374 @@
+"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.getSdkMethods = getSdkMethods;
+exports.getSdkNamespaces = getSdkNamespaces;
+exports.buildSdkRuntime = buildSdkRuntime;
+exports.buildSdkSurface = buildSdkSurface;
+// core/aidenSdk.ts — Generates the Aiden SDK surface injected into
+// the run-sandbox. Each registered tool becomes a typed function on
+// the `aiden` namespace object. The LLM writes code against this
+// surface instead of raw tool names.
+//
+// Namespace mapping:
+//   aiden.web.*     → web_search, deep_research, fetch_url, fetch_page, social_research
+//   aiden.file.*    → file_read, file_write, file_list
+//   aiden.shell.*   → shell_exec, run_python, run_node, run_powershell
+//   aiden.browser.* → open_browser, browser_click, browser_type, browser_extract, browser_screenshot
+//   aiden.screen.*  → screenshot, mouse_move, mouse_click, keyboard_type, keyboard_press, screen_read
+//   aiden.memory.*  → recall (memory_show), remember (via conversationMemory)
+//   aiden.lessons.* → check (lessons)
+//   aiden.system.*  → notify, system_info, clipboard_read, clipboard_write
+//   aiden.git.*     → git_status, git_commit, git_push
+//   aiden.data.*    → get_market_data, get_company_info, get_stocks, get_briefing, get_calendar
+//   aiden.*         → top-level: run_agent, respond
+const toolRegistry_1 = require("./toolRegistry");
+const mcpClient_1 = require("./mcpClient");
+const TOOL_SDK_MAP = [
+    // web
+    { toolName: 'web_search', namespace: 'web', method: 'search', description: 'Search the web', signature: '(query: string) => Promise<any[]>' },
+    { toolName: 'deep_research', namespace: 'web', method: 'research', description: 'In-depth research on a topic', signature: '(topic: string) => Promise<string>' },
+    { toolName: 'fetch_url', namespace: 'web', method: 'fetch', description: 'Fetch URL content', signature: '(url: string) => Promise<string>' },
+    { toolName: 'fetch_page', namespace: 'web', method: 'page', description: 'Full page content extraction', signature: '(url: string) => Promise<string>' },
+    { toolName: 'social_research', namespace: 'web', method: 'social', description: 'Social media research', signature: '(query: string) => Promise<any>' },
+    { toolName: 'ingest_youtube', namespace: 'web', method: 'youtube', description: 'Get YouTube transcript', signature: '(url: string) => Promise<string>' },
+    // file
+    { toolName: 'file_read', namespace: 'file', method: 'read', description: 'Read a file', signature: '(path: string) => Promise<string>' },
+    { toolName: 'file_write', namespace: 'file', method: 'write', description: 'Write a file', signature: '(path: string, content: string) => Promise<void>' },
+    { toolName: 'file_list', namespace: 'file', method: 'list', description: 'List directory contents', signature: '(dir: string) => Promise<string[]>' },
+    // shell
+    { toolName: 'shell_exec', namespace: 'shell', method: 'exec', description: 'Run a shell command', signature: '(command: string) => Promise<{stdout:string,stderr:string,exitCode:number}>' },
+    { toolName: 'run_python', namespace: 'shell', method: 'python', description: 'Execute Python code', signature: '(script: string) => Promise<string>' },
+    { toolName: 'run_node', namespace: 'shell', method: 'node', description: 'Execute Node.js code', signature: '(script: string) => Promise<string>' },
+    { toolName: 'run_powershell', namespace: 'shell', method: 'powershell', description: 'Execute PowerShell', signature: '(script: string) => Promise<string>' },
+    { toolName: 'cmd', namespace: 'shell', method: 'cmd', description: 'Run cmd.exe command', signature: '(command: string, options?: any) => Promise<{stdout:string,stderr:string,exitCode:number}>' },
+    { toolName: 'ps', namespace: 'shell', method: 'ps', description: 'Run PowerShell directly', signature: '(command: string, options?: any) => Promise<{stdout:string,stderr:string,exitCode:number}>' },
+    { toolName: 'wsl', namespace: 'shell', method: 'wsl', description: 'Run bash command in WSL', signature: '(command: string, options?: any) => Promise<{stdout:string,stderr:string,exitCode:number}>' },
+    // browser
+    { toolName: 'open_browser', namespace: 'browser', method: 'open', description: 'Open a URL in the browser', signature: '(url: string) => Promise<void>' },
+    { toolName: 'browser_click', namespace: 'browser', method: 'click', description: 'Click an element', signature: '(selector: string) => Promise<void>' },
+    { toolName: 'browser_type', namespace: 'browser', method: 'type', description: 'Type text into an element', signature: '(selector: string, text: string) => Promise<void>' },
+    { toolName: 'browser_extract', namespace: 'browser', method: 'extract', description: 'Extract content from page', signature: '(selector?: string) => Promise<string>' },
+    { toolName: 'browser_screenshot', namespace: 'browser', method: 'screenshot', description: 'Take a browser screenshot', signature: '() => Promise<string>' },
+    // screen
+    { toolName: 'screenshot', namespace: 'screen', method: 'capture', description: 'Capture desktop screenshot', signature: '() => Promise<string>' },
+    { toolName: 'mouse_move', namespace: 'screen', method: 'mouseMov', description: 'Move mouse to coordinates', signature: '(x: number, y: number) => Promise<void>' },
+    { toolName: 'mouse_click', namespace: 'screen', method: 'mouseClick', description: 'Click at coordinates', signature: '(x: number, y: number) => Promise<void>' },
+    { toolName: 'keyboard_type', namespace: 'screen', method: 'type', description: 'Type text via keyboard', signature: '(text: string) => Promise<void>' },
+    { toolName: 'keyboard_press', namespace: 'screen', method: 'press', description: 'Press a key combination', signature: '(key: string) => Promise<void>' },
+    { toolName: 'screen_read', namespace: 'screen', method: 'read', description: 'Read text from screen', signature: '() => Promise<string>' },
+    { toolName: 'vision_loop', namespace: 'screen', method: 'vision', description: 'Agentic vision control loop', signature: '(goal: string, maxSteps?: number) => Promise<string>' },
+    // memory
+    { toolName: 'memory_show', namespace: 'memory', method: 'recall', description: 'Recall from memory', signature: '(query: string) => Promise<string>' },
+    // system
+    { toolName: 'notify', namespace: 'system', method: 'notify', description: 'Send a system notification', signature: '(message: string, title?: string) => Promise<void>' },
+    { toolName: 'system_info', namespace: 'system', method: 'info', description: 'Get system information', signature: '() => Promise<any>' },
+    { toolName: 'clipboard_read', namespace: 'system', method: 'clipboardRead', description: 'Read clipboard content', signature: '() => Promise<string>' },
+    { toolName: 'clipboard_write', namespace: 'system', method: 'clipboardWrite', description: 'Write to clipboard', signature: '(text: string) => Promise<void>' },
+    { toolName: 'wait', namespace: 'system', method: 'wait', description: 'Wait for N milliseconds', signature: '(ms: number) => Promise<void>' },
+    // git
+    { toolName: 'git_status', namespace: 'git', method: 'status', description: 'Git status and recent commits', signature: '(path?: string) => Promise<string>' },
+    { toolName: 'git_commit', namespace: 'git', method: 'commit', description: 'Stage all and commit', signature: '(message: string) => Promise<string>' },
+    { toolName: 'git_push', namespace: 'git', method: 'push', description: 'Push to remote', signature: '(remote?: string, branch?: string) => Promise<string>' },
+    // data
+    { toolName: 'get_market_data', namespace: 'data', method: 'market', description: 'Real-time stock/market data', signature: '(symbol: string) => Promise<any>' },
+    { toolName: 'get_company_info', namespace: 'data', method: 'company', description: 'Company profile and financials', signature: '(symbol: string) => Promise<any>' },
+    { toolName: 'get_stocks', namespace: 'data', method: 'stocks', description: 'Market movers (gainers/losers)', signature: '(market: string, type: string) => Promise<any[]>' },
+    { toolName: 'get_briefing', namespace: 'data', method: 'briefing', description: 'Daily news and market briefing', signature: '() => Promise<string>' },
+    { toolName: 'get_calendar', namespace: 'data', method: 'calendar', description: 'Calendar events', signature: '(daysAhead?: number) => Promise<any[]>' },
+    { toolName: 'read_email', namespace: 'data', method: 'email', description: 'Read recent emails', signature: '(limit?: number) => Promise<any[]>' },
+    // voice
+    { toolName: 'voice_speak', namespace: 'voice', method: 'speak', description: 'Speak text via TTS provider chain', signature: '(text: string, opts?: {voice?:string,provider?:string,rate?:number,volume?:number}) => Promise<{provider:string,durationMs:number}>' },
+    { toolName: 'voice_transcribe', namespace: 'voice', method: 'transcribe', description: 'Transcribe audio file to text', signature: '(audioFilePath: string, language?: string) => Promise<{text:string,provider:string,durationMs:number}>' },
+    { toolName: 'voice_clone', namespace: 'voice', method: 'clone', description: 'Clone a voice and speak text', signature: '(text: string, referenceAudioPath: string) => Promise<{provider:string,durationMs:number}>' },
+    { toolName: 'voice_design', namespace: 'voice', method: 'design', description: 'Design a voice from description', signature: '(text: string, voiceDescription: string) => Promise<{provider:string,durationMs:number}>' },
+    { toolName: 'voice_record', namespace: 'voice', method: 'record', description: 'Record audio from microphone', signature: '(durationSeconds?: number, outputPath?: string) => Promise<string>' },
+    { toolName: 'voice_play', namespace: 'voice', method: 'play', description: 'Play an audio file', signature: '(audioSource: string) => Promise<void>' },
+    // todo
+    { toolName: 'todo', namespace: 'todo', method: 'add', description: 'Add a todo item', signature: '(text: string, priority?: string) => Promise<string>' },
+    { toolName: 'todo', namespace: 'todo', method: 'complete', description: 'Mark a todo item done', signature: '(id: string) => Promise<string>' },
+    { toolName: 'todo', namespace: 'todo', method: 'remove', description: 'Remove a todo item', signature: '(id: string) => Promise<string>' },
+    { toolName: 'todo', namespace: 'todo', method: 'list', description: 'List todo items', signature: '(filter?: string) => Promise<string>' },
+    { toolName: 'todo', namespace: 'todo', method: 'clear', description: 'Clear all todos', signature: '() => Promise<string>' },
+    // cron
+    { toolName: 'cronjob', namespace: 'cron', method: 'create', description: 'Create a scheduled job', signature: '(description: string, schedule: string, action: string) => Promise<string>' },
+    { toolName: 'cronjob', namespace: 'cron', method: 'list', description: 'List all cron jobs', signature: '() => Promise<string>' },
+    { toolName: 'cronjob', namespace: 'cron', method: 'pause', description: 'Pause a cron job', signature: '(id: string) => Promise<string>' },
+    { toolName: 'cronjob', namespace: 'cron', method: 'resume', description: 'Resume a paused cron job', signature: '(id: string) => Promise<string>' },
+    { toolName: 'cronjob', namespace: 'cron', method: 'delete', description: 'Delete a cron job', signature: '(id: string) => Promise<string>' },
+    { toolName: 'cronjob', namespace: 'cron', method: 'trigger', description: 'Immediately run a cron job', signature: '(id: string) => Promise<string>' },
+    // vision
+    { toolName: 'vision_analyze', namespace: 'vision', method: 'analyze', description: 'Analyze an image with AI', signature: '(imageSource: string, prompt?: string) => Promise<string>' },
+    // top-level
+    { toolName: 'run_agent', namespace: '', method: 'runAgent', description: 'Spawn a sub-agent', signature: '(task: string) => Promise<string>' },
+];
+/** Returns all SDK method definitions. */
+function getSdkMethods() {
+    return TOOL_SDK_MAP.map(e => ({
+        namespace: e.namespace,
+        method: e.method,
+        toolName: e.toolName,
+        description: e.description,
+        signature: e.signature,
+    }));
+}
+/** Returns namespaces present in the SDK (sorted). */
+function getSdkNamespaces() {
+    const ns = new Set(TOOL_SDK_MAP.filter(e => e.namespace).map(e => e.namespace));
+    return Array.from(ns).sort();
+}
+// ── SDK surface builder ───────────────────────────────────────────────────────
+/**
+ * Builds the runtime SDK object that is injected into the run sandbox.
+ * Returns a plain object tree matching `aiden.web.search(...)` etc.
+ *
+ * Each method:
+ *   1. Validates the tool exists in TOOLS
+ *   2. Calls executeTool with the appropriate input shape
+ *   3. Returns the output value (parsed JSON if possible)
+ */
+function buildSdkRuntime(onToolCall) {
+    /** Wraps a tool name into a callable that tracks usage. */
+    function makeMethod(toolName, inputMapper) {
+        return async (...args) => {
+            const input = inputMapper(...args);
+            onToolCall(toolName, input);
+            const result = await (0, toolRegistry_1.executeTool)(toolName, input, 0, 30000);
+            if (!result.success)
+                throw new Error(`${toolName} failed: ${result.error ?? result.output}`);
+            // Try to parse JSON output for structured data
+            try {
+                return JSON.parse(result.output);
+            }
+            catch {
+                return result.output;
+            }
+        };
+    }
+    const sdk = {
+        web: {
+            search: makeMethod('web_search', (q) => ({ query: q })),
+            research: makeMethod('deep_research', (t) => ({ topic: t })),
+            fetch: makeMethod('fetch_url', (u) => ({ url: u })),
+            page: makeMethod('fetch_page', (u) => ({ url: u })),
+            social: makeMethod('social_research', (q) => ({ query: q })),
+            youtube: makeMethod('ingest_youtube', (u) => ({ url: u })),
+        },
+        file: {
+            read: makeMethod('file_read', (p) => ({ path: p })),
+            write: makeMethod('file_write', (p, c) => ({ path: p, content: c })),
+            list: makeMethod('file_list', (d) => ({ path: d })),
+        },
+        shell: {
+            exec: makeMethod('shell_exec', (cmd) => ({ command: cmd })),
+            python: makeMethod('run_python', (s) => ({ script: s })),
+            node: makeMethod('run_node', (s) => ({ script: s })),
+            powershell: makeMethod('run_powershell', (s) => ({ script: s })),
+            cmd: makeMethod('cmd', (cmd, opts) => ({ command: cmd, ...opts })),
+            ps: makeMethod('ps', (cmd, opts) => ({ command: cmd, ...opts })),
+            wsl: makeMethod('wsl', (cmd, opts) => ({ command: cmd, ...opts })),
+        },
+        browser: {
+            open: makeMethod('open_browser', (u) => ({ url: u })),
+            click: makeMethod('browser_click', (sel) => ({ selector: sel })),
+            type: makeMethod('browser_type', (sel, t) => ({ selector: sel, text: t })),
+            extract: makeMethod('browser_extract', (sel) => ({ selector: sel ?? '' })),
+            screenshot: makeMethod('browser_screenshot', () => ({})),
+        },
+        screen: {
+            capture: makeMethod('screenshot', () => ({})),
+            mouseMov: makeMethod('mouse_move', (x, y) => ({ x, y })),
+            mouseClick: makeMethod('mouse_click', (x, y) => ({ x, y })),
+            type: makeMethod('keyboard_type', (text) => ({ text })),
+            press: makeMethod('keyboard_press', (key) => ({ key })),
+            read: makeMethod('screen_read', () => ({})),
+            vision: makeMethod('vision_loop', (goal, maxSteps = 10) => ({ goal, max_steps: maxSteps })),
+        },
+        memory: {
+            recall: makeMethod('memory_show', (q) => ({ query: q })),
+            remember: makeMethod('memory_show', (fact) => ({ query: fact, mode: 'store' })),
+        },
+        lessons: {
+            check: makeMethod('lessons', (q) => ({ query: q ?? '' })),
+        },
+        system: {
+            notify: makeMethod('notify', (msg, title) => ({ message: msg, title: title ?? 'Aiden' })),
+            info: makeMethod('system_info', () => ({})),
+            clipboardRead: makeMethod('clipboard_read', () => ({})),
+            clipboardWrite: makeMethod('clipboard_write', (text) => ({ text })),
+            wait: makeMethod('wait', (ms) => ({ ms })),
+        },
+        git: {
+            status: makeMethod('git_status', (p) => ({ path: p ?? process.cwd() })),
+            commit: makeMethod('git_commit', (msg) => ({ message: msg })),
+            push: makeMethod('git_push', (remote = 'origin', branch = 'master') => ({ remote, branch })),
+        },
+        data: {
+            market: makeMethod('get_market_data', (sym) => ({ symbol: sym })),
+            company: makeMethod('get_company_info', (sym) => ({ symbol: sym })),
+            stocks: makeMethod('get_stocks', (mkt, type) => ({ market: mkt, type })),
+            briefing: makeMethod('get_briefing', () => ({})),
+            calendar: makeMethod('get_calendar', (daysAhead = 7) => ({ days_ahead: daysAhead })),
+            email: makeMethod('read_email', (limit = 10) => ({ limit })),
+        },
+        // voice
+        voice: {
+            speak: async (text, opts = {}) => {
+                onToolCall('voice_speak', { text, ...opts });
+                const { synthesize } = await Promise.resolve().then(() => __importStar(require('./voice/tts')));
+                return synthesize({ text, voice: opts.voice, provider: opts.provider, rate: opts.rate, volume: opts.volume });
+            },
+            transcribe: async (audioFilePath, language) => {
+                onToolCall('voice_transcribe', { audioFilePath, language });
+                const { transcribe } = await Promise.resolve().then(() => __importStar(require('./voice/stt')));
+                return transcribe({ audioFilePath, language });
+            },
+            clone: async (text, referenceAudioPath) => {
+                onToolCall('voice_clone', { text, referenceAudioPath });
+                const { synthesize } = await Promise.resolve().then(() => __importStar(require('./voice/tts')));
+                return synthesize({ text, referenceAudioPath, provider: 'voxcpm' });
+            },
+            design: async (text, voiceDescription) => {
+                onToolCall('voice_design', { text, voiceDescription });
+                const { synthesize } = await Promise.resolve().then(() => __importStar(require('./voice/tts')));
+                return synthesize({ text, voiceDesignPrompt: voiceDescription, provider: 'voxcpm' });
+            },
+            reset: async () => {
+                // No-op in SDK context — state reset is a CLI concern
+                return { provider: 'none', durationMs: 0, note: 'voice reset (use /voice reset in CLI)' };
+            },
+            providers: async () => {
+                const { getTtsProviders } = await Promise.resolve().then(() => __importStar(require('./voice/tts')));
+                return getTtsProviders();
+            },
+            record: async (durationSeconds, outputPath) => {
+                onToolCall('voice_record', { durationSeconds, outputPath });
+                const { recordAudio } = await Promise.resolve().then(() => __importStar(require('./voice/audio')));
+                return recordAudio(durationSeconds, outputPath);
+            },
+            play: async (audioSource) => {
+                onToolCall('voice_play', { audioSource });
+                const { playAudio } = await Promise.resolve().then(() => __importStar(require('./voice/audio')));
+                return playAudio(audioSource);
+            },
+        },
+        // MCP namespace — direct access to connected MCP servers
+        mcp: {
+            /** List names of all connected MCP servers. */
+            list: () => (0, mcpClient_1.listMcpServers)(),
+            /** List all MCP tools (across all servers). */
+            tools: () => (0, mcpClient_1.listMcpTools)(),
+            /** Call an MCP tool by 'server:toolName' and args object. */
+            call: (toolName, args = {}) => {
+                onToolCall(`mcp:${toolName}`, args);
+                return (0, mcpClient_1.callMcpTool)(toolName, args);
+            },
+        },
+        // todo
+        todo: {
+            add: makeMethod('todo', (text, priority) => ({ op: 'add', text, priority: priority ?? 'normal' })),
+            complete: makeMethod('todo', (id) => ({ op: 'complete', id })),
+            remove: makeMethod('todo', (id) => ({ op: 'remove', id })),
+            list: makeMethod('todo', (filter) => ({ op: 'list', filter: filter ?? 'all' })),
+            clear: makeMethod('todo', () => ({ op: 'clear' })),
+        },
+        // cron
+        cron: {
+            create: makeMethod('cronjob', (description, schedule, action) => ({ op: 'create', description, schedule, action })),
+            list: makeMethod('cronjob', () => ({ op: 'list' })),
+            pause: makeMethod('cronjob', (id) => ({ op: 'pause', id })),
+            resume: makeMethod('cronjob', (id) => ({ op: 'resume', id })),
+            delete: makeMethod('cronjob', (id) => ({ op: 'delete', id })),
+            trigger: makeMethod('cronjob', (id) => ({ op: 'trigger', id })),
+        },
+        // vision
+        vision: {
+            analyze: makeMethod('vision_analyze', (imageSource, prompt) => ({ image: imageSource, prompt })),
+        },
+        // Top-level clarify — ask the user a question mid-task
+        clarify: async (question, options, allowFreeText = true) => {
+            onToolCall('clarify', { question, options, allow_free_text: allowFreeText });
+            const result = await (0, toolRegistry_1.executeTool)('clarify', { question, options, allow_free_text: allowFreeText }, 0, 300000);
+            if (!result.success)
+                throw new Error(`clarify failed: ${result.error ?? result.output}`);
+            return result.output;
+        },
+        // Top-level convenience
+        runAgent: makeMethod('run_agent', (task) => ({ task })),
+    };
+    return sdk;
+}
+// ── Prose SDK surface (for /run help display) ─────────────────────────────────
+/**
+ * Generates a human-readable string describing the full SDK surface.
+ * Used by /run help and the LLM system prompt hint.
+ */
+function buildSdkSurface() {
+    const grouped = {};
+    for (const m of TOOL_SDK_MAP) {
+        const key = m.namespace || '_top';
+        if (!grouped[key])
+            grouped[key] = [];
+        grouped[key].push(m);
+    }
+    const lines = [
+        '// Aiden SDK — auto-generated from tool registry',
+        '// Use `aiden.<namespace>.<method>(...)` in /run scripts',
+        '',
+    ];
+    const sortedNs = Object.keys(grouped).sort((a, b) => {
+        if (a === '_top')
+            return 1;
+        if (b === '_top')
+            return -1;
+        return a.localeCompare(b);
+    });
+    for (const ns of sortedNs) {
+        const label = ns === '_top' ? 'aiden (top-level)' : `aiden.${ns}`;
+        lines.push(`// ── ${label} ${'─'.repeat(Math.max(0, 50 - label.length - 6))}`);
+        for (const m of grouped[ns]) {
+            const call = ns === '_top'
+                ? `aiden.${m.method}${m.signature.startsWith('(') ? m.signature.split('=>')[0].trim() : '(...)'}`
+                : `aiden.${ns}.${m.method}${m.signature.startsWith('(') ? m.signature.split('=>')[0].trim() : '(...)'}`;
+            lines.push(`  ${call.padEnd(60)} // ${m.description}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/core/asyncTasks.js

@@ -0,0 +1,82 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncTasks = void 0;
+// core/asyncTasks.ts — Background task execution with completion notifications.
+//
+// Usage:
+//   const task = asyncTasks.spawn('research top AI frameworks 2026')
+//   // returns immediately; task runs in background
+//   // emits callbacks.async_complete when done → forwarded to all open SSE clients
+const agentLoop_1 = require("./agentLoop");
+const router_1 = require("../providers/router");
+const conversationMemory_1 = require("./conversationMemory");
+const callbackSystem_1 = require("./callbackSystem");
+// ── Manager ───────────────────────────────────────────────────────────────────
+class AsyncTaskManager {
+    constructor() {
+        this.tasks = new Map();
+    }
+    /**
+     * Spawn a new background task. Returns the task record immediately;
+     * execution runs asynchronously. A `callbacks.async_complete` event
+     * fires when it finishes (success or failure).
+     */
+    spawn(prompt) {
+        const id = `async_${Date.now()}`;
+        const task = { id, prompt, status: 'running', startedAt: Date.now() };
+        this.tasks.set(id, task);
+        // Fire-and-forget — top-level error captured here so it never becomes an
+        // unhandled rejection; execute() also updates the task internally on throw.
+        this.execute(task).catch(() => { });
+        return task;
+    }
+    async execute(task) {
+        const start = task.startedAt;
+        try {
+            const planner = (0, router_1.getModelForTask)('planner');
+            const responder = (0, router_1.getModelForTask)('responder');
+            const memCtx = conversationMemory_1.conversationMemory.buildContext();
+            // ── Step 1: Plan ────────────────────────────────────────────
+            const plan = await (0, agentLoop_1.planWithLLM)(task.prompt, [], planner.apiKey, planner.model, planner.providerName, memCtx);
+            // ── Step 2: Execute ─────────────────────────────────────────
+            const results = plan.requires_execution && plan.plan.length > 0
+                ? await (0, agentLoop_1.executePlan)(plan, (_step, _result) => { })
+                : [];
+            // ── Step 3: Respond ─────────────────────────────────────────
+            const tokens = [];
+            await (0, agentLoop_1.respondWithResults)(task.prompt, plan, results, [], 'User', responder.apiKey, responder.model, responder.providerName, (t) => tokens.push(t));
+            task.result = tokens.join('').trim();
+            task.status = 'complete';
+            task.completedAt = Date.now();
+        }
+        catch (err) {
+            task.status = 'failed';
+            task.error = err?.message || String(err);
+            task.completedAt = Date.now();
+            // re-throw so the spawn() .catch() fires for logging
+            throw err;
+        }
+        finally {
+            // Notify all open SSE clients regardless of success/failure
+            await callbackSystem_1.callbacks.emit('async_complete', 'async', {
+                taskId: task.id,
+                status: task.status,
+                elapsed: Date.now() - start,
+                preview: (task.result || task.error || '').slice(0, 200),
+            });
+        }
+    }
+    /** Return all tasks (running, complete, failed). */
+    list() {
+        return Array.from(this.tasks.values()).sort((a, b) => b.startedAt - a.startedAt);
+    }
+    /** Return a single task by ID, or undefined if not found. */
+    get(id) {
+        return this.tasks.get(id);
+    }
+}
+exports.asyncTasks = new AsyncTaskManager();

package/dist/core/auditTrail.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditTrail = exports.AuditTrail = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const AUDIT_PATH = path_1.default.join(process.cwd(), 'workspace', 'audit', 'audit.jsonl');
+class AuditTrail {
+    constructor() {
+        fs_1.default.mkdirSync(path_1.default.dirname(AUDIT_PATH), { recursive: true });
+    }
+    record(entry) {
+        const full = {
+            id: `a_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+            ts: Date.now(),
+            ...entry,
+        };
+        fs_1.default.appendFileSync(AUDIT_PATH, JSON.stringify(full) + '\n');
+    }
+    getToday() {
+        if (!fs_1.default.existsSync(AUDIT_PATH))
+            return [];
+        const today = new Date().toDateString();
+        return fs_1.default.readFileSync(AUDIT_PATH, 'utf-8')
+            .trim().split('\n').filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter(e => e && new Date(e.ts).toDateString() === today);
+    }
+    formatSummary(entries) {
+        if (entries.length === 0)
+            return 'No activity today.';
+        const success = entries.filter(e => e.success).length;
+        const failed = entries.length - success;
+        const tools = {};
+        for (const e of entries) {
+            if (e.tool)
+                tools[e.tool] = (tools[e.tool] || 0) + 1;
+        }
+        const topTools = Object.entries(tools)
+            .sort((a, b) => b[1] - a[1]).slice(0, 5)
+            .map(([t, c]) => `  ${t}: ${c}x`).join('\n');
+        const failures = entries.filter(e => !e.success).slice(-3)
+            .map(e => `  - ${e.tool || e.action}: ${e.error || 'unknown error'}`).join('\n');
+        return `DevOS Activity — ${new Date().toLocaleDateString()}
+Actions: ${entries.length} total | ${success} succeeded | ${failed} failed
+Avg duration: ${Math.round(entries.reduce((s, e) => s + e.durationMs, 0) / entries.length)}ms
+
+Top tools:
+${topTools || '  none'}
+${failures ? `\nRecent failures:\n${failures}` : ''}`;
+    }
+}
+exports.AuditTrail = AuditTrail;
+exports.auditTrail = new AuditTrail();

package/dist/core/auxiliaryClient.js

@@ -0,0 +1,114 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auxiliaryClient = void 0;
+// core/auxiliaryClient.ts — Cheap LLM client for side tasks.
+// Side tasks (memory extraction, dream consolidation, session
+// reflection, compression summaries) don't need the main model.
+// Routes to the executor tier (Cerebras → Groq → Nvidia → Ollama)
+// with lower max_tokens and shorter timeout than the main loop.
+// Matches the agentLoop.ts direct-fetch pattern exactly.
+// Falls back to callBgLLM if the executor route fails.
+const router_1 = require("../providers/router");
+const bgLLM_1 = require("./bgLLM");
+const costTracker_1 = require("./costTracker");
+// ── OpenAI-compat endpoints (mirrors agentLoop.ts) ────────────
+const AUX_ENDPOINTS = {
+    groq: 'https://api.groq.com/openai/v1/chat/completions',
+    cerebras: 'https://api.cerebras.ai/v1/chat/completions',
+    openrouter: 'https://openrouter.ai/api/v1/chat/completions',
+    nvidia: 'https://integrate.api.nvidia.com/v1/chat/completions',
+    github: 'https://models.inference.ai.azure.com/chat/completions',
+    boa: 'https://api.boa.ai/v1/chat/completions',
+};
+const DEFAULT_AUX_CONFIG = {
+    preferLocal: true,
+    maxTokens: 500,
+    timeout: 10000,
+    fallbackToMain: true,
+};
+// ── AuxiliaryClient ───────────────────────────────────────────
+class AuxiliaryClient {
+    constructor(config) {
+        this.config = { ...DEFAULT_AUX_CONFIG, ...config };
+    }
+    // ── Public: single-turn completion for a side task ─────────
+    async complete(prompt, options) {
+        const task = options?.task || 'general';
+        const maxTokens = options?.maxTokens || this.config.maxTokens;
+        // Executor tier: Cerebras → Groq → Nvidia → Ollama (cheapest available)
+        const { apiKey, model, providerName, apiName } = (0, router_1.getModelForTask)('executor');
+        console.log(`[Aux] ${task} — routing to ${apiName} (${providerName}/${model})`);
+        try {
+            const result = await this.callProviderDirect(providerName, apiKey, model, prompt, maxTokens);
+            if (result) {
+                console.log(`[Aux] Side task "${task}" routed to ${apiName} ` +
+                    `instead of main model — estimated savings: ~$0.001`);
+                return result;
+            }
+        }
+        catch (e) {
+            console.log(`[Aux] ${apiName} failed (${e.message}) — falling back`);
+        }
+        // Fallback: bgLLM (Cerebras → Ollama — safe, no global state)
+        if (this.config.fallbackToMain) {
+            console.log(`[Aux] Falling back to bgLLM for ${task}`);
+            return (0, bgLLM_1.callBgLLM)(prompt, `aux_${task}`);
+        }
+        return '';
+    }
+    // ── Direct fetch — matches agentLoop.ts pattern ────────────
+    // Lower max_tokens + shorter timeout vs. main loop.
+    // Does NOT touch currentAbortController (safe for side tasks).
+    async callProviderDirect(providerName, apiKey, model, prompt, maxTokens) {
+        const messages = [
+            { role: 'system', content: 'You are a concise assistant. Respond briefly and accurately.' },
+            { role: 'user', content: prompt },
+        ];
+        // ── Ollama ───────────────────────────────────────────────
+        if (providerName === 'ollama') {
+            const r = await fetch('http://localhost:11434/api/chat', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model, stream: false, messages }),
+                signal: AbortSignal.timeout(this.config.timeout),
+            });
+            if (!r.ok)
+                throw new Error(`ollama ${r.status}`);
+            const d = await r.json();
+            try {
+                costTracker_1.costTracker.trackUsage('ollama', model, d?.prompt_eval_count ?? 0, d?.eval_count ?? 0, undefined, true);
+            }
+            catch { }
+            return d?.message?.content || '';
+        }
+        // ── OpenAI-compatible (Cerebras, Groq, Nvidia, OpenRouter) ─
+        const url = AUX_ENDPOINTS[providerName];
+        if (!url || !apiKey)
+            return '';
+        const r = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({ model, messages, stream: false, max_tokens: maxTokens }),
+            signal: AbortSignal.timeout(this.config.timeout),
+        });
+        if (r.status === 429)
+            throw new Error(`rate limited (429)`);
+        if (!r.ok)
+            throw new Error(`${providerName} ${r.status}`);
+        const d = await r.json();
+        try {
+            costTracker_1.costTracker.trackUsage(providerName, model, d?.usage?.prompt_tokens ?? 0, d?.usage?.completion_tokens ?? 0, undefined, true);
+        }
+        catch { }
+        return d?.choices?.[0]?.message?.content || '';
+    }
+}
+// ── Singleton ──────────────────────────────────────────────────
+exports.auxiliaryClient = new AuxiliaryClient();