@a5c-ai/babysitter-pi 0.1.0

package/extensions/babysitter/session-binder.ts

@@ -0,0 +1,284 @@
+/**
+ * Auto-binds every oh-my-pi session to a babysitter session / run.
+ *
+ * Uses the babysitter SDK directly (no CLI subprocess) to create and
+ * manage runs that are tracked for the lifetime of the oh-my-pi session.
+ *
+ * State is persisted to `plugins/babysitter-pi/state/<sessionId>.json` so that
+ * sessions can be recovered after restarts.
+ *
+ * @module session-binder
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createRun } from '@a5c-ai/babysitter-sdk';
+import { readRunMetadata, loadJournal } from '@a5c-ai/babysitter-sdk';
+import type { CreateRunOptions, CreateRunResult } from '@a5c-ai/babysitter-sdk';
+import { DEFAULT_MAX_ITERATIONS } from './constants';
+
+// ---------------------------------------------------------------------------
+// RunState type
+// ---------------------------------------------------------------------------
+
+/** Snapshot of a babysitter run as tracked by the session binder. */
+export interface RunState {
+  /** The oh-my-pi session identifier bound to this run. */
+  sessionId: string;
+  /** The active run identifier. */
+  runId: string;
+  /** Absolute path to the run directory. */
+  runDir: string;
+  /** Current orchestration iteration number. */
+  iteration: number;
+  /** Maximum allowed iterations before the guard trips. */
+  maxIterations: number;
+  /** Per-iteration wall-clock times (ms) for diagnostics. */
+  iterationTimes: number[];
+  /** ISO-8601 timestamp when the run was created. */
+  startedAt: string;
+  /** The process identifier used to create the run. */
+  processId: string;
+  /** Current lifecycle status. */
+  status: 'idle' | 'running' | 'completed' | 'failed';
+}
+
+// ---------------------------------------------------------------------------
+// State persistence helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the directory used for persisting session state files.
+ * Lives alongside the extension code at `plugins/babysitter-pi/state/`.
+ */
+function getStateDir(): string {
+  // __dirname at runtime points to the compiled location of this file;
+  // the state directory sits two levels up from extensions/babysitter/.
+  return path.resolve(__dirname, '..', '..', 'state');
+}
+
+/** Build the path to a session's state file. */
+function stateFilePath(sessionId: string): string {
+  return path.join(getStateDir(), `${sessionId}.json`);
+}
+
+/**
+ * Persist {@link RunState} to disk using an atomic tmp+rename pattern
+ * so that partial writes never corrupt the file.
+ */
+function persistState(state: RunState): void {
+  const dir = getStateDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const target = stateFilePath(state.sessionId);
+  const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+  fs.renameSync(tmp, target);
+}
+
+/** Load a previously-persisted {@link RunState}, or return `null`. */
+function loadPersistedState(sessionId: string): RunState | null {
+  const filePath = stateFilePath(sessionId);
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw) as RunState;
+    // Basic shape validation
+    if (
+      typeof parsed.sessionId === 'string' &&
+      typeof parsed.runId === 'string' &&
+      typeof parsed.runDir === 'string'
+    ) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Remove the persisted state file for a session. */
+function removePersistedState(sessionId: string): void {
+  const filePath = stateFilePath(sessionId);
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+    // Already gone — the universe moves on, indifferent as always.
+  }
+}
+
+// ---------------------------------------------------------------------------
+// SessionBinder
+// ---------------------------------------------------------------------------
+
+/** In-memory map of oh-my-pi session ID to active run state. */
+const activeSessions = new Map<string, RunState>();
+
+/**
+ * Options accepted by {@link bindRun} to create a new babysitter run.
+ */
+export interface BindRunOptions {
+  /** Unique process identifier. */
+  processId: string;
+  /** Path to the process entry-point module. */
+  importPath: string;
+  /** Named export within the module (defaults to `"process"`). */
+  exportName?: string;
+  /** Inputs to feed the process function. */
+  inputs?: unknown;
+  /** Human-readable prompt / description. */
+  prompt: string;
+  /** Root directory for run storage. */
+  runsDir: string;
+}
+
+/**
+ * Initialise babysitter session state for a given oh-my-pi session.
+ *
+ * If a persisted state file exists on disk the previous {@link RunState}
+ * is restored into memory, allowing seamless recovery after restarts.
+ *
+ * @param sessionId - The oh-my-pi session identifier.
+ * @returns The recovered {@link RunState}, or `null` if no prior state exists.
+ */
+export function initSession(sessionId: string): RunState | null {
+  // Attempt recovery from disk
+  const recovered = loadPersistedState(sessionId);
+  if (recovered) {
+    activeSessions.set(sessionId, recovered);
+    return recovered;
+  }
+  // Nothing to recover — the session starts fresh.
+  return null;
+}
+
+/**
+ * Create a babysitter run via the SDK and bind it to the current session.
+ *
+ * This calls `createRun` from `@a5c-ai/babysitter-sdk` directly — no CLI
+ * subprocess is spawned.
+ *
+ * @param sessionId - The oh-my-pi session identifier.
+ * @param opts      - Options describing the process and run configuration.
+ * @returns The freshly-created {@link RunState}.
+ */
+export async function bindRun(
+  sessionId: string,
+  opts: BindRunOptions,
+): Promise<RunState> {
+  const createOpts: CreateRunOptions = {
+    runsDir: opts.runsDir,
+    process: {
+      processId: opts.processId,
+      importPath: opts.importPath,
+      exportName: opts.exportName,
+    },
+    inputs: opts.inputs,
+    prompt: opts.prompt,
+  };
+
+  const result: CreateRunResult = await createRun(createOpts);
+
+  const state: RunState = {
+    sessionId,
+    runId: result.runId,
+    runDir: result.runDir,
+    iteration: 0,
+    maxIterations: DEFAULT_MAX_ITERATIONS,
+    iterationTimes: [],
+    startedAt: new Date().toISOString(),
+    processId: opts.processId,
+    status: 'idle',
+  };
+
+  activeSessions.set(sessionId, state);
+  persistState(state);
+
+  return state;
+}
+
+/**
+ * Retrieve the active run state for a given session.
+ *
+ * @param sessionId - The oh-my-pi session identifier (optional — returns
+ *                    the first active run when omitted, because why not).
+ * @returns The {@link RunState} if one is active, otherwise `null`.
+ */
+export function getActiveRun(sessionId?: string): RunState | null {
+  if (sessionId) {
+    return activeSessions.get(sessionId) ?? null;
+  }
+  // Return the first active session if no ID specified
+  const first = activeSessions.values().next();
+  return first.done ? null : first.value;
+}
+
+/**
+ * Replace or set the active run state for a session.
+ *
+ * Persists the state to disk immediately.
+ *
+ * @param state - The {@link RunState} to store.
+ */
+export function setActiveRun(state: RunState): void {
+  activeSessions.set(state.sessionId, state);
+  persistState(state);
+}
+
+/**
+ * Clear the active run state for a session.
+ *
+ * Removes both the in-memory entry and the persisted state file.
+ *
+ * @param sessionId - The oh-my-pi session identifier.
+ */
+export function clearActiveRun(sessionId: string): void {
+  activeSessions.delete(sessionId);
+  removePersistedState(sessionId);
+}
+
+/**
+ * Quick check whether a run is currently active.
+ *
+ * When called with a `sessionId`, returns `true` only if that specific
+ * session has an active run.  When called with no arguments, returns
+ * `true` if *any* session has an active run.
+ *
+ * @param sessionId - Optional oh-my-pi session identifier.
+ * @returns `true` if a run is tracked in memory.
+ */
+export function isRunActive(sessionId?: string): boolean {
+  if (sessionId) {
+    return activeSessions.has(sessionId);
+  }
+  return activeSessions.size > 0;
+}
+
+// ---------------------------------------------------------------------------
+// SDK-backed run inspection helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the metadata for the run bound to a session, directly from disk
+ * via the SDK's `readRunMetadata`.
+ *
+ * @param sessionId - The oh-my-pi session identifier.
+ * @returns The run metadata, or `null` if no active run exists.
+ */
+export async function inspectRunMetadata(sessionId: string) {
+  const state = activeSessions.get(sessionId);
+  if (!state) return null;
+  return readRunMetadata(state.runDir);
+}
+
+/**
+ * Load the journal for the run bound to a session, directly from disk
+ * via the SDK's `loadJournal`.
+ *
+ * @param sessionId - The oh-my-pi session identifier.
+ * @returns The journal events array, or `null` if no active run exists.
+ */
+export async function inspectRunJournal(sessionId: string) {
+  const state = activeSessions.get(sessionId);
+  if (!state) return null;
+  return loadJournal(state.runDir);
+}

