@ouro.bot/cli 0.1.0-alpha.61 → 0.1.0-alpha.612

package/dist/repertoire/tools-record.js

@@ -0,0 +1,463 @@
+"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.recordToolDefinitions = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const session_events_1 = require("../heart/session-events");
+const identity_1 = require("../heart/identity");
+const embedding_provider_1 = require("../mind/embedding-provider");
+const note_search_1 = require("../mind/note-search");
+const runtime_1 = require("../nerves/runtime");
+const NOTES_INDEX_VERSION = 1;
+const NOTE_SLUG_MAX_CHARS = 40;
+const DEFAULT_LIMIT = 5;
+const MAX_LIMIT = 25;
+const DEFAULT_MIN_SCORE = 0.5;
+const PREVIEW_CHAR_LIMIT = 500;
+function hasSelfTrust(ctx) {
+    const channel = ctx?.context?.channel?.channel;
+    if (channel !== "inner")
+        return false;
+    const friend = ctx?.context?.friend;
+    return !friend || friend.id === "self";
+}
+function normalizeTags(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const rawTags = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+    const tags = rawTags
+        .map((tag) => (typeof tag === "string" ? tag.trim() : ""))
+        .filter((tag) => tag.length > 0);
+    return tags.length > 0 ? tags : undefined;
+}
+function slugForContent(content) {
+    const slug = content
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, NOTE_SLUG_MAX_CHARS)
+        .replace(/-+$/g, "");
+    return slug || "note";
+}
+function renderNote(createdAt, content, tags) {
+    const frontmatter = [`created_at: ${createdAt}`];
+    if (tags?.length) {
+        frontmatter.push("tags:");
+        for (const tag of tags) {
+            frontmatter.push(`  - ${JSON.stringify(tag)}`);
+        }
+    }
+    return `---\n${frontmatter.join("\n")}\n---\n${content}\n`;
+}
+function ensureUniquePath(notesDir, date, slug) {
+    let candidate = path.join(notesDir, `${date}-${slug}.md`);
+    let suffix = 2;
+    while (fs.existsSync(candidate)) {
+        const suffixText = `-${suffix}`;
+        const cappedSlug = `${slug.slice(0, Math.max(0, NOTE_SLUG_MAX_CHARS - suffixText.length)).replace(/-+$/g, "")}${suffixText}`;
+        candidate = path.join(notesDir, `${date}-${cappedSlug}.md`);
+        suffix += 1;
+    }
+    return candidate;
+}
+function extractPreview(body) {
+    const firstLine = body.trim().split("\n").find((line) => line.trim().length > 0);
+    return (0, session_events_1.capStructuredRecordString)(firstLine.trim()).slice(0, PREVIEW_CHAR_LIMIT);
+}
+function parseTagsFromFrontmatter(lines, startIndex) {
+    const tags = [];
+    let i = startIndex;
+    while (lines[i + 1]?.trimStart().startsWith("- ")) {
+        i += 1;
+        tags.push(lines[i].trimStart().slice(2).trim().replace(/^"|"$/g, ""));
+    }
+    return { tags, nextIndex: i };
+}
+function parseCanonicalNote(filePath, stat) {
+    const raw = fs.readFileSync(filePath, "utf8");
+    let body = raw;
+    let createdAt;
+    let tags;
+    if (raw.startsWith("---\n")) {
+        const end = raw.indexOf("\n---\n", 4);
+        if (end > 0) {
+            const frontmatterRaw = raw.slice(4, end);
+            body = raw.slice(end + "\n---\n".length);
+            const lines = frontmatterRaw.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (!line.trim())
+                    continue;
+                const colonIndex = line.indexOf(":");
+                if (colonIndex < 0)
+                    continue;
+                const key = line.slice(0, colonIndex);
+                const value = line.slice(colonIndex + 1).trim();
+                if (key === "created_at" && value) {
+                    createdAt = value.replace(/^"|"$/g, "");
+                }
+                if (key === "tags") {
+                    if (value.startsWith("[") && value.endsWith("]")) {
+                        try {
+                            const parsed = JSON.parse(value);
+                            tags = parsed.filter((tag) => typeof tag === "string");
+                        }
+                        catch {
+                            tags = undefined;
+                        }
+                    }
+                    else {
+                        const parsedTags = parseTagsFromFrontmatter(lines, i);
+                        tags = parsedTags.tags.length > 0 ? parsedTags.tags : undefined;
+                        i = parsedTags.nextIndex;
+                    }
+                }
+            }
+        }
+    }
+    const trimmedBody = body.trim();
+    if (!trimmedBody)
+        return null;
+    return {
+        filename: path.basename(filePath),
+        filePath,
+        body: trimmedBody,
+        preview: extractPreview(trimmedBody),
+        createdAt,
+        tags,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+    };
+}
+function listCanonicalNotes(notesDir) {
+    let dirEntries;
+    try {
+        dirEntries = fs.readdirSync(notesDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return dirEntries
+        .filter((entry) => entry.isFile() && !entry.name.startsWith(".") && entry.name.endsWith(".md"))
+        .map((entry) => {
+        const filePath = path.join(notesDir, entry.name);
+        try {
+            return parseCanonicalNote(filePath, fs.statSync(filePath));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((record) => record !== null)
+        .sort((left, right) => left.filename.localeCompare(right.filename));
+}
+function readIndex(indexPath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+        if (parsed.version !== NOTES_INDEX_VERSION || !Array.isArray(parsed.entries))
+            return null;
+        if (!parsed.entries.every(isIndexEntry))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isIndexEntry(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const entry = value;
+    return (typeof entry.filename === "string" &&
+        typeof entry.path === "string" &&
+        typeof entry.preview === "string" &&
+        Array.isArray(entry.embedding) &&
+        entry.embedding.every((item) => typeof item === "number") &&
+        typeof entry.mtimeMs === "number" &&
+        typeof entry.size === "number");
+}
+function entryMatchesRecord(entry, record) {
+    return (entry.filename === record.filename &&
+        entry.path === record.filePath &&
+        entry.mtimeMs === record.mtimeMs &&
+        entry.size === record.size &&
+        entry.preview === record.preview);
+}
+function indexFreshForRecords(index, records) {
+    if (!index)
+        return false;
+    if (index.entries.length !== records.length)
+        return false;
+    const recordsByFilename = new Map(records.map((record) => [record.filename, record]));
+    const seenFilenames = new Set();
+    for (const entry of index.entries) {
+        if (seenFilenames.has(entry.filename))
+            return false;
+        const record = recordsByFilename.get(entry.filename);
+        if (!record || !entryMatchesRecord(entry, record))
+            return false;
+        seenFilenames.add(entry.filename);
+    }
+    return seenFilenames.size === recordsByFilename.size;
+}
+function indexFreshExcept(index, records, filename) {
+    if (!index)
+        return false;
+    const otherRecords = records.filter((record) => record.filename !== filename);
+    const otherEntries = index.entries.filter((entry) => entry.filename !== filename);
+    return indexFreshForRecords({ version: NOTES_INDEX_VERSION, entries: otherEntries }, otherRecords);
+}
+function makeEntry(record, embedding) {
+    return {
+        filename: record.filename,
+        path: record.filePath,
+        preview: record.preview,
+        embedding,
+        ...(record.createdAt ? { created_at: record.createdAt } : {}),
+        ...(record.tags ? { tags: record.tags } : {}),
+        mtimeMs: record.mtimeMs,
+        size: record.size,
+    };
+}
+function writeIndex(indexPath, index) {
+    fs.writeFileSync(indexPath, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+}
+async function embedRecord(provider, record) {
+    const [embedding] = await provider.embed([record.body]);
+    return makeEntry(record, embedding);
+}
+async function rebuildNotesIndex(notesDir, indexPath, provider) {
+    const records = listCanonicalNotes(notesDir);
+    const entries = [];
+    for (const record of records) {
+        entries.push(await embedRecord(provider, record));
+    }
+    const index = { version: NOTES_INDEX_VERSION, entries };
+    writeIndex(indexPath, index);
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.record_notes_index_rebuilt",
+        message: "notes native index rebuilt",
+        meta: { notesDir, count: entries.length },
+    });
+    return index;
+}
+async function updateIndexForSavedNote(notesDir, indexPath, savedPath, provider) {
+    const savedRecord = parseCanonicalNote(savedPath, fs.statSync(savedPath));
+    const records = [
+        ...listCanonicalNotes(notesDir).filter((record) => record.filePath !== savedPath),
+        savedRecord,
+    ].sort((left, right) => left.filename.localeCompare(right.filename));
+    const existing = readIndex(indexPath);
+    if (!indexFreshExcept(existing, records, savedRecord.filename)) {
+        await rebuildNotesIndex(notesDir, indexPath, provider);
+        return;
+    }
+    const savedEntry = await embedRecord(provider, savedRecord);
+    const entries = [
+        ...existing.entries.filter((entry) => entry.filename !== savedRecord.filename),
+        savedEntry,
+    ].sort((left, right) => left.filename.localeCompare(right.filename));
+    writeIndex(indexPath, { version: NOTES_INDEX_VERSION, entries });
+}
+async function getFreshIndex(notesDir, indexPath, provider) {
+    const records = listCanonicalNotes(notesDir);
+    const existing = readIndex(indexPath);
+    if (indexFreshForRecords(existing, records))
+        return existing;
+    return rebuildNotesIndex(notesDir, indexPath, provider);
+}
+function createProviderForTool(toolName) {
+    const provider = (0, embedding_provider_1.createDefaultEmbeddingProvider)();
+    if (!provider) {
+        return `error: ${toolName} couldn't use notes because embeddings are not configured.`;
+    }
+    return provider;
+}
+function parseLimit(raw) {
+    const parsed = typeof raw === "string" ? Number.parseInt(raw, 10) : typeof raw === "number" ? raw : DEFAULT_LIMIT;
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_LIMIT;
+    return Math.min(Math.floor(parsed), MAX_LIMIT);
+}
+function parseMinScore(raw) {
+    const parsed = typeof raw === "string" ? Number.parseFloat(raw) : typeof raw === "number" ? raw : DEFAULT_MIN_SCORE;
+    if (!Number.isFinite(parsed))
+        return DEFAULT_MIN_SCORE;
+    return parsed;
+}
+function parseCursor(raw) {
+    const parsed = typeof raw === "string" ? Number.parseInt(raw, 10) : typeof raw === "number" ? raw : 0;
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return 0;
+    return Math.floor(parsed);
+}
+exports.recordToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "note",
+                description: "Write a durable self note as canonical markdown in my notes folder. Only available to my self/inner context, not external callers.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                        },
+                    },
+                    required: ["content"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!hasSelfTrust(ctx))
+                return "error: note requires self trust and cannot be used from an external caller context.";
+            const rawArgs = args;
+            const content = typeof rawArgs.content === "string" ? rawArgs.content.trim() : "";
+            if (!content)
+                return "content is required";
+            const provider = createProviderForTool("note");
+            if (typeof provider === "string")
+                return provider;
+            const cappedContent = (0, session_events_1.capStructuredRecordString)(content);
+            const createdAt = new Date().toISOString();
+            const date = createdAt.slice(0, 10);
+            const tags = normalizeTags(rawArgs.tags);
+            const notesDir = path.join((0, identity_1.getAgentRoot)(), "notes");
+            const indexPath = path.join(notesDir, ".index.json");
+            try {
+                fs.mkdirSync(notesDir, { recursive: true });
+                const savedPath = ensureUniquePath(notesDir, date, slugForContent(content));
+                fs.writeFileSync(savedPath, renderNote(createdAt, cappedContent, tags), "utf8");
+                await updateIndexForSavedNote(notesDir, indexPath, savedPath, provider);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "repertoire",
+                    event: "repertoire.record_note_saved",
+                    message: "canonical note saved",
+                    meta: { path: savedPath, hasTags: Boolean(tags?.length) },
+                });
+                return savedPath;
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "repertoire",
+                    event: "repertoire.record_note_save_error",
+                    message: "canonical note save failed",
+                    meta: { reason: error instanceof Error ? error.message : String(error) },
+                });
+                return "error: couldn't save the note right now.";
+            }
+        },
+        summaryKeys: ["content", "tags"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "consult_notes",
+                description: "Search my canonical markdown notes semantically using the notes-native index. Only available to my self/inner context, not external callers.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                        cursor: { type: "string" },
+                        limit: { type: "string" },
+                        minScore: { type: "string" },
+                    },
+                    required: ["query"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!hasSelfTrust(ctx))
+                return "error: consult_notes requires self trust and cannot be used from an external caller context.";
+            const rawArgs = args;
+            const query = typeof rawArgs.query === "string" ? rawArgs.query.trim() : "";
+            if (!query)
+                return JSON.stringify({ items: [] });
+            const notesDir = path.join((0, identity_1.getAgentRoot)(), "notes");
+            const indexPath = path.join(notesDir, ".index.json");
+            const records = listCanonicalNotes(notesDir);
+            if (records.length === 0)
+                return JSON.stringify({ items: [] });
+            const provider = createProviderForTool("consult_notes");
+            if (typeof provider === "string")
+                return provider;
+            try {
+                const index = await getFreshIndex(notesDir, indexPath, provider);
+                const [queryEmbedding] = await provider.embed([query]);
+                const minScore = parseMinScore(rawArgs.minScore);
+                const offset = parseCursor(rawArgs.cursor);
+                const limit = parseLimit(rawArgs.limit);
+                const ranked = index.entries
+                    .filter((entry) => entry.embedding.length > 0)
+                    .map((entry) => ({
+                    path: entry.path,
+                    filename: entry.filename,
+                    excerpt: entry.preview,
+                    score: (0, note_search_1.cosineSimilarity)(queryEmbedding, entry.embedding),
+                }))
+                    .filter((entry) => entry.score >= minScore)
+                    .sort((left, right) => right.score - left.score);
+                const items = ranked.slice(offset, offset + limit);
+                const nextOffset = offset + limit;
+                const result = nextOffset < ranked.length ? { items, nextCursor: String(nextOffset) } : { items };
+                (0, runtime_1.emitNervesEvent)({
+                    component: "repertoire",
+                    event: "repertoire.record_notes_consulted",
+                    message: "canonical notes consulted",
+                    meta: { count: items.length, totalMatches: ranked.length },
+                });
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "repertoire",
+                    event: "repertoire.record_notes_consult_error",
+                    message: "canonical notes consult failed",
+                    meta: { reason: error instanceof Error ? error.message : String(error) },
+                });
+                return "error: consult_notes couldn't search notes right now.";
+            }
+        },
+        summaryKeys: ["query"],
+    },
+];

