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

package/dist/heart/harness.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARNESS_PRIMITIVES_ENTRYPOINT = void 0;
+const runtime_1 = require("../nerves/runtime");
+__exportStar(require("./primitives"), exports);
+exports.HARNESS_PRIMITIVES_ENTRYPOINT = "harness/primitives";
+(0, runtime_1.emitNervesEvent)({
+    component: "harness",
+    event: "harness.module_entry_loaded",
+    message: "harness primitives entrypoint loaded",
+    meta: {},
+});

package/dist/heart/identity.js

@@ -0,0 +1,270 @@
+"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.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
+exports.getAgentName = getAgentName;
+exports.getRepoRoot = getRepoRoot;
+exports.getAgentBundlesRoot = getAgentBundlesRoot;
+exports.getAgentRoot = getAgentRoot;
+exports.getAgentSecretsPath = getAgentSecretsPath;
+exports.loadAgentConfig = loadAgentConfig;
+exports.resetIdentity = resetIdentity;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+exports.DEFAULT_AGENT_CONTEXT = {
+    maxTokens: 80000,
+    contextMargin: 20,
+};
+exports.DEFAULT_AGENT_PHRASES = {
+    thinking: ["working"],
+    tool: ["running tool"],
+    followup: ["processing"],
+};
+function buildDefaultAgentTemplate(_agentName) {
+    return {
+        version: 1,
+        enabled: true,
+        provider: "anthropic",
+        context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        phrases: {
+            thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
+            tool: [...exports.DEFAULT_AGENT_PHRASES.tool],
+            followup: [...exports.DEFAULT_AGENT_PHRASES.followup],
+        },
+    };
+}
+let _cachedAgentName = null;
+let _cachedAgentConfig = null;
+/**
+ * Parse `--agent <name>` from process.argv.
+ * Caches the result after first parse.
+ * Throws if --agent is missing or has no value.
+ */
+function getAgentName() {
+    if (_cachedAgentName) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "identity.resolve",
+            component: "config/identity",
+            message: "resolved agent name from cache",
+            meta: { source: "cache" },
+        });
+        return _cachedAgentName;
+    }
+    const idx = process.argv.indexOf("--agent");
+    if (idx === -1 || idx + 1 >= process.argv.length) {
+        throw new Error("Missing required --agent <name> argument. Usage: node cli-entry.js --agent ouroboros");
+    }
+    _cachedAgentName = process.argv[idx + 1];
+    (0, runtime_1.emitNervesEvent)({
+        event: "identity.resolve",
+        component: "config/identity",
+        message: "resolved agent name from argv",
+        meta: { source: "argv" },
+    });
+    return _cachedAgentName;
+}
+/**
+ * Resolve repo root from __dirname.
+ * In dev (tsx): __dirname is `<repo>/src`, so repo root is one level up.
+ * In compiled (node dist/): __dirname is `<repo>/dist`, so repo root is one level up.
+ */
+function getRepoRoot() {
+    return path.resolve(__dirname, "..");
+}
+/**
+ * Returns the shared bundle root directory: `~/AgentBundles/`
+ */
+function getAgentBundlesRoot() {
+    return path.join(os.homedir(), "AgentBundles");
+}
+/**
+ * Returns the agent-specific bundle directory: `~/AgentBundles/<agentName>.ouro/`
+ */
+function getAgentRoot() {
+    return path.join(getAgentBundlesRoot(), `${getAgentName()}.ouro`);
+}
+/**
+ * Returns the conventional secrets path: `~/.agentsecrets/<agentName>/secrets.json`
+ */
+function getAgentSecretsPath(agentName = getAgentName()) {
+    return path.join(os.homedir(), ".agentsecrets", agentName, "secrets.json");
+}
+/**
+ * Load and parse `<agentRoot>/agent.json`.
+ * Caches the result after first load.
+ * Throws descriptive error if file is missing or contains invalid JSON.
+ */
+function loadAgentConfig() {
+    if (_cachedAgentConfig) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "identity.resolve",
+            component: "config/identity",
+            message: "loaded agent config from cache",
+            meta: { source: "cache" },
+        });
+        return _cachedAgentConfig;
+    }
+    const agentRoot = getAgentRoot();
+    const configFile = path.join(agentRoot, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configFile, "utf-8");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "failed reading agent.json",
+            meta: {
+                path: configFile,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw new Error(`Cannot read agent.json at ${configFile}. Does the agent directory exist?`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "invalid agent.json syntax",
+            meta: {
+                path: configFile,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw new Error(`Invalid JSON in agent.json at ${configFile}. Check syntax.`);
+    }
+    const existingPhrases = parsed.phrases;
+    const needsFill = !existingPhrases ||
+        !existingPhrases.thinking ||
+        !existingPhrases.tool ||
+        !existingPhrases.followup;
+    if (needsFill) {
+        const filled = {
+            thinking: existingPhrases?.thinking ?? exports.DEFAULT_AGENT_PHRASES.thinking,
+            tool: existingPhrases?.tool ?? exports.DEFAULT_AGENT_PHRASES.tool,
+            followup: existingPhrases?.followup ?? exports.DEFAULT_AGENT_PHRASES.followup,
+        };
+        parsed.phrases = filled;
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config missing phrase pools; placeholders applied",
+            meta: { path: configFile },
+        });
+        fs.writeFileSync(configFile, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+    }
+    const rawProvider = parsed.provider;
+    if (rawProvider !== "azure" &&
+        rawProvider !== "minimax" &&
+        rawProvider !== "anthropic" &&
+        rawProvider !== "openai-codex") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config missing or invalid provider",
+            meta: {
+                path: configFile,
+                provider: rawProvider,
+            },
+        });
+        throw new Error(`agent.json at ${configFile} must include provider: "azure", "minimax", "anthropic", or "openai-codex".`);
+    }
+    const rawVersion = parsed.version;
+    const version = rawVersion === undefined ? 1 : rawVersion;
+    if (typeof version !== "number" ||
+        !Number.isInteger(version) ||
+        version < 1) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config missing or invalid version",
+            meta: {
+                path: configFile,
+                version: rawVersion,
+            },
+        });
+        throw new Error(`agent.json at ${configFile} must include version as integer >= 1.`);
+    }
+    const rawEnabled = parsed.enabled;
+    const enabled = rawEnabled === undefined ? true : rawEnabled;
+    if (typeof enabled !== "boolean") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config has invalid enabled flag",
+            meta: {
+                path: configFile,
+                enabled: rawEnabled,
+            },
+        });
+        throw new Error(`agent.json at ${configFile} must include enabled as boolean.`);
+    }
+    _cachedAgentConfig = {
+        version,
+        enabled,
+        provider: rawProvider,
+        context: parsed.context,
+        phrases: parsed.phrases,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        event: "identity.resolve",
+        component: "config/identity",
+        message: "loaded agent config from disk",
+        meta: { source: "disk" },
+    });
+    return _cachedAgentConfig;
+}
+/**
+ * Clear all cached identity state.
+ * Used in tests and when switching agent context.
+ */
+function resetIdentity() {
+    _cachedAgentName = null;
+    _cachedAgentConfig = null;
+}

