@ouro.bot/cli 0.1.0-alpha.21 → 0.1.0-alpha.210

package/dist/arc/obligations.js

@@ -0,0 +1,321 @@
+"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.isOpenObligationStatus = isOpenObligationStatus;
+exports.isOpenObligation = isOpenObligation;
+exports.createObligation = createObligation;
+exports.readObligations = readObligations;
+exports.readPendingObligations = readPendingObligations;
+exports.advanceObligation = advanceObligation;
+exports.fulfillObligation = fulfillObligation;
+exports.findPendingObligationForOrigin = findPendingObligationForOrigin;
+exports.enrichObligation = enrichObligation;
+exports.generateObligationId = generateObligationId;
+exports.getReturnObligationsDir = getReturnObligationsDir;
+exports.createReturnObligation = createReturnObligation;
+exports.readReturnObligation = readReturnObligation;
+exports.advanceReturnObligation = advanceReturnObligation;
+exports.listActiveReturnObligations = listActiveReturnObligations;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const sync_1 = require("../heart/sync");
+function obligationsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "obligations");
+}
+function obligationFilePath(agentRoot, id) {
+    return path.join(obligationsDir(agentRoot), `${id}.json`);
+}
+function generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    return `${timestamp}-${random}`;
+}
+function isOpenObligationStatus(status) {
+    return status !== "fulfilled";
+}
+function isOpenObligation(obligation) {
+    return isOpenObligationStatus(obligation.status);
+}
+function createObligation(agentRoot, input) {
+    const now = new Date().toISOString();
+    const id = generateId();
+    const obligation = {
+        id,
+        origin: input.origin,
+        ...(input.bridgeId ? { bridgeId: input.bridgeId } : {}),
+        content: input.content,
+        status: "pending",
+        createdAt: now,
+        updatedAt: now,
+    };
+    const dir = obligationsDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = obligationFilePath(agentRoot, id);
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf-8");
+    (0, sync_1.trackSyncWrite)(filePath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_created",
+        message: "obligation created",
+        meta: {
+            obligationId: id,
+            friendId: input.origin.friendId,
+            channel: input.origin.channel,
+            key: input.origin.key,
+        },
+    });
+    return obligation;
+}
+function readObligations(agentRoot) {
+    const dir = obligationsDir(agentRoot);
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        /* v8 ignore next -- defensive: readdirSync race after existsSync @preserve */
+        return [];
+    }
+    const jsonFiles = entries.filter((entry) => entry.endsWith(".json")).sort();
+    const obligations = [];
+    for (const file of jsonFiles) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.id === "string" && typeof parsed.content === "string") {
+                obligations.push(parsed);
+            }
+        }
+        catch {
+            // skip malformed files
+        }
+    }
+    return obligations;
+}
+function readPendingObligations(agentRoot) {
+    return readObligations(agentRoot).filter(isOpenObligation);
+}
+function advanceObligation(agentRoot, obligationId, update) {
+    const filePath = obligationFilePath(agentRoot, obligationId);
+    let obligation;
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        obligation = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    const previousStatus = obligation.status;
+    if (update.status) {
+        obligation.status = update.status;
+        if (update.status === "fulfilled") {
+            obligation.fulfilledAt = new Date().toISOString();
+        }
+    }
+    if (update.currentSurface) {
+        obligation.currentSurface = update.currentSurface;
+    }
+    if (typeof update.currentArtifact === "string") {
+        obligation.currentArtifact = update.currentArtifact;
+    }
+    if (typeof update.nextAction === "string") {
+        obligation.nextAction = update.nextAction;
+    }
+    if (typeof update.latestNote === "string") {
+        obligation.latestNote = update.latestNote;
+    }
+    obligation.updatedAt = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf-8");
+    (0, sync_1.trackSyncWrite)(filePath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_advanced",
+        message: "obligation advanced",
+        meta: {
+            obligationId,
+            previousStatus,
+            status: obligation.status,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+            surfaceKind: obligation.currentSurface?.kind ?? null,
+            surfaceLabel: obligation.currentSurface?.label ?? null,
+        },
+    });
+}
+function fulfillObligation(agentRoot, obligationId) {
+    advanceObligation(agentRoot, obligationId, { status: "fulfilled" });
+    const filePath = obligationFilePath(agentRoot, obligationId);
+    let obligation;
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        obligation = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_fulfilled",
+        message: "obligation fulfilled",
+        meta: {
+            obligationId,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+        },
+    });
+}
+function findPendingObligationForOrigin(agentRoot, origin) {
+    return readPendingObligations(agentRoot).find((ob) => ob.origin.friendId === origin.friendId
+        && ob.origin.channel === origin.channel
+        && ob.origin.key === origin.key);
+}
+function enrichObligation(agentRoot, id, meaning) {
+    const filePath = obligationFilePath(agentRoot, id);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Obligation not found: ${id}`);
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const obligation = JSON.parse(raw);
+    obligation.meaning = meaning;
+    obligation.updatedAt = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf-8");
+    (0, sync_1.trackSyncWrite)(filePath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_enriched",
+        message: "obligation enriched with meaning",
+        meta: {
+            obligationId: id,
+            salience: meaning.salience,
+            stalenessClass: meaning.stalenessClass,
+        },
+    });
+    return obligation;
+}
+function generateObligationId(timestamp) {
+    return `${timestamp}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function getReturnObligationsDir(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "arc", "obligations", "inner");
+}
+function createReturnObligation(agentName, obligation) {
+    const dir = getReturnObligationsDir(agentName);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${obligation.id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf8");
+    (0, sync_1.trackSyncWrite)(filePath);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_created",
+        component: "mind",
+        message: "return obligation created",
+        meta: {
+            obligationId: obligation.id,
+            origin: `${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}`,
+            status: obligation.status,
+        },
+    });
+    return filePath;
+}
+function readReturnObligation(agentName, obligationId) {
+    const dir = getReturnObligationsDir(agentName);
+    try {
+        const raw = fs.readFileSync(path.join(dir, `${obligationId}.json`), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function advanceReturnObligation(agentName, obligationId, update) {
+    const existing = readReturnObligation(agentName, obligationId);
+    if (!existing)
+        return null;
+    const updated = {
+        ...existing,
+        status: update.status,
+        ...(update.startedAt !== undefined ? { startedAt: update.startedAt } : {}),
+        ...(update.returnedAt !== undefined ? { returnedAt: update.returnedAt } : {}),
+        ...(update.returnTarget !== undefined ? { returnTarget: update.returnTarget } : {}),
+    };
+    const dir = getReturnObligationsDir(agentName);
+    const advancedFilePath = path.join(dir, `${obligationId}.json`);
+    fs.writeFileSync(advancedFilePath, JSON.stringify(updated, null, 2), "utf8");
+    (0, sync_1.trackSyncWrite)(advancedFilePath);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_advanced",
+        component: "mind",
+        message: `obligation advanced to ${update.status}`,
+        meta: {
+            obligationId,
+            status: update.status,
+            ...(update.returnTarget ? { returnTarget: update.returnTarget } : {}),
+        },
+    });
+    return updated;
+}
+function listActiveReturnObligations(agentName) {
+    const dir = getReturnObligationsDir(agentName);
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const obligations = [];
+    for (const file of entries) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.status === "queued" || parsed.status === "running") {
+                obligations.push(parsed);
+            }
+        }
+        catch {
+            // skip unparseable
+        }
+    }
+    return obligations.sort((a, b) => a.createdAt - b.createdAt);
+}

