@ouro.bot/cli 0.1.0-alpha.44 → 0.1.0-alpha.441

package/dist/repertoire/tools-config.js

@@ -0,0 +1,185 @@
+"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 an agent configuration value. Managed keys (version, enabled) cannot be modified.",
+                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}`;
+                }
+            }
+            // Managed: refuse
+            if (entry.tier === "managed") {
+                (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.update_config_refused", message: `refused managed change to ${a.path}`, meta: { path: a.path, tier: "managed" } });
+                return `This key is managed by the harness and cannot be modified directly.`;
+            }
+            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 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.`;
+        },
+    },
+];

package/dist/repertoire/tools-continuity.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.continuityToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const episodes_1 = require("../arc/episodes");
+const cares_1 = require("../arc/cares");
+const presence_1 = require("../arc/presence");
+const intentions_1 = require("../arc/intentions");
+exports.continuityToolDefinitions = [
+    // ── Continuity tools ──────────────────────────────────────────────
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_episodes",
+                description: "Query recent episodes from my continuity log. Returns timestamped records of significant events (obligation shifts, coding milestones, bridge events, care events, turning points).",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        limit: { type: "number", description: "Maximum episodes to return (default 20)" },
+                        kind: { type: "string", description: "Filter by episode kind: obligation_shift, coding_milestone, bridge_event, care_event, tempo_shift, turning_point" },
+                        since: { type: "string", description: "ISO timestamp — only return episodes after this time" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const options = {};
+            if (a.limit)
+                options.limit = parseInt(a.limit, 10);
+            if (a.kind)
+                options.kinds = [a.kind];
+            if (a.since)
+                options.since = a.since;
+            const episodes = (0, episodes_1.readRecentEpisodes)(agentRoot, options);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_episodes", message: `queried ${episodes.length} episodes`, meta: { count: episodes.length } });
+            return JSON.stringify(episodes, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "capture_episode",
+                description: "Record a turning point or significant moment. This is my tool for saying 'that was important — keep it.' Nearly frictionless: only summary and whyItMattered required.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        summary: { type: "string", description: "What happened" },
+                        whyItMattered: { type: "string", description: "Why this was significant" },
+                        kind: { type: "string", description: "Episode kind (default: turning_point)" },
+                        salience: { type: "string", description: "low, medium, high, or critical (default: medium)" },
+                    },
+                    required: ["summary", "whyItMattered"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const episode = (0, episodes_1.emitEpisode)(agentRoot, {
+                kind: a.kind ?? "turning_point",
+                summary: a.summary,
+                whyItMattered: a.whyItMattered,
+                relatedEntities: [],
+                salience: a.salience ?? "medium",
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.capture_episode", message: `captured episode ${episode.id}`, meta: { id: episode.id } });
+            return JSON.stringify(episode, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_presence",
+                description: "Check who's around — my own availability/lane and known peer agents.",
+                parameters: { type: "object", properties: {} },
+            },
+        },
+        handler: () => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const agentName = (0, identity_1.getAgentName)();
+            const self = (0, presence_1.readPresence)(agentRoot, agentName);
+            const peers = (0, presence_1.readPeerPresence)(agentRoot);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_presence", message: `presence: self + ${peers.length} peers`, meta: { peerCount: peers.length } });
+            return JSON.stringify({ self, peers }, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_cares",
+                description: "Query things I care about — ongoing concerns, watched situations, projects, people.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        status: { type: "string", description: "Filter by status: 'active', 'watching', 'resolved', 'dormant', or 'all' (default: active cares only)" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const cares = a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_cares", message: `queried ${cares.length} cares`, meta: { count: cares.length } });
+            return JSON.stringify(cares, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "care_manage",
+                description: "Create, update, or resolve a care. Cares are things I watch over — people, projects, missions, system health.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["create", "update", "resolve"], description: "What to do" },
+                        id: { type: "string", description: "Care ID (required for update/resolve)" },
+                        label: { type: "string", description: "Short label for the care" },
+                        why: { type: "string", description: "Why this matters" },
+                        salience: { type: "string", description: "low, medium, high, or critical" },
+                        kind: { type: "string", description: "person, agent, project, mission, or system" },
+                        stewardship: { type: "string", description: "mine, shared, or delegated" },
+                    },
+                    required: ["action"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            let result;
+            if (a.action === "create") {
+                result = (0, cares_1.createCare)(agentRoot, {
+                    label: a.label ?? "untitled",
+                    why: a.why ?? "",
+                    kind: a.kind ?? "project",
+                    status: "active",
+                    salience: a.salience ?? "medium",
+                    steward: a.stewardship ?? "mine",
+                    relatedFriendIds: [],
+                    relatedAgentIds: [],
+                    relatedObligationIds: [],
+                    relatedEpisodeIds: [],
+                    currentRisk: null,
+                    nextCheckAt: null,
+                });
+            }
+            else if (a.action === "update") {
+                const updates = {};
+                if (a.label)
+                    updates.label = a.label;
+                if (a.why)
+                    updates.why = a.why;
+                if (a.salience)
+                    updates.salience = a.salience;
+                result = (0, cares_1.updateCare)(agentRoot, a.id, updates);
+            }
+            else if (a.action === "resolve") {
+                result = (0, cares_1.resolveCare)(agentRoot, a.id);
+            }
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.care_manage", message: `care ${a.action}`, meta: { action: a.action, id: a.id } });
+            return JSON.stringify(result, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_relationships",
+                description: "Query known agent relationships — familiarity, trust, shared missions, interaction history.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        agentName: { type: "string", description: "Specific agent name to query (omit for all)" },
+                    },
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            const allFriends = ctx?.friendStore?.listAll ? await ctx.friendStore.listAll() : [];
+            let agents = allFriends.filter((f) => f.kind === "agent");
+            if (a.agentName) {
+                const needle = a.agentName.toLowerCase();
+                agents = agents.filter((f) => f.name?.toLowerCase() === needle);
+            }
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_relationships", message: `queried relationships`, meta: { agentName: a.agentName ?? "all" } });
+            return JSON.stringify(agents, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "intention_capture",
+                description: "File a lightweight mental note — something I want to do or check later, below the ceremony threshold of tasks or cares. Cheap to create, easy to close.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string", description: "What I want to keep track of" },
+                        salience: { type: "string", description: "low, medium, or high (default: low)" },
+                        nudgeAfter: { type: "string", description: "ISO timestamp — nudge me after this time" },
+                    },
+                    required: ["content"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const intention = (0, intentions_1.captureIntention)(agentRoot, {
+                content: a.content,
+                salience: a.salience ?? "low",
+                source: "tool",
+                ...(a.nudgeAfter ? { nudgeAfter: a.nudgeAfter } : {}),
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.intention_capture", message: `captured intention ${intention.id}`, meta: { id: intention.id } });
+            return JSON.stringify(intention, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "intention_manage",
+                description: "Resolve or dismiss an intention. Resolve = done. Dismiss = no longer relevant. Both remove it from active list.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["resolve", "dismiss"], description: "What to do" },
+                        id: { type: "string", description: "Intention ID" },
+                    },
+                    required: ["action", "id"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const result = a.action === "resolve"
+                ? (0, intentions_1.resolveIntention)(agentRoot, a.id)
+                : (0, intentions_1.dismissIntention)(agentRoot, a.id);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.intention_manage", message: `intention ${a.action}: ${a.id}`, meta: { action: a.action, id: a.id } });
+            return JSON.stringify(result, null, 2);
+        },
+    },
+];