@ouro.bot/cli 0.1.0-alpha.14 → 0.1.0-alpha.141

package/dist/mind/obligations.js

@@ -0,0 +1,134 @@
+"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.getObligationsDir = getObligationsDir;
+exports.generateObligationId = generateObligationId;
+exports.createObligation = createObligation;
+exports.readObligation = readObligation;
+exports.advanceObligation = advanceObligation;
+exports.listActiveObligations = listActiveObligations;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+// ── Paths ────────────────────────────────────────────────────────
+function getObligationsDir(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "obligations", "inner");
+}
+// ── ID generation ────────────────────────────────────────────────
+function generateObligationId(timestamp) {
+    return `${timestamp}-${Math.random().toString(36).slice(2, 10)}`;
+}
+// ── Store operations ─────────────────────────────────────────────
+function createObligation(agentName, obligation) {
+    const dir = getObligationsDir(agentName);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${obligation.id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf8");
+    (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 readObligation(agentName, obligationId) {
+    const dir = getObligationsDir(agentName);
+    try {
+        const raw = fs.readFileSync(path.join(dir, `${obligationId}.json`), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function advanceObligation(agentName, obligationId, update) {
+    const existing = readObligation(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 = getObligationsDir(agentName);
+    fs.writeFileSync(path.join(dir, `${obligationId}.json`), JSON.stringify(updated, null, 2), "utf8");
+    (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 listActiveObligations(agentName) {
+    const dir = getObligationsDir(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/mind/pending.js

@@ -33,24 +33,60 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INNER_DIALOG_PENDING = void 0;
 exports.getPendingDir = getPendingDir;
+exports.getDeferredReturnDir = getDeferredReturnDir;
+exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
+exports.hasPendingMessages = hasPendingMessages;
+exports.queuePendingMessage = queuePendingMessage;
+exports.enqueueDeferredReturn = enqueueDeferredReturn;
+exports.drainDeferredReturns = drainDeferredReturns;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 function getPendingDir(agentName, friendId, channel, key) {
-    return path.join(os.homedir(), ".agentstate", agentName, "pending", friendId, channel, key);
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending", friendId, channel, key);
 }
-function drainPending(pendingDir) {
+function getDeferredReturnDir(agentName, friendId) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending-returns", friendId);
+}
+/** Canonical inner-dialog pending path segments. */
+exports.INNER_DIALOG_PENDING = { friendId: "self", channel: "inner", key: "dialog" };
+/** Returns the pending dir for this agent's inner dialog. */
+function getInnerDialogPendingDir(agentName) {
+    return getPendingDir(agentName, exports.INNER_DIALOG_PENDING.friendId, exports.INNER_DIALOG_PENDING.channel, exports.INNER_DIALOG_PENDING.key);
+}
+function hasPendingMessages(pendingDir) {
     if (!fs.existsSync(pendingDir))
-        return [];
+        return false;
+    try {
+        return fs.readdirSync(pendingDir).some((entry) => entry.endsWith(".json") || entry.endsWith(".json.processing"));
+    }
+    catch {
+        return false;
+    }
+}
+function writeQueueFile(queueDir, message) {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(queueDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(message, null, 2));
+    return filePath;
+}
+function queuePendingMessage(pendingDir, message) {
+    writeQueueFile(pendingDir, message);
+}
+function drainQueue(queueDir) {
+    if (!fs.existsSync(queueDir))
+        return { messages: [], recovered: 0 };
     let entries;
     try {
-        entries = fs.readdirSync(pendingDir);
+        entries = fs.readdirSync(queueDir);
     }
     catch {
-        return [];
+        return { messages: [], recovered: 0 };
     }
     // Collect both .json (new) and .processing (crash recovery)
     const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
@@ -62,9 +98,9 @@ function drainPending(pendingDir) {
     ].sort((a, b) => a.file.localeCompare(b.file));
     const messages = [];
     for (const { file, needsRename } of allFiles) {
-        const srcPath = path.join(pendingDir, file);
+        const srcPath = path.join(queueDir, file);
         const processingPath = needsRename
-            ? path.join(pendingDir, file + ".processing")
+            ? path.join(queueDir, file + ".processing")
             : srcPath;
         try {
             if (needsRename) {
@@ -83,11 +119,42 @@ function drainPending(pendingDir) {
             catch { /* ignore */ }
         }
     }
+    return {
+        messages,
+        recovered: processingFiles.length,
+    };
+}
+function enqueueDeferredReturn(agentName, friendId, message) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const filePath = writeQueueFile(queueDir, message);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_return_enqueued",
+        component: "mind",
+        message: "deferred return queued for later friend delivery",
+        meta: { friendId, queueDir },
+    });
+    return filePath;
+}
+function drainDeferredReturns(agentName, friendId) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const { messages } = drainQueue(queueDir);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_returns_drained",
+        component: "mind",
+        message: "deferred friend returns drained",
+        meta: { friendId, queueDir, count: messages.length },
+    });
+    return messages;
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    const { messages, recovered } = drainQueue(pendingDir);
     (0, runtime_1.emitNervesEvent)({
         event: "mind.pending_drained",
         component: "mind",
         message: "pending queue drained",
-        meta: { pendingDir, count: messages.length, recovered: processingFiles.length },
+        meta: { pendingDir, count: messages.length, recovered },
     });
     return messages;
 }

package/dist/mind/phrases.js

@@ -16,6 +16,7 @@ function getPhrases() {
         message: "loading phrase pools",
         meta: {},
     });
+    (0, identity_1.resetAgentConfigCache)();
     const phrases = (0, identity_1.loadAgentConfig)().phrases;
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",