package/dist/repertoire/tools-runtime.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const socket_client_1 = require("../heart/daemon/socket-client");
+async function restartRuntime(args, agentName) {
+    if (typeof args.reason !== "string" || args.reason.trim().length === 0) {
+        return JSON.stringify({ error: "reason is required (one-line audit string)" });
+    }
+    const reason = args.reason.trim();
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.runtime_restart_requested",
+        message: "agent requested runtime restart",
+        meta: { agent: agentName, reason },
+    });
+    try {
+        const response = await (0, socket_client_1.sendDaemonCommand)(socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, {
+            kind: "daemon.restart",
+            reason,
+            requestedBy: agentName,
+        });
+        return JSON.stringify({
+            requested: true,
+            reason,
+            detail: response.message ?? "daemon restart requested",
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: "failed to reach daemon socket",
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function reviveSense(args, agentName) {
+    if (args.agent !== undefined) {
+        return "cross-agent revive is unsupported; revive_sense can only revive this agent's own senses.";
+    }
+    if (typeof args.sense !== "string" || args.sense.trim().length === 0) {
+        return JSON.stringify({ error: "sense is required (for example, 'bluebubbles')" });
+    }
+    if (typeof args.reason !== "string" || args.reason.trim().length === 0) {
+        return JSON.stringify({ error: "reason is required (one-line audit string)" });
+    }
+    const sense = args.sense.trim();
+    const reason = args.reason.trim();
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.sense_revive_requested",
+        message: "agent requested sense revive",
+        meta: { agent: agentName, sense, reason },
+    });
+    try {
+        const response = await (0, socket_client_1.sendDaemonCommand)(socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, {
+            kind: "daemon.sense_revive",
+            agent: agentName,
+            sense,
+            reason,
+        });
+        if (!response.ok) {
+            if (response.error === "Unknown daemon command kind 'daemon.sense_revive'.") {
+                return JSON.stringify({
+                    error: "daemon does not support this command; try restart_runtime",
+                    detail: response.error,
+                    agent: agentName,
+                    sense,
+                });
+            }
+            return JSON.stringify({
+                error: response.error ?? "daemon failed to revive sense",
+                agent: agentName,
+                sense,
+            });
+        }
+        return JSON.stringify({
+            revived: true,
+            agent: agentName,
+            sense,
+            detail: response.message ?? "sense revive requested",
+            snapshot: response.data,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: "failed to reach daemon socket",
+            detail: error instanceof Error ? error.message : String(error),
+            agent: agentName,
+            sense,
+        });
+    }
+}
+exports.runtimeToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "restart_runtime",
+                description: "ask my runtime (the daemon hosting me) to restart itself. for when something is wedged — stale state, recovery queue jammed, version mismatch, or i just need a fresh boot. under launchctl the daemon auto-respawns, so i come back on the other side with a clean slate. takes a one-line reason that lands in the audit log. i will NOT see this tool's response — my process exits with the daemon and i wake up fresh.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        reason: {
+                            type: "string",
+                            description: "one-line audit reason (e.g. 'bluebubbles recovery queue wedged for 4h', 'picking up daemon version update').",
+                        },
+                    },
+                    required: ["reason"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const agentName = (0, identity_1.getAgentName)();
+            return restartRuntime({ reason: args.reason }, agentName);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "revive_sense",
+                description: "revive one of my managed senses after it has wedged or landed in permanent failure. this only works for my own senses, requires family trust, and sends the daemon a one-line reason for the audit log. use restart_runtime instead if the daemon is too old to support sense-level revive.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        sense: {
+                            type: "string",
+                            description: "managed sense name to revive, for example 'bluebubbles'.",
+                        },
+                        reason: {
+                            type: "string",
+                            description: "one-line audit reason for the revive request.",
+                        },
+                    },
+                    required: ["sense", "reason"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (ctx?.context?.friend?.trustLevel !== "family") {
+                return "revive_sense requires family trust before I can revive runtime senses.";
+            }
+            const agentName = (0, identity_1.getAgentName)();
+            return reviveSense({ agent: args.agent, sense: args.sense, reason: args.reason }, agentName);
+        },
+    },
+];