aiden-runtime 3.16.0

package/dist/core/goalTracker.js

@@ -0,0 +1,75 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGoals = loadGoals;
+exports.saveGoals = saveGoals;
+exports.getActiveGoalsSummary = getActiveGoalsSummary;
+// core/goalTracker.ts — Reads/writes workspace/GOALS.md,
+// exposes active goal summaries for planner injection.
+const fs_1 = require("fs");
+const path_1 = require("path");
+const GOALS_PATH = (0, path_1.join)(process.cwd(), 'workspace', 'GOALS.md');
+// ── Parser ────────────────────────────────────────────────────
+function parseGoalSection(section) {
+    const lines = section.split('\n');
+    const title = lines[0].trim();
+    const goal = {
+        id: Date.now().toString(),
+        title,
+        status: 'not_started',
+        lastUpdated: new Date().toISOString().split('T')[0],
+    };
+    for (const line of lines.slice(1)) {
+        const t = line.trim();
+        if (t.startsWith('- Status:'))
+            goal.status = t.replace('- Status:', '').trim();
+        else if (t.startsWith('- Target:'))
+            goal.target = t.replace('- Target:', '').trim();
+        else if (t.startsWith('- Next action:'))
+            goal.nextAction = t.replace('- Next action:', '').trim();
+        else if (t.startsWith('- Note:')) {
+            if (!goal.notes)
+                goal.notes = [];
+            goal.notes.push(t.replace('- Note:', '').trim());
+        }
+    }
+    return goal;
+}
+// ── Public API ────────────────────────────────────────────────
+function loadGoals() {
+    if (!(0, fs_1.existsSync)(GOALS_PATH))
+        return [];
+    try {
+        return (0, fs_1.readFileSync)(GOALS_PATH, 'utf8')
+            .split(/^## /m)
+            .slice(1)
+            .map(parseGoalSection);
+    }
+    catch {
+        return [];
+    }
+}
+function saveGoals(goals) {
+    const today = new Date().toISOString().split('T')[0];
+    const md = '# Active Goals\n\n' +
+        goals.map(g => `## ${g.title}\n` +
+            `- Status: ${g.status}\n` +
+            (g.target ? `- Target: ${g.target}\n` : '') +
+            (g.nextAction ? `- Next action: ${g.nextAction}\n` : '') +
+            `- Last updated: ${today}\n` +
+            (g.notes?.map(n => `- Note: ${n}\n`).join('') ?? '')).join('\n');
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(GOALS_PATH), { recursive: true });
+        (0, fs_1.writeFileSync)(GOALS_PATH, md);
+    }
+    catch { }
+}
+function getActiveGoalsSummary() {
+    const active = loadGoals().filter(g => g.status !== 'done');
+    if (active.length === 0)
+        return '';
+    return 'Active goals:\n' + active.map(g => `- ${g.title} [${g.status}]: ${g.nextAction || 'No next action'}`).join('\n');
+}

