@a5c-ai/babysitter-omp 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# @a5c-ai/babysitter-omp
+
+Babysitter integration plugin for `oh-my-pi`. This package owns the
+oh-my-pi-specific install surface, command docs, and skill wiring while sharing
+compatible runtime internals with the upstream Pi-family.
+
+## Integration Model
+
+The oh-my-pi plugin keeps Babysitter as the orchestration layer for omp
+sessions:
+
+- session lifecycle hooks prepare and bind run state
+- omp commands start or resume runs
+- the harness advances one orchestration phase at a time
+- the plugin runtime records effect outcomes and updates the run state
+- completion requires the emitted `completionProof`
+
+## Installation
+
+Install the published oh-my-pi plugin globally:
+
+```bash
+npx @a5c-ai/babysitter-omp install
+```
+
+Install into a specific workspace instead of the user profile:
+
+```bash
+npx @a5c-ai/babysitter-omp install --workspace /path/to/repo
+```
+
+Or use the Babysitter SDK helper:
+
+```bash
+babysitter harness:install-plugin oh-my-pi
+babysitter harness:install-plugin oh-my-pi --workspace /path/to/repo
+```
+
+This package installs under:
+
+```text
+~/.omp/plugins/babysitter
+```
+
+If the workspace does not already have an active process-library binding, the
+installer bootstraps the shared global SDK process library automatically:
+
+```bash
+babysitter process-library:active --json
+```
+
+## Commands
+
+The plugin exposes oh-my-pi-facing Babysitter commands such as:
+
+- `/babysitter:call`
+- `/babysitter:status`
+- `/babysitter:resume`
+- `/babysitter:doctor`
+
+## Troubleshooting
+
+- `babysitter harness:discover --json` is the supported way to verify whether
+  `oh-my-pi` is installed from the current environment.
+- If discovery reports `oh-my-pi` as installed but a direct invocation fails,
+  validate the current shell `PATH` first with `where omp` on Windows.
+
+## Tests
+
+```bash
+cd plugins/babysitter-omp
+npm test
+npm run test:integration
+npm run test:harness
+npm run test:tui
+```
+
+## License
+
+MIT

package/bin/cli.cjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function printUsage() {
+  console.error([
+    'Usage:',
+    '  babysitter-omp install [--global]',
+    '  babysitter-omp install --workspace [path]',
+    '  babysitter-omp uninstall [--global]',
+    '  babysitter-omp uninstall --workspace [path]',
+  ].join('\n'));
+}
+
+function parseArgs(argv) {
+  let workspace = null;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--workspace') {
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        workspace = path.resolve(next);
+        i += 1;
+      } else {
+        workspace = process.cwd();
+      }
+      continue;
+    }
+    if (arg === '--global') {
+      workspace = null;
+      continue;
+    }
+    throw new Error(`unknown argument: ${arg}`);
+  }
+
+  return { workspace };
+}
+
+function runNodeScript(scriptPath, args) {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: process.env,
+  });
+  process.exitCode = result.status ?? 1;
+}
+
+function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  if (!command || command === '--help' || command === '-h' || command === 'help') {
+    printUsage();
+    process.exitCode = command ? 0 : 1;
+    return;
+  }
+
+  if (command !== 'install' && command !== 'uninstall') {
+    printUsage();
+    process.exitCode = 1;
+    return;
+  }
+
+  const parsed = parseArgs(rest);
+  const args = [];
+  if (parsed.workspace) {
+    args.push('--workspace', parsed.workspace);
+  } else {
+    args.push('--global');
+  }
+
+  runNodeScript(path.join(PACKAGE_ROOT, 'bin', `${command}.cjs`), args);
+}
+
+main();