package/extensions/babysitter/status-line.ts

@@ -0,0 +1,54 @@
+/**
+ * Status line integration for babysitter orchestration state.
+ *
+ * Provides a compact, single-line summary of the active babysitter run
+ * suitable for display in oh-my-pi's persistent status bar area.
+ *
+ * @module status-line
+ */
+
+import type { RunState } from './session-binder.js';
+
+/**
+ * Update the oh-my-pi status bar with the current babysitter run state.
+ *
+ * @param runState - The current {@link RunState}, or `null` when no run is active.
+ * @param pi       - The oh-my-pi extension API handle (must expose `setStatus`).
+ */
+export function updateStatusLine(runState: RunState | null, pi: any): void {
+  if (!runState) {
+    pi.setStatus('babysitter', 'Babysitter: idle');
+    return;
+  }
+
+  switch (runState.status) {
+    case 'completed':
+      pi.setStatus('babysitter', 'Babysitter: done');
+      break;
+    case 'failed':
+      pi.setStatus('babysitter', 'Babysitter: FAILED');
+      break;
+    case 'running': {
+      const elapsedMs = Date.now() - new Date(runState.startedAt).getTime();
+      const elapsedMin = Math.floor(elapsedMs / 60_000);
+      const pending = (runState as any).pendingEffectCount ?? 0;
+      pi.setStatus(
+        'babysitter',
+        `Babysitter: iter ${runState.iteration} | pending ${pending} | ${elapsedMin}m`,
+      );
+      break;
+    }
+    default:
+      pi.setStatus('babysitter', 'Babysitter: idle');
+      break;
+  }
+}
+
+/**
+ * Clear the babysitter status line (e.g. on session shutdown).
+ *
+ * @param pi - The oh-my-pi extension API handle.
+ */
+export function clearStatusLine(pi: any): void {
+  pi.setStatus('babysitter', '');
+}