package/dist/core/growthEngine.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.growthEngine = exports.GrowthEngine = void 0;
+// core/growthEngine.ts — Self-improvement through failure analysis.
+//
+// Appends every failure as a JSONL line to workspace/growth/failure-log.jsonl.
+// On analyze(), clusters failures by (capability, error-class) context hash,
+// surfaces opportunities with count >= 3, and writes a weekly markdown report.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ── Paths ──────────────────────────────────────────────────────
+const GROWTH_DIR = path_1.default.join(process.cwd(), 'workspace', 'growth');
+const FAILURE_LOG = path_1.default.join(GROWTH_DIR, 'failure-log.jsonl');
+const OPPORTUNITIES_PATH = path_1.default.join(GROWTH_DIR, 'skill-opportunities.json');
+const REPORT_PATH = path_1.default.join(GROWTH_DIR, 'weekly-report.md');
+// ── GrowthEngine ───────────────────────────────────────────────
+class GrowthEngine {
+    constructor() {
+        try {
+            fs_1.default.mkdirSync(GROWTH_DIR, { recursive: true });
+        }
+        catch { }
+    }
+    // ── Record a failure ──────────────────────────────────────────
+    logFailure(task, error, toolsAttempted) {
+        const capability = toolsAttempted[toolsAttempted.length - 1] || 'unknown';
+        const contextHash = this.hashContext(error, capability);
+        const entry = {
+            timestamp: Date.now(),
+            task,
+            error: error.slice(0, 200),
+            capability,
+            contextHash,
+        };
+        try {
+            fs_1.default.appendFileSync(FAILURE_LOG, JSON.stringify(entry) + '\n', 'utf-8');
+        }
+        catch { }
+        console.log(`[GrowthEngine] Failure logged: ${contextHash} — "${task.slice(0, 60)}"`);
+    }
+    // ── Record a success ──────────────────────────────────────────
+    // Tracked for confidence scoring — future use
+    logSuccess(_task, _tools) {
+        // No-op for now; confidence scoring uses failure ratio
+    }
+    // ── Analyse failure log and surface opportunities ─────────────
+    analyze() {
+        if (!fs_1.default.existsSync(FAILURE_LOG))
+            return [];
+        let lines;
+        try {
+            lines = fs_1.default.readFileSync(FAILURE_LOG, 'utf-8').trim().split('\n').filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+        const totalFailures = lines.length;
+        if (totalFailures === 0)
+            return [];
+        const map = new Map();
+        for (const line of lines) {
+            try {
+                const f = JSON.parse(line);
+                if (!map.has(f.contextHash)) {
+                    map.set(f.contextHash, {
+                        contextHash: f.contextHash,
+                        count: 0,
+                        suggestedSkill: this.inferSkill(f),
+                        lastSeen: f.timestamp,
+                        confidence: 0,
+                    });
+                }
+                const entry = map.get(f.contextHash);
+                entry.count++;
+                entry.lastSeen = Math.max(entry.lastSeen, f.timestamp);
+                entry.confidence = entry.count / totalFailures;
+            }
+            catch { }
+        }
+        const opportunities = Array.from(map.values())
+            .filter(o => o.count >= 3 && o.confidence > 0.1)
+            .sort((a, b) => b.count - a.count);
+        try {
+            fs_1.default.writeFileSync(OPPORTUNITIES_PATH, JSON.stringify(opportunities, null, 2), 'utf-8');
+        }
+        catch { }
+        return opportunities;
+    }
+    // ── Weekly report ─────────────────────────────────────────────
+    getWeeklyReport() {
+        const opportunities = this.analyze();
+        let failedCount = 0;
+        try {
+            if (fs_1.default.existsSync(FAILURE_LOG)) {
+                failedCount = fs_1.default.readFileSync(FAILURE_LOG, 'utf-8')
+                    .trim().split('\n').filter(Boolean).length;
+            }
+        }
+        catch { }
+        const report = {
+            learned: 0,
+            failed: failedCount,
+            gaps: opportunities.map(o => o.contextHash),
+            proposals: opportunities.map(o => o.suggestedSkill),
+        };
+        // Write markdown report
+        try {
+            const lines = [
+                `# DevOS Weekly Growth Report`,
+                ``,
+                `**Failed tasks:** ${report.failed}`,
+                `**Gaps detected:** ${report.gaps.length}`,
+                ``,
+                opportunities.length === 0
+                    ? '_No recurring failure patterns detected._'
+                    : opportunities
+                        .map(o => `- \`${o.contextHash}\` → \`${o.suggestedSkill}\` ` +
+                        `(${o.count} failures, confidence: ${(o.confidence * 100).toFixed(0)}%)`)
+                        .join('\n'),
+            ];
+            fs_1.default.writeFileSync(REPORT_PATH, lines.join('\n'), 'utf-8');
+        }
+        catch { }
+        return report;
+    }
+    // ── Context hash: (capability, error-class) pair ─────────────
+    hashContext(error, capability) {
+        const lower = error.toLowerCase();
+        const errClass = lower.includes('timeout') ? 'timeout'
+            : lower.includes('selector') ? 'selector'
+                : lower.includes('403') || lower.includes('401') ? 'auth'
+                    : lower.includes('rate') || lower.includes('429') ? 'ratelimit'
+                        : lower.includes('not found') || lower.includes('enoent') ? 'notfound'
+                            : lower.includes('parse') || lower.includes('json') ? 'parse'
+                                : lower.includes('network') || lower.includes('fetch') ? 'network'
+                                    : 'general';
+        return `${capability}_${errClass}`;
+    }
+    // ── Infer a skill name from a failure ─────────────────────────
+    inferSkill(f) {
+        const lower = f.error.toLowerCase();
+        if (lower.includes('selector'))
+            return 'web.extractor.robust';
+        if (lower.includes('timeout'))
+            return 'retry.backoff';
+        if (f.capability.includes('file'))
+            return 'file.recovery';
+        if (lower.includes('rate') || lower.includes('429'))
+            return 'provider.rotation';
+        if (lower.includes('403') || lower.includes('401'))
+            return 'auth.refresh';
+        if (lower.includes('parse') || lower.includes('json'))
+            return 'output.parser';
+        if (lower.includes('network') || lower.includes('fetch'))
+            return 'network.resilience';
+        return 'general.improvement';
+    }
+}
+exports.GrowthEngine = GrowthEngine;
+// ── Singleton ─────────────────────────────────────────────────
+exports.growthEngine = new GrowthEngine();

package/dist/core/hardwareDetector.js

@@ -0,0 +1,98 @@
+"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.detectHardware = detectHardware;
+exports.redetectHardware = redetectHardware;
+// core/hardwareDetector.ts — Cross-platform GPU/RAM detection.
+// Caches result to config/hardware.json for 24 hours.
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const CONFIG_PATH = path_1.default.join(process.cwd(), 'config', 'hardware.json');
+function safeExec(cmd) {
+    try {
+        return (0, child_process_1.execSync)(cmd, { timeout: 5000 }).toString().trim();
+    }
+    catch {
+        return '';
+    }
+}
+function detectHardware() {
+    // Return cached if exists and less than 24 hours old
+    if (fs_1.default.existsSync(CONFIG_PATH)) {
+        try {
+            const cached = JSON.parse(fs_1.default.readFileSync(CONFIG_PATH, 'utf-8'));
+            const age = Date.now() - new Date(cached.detectedAt).getTime();
+            if (age < 24 * 60 * 60 * 1000)
+                return cached;
+        }
+        catch { }
+    }
+    const platformRaw = os_1.default.platform();
+    const platform = platformRaw === 'win32' ? 'windows' : platformRaw === 'darwin' ? 'macos' : 'linux';
+    const appleSilicon = platform === 'macos' && os_1.default.arch() === 'arm64';
+    let gpu = 'Unknown GPU';
+    let vramGB = 4;
+    let cudaAvailable = false;
+    // NVIDIA — works on Windows, Linux, macOS eGPU
+    const nvidiaSmiName = safeExec('nvidia-smi --query-gpu=name --format=csv,noheader');
+    const nvidiaSmiMem = safeExec('nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits');
+    if (nvidiaSmiName && nvidiaSmiMem) {
+        gpu = nvidiaSmiName.split('\n')[0].trim();
+        vramGB = Math.round(parseInt(nvidiaSmiMem) / 1024);
+        cudaAvailable = true;
+    }
+    // Apple Silicon — use hw.gpu.unified_mem for actual GPU memory
+    if (appleSilicon && gpu === 'Unknown GPU') {
+        const unifiedMem = safeExec('sysctl -n hw.gpu.unified_mem'); // actual GPU VRAM
+        const chipType = safeExec('sysctl -n machdep.cpu.brand_string');
+        if (unifiedMem)
+            vramGB = Math.round(parseInt(unifiedMem) / (1024 ** 3));
+        else
+            vramGB = Math.round(os_1.default.totalmem() / (1024 ** 3) / 2); // fallback: half of RAM
+        gpu = chipType || 'Apple Silicon GPU';
+    }
+    // Windows fallback — integrated/AMD via WMI
+    if (platform === 'windows' && gpu === 'Unknown GPU') {
+        const wmicOut = safeExec('wmic path Win32_VideoController get Name,AdapterRAM /format:csv');
+        const lines = wmicOut.split('\n').filter(l => l.includes(','));
+        if (lines[1]) {
+            const parts = lines[1].split(',');
+            const bytes = parseInt(parts[1] || '0');
+            if (bytes > 0)
+                vramGB = Math.round(bytes / (1024 ** 3));
+            gpu = parts[2]?.trim() || 'Windows GPU';
+        }
+    }
+    // Linux AMD
+    if (platform === 'linux' && gpu === 'Unknown GPU') {
+        try {
+            const mem = fs_1.default.readFileSync('/sys/class/drm/card0/device/mem_info_vram_total', 'utf-8').trim();
+            vramGB = Math.round(parseInt(mem) / (1024 ** 3));
+            gpu = 'AMD GPU';
+        }
+        catch { }
+    }
+    const profile = {
+        gpu, vramGB: Math.max(vramGB, 2),
+        ramGB: Math.round(os_1.default.totalmem() / (1024 ** 3)),
+        platform, cudaAvailable, appleSilicon,
+        detectedAt: new Date().toISOString()
+    };
+    fs_1.default.mkdirSync(path_1.default.dirname(CONFIG_PATH), { recursive: true });
+    fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify(profile, null, 2));
+    return profile;
+}
+// Force re-detect (ignores cache)
+function redetectHardware() {
+    if (fs_1.default.existsSync(CONFIG_PATH))
+        fs_1.default.unlinkSync(CONFIG_PATH);
+    return detectHardware();
+}

