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

package/dist/heart/structured-output.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVisibleTextFromAssistantToolCalls = extractVisibleTextFromAssistantToolCalls;
+exports.normalizeStructuredOutputs = normalizeStructuredOutputs;
+exports.extractStructuredOutputsFromText = extractStructuredOutputsFromText;
+exports.extractStructuredOutputsFromEvents = extractStructuredOutputsFromEvents;
+const runtime_1 = require("../nerves/runtime");
+const ORDERED_LIST_LINE_RE = /^\s*(\d+)[.)]\s+(.+?)\s*$/;
+const MAX_ITEMS_PER_OUTPUT = 25;
+const MAX_ITEM_TEXT_CHARS = 500;
+const MAX_HEADING_CHARS = 160;
+function clip(value, maxChars) {
+    const trimmed = value.trim();
+    return trimmed.length <= maxChars ? trimmed : `${trimmed.slice(0, maxChars - 1)}…`;
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (!part || typeof part !== "object")
+            return "";
+        const text = part.text;
+        return typeof text === "string" ? text : "";
+    })
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+function parseToolArguments(raw) {
+    if (typeof raw !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractVisibleTextFromAssistantToolCalls(toolCalls) {
+    if (!Array.isArray(toolCalls))
+        return "";
+    const parts = [];
+    for (const toolCall of toolCalls) {
+        const name = toolCall.function?.name;
+        const args = parseToolArguments(toolCall.function?.arguments);
+        if (!args)
+            continue;
+        if (name === "settle" && typeof args.answer === "string") {
+            parts.push(args.answer);
+        }
+        else if (name === "speak" && typeof args.message === "string") {
+            parts.push(args.message);
+        }
+        else if (name === "surface" && typeof args.content === "string") {
+            parts.push(args.content);
+        }
+    }
+    return parts.filter((text) => text.trim().length > 0).join("\n");
+}
+function normalizeStructuredOutputItem(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (typeof record.label !== "string" || typeof record.text !== "string")
+        return null;
+    const label = record.label.trim();
+    const text = record.text.trim();
+    if (!label || !text)
+        return null;
+    return { label, text: clip(text, MAX_ITEM_TEXT_CHARS) };
+}
+function normalizeStructuredOutputs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (!item || typeof item !== "object")
+            return null;
+        const record = item;
+        if (record.schemaVersion !== 1
+            || record.kind !== "ordered_list"
+            || typeof record.id !== "string"
+            || typeof record.sourceEventId !== "string"
+            || typeof record.recordedAt !== "string") {
+            return null;
+        }
+        const items = Array.isArray(record.items)
+            ? record.items.map(normalizeStructuredOutputItem).filter((child) => child !== null)
+            : [];
+        if (items.length < 2)
+            return null;
+        return {
+            schemaVersion: 1,
+            id: record.id,
+            kind: "ordered_list",
+            sourceEventId: record.sourceEventId,
+            recordedAt: record.recordedAt,
+            ...(typeof record.heading === "string" && record.heading.trim()
+                ? { heading: clip(record.heading, MAX_HEADING_CHARS) }
+                : {}),
+            items: items.slice(0, MAX_ITEMS_PER_OUTPUT),
+        };
+    })
+        .filter((item) => item !== null);
+}
+function extractStructuredOutputsFromText(text, options) {
+    const outputs = [];
+    const lines = text.split(/\r?\n/);
+    let currentItems = [];
+    let currentHeading;
+    let lastNonListLine;
+    let lastNumber = 0;
+    const finishCurrent = () => {
+        if (currentItems.length >= 2) {
+            outputs.push({
+                schemaVersion: 1,
+                id: `structured-${options.eventId}-${outputs.length + 1}`,
+                kind: "ordered_list",
+                sourceEventId: options.eventId,
+                recordedAt: options.recordedAt,
+                ...(currentHeading ? { heading: currentHeading } : {}),
+                items: currentItems.slice(0, MAX_ITEMS_PER_OUTPUT),
+            });
+        }
+        currentItems = [];
+        currentHeading = undefined;
+        lastNumber = 0;
+    };
+    for (const line of lines) {
+        const match = line.match(ORDERED_LIST_LINE_RE);
+        if (!match) {
+            if (currentItems.length > 0 && line.trim().length > 0) {
+                finishCurrent();
+            }
+            if (line.trim().length > 0) {
+                lastNonListLine = clip(line, MAX_HEADING_CHARS);
+            }
+            continue;
+        }
+        const label = match[1];
+        const number = Number(label);
+        const body = clip(match[2], MAX_ITEM_TEXT_CHARS);
+        if (currentItems.length === 0) {
+            if (number !== 1) {
+                lastNonListLine = clip(line, MAX_HEADING_CHARS);
+                continue;
+            }
+            currentHeading = lastNonListLine;
+        }
+        else if (number !== lastNumber + 1) {
+            finishCurrent();
+            if (number !== 1) {
+                lastNonListLine = clip(line, MAX_HEADING_CHARS);
+                continue;
+            }
+            currentHeading = lastNonListLine;
+        }
+        currentItems.push({ label, text: body });
+        lastNumber = number;
+    }
+    finishCurrent();
+    if (outputs.length > 0 && options.emitTelemetry !== false) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.structured_output_extracted",
+            message: "structured assistant output extracted",
+            meta: {
+                sourceEventId: options.eventId,
+                outputCount: outputs.length,
+                itemCount: outputs.reduce((sum, output) => sum + output.items.length, 0),
+            },
+        });
+    }
+    return outputs;
+}
+function extractStructuredOutputsFromEvents(events, options = {}) {
+    return events.flatMap((event) => {
+        if (event.role !== "assistant")
+            return [];
+        const text = [contentToText(event.content), extractVisibleTextFromAssistantToolCalls(event.toolCalls)]
+            .filter((part) => part.trim().length > 0)
+            .join("\n");
+        if (!text.trim())
+            return [];
+        return extractStructuredOutputsFromText(text, {
+            eventId: event.id,
+            recordedAt: event.time?.recordedAt ?? new Date(0).toISOString(),
+            emitTelemetry: options.emitTelemetry,
+        });
+    });
+}

