@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/senses/inner-dialog-worker.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInnerDialogWorker = createInnerDialogWorker;
+exports.startInnerDialogWorker = startInnerDialogWorker;
+const inner_dialog_1 = require("./inner-dialog");
+const runtime_1 = require("../nerves/runtime");
+function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options)) {
+    let running = false;
+    async function run(reason) {
+        if (running)
+            return;
+        running = true;
+        try {
+            await runTurn({ reason });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.inner_dialog_worker_error",
+                message: "inner dialog worker turn failed",
+                meta: {
+                    reason,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+        finally {
+            running = false;
+        }
+    }
+    async function handleMessage(message) {
+        if (!message || typeof message !== "object")
+            return;
+        const maybeMessage = message;
+        if (maybeMessage.type === "heartbeat") {
+            await run("heartbeat");
+            return;
+        }
+        if (maybeMessage.type === "poke" ||
+            maybeMessage.type === "chat" ||
+            maybeMessage.type === "message") {
+            await run("instinct");
+            return;
+        }
+        if (maybeMessage.type === "shutdown") {
+            process.exit(0);
+        }
+    }
+    return { run, handleMessage };
+}
+async function startInnerDialogWorker() {
+    const worker = createInnerDialogWorker();
+    process.on("message", (message) => {
+        void worker.handleMessage(message);
+    });
+    process.on("disconnect", () => {
+        process.exit(0);
+    });
+    await worker.run("boot");
+}

package/dist/senses/inner-dialog.js

@@ -0,0 +1,231 @@
+"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.loadInnerDialogInstincts = loadInnerDialogInstincts;
+exports.buildInnerDialogBootstrapMessage = buildInnerDialogBootstrapMessage;
+exports.buildNonCanonicalCleanupNudge = buildNonCanonicalCleanupNudge;
+exports.buildInstinctUserMessage = buildInstinctUserMessage;
+exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
+exports.innerDialogSessionPath = innerDialogSessionPath;
+exports.runInnerDialogTurn = runInnerDialogTurn;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../heart/config");
+const core_1 = require("../heart/core");
+const identity_1 = require("../heart/identity");
+const context_1 = require("../mind/context");
+const prompt_1 = require("../mind/prompt");
+const bundle_manifest_1 = require("../mind/bundle-manifest");
+const nerves_1 = require("../nerves");
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_INNER_DIALOG_INSTINCTS = [
+    {
+        id: "heartbeat_checkin",
+        prompt: "Heartbeat instinct: check what changed, review priorities, and decide whether to keep resting or act.",
+        enabled: true,
+    },
+];
+function readAspirations(agentRoot) {
+    try {
+        return fs.readFileSync(path.join(agentRoot, "psyche", "ASPIRATIONS.md"), "utf8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+function loadInnerDialogInstincts() {
+    return [...DEFAULT_INNER_DIALOG_INSTINCTS];
+}
+function buildInnerDialogBootstrapMessage(aspirations, stateSummary) {
+    const aspirationText = aspirations || "No explicit aspirations file found. Reflect and define what matters next.";
+    return [
+        "Inner dialog boot.",
+        "",
+        "## aspirations",
+        aspirationText,
+        "",
+        "## current state",
+        stateSummary,
+        "",
+        "Orient yourself, decide what to do next, and make meaningful progress.",
+    ].join("\n");
+}
+function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
+    if (nonCanonicalPaths.length === 0)
+        return "";
+    const listed = nonCanonicalPaths.slice(0, 20).map((entry) => `- ${entry}`);
+    if (nonCanonicalPaths.length > 20) {
+        listed.push(`- ... (${nonCanonicalPaths.length - 20} more)`);
+    }
+    return [
+        "## canonical cleanup nudge",
+        "I found non-canonical files in my bundle. I should distill anything valuable into your memory system and remove these files.",
+        ...listed,
+    ].join("\n");
+}
+function buildInstinctUserMessage(instincts, reason, state) {
+    const active = instincts.find((instinct) => instinct.enabled !== false) ?? DEFAULT_INNER_DIALOG_INSTINCTS[0];
+    const checkpoint = state.checkpoint?.trim() || "no prior checkpoint recorded";
+    return [
+        active.prompt,
+        `reason: ${reason}`,
+        `cycle: ${state.cycleCount}`,
+        `resting: ${state.resting ? "yes" : "no"}`,
+        `checkpoint: ${checkpoint}`,
+        "resume_instruction: continue from the checkpoint if still valid; otherwise revise and proceed.",
+    ].join("\n");
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content.trim();
+    if (!Array.isArray(content))
+        return "";
+    const text = content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (!part || typeof part !== "object")
+            return "";
+        if ("text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+    return text.trim();
+}
+function deriveResumeCheckpoint(messages) {
+    const lastAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+    if (!lastAssistant)
+        return "no prior checkpoint recorded";
+    const assistantText = contentToText(lastAssistant.content);
+    if (!assistantText)
+        return "no prior checkpoint recorded";
+    const explicitCheckpoint = assistantText
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => /^checkpoint\s*:/i.test(line));
+    if (explicitCheckpoint) {
+        const parsed = explicitCheckpoint.replace(/^checkpoint\s*:\s*/i, "").trim();
+        return parsed || "no prior checkpoint recorded";
+    }
+    const firstLine = assistantText
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)[0];
+    if (firstLine.length <= 220)
+        return firstLine;
+    return `${firstLine.slice(0, 217)}...`;
+}
+function createInnerDialogCallbacks() {
+    return {
+        onModelStart: () => { },
+        onModelStreamStart: () => { },
+        onTextChunk: () => { },
+        onReasoningChunk: () => { },
+        onToolStart: () => { },
+        onToolEnd: () => { },
+        onError: () => { },
+    };
+}
+function innerDialogSessionPath() {
+    return (0, config_1.sessionPath)("self", "inner", "dialog");
+}
+async function runInnerDialogTurn(options) {
+    const now = options?.now ?? (() => new Date());
+    const reason = options?.reason ?? "heartbeat";
+    const sessionFilePath = innerDialogSessionPath();
+    const loaded = (0, context_1.loadSession)(sessionFilePath);
+    const messages = loaded?.messages ? [...loaded.messages] : [];
+    const instincts = options?.instincts ?? loadInnerDialogInstincts();
+    const state = {
+        cycleCount: 1,
+        resting: false,
+        lastHeartbeatAt: now().toISOString(),
+    };
+    if (messages.length === 0) {
+        const systemPrompt = await (0, prompt_1.buildSystem)("cli", { toolChoiceRequired: true });
+        messages.push({ role: "system", content: systemPrompt });
+        const aspirations = readAspirations((0, identity_1.getAgentRoot)());
+        const nonCanonical = (0, bundle_manifest_1.findNonCanonicalBundlePaths)((0, identity_1.getAgentRoot)());
+        const cleanupNudge = buildNonCanonicalCleanupNudge(nonCanonical);
+        const bootstrapMessage = [
+            buildInnerDialogBootstrapMessage(aspirations, "No prior inner dialog session found."),
+            cleanupNudge,
+        ].filter(Boolean).join("\n\n");
+        messages.push({ role: "user", content: bootstrapMessage });
+    }
+    else {
+        const assistantTurns = messages.filter((message) => message.role === "assistant").length;
+        state.cycleCount = assistantTurns + 1;
+        state.checkpoint = deriveResumeCheckpoint(messages);
+        const instinctPrompt = buildInstinctUserMessage(instincts, reason, state);
+        messages.push({ role: "user", content: instinctPrompt });
+    }
+    const inboxMessages = options?.drainInbox?.() ?? [];
+    if (inboxMessages.length > 0) {
+        const lastUserIdx = messages.length - 1;
+        const lastUser = messages[lastUserIdx];
+        /* v8 ignore next -- defensive: all code paths push a user message before here @preserve */
+        if (lastUser?.role === "user" && typeof lastUser.content === "string") {
+            const section = inboxMessages
+                .map((msg) => `- **${msg.from}**: ${msg.content}`)
+                .join("\n");
+            messages[lastUserIdx] = {
+                ...lastUser,
+                content: `${lastUser.content}\n\n## incoming messages\n${section}`,
+            };
+        }
+    }
+    const callbacks = createInnerDialogCallbacks();
+    const traceId = (0, nerves_1.createTraceId)();
+    const result = await (0, core_1.runAgent)(messages, callbacks, "cli", options?.signal, {
+        traceId,
+        toolChoiceRequired: true,
+        skipConfirmation: true,
+    });
+    (0, context_1.postTurn)(messages, sessionFilePath, result.usage);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.inner_dialog_turn",
+        message: "inner dialog turn completed",
+        meta: { reason, session: sessionFilePath },
+    });
+    return {
+        messages,
+        usage: result.usage,
+        sessionPath: sessionFilePath,
+    };
+}

