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

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

@@ -0,0 +1,171 @@
+"use strict";
+// FileFriendStore -- filesystem adapter for FriendStore.
+// Stores each friend as one unified JSON file in bundle `friends/`.
+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.FileFriendStore = void 0;
+const fs = __importStar(require("fs"));
+const fsPromises = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_ROLE = "friend";
+const DEFAULT_TRUST_LEVEL = "friend";
+class FileFriendStore {
+    friendsPath;
+    constructor(friendsPath) {
+        this.friendsPath = friendsPath;
+        fs.mkdirSync(friendsPath, { recursive: true });
+        (0, runtime_1.emitNervesEvent)({
+            component: "friends",
+            event: "friends.store_init",
+            message: "file friend store initialized",
+            meta: {},
+        });
+    }
+    async get(id) {
+        const record = await this.readJson(path.join(this.friendsPath, `${id}.json`));
+        if (!record)
+            return null;
+        return this.normalize(record);
+    }
+    async put(id, record) {
+        await this.writeJson(path.join(this.friendsPath, `${id}.json`), this.normalize(record));
+    }
+    async delete(id) {
+        await this.removeFile(path.join(this.friendsPath, `${id}.json`));
+    }
+    async findByExternalId(provider, externalId, tenantId) {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return null;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await this.readJson(path.join(this.friendsPath, entry));
+            if (!raw)
+                continue;
+            const record = this.normalize(raw);
+            const match = record.externalIds.some((ext) => ext.provider === provider &&
+                ext.externalId === externalId &&
+                (tenantId === undefined || ext.tenantId === tenantId));
+            if (match) {
+                return record;
+            }
+        }
+        return null;
+    }
+    async hasAnyFriends() {
+        let entries;
+        try {
+            entries = await fsPromises.readdir(this.friendsPath);
+        }
+        catch {
+            return false;
+        }
+        return entries.some((entry) => entry.endsWith(".json"));
+    }
+    normalize(raw) {
+        const trustLevel = raw.trustLevel;
+        const normalizedTrustLevel = trustLevel === "family" ||
+            trustLevel === "friend" ||
+            trustLevel === "acquaintance" ||
+            trustLevel === "stranger"
+            ? trustLevel
+            : DEFAULT_TRUST_LEVEL;
+        return {
+            id: raw.id,
+            name: raw.name,
+            role: typeof raw.role === "string" && raw.role.trim() ? raw.role : DEFAULT_ROLE,
+            trustLevel: normalizedTrustLevel,
+            connections: Array.isArray(raw.connections)
+                ? raw.connections
+                    .filter((connection) => (typeof connection === "object" &&
+                    connection !== null &&
+                    typeof connection.name === "string" &&
+                    typeof connection.relationship === "string"))
+                    .map((connection) => ({
+                    name: connection.name,
+                    relationship: connection.relationship,
+                }))
+                : [],
+            externalIds: Array.isArray(raw.externalIds) ? raw.externalIds : [],
+            tenantMemberships: Array.isArray(raw.tenantMemberships) ? raw.tenantMemberships : [],
+            toolPreferences: raw.toolPreferences && typeof raw.toolPreferences === "object"
+                ? raw.toolPreferences
+                : {},
+            notes: raw.notes && typeof raw.notes === "object" ? raw.notes : {},
+            totalTokens: typeof raw.totalTokens === "number" ? raw.totalTokens : 0,
+            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,
+        };
+    }
+    async readJson(filePath) {
+        try {
+            const raw = await fsPromises.readFile(filePath, "utf-8");
+            try {
+                const parsed = JSON.parse(raw);
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                    return null;
+                }
+                return parsed;
+            }
+            catch {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeJson(filePath, data) {
+        await fsPromises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    async removeFile(filePath) {
+        try {
+            await fsPromises.unlink(filePath);
+        }
+        catch (err) {
+            if (err?.code === "ENOENT")
+                return;
+            throw err;
+        }
+    }
+}
+exports.FileFriendStore = FileFriendStore;

package/dist/mind/friends/store.js

@@ -0,0 +1,4 @@
+"use strict";
+// Friend store abstraction.
+// All friend persistence goes through FriendStore -- no friend module imports `fs` directly.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mind/friends/tokens.js

@@ -0,0 +1,26 @@
+"use strict";
+// Token accumulation helper.
+// Tracks cumulative token usage per friend across turns.
+// Called from both CLI and Teams adapters after each agent turn.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accumulateFriendTokens = accumulateFriendTokens;
+const runtime_1 = require("../../nerves/runtime");
+async function accumulateFriendTokens(store, friendId, usage) {
+    if (!usage?.output_tokens)
+        return;
+    const record = await store.get(friendId);
+    if (!record)
+        return;
+    // Only count output tokens (what the model generated for this friend).
+    // Input tokens are mostly system prompt re-sent every turn -- counting them
+    // would inflate the total and make the onboarding threshold meaningless.
+    record.totalTokens = (record.totalTokens ?? 0) + usage.output_tokens;
+    record.updatedAt = new Date().toISOString();
+    await store.put(record.id, record);
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.tokens_accumulated",
+        message: "tokens accumulated for friend",
+        meta: { friendId, outputTokens: usage.output_tokens },
+    });
+}

package/dist/mind/friends/types.js

@@ -0,0 +1,21 @@
+"use strict";
+// Context kernel type definitions.
+// FriendRecord (merged identity + memory), channel capabilities, and resolved context.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIdentityProvider = isIdentityProvider;
+exports.isIntegration = isIntegration;
+const runtime_1 = require("../../nerves/runtime");
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation"]);
+function isIdentityProvider(value) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.identity_provider_check",
+        message: "identity provider validation",
+        meta: {},
+    });
+    return typeof value === "string" && IDENTITY_PROVIDERS.has(value);
+}
+const INTEGRATIONS = new Set(["ado", "github", "graph"]);
+function isIntegration(value) {
+    return typeof value === "string" && INTEGRATIONS.has(value);
+}

package/dist/mind/memory.js

@@ -0,0 +1,326 @@
+"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.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]);
+}
+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/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;
+}