@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.500

package/dist/heart/daemon/thoughts.js

@@ -0,0 +1,524 @@
+"use strict";
+// Formats inner dialog session turns for human consumption.
+// Used by `ouro thoughts` CLI command to show what the agent has been thinking.
+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.formatSurfacedValue = formatSurfacedValue;
+exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.deriveInnerJob = deriveInnerJob;
+exports.formatInnerDialogStatus = formatInnerDialogStatus;
+exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
+exports.parseInnerDialogSession = parseInnerDialogSession;
+exports.formatThoughtTurns = formatThoughtTurns;
+exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
+exports.readInnerDialogStatus = readInnerDialogStatus;
+exports.readInnerDialogRawData = readInnerDialogRawData;
+exports.followThoughts = followThoughts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const session_events_1 = require("../session-events");
+const runtime_1 = require("../../nerves/runtime");
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+}
+function extractToolFunction(toolCall) {
+    if (!toolCall || typeof toolCall !== "object" || !("function" in toolCall))
+        return null;
+    const maybeFunction = toolCall.function;
+    if (!maybeFunction || typeof maybeFunction !== "object")
+        return null;
+    const name = "name" in maybeFunction && typeof maybeFunction.name === "string"
+        ? maybeFunction.name
+        : undefined;
+    const argumentsValue = "arguments" in maybeFunction && typeof maybeFunction.arguments === "string"
+        ? maybeFunction.arguments
+        : undefined;
+    return { name, arguments: argumentsValue };
+}
+function classifyTurn(userText) {
+    if (userText.includes("waking up."))
+        return { type: "boot" };
+    const taskMatch = /## task: (.+)$/m.exec(userText);
+    if (taskMatch)
+        return { type: "task", taskId: taskMatch[1] };
+    return { type: "heartbeat" };
+}
+function extractToolNames(messages) {
+    const names = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            for (const tc of msg.tool_calls) {
+                const toolFunction = extractToolFunction(tc);
+                if (toolFunction?.name && toolFunction.name !== "settle")
+                    names.push(toolFunction.name);
+            }
+        }
+    }
+    return names;
+}
+function extractPendingPromptMessages(prompt) {
+    return prompt
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("[pending from "))
+        .map((line) => {
+        const separator = line.indexOf("]: ");
+        return separator >= 0 ? line.slice(separator + 3).trim() : "";
+    })
+        .filter((line) => line.length > 0);
+}
+function readPendingMessagesForStatus(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(pendingDir);
+    }
+    catch {
+        return [];
+    }
+    const files = [
+        ...entries.filter((entry) => entry.endsWith(".json.processing")),
+        ...entries.filter((entry) => entry.endsWith(".json") && !entry.endsWith(".json.processing")),
+    ].sort((a, b) => a.localeCompare(b));
+    const messages = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(pendingDir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.content === "string") {
+                messages.push(parsed);
+            }
+        }
+        catch {
+            // unreadable pending files should not break status queries
+        }
+    }
+    return messages;
+}
+function formatSurfacedValue(text, maxLength = 120) {
+    const firstLine = text
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine)
+        return "no outward result";
+    if (firstLine.length <= maxLength)
+        return `"${firstLine}"`;
+    return `"${firstLine.slice(0, maxLength - 3)}..."`;
+}
+function extractEnrichedFields(pendingMessages) {
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    if (!delegated?.delegatedFrom)
+        return {};
+    const snippet = delegated.content.length > 80 ? delegated.content.slice(0, 77) + "..." : delegated.content;
+    return {
+        origin: {
+            friendId: delegated.delegatedFrom.friendId,
+            channel: delegated.delegatedFrom.channel,
+            key: delegated.delegatedFrom.key,
+        },
+        contentSnippet: snippet,
+        ...(delegated.obligationStatus === "pending" ? { obligationPending: true } : {}),
+    };
+}
+function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
+    if (runtimeState?.status === "running") {
+        if (pendingMessages.length > 0) {
+            return {
+                queue: "queued to inner/dialog",
+                wake: "queued behind active turn",
+                processing: "pending",
+                surfaced: "nothing yet",
+                ...extractEnrichedFields(pendingMessages),
+            };
+        }
+        return {
+            queue: "clear",
+            wake: "in progress",
+            processing: "started",
+            surfaced: "nothing yet",
+        };
+    }
+    if (pendingMessages.length > 0) {
+        return {
+            queue: "queued to inner/dialog",
+            wake: "awaiting inner session",
+            processing: "pending",
+            surfaced: "nothing yet",
+            ...extractEnrichedFields(pendingMessages),
+        };
+    }
+    const latestProcessedPendingTurn = [...turns]
+        .reverse()
+        .find((turn) => extractPendingPromptMessages(turn.prompt).length > 0);
+    if (!latestProcessedPendingTurn) {
+        return {
+            queue: "clear",
+            wake: "idle",
+            processing: "idle",
+            surfaced: "nothing recent",
+        };
+    }
+    return {
+        queue: "clear",
+        wake: "completed",
+        processing: "processed",
+        surfaced: formatSurfacedValue(latestProcessedPendingTurn.response),
+    };
+}
+function deriveInnerJob(pendingMessages, turns, runtimeState) {
+    const isRunning = runtimeState?.status === "running";
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    const enriched = extractEnrichedFields(pendingMessages);
+    const pendingMode = delegated && "mode" in delegated && delegated.mode ? delegated.mode : "reflect";
+    const origin = enriched.origin ?? null;
+    const content = delegated?.content ?? null;
+    const obligationStatus = delegated?.obligationStatus ?? null;
+    const queuedAt = delegated?.timestamp ?? null;
+    if (isRunning) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "running", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "running",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: runtimeState?.startedAt ?? null,
+            surfacedAt: null,
+        };
+    }
+    if (pendingMessages.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "queued", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "queued",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    // No pending, not running -- check for surfaced result
+    const latestProcessedPendingTurn = [...turns]
+        .reverse()
+        .find((turn) => extractPendingPromptMessages(turn.prompt).length > 0);
+    if (latestProcessedPendingTurn) {
+        const surfacedResult = extractThoughtResponseFromMessages([
+            { role: "assistant", content: latestProcessedPendingTurn.response },
+        ]);
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.inner_job_derive",
+            message: "derived inner job state",
+            meta: { status: "surfaced", mode: "reflect", hasOrigin: false, hasObligation: false },
+        });
+        return {
+            status: "surfaced",
+            content: null,
+            origin: null,
+            mode: "reflect",
+            obligationStatus: null,
+            /* v8 ignore next -- defensive: surfacedResult fallback @preserve */
+            surfacedResult: surfacedResult || null,
+            queuedAt: null,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.inner_job_derive",
+        message: "derived inner job state",
+        meta: { status: "idle", mode: "reflect", hasOrigin: false, hasObligation: false },
+    });
+    return {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+}
+function formatInnerDialogStatus(status) {
+    const lines = [
+        `queue: ${status.queue}`,
+        `wake: ${status.wake}`,
+        `processing: ${status.processing}`,
+        `surfaced: ${status.surfaced}`,
+    ];
+    if (status.origin) {
+        lines.push(`origin: ${status.origin.friendId}/${status.origin.channel}/${status.origin.key}`);
+    }
+    if (status.contentSnippet) {
+        lines.push(`asked: ${status.contentSnippet}`);
+    }
+    if (status.obligationPending) {
+        lines.push("obligation: pending");
+    }
+    return lines.join("\n");
+}
+/** Extract text from a settle tool call's arguments. */
+function extractSettleAnswer(messages) {
+    for (let k = messages.length - 1; k >= 0; k--) {
+        const msg = messages[k];
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
+            continue;
+        for (const tc of msg.tool_calls) {
+            const toolFunction = extractToolFunction(tc);
+            if (toolFunction?.name !== "settle")
+                continue;
+            try {
+                const parsed = JSON.parse(toolFunction.arguments ?? "{}");
+                if (typeof parsed.answer === "string" && parsed.answer.trim())
+                    return parsed.answer.trim();
+            }
+            catch {
+                // malformed arguments — skip
+            }
+        }
+    }
+    return "";
+}
+function extractThoughtResponseFromMessages(messages) {
+    const assistantMsgs = messages.filter((message) => message.role === "assistant");
+    const lastAssistant = assistantMsgs.reverse().find((message) => contentToText(message.content).trim().length > 0);
+    return lastAssistant
+        ? contentToText(lastAssistant.content).trim()
+        : extractSettleAnswer(messages);
+}
+function parseInnerDialogSession(sessionPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_parse",
+        message: "parsing inner dialog session",
+        meta: { sessionPath },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(sessionPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let parsedRaw;
+    try {
+        parsedRaw = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const legacyRecord = parsedRaw && typeof parsedRaw === "object"
+        ? parsedRaw
+        : null;
+    const messages = legacyRecord?.version === 1 && Array.isArray(legacyRecord.messages)
+        ? legacyRecord.messages
+        : (() => {
+            const envelope = (0, session_events_1.parseSessionEnvelope)(parsedRaw, {
+                recordedAt: new Date().toISOString(),
+            });
+            if (!envelope)
+                return null;
+            return (0, session_events_1.projectProviderMessages)(envelope);
+        })();
+    if (!messages)
+        return [];
+    const normalizedMessages = messages;
+    const turns = [];
+    // Walk messages, pairing user → (tool calls) → assistant sequences
+    let i = 0;
+    while (i < normalizedMessages.length) {
+        const msg = normalizedMessages[i];
+        if (msg.role === "system") {
+            i++;
+            continue;
+        }
+        if (msg.role !== "user") {
+            i++;
+            continue;
+        }
+        const userText = contentToText(msg.content);
+        const classification = classifyTurn(userText);
+        // Collect all messages until the next user message (or end)
+        const turnMessages = [];
+        let j = i + 1;
+        while (j < normalizedMessages.length && normalizedMessages[j].role !== "user") {
+            turnMessages.push(normalizedMessages[j]);
+            j++;
+        }
+        // Find the last assistant text response in this turn.
+        // With tool_choice="required", the response may be inside a settle tool call.
+        const response = extractThoughtResponseFromMessages(turnMessages);
+        const tools = extractToolNames(turnMessages);
+        turns.push({
+            type: classification.type,
+            prompt: userText.trim(),
+            response,
+            tools,
+            ...(classification.taskId ? { taskId: classification.taskId } : {}),
+        });
+        i = j;
+    }
+    return turns;
+}
+function formatThoughtTurns(turns, lastN) {
+    if (turns.length === 0)
+        return "no inner dialog activity";
+    const selected = lastN > 0 ? turns.slice(-lastN) : turns;
+    /* v8 ignore next -- unreachable: turns.length > 0 checked above, slice always returns ≥1 @preserve */
+    if (selected.length === 0)
+        return "no inner dialog activity";
+    const lines = [];
+    for (const turn of selected) {
+        const typeLabel = turn.type === "task" && turn.taskId
+            ? `task: ${turn.taskId}`
+            : turn.type;
+        lines.push(`--- ${typeLabel} ---`);
+        if (turn.tools.length > 0) {
+            lines.push(`tools: ${turn.tools.join(", ")}`);
+        }
+        if (turn.response) {
+            lines.push(turn.response);
+        }
+        else {
+            lines.push("(no response)");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function getInnerDialogSessionPath(agentRoot) {
+    return path.join(agentRoot, "state", "sessions", "self", "inner", "dialog.json");
+}
+function getInnerDialogRuntimeStatePath(sessionPath) {
+    return path.join(path.dirname(sessionPath), "runtime.json");
+}
+function readInnerDialogRuntimeState(runtimePath) {
+    try {
+        const raw = fs.readFileSync(runtimePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.status !== "running" && parsed.status !== "idle")
+            return null;
+        return {
+            status: parsed.status,
+            reason: parsed.reason === "boot" || parsed.reason === "heartbeat" || parsed.reason === "instinct"
+                ? parsed.reason
+                : undefined,
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : undefined,
+            lastCompletedAt: typeof parsed.lastCompletedAt === "string" ? parsed.lastCompletedAt : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDialogRuntimeStatePath(sessionPath)) {
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
+}
+function readInnerDialogRawData(sessionPath, pendingDir) {
+    const runtimePath = getInnerDialogRuntimeStatePath(sessionPath);
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    return { pendingMessages, turns, runtimeState };
+}
+/**
+ * Watch a session file and emit new turns as they appear.
+ * Returns a cleanup function that stops the watcher.
+ */
+function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
+    let displayedCount = parseInnerDialogSession(sessionPath).length;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_follow_start",
+        message: "started following inner dialog session",
+        meta: { sessionPath, initialTurns: displayedCount },
+    });
+    fs.watchFile(sessionPath, { interval: pollIntervalMs }, () => {
+        const turns = parseInnerDialogSession(sessionPath);
+        if (turns.length > displayedCount) {
+            const newTurns = turns.slice(displayedCount);
+            onNewTurns(formatThoughtTurns(newTurns, 0));
+            displayedCount = turns.length;
+        }
+    });
+    return () => {
+        fs.unwatchFile(sessionPath);
+        // Must be named `_end` (not `_stop`) to satisfy the nerves audit's
+        // start/end pairing rule — see src/nerves/coverage/audit-rules.ts which
+        // pairs `<prefix>_start` with `<prefix>_end` or `<prefix>_error`.
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.thoughts_follow_end",
+            message: "stopped following inner dialog session",
+            meta: { sessionPath, totalTurns: displayedCount },
+        });
+    };
+}