@ouro.bot/cli 0.1.0-alpha.2 → 0.1.0-alpha.200

package/dist/heart/daemon/specialist-tools.js

@@ -0,0 +1,283 @@
+"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.getSpecialistTools = getSpecialistTools;
+exports.createSpecialistExecTool = createSpecialistExecTool;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const tools_base_1 = require("../../repertoire/tools-base");
+const hatch_flow_1 = require("./hatch-flow");
+const hatch_animation_1 = require("./hatch-animation");
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const runtime_1 = require("../../nerves/runtime");
+const completeAdoptionTool = {
+    type: "function",
+    function: {
+        name: "complete_adoption",
+        description: "finalize the agent bundle and hatch the new agent. call this only when you have written all 5 psyche files and agent.json to the temp directory, and the human has approved the bundle.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "the PascalCase name for the new agent (e.g. 'Slugger')",
+                },
+                handoff_message: {
+                    type: "string",
+                    description: "a warm handoff message to display to the human after the agent is hatched",
+                },
+                phone: {
+                    type: "string",
+                    description: "the human's phone number (optional, for iMessage contact recognition)",
+                },
+                teams_handle: {
+                    type: "string",
+                    description: "the human's Teams email/handle (optional, for Teams contact recognition)",
+                },
+            },
+            required: ["name", "handoff_message"],
+        },
+    },
+};
+const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
+const writeFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "write_file");
+const listDirToolSchema = {
+    type: "function",
+    function: {
+        name: "list_directory",
+        description: "list directory contents",
+        parameters: {
+            type: "object",
+            properties: { path: { type: "string" } },
+            required: ["path"],
+        },
+    },
+};
+/**
+ * Returns the specialist's tool schema array.
+ */
+function getSpecialistTools() {
+    return [completeAdoptionTool, tools_base_1.settleTool, readFileTool.tool, writeFileTool.tool, listDirToolSchema];
+}
+const PSYCHE_FILES = ["SOUL.md", "IDENTITY.md", "LORE.md", "TACIT.md", "ASPIRATIONS.md"];
+function isPascalCase(name) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function writeReadme(dir, purpose) {
+    fs.mkdirSync(dir, { recursive: true });
+    const readmePath = path.join(dir, "README.md");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(readmePath)) {
+        fs.writeFileSync(readmePath, `# ${path.basename(dir)}\n\n${purpose}\n`, "utf-8");
+    }
+}
+function scaffoldBundle(bundleRoot) {
+    writeReadme(path.join(bundleRoot, "memory"), "Persistent memory store.");
+    writeReadme(path.join(bundleRoot, "memory", "daily"), "Daily memory entries.");
+    writeReadme(path.join(bundleRoot, "memory", "archive"), "Archived memory.");
+    writeReadme(path.join(bundleRoot, "friends"), "Known friend records.");
+    writeReadme(path.join(bundleRoot, "tasks"), "Task files.");
+    writeReadme(path.join(bundleRoot, "tasks", "one-shots"), "One-shot tasks.");
+    writeReadme(path.join(bundleRoot, "habits"), "Recurring habits and autonomous rhythms.");
+    writeReadme(path.join(bundleRoot, "tasks", "ongoing"), "Ongoing tasks.");
+    writeReadme(path.join(bundleRoot, "skills"), "Local skill files.");
+    writeReadme(path.join(bundleRoot, "senses"), "Sense-specific config.");
+    writeReadme(path.join(bundleRoot, "senses", "teams"), "Teams sense config.");
+    // Memory scaffold files
+    const memoryRoot = path.join(bundleRoot, "memory");
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    const entitiesPath = path.join(memoryRoot, "entities.json");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(factsPath))
+        fs.writeFileSync(factsPath, "", "utf-8");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(entitiesPath))
+        fs.writeFileSync(entitiesPath, "{}\n", "utf-8");
+    // bundle-meta.json
+    const meta = (0, bundle_manifest_1.createBundleMeta)();
+    fs.writeFileSync(path.join(bundleRoot, "bundle-meta.json"), JSON.stringify(meta, null, 2) + "\n", "utf-8");
+}
+function moveDir(src, dest) {
+    try {
+        fs.renameSync(src, dest);
+    }
+    catch {
+        /* v8 ignore start -- cross-device fallback: only triggers on EXDEV (e.g. /tmp → different mount), untestable in CI @preserve */
+        fs.cpSync(src, dest, { recursive: true });
+        fs.rmSync(src, { recursive: true, force: true });
+        /* v8 ignore stop */
+    }
+}
+async function execCompleteAdoption(args, deps) {
+    const name = args.name;
+    const handoffMessage = args.handoff_message;
+    if (!name) {
+        return "error: missing required 'name' parameter";
+    }
+    if (!isPascalCase(name)) {
+        return `error: name '${name}' must be PascalCase (e.g. 'Slugger', 'MyAgent')`;
+    }
+    // Validate psyche files exist
+    const psycheDir = path.join(deps.tempDir, "psyche");
+    const missingPsyche = PSYCHE_FILES.filter((f) => !fs.existsSync(path.join(psycheDir, f)));
+    if (missingPsyche.length > 0) {
+        return `error: missing psyche files in temp directory: ${missingPsyche.join(", ")}. write them first using write_file.`;
+    }
+    // Validate agent.json exists
+    const agentJsonPath = path.join(deps.tempDir, "agent.json");
+    if (!fs.existsSync(agentJsonPath)) {
+        return "error: agent.json not found in temp directory. write it first using write_file.";
+    }
+    // Validate target doesn't exist
+    const targetBundle = path.join(deps.bundlesRoot, `${name}.ouro`);
+    if (fs.existsSync(targetBundle)) {
+        return `error: bundle '${name}.ouro' already exists at ${deps.bundlesRoot}. choose a different name.`;
+    }
+    // Scaffold structural dirs into tempDir
+    scaffoldBundle(deps.tempDir);
+    // Move tempDir -> final bundle location
+    moveDir(deps.tempDir, targetBundle);
+    // Write secrets
+    try {
+        (0, hatch_flow_1.writeSecretsFile)(name, deps.provider, deps.credentials, deps.secretsRoot);
+    }
+    catch (e) {
+        // Rollback: remove the moved bundle
+        try {
+            fs.rmSync(targetBundle, { recursive: true, force: true });
+        }
+        catch {
+            // Best effort cleanup
+        }
+        return `error: failed to write secrets: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+    }
+    // Create initial friend record if contact info provided
+    const phone = args.phone;
+    const teamsHandle = args.teams_handle;
+    if (phone || teamsHandle) {
+        const friendId = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const externalIds = [];
+        if (phone)
+            externalIds.push({ provider: "imessage-handle", externalId: phone, linkedAt: now });
+        if (teamsHandle)
+            externalIds.push({ provider: "aad", externalId: teamsHandle, linkedAt: now });
+        const friendRecord = {
+            id: friendId,
+            name: deps.humanName ?? "primary",
+            trustLevel: "family",
+            externalIds,
+            tenantMemberships: [],
+            toolPreferences: {},
+            notes: {},
+            createdAt: now,
+            updatedAt: now,
+            schemaVersion: 1,
+        };
+        const friendPath = path.join(targetBundle, "friends", `${friendId}.json`);
+        fs.writeFileSync(friendPath, JSON.stringify(friendRecord, null, 2), "utf-8");
+    }
+    // Play hatch animation
+    await (0, hatch_animation_1.playHatchAnimation)(name, deps.animationWriter);
+    // Display handoff message
+    /* v8 ignore next -- UI-only: handoff message display, covered by integration @preserve */
+    if (handoffMessage && deps.animationWriter) {
+        deps.animationWriter(`\n${handoffMessage}\n`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.adoption_complete",
+        message: "adoption completed successfully",
+        meta: { agentName: name, bundlePath: targetBundle },
+    });
+    return JSON.stringify({ success: true, agentName: name, bundlePath: targetBundle });
+}
+/**
+ * Create a specialist tool executor with the given dependencies captured in closure.
+ */
+function createSpecialistExecTool(deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_exec_tool_created",
+        message: "specialist exec tool created",
+        meta: { tempDir: deps.tempDir },
+    });
+    return async (name, args) => {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.specialist_tool_exec",
+            message: "executing specialist tool",
+            meta: { tool: name },
+        });
+        if (name === "complete_adoption") {
+            return execCompleteAdoption(args, deps);
+        }
+        if (name === "read_file") {
+            try {
+                return fs.readFileSync(args.path, "utf-8");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
+        }
+        if (name === "write_file") {
+            try {
+                const dir = path.dirname(args.path);
+                fs.mkdirSync(dir, { recursive: true });
+                const content = typeof args.content === "string"
+                    ? args.content
+                    : JSON.stringify(args.content, null, 2);
+                fs.writeFileSync(args.path, content, "utf-8");
+                return `wrote ${args.path}`;
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
+        }
+        if (name === "list_directory") {
+            try {
+                return fs
+                    .readdirSync(args.path, { withFileTypes: true })
+                    .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
+                    .join("\n");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
+        }
+        return `error: unknown tool '${name}'`;
+    };
+}

package/dist/heart/daemon/staged-restart.js

@@ -0,0 +1,138 @@
+"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.performStagedRestart = performStagedRestart;
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+async function performStagedRestart(version, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.staged_restart_start",
+        message: "starting staged restart",
+        meta: { version },
+    });
+    // Step 1: Install new version
+    try {
+        deps.execSync(`npm install -g @ouro.bot/cli@${version}`);
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_install_failed",
+            message: "npm install failed",
+            meta: { version, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    // Step 2: Resolve new code path
+    const newCodePath = deps.resolveNewCodePath(version);
+    if (!newCodePath) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_path_failed",
+            message: "could not resolve new code path",
+            meta: { version },
+        });
+        return { ok: false, error: "could not resolve new code path after install" };
+    }
+    // Step 3: Spawn hook runner on NEW code
+    const hookRunnerPath = path.join(newCodePath, "dist", "heart", "daemon", "run-hooks.js");
+    const spawnResult = deps.spawnSync(deps.nodePath, [hookRunnerPath, "--bundles-root", deps.bundlesRoot], { stdio: "inherit" });
+    if (spawnResult.error) {
+        const errorMessage = spawnResult.error.message;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_spawn_failed",
+            message: "hook runner spawn failed",
+            meta: { version, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    if (spawnResult.status !== 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_hooks_failed",
+            message: "hook runner exited with non-zero status",
+            meta: { version, exitCode: spawnResult.status },
+        });
+        return { ok: false, error: `hook runner exited with code ${spawnResult.status}` };
+    }
+    // Step 4: Graceful shutdown then self-spawn new daemon
+    // We can't rely on launchd KeepAlive — the plist may not be loaded.
+    // Instead: shut down (releases socket), spawn new daemon from updated code.
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.staged_restart_hooks_passed",
+        message: "hooks passed, shutting down and spawning new daemon",
+        meta: { version },
+    });
+    let shutdownError;
+    try {
+        await deps.gracefulShutdown();
+    }
+    catch (err) {
+        shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_shutdown_error",
+            message: "graceful shutdown encountered error (continuing with spawn)",
+            meta: { version, error: shutdownError },
+        });
+    }
+    // Spawn new daemon from updated code path
+    const newEntry = path.join(newCodePath, "dist", "heart", "daemon", "daemon-entry.js");
+    const socketArg = deps.socketPath ?? "/tmp/ouroboros-daemon.sock";
+    try {
+        const { pid } = deps.spawnNewDaemon(newEntry, socketArg);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_spawned",
+            message: "new daemon spawned successfully",
+            meta: { version, pid, entry: newEntry },
+        });
+    }
+    catch (err) {
+        const spawnError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_respawn_failed",
+            message: "failed to spawn new daemon after shutdown",
+            meta: { version, error: spawnError, entry: newEntry },
+        });
+        return { ok: false, error: `shutdown succeeded but failed to spawn new daemon: ${spawnError}`, shutdownError };
+    }
+    return { ok: true, shutdownError };
+}

package/dist/heart/daemon/task-scheduler.js

@@ -39,6 +39,7 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const parser_1 = require("../../repertoire/tasks/parser");
+const cadence_1 = require("./cadence");
 function walkMarkdownFiles(root, readdirSync, existsSync, files) {
     if (!existsSync(root))
         return;
@@ -53,29 +54,6 @@ function walkMarkdownFiles(root, readdirSync, existsSync, files) {
         }
     }
 }
-function parseCadence(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const value = raw.trim();
-    if (!value)
-        return null;
-    // Cron format (minute hour day month weekday)
-    if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(value)) {
-        return value;
-    }
-    const cadenceMatch = /^(\d+)(m|h|d)$/.exec(value);
-    if (!cadenceMatch)
-        return null;
-    const interval = Number.parseInt(cadenceMatch[1], 10);
-    if (!Number.isFinite(interval) || interval <= 0)
-        return null;
-    const unit = cadenceMatch[2];
-    if (unit === "m")
-        return `*/${interval} * * * *`;
-    if (unit === "h")
-        return `0 */${interval} * * *`;
-    return `0 0 */${interval} * *`;
-}
 function parseScheduledAt(raw) {
     if (typeof raw !== "string")
         return null;
@@ -140,7 +118,7 @@ class TaskDrivenScheduler {
         const nextTaskPaths = new Map();
         for (const agent of this.agents) {
             const taskRoot = path.join(this.bundlesRoot, `${agent}.ouro`, "tasks");
-            const collections = ["one-shots", "ongoing", "habits"];
+            const collections = ["one-shots", "ongoing"];
             const files = [];
             for (const collection of collections) {
                 walkMarkdownFiles(path.join(taskRoot, collection), this.readdirSync, this.existsSync, files);
@@ -157,7 +135,7 @@ class TaskDrivenScheduler {
                 nextTaskPaths.set(`${agent}:${taskId}`, filePath);
                 if (task.status === "done")
                     continue;
-                const cadence = parseCadence(task.frontmatter.cadence);
+                const cadence = (0, cadence_1.parseCadenceToCron)(task.frontmatter.cadence);
                 if (cadence) {
                     const id = `${agent}:${taskId}:cadence`;
                     nextJobs.set(id, {