aiden-runtime 3.16.0

package/dist/core/semanticMemory.js

@@ -0,0 +1,223 @@
+"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.semanticMemory = exports.SemanticMemory = void 0;
+// core/semanticMemory.ts — Local semantic memory with TF-IDF inspired
+// word-level embeddings. No external API required — pure JS math.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const bm25_1 = require("./bm25");
+const MEMORY_PATH = path_1.default.join(process.cwd(), 'workspace', 'semantic.json');
+// ── Temporal decay helpers ────────────────────────────────────
+const HALF_LIFE_DAYS = 30;
+const DECAY_LAMBDA = Math.LN2 / HALF_LIFE_DAYS;
+function applyTemporalDecay(results) {
+    const now = Date.now();
+    return results.map(r => {
+        // Facts and entities are evergreen — never decay
+        if (r.item.metadata.type === 'fact' || r.item.metadata.type === 'entity') {
+            return r;
+        }
+        const ageInDays = (now - r.item.metadata.timestamp) / 86400000;
+        const multiplier = Math.exp(-DECAY_LAMBDA * ageInDays);
+        return { ...r, score: r.score * multiplier };
+    }).sort((a, b) => b.score - a.score);
+}
+// ── MMR diversity re-ranking helpers ──────────────────────────
+function tokenize(text) {
+    return new Set(text.toLowerCase().split(/\W+/).filter(t => t.length > 2));
+}
+function jaccardSimilarity(a, b) {
+    const intersection = new Set([...a].filter(x => b.has(x)));
+    const union = new Set([...a, ...b]);
+    return union.size === 0 ? 0 : intersection.size / union.size;
+}
+function applyMMR(results, lambda = 0.7, maxResults = 10) {
+    if (results.length <= 1)
+        return results;
+    const selected = [];
+    const remaining = [...results];
+    // Always pick highest-scoring first
+    selected.push(remaining.shift());
+    while (selected.length < maxResults && remaining.length > 0) {
+        let bestIdx = 0;
+        let bestScore = -Infinity;
+        for (let i = 0; i < remaining.length; i++) {
+            const relevance = remaining[i].score;
+            const maxSim = Math.max(...selected.map(s => jaccardSimilarity(tokenize(remaining[i].item.text), tokenize(s.item.text))));
+            const mmrScore = lambda * relevance - (1 - lambda) * maxSim;
+            if (mmrScore > bestScore) {
+                bestScore = mmrScore;
+                bestIdx = i;
+            }
+        }
+        selected.push(remaining.splice(bestIdx, 1)[0]);
+    }
+    return selected;
+}
+class SemanticMemory {
+    constructor() {
+        this.data = [];
+        this.bm25 = new bm25_1.BM25();
+        this.bm25IndexBuilt = false;
+        this.load();
+    }
+    // ── Persistence ───────────────────────────────────────────────
+    load() {
+        try {
+            if (fs_1.default.existsSync(MEMORY_PATH)) {
+                this.data = JSON.parse(fs_1.default.readFileSync(MEMORY_PATH, 'utf-8'));
+            }
+        }
+        catch { }
+    }
+    save() {
+        try {
+            fs_1.default.mkdirSync(path_1.default.dirname(MEMORY_PATH), { recursive: true });
+            fs_1.default.writeFileSync(MEMORY_PATH, JSON.stringify(this.data, null, 2));
+        }
+        catch { }
+    }
+    // ── Embedding ─────────────────────────────────────────────────
+    // TF-IDF inspired bag-of-words embedding into 128-dim space.
+    // Uses polynomial rolling hash — similar topics yield similar vectors.
+    embed(text) {
+        const dim = 128;
+        const vec = new Array(dim).fill(0);
+        // Normalize and tokenize
+        const words = text
+            .toLowerCase()
+            .replace(/[^a-z0-9\s]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 2);
+        // Remove stop words
+        const stopWords = new Set([
+            'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can',
+            'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him',
+            'his', 'how', 'its', 'may', 'new', 'now', 'old', 'see', 'two',
+            'way', 'who', 'did', 'let', 'put', 'say', 'she', 'too', 'use',
+        ]);
+        const meaningful = words.filter(w => !stopWords.has(w));
+        // Hash each word into vector space using polynomial rolling hash
+        for (let wi = 0; wi < meaningful.length; wi++) {
+            const word = meaningful[wi];
+            let h1 = 0, h2 = 0;
+            for (let i = 0; i < word.length; i++) {
+                const c = word.charCodeAt(i);
+                h1 = (h1 * 31 + c) % dim;
+                h2 = (h2 * 37 + c) % dim;
+            }
+            // Boost by word length — longer words carry more meaning
+            const weight = Math.log(word.length + 1);
+            vec[h1] += weight;
+            vec[h2] += weight * 0.5;
+            // Bigram context — captures phrase meaning
+            if (wi > 0) {
+                const prev = meaningful[wi - 1];
+                let bh = 0;
+                for (let i = 0; i < prev.length && i < 4; i++) {
+                    bh = (bh * 41 + prev.charCodeAt(i)) % dim;
+                }
+                vec[(h1 + bh) % dim] += 0.3;
+            }
+        }
+        // L2 normalize
+        const mag = Math.sqrt(vec.reduce((s, v) => s + v * v, 0)) + 1e-8;
+        return vec.map(v => v / mag);
+    }
+    cosine(a, b) {
+        let dot = 0;
+        for (let i = 0; i < a.length; i++)
+            dot += a[i] * b[i];
+        return Math.max(0, Math.min(1, dot)); // already L2-normalized
+    }
+    // ── Public API ────────────────────────────────────────────────
+    add(text, type = 'exchange', tags) {
+        if (!text.trim() || text.length < 10)
+            return;
+        // Don't store duplicates
+        const existing = this.data.find(d => d.text === text);
+        if (existing)
+            return;
+        const item = {
+            id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            text: text.slice(0, 500),
+            embedding: this.embed(text),
+            metadata: { type, timestamp: Date.now(), tags },
+        };
+        this.data.push(item);
+        this.bm25IndexBuilt = false; // Sprint 14: invalidate BM25 index on new item
+        // Keep max 500 items — remove oldest
+        if (this.data.length > 500) {
+            this.data = this.data
+                .sort((a, b) => b.metadata.timestamp - a.metadata.timestamp)
+                .slice(0, 500);
+        }
+        this.save();
+    }
+    // ── BM25 index builder ────────────────────────────────────────
+    buildBM25Index() {
+        const texts = this.data.map(d => d.text);
+        if (texts.length > 0) {
+            this.bm25.index(texts);
+            this.bm25IndexBuilt = true;
+        }
+    }
+    // ── Vector-only search ────────────────────────────────────────
+    vectorSearch(query, topK) {
+        const qVec = this.embed(query);
+        return this.data
+            .map((item, index) => ({ index, score: this.cosine(qVec, item.embedding) }))
+            .filter(r => r.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, topK);
+    }
+    // ── Hybrid search: BM25 + vector with reciprocal rank fusion ──
+    search(query, topK = 5, minScore = 0.3) {
+        if (this.data.length === 0)
+            return [];
+        if (!this.bm25IndexBuilt)
+            this.buildBM25Index();
+        const fetch = topK * 2;
+        // BM25 reciprocal rank scores (weight 0.4)
+        const bm25Results = this.bm25.search(query, fetch);
+        const bm25Scores = new Map();
+        bm25Results.forEach((r, rank) => bm25Scores.set(r.index, 1 / (rank + 1)));
+        // Vector reciprocal rank scores (weight 0.6)
+        const vectorResults = this.vectorSearch(query, fetch);
+        const vectorScores = new Map();
+        vectorResults.forEach((r, rank) => vectorScores.set(r.index, 1 / (rank + 1)));
+        // Reciprocal rank fusion
+        const allIndices = new Set([...bm25Scores.keys(), ...vectorScores.keys()]);
+        const fused = Array.from(allIndices)
+            .map(idx => ({
+            item: this.data[idx],
+            score: (bm25Scores.get(idx) || 0) * 0.4 + (vectorScores.get(idx) || 0) * 0.6,
+        }))
+            .filter(r => r.item && r.score >= minScore)
+            .sort((a, b) => b.score - a.score);
+        // Feature 4: temporal decay — recent memories rank higher
+        const decayed = applyTemporalDecay(fused);
+        // Feature 5: MMR diversity — prevent duplicate daily-note results
+        const diverse = applyMMR(decayed, 0.7, topK);
+        return diverse.map(r => r.item);
+    }
+    searchText(query, topK = 3) {
+        return this.search(query, topK).map(item => item.text);
+    }
+    getStats() {
+        const byType = {};
+        this.data.forEach(d => {
+            byType[d.metadata.type] = (byType[d.metadata.type] || 0) + 1;
+        });
+        return { total: this.data.length, byType };
+    }
+}
+exports.SemanticMemory = SemanticMemory;
+exports.semanticMemory = new SemanticMemory();