package/dist/heart/sync-classification.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Sync failure taxonomy classifier — Layer 2 of the harness-hardening sequence.
+ *
+ * Pure pattern-matcher over (error, context) that turns common git failure
+ * shapes into the locked taxonomy variants. Used by `runBootSyncProbe` (the
+ * `ouro up` pre-flight pull orchestrator) and by `postTurnPush`'s legacy
+ * push-rejected/conflict path so both producers share one vocabulary.
+ *
+ * Pattern priority — most actionable / specific wins:
+ *   1. Abort signal (timeout-soft / timeout-hard) — caller explicitly aborted.
+ *   2. not-found-404 — 404 / "Repository not found": remote endpoint gone.
+ *   3. auth-failed — 401 / 403 / "Authentication failed".
+ *   4. network-down — ENOTFOUND / ECONNREFUSED / "Could not resolve host".
+ *   5. dirty-working-tree — "would be overwritten" / "stash them".
+ *   6. merge-conflict — CONFLICT marker in stderr (also collects file list).
+ *   7. non-fast-forward — "non-fast-forward" / "fetch first".
+ *   8. unknown — fallthrough.
+ *
+ * The classifier never throws and never writes to disk. It calls
+ * `git status --porcelain=v1` only when it has already classified the error
+ * as a merge conflict, to enumerate unmerged paths for the consumer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySyncFailure = classifySyncFailure;
+const child_process_1 = require("child_process");
+/**
+ * Enumerate unmerged paths via `git status --porcelain=v1`. Pulled out as a
+ * pure helper so the classifier can be tested without a live git repo (the
+ * caller mocks `child_process.execFileSync`).
+ *
+ * Mirrors `sync.ts:collectRebaseConflictFiles` — kept as a separate copy here
+ * so this module has zero internal dep on `sync.ts`. The caller of
+ * `classifySyncFailure` doesn't see the duplication; the runtime cost is one
+ * git invocation per merge-conflict classification, same as before.
+ */
+function collectConflictFiles(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 -- defensive: git status failure inside a git repo would require a corrupt repo @preserve */
+        return [];
+    }
+}
+function isAbortError(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const candidate = error;
+    if (candidate.name === "AbortError")
+        return true;
+    if (candidate.code === "ABORT_ERR")
+        return true;
+    return false;
+}
+function readMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (error === null || error === undefined)
+        return String(error);
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        /* v8 ignore next -- defensive: JSON.stringify only fails on circular/BigInt; real-world git errors don't trigger it @preserve */
+        return String(error);
+    }
+}
+function readErrorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" ? code : undefined;
+}
+/**
+ * Classify a sync failure into one of the locked taxonomy variants.
+ *
+ * Pure: never throws, never writes. Calls `git status` only when the error
+ * was already classified as a merge conflict, to enumerate unmerged files.
+ */
+function classifySyncFailure(error, context) {
+    const message = readMessage(error);
+    const errorCode = readErrorCode(error);
+    // 1. Abort signal — highest priority. Caller's signal trumps content match.
+    if (isAbortError(error)) {
+        const reason = context.abortReason ?? "hard";
+        return {
+            classification: reason === "soft" ? "timeout-soft" : "timeout-hard",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // Lowercased copy for case-insensitive substring matching.
+    const lower = message.toLowerCase();
+    // 2. Not-found-404 — most actionable diagnosis when both 404 and other
+    // signals are present. "404" and "Repository not found" are the canonical
+    // shapes.
+    if (lower.includes("404") || lower.includes("repository not found")) {
+        return {
+            classification: "not-found-404",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 3. Auth failed — 401 / 403 / "Authentication failed" / "Permission denied".
+    if (lower.includes("401")
+        || lower.includes("403")
+        || lower.includes("authentication failed")
+        || lower.includes("permission denied")) {
+        return {
+            classification: "auth-failed",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 4. Network down — DNS / connection errors.
+    if (errorCode === "ENOTFOUND"
+        || errorCode === "ECONNREFUSED"
+        || lower.includes("enotfound")
+        || lower.includes("econnrefused")
+        || lower.includes("could not resolve host")
+        || lower.includes("connection refused")) {
+        return {
+            classification: "network-down",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 5. Dirty working tree — pull / merge would clobber uncommitted changes.
+    if (lower.includes("would be overwritten")
+        || lower.includes("commit your changes or stash them")) {
+        return {
+            classification: "dirty-working-tree",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 6. Merge conflict — CONFLICT marker in stderr. Collect unmerged files.
+    if (lower.includes("conflict")) {
+        return {
+            classification: "merge-conflict",
+            error: message,
+            conflictFiles: collectConflictFiles(context.agentRoot),
+        };
+    }
+    // 7. Non-fast-forward — push rejected because remote moved.
+    if (lower.includes("non-fast-forward")
+        || lower.includes("fetch first")
+        || lower.includes("rejected")) {
+        return {
+            classification: "non-fast-forward",
+            error: message,
+            conflictFiles: [],
+        };
+    }
+    // 8. Fallthrough.
+    return {
+        classification: "unknown",
+        error: message,
+        conflictFiles: [],
+    };
+}

package/dist/heart/sync-health.js

@@ -0,0 +1,152 @@
+"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.parseBundleSyncFailure = parseBundleSyncFailure;
+exports.parseBundleSyncSkippedFiles = parseBundleSyncSkippedFiles;
+exports.readBundleSyncHealth = readBundleSyncHealth;
+exports.summarizeSyncError = summarizeSyncError;
+exports.formatMegabytes = formatMegabytes;
+exports.describeSyncFailure = describeSyncFailure;
+exports.describeSkippedFiles = describeSkippedFiles;
+exports.checkBundleSyncHealth = checkBundleSyncHealth;
+/**
+ * Reads the two bundle sync records that post-turn sync leaves on disk and
+ * turns them into one view for `ouro status` and the daemon health check:
+ *
+ *   - `state/pending-sync.json`: the last sync failed and nothing has
+ *     succeeded since (written and cleared by `postTurnPush`).
+ *   - `state/sync-skipped-files.json`: files sync left uncommitted because
+ *     they are over `SYNC_FILE_SIZE_LIMIT_BYTES`.
+ *
+ * Reading never throws: an unreadable or malformed record reads as absent.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function readJson(filePath, readFile) {
+    try {
+        return JSON.parse(readFile(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+/**
+ * Accepts both the on-disk `pending-sync.json` shape (`failedAt`) and the
+ * `BundleSyncFailure` shape the daemon sends in status (`lastFailedAt`).
+ */
+function parseBundleSyncFailure(value) {
+    const record = asRecord(value);
+    if (!record || typeof record.error !== "string")
+        return null;
+    const lastFailedAt = typeof record.failedAt === "string"
+        ? record.failedAt
+        : typeof record.lastFailedAt === "string" ? record.lastFailedAt : "unknown";
+    return {
+        error: record.error,
+        classification: typeof record.classification === "string" ? record.classification : "unknown",
+        firstFailedAt: typeof record.firstFailedAt === "string" ? record.firstFailedAt : lastFailedAt,
+        lastFailedAt,
+        consecutiveFailures: typeof record.consecutiveFailures === "number" && record.consecutiveFailures > 0
+            ? record.consecutiveFailures
+            : 1,
+    };
+}
+/** Accepts the `sync-skipped-files.json` record or a bare array of files. */
+function parseBundleSyncSkippedFiles(value) {
+    const files = Array.isArray(value) ? value : asRecord(value)?.files;
+    if (!Array.isArray(files))
+        return [];
+    return files.flatMap((entry) => {
+        const file = asRecord(entry);
+        if (!file || typeof file.path !== "string" || typeof file.bytes !== "number")
+            return [];
+        return [{ path: file.path, bytes: file.bytes }];
+    });
+}
+function readBundleSyncHealth(agentRoot, deps = {}) {
+    const readFile = deps.readFileSync ?? ((p, encoding) => fs.readFileSync(p, encoding));
+    return {
+        failure: parseBundleSyncFailure(readJson(path.join(agentRoot, "state", "pending-sync.json"), readFile)),
+        skippedFiles: parseBundleSyncSkippedFiles(readJson(path.join(agentRoot, "state", "sync-skipped-files.json"), readFile)),
+    };
+}
+/** First line of a git error, capped so one status line stays readable. */
+function summarizeSyncError(error) {
+    const firstLine = error.split("\n").map((line) => line.trim()).find((line) => line.length > 0) ?? "unknown";
+    return firstLine.length > 160 ? `${firstLine.slice(0, 157)}...` : firstLine;
+}
+function formatMegabytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
+function describeSyncFailure(failure) {
+    return `sync failing since ${failure.firstFailedAt} (${failure.consecutiveFailures} attempt(s)): ${summarizeSyncError(failure.error)}`;
+}
+function describeSkippedFiles(files) {
+    const listed = files.slice(0, 3).map((file) => `${file.path} (${formatMegabytes(file.bytes)})`).join(", ");
+    const more = files.length > 3 ? `, and ${files.length - 3} more` : "";
+    return `${files.length} file(s) too large to sync left uncommitted: ${listed}${more}`;
+}
+/**
+ * Daemon health check over the managed agents' bundle sync rows. Bundles with
+ * sync disabled are ignored. Sync trouble is a warning, never critical: the
+ * agent still runs, but its bundle is not being backed up, which must stay
+ * visible until someone fixes it.
+ */
+function checkBundleSyncHealth(rows) {
+    const problems = [];
+    for (const row of rows) {
+        if (!row.enabled)
+            continue;
+        if (row.failure)
+            problems.push(`${row.agent}: ${describeSyncFailure(row.failure)}`);
+        if (row.skippedFiles && row.skippedFiles.length > 0)
+            problems.push(`${row.agent}: ${describeSkippedFiles(row.skippedFiles)}`);
+    }
+    if (problems.length === 0) {
+        return { name: "bundle-sync", status: "ok", message: "bundle sync healthy" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "heart",
+        event: "heart.bundle_sync_unhealthy",
+        message: "bundle sync health check found problems",
+        meta: { problems },
+    });
+    return { name: "bundle-sync", status: "warn", message: problems.join("; ") };
+}