package/extensions/babysitter/task-interceptor.ts

@@ -0,0 +1,82 @@
+/**
+ * Intercepts built-in task/todo tools during active babysitter runs.
+ *
+ * When a babysitter run is active, direct use of oh-my-pi's native task
+ * and todo tools would conflict with babysitter's own orchestration.
+ * This module detects those calls and blocks them, directing the agent
+ * to use babysitter effects instead.
+ *
+ * Wire into the extension via `pi.on("tool_call", ...)`.
+ *
+ * @module task-interceptor
+ */
+
+import { isRunActive } from './session-binder.js';
+
+/** Tool names that should be intercepted during an active run. */
+export const INTERCEPTED_TOOLS = [
+  'task',
+  'todo_write',
+  'TodoWrite',
+  'TaskCreate',
+  'sub_agent',
+  'quick_task',
+];
+
+/**
+ * Check whether a given tool name is subject to interception.
+ *
+ * @param toolName - The tool name to check.
+ * @returns `true` if the tool would be intercepted during an active run.
+ */
+export function shouldIntercept(toolName: string): boolean {
+  return INTERCEPTED_TOOLS.includes(toolName);
+}
+
+/**
+ * Evaluate whether a tool call should be intercepted.
+ *
+ * When a babysitter run is actively orchestrating, calls to built-in
+ * task and todo tools are blocked and a reason is provided so the
+ * agent can route the request through babysitter instead.
+ *
+ * Returns `null` when no interception is needed (no active run or
+ * the tool is not in the intercepted list), allowing normal operation.
+ *
+ * Returns `{ block: true, reason }` when the tool should be prevented
+ * from executing.
+ *
+ * Designed to be wired into oh-my-pi's `tool_call` event handler:
+ * ```ts
+ * pi.on('tool_call', (toolName, params) => {
+ *   return interceptToolCall(toolName, params, pi);
+ * });
+ * ```
+ *
+ * @param toolName - The name of the tool being invoked.
+ * @param params   - The parameters passed to the tool.
+ * @param pi       - The oh-my-pi ExtensionAPI instance.
+ * @returns An intercept result or `null` to allow the call.
+ */
+export function interceptToolCall(
+  toolName: string,
+  params: unknown,
+  pi: any,
+): { block: boolean; reason?: string } | null {
+  // No active run -- allow everything.
+  if (!isRunActive()) {
+    return null;
+  }
+
+  // Tool is not one we care about -- allow.
+  if (!shouldIntercept(toolName)) {
+    return null;
+  }
+
+  // Active run AND intercepted tool -- block.
+  return {
+    block: true,
+    reason:
+      'Babysitter orchestration is active. Task management is handled by babysitter effects. Use /babysitter:status to check progress.',
+  };
+}

