@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

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: [],
+    };
+}