package/dist/core/hooks.js

@@ -0,0 +1,45 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHook = registerHook;
+exports.getHookCount = getHookCount;
+exports.fireHook = fireHook;
+exports.registerExternalHook = registerExternalHook;
+// ── Registry ───────────────────────────────────────────────────
+const registry = new Map();
+function registerHook(event, handler) {
+    const handlers = registry.get(event) ?? [];
+    handlers.push(handler);
+    registry.set(event, handlers);
+}
+function getHookCount(event) {
+    return registry.get(event)?.length ?? 0;
+}
+async function fireHook(event, payload) {
+    const handlers = registry.get(event);
+    if (!handlers || handlers.length === 0)
+        return;
+    console.log(`[Hooks] Firing "${event}" (${handlers.length} handler(s))`);
+    for (const handler of handlers) {
+        try {
+            await handler(payload);
+        }
+        catch (e) {
+            console.error(`[Hooks] Handler error for "${event}": ${e.message}`);
+        }
+    }
+}
+// ── Plugin hook registration ───────────────────────────────────
+// Validates the event is a known HookEvent before delegating to registerHook.
+const VALID_HOOK_EVENTS = ['pre_compact', 'session_stop', 'after_tool_call'];
+function registerExternalHook(event, handler, source) {
+    if (!VALID_HOOK_EVENTS.includes(event)) {
+        console.warn(`[Hooks] Plugin "${source}" tried unknown event "${event}" — valid: ${VALID_HOOK_EVENTS.join(', ')}`);
+        return;
+    }
+    registerHook(event, handler);
+    console.log(`[Hooks] Plugin "${source}" registered hook for "${event}"`);
+}