package/extensions/babysitter/todo-replacement.ts

@@ -0,0 +1,125 @@
+/**
+ * Replaces oh-my-pi's native todo widget with babysitter task tracking.
+ *
+ * Instead of maintaining a separate todo list, this module reads the
+ * babysitter journal directly via the SDK and maps effect states into
+ * a todo-compatible TUI widget.
+ *
+ * @module todo-replacement
+ */
+
+import { loadJournal } from '@a5c-ai/babysitter-sdk';
+
+// ---------------------------------------------------------------------------
+// TodoItem type
+// ---------------------------------------------------------------------------
+
+/** A single todo item derived from babysitter journal events. */
+export interface TodoItem {
+  /** The effect identifier (unique per task dispatch). */
+  id: string;
+  /** Human-readable title derived from the effect label or taskId. */
+  title: string;
+  /** Display status: "in-progress", "completed", or "failed". */
+  status: 'in-progress' | 'completed' | 'failed';
+  /** The effect kind (e.g. "node", "shell", "breakpoint"). */
+  kind: string;
+}
+
+// ---------------------------------------------------------------------------
+// buildTodoItems — extract TodoItems from raw journal events
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a list of {@link TodoItem}s from raw babysitter journal events.
+ *
+ * Walks the event list in order, creating items on EFFECT_REQUESTED and
+ * updating their status on EFFECT_RESOLVED.
+ *
+ * @param journalEvents - Array of journal events as returned by `loadJournal`.
+ * @returns An array of {@link TodoItem}s reflecting the current state.
+ */
+export function buildTodoItems(journalEvents: any[]): TodoItem[] {
+  const itemsById = new Map<string, TodoItem>();
+
+  for (const event of journalEvents) {
+    if (event.type === 'EFFECT_REQUESTED') {
+      const data = event.data ?? {};
+      const effectId: string = data.effectId ?? event.ulid ?? '';
+      const title: string = data.label ?? data.taskId ?? effectId;
+      const kind: string = data.kind ?? 'unknown';
+
+      itemsById.set(effectId, {
+        id: effectId,
+        title,
+        status: 'in-progress',
+        kind,
+      });
+    } else if (event.type === 'EFFECT_RESOLVED') {
+      const data = event.data ?? {};
+      const effectId: string = data.effectId ?? '';
+      const existing = itemsById.get(effectId);
+      if (existing) {
+        existing.status = data.status === 'ok' ? 'completed' : 'failed';
+      }
+    }
+  }
+
+  return Array.from(itemsById.values());
+}
+
+// ---------------------------------------------------------------------------
+// formatTodoWidget — render TodoItems as TUI widget lines
+// ---------------------------------------------------------------------------
+
+/**
+ * Format todo items as widget lines suitable for `pi.setWidget()`.
+ *
+ * Each line uses a checkbox-style prefix:
+ * - `[x]` for completed items
+ * - `[ ]` for in-progress items
+ * - `[!]` for failed items
+ *
+ * @param items - The {@link TodoItem}s to render.
+ * @returns An array of formatted strings, one per item.
+ */
+export function formatTodoWidget(items: TodoItem[]): string[] {
+  return items.map((item) => {
+    let prefix: string;
+    switch (item.status) {
+      case 'completed':
+        prefix = '[x]';
+        break;
+      case 'failed':
+        prefix = '[!]';
+        break;
+      case 'in-progress':
+      default:
+        prefix = '[ ]';
+        break;
+    }
+    return `${prefix} ${item.title} (${item.kind})`;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// syncTodoState — read journal and push widget update
+// ---------------------------------------------------------------------------
+
+/**
+ * Synchronise babysitter task state into oh-my-pi's todo widget.
+ *
+ * Reads the journal from disk using the SDK's `loadJournal`, builds
+ * todo items from the events, formats them as widget lines, and pushes
+ * the result to the TUI via `pi.setWidget()`.
+ *
+ * @param runDir - Absolute path to the babysitter run directory.
+ * @param pi     - The oh-my-pi extension API handle.
+ */
+export async function syncTodoState(runDir: string, pi: any): Promise<void> {
+  const journalEvents = await loadJournal(runDir);
+  const items = buildTodoItems(journalEvents);
+  const lines = formatTodoWidget(items);
+
+  pi.setWidget('babysitter:todos', lines);
+}