@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/mind/prompt.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetPsycheCache = resetPsycheCache;
+exports.buildSessionSummary = buildSessionSummary;
 exports.runtimeInfoSection = runtimeInfoSection;
 exports.contextSection = contextSection;
 exports.buildSystem = buildSystem;
@@ -43,6 +44,7 @@ const core_1 = require("../heart/core");
 const tools_1 = require("../repertoire/tools");
 const skills_1 = require("../repertoire/skills");
 const identity_1 = require("../heart/identity");
+const os = __importStar(require("os"));
 const channel_1 = require("./friends/channel");
 const runtime_1 = require("../nerves/runtime");
 const first_impressions_1 = require("./first-impressions");
@@ -73,6 +75,94 @@ function loadPsyche() {
 function resetPsycheCache() {
     _psycheCache = null;
 }
+const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
+function resolveFriendName(friendId, friendsDir, agentName) {
+    if (friendId === "self")
+        return agentName;
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const record = JSON.parse(raw);
+        return record.name ?? friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+function buildSessionSummary(options) {
+    const { sessionsDir, friendsDir, agentName, currentFriendId, currentChannel, currentKey, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, } = options;
+    if (!fs.existsSync(sessionsDir))
+        return "";
+    const now = Date.now();
+    const entries = [];
+    let friendDirs;
+    try {
+        friendDirs = fs.readdirSync(sessionsDir);
+    }
+    catch {
+        return "";
+    }
+    for (const friendId of friendDirs) {
+        const friendPath = path.join(sessionsDir, friendId);
+        let channels;
+        try {
+            channels = fs.readdirSync(friendPath);
+        }
+        catch {
+            continue;
+        }
+        for (const channel of channels) {
+            const channelPath = path.join(friendPath, channel);
+            let keys;
+            try {
+                keys = fs.readdirSync(channelPath);
+            }
+            catch {
+                continue;
+            }
+            for (const keyFile of keys) {
+                if (!keyFile.endsWith(".json"))
+                    continue;
+                const key = keyFile.replace(/\.json$/, "");
+                // Exclude current session
+                if (friendId === currentFriendId && channel === currentChannel && key === currentKey) {
+                    continue;
+                }
+                const filePath = path.join(channelPath, keyFile);
+                let mtimeMs;
+                try {
+                    mtimeMs = fs.statSync(filePath).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                if (now - mtimeMs > activeThresholdMs)
+                    continue;
+                const displayName = resolveFriendName(friendId, friendsDir, agentName);
+                entries.push({ friendId, displayName, channel, key, lastActivityMs: mtimeMs });
+            }
+        }
+    }
+    if (entries.length === 0)
+        return "";
+    // Sort by most recent first
+    entries.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
+    const lines = ["## active sessions"];
+    for (const entry of entries) {
+        const ago = formatTimeAgo(now - entry.lastActivityMs);
+        lines.push(`- ${entry.displayName}/${entry.channel}/${entry.key} (last: ${ago})`);
+    }
+    return lines.join("\n");
+}
+function formatTimeAgo(ms) {
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
 function soulSection() {
     return loadPsyche().soul;
 }
@@ -108,6 +198,9 @@ function runtimeInfoSection(channel) {
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
+    else if (channel === "bluebubbles") {
+        lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
+    }
     else {
         lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");
     }
@@ -238,6 +331,14 @@ async function buildSystem(channel = "cli", options, context) {
         toolsSection(channel, options),
         skillsSection(),
         taskBoardSection(),
+        buildSessionSummary({
+            sessionsDir: path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions"),
+            friendsDir: path.join((0, identity_1.getAgentRoot)(), "friends"),
+            agentName: (0, identity_1.getAgentName)(),
+            currentFriendId: context?.friend?.id,
+            currentChannel: channel,
+            currentKey: "session",
+        }),
         memoryFriendToolContractSection(),
         toolBehaviorSection(options),
         contextSection(context),

package/dist/nerves/coverage/file-completeness.js

@@ -11,12 +11,22 @@ exports.isTypeOnlyFile = isTypeOnlyFile;
 exports.checkFileCompleteness = checkFileCompleteness;
 /**
  * Determines if a source file is type-only (no executable code).
- * A file is type-only if it contains no function, class, or const declarations.
+ * A file is type-only if it contains no function, class, or mutable declarations.
+ * `const ... as const` declarations are treated as type-equivalent (frozen
+ * compile-time values with no side effects).
  */
 function isTypeOnlyFile(source) {
-    // Look for executable code markers: function, class, const/let/var declarations
-    const executablePattern = /\b(function|class|const|let|var)\s/;
-    return !executablePattern.test(source);
+    const lines = source.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip lines that are const+as-const (type-equivalent frozen values)
+        if (/\bconst\s/.test(trimmed) && /\bas\s+const\b/.test(trimmed))
+            continue;
+        // Check for executable code markers
+        if (/\b(function|class|const|let|var)\s/.test(trimmed))
+            return false;
+    }
+    return true;
 }
 /**
  * Check that all production files have at least one emitNervesEvent call.

package/dist/repertoire/tools-base.js

@@ -41,6 +41,7 @@ const skills_1 = require("./skills");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
+const os = __importStar(require("os"));
 const tasks_1 = require("./tasks");
 const tools_1 = require("./coding/tools");
 const memory_1 = require("../mind/memory");
@@ -602,6 +603,97 @@ exports.baseToolDefinitions = [
             }
         },
     },
+    // -- cross-session awareness --
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_session",
+                description: "read the last messages from another session. use this to check on a conversation with a friend or review your own inner dialog.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        key: { type: "string", description: "session key (defaults to 'session')" },
+                        messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
+                    },
+                    required: ["friendId", "channel"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            try {
+                const friendId = args.friendId;
+                const channel = args.channel;
+                const key = args.key || "session";
+                const count = parseInt(args.messageCount || "20", 10);
+                const sessFile = path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions", friendId, channel, `${key}.json`);
+                const raw = fs.readFileSync(sessFile, "utf-8");
+                const data = JSON.parse(raw);
+                const messages = (data.messages || [])
+                    .filter((m) => m.role !== "system");
+                const tail = messages.slice(-count);
+                if (tail.length === 0)
+                    return "session exists but has no non-system messages.";
+                const transcript = tail.map((m) => `[${m.role}] ${m.content}`).join("\n");
+                // LLM summarization when summarize function is available
+                if (ctx?.summarize) {
+                    const trustLevel = ctx.context?.friend?.trustLevel ?? "family";
+                    const isSelfQuery = friendId === "self";
+                    const instruction = isSelfQuery
+                        ? "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning."
+                        : `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+                    return await ctx.summarize(transcript, instruction);
+                }
+                return transcript;
+            }
+            catch {
+                return "no session found for that friend/channel/key combination.";
+            }
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "send_message",
+                description: "send a message to a friend's session. the message is queued as a pending file and delivered when the target session drains its queue.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        key: { type: "string", description: "session key (defaults to 'session')" },
+                        content: { type: "string", description: "the message content to send" },
+                    },
+                    required: ["friendId", "channel", "content"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const friendId = args.friendId;
+            const channel = args.channel;
+            const key = args.key || "session";
+            const content = args.content;
+            const now = Date.now();
+            const pendingDir = path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "pending", friendId, channel, key);
+            fs.mkdirSync(pendingDir, { recursive: true });
+            const fileName = `${now}-${Math.random().toString(36).slice(2, 10)}.json`;
+            const filePath = path.join(pendingDir, fileName);
+            const envelope = {
+                from: (0, identity_1.getAgentName)(),
+                friendId,
+                channel,
+                key,
+                content,
+                timestamp: now,
+            };
+            fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
+            const preview = content.length > 80 ? content.slice(0, 80) + "…" : content;
+            return `message queued for delivery to ${friendId} on ${channel}/${key}. preview: "${preview}". it will be delivered when their session is next active.`;
+        },
+    },
     ...tools_1.codingToolDefinitions,
 ];
 // Backward-compat: extract just the OpenAI tool schemas

package/dist/repertoire/tools.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function (
 const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
 const REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "git_commit", "gh_cli"]);
 function baseToolsForCapabilities(capabilities) {
-    const isRemoteChannel = capabilities?.channel === "teams";
+    const isRemoteChannel = capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
     if (!isRemoteChannel)
         return tools_base_1.tools;
     return tools_base_1.tools.filter((tool) => !REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
@@ -87,7 +87,7 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    const isRemoteChannel = ctx?.context?.channel?.channel === "teams";
+    const isRemoteChannel = ctx?.context?.channel?.channel === "teams" || ctx?.context?.channel?.channel === "bluebubbles";
     if (isRemoteChannel && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
         const message = "I can't do that from here because I'm talking to multiple people in a shared remote channel, and local shell/file/git/gh operations could let conversations interfere with each other. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
         (0, runtime_1.emitNervesEvent)({
@@ -95,7 +95,7 @@ async function execTool(name, args, ctx) {
             event: "tool.error",
             component: "tools",
             message: "blocked local tool in remote channel",
-            meta: { name, channel: "teams" },
+            meta: { name, channel: ctx?.context?.channel?.channel },
         });
         return message;
     }

package/dist/senses/bluebubbles-client.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBlueBubblesClient = createBlueBubblesClient;
+const node_crypto_1 = require("node:crypto");
+const config_1 = require("../heart/config");
+const runtime_1 = require("../nerves/runtime");
+const bluebubbles_model_1 = require("./bluebubbles-model");
+function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
+    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = new URL(endpoint.replace(/^\//, ""), root);
+    url.searchParams.set("password", password);
+    return url.toString();
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function extractMessageGuid(payload) {
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const record = payload;
+    const data = record.data && typeof record.data === "object" && !Array.isArray(record.data)
+        ? record.data
+        : null;
+    const candidates = [
+        record.messageGuid,
+        record.messageId,
+        record.guid,
+        data?.messageGuid,
+        data?.messageId,
+        data?.guid,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+async function parseJsonBody(response) {
+    const raw = await response.text();
+    if (!raw.trim())
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function buildRepairUrl(baseUrl, messageGuid, password) {
+    const url = buildBlueBubblesApiUrl(baseUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}`, password);
+    const parsed = new URL(url);
+    parsed.searchParams.set("with", "attachments,payloadData,chats,messageSummaryInfo");
+    return parsed.toString();
+}
+function collectPreviewStrings(value, out, depth = 0) {
+    if (depth > 4 || out.length >= 4)
+        return;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed)
+            out.push(trimmed);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectPreviewStrings(entry, out, depth + 1);
+        return;
+    }
+    const record = asRecord(value);
+    if (!record)
+        return;
+    const preferredKeys = ["title", "summary", "subtitle", "previewText", "siteName", "host", "url"];
+    for (const key of preferredKeys) {
+        if (out.length >= 4)
+            break;
+        collectPreviewStrings(record[key], out, depth + 1);
+    }
+}
+function extractLinkPreviewText(data) {
+    const values = [];
+    collectPreviewStrings(data.payloadData, values);
+    collectPreviewStrings(data.messageSummaryInfo, values);
+    const unique = [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(0, 2).join(" — ");
+}
+function applyRepairNotice(event, notice) {
+    return {
+        ...event,
+        requiresRepair: false,
+        repairNotice: notice,
+    };
+}
+function hydrateTextForAgent(event, rawData) {
+    if (event.kind !== "message") {
+        return { ...event, requiresRepair: false };
+    }
+    if (event.balloonBundleId !== "com.apple.messages.URLBalloonProvider") {
+        return { ...event, requiresRepair: false };
+    }
+    const previewText = extractLinkPreviewText(rawData);
+    if (!previewText) {
+        return { ...event, requiresRepair: false };
+    }
+    const base = event.text.trim();
+    const textForAgent = base
+        ? `${base}\n[link preview: ${previewText}]`
+        : `[link preview: ${previewText}]`;
+    return {
+        ...event,
+        textForAgent,
+        requiresRepair: false,
+    };
+}
+function extractRepairData(payload) {
+    const record = asRecord(payload);
+    return asRecord(record?.data) ?? record;
+}
+function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(), channelConfig = (0, config_1.getBlueBubblesChannelConfig)()) {
+    return {
+        async sendText(params) {
+            const trimmedText = params.text.trim();
+            if (!trimmedText) {
+                throw new Error("BlueBubbles send requires non-empty text.");
+            }
+            if (!params.chat.chatGuid) {
+                throw new Error("BlueBubbles send currently requires chat.chatGuid from the inbound event.");
+            }
+            const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/text", config.password);
+            const body = {
+                chatGuid: params.chat.chatGuid,
+                tempGuid: (0, node_crypto_1.randomUUID)(),
+                message: trimmedText,
+            };
+            if (params.replyToMessageGuid?.trim()) {
+                body.method = "private-api";
+                body.selectedMessageGuid = params.replyToMessageGuid.trim();
+                body.partIndex = 0;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_send_start",
+                message: "sending bluebubbles message",
+                meta: {
+                    chatGuid: params.chat.chatGuid,
+                    hasReplyTarget: Boolean(params.replyToMessageGuid?.trim()),
+                },
+            });
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.bluebubbles_send_error",
+                    message: "bluebubbles send failed",
+                    meta: {
+                        status: response.status,
+                        reason: errorText || "unknown",
+                    },
+                });
+                throw new Error(`BlueBubbles send failed (${response.status}): ${errorText || "unknown"}`);
+            }
+            const payload = await parseJsonBody(response);
+            const messageGuid = extractMessageGuid(payload);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_send_end",
+                message: "bluebubbles message sent",
+                meta: {
+                    chatGuid: params.chat.chatGuid,
+                    messageGuid: messageGuid ?? null,
+                },
+            });
+            return { messageGuid };
+        },
+        async repairEvent(event) {
+            if (!event.requiresRepair) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_skipped",
+                    message: "bluebubbles event repair skipped",
+                    meta: {
+                        kind: event.kind,
+                        messageGuid: event.messageGuid,
+                    },
+                });
+                return event;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_repair_start",
+                message: "repairing bluebubbles event by guid",
+                meta: {
+                    kind: event.kind,
+                    messageGuid: event.messageGuid,
+                    eventType: event.eventType,
+                },
+            });
+            const url = buildRepairUrl(config.serverUrl, event.messageGuid, config.password);
+            try {
+                const response = await fetch(url, {
+                    method: "GET",
+                    signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "");
+                    const repaired = applyRepairNotice(event, `BlueBubbles repair failed: ${errorText || `HTTP ${response.status}`}`);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_repair_error",
+                        message: "bluebubbles repair request failed",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                            status: response.status,
+                            reason: errorText || "unknown",
+                        },
+                    });
+                    return repaired;
+                }
+                const payload = await parseJsonBody(response);
+                const data = extractRepairData(payload);
+                if (!data || typeof data.guid !== "string") {
+                    const repaired = applyRepairNotice(event, "BlueBubbles repair failed: invalid message payload");
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_repair_error",
+                        message: "bluebubbles repair returned unusable payload",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                        },
+                    });
+                    return repaired;
+                }
+                const normalized = (0, bluebubbles_model_1.normalizeBlueBubblesEvent)({
+                    type: event.eventType,
+                    data,
+                });
+                const hydrated = hydrateTextForAgent(normalized, data);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_end",
+                    message: "bluebubbles event repaired",
+                    meta: {
+                        kind: hydrated.kind,
+                        messageGuid: hydrated.messageGuid,
+                        repairedFrom: event.kind,
+                    },
+                });
+                return hydrated;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_error",
+                    message: "bluebubbles repair threw",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        reason,
+                    },
+                });
+                return applyRepairNotice(event, `BlueBubbles repair failed: ${reason}`);
+            }
+        },
+    };
+}

package/dist/senses/bluebubbles-entry.js

@@ -0,0 +1,11 @@
+"use strict";
+// Thin entrypoint for `npm run bluebubbles` / `node dist/senses/bluebubbles-entry.js --agent <name>`.
+// Separated from bluebubbles.ts so the BlueBubbles adapter stays testable.
+Object.defineProperty(exports, "__esModule", { value: true });
+if (!process.argv.includes("--agent")) {
+    // eslint-disable-next-line no-console -- pre-boot guard: --agent check before imports
+    console.error("Missing required --agent <name> argument.\nUsage: node dist/senses/bluebubbles-entry.js --agent ouroboros");
+    process.exit(1);
+}
+const bluebubbles_1 = require("./bluebubbles");
+(0, bluebubbles_1.startBlueBubblesApp)();