package/dist/core/sessionMemory.js

@@ -0,0 +1,259 @@
+"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.sessionMemory = void 0;
+exports.saveSessionMetadata = saveSessionMetadata;
+exports.loadSessionMetadata = loadSessionMetadata;
+exports.getSessionLineage = getSessionLineage;
+exports.createChildSession = createChildSession;
+// core/sessionMemory.ts — Per-session markdown log.
+// After every 5 exchanges AND on conversation end, a background
+// agent writes/updates workspace/sessions/{sessionId}.md.
+// Injects last session context at conversation start.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const auxiliaryClient_1 = require("./auxiliaryClient");
+const SESSIONS_DIR = path_1.default.join(process.env.AIDEN_USER_DATA || process.cwd(), 'workspace', 'sessions');
+function metaPath(sessionId) {
+    return path_1.default.join(SESSIONS_DIR, `${sessionId}.meta.json`);
+}
+function saveSessionMetadata(meta) {
+    try {
+        fs_1.default.mkdirSync(SESSIONS_DIR, { recursive: true });
+        fs_1.default.writeFileSync(metaPath(meta.id), JSON.stringify(meta, null, 2), 'utf-8');
+    }
+    catch (e) {
+        console.error('[SessionLineage] Save failed:', e.message);
+    }
+}
+function loadSessionMetadata(sessionId) {
+    try {
+        const p = metaPath(sessionId);
+        if (!fs_1.default.existsSync(p))
+            return null;
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getSessionLineage(sessionId) {
+    const lineage = [];
+    let current = loadSessionMetadata(sessionId);
+    if (!current)
+        return lineage;
+    const visited = new Set();
+    // Walk back to root via parentId chain
+    while (current && !visited.has(current.id)) {
+        visited.add(current.id);
+        lineage.unshift(current);
+        if (!current.parentId)
+            break;
+        current = loadSessionMetadata(current.parentId);
+    }
+    // Walk forward from tail to include any children not yet visited
+    let tail = lineage[lineage.length - 1];
+    while (tail?.childId && !visited.has(tail.childId)) {
+        visited.add(tail.childId);
+        const child = loadSessionMetadata(tail.childId);
+        if (!child)
+            break;
+        lineage.push(child);
+        tail = child;
+    }
+    return lineage;
+}
+function createChildSession(parentSessionId, reason, messageCount, tokenCount) {
+    const childId = `session_${Date.now()}`;
+    const now = Date.now();
+    // Load or bootstrap parent metadata
+    const parentMeta = loadSessionMetadata(parentSessionId) ?? {
+        id: parentSessionId,
+        depth: 0,
+        originalSessionId: parentSessionId,
+        createdAt: now,
+    };
+    // Stamp compression info on parent
+    parentMeta.childId = childId;
+    parentMeta.compressedAt = now;
+    parentMeta.messageCountBeforeCompression = messageCount;
+    parentMeta.tokenCountBeforeCompression = tokenCount;
+    saveSessionMetadata(parentMeta);
+    // Create child metadata
+    const childMeta = {
+        id: childId,
+        parentId: parentSessionId,
+        depth: parentMeta.depth + 1,
+        compressionReason: reason,
+        originalSessionId: parentMeta.originalSessionId,
+        createdAt: now,
+    };
+    saveSessionMetadata(childMeta);
+    console.log(`[SessionLineage] Created child ${childId} (depth ${childMeta.depth}) from ${parentSessionId}`);
+    return childId;
+}
+// ── Section headers (must match exactly) ──────────────────────
+const SECTION_HEADERS = [
+    '# Session Title',
+    '# Current State',
+    '# What the User Asked',
+    '# Files Touched',
+    '# Commands Run',
+    '# Errors & Fixes',
+    '# Learnings',
+    '# Results',
+    '# Worklog',
+];
+// ── Helpers ───────────────────────────────────────────────────
+function sessionPath(sessionId) {
+    return path_1.default.join(SESSIONS_DIR, `${sessionId}.md`);
+}
+function buildPrompt(state) {
+    const msgs = state.exchanges.map(e => `[${e.role.toUpperCase()}] ${e.content.slice(0, 600)}`).join('\n\n');
+    const files = state.exchanges.flatMap(e => e.files ?? []).filter(Boolean);
+    const cmds = state.exchanges.flatMap(e => e.cmds ?? []).filter(Boolean);
+    const errors = state.exchanges.flatMap(e => e.errors ?? []).filter(Boolean);
+    return `You are a session memory writer for DevOS. Based on the conversation below, write a session summary in this exact format with these exact headers (never change the headers):
+
+# Session Title
+_A short 5-10 word title_
+
+# Current State
+_What's being worked on right now? Next steps?_
+
+# What the User Asked
+_The original goal. Design decisions made._
+
+# Files Touched
+_Important files and what was done to them._
+
+# Commands Run
+_Key commands and their purpose._
+
+# Errors & Fixes
+_What broke and how it was resolved._
+
+# Learnings
+_What worked, what didn't, what to avoid next time._
+
+# Results
+_Key outputs or answers produced._
+
+# Worklog
+_Terse step-by-step of what happened._
+
+CONVERSATION:
+${msgs}
+
+FILES TOUCHED: ${files.join(', ') || 'none'}
+COMMANDS RUN: ${cmds.join(', ') || 'none'}
+ERRORS: ${errors.join(', ') || 'none'}
+
+Write the session summary now. Use the exact headers shown above.`;
+}
+// ── SessionMemory ─────────────────────────────────────────────
+class SessionMemory {
+    constructor() {
+        this.sessions = new Map();
+        try {
+            fs_1.default.mkdirSync(SESSIONS_DIR, { recursive: true });
+        }
+        catch { }
+    }
+    // ── Start / get session ───────────────────────────────────
+    getOrCreate(sessionId) {
+        if (!this.sessions.has(sessionId)) {
+            this.sessions.set(sessionId, {
+                sessionId,
+                startTs: Date.now(),
+                exchanges: [],
+            });
+        }
+        return this.sessions.get(sessionId);
+    }
+    // ── Add exchange ──────────────────────────────────────────
+    addExchange(sessionId, userMsg, aiMsg, files, cmds, errors) {
+        const state = this.getOrCreate(sessionId);
+        state.exchanges.push({ role: 'user', content: userMsg, ts: Date.now() });
+        state.exchanges.push({ role: 'assistant', content: aiMsg, ts: Date.now(), files, cmds, errors });
+        // Every 5 exchange pairs (10 messages), write in background
+        const pairs = Math.floor(state.exchanges.length / 2);
+        if (pairs > 0 && pairs % 5 === 0) {
+            setTimeout(() => { this.writeSession(sessionId).catch(() => { }); }, 100);
+        }
+    }
+    // ── End session ───────────────────────────────────────────
+    endSession(sessionId) {
+        setTimeout(() => { this.writeSession(sessionId).catch(() => { }); }, 100);
+    }
+    // ── Write session file ────────────────────────────────────
+    async writeSession(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state || state.exchanges.length === 0)
+            return;
+        try {
+            const prompt = buildPrompt(state);
+            const content = await auxiliaryClient_1.auxiliaryClient.complete(prompt, { task: 'reflection', maxTokens: 500 });
+            if (!content || !content.includes('# Session Title'))
+                return;
+            const filePath = sessionPath(sessionId);
+            fs_1.default.writeFileSync(filePath, content, 'utf-8');
+            state.lastWrittenAt = Date.now();
+            console.log(`[SessionMemory] Written: ${filePath}`);
+        }
+        catch (e) {
+            console.error('[SessionMemory] Write failed:', e.message);
+        }
+    }
+    // ── Get last session context (inject at conversation start) ─
+    getLastContext(sessionId) {
+        // Try exact session file first
+        const exact = sessionPath(sessionId);
+        if (fs_1.default.existsSync(exact)) {
+            try {
+                return fs_1.default.readFileSync(exact, 'utf-8').slice(0, 2000);
+            }
+            catch { }
+        }
+        // Fall back to most recent session file
+        try {
+            if (!fs_1.default.existsSync(SESSIONS_DIR))
+                return '';
+            const files = fs_1.default.readdirSync(SESSIONS_DIR)
+                .filter(f => f.endsWith('.md'))
+                .map(f => ({
+                name: f,
+                mtime: fs_1.default.statSync(path_1.default.join(SESSIONS_DIR, f)).mtimeMs,
+            }))
+                .sort((a, b) => b.mtime - a.mtime);
+            if (files.length === 0)
+                return '';
+            const latest = path_1.default.join(SESSIONS_DIR, files[0].name);
+            return fs_1.default.readFileSync(latest, 'utf-8').slice(0, 2000);
+        }
+        catch {
+            return '';
+        }
+    }
+    // ── List sessions ──────────────────────────────────────────
+    listSessions() {
+        try {
+            if (!fs_1.default.existsSync(SESSIONS_DIR))
+                return [];
+            return fs_1.default.readdirSync(SESSIONS_DIR)
+                .filter(f => f.endsWith('.md'))
+                .sort();
+        }
+        catch {
+            return [];
+        }
+    }
+}
+// ── Singleton ──────────────────────────────────────────────────
+exports.sessionMemory = new SessionMemory();

package/dist/core/sessionRouter.js

@@ -0,0 +1,91 @@
+"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.sessionRouter = void 0;
+// core/sessionRouter.ts — Cross-channel session tracking.
+// Maintains a stable sessionId per user so conversation history
+// is shared regardless of whether the user is on Telegram,
+// the dashboard, or any future channel.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ── SessionRouter class ────────────────────────────────────────
+class SessionRouter {
+    constructor() {
+        this.sessions = new Map();
+        this.userToSession = new Map();
+    }
+    // ── Get or create session for a user ─────────────────────────
+    getSession(userId, channel) {
+        const existingId = this.userToSession.get(userId);
+        if (existingId && this.sessions.has(existingId)) {
+            const session = this.sessions.get(existingId);
+            session.lastChannel = channel;
+            session.lastActivity = Date.now();
+            if (!session.channels.includes(channel)) {
+                session.channels.push(channel);
+                console.log(`[Session] User ${userId} continued on ${channel} ` +
+                    `(started on ${session.channels[0]})`);
+            }
+            return session;
+        }
+        // Create new session
+        const session = {
+            sessionId: `session_${Date.now()}`,
+            userId,
+            channels: [channel],
+            lastChannel: channel,
+            lastActivity: Date.now(),
+            messageCount: 0,
+        };
+        this.sessions.set(session.sessionId, session);
+        this.userToSession.set(userId, session.sessionId);
+        return session;
+    }
+    // ── Load persisted conversation history for a session ────────
+    // Reads from workspace/sessions/<sessionId>.json if it exists.
+    // The actual continuity comes from conversationMemory.setSession()
+    // receiving the stable sessionId — this is a foundation for
+    // future per-session file-based export / mobile sync.
+    getHistory(userId) {
+        const sessionId = this.userToSession.get(userId);
+        if (!sessionId)
+            return [];
+        const sessionFile = path_1.default.join(process.cwd(), 'workspace', 'sessions', `${sessionId}.json`);
+        if (fs_1.default.existsSync(sessionFile)) {
+            try {
+                const data = JSON.parse(fs_1.default.readFileSync(sessionFile, 'utf8'));
+                return data.messages || [];
+            }
+            catch { }
+        }
+        return [];
+    }
+    // ── Log a cross-channel continuation event ───────────────────
+    markContinuation(userId, fromChannel, toChannel) {
+        const session = this.getSession(userId, toChannel);
+        console.log(`[Session] Continuation: ${fromChannel} → ${toChannel} ` +
+            `(${session.messageCount} messages in history)`);
+    }
+    // ── Return channels for a given session ID ───────────────────
+    // Used by /api/sessions to enrich the session list response.
+    getSessionChannels(sessionId) {
+        return this.sessions.get(sessionId)?.channels ?? [];
+    }
+    // ── Expire sessions older than 24 h ──────────────────────────
+    cleanup() {
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        for (const [id, session] of this.sessions) {
+            if (session.lastActivity < cutoff) {
+                this.sessions.delete(id);
+                this.userToSession.delete(session.userId);
+            }
+        }
+    }
+}
+exports.sessionRouter = new SessionRouter();