package/dist/core/httpKeepalive.js

@@ -0,0 +1,46 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupHttpKeepalive = setupHttpKeepalive;
+// core/httpKeepalive.ts — Phase 7 of Prompt 10.
+//
+// Sets a global undici Agent with TCP keepalive enabled.
+// All providers use Node.js global fetch(), which is backed by undici in
+// Node 18+.  A single call to setupHttpKeepalive() at server startup
+// eliminates the cold-connect TCP handshake on every LLM request.
+//
+// Keepalive settings:
+//   keepAliveTimeout       60 s  — hold idle connections this long
+//   keepAliveMaxTimeout   300 s  — server-driven max (Groq allows ~5 min)
+//   connections            50   — max concurrent sockets per origin
+//   pipelining              1   — one request per connection (safe for HTTP/1.1)
+//
+// Call once at startup:
+//   import { setupHttpKeepalive } from '../core/httpKeepalive'
+//   setupHttpKeepalive()
+const undici_1 = require("undici");
+let installed = false;
+/**
+ * Install a keepalive-enabled undici Agent as the global fetch dispatcher.
+ * Idempotent — safe to call multiple times.
+ */
+function setupHttpKeepalive() {
+    if (installed)
+        return;
+    const agent = new undici_1.Agent({
+        connect: {
+            keepAlive: true,
+            keepAliveInitialDelay: 0,
+        },
+        keepAliveTimeout: 60000, // 60 s idle before closing
+        keepAliveMaxTimeout: 300000, // 5 min hard cap
+        connections: 50, // sockets per origin
+        pipelining: 1, // no pipelining — safer with AI APIs
+    });
+    (0, undici_1.setGlobalDispatcher)(agent);
+    installed = true;
+    console.log('[HttpKeepalive] Global undici Agent installed — TCP keepalive active');
+}