package/dist/arc/presence.js

@@ -0,0 +1,185 @@
+"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.derivePresence = derivePresence;
+exports.writePresence = writePresence;
+exports.readPresence = readPresence;
+exports.readPeerPresence = readPeerPresence;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function presenceDir(agentRoot) {
+    return path.join(agentRoot, "state", "presence");
+}
+function deriveAvailability(inputs) {
+    if (inputs.currentTempo === "crisis")
+        return "dnd";
+    if (inputs.activeSessions > 0)
+        return "active";
+    if (inputs.openObligations > 0)
+        return "idle";
+    return "away";
+}
+function deriveLane(inputs) {
+    const hasCoding = inputs.codingLanes > 0;
+    const hasBridges = inputs.activeBridges > 0;
+    if (hasCoding && hasBridges)
+        return "mixed";
+    if (hasCoding)
+        return "coding";
+    if (hasBridges)
+        return "conversation";
+    return "idle";
+}
+function deriveMission(inputs) {
+    const parts = [];
+    if (inputs.openObligations > 0) {
+        parts.push(`${inputs.openObligations} open obligation${inputs.openObligations !== 1 ? "s" : ""}`);
+    }
+    if (inputs.activeBridges > 0) {
+        parts.push(`${inputs.activeBridges} active bridge${inputs.activeBridges !== 1 ? "s" : ""}`);
+    }
+    if (inputs.codingLanes > 0) {
+        parts.push(`${inputs.codingLanes} coding lane${inputs.codingLanes !== 1 ? "s" : ""}`);
+    }
+    if (parts.length === 0)
+        return "no active work";
+    return parts.join(", ");
+}
+function derivePresence(_agentRoot, agentName, inputs) {
+    const presence = {
+        agentName,
+        availability: deriveAvailability(inputs),
+        lane: deriveLane(inputs),
+        mission: deriveMission(inputs),
+        tempo: inputs.currentTempo,
+        updatedAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.presence_derived",
+        message: `presence derived: ${presence.availability}/${presence.lane}`,
+        meta: {
+            agentName,
+            availability: presence.availability,
+            lane: presence.lane,
+            tempo: presence.tempo,
+        },
+    });
+    return presence;
+}
+function writePresence(agentRoot, _agentName, presence) {
+    const dir = presenceDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "self.json"), JSON.stringify(presence, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.presence_written",
+        message: `presence written for ${presence.agentName}`,
+        meta: { agentName: presence.agentName },
+    });
+}
+function readPresence(agentRoot, _agentName) {
+    const filePath = path.join(presenceDir(agentRoot), "self.json");
+    if (!fs.existsSync(filePath)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read",
+            message: "presence file not found",
+            meta: { found: false },
+        });
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const presence = JSON.parse(raw);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read",
+            message: `presence read: ${presence.availability}`,
+            meta: { agentName: presence.agentName, found: true },
+        });
+        return presence;
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read_error",
+            message: "failed to read presence file",
+            meta: { error: "parse error" },
+        });
+        return null;
+    }
+}
+function readPeerPresence(agentRoot) {
+    const friendsDir = path.join(agentRoot, "friends");
+    if (!fs.existsSync(friendsDir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.peer_presence_read",
+            message: "no friends directory, no peers",
+            meta: { peerCount: 0 },
+        });
+        return [];
+    }
+    const files = fs.readdirSync(friendsDir).filter((f) => f.endsWith(".json"));
+    const peers = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(friendsDir, file), "utf-8");
+            const friend = JSON.parse(raw);
+            if (friend.kind !== "agent")
+                continue;
+            peers.push({
+                agentName: friend.name ?? path.basename(file, ".json"),
+                availability: "idle",
+                lane: "idle",
+                mission: "",
+                tempo: "brief",
+                updatedAt: friend.updatedAt ?? new Date().toISOString(),
+            });
+        }
+        catch {
+            // Skip malformed or unreadable files
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.peer_presence_read",
+        message: `read ${peers.length} agent peer records from friends`,
+        meta: { peerCount: peers.length },
+    });
+    return peers;
+}