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

package/dist/mind/format.js

@@ -0,0 +1,56 @@
+"use strict";
+// Shared formatting functions for tool results, kicks, and errors.
+// Used by both CLI and Teams adapters for consistent output.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToolResult = formatToolResult;
+exports.formatKick = formatKick;
+exports.formatError = formatError;
+const runtime_1 = require("../nerves/runtime");
+function compactSummary(summary) {
+    const oneLine = summary.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= 120)
+        return oneLine;
+    return oneLine.slice(0, 120) + "...";
+}
+function formatToolResult(name, summary, success) {
+    const compacted = compactSummary(summary);
+    (0, runtime_1.emitNervesEvent)({
+        event: "channel.message_sent",
+        component: "channels",
+        message: "formatted tool result for channel output",
+        meta: {
+            kind: "tool_result",
+            name,
+            success,
+            has_summary: compacted.length > 0,
+        },
+    });
+    if (success) {
+        return "\u2713 " + name + (compacted ? " (" + compacted + ")" : "");
+    }
+    return "\u2717 " + name + ": " + compacted;
+}
+function formatKick() {
+    (0, runtime_1.emitNervesEvent)({
+        event: "channel.message_sent",
+        component: "channels",
+        message: "formatted kick message for channel output",
+        meta: {
+            kind: "kick",
+        },
+    });
+    return "\u21BB kick";
+}
+function formatError(error) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        event: "channel.error",
+        component: "channels",
+        message: "formatted channel error message",
+        meta: {
+            kind: "error",
+            error_message: error.message,
+        },
+    });
+    return "Error: " + error.message;
+}

package/dist/mind/friends/channel.js

@@ -0,0 +1,41 @@
+"use strict";
+// Channel capabilities -- hardcoded const map keyed by channel identifier.
+// Pure lookup, no I/O, cannot fail. Unknown channel gets minimal defaults.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChannelCapabilities = getChannelCapabilities;
+const runtime_1 = require("../../nerves/runtime");
+const CHANNEL_CAPABILITIES = {
+    cli: {
+        channel: "cli",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: true,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
+    teams: {
+        channel: "teams",
+        availableIntegrations: ["ado", "graph", "github"],
+        supportsMarkdown: true,
+        supportsStreaming: true,
+        supportsRichCards: true,
+        maxMessageLength: Infinity,
+    },
+};
+const DEFAULT_CAPABILITIES = {
+    channel: "cli",
+    availableIntegrations: [],
+    supportsMarkdown: false,
+    supportsStreaming: false,
+    supportsRichCards: false,
+    maxMessageLength: Infinity,
+};
+function getChannelCapabilities(channel) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.capabilities_lookup",
+        message: "channel capabilities lookup",
+        meta: { channel },
+    });
+    return CHANNEL_CAPABILITIES[channel] ?? DEFAULT_CAPABILITIES;
+}

package/dist/mind/friends/resolver.js

@@ -0,0 +1,84 @@
+"use strict";
+// FriendResolver -- resolves external identity into a FriendRecord + channel capabilities.
+// Created per-request (per-incoming-message), per-friend.
+// Replaces the old ContextResolver: no authority checker, no separate memory resolution.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FriendResolver = void 0;
+const crypto_1 = require("crypto");
+const channel_1 = require("./channel");
+const runtime_1 = require("../../nerves/runtime");
+const CURRENT_SCHEMA_VERSION = 1;
+class FriendResolver {
+    store;
+    params;
+    constructor(store, params) {
+        this.store = store;
+        this.params = params;
+    }
+    async resolve() {
+        const friend = await this.resolveOrCreate();
+        const channel = (0, channel_1.getChannelCapabilities)(this.params.channel);
+        return { friend, channel };
+    }
+    async resolveOrCreate() {
+        // Try to find existing friend by external ID
+        let existing = null;
+        try {
+            existing = await this.store.findByExternalId(this.params.provider, this.params.externalId, this.params.tenantId);
+        }
+        catch {
+            // Store search failure -- fall through to create new (D16)
+        }
+        if (existing)
+            return existing;
+        // First encounter -- create new FriendRecord
+        const now = new Date().toISOString();
+        const externalId = {
+            provider: this.params.provider,
+            externalId: this.params.externalId,
+            linkedAt: now,
+            ...(this.params.tenantId !== undefined ? { tenantId: this.params.tenantId } : {}),
+        };
+        const tenantMemberships = this.params.tenantId ? [this.params.tenantId] : [];
+        let hasAnyFriends = false;
+        try {
+            if (typeof this.store.hasAnyFriends === "function") {
+                hasAnyFriends = await this.store.hasAnyFriends();
+            }
+        }
+        catch {
+            hasAnyFriends = false;
+        }
+        const isFirstImprint = !hasAnyFriends;
+        const friend = {
+            id: (0, crypto_1.randomUUID)(),
+            name: this.params.displayName,
+            role: isFirstImprint ? "primary" : "stranger",
+            trustLevel: isFirstImprint ? "family" : "stranger",
+            connections: [],
+            externalIds: [externalId],
+            tenantMemberships,
+            toolPreferences: {},
+            notes: this.params.displayName !== "Unknown" ? { name: { value: this.params.displayName, savedAt: now } } : {},
+            totalTokens: 0,
+            createdAt: now,
+            updatedAt: now,
+            schemaVersion: CURRENT_SCHEMA_VERSION,
+        };
+        // Persist -- log and continue on failure (D16)
+        try {
+            await this.store.put(friend.id, friend);
+        }
+        catch (err) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "friends.persist_error",
+                component: "friends",
+                message: "failed to persist friend record",
+                meta: { reason: err instanceof Error ? err.message : String(err) },
+            });
+        }
+        return friend;
+    }
+}
+exports.FriendResolver = FriendResolver;

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);
+}