@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

package/dist/repertoire/tools-bluebubbles.js

@@ -89,5 +89,6 @@ exports.bluebubblesToolDefinitions = [
             });
             return "target must be one of: current_lane, top_level, thread.";
         },
+        summaryKeys: ["target", "threadOriginatorGuid"],
     },
 ];

package/dist/repertoire/tools-bridge.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bridgeToolDefinitions = void 0;
+const config_1 = require("../heart/config");
+const manager_1 = require("../heart/bridges/manager");
+const runtime_1 = require("../nerves/runtime");
+const session_transcript_1 = require("../heart/session-transcript");
+const NO_SESSION_FOUND_MESSAGE = "no session found for that friend/channel/key combination.";
+const EMPTY_SESSION_MESSAGE = "session exists but has no non-system messages.";
+async function summarizeSessionTailSafely(options) {
+    try {
+        return await (0, session_transcript_1.summarizeSessionTail)(options);
+    }
+    catch (error) {
+        if (options.summarize) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.session_tail_summary_summary_fallback",
+                message: "session tail summarization failed; using raw transcript",
+                meta: {
+                    friendId: options.friendId,
+                    channel: options.channel,
+                    key: options.key,
+                    /* v8 ignore next -- branch: String(error) fallback only for non-Error throws @preserve */
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+            try {
+                return await (0, session_transcript_1.summarizeSessionTail)({
+                    ...options,
+                    summarize: undefined,
+                });
+            }
+            catch {
+                return { kind: "missing" };
+            }
+        }
+        return { kind: "missing" };
+    }
+}
+exports.bridgeToolDefinitions = [
+    // -- cross-session awareness --
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "bridge_manage",
+                description: "create and manage shared live-work bridges across already-active sessions.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: {
+                            type: "string",
+                            enum: ["begin", "attach", "status", "promote_task", "complete", "cancel"],
+                        },
+                        bridgeId: { type: "string", description: "bridge id for all actions except begin" },
+                        objective: { type: "string", description: "objective for begin" },
+                        summary: { type: "string", description: "optional concise shared-work summary" },
+                        friendId: { type: "string", description: "target friend id for attach" },
+                        channel: { type: "string", description: "target channel for attach" },
+                        key: { type: "string", description: "target session key for attach (defaults to 'session')" },
+                        title: { type: "string", description: "task title override for promote_task" },
+                        category: { type: "string", description: "task category override for promote_task" },
+                        body: { type: "string", description: "task body override for promote_task" },
+                    },
+                    required: ["action"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const manager = (0, manager_1.createBridgeManager)();
+            const action = (args.action || "").trim();
+            if (action === "begin") {
+                if (!ctx?.currentSession) {
+                    return "bridge_manage begin requires an active session context.";
+                }
+                const objective = (args.objective || "").trim();
+                if (!objective)
+                    return "objective is required for bridge begin.";
+                return (0, manager_1.formatBridgeStatus)(manager.beginBridge({
+                    objective,
+                    summary: (args.summary || objective).trim(),
+                    session: ctx.currentSession,
+                }));
+            }
+            const bridgeId = (args.bridgeId || "").trim();
+            if (!bridgeId) {
+                return "bridgeId is required for this bridge action.";
+            }
+            if (action === "attach") {
+                const friendId = (args.friendId || "").trim();
+                const channel = (args.channel || "").trim();
+                const key = (args.key || "session").trim();
+                if (!friendId || !channel) {
+                    return "friendId and channel are required for bridge attach.";
+                }
+                const sessionPath = (0, config_1.resolveSessionPath)(friendId, channel, key);
+                const sessionTail = await summarizeSessionTailSafely({
+                    sessionPath,
+                    friendId,
+                    channel,
+                    key,
+                    messageCount: 20,
+                    trustLevel: ctx?.context?.friend?.trustLevel,
+                    summarize: ctx?.summarize,
+                    archiveFallback: true,
+                });
+                if (sessionTail.kind === "missing") {
+                    return NO_SESSION_FOUND_MESSAGE;
+                }
+                return (0, manager_1.formatBridgeStatus)(manager.attachSession(bridgeId, {
+                    friendId,
+                    channel,
+                    key,
+                    sessionPath,
+                    snapshot: sessionTail.kind === "ok" ? sessionTail.snapshot : EMPTY_SESSION_MESSAGE,
+                }));
+            }
+            if (action === "status") {
+                const bridge = manager.getBridge(bridgeId);
+                if (!bridge)
+                    return `bridge not found: ${bridgeId}`;
+                return (0, manager_1.formatBridgeStatus)(bridge);
+            }
+            if (action === "promote_task") {
+                return (0, manager_1.formatBridgeStatus)(manager.promoteBridgeToTask(bridgeId, {
+                    title: args.title,
+                    category: args.category,
+                    body: args.body,
+                }));
+            }
+            if (action === "complete") {
+                return (0, manager_1.formatBridgeStatus)(manager.completeBridge(bridgeId));
+            }
+            if (action === "cancel") {
+                return (0, manager_1.formatBridgeStatus)(manager.cancelBridge(bridgeId));
+            }
+            return `unknown bridge action: ${action}`;
+        },
+        summaryKeys: ["action", "bridgeId", "objective", "friendId", "channel", "key"],
+    },
+];