package/dist/senses/session-lock.js

@@ -0,0 +1,119 @@
+"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.SessionLockError = void 0;
+exports.acquireSessionLock = acquireSessionLock;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+class SessionLockError extends Error {
+    agentName;
+    constructor(agentName) {
+        super(`already chatting with ${agentName} in another terminal`);
+        this.name = "SessionLockError";
+        this.agentName = agentName;
+    }
+}
+exports.SessionLockError = SessionLockError;
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const defaultDeps = {
+    writeFileSync: (p, d, o) => fs.writeFileSync(p, d, o),
+    readFileSync: (p, e) => fs.readFileSync(p, e),
+    unlinkSync: (p) => fs.unlinkSync(p),
+    pid: process.pid,
+    isProcessAlive: defaultIsProcessAlive,
+};
+function acquireSessionLock(lockPath, agentName, deps = defaultDeps) {
+    const tryWrite = () => {
+        try {
+            deps.writeFileSync(lockPath, String(deps.pid), { flag: "wx" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!tryWrite()) {
+        // Lock file exists — check if stale
+        let existingPid;
+        try {
+            existingPid = parseInt(deps.readFileSync(lockPath, "utf-8").trim(), 10);
+        }
+        catch {
+            // Can't read lock file — try removing and retrying
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+            if (!tryWrite())
+                throw new SessionLockError(agentName);
+            return makeRelease(lockPath, deps);
+        }
+        if (Number.isNaN(existingPid) || !deps.isProcessAlive(existingPid)) {
+            // Stale lock — remove and retry
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+            if (!tryWrite())
+                throw new SessionLockError(agentName);
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.session_lock_stolen", message: "stole stale session lock from dead process", meta: { agentName, existingPid } });
+            return makeRelease(lockPath, deps);
+        }
+        throw new SessionLockError(agentName);
+    }
+    return makeRelease(lockPath, deps);
+}
+function makeRelease(lockPath, deps) {
+    let released = false;
+    return {
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+        },
+    };
+}

package/dist/senses/teams-entry.js

@@ -0,0 +1,15 @@
+"use strict";
+// Thin entrypoint for `npm run teams` / `node dist/senses/teams-entry.js --agent <name>`.
+// Separated from teams.ts so the Teams adapter is pure library code with clean
+// 100% test coverage -- entrypoints can't be covered by vitest since
+// require.main !== module in the test runner.
+// All config comes from the conventional ~/.agentsecrets/<agent>/secrets.json path.
+Object.defineProperty(exports, "__esModule", { value: true });
+// Fail fast if --agent is missing (before any src/ code tries getAgentName())
+if (!process.argv.includes("--agent")) {
+    // eslint-disable-next-line no-console -- pre-boot guard: --agent check before imports
+    console.error("Missing required --agent <name> argument.\nUsage: node dist/senses/teams-entry.js --agent ouroboros");
+    process.exit(1);
+}
+const teams_1 = require("./teams");
+(0, teams_1.startTeamsApp)();