package/bin/install.cjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const INSTALL_ENTRIES = [
+  { source: 'package.json', required: true },
+  { source: 'extensions', required: true },
+  { source: 'skills', required: true },
+  { source: 'commands', required: true },
+  { source: 'scripts', required: true },
+];
+
+function parseArgs(argv) {
+  const args = {
+    workspace: null,
+  };
+  for (let i = 2; i < argv.length; i += 1) {
+    if (argv[i] === '--workspace' && argv[i + 1]) {
+      args.workspace = path.resolve(argv[++i]);
+    } else if (argv[i] === '--global') {
+      args.workspace = null;
+    } else {
+      throw new Error(`unknown argument: ${argv[i]}`);
+    }
+  }
+  return args;
+}
+
+function getGlobalStateDir() {
+  if (process.env.BABYSITTER_GLOBAL_STATE_DIR) {
+    return path.resolve(process.env.BABYSITTER_GLOBAL_STATE_DIR);
+  }
+  return path.join(os.homedir(), '.a5c');
+}
+
+function getPluginRoot(args) {
+  const base = args.workspace ? path.resolve(args.workspace) : os.homedir();
+  return path.join(base, '.omp', 'plugins', 'babysitter');
+}
+
+function copyRecursive(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      if (['node_modules', '.git', 'test', '.gitignore', 'state'].includes(entry)) continue;
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function resolveBabysitterCommand(packageRoot) {
+  if (process.env.BABYSITTER_SDK_CLI) {
+    return {
+      command: process.execPath,
+      argsPrefix: [path.resolve(process.env.BABYSITTER_SDK_CLI)],
+    };
+  }
+  try {
+    return {
+      command: process.execPath,
+      argsPrefix: [
+        require.resolve('@a5c-ai/babysitter-sdk/dist/cli/main.js', {
+          paths: [packageRoot],
+        }),
+      ],
+    };
+  } catch {
+    return {
+      command: 'babysitter',
+      argsPrefix: [],
+    };
+  }
+}
+
+function runBabysitterCli(packageRoot, cliArgs) {
+  const resolved = resolveBabysitterCommand(packageRoot);
+  const result = spawnSync(resolved.command, [...resolved.argsPrefix, ...cliArgs], {
+    cwd: packageRoot,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    env: process.env,
+  });
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    const stdout = (result.stdout || '').trim();
+    throw new Error(
+      `babysitter ${cliArgs.join(' ')} failed` +
+      (stderr ? `: ${stderr}` : stdout ? `: ${stdout}` : ''),
+    );
+  }
+  return result.stdout;
+}
+
+function ensureGlobalProcessLibrary() {
+  const active = JSON.parse(
+    runBabysitterCli(
+      PACKAGE_ROOT,
+      ['process-library:active', '--state-dir', getGlobalStateDir(), '--json'],
+    ),
+  );
+  console.log(`[babysitter]   process library: ${active.binding?.dir}`);
+}
+
+function installEntry(pluginRoot, entry) {
+  const src = path.join(PACKAGE_ROOT, entry.source);
+  const dest = path.join(pluginRoot, entry.source);
+  if (!fs.existsSync(src)) {
+    if (entry.required) throw new Error(`required install payload is missing: ${src}`);
+    return;
+  }
+  copyRecursive(src, dest);
+  console.log(`[babysitter]   ${entry.source}${fs.statSync(src).isDirectory() ? '/' : ''}`);
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const pluginRoot = getPluginRoot(args);
+  console.log(`[babysitter] Installing oh-my-pi plugin to ${pluginRoot}`);
+
+  try {
+    fs.rmSync(pluginRoot, { recursive: true, force: true });
+    fs.mkdirSync(pluginRoot, { recursive: true });
+    for (const entry of INSTALL_ENTRIES) {
+      installEntry(pluginRoot, entry);
+    }
+    fs.mkdirSync(path.join(pluginRoot, 'state'), { recursive: true });
+    ensureGlobalProcessLibrary();
+    console.log('[babysitter] Installation complete!');
+  } catch (err) {
+    console.error(`[babysitter] Failed to install plugin files: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/bin/uninstall.cjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function parseArgs(argv) {
+  const args = {
+    workspace: null,
+  };
+  for (let i = 2; i < argv.length; i += 1) {
+    if (argv[i] === '--workspace' && argv[i + 1]) {
+      args.workspace = path.resolve(argv[++i]);
+    } else if (argv[i] === '--global') {
+      args.workspace = null;
+    } else {
+      throw new Error(`unknown argument: ${argv[i]}`);
+    }
+  }
+  return args;
+}
+
+function getPluginRoot(args) {
+  const base = args.workspace ? path.resolve(args.workspace) : os.homedir();
+  return path.join(base, '.omp', 'plugins', 'babysitter');
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const pluginRoot = getPluginRoot(args);
+  if (!fs.existsSync(pluginRoot)) {
+    console.log('[babysitter] Nothing to uninstall.');
+    return;
+  }
+  fs.rmSync(pluginRoot, { recursive: true, force: true });
+  console.log(`[babysitter] Removed ${pluginRoot}`);
+}
+
+main();

package/commands/babysitter-call.md

@@ -0,0 +1,12 @@
+---
+name: babysitter:call
+description: Start a babysitter orchestration run
+arguments:
+  - name: prompt
+    description: The task to orchestrate
+    required: true
+---
+
+Start a babysitter orchestration run. Creates a new run using the SDK, binds it to the current session, and begins iteration.
+
+This command initialises a fresh babysitter run with the given prompt, associates it with the active oh-my-pi session, and kicks off the first orchestration iteration. The loop driver will continue iterating automatically on subsequent `agent_end` events until the run completes, fails, or a guard trips.

package/commands/babysitter-doctor.md

@@ -0,0 +1,10 @@
+---
+name: babysitter:doctor
+description: Diagnose the health of a babysitter run
+arguments:
+  - name: runId
+    description: Optional run ID to diagnose (defaults to the active run)
+    required: false
+---
+
+Run diagnostic checks against a babysitter run to identify potential issues. Inspects run metadata, journal integrity, state cache, lock files, and effect health.

package/commands/babysitter-resume.md

@@ -0,0 +1,16 @@
+---
+name: babysitter:resume
+description: Resume a previously stopped or interrupted babysitter run
+arguments:
+  - name: runId
+    description: The run ID to resume
+    required: true
+---
+
+Resume an existing babysitter orchestration run that was previously stopped, interrupted, or is in a waiting state. Re-binds the run to the current session and continues iteration from where it left off.
+
+## Behaviour
+
+1. Locates the run directory for the given run ID.
+2. Reads run metadata and journal to determine current state.
+3. Re-binds the run to the active oh-my-pi session.

package/commands/babysitter-status.md

@@ -0,0 +1,15 @@
+---
+name: babysitter:status
+description: Check the status of the active babysitter run
+arguments:
+  - name: runId
+    description: Optional run ID to check (defaults to the active run)
+    required: false
+---
+
+Check the current status of a babysitter orchestration run.
+
+## Notes
+
+- When called without arguments, reports on the run bound to the current session.
+- If discovery reports `oh-my-pi` as installed but direct invocation fails, validate `where omp`.

package/extensions/babysitter/cli-wrapper.ts

@@ -0,0 +1,95 @@
+/**
+ * Babysitter CLI invocation helper.
+ *
+ * Spawns the `babysitter` CLI as a child process, captures stdout/stderr,
+ * parses JSON output, and surfaces structured errors.  Every other module
+ * that needs to talk to babysitter goes through here so there is exactly
+ * one place to handle timeouts, env vars, and error mapping.
+ *
+ * @deprecated Use `sdk-bridge.ts` instead.  This module spawns a child
+ * process to communicate with babysitter.  The SDK bridge imports the
+ * runtime directly, avoiding subprocess overhead and JSON parsing.
+ * This file is retained only for backward compatibility and will be
+ * removed in a future release.
+ *
+ * @module cli-wrapper
+ */
+
+import { execFile } from 'node:child_process';
+import { CLI_COMMAND, CLI_TIMEOUT_MS } from './constants';
+
+/** Structured result from a CLI invocation. */
+export interface CliResult<T = unknown> {
+  /** Whether the process exited with code 0. */
+  success: boolean;
+  /** Parsed JSON from stdout (when `--json` flag is used). */
+  data?: T;
+  /** Raw stdout string. */
+  stdout: string;
+  /** Raw stderr string. */
+  stderr: string;
+  /** Process exit code (null when killed by signal). */
+  exitCode: number | null;
+}
+
+/**
+ * Invoke the babysitter CLI with the given command and arguments.
+ *
+ * The `--json` flag is appended automatically so callers always get
+ * machine-readable output.  Errors are captured rather than thrown --
+ * inspect `CliResult.success` to decide how to proceed.
+ *
+ * @param command - The babysitter sub-command (e.g. `"run:iterate"`).
+ * @param args    - Additional positional / flag arguments.
+ * @param options - Optional overrides for timeout and env.
+ * @returns A promise that resolves to the structured CLI result.
+ *
+ * @example
+ * ```ts
+ * const res = await runCli('run:iterate', ['--run-id', runId]);
+ * if (res.success && res.data) {
+ *   console.log(res.data);
+ * }
+ * ```
+ */
+export async function runCli<T = unknown>(
+  command: string,
+  args: string[] = [],
+  options: { timeoutMs?: number; env?: Record<string, string> } = {},
+): Promise<CliResult<T>> {
+  const timeout = options.timeoutMs ?? CLI_TIMEOUT_MS;
+  const fullArgs = [command, '--json', ...args];
+
+  return new Promise<CliResult<T>>((resolve) => {
+    const child = execFile(
+      CLI_COMMAND,
+      fullArgs,
+      {
+        timeout,
+        maxBuffer: 10 * 1024 * 1024, // 10 MiB
+        env: { ...process.env, ...options.env },
+      },
+      (error, stdout, stderr) => {
+        const exitCode =
+          error && 'code' in error ? (error.code as number | null) : child.exitCode;
+
+        let data: T | undefined;
+        try {
+          if (stdout.trim()) {
+            data = JSON.parse(stdout) as T;
+          }
+        } catch {
+          // stdout was not valid JSON -- leave data undefined
+        }
+
+        resolve({
+          success: exitCode === 0,
+          data,
+          stdout: String(stdout),
+          stderr: String(stderr),
+          exitCode: typeof exitCode === 'number' ? exitCode : null,
+        });
+      },
+    );
+  });
+}

package/extensions/babysitter/constants.ts

@@ -0,0 +1,77 @@
+/**
+ * Configuration constants for the babysitter oh-my-pi extension.
+ *
+ * Centralises magic strings, default timeouts, environment variable names,
+ * and widget keys so the rest of the extension can remain blissfully ignorant
+ * of where these values come from.
+ *
+ * @module constants
+ */
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+/** Path (or bare command name) used to invoke the babysitter CLI. */
+export const CLI_COMMAND = process.env['BABYSITTER_CLI_PATH'] ?? 'babysitter';
+
+/** Default timeout (ms) applied to every CLI invocation. */
+export const CLI_TIMEOUT_MS = 120_000;
+
+// ---------------------------------------------------------------------------
+// Orchestration limits (mirrors BABYSITTER_MAX_ITERATIONS etc.)
+// ---------------------------------------------------------------------------
+
+/** Default maximum orchestration iterations per run. */
+export const DEFAULT_MAX_ITERATIONS = 256;
+
+/** Default maximum wall-clock time (ms) for a single run. */
+export const DEFAULT_MAX_DURATION_MS = 30 * 60 * 1_000; // 30 minutes
+
+/** Consecutive errors before the guard trips. */
+export const DEFAULT_ERROR_THRESHOLD = 5;
+
+/** Number of identical iteration digests that signal a doom loop. */
+export const DEFAULT_DOOM_LOOP_WINDOW = 4;
+
+// ---------------------------------------------------------------------------
+// Timeouts
+// ---------------------------------------------------------------------------
+
+/** Timeout (ms) for a single effect execution. */
+export const EFFECT_TIMEOUT_MS = 900_000; // 15 minutes, matches NODE_TASK_TIMEOUT
+
+/** Timeout (ms) for posting a task result back. */
+export const POST_RESULT_TIMEOUT_MS = 30_000;
+
+/** Delay (ms) for a sleep effect (placeholder; real value comes from the effect). */
+export const DEFAULT_SLEEP_MS = 5_000;
+
+// ---------------------------------------------------------------------------
+// Environment variable names
+// ---------------------------------------------------------------------------
+
+export const ENV_RUNS_DIR = 'BABYSITTER_RUNS_DIR';
+export const ENV_MAX_ITERATIONS = 'BABYSITTER_MAX_ITERATIONS';
+export const ENV_QUALITY_THRESHOLD = 'BABYSITTER_QUALITY_THRESHOLD';
+export const ENV_TIMEOUT = 'BABYSITTER_TIMEOUT';
+export const ENV_LOG_LEVEL = 'BABYSITTER_LOG_LEVEL';
+export const ENV_HOOK_TIMEOUT = 'BABYSITTER_HOOK_TIMEOUT';
+export const ENV_NODE_TASK_TIMEOUT = 'BABYSITTER_NODE_TASK_TIMEOUT';
+export const ENV_CLI_PATH = 'BABYSITTER_CLI_PATH';
+
+// ---------------------------------------------------------------------------
+// Widget keys (for registerMessageRenderer / TUI identification)
+// ---------------------------------------------------------------------------
+
+export const WIDGET_RUN_PROGRESS = 'babysitter:run-progress';
+export const WIDGET_TASK_STATUS = 'babysitter:task-status';
+export const WIDGET_QUALITY_SCORE = 'babysitter:quality-score';
+export const WIDGET_PHASE_INDICATOR = 'babysitter:phase-indicator';
+
+// ---------------------------------------------------------------------------
+// Extension metadata
+// ---------------------------------------------------------------------------
+
+export const EXTENSION_NAME = 'babysitter';
+export const EXTENSION_VERSION = '0.1.0';