package/dist/core/hybridSearch.js

@@ -0,0 +1,101 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hybridSearch = hybridSearch;
+// core/hybridSearch.ts — Weighted hybrid: semantic memory (0.6) + FTS (0.4).
+//
+// Combines:
+//   1. semanticMemory.search()  — BM25 + vector, workspace/memory/*.md store
+//   2. sessionSearch.searchSessions() — BM25 over workspace/sessions/*.md
+//
+// Scores are normalised to [0, 1] then merged with the weights above.
+// Deduplication: if a result appears in both sources, the max normalised
+// score is used (avoids double-counting).
+const semanticMemory_1 = require("./semanticMemory");
+const sessionSearch_1 = require("./sessionSearch");
+// ── Normalise an array of scores to [0, 1] ────────────────────
+function normalise(scores) {
+    const max = Math.max(...scores, 1e-9);
+    return scores.map(s => s / max);
+}
+// ── Simple snippet extractor ──────────────────────────────────
+function snippet(text, maxLen = 200) {
+    const s = text.replace(/\s+/g, ' ').trim();
+    return s.length <= maxLen ? s : s.slice(0, maxLen) + '…';
+}
+// ── Main hybrid search ────────────────────────────────────────
+/**
+ * Hybrid search combining semantic memory and BM25 session search.
+ *
+ * @param query   Natural-language query
+ * @param opts    Optional weight overrides and topK
+ */
+function hybridSearch(query, opts = {}) {
+    const topK = opts.topK ?? 5;
+    const wSem = opts.semanticWeight ?? 0.6;
+    const wFts = opts.ftsWeight ?? 0.4;
+    const fetch = topK * 3; // oversample before merging
+    // ── 1. Semantic memory results ────────────────────────────────
+    let semTexts = [];
+    try {
+        semTexts = semanticMemory_1.semanticMemory.searchText(query, fetch);
+    }
+    catch { /* ok */ }
+    const semHits = new Map();
+    const semScores = semTexts.map((_, i) => Math.max(0, 1 - i / fetch));
+    const normSem = normalise(semScores);
+    semTexts.forEach((text, i) => {
+        const id = `sem:${simpleHash(text)}`;
+        semHits.set(id, {
+            title: snippet(text, 60),
+            snippet: snippet(text),
+            rawScore: normSem[i] * wSem,
+            source: 'semantic',
+        });
+    });
+    // ── 2. Session FTS results ────────────────────────────────────
+    let ftsHits = [];
+    try {
+        ftsHits = (0, sessionSearch_1.searchSessions)(query, fetch);
+    }
+    catch { /* ok */ }
+    const ftsScores = ftsHits.map(h => h.score);
+    const normFts = normalise(ftsScores);
+    const ftsMap = new Map();
+    ftsHits.forEach((h, i) => {
+        ftsMap.set(`fts:${h.doc.id}`, {
+            title: h.doc.title,
+            snippet: snippet(h.doc.content),
+            rawScore: normFts[i] * wFts,
+        });
+    });
+    // ── 3. Merge ──────────────────────────────────────────────────
+    const merged = new Map();
+    for (const [id, h] of semHits) {
+        merged.set(id, { id, title: h.title, snippet: h.snippet, score: h.rawScore, source: 'semantic' });
+    }
+    for (const [id, h] of ftsMap) {
+        if (merged.has(id)) {
+            const existing = merged.get(id);
+            existing.score = Math.max(existing.score, h.rawScore);
+            existing.source = 'both';
+        }
+        else {
+            merged.set(id, { id, title: h.title, snippet: h.snippet, score: h.rawScore, source: 'session' });
+        }
+    }
+    return Array.from(merged.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+}
+// ── Simple string hash for dedup ──────────────────────────────
+function simpleHash(s) {
+    let h = 0;
+    for (let i = 0; i < Math.min(s.length, 64); i++) {
+        h = Math.imul(31, h) + s.charCodeAt(i) | 0;
+    }
+    return (h >>> 0).toString(36);
+}