@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.71

package/dist/heart/safe-workspace.js

@@ -0,0 +1,228 @@
+"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.resetSafeWorkspaceSelection = resetSafeWorkspaceSelection;
+exports.getActiveSafeWorkspaceSelection = getActiveSafeWorkspaceSelection;
+exports.ensureSafeRepoWorkspace = ensureSafeRepoWorkspace;
+exports.resolveSafeRepoPath = resolveSafeRepoPath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const identity_1 = require("./identity");
+const runtime_1 = require("../nerves/runtime");
+let activeSelection = null;
+let cleanupHookRegistered = false;
+function defaultNow() {
+    return Date.now();
+}
+function resolveAgentName(explicit) {
+    if (explicit && explicit.trim().length > 0)
+        return explicit.trim();
+    try {
+        return (0, identity_1.getAgentName)();
+    }
+    catch {
+        return "slugger";
+    }
+}
+function runGit(cwd, args, spawnSync) {
+    return spawnSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+}
+function readStdout(result) {
+    return (result.stdout ?? Buffer.from("")).toString("utf-8").trim();
+}
+function readStderr(result) {
+    return (result.stderr ?? Buffer.from("")).toString("utf-8").trim();
+}
+function assertGitOk(result, action) {
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const detail = readStderr(result) || readStdout(result) || `exit ${result.status ?? "unknown"}`;
+        throw new Error(`${action} failed: ${detail}`);
+    }
+    return readStdout(result);
+}
+function isGitClone(repoRoot, spawnSync) {
+    const result = runGit(repoRoot, ["rev-parse", "--is-inside-work-tree"], spawnSync);
+    return result.status === 0 && readStdout(result) === "true";
+}
+function readCurrentBranch(repoRoot, spawnSync) {
+    return assertGitOk(runGit(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"], spawnSync), "git branch read");
+}
+function ensureFetchedOrigin(repoRoot, spawnSync) {
+    assertGitOk(runGit(repoRoot, ["fetch", "origin"], spawnSync), "git fetch origin");
+}
+function ensureMainFastForward(repoRoot, spawnSync) {
+    assertGitOk(runGit(repoRoot, ["pull", "--ff-only", "origin", "main"], spawnSync), "git pull --ff-only origin main");
+}
+function createDedicatedWorktree(repoRoot, workspaceRoot, branchSuffix, existsSync, mkdirSync, rmSync, spawnSync) {
+    mkdirSync(path.dirname(workspaceRoot), { recursive: true });
+    const branchName = `slugger/${branchSuffix}`;
+    if (existsSync(workspaceRoot)) {
+        rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+    assertGitOk(runGit(repoRoot, ["worktree", "add", "-B", branchName, workspaceRoot, "origin/main"], spawnSync), "git worktree add");
+    return { workspaceRoot, created: true };
+}
+function createScratchClone(workspaceRoot, cloneUrl, existsSync, mkdirSync, rmSync, spawnSync) {
+    mkdirSync(path.dirname(workspaceRoot), { recursive: true });
+    if (existsSync(workspaceRoot)) {
+        rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+    const result = spawnSync("git", ["clone", "--depth", "1", "--branch", "main", cloneUrl, workspaceRoot], {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    assertGitOk(result, "git clone");
+    return { workspaceRoot, created: true };
+}
+function registerCleanupHook(options) {
+    if (cleanupHookRegistered)
+        return;
+    cleanupHookRegistered = true;
+    process.on("exit", () => {
+        if (!activeSelection?.cleanupAfterMerge)
+            return;
+        try {
+            options.rmSync(activeSelection.workspaceRoot, { recursive: true, force: true });
+        }
+        catch {
+            // best effort
+        }
+    });
+}
+function resetSafeWorkspaceSelection(options = {}) {
+    activeSelection = null;
+    if (!options.keepCleanupHookRegistered) {
+        cleanupHookRegistered = false;
+    }
+}
+function getActiveSafeWorkspaceSelection() {
+    return activeSelection;
+}
+function ensureSafeRepoWorkspace(options = {}) {
+    if (activeSelection) {
+        return activeSelection;
+    }
+    const repoRoot = options.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const agentName = resolveAgentName(options.agentName);
+    const canonicalRepoUrl = options.canonicalRepoUrl ?? identity_1.HARNESS_CANONICAL_REPO_URL;
+    const workspaceBase = options.workspaceRoot ?? (0, identity_1.getAgentRepoWorkspacesRoot)(agentName);
+    const spawnSync = options.spawnSync ?? child_process_1.spawnSync;
+    const existsSync = options.existsSync ?? fs.existsSync;
+    const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+    const rmSync = options.rmSync ?? fs.rmSync;
+    const now = options.now ?? defaultNow;
+    const stamp = String(now());
+    registerCleanupHook({ rmSync });
+    let selection;
+    if (isGitClone(repoRoot, spawnSync)) {
+        const branch = readCurrentBranch(repoRoot, spawnSync);
+        ensureFetchedOrigin(repoRoot, spawnSync);
+        if (branch === "main") {
+            ensureMainFastForward(repoRoot, spawnSync);
+            const worktreeRoot = path.join(workspaceBase, `ouroboros-main-${stamp}`);
+            const created = createDedicatedWorktree(repoRoot, worktreeRoot, `safe-workspace-${stamp}`, existsSync, mkdirSync, rmSync, spawnSync);
+            selection = {
+                runtimeKind: "clone-main",
+                repoRoot,
+                workspaceRoot: created.workspaceRoot,
+                sourceBranch: branch,
+                sourceCloneUrl: canonicalRepoUrl,
+                cleanupAfterMerge: false,
+                created: created.created,
+                note: `running from clone on main; fast-forwarded and created dedicated worktree ${created.workspaceRoot}`,
+            };
+        }
+        else {
+            const worktreeRoot = path.join(workspaceBase, `ouroboros-origin-main-${stamp}`);
+            const created = createDedicatedWorktree(repoRoot, worktreeRoot, `safe-workspace-${stamp}`, existsSync, mkdirSync, rmSync, spawnSync);
+            selection = {
+                runtimeKind: "clone-non-main",
+                repoRoot,
+                workspaceRoot: created.workspaceRoot,
+                sourceBranch: branch,
+                sourceCloneUrl: canonicalRepoUrl,
+                cleanupAfterMerge: false,
+                created: created.created,
+                note: `running from branch ${branch}; defaulted new work from origin/main in dedicated worktree ${created.workspaceRoot}`,
+            };
+        }
+    }
+    else {
+        const scratchRoot = path.join(workspaceBase, `ouroboros-scratch-${stamp}`);
+        const created = createScratchClone(scratchRoot, canonicalRepoUrl, existsSync, mkdirSync, rmSync, spawnSync);
+        selection = {
+            runtimeKind: "installed-runtime",
+            repoRoot,
+            workspaceRoot: created.workspaceRoot,
+            sourceBranch: null,
+            sourceCloneUrl: canonicalRepoUrl,
+            cleanupAfterMerge: true,
+            created: created.created,
+            note: `running from installed runtime/wrapper; created scratch clone ${created.workspaceRoot} from ${canonicalRepoUrl}`,
+        };
+    }
+    activeSelection = selection;
+    (0, runtime_1.emitNervesEvent)({
+        component: "workspace",
+        event: "workspace.safe_repo_acquired",
+        message: "acquired safe repo workspace before local edits",
+        meta: {
+            runtimeKind: selection.runtimeKind,
+            repoRoot: selection.repoRoot,
+            workspaceRoot: selection.workspaceRoot,
+            sourceBranch: selection.sourceBranch,
+            sourceCloneUrl: selection.sourceCloneUrl,
+            cleanupAfterMerge: selection.cleanupAfterMerge,
+        },
+    });
+    return selection;
+}
+function resolveSafeRepoPath(options) {
+    const requestedPath = path.resolve(options.requestedPath);
+    const repoRoot = path.resolve(options.repoRoot ?? (0, identity_1.getRepoRoot)());
+    if (activeSelection && requestedPath.startsWith(activeSelection.workspaceRoot + path.sep)) {
+        return { selection: activeSelection, resolvedPath: requestedPath };
+    }
+    if (requestedPath !== repoRoot && !requestedPath.startsWith(repoRoot + path.sep)) {
+        return { selection: activeSelection, resolvedPath: requestedPath };
+    }
+    const selection = ensureSafeRepoWorkspace(options);
+    const relativePath = requestedPath === repoRoot ? "" : path.relative(repoRoot, requestedPath);
+    const resolvedPath = relativePath ? path.join(selection.workspaceRoot, relativePath) : selection.workspaceRoot;
+    return { selection, resolvedPath };
+}

package/dist/heart/sense-truth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSenseInventory = getSenseInventory;
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+const SENSES = [
+    { sense: "cli", label: "CLI", daemonManaged: false },
+    { sense: "teams", label: "Teams", daemonManaged: true },
+    { sense: "bluebubbles", label: "BlueBubbles", daemonManaged: true },
+];
+function configuredSenses(senses) {
+    return senses ?? {
+        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+}
+function resolveStatus(enabled, daemonManaged, runtimeInfo) {
+    if (!enabled) {
+        return "disabled";
+    }
+    if (!daemonManaged) {
+        return "interactive";
+    }
+    if (runtimeInfo?.runtime === "error") {
+        return "error";
+    }
+    if (runtimeInfo?.runtime === "running") {
+        return "running";
+    }
+    if (runtimeInfo?.configured === false) {
+        return "needs_config";
+    }
+    return "ready";
+}
+function getSenseInventory(agent, runtime = {}) {
+    const senses = configuredSenses(agent.senses);
+    const inventory = SENSES.map(({ sense, label, daemonManaged }) => {
+        const enabled = senses[sense].enabled;
+        return {
+            sense,
+            label,
+            enabled,
+            daemonManaged,
+            status: resolveStatus(enabled, daemonManaged, runtime[sense]),
+        };
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.sense_inventory_built",
+        message: "built sense inventory",
+        meta: {
+            senses: inventory.map((entry) => ({
+                sense: entry.sense,
+                enabled: entry.enabled,
+                status: entry.status,
+            })),
+        },
+    });
+    return inventory;
+}

package/dist/heart/session-activity.js

@@ -0,0 +1,169 @@
+"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.listSessionActivity = listSessionActivity;
+exports.findFreshestFriendSession = findFreshestFriendSession;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function resolveFriendName(friendId, friendsDir, agentName) {
+    if (friendId === "self")
+        return agentName;
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.name ?? friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+function parseFriendActivity(sessionPath) {
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(sessionPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(sessionPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const explicit = parsed?.state?.lastFriendActivityAt;
+        if (typeof explicit === "string") {
+            const parsedMs = Date.parse(explicit);
+            if (Number.isFinite(parsedMs)) {
+                return {
+                    lastActivityMs: parsedMs,
+                    lastActivityAt: new Date(parsedMs).toISOString(),
+                    activitySource: "friend-facing",
+                };
+            }
+        }
+    }
+    catch {
+        // fall back to file mtime below
+    }
+    return {
+        lastActivityMs: mtimeMs,
+        lastActivityAt: new Date(mtimeMs).toISOString(),
+        activitySource: "mtime-fallback",
+    };
+}
+function listSessionActivity(query) {
+    const { sessionsDir, friendsDir, agentName, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, currentSession = null, } = query;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_activity_scan",
+        message: "scanning session activity",
+        meta: {
+            sessionsDir,
+            currentSession: currentSession ? `${currentSession.friendId}/${currentSession.channel}/${currentSession.key}` : null,
+        },
+    });
+    if (!fs.existsSync(sessionsDir))
+        return [];
+    const now = Date.now();
+    const results = [];
+    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$/, "");
+                if (currentSession && friendId === currentSession.friendId && channel === currentSession.channel && key === currentSession.key) {
+                    continue;
+                }
+                const sessionPath = path.join(channelPath, keyFile);
+                const activity = parseFriendActivity(sessionPath);
+                if (!activity)
+                    continue;
+                if (now - activity.lastActivityMs > activeThresholdMs)
+                    continue;
+                results.push({
+                    friendId,
+                    friendName: resolveFriendName(friendId, friendsDir, agentName),
+                    channel,
+                    key,
+                    sessionPath,
+                    lastActivityAt: activity.lastActivityAt,
+                    lastActivityMs: activity.lastActivityMs,
+                    activitySource: activity.activitySource,
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => {
+        const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+        if (sourceDiff !== 0)
+            return sourceDiff;
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+}
+function findFreshestFriendSession(query) {
+    const { activeOnly = false, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, ...rest } = query;
+    const currentSession = rest.currentSession ?? null;
+    const all = activeOnly
+        ? listSessionActivity({ ...rest, activeThresholdMs, currentSession })
+        : listSessionActivity({ ...rest, activeThresholdMs: Number.MAX_SAFE_INTEGER, currentSession });
+    return all.find((entry) => entry.friendId === query.friendId) ?? null;
+}

package/dist/heart/session-recall.js

@@ -0,0 +1,116 @@
+"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.recallSession = recallSession;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function normalizeContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part
+        ? String(part.text ?? "")
+        : ""))
+        .filter((text) => text.length > 0)
+        .join("");
+}
+function buildSummaryInstruction(friendId, channel, trustLevel) {
+    if (friendId === "self" && channel === "inner") {
+        return "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning.";
+    }
+    return `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+}
+function clip(text, limit = 160) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length > limit ? compact.slice(0, limit - 1) + "…" : compact;
+}
+function buildSnapshot(summary, tailMessages) {
+    const lines = [`recent focus: ${clip(summary, 240)}`];
+    const latestUser = [...tailMessages].reverse().find((message) => message.role === "user")?.content;
+    const latestAssistant = [...tailMessages].reverse().find((message) => message.role === "assistant")?.content;
+    if (latestUser) {
+        lines.push(`latest user: ${clip(latestUser)}`);
+    }
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+async function recallSession(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_recall",
+        message: "recalling session transcript tail",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            messageCount: options.messageCount,
+        },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(options.sessionPath, "utf-8");
+    }
+    catch {
+        return { kind: "missing" };
+    }
+    const parsed = JSON.parse(raw);
+    const tailMessages = (parsed.messages ?? [])
+        .map((message) => ({
+        role: typeof message.role === "string" ? message.role : "",
+        content: normalizeContent(message.content),
+    }))
+        .filter((message) => message.role !== "system" && message.content.length > 0)
+        .slice(-options.messageCount);
+    if (tailMessages.length === 0) {
+        return { kind: "empty" };
+    }
+    const transcript = tailMessages
+        .map((message) => `[${message.role}] ${message.content}`)
+        .join("\n");
+    const summary = options.summarize
+        ? await options.summarize(transcript, buildSummaryInstruction(options.friendId, options.channel, options.trustLevel ?? "family"))
+        : transcript;
+    return {
+        kind: "ok",
+        transcript,
+        summary,
+        snapshot: buildSnapshot(summary, tailMessages),
+        tailMessages,
+    };
+}