@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/mind/memory.js

@@ -0,0 +1,388 @@
+"use strict";
+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.__memoryTestUtils = void 0;
+exports.ensureMemoryStorePaths = ensureMemoryStorePaths;
+exports.appendFactsWithDedup = appendFactsWithDedup;
+exports.readMemoryFacts = readMemoryFacts;
+exports.saveMemoryFact = saveMemoryFact;
+exports.backfillEmbeddings = backfillEmbeddings;
+exports.searchMemoryFacts = searchMemoryFacts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const DEDUP_THRESHOLD = 0.6;
+const ENTITY_TOKEN = /[a-z0-9]+/g;
+const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+class OpenAIEmbeddingProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async embed(texts) {
+        const response = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input: texts,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
+        }
+        const payload = (await response.json());
+        if (!payload.data || payload.data.length !== texts.length) {
+            throw new Error("embedding response missing expected vectors");
+        }
+        return payload.data.map((entry) => entry.embedding);
+    }
+}
+function ensureMemoryStorePaths(rootDir) {
+    const factsPath = path.join(rootDir, "facts.jsonl");
+    const entitiesPath = path.join(rootDir, "entities.json");
+    const dailyDir = path.join(rootDir, "daily");
+    fs.mkdirSync(rootDir, { recursive: true });
+    fs.mkdirSync(dailyDir, { recursive: true });
+    if (!fs.existsSync(factsPath))
+        fs.writeFileSync(factsPath, "", "utf8");
+    if (!fs.existsSync(entitiesPath))
+        fs.writeFileSync(entitiesPath, "{}\n", "utf8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.memory_paths_ready",
+        message: "memory store paths ready",
+        meta: { rootDir },
+    });
+    return { rootDir, factsPath, entitiesPath, dailyDir };
+}
+function overlapScore(left, right) {
+    const leftWords = new Set(left
+        .toLowerCase()
+        .split(/[^a-z0-9]+/g)
+        .filter(Boolean));
+    const rightWords = new Set(right
+        .toLowerCase()
+        .split(/[^a-z0-9]+/g)
+        .filter(Boolean));
+    if (leftWords.size === 0 || rightWords.size === 0)
+        return 0;
+    let common = 0;
+    for (const word of leftWords) {
+        if (rightWords.has(word))
+            common++;
+    }
+    return common / Math.min(leftWords.size, rightWords.size);
+}
+function readExistingFacts(factsPath) {
+    if (!fs.existsSync(factsPath))
+        return [];
+    const raw = fs.readFileSync(factsPath, "utf8").trim();
+    if (!raw)
+        return [];
+    return raw
+        .split("\n")
+        .map((line) => JSON.parse(line));
+}
+function readEntityIndex(entitiesPath) {
+    if (!fs.existsSync(entitiesPath))
+        return {};
+    try {
+        const raw = fs.readFileSync(entitiesPath, "utf8").trim();
+        if (!raw)
+            return {};
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function writeEntityIndex(entitiesPath, index) {
+    fs.writeFileSync(entitiesPath, JSON.stringify(index, null, 2) + "\n", "utf8");
+}
+function extractEntityTokens(text) {
+    const matches = text.toLowerCase().match(ENTITY_TOKEN) ?? [];
+    return [...new Set(matches.filter((token) => token.length >= 3))];
+}
+function updateEntityIndex(entitiesPath, fact) {
+    const index = readEntityIndex(entitiesPath);
+    const tokens = extractEntityTokens(fact.text);
+    for (const token of tokens) {
+        const existing = index[token];
+        if (existing) {
+            existing.count += 1;
+            if (!existing.factIds.includes(fact.id))
+                existing.factIds.push(fact.id);
+            existing.lastSeenAt = fact.createdAt;
+            continue;
+        }
+        index[token] = {
+            count: 1,
+            factIds: [fact.id],
+            lastSeenAt: fact.createdAt,
+        };
+    }
+    writeEntityIndex(entitiesPath, index);
+}
+function appendDailyFact(dailyDir, fact) {
+    fs.mkdirSync(dailyDir, { recursive: true });
+    const day = fact.createdAt.slice(0, 10) || "unknown";
+    const dayPath = path.join(dailyDir, `${day}.jsonl`);
+    fs.appendFileSync(dayPath, `${JSON.stringify(fact)}\n`, "utf8");
+}
+function appendFactsWithDedup(stores, incoming) {
+    const existing = readExistingFacts(stores.factsPath);
+    const all = [...existing];
+    let added = 0;
+    let skipped = 0;
+    for (const fact of incoming) {
+        const duplicate = all.some((prior) => overlapScore(prior.text, fact.text) > DEDUP_THRESHOLD);
+        if (duplicate) {
+            skipped++;
+            continue;
+        }
+        all.push(fact);
+        added++;
+        fs.appendFileSync(stores.factsPath, `${JSON.stringify(fact)}\n`, "utf8");
+        updateEntityIndex(stores.entitiesPath, fact);
+        appendDailyFact(stores.dailyDir, fact);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.memory_write",
+        message: "memory write completed",
+        meta: { added, skipped },
+    });
+    return { added, skipped };
+}
+function cosineSimilarity(left, right) {
+    if (left.length === 0 || right.length === 0 || left.length !== right.length)
+        return 0;
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let i = 0; i < left.length; i += 1) {
+        dot += left[i] * right[i];
+        leftNorm += left[i] * left[i];
+        rightNorm += right[i] * right[i];
+    }
+    if (leftNorm === 0 || rightNorm === 0)
+        return 0;
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+exports.__memoryTestUtils = {
+    cosineSimilarity,
+};
+function createDefaultEmbeddingProvider() {
+    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)().trim();
+    if (!apiKey)
+        return null;
+    return new OpenAIEmbeddingProvider(apiKey);
+}
+async function buildEmbedding(text, embeddingProvider) {
+    const provider = embeddingProvider ?? createDefaultEmbeddingProvider();
+    if (!provider) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.memory_embedding_unavailable",
+            message: "embedding provider unavailable for memory write",
+            meta: { reason: "missing_openai_embeddings_key" },
+        });
+        return [];
+    }
+    try {
+        const vectors = await provider.embed([text]);
+        return vectors[0] ?? [];
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.memory_embedding_unavailable",
+            message: "embedding provider unavailable for memory write",
+            meta: {
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return [];
+    }
+}
+function readMemoryFacts(memoryRoot = path.join((0, identity_1.getAgentRoot)(), "psyche", "memory")) {
+    return readExistingFacts(path.join(memoryRoot, "facts.jsonl"));
+}
+async function saveMemoryFact(options) {
+    const text = options.text.trim();
+    const memoryRoot = options.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
+    const stores = ensureMemoryStorePaths(memoryRoot);
+    const embedding = await buildEmbedding(text, options.embeddingProvider);
+    const fact = {
+        id: options.idFactory ? options.idFactory() : (0, crypto_1.randomUUID)(),
+        text,
+        source: options.source,
+        about: options.about?.trim() || undefined,
+        createdAt: (options.now ?? (() => new Date()))().toISOString(),
+        embedding,
+    };
+    return appendFactsWithDedup(stores, [fact]);
+}
+async function backfillEmbeddings(options) {
+    const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    if (!fs.existsSync(factsPath))
+        return { total: 0, backfilled: 0, failed: 0 };
+    const facts = readExistingFacts(factsPath);
+    const needsEmbedding = facts.filter((f) => !Array.isArray(f.embedding) || f.embedding.length === 0);
+    if (needsEmbedding.length === 0)
+        return { total: facts.length, backfilled: 0, failed: 0 };
+    const provider = options?.embeddingProvider ?? createDefaultEmbeddingProvider();
+    if (!provider) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.memory_backfill_skipped",
+            message: "embedding provider unavailable for backfill",
+            meta: { needsEmbedding: needsEmbedding.length },
+        });
+        return { total: facts.length, backfilled: 0, failed: needsEmbedding.length };
+    }
+    const batchSize = options?.batchSize ?? 50;
+    let backfilled = 0;
+    let failed = 0;
+    for (let i = 0; i < needsEmbedding.length; i += batchSize) {
+        const batch = needsEmbedding.slice(i, i + batchSize);
+        try {
+            const vectors = await provider.embed(batch.map((f) => f.text));
+            for (let j = 0; j < batch.length; j++) {
+                batch[j].embedding = vectors[j] ?? [];
+                if (batch[j].embedding.length > 0)
+                    backfilled++;
+                else
+                    failed++;
+            }
+        }
+        catch (error) {
+            failed += batch.length;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "mind",
+                event: "mind.memory_backfill_batch_error",
+                message: "embedding backfill batch failed",
+                meta: {
+                    batchStart: i,
+                    batchSize: batch.length,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    // Rewrite facts file with updated embeddings
+    const lines = facts.map((f) => JSON.stringify(f)).join("\n") + "\n";
+    fs.writeFileSync(factsPath, lines, "utf8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.memory_backfill_complete",
+        message: "embedding backfill completed",
+        meta: { total: facts.length, backfilled, failed },
+    });
+    return { total: facts.length, backfilled, failed };
+}
+function substringMatches(queryLower, facts) {
+    return facts.filter((fact) => fact.text.toLowerCase().includes(queryLower));
+}
+function uniqueFacts(facts) {
+    const seen = new Set();
+    const unique = [];
+    for (const fact of facts) {
+        if (seen.has(fact.id))
+            continue;
+        seen.add(fact.id);
+        unique.push(fact);
+    }
+    return unique;
+}
+async function searchMemoryFacts(query, facts, embeddingProvider) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return [];
+    const queryLower = trimmed.toLowerCase();
+    const substringFallback = () => substringMatches(queryLower, facts).slice(0, 5);
+    const embeddedFacts = facts.filter((fact) => Array.isArray(fact.embedding) && fact.embedding.length > 0);
+    if (embeddedFacts.length === 0) {
+        return substringFallback();
+    }
+    const provider = embeddingProvider ?? createDefaultEmbeddingProvider();
+    if (!provider) {
+        return substringFallback();
+    }
+    try {
+        const vectors = await provider.embed([trimmed]);
+        const queryEmbedding = vectors[0];
+        if (!Array.isArray(queryEmbedding) || queryEmbedding.length === 0) {
+            return substringFallback();
+        }
+        const scored = embeddedFacts
+            .filter((fact) => fact.embedding.length === queryEmbedding.length)
+            .map((fact) => ({
+            fact,
+            score: cosineSimilarity(queryEmbedding, fact.embedding),
+        }))
+            .filter((entry) => entry.score > 0)
+            .sort((left, right) => right.score - left.score)
+            .map((entry) => entry.fact);
+        const fallback = substringFallback();
+        return uniqueFacts([...scored, ...fallback]).slice(0, 5);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.memory_embedding_unavailable",
+            message: "embedding provider unavailable for memory search",
+            meta: {
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return substringFallback();
+    }
+}

package/dist/mind/pending.js

@@ -0,0 +1,93 @@
+"use strict";
+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.getPendingDir = getPendingDir;
+exports.drainPending = drainPending;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const runtime_1 = require("../nerves/runtime");
+function getPendingDir(agentName, friendId, channel, key) {
+    return path.join(os.homedir(), ".agentstate", agentName, "pending", friendId, channel, key);
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(pendingDir);
+    }
+    catch {
+        return [];
+    }
+    // Collect both .json (new) and .processing (crash recovery)
+    const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
+    const processingFiles = entries.filter(f => f.endsWith(".json.processing"));
+    // Sort by filename (timestamp prefix gives chronological order)
+    const allFiles = [
+        ...processingFiles.map(f => ({ file: f, needsRename: false })),
+        ...jsonFiles.map(f => ({ file: f, needsRename: true })),
+    ].sort((a, b) => a.file.localeCompare(b.file));
+    const messages = [];
+    for (const { file, needsRename } of allFiles) {
+        const srcPath = path.join(pendingDir, file);
+        const processingPath = needsRename
+            ? path.join(pendingDir, file + ".processing")
+            : srcPath;
+        try {
+            if (needsRename) {
+                fs.renameSync(srcPath, processingPath);
+            }
+            const raw = fs.readFileSync(processingPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            messages.push(parsed);
+            fs.unlinkSync(processingPath);
+        }
+        catch {
+            // Skip unparseable files — still try to clean up
+            try {
+                fs.unlinkSync(processingPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.pending_drained",
+        component: "mind",
+        message: "pending queue drained",
+        meta: { pendingDir, count: messages.length, recovered: processingFiles.length },
+    });
+    return messages;
+}

package/dist/mind/phrases.js

@@ -0,0 +1,43 @@
+"use strict";
+// Shared phrase pools for fun loading messages.
+// Phrases have NO trailing "..." -- adapters add that.
+// Pools are loaded from agent.json via loadAgentConfig().
+// If agent.json has no phrases, loadAgentConfig() auto-fills placeholders.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPhrases = getPhrases;
+exports.pickPhrase = pickPhrase;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+// Returns phrase pools from agent.json (always present — loadAgentConfig auto-fills).
+function getPhrases() {
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_start",
+        component: "repertoire",
+        message: "loading phrase pools",
+        meta: {},
+    });
+    const phrases = (0, identity_1.loadAgentConfig)().phrases;
+    (0, runtime_1.emitNervesEvent)({
+        event: "repertoire.load_end",
+        component: "repertoire",
+        message: "loaded phrase pools",
+        meta: {
+            thinking_count: phrases.thinking.length,
+            tool_count: phrases.tool.length,
+            followup_count: phrases.followup.length,
+        },
+    });
+    return phrases;
+}
+// Pick a random phrase from a pool, avoiding immediate repeats.
+function pickPhrase(pool, lastUsed) {
+    if (pool.length === 0)
+        return "";
+    if (pool.length === 1)
+        return pool[0];
+    let pick;
+    do {
+        pick = pool[Math.floor(Math.random() * pool.length)];
+    } while (pick === lastUsed);
+    return pick;
+}

package/dist/mind/prompt-refresh.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshSystemPrompt = refreshSystemPrompt;
+const prompt_1 = require("./prompt");
+const runtime_1 = require("../nerves/runtime");
+async function refreshSystemPrompt(messages, channel, options, context) {
+    const newSystem = await (0, prompt_1.buildSystem)(channel, options, context);
+    if (messages.length > 0 && messages[0].role === "system") {
+        messages[0] = { role: "system", content: newSystem };
+    }
+    else {
+        messages.unshift({ role: "system", content: newSystem });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.system_prompt_refreshed",
+        component: "mind",
+        message: "system prompt refreshed",
+        meta: { channel },
+    });
+}