@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.921

package/dist/repertoire/tools-notes.js

@@ -0,0 +1,496 @@
+"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.notesToolDefinitions = exports.OWN_PERSONA_NOTE_REFUSAL = void 0;
+exports.isOwnPersonaNote = isOwnPersonaNote;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const skills_1 = require("./skills");
+const config_1 = require("../heart/config");
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../heart/identity");
+const friends_1 = require("@ouro.bot/friends");
+const diary_1 = require("../mind/diary");
+const record_paths_1 = require("../mind/record-paths");
+const provenance_trust_1 = require("../mind/provenance-trust");
+const relationship_authorization_1 = require("./relationship-authorization");
+const CLAUDE_READ_ONLY_TOOLS = "Read,Grep,Glob,LS";
+function bundleRelativeLocator(filePath, ctx) {
+    const agentRoot = ctx?.agentRoot ?? (0, identity_1.getAgentRoot)();
+    const relativePath = path.relative(agentRoot, filePath);
+    if (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+        return relativePath.split(path.sep).join("/");
+    }
+    return filePath.split(path.sep).join("/");
+}
+// A friend note is a fact or preference about a person. The agent's own personality, voice and psyche are not facts
+// about the person: they live in the bundle's psyche folder, which ships from the repo and is changed by pull request.
+const OWN_PERSONA_NOTE = /\b(?:your|my|the\s+(?:agent|butler|bot|assistant)(?:['\u2019]s)?)\s+(?:own\s+)?(?:personality|persona|psyche|soul|identity|character|voice|self[- ]concept)\b|\b(?:channel|embody|role-?play|act\s+like|talk\s+like|sound\s+like|be\s+more)\b[^.\n]{0,40}\b(?:energy|vibe|character|persona)\b|\b(?:act|behave)\s+like\s+(?:a|an|the)\b/i;
+const PERSONA_KEY = /^\s*(?:persona|personality|psyche|soul)\s*$/i;
+function isOwnPersonaNote(key, content) {
+    return PERSONA_KEY.test(key ?? "") || OWN_PERSONA_NOTE.test(`${key ?? ""} ${content ?? ""}`);
+}
+exports.OWN_PERSONA_NOTE_REFUSAL = "that note is about my own personality or voice, not about the person, so it does not belong in a friend note. my psyche lives in the bundle's psyche folder and ships from the repo; i do not edit it live. a personality change goes to Claude Code as a request (over A2A, or as a failure or feature report), and it ships by pull request through the replay gate. this is a guardrail on persona content, not on the person: a note about the person themselves (their facts, preferences, voice, character in a game) is fine and saves normally. friend notes hold facts and preferences about this person only.";
+exports.notesToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "list_skills",
+                description: "list all available skills",
+                parameters: { type: "object", properties: {} },
+            },
+        },
+        handler: () => JSON.stringify((0, skills_1.listSkills)()),
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "load_skill",
+                description: "load a skill by name, returns its content",
+                parameters: {
+                    type: "object",
+                    properties: { name: { type: "string" } },
+                    required: ["name"],
+                },
+            },
+        },
+        handler: (a) => {
+            try {
+                return (0, skills_1.loadSkill)(a.name);
+            }
+            catch (e) {
+                return `error: ${e}`;
+            }
+        },
+        summaryKeys: ["name"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "claude",
+                description: "use claude code to query this codebase or get an outside perspective. Use for code review, second opinions, or questions that benefit from a fresh perspective outside this conversation's context.",
+                parameters: {
+                    type: "object",
+                    properties: { prompt: { type: "string" } },
+                    required: ["prompt"],
+                },
+            },
+        },
+        handler: (a) => {
+            try {
+                const result = (0, child_process_1.spawnSync)("claude", [
+                    "-p",
+                    "--no-session-persistence",
+                    "--permission-mode",
+                    "plan",
+                    "--tools",
+                    CLAUDE_READ_ONLY_TOOLS,
+                    "--add-dir",
+                    ".",
+                ], {
+                    input: a.prompt,
+                    encoding: "utf-8",
+                    timeout: 60000,
+                });
+                if (result.error)
+                    return `error: ${result.error}`;
+                if (result.status !== 0)
+                    return `claude exited with code ${result.status}: ${result.stderr}`;
+                return result.stdout || "(no output)";
+            }
+            catch (e) {
+                return `error: ${e}`;
+            }
+        },
+        summaryKeys: ["prompt"],
+        riskProfile: {
+            mutates: "none",
+            risk: "low",
+            reason: "runs Claude Code in plan mode with only read/search/list tools",
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "web_search",
+                description: "search the web using perplexity. returns ranked results with titles, urls, and snippets",
+                parameters: {
+                    type: "object",
+                    properties: { query: { type: "string" } },
+                    required: ["query"],
+                },
+            },
+        },
+        handler: async (a) => {
+            try {
+                const key = (0, config_1.getIntegrationsConfig)().perplexityApiKey;
+                if (!key)
+                    return "error: perplexityApiKey not configured in the agent vault runtime/config item";
+                const res = await fetch("https://api.perplexity.ai/search", {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${key}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ query: a.query, max_results: 5 }),
+                });
+                if (!res.ok)
+                    return `error: ${res.status} ${res.statusText}`;
+                const data = (await res.json());
+                if (!data.results?.length)
+                    return "no results found";
+                return data.results
+                    .map((r) => `${r.title}\n${r.url}\n${r.snippet}`)
+                    .join("\n\n");
+            }
+            catch (e) {
+                return `error: ${e}`;
+            }
+        },
+        summaryKeys: ["query"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "search_facts",
+                description: "Search my Desk record diary facts matching a query. Uses semantic similarity -- phrasing matters. Try different angles if the first query doesn't find what you're looking for. Search written facts before asking the human something the record may already answer.",
+                parameters: {
+                    type: "object",
+                    properties: { query: { type: "string" } },
+                    required: ["query"],
+                },
+            },
+        },
+        handler: async (a) => {
+            try {
+                const query = (a.query || "").trim();
+                if (!query)
+                    return "query is required";
+                const resultLines = [];
+                const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)());
+                for (const fact of hits) {
+                    let meta = `source=${fact.source}, createdAt=${fact.createdAt}`;
+                    if (fact.provenance) {
+                        if (fact.provenance.channel)
+                            meta += `, channel=${fact.provenance.channel}`;
+                        if (fact.provenance.friendName)
+                            meta += `, friend=${fact.provenance.friendName}`;
+                        if (fact.provenance.trust)
+                            meta += `, trust=${fact.provenance.trust}`;
+                    }
+                    const tag = (0, provenance_trust_1.classifyProvenanceTrust)(fact.provenance) === "external" ? "diary/external" : "diary";
+                    resultLines.push(`[${tag}] ${fact.text} (${meta})`);
+                }
+                return resultLines.join("\n");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+            }
+        },
+        summaryKeys: ["query"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "consult_diary",
+                description: "Inspect my Desk record diary facts. With a query, searches semantically. Without a query, returns the most recent facts. Use this for direct record inspection before asking someone to restate something already written down.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                        limit: { type: "string" },
+                    },
+                },
+            },
+        },
+        handler: async (a) => {
+            try {
+                const limitRaw = a.limit ? Number.parseInt(String(a.limit), 10) : 10;
+                const limit = Number.isFinite(limitRaw) ? Math.min(50, Math.max(1, limitRaw)) : 10;
+                const query = typeof a.query === "string" ? a.query.trim() : "";
+                const facts = (0, diary_1.readDiaryEntries)();
+                const matches = query ? await (0, diary_1.searchDiaryEntries)(query, facts) : [...facts].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+                const items = matches.slice(0, limit).map((fact) => ({
+                    id: fact.id,
+                    text: fact.text,
+                    source: fact.source,
+                    createdAt: fact.createdAt,
+                    ...(fact.about ? { about: fact.about } : {}),
+                    ...(fact.provenance ? { provenance: fact.provenance } : {}),
+                }));
+                return JSON.stringify({ items });
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+            }
+        },
+        summaryKeys: ["query", "limit"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "diary_write",
+                description: "Write an entry in my diary -- something I learned, noticed, or concluded that I want available later. Use 'about' to tag the entry to a person, topic, or context. Write for my future self: include enough context that the entry makes sense without the surrounding conversation. Prefer durable conclusions over passing noise. Don't duplicate what already belongs in friend notes.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        entry: { type: "string" },
+                        about: { type: "string" },
+                    },
+                    required: ["entry"],
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            const entry = (a.entry || "").trim();
+            if (!entry)
+                return "entry is required";
+            let provenance;
+            if (ctx?.context) {
+                const p = { tool: "diary_write" };
+                const channel = ctx.context.channel?.channel;
+                if (channel)
+                    p.channel = channel;
+                const friendId = ctx.context.friend?.id;
+                if (friendId)
+                    p.friendId = friendId;
+                const friendName = ctx.context.friend?.name;
+                if (friendName)
+                    p.friendName = friendName;
+                const trust = ctx.context.friend?.trustLevel;
+                if (trust)
+                    p.trust = trust;
+                provenance = p;
+            }
+            const result = await (0, diary_1.saveDiaryEntry)({
+                text: entry,
+                source: "tool:diary_write",
+                about: typeof a.about === "string" ? a.about : undefined,
+                provenance,
+            });
+            if (result.added > 0) {
+                ctx?.habitSession?.recordProducedRef?.({
+                    kind: "desk_record",
+                    locator: bundleRelativeLocator(path.join((0, record_paths_1.resolveRecordDiaryRoot)(), "facts.jsonl"), ctx),
+                });
+            }
+            return `saved diary entry (added=${result.added}, skipped=${result.skipped})`;
+        },
+        summaryKeys: ["entry", "about"],
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes Desk record diary fact" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "friend_list",
+                description: "list all friends with id, name, and trust level. use this when i need to see who i know — e.g. for cross-chat outreach decisions, screener triage, or just orienting on the friend graph.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        trust: { type: "string", enum: ["family", "friend", "stranger"], description: "optional trust filter; omit to list all" },
+                        limit: { type: "string", description: "max records to return, 1-200. defaults to 50." },
+                    },
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            /* v8 ignore start -- friend_list defensive plumbing: ctx + listAll guards, trust/limit branch fan-out, and empty-set status messages aren't all combined in tests; full coverage lives at the friend-store unit-test layer @preserve */
+            if (!ctx?.friendStore)
+                return "i can't list friends -- friend store not available";
+            if (!ctx.friendStore.listAll)
+                return "the configured friend store does not support listing.";
+            const all = await ctx.friendStore.listAll();
+            const trustFilter = a.trust;
+            const filtered = trustFilter
+                ? all.filter((f) => (f.trustLevel ?? "friend") === trustFilter)
+                : all;
+            const limitRaw = a.limit ? Number.parseInt(a.limit, 10) : 50;
+            const limit = Number.isFinite(limitRaw) ? Math.min(200, Math.max(1, limitRaw)) : 50;
+            const ordered = [...filtered].sort((left, right) => left.name.localeCompare(right.name)).slice(0, limit);
+            if (ordered.length === 0) {
+                return trustFilter ? `no friends with trust level '${trustFilter}'.` : "no friends recorded yet.";
+            }
+            /* v8 ignore stop */
+            /* v8 ignore start -- formatting branches: externalIds presence + pluralization + trust suffix variants depend on specific friend-record shapes not exhaustively combined in tests @preserve */
+            const lines = ordered.map((friend) => {
+                const externals = friend.externalIds && friend.externalIds.length > 0
+                    ? ` [${friend.externalIds.map((id) => `${id.provider}:${id.externalId}`).join(", ")}]`
+                    : "";
+                return `- ${friend.id} (${friend.trustLevel ?? "friend"}): ${friend.name}${externals}`;
+            });
+            return `${ordered.length} friend${ordered.length === 1 ? "" : "s"}${trustFilter ? ` with trust=${trustFilter}` : ""}:\n${lines.join("\n")}`;
+            /* v8 ignore stop */
+        },
+        summaryKeys: ["trust", "limit"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "get_friend_note",
+                description: "read a specific friend record by friend id. use this when i need notes/context about someone not currently active",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string" },
+                    },
+                    required: ["friendId"],
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            const friendId = (a.friendId || "").trim();
+            if (!friendId)
+                return "friendId is required";
+            if (!ctx?.friendStore)
+                return "i can't read friend notes -- friend store not available";
+            const friend = await ctx.friendStore.get(friendId);
+            if (!friend)
+                return `friend not found: ${friendId}`;
+            return JSON.stringify(friend, null, 2);
+        },
+        summaryKeys: ["friendId"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "save_friend_note",
+                description: "save something i learned about my friend. use type 'name' to update their display name, 'tool_preference' for presentation preferences, or 'note' for general context. For Sanctuary relationships, preference source is stated (the person said or confirmed it), observed (a revisable pattern i inferred), or default (a fallback until better evidence), and only communication or timing are accepted. Other agents retain their existing integration-preference behavior and do not persist this provenance field. desired state and action authority belong in steward policy. notes and preferences improve orientation but never grant authority. set override=true when replacing an existing value.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        type: { type: "string", enum: ["name", "tool_preference", "note"], description: "what kind of information to save" },
+                        key: { type: "string", description: "category key (required for tool_preference and note; Sanctuary relationship preferences use communication or timing)" },
+                        source: { type: "string", enum: ["stated", "observed", "default"], description: "preference provenance; required for Sanctuary relationship preferences" },
+                        content: { type: "string", description: "the value to save" },
+                        override: { type: "string", enum: ["true", "false"], description: "set to 'true' to overwrite an existing value" },
+                    },
+                    required: ["type", "content"],
+                },
+            },
+        },
+        handler: async (a, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.save_friend_note",
+                message: "save friend note invoked",
+                meta: { type: a.type },
+            });
+            if (!ctx?.context) {
+                return "i can't save notes -- no friend context available";
+            }
+            if (!ctx.friendStore) {
+                return "i can't save notes -- friend store not available";
+            }
+            const friendId = ctx.context.friend?.id;
+            if (!friendId)
+                return "i can't save notes -- no friend identity available";
+            if (a.type !== "name" && isOwnPersonaNote(a.key, a.content))
+                return exports.OWN_PERSONA_NOTE_REFUSAL;
+            const actor = ctx.relationshipAuthorization?.actor;
+            const isSanctuaryRelationship = ctx.context.friend?.capabilityProfileId?.startsWith("sanctuary-") === true;
+            const preferenceSource = a.source;
+            if (isSanctuaryRelationship && a.type === "tool_preference" && !["stated", "observed", "default"].includes(String(preferenceSource))) {
+                return "i need exact preference provenance: source must be stated, observed, or default";
+            }
+            if (isSanctuaryRelationship && a.type === "tool_preference" && !["communication", "timing"].includes(a.key ?? "")) {
+                return "Sanctuary relationship preferences are limited to communication or timing; desired state and action authority belong in steward policy";
+            }
+            if (actor?.trustLevel === "friend" && (actor.friendId !== friendId || a.type !== "tool_preference" || !["communication", "timing"].includes(a.key ?? ""))) {
+                return "household members may only save their own communication or timing preferences; preferences never grant authority";
+            }
+            // Validate parameters (input-shape guards stay harness-side so we keep the
+            // first-person tool wording; applyFriendNote does the record mutation).
+            if (!a.content)
+                return "i need a content value to save";
+            const validTypes = ["name", "tool_preference", "note"];
+            if (!validTypes.includes(a.type))
+                return `i don't recognize type '${a.type}' -- use name, tool_preference, or note`;
+            if ((a.type === "tool_preference" || a.type === "note") && !a.key)
+                return "i need a key for tool_preference or note type";
+            // Record-domain logic lives in @ouro.bot/friends; this wrapper maps the
+            // structured FriendOpResult back to the tool's first-person strings.
+            if (isSanctuaryRelationship && a.type === "tool_preference" && preferenceSource) {
+                const current = await ctx.friendStore.get(friendId);
+                if (!current)
+                    return "i can't find the friend record on disk";
+                if (current.relationshipPolicy?.preferences[a.key] && a.override !== "true")
+                    return `relationship preference '${a.key}' already exists; call again with override: true to replace it`;
+                const sourceKind = preferenceSource === "observed" ? "observed pattern" : preferenceSource === "default" ? "default fallback" : "explicit turn";
+                const turnSource = `${ctx.currentSession?.channel ?? "relationship"} ${sourceKind} ${actor?.sessionEventId ?? "unknown-event"}`;
+                await ctx.friendStore.put(friendId, (0, relationship_authorization_1.withRelationshipPreference)(current, { category: a.key, value: a.content, provenance: preferenceSource, source: turnSource }));
+                return `saved preference: source=${turnSource}; provenance=${preferenceSource}; category=${a.key}; value=${a.content}; this changes presentation only and grants no authority`;
+            }
+            const storedKey = a.key;
+            const result = await (0, friends_1.applyFriendNote)(ctx.friendStore, friendId, {
+                type: a.type,
+                ...(storedKey !== undefined ? { key: storedKey } : {}),
+                content: a.content,
+                override: a.override === "true",
+            });
+            switch (result.status) {
+                case "saved":
+                    if (a.type === "name")
+                        return `saved: name = ${a.content}`;
+                    if (a.type === "tool_preference")
+                        return `saved: toolPreference ${a.key} = ${a.content}`;
+                    return `saved: note ${a.key} = ${a.content}`;
+                case "redirected_to_name":
+                    return `updated friend's name to '${a.content}' (stored as name, not a note)`;
+                case "override_required":
+                    // result.message embeds the existing value; append the harness merge instruction.
+                    return `${result.message}. if you want to replace it, call again with override: true. or merge both values into content and override.`;
+                case "not_found":
+                    return "i can't find the friend record on disk";
+                /* v8 ignore next 2 -- invalid is pre-empted by the harness validation above; kept for exhaustiveness @preserve */
+                case "invalid":
+                    return result.message ?? "i can't save that note";
+                default:
+                    return `error saving note: ${result.message}`;
+            }
+        },
+        summaryKeys: ["type", "key", "content"],
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "writes friend notes/preferences" },
+    },
+];