@ouro.bot/cli 0.1.0-alpha.56 → 0.1.0-alpha.560

package/dist/mind/friends/store-file.js

@@ -55,10 +55,29 @@ class FileFriendStore {
         });
     }
     async get(id) {
+        // Direct UUID lookup
         const record = await this.readJson(path.join(this.friendsPath, `${id}.json`));
-        if (!record)
-            return null;
-        return this.normalize(record);
+        if (record)
+            return this.normalize(record);
+        // Fallback: if id is a name (not UUID), scan for matching friend
+        /* v8 ignore start -- name fallback: exercised by live proactive sends @preserve */
+        try {
+            const entries = await fsPromises.readdir(this.friendsPath);
+            for (const entry of entries) {
+                if (!entry.endsWith(".json"))
+                    continue;
+                const raw = await this.readJson(path.join(this.friendsPath, entry));
+                if (!raw)
+                    continue;
+                const normalized = this.normalize(raw);
+                if (normalized.name?.toLowerCase() === id.toLowerCase()) {
+                    return normalized;
+                }
+            }
+        }
+        catch { /* directory unreadable — return null */ }
+        /* v8 ignore stop */
+        return null;
     }
     async put(id, record) {
         await this.writeJson(path.join(this.friendsPath, `${id}.json`), this.normalize(record));
@@ -127,6 +146,8 @@ class FileFriendStore {
             trustLevel === "stranger"
             ? trustLevel
             : DEFAULT_TRUST_LEVEL;
+        const kind = raw.kind === "human" || raw.kind === "agent" ? raw.kind : "human";
+        const agentMeta = kind === "agent" ? this.normalizeAgentMeta(raw.agentMeta) : undefined;
         return {
             id: raw.id,
             name: raw.name,
@@ -153,6 +174,21 @@ class FileFriendStore {
             createdAt: typeof raw.createdAt === "string" ? raw.createdAt : new Date().toISOString(),
             updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : new Date().toISOString(),
             schemaVersion: typeof raw.schemaVersion === "number" ? raw.schemaVersion : 1,
+            kind,
+            agentMeta,
+        };
+    }
+    normalizeAgentMeta(raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const meta = raw;
+        if (typeof meta.bundleName !== "string")
+            return undefined;
+        return {
+            bundleName: meta.bundleName,
+            familiarity: typeof meta.familiarity === "number" ? meta.familiarity : 0,
+            sharedMissions: Array.isArray(meta.sharedMissions) ? meta.sharedMissions : [],
+            outcomes: Array.isArray(meta.outcomes) ? meta.outcomes : [],
         };
     }
     async readJson(filePath) {

package/dist/mind/friends/types.js

@@ -1,13 +1,13 @@
 "use strict";
 // Context kernel type definitions.
-// FriendRecord (merged identity + memory), channel capabilities, and resolved context.
+// FriendRecord (merged identity + notes), channel capabilities, and resolved context.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRUSTED_LEVELS = void 0;
 exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
 exports.isTrustedLevel = isTrustedLevel;
 const runtime_1 = require("../../nerves/runtime");
-const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle", "email-address"]);
 function isIdentityProvider(value) {
     (0, runtime_1.emitNervesEvent)({
         component: "friends",

package/dist/mind/journal-index.js

@@ -0,0 +1,161 @@
+"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.indexJournalFiles = indexJournalFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const TEXT_EXTENSIONS = new Set([".md", ".txt"]);
+const PREVIEW_CHAR_LIMIT = 500;
+function readExistingIndex(indexPath) {
+    try {
+        const raw = fs.readFileSync(indexPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
+function extractPreview(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return "";
+    return trimmed.split("\n")[0].replace(/^#+\s*/, "").trim();
+}
+async function indexJournalFiles(journalDir, indexPath, embedProvider) {
+    // Read existing index
+    const existingIndex = readExistingIndex(indexPath);
+    const indexMap = new Map();
+    for (const entry of existingIndex) {
+        indexMap.set(entry.filename, entry);
+    }
+    // Scan journal dir for text files
+    let dirEntries;
+    try {
+        dirEntries = fs.readdirSync(journalDir, { withFileTypes: true });
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.journal_index_scan",
+            message: "journal dir not found or unreadable",
+            meta: { journalDir },
+        });
+        return 0;
+    }
+    const textFiles = dirEntries.filter((entry) => {
+        if (!entry.isFile())
+            return false;
+        if (entry.name.startsWith("."))
+            return false;
+        const ext = path.extname(entry.name).toLowerCase();
+        return TEXT_EXTENSIONS.has(ext);
+    });
+    if (textFiles.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.journal_index_scan",
+            message: "no text files found in journal",
+            meta: { journalDir },
+        });
+        return 0;
+    }
+    let newlyIndexed = 0;
+    for (const file of textFiles) {
+        const filePath = path.join(journalDir, file.name);
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        }
+        catch {
+            /* v8 ignore next -- filesystem race: file deleted between readdir and stat @preserve */
+            continue;
+        }
+        // Check if already indexed with same mtime
+        const existing = indexMap.get(file.name);
+        if (existing && existing.mtime === stat.mtimeMs) {
+            continue;
+        }
+        // Read content for embedding
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf8");
+        }
+        catch {
+            /* v8 ignore next -- filesystem race: file deleted between stat and read @preserve */
+            continue;
+        }
+        const preview = extractPreview(content);
+        const embedText = content.slice(0, PREVIEW_CHAR_LIMIT);
+        // Generate embedding
+        let embedding;
+        try {
+            const vectors = await embedProvider.embed([embedText]);
+            embedding = vectors[0] ?? [];
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "mind",
+                event: "mind.journal_embedding_error",
+                message: "embedding failed for journal file",
+                meta: { filename: file.name },
+            });
+            embedding = [];
+        }
+        indexMap.set(file.name, {
+            filename: file.name,
+            embedding,
+            mtime: stat.mtimeMs,
+            preview,
+        });
+        newlyIndexed++;
+    }
+    // Write updated index back
+    if (newlyIndexed > 0) {
+        const updatedIndex = Array.from(indexMap.values());
+        fs.writeFileSync(indexPath, JSON.stringify(updatedIndex, null, 2), "utf8");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.journal_index_complete",
+        message: "journal indexing complete",
+        meta: { journalDir, newlyIndexed, total: indexMap.size },
+    });
+    return newlyIndexed;
+}

package/dist/mind/note-search.js

@@ -0,0 +1,268 @@
+"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.cosineSimilarity = cosineSimilarity;
+exports.searchDiaryFactsForQuery = searchDiaryFactsForQuery;
+exports.searchJournalIndex = searchJournalIndex;
+exports.injectNoteSearchContext = injectNoteSearchContext;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const diary_1 = require("./diary");
+const provenance_trust_1 = require("./provenance-trust");
+const embedding_provider_1 = require("./embedding-provider");
+const DEFAULT_MIN_SCORE = 0.5;
+const DEFAULT_TOP_K = 3;
+function createDefaultProvider() {
+    const provider = (0, embedding_provider_1.createDefaultEmbeddingProvider)();
+    if (!provider) {
+        throw new Error("openaiEmbeddingsApiKey not configured");
+    }
+    return provider;
+}
+function readFacts(diaryRoot) {
+    const factsPath = path.join(diaryRoot, "facts.jsonl");
+    if (!fs.existsSync(factsPath))
+        return [];
+    const raw = fs.readFileSync(factsPath, "utf8").trim();
+    if (!raw)
+        return [];
+    const facts = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            facts.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Skip corrupt lines (e.g. partial write from a crash).
+        }
+    }
+    return facts;
+}
+function getLatestUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "user")
+            continue;
+        if (typeof message.content !== "string")
+            continue;
+        const text = message.content.trim();
+        if (text.length > 0)
+            return text;
+    }
+    return "";
+}
+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++) {
+        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));
+}
+async function searchDiaryFactsForQuery(query, facts, provider, options) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return [];
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    const [queryEmbedding] = await provider.embed([trimmed]);
+    return facts
+        .map((fact) => ({
+        ...fact,
+        score: cosineSimilarity(queryEmbedding, fact.embedding),
+    }))
+        .filter((fact) => fact.score >= minScore)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, topK);
+}
+function readJournalIndex(journalDir) {
+    const indexPath = path.join(journalDir, ".index.json");
+    try {
+        const raw = fs.readFileSync(indexPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
+function searchJournalIndex(queryEmbedding, entries, options) {
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    return entries
+        .filter((entry) => Array.isArray(entry.embedding) && entry.embedding.length > 0)
+        .map((entry) => ({
+        filename: entry.filename,
+        preview: entry.preview,
+        score: cosineSimilarity(queryEmbedding, entry.embedding),
+    }))
+        .filter((entry) => entry.score >= minScore)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, topK);
+}
+function resolveJournalDir(diaryRoot, explicitJournalDir) {
+    if (explicitJournalDir)
+        return explicitJournalDir;
+    // journal/ is a sibling of diary/ at the agent root level
+    const agentRoot = path.dirname(diaryRoot);
+    return path.join(agentRoot, "journal");
+}
+async function injectNoteSearchContext(messages, options) {
+    try {
+        if (messages[0]?.role !== "system" || typeof messages[0].content !== "string")
+            return;
+        const query = getLatestUserText(messages);
+        if (!query)
+            return;
+        const diaryRoot = options?.diaryRoot ?? (0, diary_1.resolveDiaryRoot)();
+        const facts = readFacts(diaryRoot);
+        const journalDir = resolveJournalDir(diaryRoot, options?.journalDir);
+        const journalEntries = readJournalIndex(journalDir);
+        if (facts.length === 0 && journalEntries.length === 0)
+            return;
+        // Build combined result lines tagged by source
+        const resultLines = [];
+        let queryEmbedding;
+        // Search diary entries
+        if (facts.length > 0) {
+            let found;
+            try {
+                const provider = options?.provider ?? createDefaultProvider();
+                found = await searchDiaryFactsForQuery(query, facts, provider, options);
+                // Compute query embedding for journal search while provider is available
+                if (journalEntries.length > 0) {
+                    const [qe] = await provider.embed([query.trim()]);
+                    queryEmbedding = qe;
+                }
+            }
+            catch {
+                // Embeddings unavailable — fall back to substring matching
+                const lowerQuery = query.toLowerCase();
+                const topK = options?.topK ?? DEFAULT_TOP_K;
+                found = facts
+                    .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
+                    .slice(0, topK)
+                    .map((fact) => ({ ...fact, score: 1 }));
+                if (found.length > 0) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "mind",
+                        event: "mind.note_search_fallback",
+                        message: "embeddings unavailable, used substring fallback",
+                        meta: { matchCount: found.length },
+                    });
+                }
+            }
+            for (const fact of found) {
+                let meta = `score=${fact.score.toFixed(3)} source=${fact.source}`;
+                if (fact.provenance) {
+                    if (fact.provenance.channel)
+                        meta += ` channel=${fact.provenance.channel}`;
+                    if (fact.provenance.friendName)
+                        meta += ` friend=${fact.provenance.friendName}`;
+                    if (fact.provenance.trust)
+                        meta += ` trust=${fact.provenance.trust}`;
+                }
+                const tag = (0, provenance_trust_1.classifyProvenanceTrust)(fact.provenance) === "external" ? "diary/external" : "diary";
+                resultLines.push({
+                    text: `[${tag}] ${fact.text} [${meta}]`,
+                    score: fact.score,
+                });
+            }
+        }
+        // Search journal entries (works whether diary had results or not)
+        if (journalEntries.length > 0) {
+            try {
+                if (!queryEmbedding) {
+                    const provider = options?.provider ?? createDefaultProvider();
+                    const [qe] = await provider.embed([query.trim()]);
+                    queryEmbedding = qe;
+                }
+                if (queryEmbedding) {
+                    const journalResults = searchJournalIndex(queryEmbedding, journalEntries, options);
+                    for (const entry of journalResults) {
+                        resultLines.push({
+                            text: `[journal] ${entry.filename}: ${entry.preview} [score=${entry.score.toFixed(3)}]`,
+                            score: entry.score,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Embeddings unavailable — no journal fallback
+            }
+        }
+        if (resultLines.length === 0)
+            return;
+        // Sort all results by score descending
+        resultLines.sort((left, right) => right.score - left.score);
+        const noteSection = resultLines
+            .map((entry, index) => `${index + 1}. ${entry.text}`)
+            .join("\n");
+        messages[0] = {
+            role: "system",
+            content: `${messages[0].content}\n\n## from my diary and journal\n${noteSection}`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.note_search_context",
+            message: "note search injected",
+            meta: { count: resultLines.length },
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.note_search_context_error",
+            message: "note search failed",
+            meta: {
+                reason: error instanceof Error ? error.message : /* v8 ignore start -- defensive: non-Error catch branch @preserve */ String(error) /* v8 ignore stop */,
+            },
+        });
+    }
+}