@ouro.bot/cli 0.1.0-alpha.21 → 0.1.0-alpha.211

package/dist/repertoire/tools-bluebubbles.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bluebubblesToolDefinitions = void 0;
+const runtime_1 = require("../nerves/runtime");
+exports.bluebubblesToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "bluebubbles_set_reply_target",
+                description: "choose where the current iMessage turn should land. use this when you want to widen back to top-level or route your update into a specific active thread in the same chat.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        target: {
+                            type: "string",
+                            enum: ["current_lane", "top_level", "thread"],
+                            description: "current_lane mirrors the current inbound lane, top_level answers in the main chat, and thread targets a specific active thread.",
+                        },
+                        threadOriginatorGuid: {
+                            type: "string",
+                            description: "required when target=thread; use one of the thread ids surfaced in the inbound iMessage context.",
+                        },
+                    },
+                    required: ["target"],
+                },
+            },
+        },
+        handler: (args, ctx) => {
+            const target = typeof args.target === "string" ? args.target.trim() : "";
+            const controller = ctx?.bluebubblesReplyTarget;
+            if (!controller) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "tools",
+                    event: "tool.error",
+                    message: "bluebubbles reply target missing controller",
+                    meta: { target },
+                });
+                return "bluebubbles reply targeting is not available in this context.";
+            }
+            if (target === "current_lane") {
+                const result = controller.setSelection({ target: "current_lane" });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.end",
+                    message: "bluebubbles reply target updated",
+                    meta: { target: "current_lane", success: true },
+                });
+                return result;
+            }
+            if (target === "top_level") {
+                const result = controller.setSelection({ target: "top_level" });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.end",
+                    message: "bluebubbles reply target updated",
+                    meta: { target: "top_level", success: true },
+                });
+                return result;
+            }
+            if (target === "thread") {
+                const threadOriginatorGuid = typeof args.threadOriginatorGuid === "string" ? args.threadOriginatorGuid.trim() : "";
+                if (!threadOriginatorGuid) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "tools",
+                        event: "tool.error",
+                        message: "bluebubbles reply target missing thread id",
+                        meta: { target: "thread" },
+                    });
+                    return "threadOriginatorGuid is required when target=thread.";
+                }
+                const result = controller.setSelection({ target: "thread", threadOriginatorGuid });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.end",
+                    message: "bluebubbles reply target updated",
+                    meta: { target: "thread", success: true },
+                });
+                return result;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "tools",
+                event: "tool.error",
+                message: "bluebubbles reply target invalid target",
+                meta: { target },
+            });
+            return "target must be one of: current_lane, top_level, thread.";
+        },
+        summaryKeys: ["target", "threadOriginatorGuid"],
+    },
+];

package/dist/repertoire/tools-bridge.js

