@ouro.bot/cli 0.1.0-alpha.4 → 0.1.0-alpha.400

package/dist/heart/streaming.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalAnswerParser = void 0;
+exports.SettleStreamer = exports.SettleParser = void 0;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
 exports.streamResponsesApi = streamResponsesApi;
 const runtime_1 = require("../nerves/runtime");
 // Character-level state machine that extracts the answer value from
-// `final_answer` tool call JSON arguments as they stream in.
+// `settle` tool call JSON arguments as they stream in.
 // Scans for prefix `"answer":"` or `"answer": "` in the character stream,
 // then emits text handling JSON escapes, stopping at unescaped closing `"`.
-class FinalAnswerParser {
+class SettleParser {
     // Possible prefixes to match (with and without space after colon)
     static PREFIXES = ['"answer":"', '"answer": "'];
     // Buffer of characters seen so far (pre-activation only)
@@ -29,7 +29,7 @@ class FinalAnswerParser {
             if (!this._active) {
                 this.buf += ch;
                 // Check if any prefix has been fully matched in the buffer
-                for (const prefix of FinalAnswerParser.PREFIXES) {
+                for (const prefix of SettleParser.PREFIXES) {
                     if (this.buf.endsWith(prefix)) {
                         this._active = true;
                         break;
@@ -76,7 +76,96 @@ class FinalAnswerParser {
         return out;
     }
 }
-exports.FinalAnswerParser = FinalAnswerParser;
+exports.SettleParser = SettleParser;
+// Shared helper: wraps SettleParser with onClearText + onTextChunk wiring.
+// Used by all streaming providers (Chat Completions, Responses API, Anthropic)
+// so the eager-match settle streaming pattern lives in one place.
+class SettleStreamer {
+    parser = new SettleParser();
+    _detected = false;
+    callbacks;
+    enabled;
+    constructor(callbacks, enabled = true) {
+        this.callbacks = callbacks;
+        this.enabled = enabled;
+    }
+    get detected() { return this._detected; }
+    get streamed() { return this.parser.active; }
+    /** Mark settle as detected. Calls onClearText on the callbacks. */
+    activate() {
+        if (!this.enabled)
+            return;
+        if (this._detected)
+            return;
+        this._detected = true;
+        this.callbacks.onClearText?.();
+    }
+    /** Feed an argument delta through the parser. Emits text via onTextChunk. */
+    processDelta(delta) {
+        if (!this.enabled)
+            return;
+        if (!this._detected)
+            return;
+        const text = this.parser.process(delta);
+        if (text)
+            this.callbacks.onTextChunk(text);
+    }
+}
+exports.SettleStreamer = SettleStreamer;
+function toResponsesUserContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object") {
+            continue;
+        }
+        if (part.type === "text" && typeof part.text === "string") {
+            parts.push({ type: "input_text", text: part.text });
+            continue;
+        }
+        if (part.type === "image_url") {
+            const imageUrl = typeof part.image_url?.url === "string" ? part.image_url.url : "";
+            if (!imageUrl)
+                continue;
+            parts.push({
+                type: "input_image",
+                image_url: imageUrl,
+                detail: part.image_url?.detail ?? "auto",
+            });
+            continue;
+        }
+        if (part.type === "input_audio" &&
+            typeof part.input_audio?.data === "string" &&
+            (part.input_audio.format === "mp3" || part.input_audio.format === "wav")) {
+            parts.push({
+                type: "input_audio",
+                input_audio: {
+                    data: part.input_audio.data,
+                    format: part.input_audio.format,
+                },
+            });
+            continue;
+        }
+        if (part.type === "file") {
+            const fileRecord = { type: "input_file" };
+            if (typeof part.file?.file_data === "string")
+                fileRecord.file_data = part.file.file_data;
+            if (typeof part.file?.file_id === "string")
+                fileRecord.file_id = part.file.file_id;
+            if (typeof part.file?.filename === "string")
+                fileRecord.filename = part.file.filename;
+            if (typeof part.file?.file_data === "string" || typeof part.file?.file_id === "string") {
+                parts.push(fileRecord);
+            }
+        }
+    }
+    return parts.length > 0 ? parts : "";
+}
 function toResponsesInput(messages) {
     let instructions = "";
     const input = [];
@@ -90,7 +179,7 @@ function toResponsesInput(messages) {
         }
         if (msg.role === "user") {
             const u = msg;
-            input.push({ role: "user", content: typeof u.content === "string" ? u.content : "" });
+            input.push({ role: "user", content: toResponsesUserContent(u.content) });
             continue;
         }
         if (msg.role === "assistant") {
@@ -102,7 +191,10 @@ function toResponsesInput(messages) {
                 }
             }
             if (a.content) {
-                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+                const assistantItem = { role: "assistant", content: typeof a.content === "string" ? a.content : "" };
+                if (a.phase)
+                    assistantItem.phase = a.phase;
+                input.push(assistantItem);
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {
@@ -141,7 +233,7 @@ function toResponsesTools(ccTools) {
         strict: false,
     }));
 }
-async function streamChatCompletion(client, createParams, callbacks, signal) {
+async function streamChatCompletion(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -155,8 +247,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerParser = new FinalAnswerParser();
-    let finalAnswerDetected = false;
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -271,24 +362,21 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
                     toolCalls[tc.index].id = tc.id;
                 if (tc.function?.name) {
                     toolCalls[tc.index].name = tc.function.name;
-                    // Detect final_answer tool call on first name delta.
+                    // Detect settle tool call on first name delta.
                     // Only activate streaming if this is the sole tool call (index 0
                     // and no other indices seen). Mixed calls are rejected by core.ts.
-                    if (tc.function.name === "final_answer" && !finalAnswerDetected
+                    if (tc.function.name === "settle" && !answerStreamer.detected
                         && tc.index === 0 && Object.keys(toolCalls).length === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 if (tc.function?.arguments) {
                     toolCalls[tc.index].arguments += tc.function.arguments;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole tool call.
-                    if (finalAnswerDetected && toolCalls[tc.index].name === "final_answer"
+                    if (answerStreamer.detected && toolCalls[tc.index].name === "settle"
                         && Object.keys(toolCalls).length === 1) {
-                        const text = answerParser.process(tc.function.arguments);
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(tc.function.arguments);
                     }
                 }
             }
@@ -302,10 +390,10 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         toolCalls: Object.values(toolCalls),
         outputItems: [],
         usage,
-        finalAnswerStreamed: answerParser.active,
+        settleStreamed: answerStreamer.streamed,
     };
 }
-async function streamResponsesApi(client, createParams, callbacks, signal) {
+async function streamResponsesApi(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -320,9 +408,8 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerParser = new FinalAnswerParser();
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     let functionCallCount = 0;
-    let finalAnswerDetected = false;
     for await (const event of response) {
         if (signal?.aborted)
             break;
@@ -351,12 +438,11 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                         name: String(event.item.name),
                         arguments: "",
                     };
-                    // Detect final_answer function call -- clear any streamed noise.
+                    // Detect settle function call -- clear any streamed noise.
                     // Only activate when this is the first (and so far only) function call.
                     // Mixed calls are rejected by core.ts; no need to stream their args.
-                    if (String(event.item.name) === "final_answer" && functionCallCount === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                    if (String(event.item.name) === "settle" && functionCallCount === 1) {
+                        answerStreamer.activate();
                     }
                 }
                 break;
@@ -364,13 +450,11 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
             case "response.function_call_arguments.delta": {
                 if (currentToolCall) {
                     currentToolCall.arguments += event.delta;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole function call.
-                    if (finalAnswerDetected && currentToolCall.name === "final_answer"
+                    if (answerStreamer.detected && currentToolCall.name === "settle"
                         && functionCallCount === 1) {
-                        const text = answerParser.process(String(event.delta));
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(String(event.delta));
                     }
                 }
                 break;
@@ -410,6 +494,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
         toolCalls,
         outputItems,
         usage,
-        finalAnswerStreamed: answerParser.active,
+        settleStreamed: answerStreamer.streamed,
     };
 }

package/dist/heart/sync.js

@@ -0,0 +1,332 @@
+"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.preTurnPull = preTurnPull;
+exports.postTurnPush = postTurnPush;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function writePendingSync(agentRoot, error, classification, conflictFiles) {
+    const pendingSyncPath = path.join(agentRoot, "state", "pending-sync.json");
+    fs.mkdirSync(path.join(agentRoot, "state"), { recursive: true });
+    const record = {
+        error,
+        failedAt: new Date().toISOString(),
+        classification,
+        conflictFiles,
+    };
+    fs.writeFileSync(pendingSyncPath, JSON.stringify(record, null, 2), "utf-8");
+}
+function collectRebaseConflictFiles(agentRoot) {
+    try {
+        const output = (0, child_process_1.execFileSync)("git", ["status", "--porcelain=v1"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 5000,
+        }).toString();
+        const files = [];
+        for (const line of output.split("\n")) {
+            // Unmerged paths in porcelain v1 are prefixed with UU/AA/DD/AU/UA/DU/UD
+            if (/^(UU|AA|DD|AU|UA|DU|UD) /.test(line)) {
+                files.push(line.slice(3).trim());
+            }
+        }
+        return files;
+    }
+    catch {
+        /* v8 ignore next -- git status --porcelain failure inside a repo would require a corrupt repo @preserve */
+        return [];
+    }
+}
+/**
+ * Check whether the bundle is initialized as a git repo.
+ * Used by both pre-turn pull and post-turn push to surface a clear,
+ * actionable error when sync is enabled but the user never ran `git init`
+ * inside their bundle. This error is propagated all the way into the
+ * agent's start-of-turn packet as a Sync warning, so the agent can
+ * either ask the user or run `git init` itself.
+ */
+function ensureGitRepo(agentRoot) {
+    if (fs.existsSync(path.join(agentRoot, ".git"))) {
+        return { ok: true };
+    }
+    const error = `bundle is not a git repo; run \`git init\` inside ${agentRoot} to enable sync (or disable sync in agent.json)`;
+    return { ok: false, error };
+}
+/**
+ * Pre-turn pull: sync the agent bundle from remote before assembling the start-of-turn packet.
+ *
+ * If the bundle has no git remote configured, the pull is skipped and the function
+ * returns ok — matching the no-remote behavior of postTurnPush. This supports the
+ * "local-only sync" mode where the bundle accumulates a commit log without ever
+ * pushing or pulling from a remote.
+ */
+function preTurnPull(agentRoot, config) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.sync_pull_start",
+        message: "pre-turn pull starting",
+        meta: { agentRoot, remote: config.remote },
+    });
+    // Check that the bundle is actually a git repo before touching git at all.
+    // Surfaces a clear, actionable error via syncFailure → start-of-turn packet
+    // so the agent can propose running `git init` (or just do it).
+    const repoCheck = ensureGitRepo(agentRoot);
+    if (!repoCheck.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "heart",
+            event: "heart.sync_not_a_repo",
+            message: "pre-turn pull failed: bundle is not a git repo",
+            meta: { agentRoot },
+        });
+        return repoCheck;
+    }
+    // Check if any remote is configured. If not, skip the pull (local-only mode).
+    try {
+        const remoteOutput = (0, child_process_1.execFileSync)("git", ["remote"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 5000,
+        }).toString().trim();
+        if (remoteOutput.length === 0) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "heart",
+                event: "heart.sync_pull_end",
+                message: "pre-turn pull skipped: no remote configured",
+                meta: { agentRoot },
+            });
+            return { ok: true };
+        }
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_pull_error",
+            message: "pre-turn pull failed: git remote check failed",
+            meta: { agentRoot, error },
+        });
+        return { ok: false, error };
+    }
+    try {
+        (0, child_process_1.execFileSync)("git", ["pull", config.remote], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 30000,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_pull_end",
+            message: "pre-turn pull complete",
+            meta: { agentRoot },
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_pull_error",
+            message: "pre-turn pull failed",
+            meta: { agentRoot, error },
+        });
+        return { ok: false, error };
+    }
+}
+/**
+ * Post-turn push: discover dirty files via `git status`, commit, and push.
+ * Uses git-status-based discovery instead of explicit path tracking, ensuring
+ * all file writers are captured regardless of whether they call a tracking API.
+ */
+function postTurnPush(agentRoot, config) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.sync_push_start",
+        message: "post-turn push starting",
+        meta: { agentRoot, remote: config.remote },
+    });
+    // Same git-repo check as preTurnPull. This is the more common failure path
+    // since postTurnPush runs after every turn while preTurnPull only runs on
+    // user-initiated turns. Prior to this guard, an un-init'd bundle would fail
+    // the git-status invocation below with a generic "not a git repository"
+    // error; now we catch it explicitly with an actionable message.
+    const repoCheck = ensureGitRepo(agentRoot);
+    if (!repoCheck.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "heart",
+            event: "heart.sync_not_a_repo",
+            message: "post-turn push failed: bundle is not a git repo",
+            meta: { agentRoot },
+        });
+        return repoCheck;
+    }
+    let statusOutput;
+    try {
+        statusOutput = (0, child_process_1.execFileSync)("git", ["status", "--porcelain"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 10000,
+        }).toString().trim();
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_error",
+            message: "post-turn push: git status failed",
+            meta: { agentRoot, error },
+        });
+        return { ok: false, error };
+    }
+    if (statusOutput.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_end",
+            message: "post-turn push: no changes to sync",
+            meta: { agentRoot },
+        });
+        return { ok: true };
+    }
+    const changedCount = statusOutput.split("\n").length;
+    try {
+        (0, child_process_1.execFileSync)("git", ["add", "-A"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+        (0, child_process_1.execFileSync)("git", ["commit", "-m", "sync: post-turn update"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+        // Check if a remote exists
+        const remoteOutput = (0, child_process_1.execFileSync)("git", ["remote"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 5000,
+        }).toString().trim();
+        if (remoteOutput.length === 0) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "heart",
+                event: "heart.sync_push_end",
+                message: "post-turn push: committed locally, no remote configured",
+                meta: { agentRoot, changedCount },
+            });
+            return { ok: true };
+        }
+        try {
+            (0, child_process_1.execFileSync)("git", ["push", config.remote], {
+                cwd: agentRoot,
+                stdio: "pipe",
+                timeout: 30000,
+            });
+        }
+        catch {
+            // Push rejected -- try pull-rebase-push
+            let rebaseError = null;
+            try {
+                (0, child_process_1.execFileSync)("git", ["pull", "--rebase", config.remote], {
+                    cwd: agentRoot,
+                    stdio: "pipe",
+                    timeout: 30000,
+                });
+            }
+            catch (err) {
+                rebaseError = err instanceof Error ? err.message : String(err);
+            }
+            if (rebaseError === null) {
+                try {
+                    (0, child_process_1.execFileSync)("git", ["push", config.remote], {
+                        cwd: agentRoot,
+                        stdio: "pipe",
+                        timeout: 30000,
+                    });
+                    // rebase + retry push both succeeded — fall through to success
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "heart",
+                        event: "heart.sync_push_end",
+                        message: "post-turn push complete after rebase retry",
+                        meta: { agentRoot, changedCount },
+                    });
+                    return { ok: true };
+                }
+                catch (retryErr) {
+                    // Second push rejected — remote advanced again during rebase
+                    const retryError = retryErr instanceof Error ? retryErr.message : /* v8 ignore next -- defensive non-Error catch @preserve */ String(retryErr);
+                    writePendingSync(agentRoot, retryError, "push_rejected", []);
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "heart",
+                        event: "heart.sync_push_error",
+                        message: "post-turn push failed after retry: push_rejected",
+                        meta: { agentRoot, error: retryError, classification: "push_rejected" },
+                    });
+                    return { ok: false, error: retryError };
+                }
+            }
+            // Rebase failed — detect conflict files via git status. Preserve
+            // the original rebase error message so callers see the real cause.
+            const conflictFiles = collectRebaseConflictFiles(agentRoot);
+            const classification = conflictFiles.length > 0 ? "pull_rebase_conflict" : "unknown";
+            writePendingSync(agentRoot, rebaseError, classification, conflictFiles);
+            (0, runtime_1.emitNervesEvent)({
+                component: "heart",
+                event: "heart.sync_push_error",
+                message: `post-turn push failed: ${classification}`,
+                meta: { agentRoot, error: rebaseError, classification, conflictFiles },
+            });
+            return { ok: false, error: rebaseError };
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_end",
+            message: "post-turn push complete",
+            meta: { agentRoot, changedCount },
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_error",
+            message: "post-turn push failed",
+            meta: { agentRoot, error },
+        });
+        return { ok: false, error };
+    }
+}