aiden-runtime 3.16.0

package/dist/core/importers.js

@@ -0,0 +1,164 @@
+"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.importChatGPT = importChatGPT;
+exports.importOpenClaw = importOpenClaw;
+// core/importers.ts — Import conversation history from ChatGPT
+// (conversations.json export) and OpenClaw (memory.md files)
+// into Aiden's Knowledge Base and workspace memory.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const knowledgeBase_1 = require("./knowledgeBase");
+const WORKSPACE_ROOT = process.env.AIDEN_USER_DATA || process.cwd();
+const MEMORY_DIR = path_1.default.join(WORKSPACE_ROOT, 'workspace', 'memory');
+// ── ChatGPT importer ──────────────────────────────────────────
+// Parses the conversations.json from a ChatGPT data export.
+//
+// Export format:
+//   Array<{ title: string, mapping: Record<id, { message: {
+//     author: { role: 'user'|'assistant' },
+//     content: { parts: string[] }
+//   }}> }>
+async function importChatGPT(filePath) {
+    const result = {
+        source: 'chatgpt',
+        conversationsImported: 0,
+        memoriesExtracted: 0,
+        errors: [],
+    };
+    try {
+        const raw = fs_1.default.readFileSync(filePath, 'utf8');
+        const conversations = JSON.parse(raw);
+        if (!Array.isArray(conversations)) {
+            result.errors.push('Invalid format: expected array of conversations');
+            return result;
+        }
+        for (const convo of conversations) {
+            try {
+                const messages = [];
+                if (convo.mapping && typeof convo.mapping === 'object') {
+                    for (const entry of Object.values(convo.mapping)) {
+                        const msg = entry?.message;
+                        if (!msg)
+                            continue;
+                        const parts = msg?.content?.parts;
+                        if (!Array.isArray(parts) || typeof parts[0] !== 'string')
+                            continue;
+                        const text = parts[0].trim();
+                        if (text.length <= 10)
+                            continue;
+                        const role = msg.author?.role || 'unknown';
+                        messages.push(`${role}: ${text}`);
+                    }
+                }
+                if (messages.length === 0)
+                    continue;
+                const content = messages.join('\n\n').substring(0, 50000);
+                const title = String(convo.title || 'ChatGPT Import').replace(/[^a-zA-Z0-9._\- ]/g, '_').slice(0, 80);
+                const filename = `chatgpt_${title}.txt`;
+                const ingestResult = knowledgeBase_1.knowledgeBase.ingestText(content, filename, 'conversation', ['chatgpt', 'imported', 'conversation'], 'public');
+                if (ingestResult.success) {
+                    result.conversationsImported++;
+                }
+                else {
+                    result.errors.push(`Ingestion failed for: ${title}`);
+                }
+            }
+            catch (err) {
+                result.errors.push(`Failed to import: ${String(convo.title || 'unknown')}`);
+            }
+        }
+        console.log(`[Import] ChatGPT: ${result.conversationsImported} conversations imported`);
+    }
+    catch (err) {
+        result.errors.push(`Parse error: ${String(err)}`);
+    }
+    return result;
+}
+// ── OpenClaw importer ─────────────────────────────────────────
+// Walks an OpenClaw workspace directory, ingests every .md file
+// into the Knowledge Base, and copies memory/lessons files into
+// workspace/memory/ so Aiden can surface them during planning.
+function findMdFiles(dir) {
+    const files = [];
+    try {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                files.push(...findMdFiles(fullPath));
+            }
+            else if (entry.name.endsWith('.md')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch { }
+    return files;
+}
+async function importOpenClaw(directoryPath) {
+    const result = {
+        source: 'openclaw',
+        conversationsImported: 0,
+        memoriesExtracted: 0,
+        errors: [],
+    };
+    if (!fs_1.default.existsSync(directoryPath)) {
+        result.errors.push(`Directory not found: ${directoryPath}`);
+        return result;
+    }
+    const mdFiles = findMdFiles(directoryPath);
+    for (const file of mdFiles) {
+        try {
+            const content = fs_1.default.readFileSync(file, 'utf8');
+            if (content.trim().length < 50)
+                continue; // skip empty/trivial files
+            const basename = path_1.default.basename(file, '.md');
+            const lower = file.toLowerCase();
+            const isMemory = lower.includes('memory');
+            const isLesson = lower.includes('lesson');
+            const isDaily = /\d{4}[-_]\d{2}[-_]\d{2}/.test(basename);
+            const category = isMemory ? 'memory'
+                : isLesson ? 'lessons'
+                    : isDaily ? 'daily-log'
+                        : 'document';
+            const filename = `openclaw_${basename.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 60)}.md`;
+            const ingestResult = knowledgeBase_1.knowledgeBase.ingestText(content.substring(0, 50000), filename, category, ['openclaw', 'imported', category], 'public');
+            if (ingestResult.success) {
+                result.conversationsImported++;
+            }
+            else {
+                result.errors.push(`Ingestion failed: ${basename}`);
+            }
+            // Copy memory and lesson files into workspace/memory/ so the
+            // memory recall system can surface them during planning
+            if (isMemory || isLesson) {
+                try {
+                    fs_1.default.mkdirSync(MEMORY_DIR, { recursive: true });
+                    const destName = `imported_${basename.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 60)}.md`;
+                    const destPath = path_1.default.join(MEMORY_DIR, destName);
+                    // Only write if not already present (avoid duplicate on re-import)
+                    if (!fs_1.default.existsSync(destPath)) {
+                        fs_1.default.writeFileSync(destPath, `<!-- source: openclaw_import | confidence: 0.7 -->\n${content}`, 'utf8');
+                        result.memoriesExtracted++;
+                    }
+                }
+                catch (memErr) {
+                    result.errors.push(`Memory copy failed: ${basename} — ${String(memErr)}`);
+                }
+            }
+        }
+        catch (err) {
+            result.errors.push(`Failed: ${path_1.default.basename(file)}`);
+        }
+    }
+    console.log(`[Import] OpenClaw: ${result.conversationsImported} files ingested, ` +
+        `${result.memoriesExtracted} memories extracted`);
+    return result;
+}

package/dist/core/instinctSystem.js

@@ -0,0 +1,223 @@
+"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.instinctSystem = void 0;
+exports.initInstinctSystem = initInstinctSystem;
+// core/instinctSystem.ts — Micro-pattern instinct layer.
+// Sits BELOW skills. Instincts are atomic "when X do Y" patterns
+// with confidence scores. When 3+ related instincts cluster with
+// enough total confidence, they evolve into a full SKILL.md.
+const fs_1 = require("fs");
+const path_1 = require("path");
+// ── Thresholds ─────────────────────────────────────────────────
+const CONFIDENCE_GAIN = 0.1;
+const CONFIDENCE_LOSS = 0.2;
+const DEPRECATION_THRESHOLD = 0.2;
+const EVOLUTION_MIN_COUNT = 3;
+const EVOLUTION_MIN_CONFIDENCE = 2.0; // sum of confidences across group
+// ── InstinctSystem ─────────────────────────────────────────────
+function tokenize(text) {
+    return text.toLowerCase().split(/\W+/).filter(w => w.length > 3);
+}
+class InstinctSystem {
+    constructor(workspaceDir) {
+        this.instincts = [];
+        this._saveTimer = null;
+        // CRITICAL: instincts are workspace-scoped.
+        // Trading instincts don't leak into DevOS work.
+        this.savePath = (0, path_1.join)(workspaceDir, 'instincts.json');
+        this.learnedDir = (0, path_1.join)(workspaceDir, 'skills', 'learned');
+        this.load();
+    }
+    // ── Observe a tool call ───────────────────────────────────────
+    observe(toolName, args, success, sessionId) {
+        const argSnippet = JSON.stringify(args).slice(0, 80);
+        const action = success
+            ? `Use ${toolName} with args like ${argSnippet}`
+            : `Avoid ${toolName} when args like ${argSnippet} — fails`;
+        const words = tokenize(action);
+        const existing = this.findSimilar(words);
+        if (existing) {
+            if (success) {
+                existing.confidence = Math.min(0.95, existing.confidence + CONFIDENCE_GAIN);
+                if (!existing.evidence.includes(sessionId)) {
+                    existing.evidence.push(sessionId);
+                }
+            }
+            else {
+                existing.confidence -= CONFIDENCE_LOSS;
+                existing.contradictions++;
+                if (existing.confidence < DEPRECATION_THRESHOLD) {
+                    existing.status = 'deprecated';
+                    console.log(`[Instinct] Deprecated: "${existing.action.slice(0, 60)}"`);
+                }
+            }
+            existing.lastSeen = new Date().toISOString();
+        }
+        else if (success) {
+            this.instincts.push({
+                id: `inst_${Date.now()}`,
+                action,
+                words,
+                evidence: [sessionId],
+                confidence: 0.3,
+                category: 'tool_pattern',
+                created: new Date().toISOString(),
+                lastSeen: new Date().toISOString(),
+                contradictions: 0,
+                status: 'active',
+            });
+        }
+        this.checkEvolution();
+        this.save();
+    }
+    // ── Word-overlap similarity — 3+ shared words = same instinct ─
+    // Accepts pre-tokenized words to avoid re-tokenizing the incoming action.
+    // Uses inst.words cache so each stored instinct is tokenized only once.
+    findSimilar(incomingWords) {
+        const wordSet = new Set(incomingWords);
+        return this.instincts.find(inst => {
+            if (inst.status !== 'active')
+                return false;
+            // inst.words may be absent on instincts loaded from disk before this field existed
+            const instWords = inst.words ?? (inst.words = tokenize(inst.action));
+            return instWords.filter(w => wordSet.has(w)).length >= 3;
+        });
+    }
+    // ── Evolution check — cluster 3+ high-confidence instincts ────
+    checkEvolution() {
+        // Skip when too few active instincts to possibly meet EVOLUTION_MIN_COUNT
+        const activeCount = this.instincts.filter(i => i.status === 'active').length;
+        if (activeCount < EVOLUTION_MIN_COUNT)
+            return;
+        const byCategory = new Map();
+        for (const inst of this.instincts) {
+            if (inst.status !== 'active')
+                continue;
+            const group = byCategory.get(inst.category) ?? [];
+            group.push(inst);
+            byCategory.set(inst.category, group);
+        }
+        for (const [, group] of byCategory) {
+            if (group.length < EVOLUTION_MIN_COUNT)
+                continue;
+            const totalConfidence = group.reduce((sum, i) => sum + i.confidence, 0);
+            if (totalConfidence < EVOLUTION_MIN_CONFIDENCE)
+                continue;
+            const skillName = `evolved_${group[0].category}_${Date.now()}`;
+            console.log(`[Instinct] Evolving ${group.length} instincts into skill: ${skillName}`);
+            for (const inst of group) {
+                inst.status = 'evolved_into';
+                inst.evolvedInto = skillName;
+            }
+            this.notifyEvolution(skillName, group);
+        }
+    }
+    // ── Write a SKILL.md directory for SkillLoader to pick up ─────
+    // SkillLoader expects: skills/learned/{name}/SKILL.md
+    // A flat .md file would be skipped (isDirectory() check).
+    notifyEvolution(skillName, instincts) {
+        const skillDir = (0, path_1.join)(this.learnedDir, skillName);
+        const skillFile = (0, path_1.join)(skillDir, 'SKILL.md');
+        const content = [
+            `---`,
+            `name: ${skillName}`,
+            `description: Evolved from ${instincts.length} observed tool patterns`,
+            `version: 1.0.0`,
+            `confidence: low`,
+            `tags: ${instincts[0].category}, evolved, auto-generated`,
+            `---`,
+            ``,
+            `## Source Instincts`,
+            ...instincts.map(i => `- ${i.action} (confidence: ${(i.confidence * 100).toFixed(0)}%)`),
+            ``,
+            `## Summary`,
+            `This skill evolved from ${instincts.length} observed patterns in category "${instincts[0].category}".`,
+        ].join('\n');
+        try {
+            (0, fs_1.mkdirSync)(skillDir, { recursive: true });
+            (0, fs_1.writeFileSync)(skillFile, content);
+            console.log(`[Instinct] Wrote evolved skill: ${skillFile}`);
+            // Invalidate skillLoader cache so new skill is picked up
+            Promise.resolve().then(() => __importStar(require('./skillLoader'))).then(m => m.skillLoader.refresh()).catch(() => { });
+        }
+        catch (e) {
+            console.warn(`[Instinct] Failed to write evolved skill: ${e.message}`);
+        }
+    }
+    // ── Retrieve top instincts relevant to current context ────────
+    getRelevantInstincts(context) {
+        const active = this.instincts
+            .filter(i => i.status === 'active' && i.confidence > 0.5)
+            .sort((a, b) => b.confidence - a.confidence)
+            .slice(0, 5);
+        if (active.length === 0)
+            return '';
+        return ('Learned patterns:\n' +
+            active
+                .map(i => `- ${i.action} (confidence: ${(i.confidence * 100).toFixed(0)}%)`)
+                .join('\n'));
+    }
+    // ── Persistence ───────────────────────────────────────────────
+    load() {
+        try {
+            this.instincts = JSON.parse((0, fs_1.readFileSync)(this.savePath, 'utf8'));
+        }
+        catch {
+            this.instincts = [];
+        }
+    }
+    // Debounced — coalesces rapid bursts of tool calls into one disk write
+    save() {
+        if (this._saveTimer)
+            return;
+        this._saveTimer = setTimeout(() => {
+            this._saveTimer = null;
+            try {
+                (0, fs_1.mkdirSync)((0, path_1.dirname)(this.savePath), { recursive: true });
+                (0, fs_1.writeFileSync)(this.savePath, JSON.stringify(this.instincts, null, 2));
+            }
+            catch { }
+        }, 2000);
+    }
+}
+function initInstinctSystem(workspaceDir) {
+    exports.instinctSystem = new InstinctSystem(workspaceDir);
+    console.log('[Instinct] System initialized');
+}