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

package/dist/heart/background-operations.js

@@ -0,0 +1,281 @@
+"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.readBackgroundOperation = readBackgroundOperation;
+exports.listBackgroundOperations = listBackgroundOperations;
+exports.startBackgroundOperation = startBackgroundOperation;
+exports.markBackgroundOperationRunning = markBackgroundOperationRunning;
+exports.updateBackgroundOperation = updateBackgroundOperation;
+exports.completeBackgroundOperation = completeBackgroundOperation;
+exports.failBackgroundOperation = failBackgroundOperation;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+function operationsDir(agentName, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    return path.join(agentRoot, "state", "background-operations");
+}
+function operationPath(locator) {
+    return path.join(operationsDir(locator.agentName, locator.agentRoot), `${locator.id}.json`);
+}
+function normalizeProgress(progress) {
+    if (!progress)
+        return undefined;
+    const normalized = {};
+    if (typeof progress.current === "number" && Number.isFinite(progress.current))
+        normalized.current = progress.current;
+    if (typeof progress.total === "number" && Number.isFinite(progress.total))
+        normalized.total = progress.total;
+    if (typeof progress.unit === "string" && progress.unit.trim().length > 0)
+        normalized.unit = progress.unit.trim();
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function normalizeRecord(record) {
+    if (record.schemaVersion !== 1)
+        return null;
+    if (typeof record.id !== "string" || record.id.trim().length === 0)
+        return null;
+    if (typeof record.agentName !== "string" || record.agentName.trim().length === 0)
+        return null;
+    if (typeof record.kind !== "string" || record.kind.trim().length === 0)
+        return null;
+    if (typeof record.title !== "string" || record.title.trim().length === 0)
+        return null;
+    if (typeof record.summary !== "string" || record.summary.trim().length === 0)
+        return null;
+    if (typeof record.createdAt !== "string" || record.createdAt.trim().length === 0)
+        return null;
+    if (typeof record.updatedAt !== "string" || record.updatedAt.trim().length === 0)
+        return null;
+    if (record.status !== "queued"
+        && record.status !== "running"
+        && record.status !== "succeeded"
+        && record.status !== "failed") {
+        return null;
+    }
+    const normalized = {
+        schemaVersion: 1,
+        id: record.id,
+        agentName: record.agentName,
+        kind: record.kind,
+        title: record.title,
+        status: record.status,
+        summary: record.summary,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+    };
+    if (typeof record.detail === "string" && record.detail.trim().length > 0)
+        normalized.detail = record.detail.trim();
+    if (typeof record.startedAt === "string" && record.startedAt.trim().length > 0)
+        normalized.startedAt = record.startedAt;
+    if (typeof record.finishedAt === "string" && record.finishedAt.trim().length > 0)
+        normalized.finishedAt = record.finishedAt;
+    const progress = normalizeProgress(record.progress);
+    if (progress)
+        normalized.progress = progress;
+    if (record.spec && typeof record.spec === "object" && !Array.isArray(record.spec))
+        normalized.spec = { ...record.spec };
+    if (record.result && typeof record.result === "object" && !Array.isArray(record.result))
+        normalized.result = { ...record.result };
+    if (record.error && typeof record.error.message === "string" && record.error.message.trim().length > 0) {
+        normalized.error = { message: record.error.message.trim() };
+    }
+    if (record.failure && typeof record.failure === "object" && !Array.isArray(record.failure)) {
+        const failureClass = typeof record.failure.class === "string" ? record.failure.class.trim() : "";
+        const retryDisposition = record.failure.retryDisposition;
+        const hint = typeof record.failure.hint === "string" ? record.failure.hint.trim() : "";
+        if (failureClass) {
+            normalized.failure = {
+                class: failureClass,
+                ...(retryDisposition === "retry-safe" || retryDisposition === "fix-before-retry" || retryDisposition === "investigate-first"
+                    ? { retryDisposition }
+                    : {}),
+                ...(hint ? { hint } : {}),
+            };
+        }
+    }
+    if (Array.isArray(record.remediation)) {
+        const remediation = record.remediation.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+        if (remediation.length > 0)
+            normalized.remediation = remediation;
+    }
+    return normalized;
+}
+function readRecord(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return normalizeRecord(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function specText(spec, key) {
+    const value = spec?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function visibleOperationKey(record) {
+    if (record.kind !== "mail.import-mbox")
+        return null;
+    const filePath = specText(record.spec, "filePath");
+    if (!filePath)
+        return null;
+    const ownerEmail = specText(record.spec, "ownerEmail").toLowerCase();
+    const source = specText(record.spec, "source").toLowerCase();
+    return `${record.agentName.toLowerCase()}|${record.kind}|${filePath}|${ownerEmail}|${source}`;
+}
+function writeRecord(locator, record) {
+    const normalized = normalizeRecord(record);
+    if (!normalized) {
+        throw new Error(`invalid background operation record: ${locator.id}`);
+    }
+    fs.mkdirSync(operationsDir(locator.agentName, locator.agentRoot), { recursive: true });
+    fs.writeFileSync(operationPath(locator), `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.background_operation_written",
+        message: "background operation state written",
+        meta: { agentName: locator.agentName, id: locator.id, kind: normalized.kind, status: normalized.status },
+    });
+    return normalized;
+}
+function requireRecord(locator) {
+    const record = readBackgroundOperation(locator);
+    if (!record) {
+        throw new Error(`background operation not found: ${locator.id}`);
+    }
+    return record;
+}
+function readBackgroundOperation(locator) {
+    return readRecord(operationPath(locator));
+}
+function listBackgroundOperations(input) {
+    const dir = operationsDir(input.agentName, input.agentRoot);
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const records = entries
+        .filter((entry) => entry.endsWith(".json"))
+        .map((entry) => readRecord(path.join(dir, entry)))
+        .filter((entry) => entry !== null)
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+    const visibleKeys = new Set();
+    const visible = records.filter((record) => {
+        const key = visibleOperationKey(record);
+        if (!key)
+            return true;
+        if (visibleKeys.has(key))
+            return false;
+        visibleKeys.add(key);
+        return true;
+    });
+    return visible.slice(0, input.limit ?? 10);
+}
+function startBackgroundOperation(input) {
+    return writeRecord(input, {
+        schemaVersion: 1,
+        id: input.id,
+        agentName: input.agentName,
+        kind: input.kind,
+        title: input.title,
+        status: "queued",
+        summary: input.summary,
+        createdAt: input.createdAt,
+        updatedAt: input.createdAt,
+        ...(input.spec ? { spec: input.spec } : {}),
+    });
+}
+function markBackgroundOperationRunning(input) {
+    const current = requireRecord(input);
+    const updatedAt = input.updatedAt ?? input.startedAt;
+    return writeRecord(input, {
+        ...current,
+        status: "running",
+        summary: input.summary ?? current.summary,
+        ...(input.detail ? { detail: input.detail } : {}),
+        ...(normalizeProgress(input.progress) ? { progress: normalizeProgress(input.progress) } : {}),
+        startedAt: input.startedAt,
+        updatedAt,
+        ...(current.finishedAt ? { finishedAt: current.finishedAt } : {}),
+    });
+}
+function updateBackgroundOperation(input) {
+    const current = requireRecord(input);
+    return writeRecord(input, {
+        ...current,
+        summary: input.summary ?? current.summary,
+        ...(input.detail ? { detail: input.detail } : {}),
+        ...(normalizeProgress(input.progress) ? { progress: normalizeProgress(input.progress) } : {}),
+        ...(input.spec ? { spec: input.spec } : {}),
+        updatedAt: input.updatedAt ?? current.updatedAt,
+    });
+}
+function completeBackgroundOperation(input) {
+    const current = requireRecord(input);
+    return writeRecord(input, {
+        ...current,
+        status: "succeeded",
+        summary: input.summary ?? current.summary,
+        ...(input.detail ? { detail: input.detail } : {}),
+        ...(normalizeProgress(input.progress) ? { progress: normalizeProgress(input.progress) } : {}),
+        ...(input.result ? { result: input.result } : {}),
+        error: undefined,
+        remediation: undefined,
+        failure: undefined,
+        finishedAt: input.finishedAt,
+        updatedAt: input.updatedAt ?? input.finishedAt,
+    });
+}
+function failBackgroundOperation(input) {
+    const current = requireRecord(input);
+    return writeRecord(input, {
+        ...current,
+        status: "failed",
+        summary: input.summary ?? current.summary,
+        ...(input.detail ? { detail: input.detail } : {}),
+        ...(normalizeProgress(input.progress) ? { progress: normalizeProgress(input.progress) } : {}),
+        error: { message: input.error },
+        ...(input.failure ? { failure: input.failure } : {}),
+        ...(input.remediation && input.remediation.length > 0 ? { remediation: input.remediation } : {}),
+        finishedAt: input.finishedAt,
+        updatedAt: input.updatedAt ?? input.finishedAt,
+    });
+}

package/dist/heart/bridges/manager.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBridgeStatus = formatBridgeStatus;
+exports.formatBridgeContext = formatBridgeContext;
+exports.createBridgeManager = createBridgeManager;
+const runtime_1 = require("../../nerves/runtime");
+const state_machine_1 = require("./state-machine");
+const store_1 = require("./store");
+const turn_coordinator_1 = require("../turn-coordinator");
+const tasks_1 = require("../../repertoire/tasks");
+function defaultIdFactory() {
+    return `bridge-${Date.now().toString(36)}`;
+}
+function sessionIdentityKey(session) {
+    return `${session.friendId}/${session.channel}/${session.key}`;
+}
+function assertBridgeMutable(bridge, action) {
+    if (bridge.lifecycle === "completed" || bridge.lifecycle === "cancelled") {
+        throw new Error(`cannot ${action} a terminal bridge`);
+    }
+}
+function defaultTaskBody(bridge) {
+    const lines = [
+        "## scope",
+        bridge.objective,
+        "",
+        "## bridge",
+        `id: ${bridge.id}`,
+    ];
+    if (bridge.attachedSessions.length > 0) {
+        lines.push("sessions:");
+        for (const session of bridge.attachedSessions) {
+            lines.push(`- ${sessionIdentityKey(session)}`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatBridgeStatus(bridge) {
+    const summary = typeof bridge.summary === "string" ? bridge.summary.trim() : "";
+    const lines = [
+        `bridge: ${bridge.id}`,
+        `objective: ${bridge.objective}`,
+        `state: ${(0, state_machine_1.bridgeStateLabel)(bridge)}`,
+        `sessions: ${bridge.attachedSessions.length}`,
+        `task: ${bridge.task?.taskName ?? "none"}`,
+    ];
+    if (summary) {
+        lines.push(`summary: ${summary}`);
+    }
+    return lines.join("\n");
+}
+function formatBridgeContext(bridges) {
+    if (bridges.length === 0)
+        return "";
+    const lines = ["## active bridge work"];
+    for (const bridge of bridges) {
+        const task = bridge.task?.taskName ? ` (task: ${bridge.task.taskName})` : "";
+        const label = typeof bridge.summary === "string" && bridge.summary.trim().length > 0 ? bridge.summary.trim() : bridge.objective;
+        lines.push(`- ${bridge.id}: ${label} [${(0, state_machine_1.bridgeStateLabel)(bridge)}]${task}`);
+    }
+    return lines.join("\n");
+}
+function ensureRunnable(bridge, now, store) {
+    if (bridge.lifecycle === "forming" || bridge.lifecycle === "suspended") {
+        const activated = {
+            ...bridge,
+            ...(0, state_machine_1.activateBridge)(bridge),
+            updatedAt: now(),
+        };
+        return store.save(activated);
+    }
+    if (bridge.lifecycle === "completed" || bridge.lifecycle === "cancelled") {
+        throw new Error(`bridge is terminal: ${bridge.id}`);
+    }
+    return bridge;
+}
+function sessionMatches(left, right) {
+    return left.friendId === right.friendId && left.channel === right.channel && left.key === right.key;
+}
+function hasAttachedSessionActivity(bridge, sessionActivity) {
+    return sessionActivity.some((activity) => activity.channel !== "inner"
+        && bridge.attachedSessions.some((session) => sessionMatches(activity, session)));
+}
+function hasLiveTaskStatus(bridge, taskBoard) {
+    const taskName = bridge.task?.taskName;
+    if (!taskName)
+        return false;
+    return (taskBoard.byStatus.processing.includes(taskName)
+        || taskBoard.byStatus.collaborating.includes(taskName)
+        || taskBoard.byStatus.validating.includes(taskName));
+}
+function isCurrentSessionAttached(bridge, currentSession) {
+    if (!currentSession)
+        return false;
+    return bridge.attachedSessions.some((session) => sessionMatches(session, currentSession));
+}
+function createBridgeManager(options = {}) {
+    const store = options.store ?? (0, store_1.createBridgeStore)();
+    const now = options.now ?? (() => new Date().toISOString());
+    const idFactory = options.idFactory ?? defaultIdFactory;
+    function requireBridge(bridgeId) {
+        const bridge = store.get(bridgeId);
+        if (!bridge) {
+            throw new Error(`bridge not found: ${bridgeId}`);
+        }
+        return bridge;
+    }
+    function save(bridge) {
+        return store.save(bridge);
+    }
+    return {
+        beginBridge(input) {
+            const timestamp = now();
+            const state = (0, state_machine_1.activateBridge)((0, state_machine_1.createBridgeState)());
+            const bridge = {
+                id: idFactory(),
+                objective: input.objective,
+                summary: input.summary,
+                lifecycle: state.lifecycle,
+                runtime: state.runtime,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                attachedSessions: [input.session],
+                task: null,
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_begin",
+                message: "created bridge",
+                meta: {
+                    bridgeId: bridge.id,
+                    session: sessionIdentityKey(input.session),
+                },
+            });
+            return save(bridge);
+        },
+        attachSession(bridgeId, session) {
+            const bridge = requireBridge(bridgeId);
+            assertBridgeMutable(bridge, "attach session to");
+            const existing = bridge.attachedSessions.some((candidate) => sessionIdentityKey(candidate) === sessionIdentityKey(session));
+            if (existing)
+                return bridge;
+            const updated = {
+                ...bridge,
+                attachedSessions: [...bridge.attachedSessions, session],
+                updatedAt: now(),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_attach_session",
+                message: "attached canonical session to bridge",
+                meta: {
+                    bridgeId,
+                    session: sessionIdentityKey(session),
+                },
+            });
+            return save(updated);
+        },
+        detachSession(bridgeId, session) {
+            const bridge = requireBridge(bridgeId);
+            assertBridgeMutable(bridge, "detach session from");
+            const updated = {
+                ...bridge,
+                attachedSessions: bridge.attachedSessions.filter((candidate) => sessionIdentityKey(candidate) !== sessionIdentityKey(session)),
+                updatedAt: now(),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_detach_session",
+                message: "detached canonical session from bridge",
+                meta: {
+                    bridgeId,
+                    session: sessionIdentityKey(session),
+                },
+            });
+            return save(updated);
+        },
+        getBridge(bridgeId) {
+            return store.get(bridgeId);
+        },
+        listBridges() {
+            return store.list();
+        },
+        findBridgesForSession(session) {
+            return store.findBySession(session)
+                .filter((bridge) => bridge.lifecycle !== "completed" && bridge.lifecycle !== "cancelled");
+        },
+        reconcileLifecycles(input) {
+            return store.list().map((bridge) => {
+                const nextState = (0, state_machine_1.reconcileBridgeState)(bridge, {
+                    hasAttachedSessionActivity: hasAttachedSessionActivity(bridge, input.sessionActivity),
+                    hasLiveTask: hasLiveTaskStatus(bridge, input.taskBoard),
+                    currentSessionAttached: isCurrentSessionAttached(bridge, input.currentSession),
+                });
+                if (nextState.lifecycle === bridge.lifecycle && nextState.runtime === bridge.runtime) {
+                    return bridge;
+                }
+                return save({
+                    ...bridge,
+                    ...nextState,
+                    updatedAt: now(),
+                });
+            });
+        },
+        promoteBridgeToTask(bridgeId, input = {}) {
+            const bridge = requireBridge(bridgeId);
+            assertBridgeMutable(bridge, "promote");
+            if (bridge.task)
+                return bridge;
+            const taskPath = (0, tasks_1.getTaskModule)().createTask({
+                title: input.title?.trim() || bridge.objective,
+                type: "ongoing",
+                category: input.category?.trim() || "coordination",
+                status: "processing",
+                body: input.body?.trim() || defaultTaskBody(bridge),
+                activeBridge: bridge.id,
+                bridgeSessions: bridge.attachedSessions.map((session) => sessionIdentityKey(session)),
+            });
+            const taskName = taskPath.replace(/^.*\//, "").replace(/\.md$/, "");
+            const updated = save({
+                ...bridge,
+                task: {
+                    taskName,
+                    path: taskPath,
+                    mode: "promoted",
+                    boundAt: now(),
+                },
+                updatedAt: now(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_promote_task",
+                message: "promoted bridge to task-backed work",
+                meta: {
+                    bridgeId,
+                    taskName,
+                },
+            });
+            return updated;
+        },
+        completeBridge(bridgeId) {
+            const bridge = requireBridge(bridgeId);
+            const updated = save({
+                ...bridge,
+                ...(0, state_machine_1.completeBridge)(bridge),
+                updatedAt: now(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_complete",
+                message: "completed bridge",
+                meta: {
+                    bridgeId,
+                },
+            });
+            return updated;
+        },
+        cancelBridge(bridgeId) {
+            const bridge = requireBridge(bridgeId);
+            const updated = save({
+                ...bridge,
+                ...(0, state_machine_1.cancelBridge)(bridge),
+                updatedAt: now(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_cancel",
+                message: "cancelled bridge",
+                meta: {
+                    bridgeId,
+                },
+            });
+            return updated;
+        },
+        async runBridgeTurn(bridgeId, fn) {
+            if (!(0, turn_coordinator_1.tryBeginSharedTurn)("bridge", bridgeId)) {
+                const bridge = requireBridge(bridgeId);
+                const queued = bridge.runtime === "awaiting-follow-up"
+                    ? bridge
+                    : save({
+                        ...bridge,
+                        ...(0, state_machine_1.queueBridgeFollowUp)(bridge),
+                        updatedAt: now(),
+                    });
+                (0, turn_coordinator_1.enqueueSharedFollowUp)("bridge", bridgeId, {
+                    conversationId: bridgeId,
+                    text: "bridge follow-up",
+                    receivedAt: Date.now(),
+                    effect: "none",
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "engine",
+                    event: "engine.bridge_turn_queued",
+                    message: "queued follow-up bridge turn",
+                    meta: {
+                        bridgeId,
+                    },
+                });
+                return {
+                    queued: true,
+                    bridge: queued,
+                };
+            }
+            try {
+                let current = ensureRunnable(requireBridge(bridgeId), now, store);
+                current = save({
+                    ...current,
+                    ...(0, state_machine_1.beginBridgeProcessing)(current),
+                    updatedAt: now(),
+                });
+                while (true) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "engine",
+                        event: "engine.bridge_turn_start",
+                        message: "running bridge turn",
+                        meta: {
+                            bridgeId,
+                        },
+                    });
+                    await fn();
+                    let next = requireBridge(bridgeId);
+                    const bufferedFollowUps = (0, turn_coordinator_1.drainSharedFollowUps)("bridge", bridgeId);
+                    if (bufferedFollowUps.length > 0 && next.runtime !== "awaiting-follow-up") {
+                        next = save({
+                            ...next,
+                            ...(0, state_machine_1.queueBridgeFollowUp)(next),
+                            updatedAt: now(),
+                        });
+                    }
+                    const advanced = save({
+                        ...next,
+                        ...(0, state_machine_1.advanceBridgeAfterTurn)(next),
+                        updatedAt: now(),
+                    });
+                    if (advanced.runtime === "processing") {
+                        current = advanced;
+                        continue;
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "engine",
+                        event: "engine.bridge_turn_end",
+                        message: "bridge turn finished",
+                        meta: {
+                            bridgeId,
+                        },
+                    });
+                    return {
+                        queued: false,
+                        bridge: current = advanced,
+                    };
+                }
+            }
+            finally {
+                (0, turn_coordinator_1.endSharedTurn)("bridge", bridgeId);
+            }
+        },
+    };
+}