@ouro.bot/cli 0.1.0-alpha.24 → 0.1.0-alpha.241

package/dist/repertoire/tools-flight.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flightToolDefinitions = void 0;
+exports.resetDuffelClient = resetDuffelClient;
+const duffel_client_1 = require("./duffel-client");
+const user_profile_1 = require("./user-profile");
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+// Lazy-initialized Duffel client singleton
+let _duffelClient = null;
+async function getDuffelClient() {
+    if (!_duffelClient) {
+        _duffelClient = await (0, duffel_client_1.createDuffelClient)();
+    }
+    return _duffelClient;
+}
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot access flight tools.";
+    }
+    if (ctx.context.friend.trustLevel !== "family") {
+        return "booking and cancellation require family trust level.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+function requireFriendContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot search flights.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+exports.flightToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_search",
+                description: "Search for flights between two airports. Returns available offers with prices.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        origin: { type: "string", description: "Origin airport IATA code (e.g. 'SFO')" },
+                        destination: { type: "string", description: "Destination airport IATA code (e.g. 'JFK')" },
+                        departure_date: { type: "string", description: "Departure date (YYYY-MM-DD)" },
+                        return_date: { type: "string", description: "Return date for round trips (optional)" },
+                        passengers: { type: "string", description: "Number of adult passengers (default '1')" },
+                        cabin_class: { type: "string", description: "Cabin class: economy, premium_economy, business, first" },
+                    },
+                    required: ["origin", "destination", "departure_date"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_search",
+                message: "flight_search invoked",
+                meta: { tool: "flight_search", origin: args.origin, destination: args.destination },
+            });
+            const guard = requireFriendContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const client = await getDuffelClient();
+                const passengerCount = parseInt(args.passengers || "1", 10);
+                const passengers = Array.from({ length: passengerCount }, () => ({ type: "adult" }));
+                const offers = await client.searchFlights({
+                    origin: args.origin,
+                    destination: args.destination,
+                    departureDate: args.departure_date,
+                    returnDate: args.return_date,
+                    passengers,
+                    cabinClass: args.cabin_class,
+                });
+                if (offers.length === 0) {
+                    return "no flights found for those criteria.";
+                }
+                return JSON.stringify(offers, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive @preserve */
+                return `flight search error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["origin", "destination", "departure_date"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_hold",
+                description: "Hold a flight offer for a short period before committing to book. Not all airlines support holds.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        offer_id: { type: "string", description: "The Duffel offer ID to hold" },
+                    },
+                    required: ["offer_id"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_hold",
+                message: "flight_hold invoked",
+                meta: { tool: "flight_hold", offerId: args.offer_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            // Hold functionality would call Duffel's offer hold API.
+            // For pre-build, we return a structured acknowledgment.
+            return JSON.stringify({
+                status: "hold_requested",
+                offerId: args.offer_id,
+                message: "Hold requested. Confirm or cancel before the hold expires.",
+            });
+        },
+        summaryKeys: ["offer_id"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_book",
+                description: "Book a flight. Pulls passenger name/DOB/passport from the user's profile. Creates a virtual card, books the flight, then deactivates the card. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        offer_id: { type: "string", description: "The Duffel offer ID to book" },
+                        amount: { type: "string", description: "Expected total amount in dollars" },
+                        currency: { type: "string", description: "Currency code (e.g. 'usd')" },
+                    },
+                    required: ["offer_id", "amount", "currency"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_book",
+                message: "flight_book invoked",
+                meta: { tool: "flight_book", offerId: args.offer_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                // Get passenger data from profile
+                const legalName = await (0, user_profile_1.getUserProfileField)(guard.friendId, "legalName", store);
+                if (!legalName) {
+                    return "passenger profile not found — please store your profile first using user_profile_store.";
+                }
+                const dateOfBirth = await (0, user_profile_1.getUserProfileField)(guard.friendId, "dateOfBirth", store);
+                const passport = await (0, user_profile_1.getUserProfileField)(guard.friendId, "passport", store);
+                const client = await getDuffelClient();
+                const result = await client.createOrder({
+                    offerId: args.offer_id,
+                    passengers: [{
+                            type: "adult",
+                            givenName: legalName.first,
+                            familyName: legalName.last,
+                            /* v8 ignore next -- reason @preserve */
+                            dateOfBirth: dateOfBirth ?? "1990-01-01",
+                            passportNumber: passport?.number,
+                            passportCountry: passport?.country,
+                            passportExpiry: passport?.expiry,
+                        }],
+                    amount: parseFloat(args.amount),
+                    currency: args.currency,
+                });
+                return JSON.stringify(result, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive @preserve */
+                return `booking error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["offer_id", "amount"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "flight_cancel",
+                description: "Cancel a flight booking. Not all bookings are cancellable. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        order_id: { type: "string", description: "The Duffel order ID to cancel" },
+                    },
+                    required: ["order_id"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_flight_cancel",
+                message: "flight_cancel invoked",
+                meta: { tool: "flight_cancel", orderId: args.order_id },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const client = await getDuffelClient();
+                const result = await client.cancelOrder(args.order_id);
+                return JSON.stringify(result, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive @preserve */
+                return `cancellation error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["order_id"],
+    },
+];
+/** Reset the Duffel client singleton (for testing). */
+function resetDuffelClient() {
+    _duffelClient = null;
+}

package/dist/repertoire/tools-flow.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restTool = exports.settleTool = exports.observeTool = exports.ponderTool = void 0;
+exports.ponderTool = {
+    type: "function",
+    function: {
+        name: "ponder",
+        description: "i need to sit with this. from a conversation, takes the thread inward with a thought and a parting word. from inner dialog, keeps the wheel turning for another pass. must be the only tool call in the turn. Use when a question deserves more thought than this turn allows. Don't ponder trivial questions.",
+        parameters: {
+            type: "object",
+            properties: {
+                thought: {
+                    type: "string",
+                    description: "the question or thread that needs more thought — brief framing, not analysis. required from a conversation, ignored from inner dialog.",
+                },
+                say: {
+                    type: "string",
+                    description: "what you say before going quiet — speak to what caught your attention, not just that something did. required from a conversation, ignored from inner dialog.",
+                },
+            },
+        },
+    },
+};
+exports.observeTool = {
+    type: "function",
+    function: {
+        name: "observe",
+        description: "absorb what happened without responding — the moment doesn't call for words. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {
+                reason: { type: "string", description: "brief reason for staying silent (for logging)" },
+            },
+        },
+    },
+};
+exports.settleTool = {
+    type: "function",
+    function: {
+        name: "settle",
+        description: "respond to the user with your message. call this tool when you are ready to deliver your response. Only call when you have a substantive response. If you're settling with 'I'll look into that,' you probably should be using a tool instead.",
+        parameters: {
+            type: "object",
+            properties: {
+                answer: { type: "string" },
+                intent: { type: "string", enum: ["complete", "blocked", "direct_reply"] },
+            },
+            required: ["answer"],
+        },
+    },
+};
+exports.restTool = {
+    type: "function",
+    function: {
+        name: "rest",
+        description: "put this down for now — the wheel stops until the next heartbeat. must be the only tool call in the turn.",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+    },
+};

package/dist/repertoire/tools-github.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.githubToolDefinitions = void 0;
-exports.summarizeGithubArgs = summarizeGithubArgs;
 const github_client_1 = require("./github-client");
 const runtime_1 = require("../nerves/runtime");
 exports.githubToolDefinitions = [
@@ -43,11 +42,6 @@ exports.githubToolDefinitions = [
             return (0, github_client_1.githubRequest)(ctx.githubToken, "POST", `/repos/${owner}/${repo}/issues`, JSON.stringify(payload));
         },
         integration: "github",
-        confirmationRequired: true,
+        summaryKeys: ["title"],
     },
 ];
-function summarizeGithubArgs(name, args) {
-    if (name === "file_ouroboros_bug")
-        return args.title || "";
-    return undefined;
-}

package/dist/repertoire/tools-memory.js

@@ -0,0 +1,347 @@
+"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.memoryToolDefinitions = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const skills_1 = require("./skills");
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const diary_1 = require("../mind/diary");
+exports.memoryToolDefinitions = [
+    {
+        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", "--dangerously-skip-permissions", "--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"],
+    },
+    {
+        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 secrets.json";
+                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: "recall",
+                description: "Search my diary and journal for facts, thoughts, and working notes matching a query. Uses semantic similarity -- phrasing matters. Try different angles if the first query doesn't find what you're looking for. Check recall before asking the human something you might already know.",
+                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 = [];
+                // Search diary entries
+                const hits = await (0, diary_1.searchDiaryEntries)(query, (0, diary_1.readDiaryEntries)());
+                for (const fact of hits) {
+                    resultLines.push(`[diary] ${fact.text} (source=${fact.source}, createdAt=${fact.createdAt})`);
+                }
+                // Search journal index
+                const agentRoot = (0, identity_1.getAgentRoot)();
+                const journalIndexPath = path.join(agentRoot, "journal", ".index.json");
+                try {
+                    const raw = fs.readFileSync(journalIndexPath, "utf8");
+                    const journalEntries = JSON.parse(raw);
+                    if (Array.isArray(journalEntries) && journalEntries.length > 0) {
+                        // Substring match on preview and filename
+                        const lowerQuery = query.toLowerCase();
+                        for (const entry of journalEntries) {
+                            /* v8 ignore next 4 -- both sides tested (filename-only match in recall-journal.test.ts); v8 misreports || short-circuit @preserve */
+                            if (entry.preview.toLowerCase().includes(lowerQuery) ||
+                                entry.filename.toLowerCase().includes(lowerQuery)) {
+                                resultLines.push(`[journal] ${entry.filename}: ${entry.preview}`);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // No journal index or malformed — skip journal search
+                }
+                return resultLines.join("\n");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : String(e)}`;
+            }
+        },
+        summaryKeys: ["query"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "diary_write",
+                description: "Write an entry in my diary -- something I learned, noticed, or concluded that I want to recall 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) => {
+            const entry = (a.entry || "").trim();
+            if (!entry)
+                return "entry is required";
+            const result = await (0, diary_1.saveDiaryEntry)({
+                text: entry,
+                source: "tool:diary_write",
+                about: typeof a.about === "string" ? a.about : undefined,
+            });
+            return `saved diary entry (added=${result.added}, skipped=${result.skipped})`;
+        },
+        summaryKeys: ["entry", "about"],
+    },
+    {
+        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 how they like a specific tool to behave (key = tool category like 'ado', 'graph'), or 'note' for general knowledge (key = topic). when updating an existing value, set override to true if i'm replacing/correcting it. omit override (or set false) if i'm unsure and want to check what's already saved.",
+                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, e.g. 'ado', 'role')" },
+                        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";
+            // Validate parameters
+            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";
+            try {
+                // Read fresh record from disk
+                const record = await ctx.friendStore.get(friendId);
+                if (!record)
+                    return "i can't find the friend record on disk";
+                const isOverride = a.override === "true";
+                if (a.type === "name") {
+                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
+                    await ctx.friendStore.put(friendId, updated);
+                    return `saved: name = ${a.content}`;
+                }
+                if (a.type === "tool_preference") {
+                    const existing = record.toolPreferences[a.key];
+                    if (existing && !isOverride) {
+                        return `i already have a preference for '${a.key}': "${existing}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
+                    }
+                    const updated = { ...record, toolPreferences: { ...record.toolPreferences, [a.key]: a.content }, updatedAt: new Date().toISOString() };
+                    await ctx.friendStore.put(friendId, updated);
+                    return `saved: toolPreference ${a.key} = ${a.content}`;
+                }
+                // type === "note"
+                // Redirect "name" key to name field
+                if (a.key === "name") {
+                    const updated = { ...record, name: a.content, updatedAt: new Date().toISOString() };
+                    await ctx.friendStore.put(friendId, updated);
+                    return `updated friend's name to '${a.content}' (stored as name, not a note)`;
+                }
+                const existing = record.notes[a.key];
+                if (existing && !isOverride) {
+                    return `i already have a note for '${a.key}': "${existing.value}". if you want to replace it, call again with override: true. or merge both values into content and override.`;
+                }
+                const updated = { ...record, notes: { ...record.notes, [a.key]: { value: a.content, savedAt: new Date().toISOString() } }, updatedAt: new Date().toISOString() };
+                await ctx.friendStore.put(friendId, updated);
+                return `saved: note ${a.key} = ${a.content}`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: non-Error branch for String(err) @preserve */
+                return `error saving note: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["type", "key", "content"],
+    },
+];