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

package/dist/mind/prompt.js

@@ -0,0 +1,352 @@
+"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.resetPsycheCache = resetPsycheCache;
+exports.buildSessionSummary = buildSessionSummary;
+exports.runtimeInfoSection = runtimeInfoSection;
+exports.contextSection = contextSection;
+exports.buildSystem = buildSystem;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("../heart/core");
+const tools_1 = require("../repertoire/tools");
+const skills_1 = require("../repertoire/skills");
+const identity_1 = require("../heart/identity");
+const os = __importStar(require("os"));
+const channel_1 = require("./friends/channel");
+const runtime_1 = require("../nerves/runtime");
+const first_impressions_1 = require("./first-impressions");
+const tasks_1 = require("../repertoire/tasks");
+// Lazy-loaded psyche text cache
+let _psycheCache = null;
+function loadPsycheFile(name) {
+    try {
+        const psycheDir = path.join((0, identity_1.getAgentRoot)(), "psyche");
+        return fs.readFileSync(path.join(psycheDir, name), "utf-8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+function loadPsyche() {
+    if (_psycheCache)
+        return _psycheCache;
+    _psycheCache = {
+        soul: loadPsycheFile("SOUL.md"),
+        identity: loadPsycheFile("IDENTITY.md"),
+        lore: loadPsycheFile("LORE.md"),
+        tacitKnowledge: loadPsycheFile("TACIT.md"),
+        aspirations: loadPsycheFile("ASPIRATIONS.md"),
+    };
+    return _psycheCache;
+}
+function resetPsycheCache() {
+    _psycheCache = null;
+}
+const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
+function resolveFriendName(friendId, friendsDir, agentName) {
+    if (friendId === "self")
+        return agentName;
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const record = JSON.parse(raw);
+        return record.name ?? friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+function buildSessionSummary(options) {
+    const { sessionsDir, friendsDir, agentName, currentFriendId, currentChannel, currentKey, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, } = options;
+    if (!fs.existsSync(sessionsDir))
+        return "";
+    const now = Date.now();
+    const entries = [];
+    let friendDirs;
+    try {
+        friendDirs = fs.readdirSync(sessionsDir);
+    }
+    catch {
+        return "";
+    }
+    for (const friendId of friendDirs) {
+        const friendPath = path.join(sessionsDir, friendId);
+        let channels;
+        try {
+            channels = fs.readdirSync(friendPath);
+        }
+        catch {
+            continue;
+        }
+        for (const channel of channels) {
+            const channelPath = path.join(friendPath, channel);
+            let keys;
+            try {
+                keys = fs.readdirSync(channelPath);
+            }
+            catch {
+                continue;
+            }
+            for (const keyFile of keys) {
+                if (!keyFile.endsWith(".json"))
+                    continue;
+                const key = keyFile.replace(/\.json$/, "");
+                // Exclude current session
+                if (friendId === currentFriendId && channel === currentChannel && key === currentKey) {
+                    continue;
+                }
+                const filePath = path.join(channelPath, keyFile);
+                let mtimeMs;
+                try {
+                    mtimeMs = fs.statSync(filePath).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                if (now - mtimeMs > activeThresholdMs)
+                    continue;
+                const displayName = resolveFriendName(friendId, friendsDir, agentName);
+                entries.push({ friendId, displayName, channel, key, lastActivityMs: mtimeMs });
+            }
+        }
+    }
+    if (entries.length === 0)
+        return "";
+    // Sort by most recent first
+    entries.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
+    const lines = ["## active sessions"];
+    for (const entry of entries) {
+        const ago = formatTimeAgo(now - entry.lastActivityMs);
+        lines.push(`- ${entry.displayName}/${entry.channel}/${entry.key} (last: ${ago})`);
+    }
+    return lines.join("\n");
+}
+function formatTimeAgo(ms) {
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function soulSection() {
+    return loadPsyche().soul;
+}
+function identitySection() {
+    return loadPsyche().identity;
+}
+function loreSection() {
+    const text = loadPsyche().lore;
+    if (!text)
+        return "";
+    return `## my lore\n${text}`;
+}
+function tacitKnowledgeSection() {
+    const text = loadPsyche().tacitKnowledge;
+    if (!text)
+        return "";
+    return `## tacit knowledge\n${text}`;
+}
+function aspirationsSection() {
+    const text = loadPsyche().aspirations;
+    if (!text)
+        return "";
+    return `## my aspirations\n${text}`;
+}
+function runtimeInfoSection(channel) {
+    const lines = [];
+    const agentName = (0, identity_1.getAgentName)();
+    lines.push(`## runtime`);
+    lines.push(`agent: ${agentName}`);
+    lines.push(`cwd: ${process.cwd()}`);
+    lines.push(`channel: ${channel}`);
+    lines.push(`i can read and modify my own source code.`);
+    if (channel === "cli") {
+        lines.push("i introduce myself on boot with a fun random greeting.");
+    }
+    else {
+        lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");
+    }
+    return lines.join("\n");
+}
+function providerSection() {
+    return `## my provider\n${(0, core_1.getProviderDisplayLabel)()}`;
+}
+function dateSection() {
+    const today = new Date().toISOString().slice(0, 10);
+    return `current date: ${today}`;
+}
+function toolsSection(channel, options) {
+    const channelTools = (0, tools_1.getToolsForChannel)((0, channel_1.getChannelCapabilities)(channel));
+    const activeTools = (options?.toolChoiceRequired ?? true) ? [...channelTools, tools_1.finalAnswerTool] : channelTools;
+    const list = activeTools
+        .map((t) => `- ${t.function.name}: ${t.function.description}`)
+        .join("\n");
+    return `## my tools\n${list}`;
+}
+function skillsSection() {
+    const names = (0, skills_1.listSkills)() || [];
+    if (!names.length)
+        return "";
+    return `## my skills (use load_skill to activate)\n${names.join(", ")}`;
+}
+function taskBoardSection() {
+    try {
+        const board = (0, tasks_1.getTaskModule)().getBoard().compact.trim();
+        if (!board)
+            return "";
+        return `## task board\n${board}`;
+    }
+    catch {
+        return "";
+    }
+}
+function memoryFriendToolContractSection() {
+    return `## memory and friend tool contracts
+1. \`save_friend_note\` — When I learn something about a person - a preference, a tool setting, a personal detail, or how they like to work - I call \`save_friend_note\` immediately. This is how I build knowledge about people.
+2. \`memory_save\` — When I learn something general - about a project, codebase, system, decision, or anything I might need later that isn't about a specific person - I call \`memory_save\`. When in doubt, I save it.
+3. \`get_friend_note\` — When I need to check what I know about someone who isn't in this conversation - cross-referencing before mentioning someone, or checking context about a person someone else brought up - I call \`get_friend_note\`.
+4. \`memory_search\` — When I need to recall something I learned before - a topic comes up and I want to check what I know - I call \`memory_search\`.
+
+## what's already in my context
+- My active friend's notes are auto-loaded (I don't need \`get_friend_note\` for the person I'm talking to).
+- Associative recall auto-injects relevant facts (but \`memory_search\` is there when I need something specific).
+- My psyche files (SOUL, IDENTITY, TACIT, LORE, ASPIRATIONS) are always loaded - I already know who I am.
+- My task board is always loaded - I already know my work.`;
+}
+function toolBehaviorSection(options) {
+    if (!(options?.toolChoiceRequired ?? true))
+        return "";
+    return `## tool behavior
+tool_choice is set to "required" -- i must call a tool on every turn.
+- need more information? i call a tool.
+- ready to respond to the user? i call \`final_answer\`.
+\`final_answer\` is a tool call -- it satisfies the tool_choice requirement.
+\`final_answer\` must be the ONLY tool call in that turn. do not combine it with other tool calls.
+do NOT call \`get_current_time\` or other no-op tools just before \`final_answer\`. if i am done, i call \`final_answer\` directly.`;
+}
+function contextSection(context) {
+    if (!context)
+        return "";
+    const lines = ["## friend context"];
+    const friendOrIdentity = context.friend;
+    if (!friendOrIdentity)
+        return "";
+    const emailId = friendOrIdentity.externalIds.find(e => e.provider === "aad");
+    const idDisplay = emailId
+        ? `${friendOrIdentity.name} (${emailId.externalId})`
+        : friendOrIdentity.name;
+    lines.push(`friend: ${idDisplay}`);
+    // Channel
+    const ch = context.channel;
+    const traits = [];
+    if (ch.supportsMarkdown)
+        traits.push("markdown");
+    if (!ch.supportsStreaming)
+        traits.push("no streaming");
+    if (ch.supportsStreaming)
+        traits.push("streaming");
+    if (ch.supportsRichCards)
+        traits.push("rich cards");
+    // maxMessageLength constraint removed -- chunked streaming handles delivery,
+    // error recovery splits on failure. No artificial limits in the prompt.
+    /* v8 ignore next -- empty-traits branch unreachable: streaming/no-streaming always adds a trait @preserve */
+    lines.push(`channel: ${ch.channel}${traits.length ? ` (${traits.join(", ")})` : ""}`);
+    // Friend record (guaranteed non-null here -- checked above)
+    const friend = context.friend;
+    // Always-on directives (permanent in contextSection, never gated by token threshold)
+    lines.push("");
+    lines.push("my conversation memory is ephemeral -- it resets between sessions. anything i learn about my friend, i save with save_friend_note so future me remembers.");
+    lines.push("the conversation is my source of truth. my notes are a journal for future me -- they may be stale or incomplete.");
+    lines.push("when i learn something that might invalidate an existing note, i check related notes and update or override any that are stale.");
+    lines.push("i save ANYTHING i learn about my friend immediately with save_friend_note -- names, preferences, what they do, what they care about. when in doubt, save it. saving comes BEFORE responding: i call save_friend_note first, then final_answer on the next turn.");
+    // Onboarding instructions (only below token threshold -- drop once exceeded)
+    const impressions = (0, first_impressions_1.getFirstImpressions)(friend);
+    if (impressions) {
+        lines.push(impressions);
+    }
+    // Friend notes (from FriendRecord -- rendered in system prompt, NOT toolPreferences)
+    if (Object.keys(friend.notes).length > 0) {
+        lines.push("");
+        lines.push("## what i know about this friend");
+        for (const [key, entry] of Object.entries(friend.notes)) {
+            lines.push(`- ${key}: [${entry.savedAt.slice(0, 10)}] ${entry.value}`);
+        }
+    }
+    return lines.join("\n");
+}
+async function buildSystem(channel = "cli", options, context) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "buildSystem started",
+        meta: { channel, has_context: Boolean(context), tool_choice_required: Boolean(options?.toolChoiceRequired) },
+    });
+    const system = [
+        soulSection(),
+        identitySection(),
+        loreSection(),
+        tacitKnowledgeSection(),
+        aspirationsSection(),
+        runtimeInfoSection(channel),
+        providerSection(),
+        dateSection(),
+        toolsSection(channel, options),
+        skillsSection(),
+        taskBoardSection(),
+        buildSessionSummary({
+            sessionsDir: path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions"),
+            friendsDir: path.join((0, identity_1.getAgentRoot)(), "friends"),
+            agentName: (0, identity_1.getAgentName)(),
+            currentFriendId: context?.friend?.id,
+            currentChannel: channel,
+            currentKey: "session",
+        }),
+        memoryFriendToolContractSection(),
+        toolBehaviorSection(options),
+        contextSection(context),
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_end",
+        component: "mind",
+        message: "buildSystem completed",
+        meta: { channel },
+    });
+    return system;
+}

package/dist/mind/token-estimate.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__internal = void 0;
+exports.estimateTokensForMessage = estimateTokensForMessage;
+exports.estimateTokensForMessages = estimateTokensForMessages;
+const runtime_1 = require("../nerves/runtime");
+// A conservative, dependency-free token estimator.
+// Goal: avoid context overflows without pulling in tokenizer deps.
+const CHARS_PER_TOKEN = 4;
+const PER_MESSAGE_OVERHEAD_TOKENS = 10;
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return "";
+    }
+}
+function countCharsInContent(content) {
+    if (!content)
+        return 0;
+    if (typeof content === "string")
+        return content.length;
+    if (Array.isArray(content)) {
+        let total = 0;
+        for (const part of content) {
+            if (!part)
+                continue;
+            if (typeof part === "string") {
+                total += part.length;
+                continue;
+            }
+            if (typeof part === "object") {
+                // Common OpenAI content-part shapes: {type:"text", text:"..."}
+                // Be defensive and only count obvious text-like fields.
+                const p = part;
+                if (typeof p.text === "string")
+                    total += p.text.length;
+                if (typeof p.content === "string")
+                    total += p.content.length;
+                if (typeof p.name === "string")
+                    total += p.name.length;
+                // As a fallback, stringify small-ish objects. This is conservative.
+                if (total === 0)
+                    total += safeStringify(p).length;
+            }
+        }
+        return total;
+    }
+    if (typeof content === "object") {
+        const c = content;
+        if (typeof c.text === "string")
+            return c.text.length;
+        if (typeof c.content === "string")
+            return c.content.length;
+        return safeStringify(content).length;
+    }
+    return 0;
+}
+function countCharsInToolCalls(toolCalls) {
+    if (!Array.isArray(toolCalls))
+        return 0;
+    let total = 0;
+    for (const tc of toolCalls) {
+        if (!tc || typeof tc !== "object")
+            continue;
+        const t = tc;
+        if (typeof t.id === "string")
+            total += t.id.length;
+        if (typeof t.type === "string")
+            total += t.type.length;
+        if (t.function && typeof t.function === "object") {
+            if (typeof t.function.name === "string")
+                total += t.function.name.length;
+            if (typeof t.function.arguments === "string")
+                total += t.function.arguments.length;
+            else if (t.function.arguments != null)
+                total += safeStringify(t.function.arguments).length;
+        }
+    }
+    return total;
+}
+function estimateTokensForMessage(msg) {
+    try {
+        let chars = 0;
+        // role/name/tool_call_id count as metadata.
+        const m = msg;
+        if (typeof m.role === "string")
+            chars += m.role.length;
+        if (typeof m.name === "string")
+            chars += m.name.length;
+        if (typeof m.tool_call_id === "string")
+            chars += m.tool_call_id.length;
+        chars += countCharsInContent(m.content);
+        chars += countCharsInToolCalls(m.tool_calls);
+        return PER_MESSAGE_OVERHEAD_TOKENS + Math.ceil(chars / CHARS_PER_TOKEN);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.token_estimate_error",
+            level: "warn",
+            message: "token estimation failed; using overhead fallback",
+            meta: { reason: error instanceof Error ? error.message : String(error) },
+        });
+        // estimator must never throw
+        return PER_MESSAGE_OVERHEAD_TOKENS;
+    }
+}
+function estimateTokensForMessages(msgs) {
+    let total = 0;
+    for (const msg of msgs)
+        total += estimateTokensForMessage(msg);
+    return total;
+}
+exports.__internal = {
+    CHARS_PER_TOKEN,
+    PER_MESSAGE_OVERHEAD_TOKENS,
+};

