@a5c-ai/babysitter-sdk 0.0.184 → 0.0.185

package/dist/harness/ohMyPi.js

@@ -1,31 +1,167 @@
 "use strict";
-/**
- * Oh-My-Pi harness adapter.
- *
- * Oh-my-pi (omp) is a fork of pi that shares the same environment variables,
- * session conventions, and hook mechanisms. This adapter wraps the pi adapter
- * with a different name so the registry can distinguish between the two when
- * both are installed.
- */
+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.createOhMyPiAdapter = createOhMyPiAdapter;
-const pi_1 = require("./pi");
+const path = __importStar(require("node:path"));
+const types_1 = require("./types");
+const context_1 = require("../prompts/context");
+const config_1 = require("../config");
+const session_1 = require("../session");
 const installSupport_1 = require("./installSupport");
-/**
- * Create an adapter for oh-my-pi.
- *
- * Reuses the pi adapter's implementation entirely — same env vars, same
- * session binding, same hook handling — but reports `name: "oh-my-pi"`.
- */
+function resolveOhMyPiPluginRoot(args = {}) {
+    const root = args.pluginRoot || process.env.OMP_PLUGIN_ROOT;
+    return root ? path.resolve(root) : undefined;
+}
+function resolveOhMyPiStateDir(args) {
+    if (args.stateDir)
+        return path.resolve(args.stateDir);
+    return (0, config_1.getGlobalStateDir)();
+}
+function resolveOhMyPiSessionId(parsed) {
+    if (parsed.sessionId)
+        return parsed.sessionId;
+    if (process.env.BABYSITTER_SESSION_ID)
+        return process.env.BABYSITTER_SESSION_ID;
+    if (process.env.OMP_SESSION_ID)
+        return process.env.OMP_SESSION_ID;
+    return undefined;
+}
+async function bindOhMyPiSession(opts) {
+    const stateDir = resolveOhMyPiStateDir({
+        stateDir: opts.stateDir,
+        pluginRoot: opts.pluginRoot,
+    });
+    const stateFile = (0, session_1.getSessionFilePath)(stateDir, opts.sessionId);
+    if (await (0, session_1.sessionFileExists)(stateFile)) {
+        const existing = await (0, session_1.readSessionFile)(stateFile);
+        if (existing.state.runId && existing.state.runId !== opts.runId) {
+            return {
+                harness: "oh-my-pi",
+                sessionId: opts.sessionId,
+                stateFile,
+                error: `Session already associated with run ${existing.state.runId}`,
+            };
+        }
+        await (0, session_1.updateSessionState)(stateFile, { active: true, runId: opts.runId }, existing);
+        return {
+            harness: "oh-my-pi",
+            sessionId: opts.sessionId,
+            stateFile,
+        };
+    }
+    const now = (0, session_1.getCurrentTimestamp)();
+    const state = {
+        active: true,
+        iteration: 1,
+        maxIterations: opts.maxIterations ?? 256,
+        runId: opts.runId,
+        startedAt: now,
+        lastIterationAt: now,
+        iterationTimes: [],
+    };
+    await (0, session_1.writeSessionFile)(stateFile, state, opts.prompt);
+    return {
+        harness: "oh-my-pi",
+        sessionId: opts.sessionId,
+        stateFile,
+    };
+}
+function writeNoopHookResult() {
+    process.stdout.write("{}\n");
+}
+async function installOhMyPiPlugin(options) {
+    const packageArgs = ["install"];
+    if (options.workspace) {
+        packageArgs.push("--workspace", path.resolve(options.workspace));
+    }
+    else {
+        packageArgs.push("--global");
+    }
+    return (0, installSupport_1.runPackageBinaryViaNpx)({
+        harness: "oh-my-pi",
+        packageName: "@a5c-ai/babysitter-omp",
+        packageArgs,
+        summary: options.workspace
+            ? "Install the published Babysitter oh-my-pi package for the target workspace."
+            : "Install the published Babysitter oh-my-pi package into the user profile.",
+        options,
+        env: process.env,
+    });
+}
 function createOhMyPiAdapter() {
-    const piAdapter = (0, pi_1.createPiAdapter)();
     return {
-        ...piAdapter,
         name: "oh-my-pi",
         isActive() {
-            // oh-my-pi shares OMP_* env vars with pi, but we only claim active
-            // if OMP_PLUGIN_ROOT or OMP_SESSION_ID is set (not PI_* variants)
-            return !!(process.env.OMP_SESSION_ID || process.env.OMP_PLUGIN_ROOT);
+            return !!(process.env.BABYSITTER_SESSION_ID ||
+                process.env.OMP_SESSION_ID ||
+                process.env.OMP_PLUGIN_ROOT);
+        },
+        autoResolvesSessionId() {
+            return true;
+        },
+        getMissingSessionIdHint() {
+            return "oh-my-pi should provide OMP_SESSION_ID when the Babysitter package is active.";
+        },
+        supportsHookType(_hookType) {
+            return false;
+        },
+        getUnsupportedHookMessage(hookType) {
+            return `oh-my-pi does not use babysitter hook:run for "${hookType}". Use the oh-my-pi package skills and extension bridge instead.`;
+        },
+        resolveSessionId(parsed) {
+            return resolveOhMyPiSessionId(parsed);
+        },
+        resolveStateDir(args) {
+            return resolveOhMyPiStateDir(args);
+        },
+        resolvePluginRoot(args) {
+            return resolveOhMyPiPluginRoot(args);
+        },
+        bindSession(opts) {
+            return bindOhMyPiSession(opts);
+        },
+        handleStopHook(_args) {
+            writeNoopHookResult();
+            return Promise.resolve(0);
+        },
+        handleSessionStartHook(_args) {
+            writeNoopHookResult();
+            return Promise.resolve(0);
+        },
+        findHookDispatcherPath(_startCwd) {
+            return null;
         },
         installHarness(options) {
             return (0, installSupport_1.installCliViaNpm)({
@@ -37,10 +173,13 @@ function createOhMyPiAdapter() {
             });
         },
         installPlugin(options) {
-            return (0, pi_1.installPiFamilyPlugin)({
-                harness: "oh-my-pi",
-                options,
-            });
+            return installOhMyPiPlugin(options);
+        },
+        getCapabilities() {
+            return [types_1.HarnessCapability.Programmatic, types_1.HarnessCapability.SessionBinding, types_1.HarnessCapability.HeadlessPrompt, types_1.HarnessCapability.Mcp];
+        },
+        getPromptContext(opts) {
+            return (0, context_1.createOhMyPiContext)(opts);
         },
     };
 }

package/dist/harness/opencode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * OpenCode harness adapter.
+ *
+ * Centralizes all OpenCode-specific behaviors:
+ *   - Session ID resolution (BABYSITTER_SESSION_ID, self-injected via shell.env hook)
+ *   - State directory conventions (global state dir by default)
+ *   - Session binding (run:create → state file with run association)
+ *   - Minimal stop hook handler (no native stop hook — in-turn model)
+ *   - Session-start hook handler (baseline state file creation)
+ *
+ * OpenCode characteristics:
+ *   - Go binary, CLI command: `opencode`
+ *   - Config directory: `.opencode/`
+ *   - Plugin system: JS/TS modules in `.opencode/plugins/` with hooks for
+ *     `tool.execute.before/after`, `session.idle`, `session.created`, `shell.env`
+ *   - NO blocking stop hook — `session.idle` is fire-and-forget
+ *   - Programmatic API: `@opencode-ai/sdk` with `session.create()`,
+ *     `session.prompt()`, `event.subscribe()` (SSE)
+ *   - Env vars: Does NOT inject distinctive env vars into plugins — weak
+ *     caller detection. The babysitter plugin self-injects
+ *     `BABYSITTER_SESSION_ID` via the `shell.env` hook.
+ *   - Loop mechanism: in-turn (no stop-hook, must use SDK loop driver or
+ *     in-turn orchestration)
+ *   - Capabilities: [HeadlessPrompt] only
+ */
+import type { HarnessAdapter } from "./types";
+export declare function createOpenCodeAdapter(): HarnessAdapter;
+//# sourceMappingURL=opencode.d.ts.map

package/dist/harness/opencode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/harness/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAkBH,OAAO,KAAK,EACV,cAAc,EAMf,MAAM,SAAS,CAAC;AA+fjB,wBAAgB,qBAAqB,IAAI,cAAc,CAsHtD"}