aiden-runtime 3.16.0

package/dist/core/taskState.js

@@ -0,0 +1,168 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskStateManager = exports.TaskStateManager = void 0;
+// core/taskState.ts — Persistent step-level task state.
+// Enables crash recovery, idempotent execution, and token budgeting.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const TASKS_DIR = path_1.default.join(process.cwd(), 'workspace', 'tasks');
+// ── TaskStateManager ───────────────────────────────────────────
+class TaskStateManager {
+    create(taskId, goal, totalSteps, planId) {
+        const state = {
+            id: taskId,
+            goal,
+            planId,
+            status: 'running',
+            currentStep: 0,
+            totalSteps,
+            steps: [],
+            tokenUsage: 0,
+            tokenLimit: 50000,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        this.save(state);
+        return state;
+    }
+    load(taskId) {
+        try {
+            const statePath = path_1.default.join(TASKS_DIR, taskId, 'state.json');
+            if (!fs_1.default.existsSync(statePath))
+                return null;
+            return JSON.parse(fs_1.default.readFileSync(statePath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    save(state) {
+        try {
+            const taskDir = path_1.default.join(TASKS_DIR, state.id);
+            fs_1.default.mkdirSync(taskDir, { recursive: true });
+            state.updatedAt = Date.now();
+            // Atomic write — temp file then rename, avoids corruption on crash
+            const statePath = path_1.default.join(taskDir, 'state.json');
+            const tempPath = path_1.default.join(taskDir, 'state.tmp.json');
+            fs_1.default.writeFileSync(tempPath, JSON.stringify(state, null, 2));
+            fs_1.default.renameSync(tempPath, statePath);
+        }
+        catch (e) {
+            console.error(`[TaskState] Save failed for ${state.id}: ${e.message}`);
+        }
+    }
+    startStep(state, index, tool, input) {
+        const existing = state.steps.find(s => s.index === index);
+        if (!existing) {
+            state.steps.push({ index, tool, input, status: 'pending' });
+        }
+        state.currentStep = index;
+        this.save(state);
+    }
+    // NEVER overwrite a completed step — idempotency guard
+    completeStep(state, index, output, duration) {
+        const step = state.steps.find(s => s.index === index);
+        if (step && step.status === 'completed') {
+            console.log(`[TaskState] Step ${index} already completed — skipping overwrite`);
+            return;
+        }
+        if (step) {
+            step.status = 'completed';
+            step.output = output.slice(0, 2000); // cap stored output
+            step.duration = duration;
+            step.completedAt = Date.now();
+        }
+        // Estimate token usage — chars/4 is a reasonable approximation
+        state.tokenUsage += Math.ceil(output.length / 4);
+        this.save(state);
+    }
+    failStep(state, index, error) {
+        const step = state.steps.find(s => s.index === index);
+        if (step) {
+            step.status = 'failed';
+            step.error = error;
+            step.completedAt = Date.now();
+        }
+        this.save(state);
+    }
+    complete(state) {
+        state.status = 'completed';
+        state.completedAt = Date.now();
+        this.save(state);
+    }
+    fail(state, error) {
+        state.status = 'failed';
+        state.error = error;
+        state.completedAt = Date.now();
+        this.save(state);
+    }
+    isStepCompleted(state, index) {
+        const step = state.steps.find(s => s.index === index);
+        return step?.status === 'completed';
+    }
+    isOverBudget(state) {
+        return state.tokenUsage >= state.tokenLimit;
+    }
+    // Find the first incomplete step index — used to find resume point after crash
+    getResumePoint(state) {
+        for (let i = 0; i < state.totalSteps; i++) {
+            const step = state.steps.find(s => s.index === i);
+            if (!step || step.status !== 'completed')
+                return i;
+        }
+        return state.totalSteps; // all steps done
+    }
+    getRunningTasks() {
+        const running = [];
+        try {
+            if (!fs_1.default.existsSync(TASKS_DIR))
+                return [];
+            const dirs = fs_1.default.readdirSync(TASKS_DIR).filter(d => d.startsWith('task_'));
+            for (const dir of dirs) {
+                const state = this.load(dir);
+                if (state && state.status === 'running')
+                    running.push(state);
+            }
+        }
+        catch { }
+        return running;
+    }
+    listAll() {
+        try {
+            if (!fs_1.default.existsSync(TASKS_DIR))
+                return [];
+            return fs_1.default.readdirSync(TASKS_DIR)
+                .filter(d => d.startsWith('task_'))
+                .sort().reverse().slice(0, 20)
+                .map(dir => {
+                const state = this.load(dir);
+                if (!state)
+                    return null;
+                return {
+                    id: state.id,
+                    goal: state.goal.slice(0, 80),
+                    status: state.status,
+                    currentStep: state.currentStep,
+                    totalSteps: state.totalSteps,
+                    tokenUsage: state.tokenUsage,
+                    tokenLimit: state.tokenLimit,
+                    createdAt: state.createdAt,
+                    updatedAt: state.updatedAt,
+                };
+            })
+                .filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.TaskStateManager = TaskStateManager;
+exports.taskStateManager = new TaskStateManager();

package/dist/core/telegramBot.js

@@ -0,0 +1,152 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramBot = void 0;
+exports.registerTelegramCallbacks = registerTelegramCallbacks;
+// core/telegramBot.ts — Telegram bot integration for Aiden.
+// Uses native fetch (Node 18+). No external dependencies.
+const callbackSystem_1 = require("./callbackSystem");
+// ── TelegramBot ────────────────────────────────────────────────
+class TelegramBot {
+    constructor(config) {
+        this.offset = 0;
+        this.polling = false;
+        this.token = config.botToken;
+        this.baseUrl = `https://api.telegram.org/bot${this.token}`;
+        this.allowedChats = new Set(config.allowedChatIds);
+    }
+    // ── Send a message (auto-chunks at 4000 chars) ──────────────
+    async sendMessage(chatId, text) {
+        const chunks = this.chunkMessage(text, 4000);
+        for (const chunk of chunks) {
+            try {
+                await fetch(`${this.baseUrl}/sendMessage`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        chat_id: chatId,
+                        text: chunk,
+                        parse_mode: 'Markdown',
+                    }),
+                });
+            }
+            catch (e) {
+                console.error('[Telegram] sendMessage error:', e.message);
+            }
+        }
+    }
+    // ── Show typing indicator ───────────────────────────────────
+    async sendTyping(chatId) {
+        try {
+            await fetch(`${this.baseUrl}/sendChatAction`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ chat_id: chatId, action: 'typing' }),
+            });
+        }
+        catch { }
+    }
+    // ── Long-poll for updates ───────────────────────────────────
+    async poll() {
+        try {
+            const response = await fetch(`${this.baseUrl}/getUpdates?offset=${this.offset}&timeout=30`);
+            const data = await response.json();
+            if (data.ok && data.result.length > 0) {
+                this.offset = data.result[data.result.length - 1].update_id + 1;
+                return data.result;
+            }
+        }
+        catch (error) {
+            console.error('[Telegram] Poll error:', error.message);
+        }
+        return [];
+    }
+    // ── Main polling loop ───────────────────────────────────────
+    async startPolling(onMessage) {
+        if (this.polling)
+            return;
+        this.polling = true;
+        console.log('[Telegram] Bot started polling');
+        while (this.polling) {
+            const updates = await this.poll();
+            for (const update of updates) {
+                if (!update.message?.text)
+                    continue;
+                const chatId = String(update.message.chat.id);
+                const text = update.message.text;
+                // Security: only respond to allowed chat IDs
+                // If allowedChatIds is empty, respond to everyone (first-time setup)
+                if (this.allowedChats.size > 0 && !this.allowedChats.has(chatId)) {
+                    console.log(`[Telegram] Ignored message from unauthorized chat: ${chatId}`);
+                    await this.sendMessage(chatId, '⚠️ Unauthorized. Add your chat ID to Aiden Settings → Channels → Telegram.');
+                    continue;
+                }
+                console.log(`[Telegram] Message from ${chatId}: ${text.substring(0, 50)}`);
+                await this.sendTyping(chatId);
+                try {
+                    const response = await onMessage(chatId, text);
+                    await this.sendMessage(chatId, response);
+                }
+                catch (error) {
+                    console.error('[Telegram] Error processing message:', error.message);
+                    await this.sendMessage(chatId, '❌ Something went wrong processing your message. Try again.');
+                }
+            }
+        }
+    }
+    // ── Stop polling ────────────────────────────────────────────
+    stop() {
+        this.polling = false;
+        console.log('[Telegram] Bot stopped');
+    }
+    // ── Chunk long messages ─────────────────────────────────────
+    chunkMessage(text, maxLength) {
+        if (text.length <= maxLength)
+            return [text];
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+            if (remaining.length <= maxLength) {
+                chunks.push(remaining);
+                break;
+            }
+            // Prefer splitting at a newline
+            let splitAt = remaining.lastIndexOf('\n', maxLength);
+            if (splitAt < maxLength * 0.5) {
+                // No good newline — try a space
+                splitAt = remaining.lastIndexOf(' ', maxLength);
+            }
+            if (splitAt < maxLength * 0.5) {
+                // No good split point — hard cut
+                splitAt = maxLength;
+            }
+            chunks.push(remaining.substring(0, splitAt));
+            remaining = remaining.substring(splitAt).trim();
+        }
+        return chunks;
+    }
+}
+exports.TelegramBot = TelegramBot;
+// ── Callback integration ──────────────────────────────────────────────────────
+/**
+ * Register a persistent callback subscriber that sends a typing indicator to
+ * the relevant Telegram chat whenever a tool starts executing in any session
+ * that originated from Telegram.
+ *
+ * The gateway routes Telegram messages with sessionId `telegram_telegram_{chatId}`,
+ * so we extract the chatId from that pattern and call sendTyping().
+ *
+ * @returns An unsubscribe function — call it when the bot is stopped.
+ */
+function registerTelegramCallbacks(bot) {
+    return callbackSystem_1.callbacks.on('tool_start', async (payload) => {
+        const prefix = 'telegram_telegram_';
+        if (payload.sessionId.startsWith(prefix)) {
+            const chatId = payload.sessionId.slice(prefix.length);
+            await bot.sendTyping(chatId);
+        }
+    });
+}

package/dist/core/todoManager.js

@@ -0,0 +1,70 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+//
+// core/todoManager.ts — Per-session in-memory task list.
+//
+// Intentionally ephemeral: todos reset on process restart.
+// Use aiden.todo.* or the /todo CLI command to manage items.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTodo = addTodo;
+exports.completeTodo = completeTodo;
+exports.removeTodo = removeTodo;
+exports.clearTodos = clearTodos;
+exports.listTodos = listTodos;
+exports.getTodo = getTodo;
+exports.formatTodoList = formatTodoList;
+let todos = [];
+let seq = 1;
+// ── CRUD ──────────────────────────────────────────────────────────────────────
+function addTodo(text, priority = 'normal') {
+    const item = {
+        id: String(seq++),
+        text: text.trim(),
+        done: false,
+        priority,
+        createdAt: new Date().toISOString(),
+    };
+    todos.push(item);
+    return item;
+}
+function completeTodo(id) {
+    const item = todos.find(t => t.id === id);
+    if (!item)
+        return null;
+    item.done = true;
+    item.doneAt = new Date().toISOString();
+    return item;
+}
+function removeTodo(id) {
+    const before = todos.length;
+    todos = todos.filter(t => t.id !== id);
+    return todos.length < before;
+}
+function clearTodos() {
+    const count = todos.length;
+    todos = [];
+    return count;
+}
+function listTodos(filter = 'all') {
+    if (filter === 'done')
+        return todos.filter(t => t.done);
+    if (filter === 'pending')
+        return todos.filter(t => !t.done);
+    return [...todos];
+}
+function getTodo(id) {
+    return todos.find(t => t.id === id);
+}
+// ── Formatting helper ─────────────────────────────────────────────────────────
+function formatTodoList(items) {
+    if (!items.length)
+        return 'No items.';
+    return items.map(t => {
+        const status = t.done ? '✓' : '○';
+        const pri = t.priority !== 'normal' ? ` [${t.priority}]` : '';
+        return `[${t.id}] ${status}${pri} ${t.text}`;
+    }).join('\n');
+}

package/dist/core/toolNameRepair.js

@@ -0,0 +1,71 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lev = lev;
+exports.normalize = normalize;
+exports.repairToolName = repairToolName;
+// ── Levenshtein distance ──────────────────────────────────────────────────────
+function lev(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+// ── Normalization ─────────────────────────────────────────────────────────────
+// Strip common hallucination suffixes/patterns that LLMs append to tool names.
+const SUFFIX_PATTERNS = [
+    /_\d+$/, // web_search_1, file_write_2
+    /\.(exec|run|call|tool)$/i, // file_write.exec
+    /_(exec|run|call|tool|v\d+)$/i, // shell_exec_run, web_search_v2
+];
+const CAMEL_TO_SNAKE_RE = /([A-Z])/g;
+function normalize(name) {
+    let s = name.trim();
+    // camelCase → snake_case: getStocks → get_stocks, deepResearch → deep_research
+    s = s.replace(CAMEL_TO_SNAKE_RE, '_$1').toLowerCase().replace(/^_/, '');
+    // strip known hallucination suffixes
+    for (const pattern of SUFFIX_PATTERNS) {
+        s = s.replace(pattern, '');
+    }
+    return s;
+}
+// ── Main export ───────────────────────────────────────────────────────────────
+/**
+ * Try to map a hallucinated/corrupted tool name to the closest valid tool.
+ *
+ * @param name        - The tool name the LLM produced
+ * @param validTools  - Authoritative list of valid tool names
+ * @returns A RepairResult if a match within threshold was found; null otherwise
+ */
+function repairToolName(name, validTools) {
+    if (validTools.includes(name))
+        return null; // already valid — nothing to do
+    const normalized = normalize(name);
+    // Exact match after normalization (e.g. getStocks → get_stocks)
+    if (validTools.includes(normalized)) {
+        return { original: name, repaired: normalized, distance: 0 };
+    }
+    // Fuzzy match: find the closest valid tool within the edit-distance threshold
+    // Threshold scales with name length: max(2, floor(len * 0.3))
+    const threshold = Math.max(2, Math.floor(normalized.length * 0.3));
+    let best = null;
+    for (const valid of validTools) {
+        const d = lev(normalized, valid);
+        if (d <= threshold && (!best || d < best.distance)) {
+            best = { repaired: valid, distance: d };
+        }
+    }
+    if (!best)
+        return null;
+    return { original: name, repaired: best.repaired, distance: best.distance };
+}