package/dist/heart/kicks.js

@@ -0,0 +1,144 @@
+"use strict";
+// TODO: Kicks enforce "any action" but not "meaningful action". After a narration
+// kick, the model can satisfy the constraint by calling a no-op tool like
+// get_current_time({}). We need to detect trivial compliance and either re-kick
+// or discount the tool call. Ideally, the kick message would suggest a specific
+// tool call based on conversation context (what the user asked, what tools are
+// relevant) rather than just saying "call a tool". That's a bigger piece of work —
+// it requires the kick system to be context-aware.
+// See ouroboros' observation: "i'm not chickening out. i'm satisfying a crude
+// constraint. poorly."
+//
+// A kick is a self-correction. When the harness detects a malformed response,
+// it injects an assistant-role message as if the model caught its own mistake.
+//
+// Kicks are:
+//   - assistant role (self-correction, not external rebuke)
+//   - first person ("I" not "you")
+//   - forward-looking (what I'm doing next, not what I did wrong)
+//   - short (one sentence)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasToolIntent = hasToolIntent;
+exports.detectKick = detectKick;
+const KICK_MESSAGES = {
+    empty: "I sent an empty message by accident — let me try again.",
+    narration: "I narrated instead of acting. Using the tool now -- if done, calling final_answer.",
+    tool_required: "tool-required is on — I need to call a tool. use /tool-required to turn it off.",
+};
+const TOOL_INTENT_PATTERNS = [
+    // Explicit intent — "let me", "I'll", "I will"
+    /\blet me\b/i,
+    /\bi'll\b/i,
+    /\bi will\b/i,
+    /\bi would like to\b/i,
+    /\bi want to\b/i,
+    // "going to" variants
+    /\bi'm going to\b/i,
+    /\bgoing to\b/i,
+    /\bi am going to\b/i,
+    // Present continuous — "i'm checking", "i am querying"
+    /\bi'm \w+ing\b/i,
+    /\bi am \w+ing\b/i,
+    // Action announcements — "I need to", "I should", "I can"
+    /\bi need to\b/i,
+    /\bi should\b/i,
+    /\bi can\b/i,
+    // Obligation — "I have to", "I must"
+    /\bi have to\b/i,
+    /\bwe have to\b/i,
+    /\bi must\b/i,
+    /\bwe must\b/i,
+    // First person plural intent
+    /\bwe need to\b/i,
+    /\bwe should\b/i,
+    /\bwe can\b/i,
+    /\bwe'll\b/i,
+    /\bwe will\b/i,
+    /\bwe're going to\b/i,
+    /\bwe are going to\b/i,
+    /\blet's\b/i,
+    // Gerund phase shifts — "entering", "starting", "proceeding", "switching"
+    /\bentering\b/i,
+    /\bstarting with\b/i,
+    /\bproceeding\b/i,
+    /\bswitching to\b/i,
+    // Temporal narration — "first", "now I/we", "next turn", "next, I"
+    /\bfirst,?\s+i\b/i,
+    /\bnow i\b/i,
+    /\bnow we\b/i,
+    /\bnext turn\b/i,
+    /\bnext,?\s+i\b/i,
+    /\bnext,?\s+we\b/i,
+    // Sequential narration — "then I/we", "after that", "once I/we", "before I/we"
+    /\bthen i\b/i,
+    /\bthen we\b/i,
+    /\bafter that\b/i,
+    /\bonce i\b/i,
+    /\bonce we\b/i,
+    /\bbefore i\b/i,
+    /\bbefore we\b/i,
+    // Future intent — "about to", "gonna"
+    /\babout to\b/i,
+    /\bgonna\b/i,
+    // Hedged intent — "allow me to", "time to"
+    /\ballow me to\b/i,
+    /\btime to\b/i,
+    // Movement narration — "moving on", "moving to"
+    /\bmoving on\b/i,
+    /\bmoving to\b/i,
+    // Self-narration — "my next step", "my plan", "the plan is", "tool calls only"
+    /\bmy next step\b/i,
+    /\bmy plan\b/i,
+    /\bthe plan is\b/i,
+    /\btool calls only\b/i,
+    // "Continuing" at start of any line — narration filler (multiline so ^ matches after \n)
+    /^continuing\b/im,
+    // "continues" anywhere — progress narration ("The work continues", "continues to be complex")
+    /\bcontinues\b/i,
+    // "Next up" at start of text — e.g. "Next up:", "Next up, I'll..."
+    /^next up\b/i,
+];
+// Normalize curly quotes/apostrophes to straight so patterns match consistently
+function normalize(text) {
+    return text.replace(/[\u2018\u2019\u2032]/g, "'").replace(/[\u201C\u201D]/g, '"');
+}
+function hasToolIntent(text) {
+    return TOOL_INTENT_PATTERNS.some((p) => p.test(normalize(text)));
+}
+// Detect what kind of kick is needed, or null if response is fine.
+// Priority: empty > narration > tool_required
+function detectKick(content, options) {
+    const isEmpty = !content?.trim();
+    if (isEmpty) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.error",
+            component: "engine",
+            message: "empty assistant content detected",
+            meta: { reason: "empty" },
+        });
+        return { reason: "empty", message: KICK_MESSAGES.empty };
+    }
+    if (hasToolIntent(content)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.error",
+            component: "engine",
+            message: "narration-style response detected",
+            meta: { reason: "narration" },
+        });
+        return { reason: "narration", message: KICK_MESSAGES.narration };
+    }
+    if (options?.toolChoiceRequired) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "engine.error",
+            component: "engine",
+            message: "tool-required mode response missing tool call",
+            meta: { reason: "tool_required" },
+        });
+        return { reason: "tool_required", message: KICK_MESSAGES.tool_required };
+    }
+    return null;
+}
+const runtime_1 = require("../nerves/runtime");

package/dist/heart/primitives.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARNESS_BOOTSTRAP_PHASES = void 0;
+exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "inner-dialog"];