@@ -0,0 +1,141 @@
+"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_recall_1 = require("../heart/session-recall");
+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 recallSessionSafely(options) {
+    try {
+        return await (0, session_recall_1.recallSession)(options);
+    }
+    catch (error) {
+        if (options.summarize) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.session_recall_summary_fallback",
+                message: "session recall 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_recall_1.recallSession)({
+                    ...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 recall = await recallSessionSafely({
+                    sessionPath,
+                    friendId,
+                    channel,
+                    key,
+                    messageCount: 20,
+                    trustLevel: ctx?.context?.friend?.trustLevel,
+                    summarize: ctx?.summarize,
+                });
+                if (recall.kind === "missing") {
+                    return NO_SESSION_FOUND_MESSAGE;
+                }
+                return (0, manager_1.formatBridgeStatus)(manager.attachSession(bridgeId, {
+                    friendId,
+                    channel,
+                    key,
+                    sessionPath,
+                    snapshot: recall.kind === "ok" ? recall.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"],
+    },
+];

package/dist/repertoire/tools-config.js

@@ -0,0 +1,266 @@
+"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.configToolDefinitions = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../heart/identity");
+const config_registry_1 = require("../heart/config-registry");
+exports.configToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "read_config",
+                description: "Read current agent configuration with tier annotations, descriptions, defaults, and effects. Optionally filter by topic to see only related settings.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        related_to: {
+                            type: "string",
+                            description: "Optional topic to filter results (e.g., 'model', 'logging', 'senses'). Case-insensitive partial match.",
+                        },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            const entries = a.related_to
+                ? (0, config_registry_1.getRegistryEntriesByTopic)(a.related_to)
+                : (0, config_registry_1.getRegistryEntries)();
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const configPath = path.join(agentRoot, "agent.json");
+            let rawConfig = {};
+            try {
+                rawConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                /* v8 ignore next -- defensive: agent.json read failure in read_config @preserve */
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.read_config_error", message: "failed to read agent.json", meta: { path: configPath } });
+            }
+            const result = entries.map((entry) => {
+                const parts = entry.path.split(".");
+                let current = rawConfig;
+                for (const part of parts) {
+                    if (current && typeof current === "object" && !Array.isArray(current)) {
+                        current = current[part];
+                    }
+                    else {
+                        current = undefined;
+                        break;
+                    }
+                }
+                const isExplicit = current !== undefined;
+                let source;
+                let currentValue;
+                if (isExplicit) {
+                    source = "explicit";
+                    currentValue = current;
+                }
+                else if (entry.default !== undefined) {
+                    source = "default";
+                    currentValue = entry.default;
+                }
+                else {
+                    source = "unset";
+                    currentValue = null;
+                }
+                return {
+                    path: entry.path,
+                    currentValue,
+                    source,
+                    tier: entry.tier,
+                    description: entry.description,
+                    default: entry.default !== undefined ? entry.default : null,
+                    effects: entry.effects,
+                    topics: entry.topics,
+                };
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.read_config", message: `read_config returned ${result.length} entries`, meta: { count: result.length, topic: a.related_to ?? null } });
+            return JSON.stringify({ entries: result }, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "update_config",
+                description: "Update a Tier 1 (self-service) agent configuration value immediately. For Tier 2 keys that require operator approval, use propose_config instead. Tier 3 (operator-only) keys are refused.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Config key in dot-notation (e.g., 'context.contextMargin', 'logging.level')" },
+                        value: { type: "string", description: "New value as JSON (e.g., '25', '\"debug\"', '[\"terminal\", \"ndjson\"]')" },
+                    },
+                    required: ["path", "value"],
+                },
+            },
+        },
+        handler: (a) => {
+            const entry = (0, config_registry_1.getRegistryEntry)(a.path);
+            if (!entry) {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_error", message: `unknown config path: ${a.path}`, meta: { path: a.path } });
+                return `Error: unknown config path "${a.path}". Use read_config to see available paths.`;
+            }
+            let parsedValue;
+            try {
+                parsedValue = JSON.parse(a.value);
+            }
+            catch {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_error", message: `invalid JSON value for ${a.path}`, meta: { path: a.path, value: a.value } });
+                return `Error: invalid JSON value. Provide value as valid JSON (e.g., 25, "debug", ["terminal"]).`;
+            }
+            // Validate value against registry entry's validator
+            /* v8 ignore next -- all current entries have validators; guard kept for future entries without one @preserve */
+            if (entry.validate) {
+                const validationError = entry.validate(parsedValue);
+                if (validationError) {
+                    (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_error", message: `validation failed for ${a.path}: ${validationError}`, meta: { path: a.path, value: a.value, validationError } });
+                    return `Error: validation failed for "${a.path}": ${validationError}`;
+                }
+            }
+            // Tier 3: refuse
+            if (entry.tier === 3) {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_refused", message: `refused T3 change to ${a.path}`, meta: { path: a.path, tier: 3 } });
+                return `Refused: "${a.path}" is an operator-only (Tier 3) key. ${entry.description} Only the operator can change this value directly in agent.json.`;
+            }
+            // Tier 2: refuse — must use propose_config
+            if (entry.tier === 2) {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_refused", message: `refused T2 change to ${a.path} — use propose_config`, meta: { path: a.path, tier: 2 } });
+                return `Refused: "${a.path}" is a Tier 2 (proposal) key that requires operator approval. Use propose_config instead of update_config to propose this change.`;
+            }
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const configPath = path.join(agentRoot, "agent.json");
+            let rawConfig;
+            try {
+                rawConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                /* v8 ignore next -- defensive: agent.json read failure in update_config @preserve */
+                return `Error: failed to read agent.json at ${configPath}`;
+            }
+            // Apply T1 change immediately
+            const parts = entry.path.split(".");
+            let target = rawConfig;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (!(parts[i] in target) || typeof target[parts[i]] !== "object" || target[parts[i]] === null) {
+                    target[parts[i]] = {};
+                }
+                target = target[parts[i]];
+            }
+            target[parts[parts.length - 1]] = parsedValue;
+            fs.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n", "utf-8");
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_applied", message: `applied config change to ${a.path}`, meta: { path: a.path, tier: entry.tier, value: parsedValue } });
+            return `Success: "${a.path}" updated to ${JSON.stringify(parsedValue)}. Change applied immediately.`;
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "propose_config",
+                description: "Propose a change to a Tier 2 (proposal) agent configuration value. Requires operator approval before the change is applied. For Tier 1 self-service keys, use update_config instead.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Config key in dot-notation (e.g., 'context.maxTokens', 'humanFacing.model')" },
+                        value: { type: "string", description: "New value as JSON (e.g., '120000', '\"azure\"', '{\"enabled\": true}')" },
+                    },
+                    required: ["path", "value"],
+                },
+            },
+        },
+        confirmationRequired: true,
+        confirmationAlwaysRequired: true,
+        handler: (a) => {
+            const entry = (0, config_registry_1.getRegistryEntry)(a.path);
+            if (!entry) {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.propose_config_error", message: `unknown config path: ${a.path}`, meta: { path: a.path } });
+                return `Error: unknown config path "${a.path}". Use read_config to see available paths.`;
+            }
+            let parsedValue;
+            try {
+                parsedValue = JSON.parse(a.value);
+            }
+            catch {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.propose_config_error", message: `invalid JSON value for ${a.path}`, meta: { path: a.path, value: a.value } });
+                return `Error: invalid JSON value. Provide value as valid JSON (e.g., 120000, "azure", {"enabled": true}).`;
+            }
+            // Validate value against registry entry's validator
+            /* v8 ignore next -- all current entries have validators; guard kept for future entries without one @preserve */
+            if (entry.validate) {
+                const validationError = entry.validate(parsedValue);
+                if (validationError) {
+                    (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.propose_config_error", message: `validation failed for ${a.path}: ${validationError}`, meta: { path: a.path, value: a.value, validationError } });
+                    return `Error: validation failed for "${a.path}": ${validationError}`;
+                }
+            }
+            // Tier 3: refuse
+            if (entry.tier === 3) {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.propose_config_refused", message: `refused T3 change to ${a.path}`, meta: { path: a.path, tier: 3 } });
+                return `Refused: "${a.path}" is an operator-only (Tier 3) key. ${entry.description} Only the operator can change this value directly in agent.json.`;
+            }
+            // Tier 1: refuse — use update_config for self-service keys
+            if (entry.tier === 1) {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.propose_config_refused", message: `refused T1 change to ${a.path} — use update_config`, meta: { path: a.path, tier: 1 } });
+                return `Refused: "${a.path}" is a Tier 1 (self-service) key. Use update_config instead — no operator approval needed.`;
+            }
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const configPath = path.join(agentRoot, "agent.json");
+            let rawConfig;
+            try {
+                rawConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                /* v8 ignore next -- defensive: agent.json read failure in propose_config @preserve */
+                return `Error: failed to read agent.json at ${configPath}`;
+            }
+            // Apply T2 change (operator confirmation already obtained via confirmationAlwaysRequired)
+            const parts = entry.path.split(".");
+            let target = rawConfig;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (!(parts[i] in target) || typeof target[parts[i]] !== "object" || target[parts[i]] === null) {
+                    target[parts[i]] = {};
+                }
+                target = target[parts[i]];
+            }
+            target[parts[parts.length - 1]] = parsedValue;
+            fs.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n", "utf-8");
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.propose_config_applied", message: `applied approved config change to ${a.path}`, meta: { path: a.path, tier: entry.tier, value: parsedValue } });
+            return `Success: "${a.path}" updated to ${JSON.stringify(parsedValue)}. Change approved and applied.`;
+        },
+    },
+];