package/dist/nerves/cli-logging.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCliRuntimeLogger = configureCliRuntimeLogger;
+const config_1 = require("../heart/config");
+const nerves_1 = require("../nerves");
+const runtime_1 = require("./runtime");
+const runtime_2 = require("./runtime");
+function resolveCliSinks(sinks) {
+    const requested = sinks && sinks.length > 0 ? sinks : ["terminal", "ndjson"];
+    return [...new Set(requested)];
+}
+function configureCliRuntimeLogger(_friendId, options = {}) {
+    const sinkKinds = resolveCliSinks(options.sinks);
+    const sinks = sinkKinds.map((sinkKind) => {
+        if (sinkKind === "terminal") {
+            return (0, nerves_1.createTerminalSink)();
+        }
+        return (0, nerves_1.createNdjsonFileSink)((0, config_1.logPath)("cli", "runtime"));
+    });
+    const logger = (0, nerves_1.createLogger)({
+        level: options.level ?? "info",
+        sinks,
+    });
+    (0, runtime_2.setRuntimeLogger)(logger);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.cli_logger_configured",
+        message: "cli runtime logger configured",
+        meta: { sinks: sinkKinds, level: options.level ?? "info" },
+    });
+}

package/dist/nerves/coverage/audit-rules.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Per-test audit rules for nerves event coverage.
+ *
+ * Rule 1: every-test-emits -- every test must emit at least one event
+ * Rule 2: start/end pairing -- _start events must have matching _end or _error
+ * Rule 3: error context -- error-level events must have non-empty meta
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEveryTestEmits = checkEveryTestEmits;
+exports.checkStartEndPairing = checkStartEndPairing;
+exports.checkErrorContext = checkErrorContext;
+/**
+ * Rule 1: Every test must emit at least one nerves event.
+ */
+function checkEveryTestEmits(data) {
+    if (!data || typeof data !== "object") {
+        return { status: "fail", total_tests: 0, silent_tests: [] };
+    }
+    const entries = Object.entries(data);
+    const silent = entries
+        .filter(([, events]) => !Array.isArray(events) || events.length === 0)
+        .map(([name]) => name);
+    return {
+        status: silent.length === 0 ? "pass" : "fail",
+        total_tests: entries.length,
+        silent_tests: silent,
+    };
+}
+/**
+ * Rule 2: _start events must have matching _end or _error within the same test.
+ */
+function checkStartEndPairing(data) {
+    if (!data || typeof data !== "object") {
+        return { status: "fail", unmatched: [] };
+    }
+    const unmatched = [];
+    for (const [testName, events] of Object.entries(data)) {
+        if (!Array.isArray(events))
+            continue;
+        const eventNames = events.map((e) => e.event);
+        const startEvents = eventNames.filter((name) => name.endsWith("_start"));
+        for (const startEvent of startEvents) {
+            const prefix = startEvent.slice(0, -"_start".length);
+            const hasEnd = eventNames.some((name) => name === `${prefix}_end`);
+            const hasError = eventNames.some((name) => name === `${prefix}_error`);
+            if (!hasEnd && !hasError) {
+                unmatched.push(`${testName}: ${startEvent} has no matching ${prefix}_end or ${prefix}_error`);
+            }
+        }
+    }
+    return {
+        status: unmatched.length === 0 ? "pass" : "fail",
+        unmatched,
+    };
+}
+/**
+ * Rule 3: Error-level events must have non-empty meta (at least one key).
+ */
+function checkErrorContext(data) {
+    if (!data || typeof data !== "object") {
+        return { status: "fail", violations: [] };
+    }
+    const violations = [];
+    for (const [testName, events] of Object.entries(data)) {
+        if (!Array.isArray(events))
+            continue;
+        for (const event of events) {
+            if (event.level !== "error")
+                continue;
+            const meta = event.meta;
+            if (!meta || typeof meta !== "object" || Object.keys(meta).length === 0) {
+                violations.push(`${testName}: error event '${event.event}' has empty or missing meta`);
+            }
+        }
+    }
+    return {
+        status: violations.length === 0 ? "pass" : "fail",
+        violations,
+    };
+}