@a5c-ai/babysitter-gemini 4.0.153

package/bin/cli.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const PLUGIN_NAME = 'babysitter-gemini';
+const EXTENSION_NAME = 'babysitter'; // matches gemini-extension.json "name"
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function printUsage() {
+  console.log([
+    `${PLUGIN_NAME} - Babysitter plugin for Gemini CLI`,
+    '',
+    'Usage:',
+    `  ${PLUGIN_NAME} install [--global]              Install via: gemini extensions install <package-root>`,
+    `  ${PLUGIN_NAME} install --link                   Link via: gemini extensions link <package-root> (dev mode)`,
+    `  ${PLUGIN_NAME} uninstall                        Uninstall via: gemini extensions uninstall ${EXTENSION_NAME}`,
+    `  ${PLUGIN_NAME} status                           Check installation status`,
+    `  ${PLUGIN_NAME} version                          Show version info`,
+    `  ${PLUGIN_NAME} help                             Show this message`,
+    '',
+    'Installation delegates to `gemini extensions install/link/uninstall`.',
+    'The Gemini CLI must be installed for install/uninstall to work.',
+    '',
+    'The plugin provides:',
+    '  - GEMINI.md context file for orchestration instructions',
+    '  - SessionStart hook for session initialization',
+    '  - AfterAgent hook for continuation loop',
+    '  - Command definitions for all babysitter workflows',
+  ].join('\n'));
+}
+
+function getVersions() {
+  try {
+    const versionsPath = path.join(PACKAGE_ROOT, 'versions.json');
+    return JSON.parse(fs.readFileSync(versionsPath, 'utf8'));
+  } catch {
+    return { sdkVersion: 'unknown', extensionVersion: 'unknown' };
+  }
+}
+
+function getExtensionDir() {
+  return path.join(os.homedir(), '.gemini', 'extensions', EXTENSION_NAME);
+}
+
+function isGeminiCliAvailable() {
+  const result = spawnSync('gemini', ['--version'], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    shell: true,
+    timeout: 10000,
+  });
+  return result.status === 0;
+}
+
+function requireGeminiCli() {
+  if (!isGeminiCliAvailable()) {
+    console.error('[babysitter] Error: Gemini CLI is not installed or not in PATH.');
+    console.error('[babysitter] Install it first: https://github.com/google-gemini/gemini-cli');
+    process.exitCode = 1;
+    return false;
+  }
+  return true;
+}
+
+function resolveBabysitterCommand() {
+  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: [PACKAGE_ROOT],
+        }),
+      ],
+    };
+  } catch {
+    return { command: 'babysitter', argsPrefix: [] };
+  }
+}
+
+function runBabysitterCli(cliArgs) {
+  const resolved = resolveBabysitterCommand();
+  const result = spawnSync(resolved.command, [...resolved.argsPrefix, ...cliArgs], {
+    cwd: PACKAGE_ROOT,
+    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 getGlobalStateDir() {
+  if (process.env.BABYSITTER_GLOBAL_STATE_DIR) {
+    return path.resolve(process.env.BABYSITTER_GLOBAL_STATE_DIR);
+  }
+  return path.join(os.homedir(), '.a5c');
+}
+
+// ---------------------------------------------------------------------------
+// Install
+// ---------------------------------------------------------------------------
+
+function install(useLink) {
+  if (!requireGeminiCli()) return;
+
+  const subcommand = useLink ? 'link' : 'install';
+  console.log(`[babysitter] Running: gemini extensions ${subcommand} ${PACKAGE_ROOT}`);
+
+  const result = spawnSync('gemini', ['extensions', subcommand, PACKAGE_ROOT], {
+    stdio: 'inherit',
+    shell: true,
+    timeout: 60000,
+  });
+
+  if (result.status !== 0) {
+    console.error(`[babysitter] gemini extensions ${subcommand} failed (exit ${result.status}).`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (useLink) {
+    console.log('[babysitter] Extension linked. Changes to the package are reflected immediately.');
+  } else {
+    console.log('[babysitter] Extension installed.');
+  }
+
+  installSdk();
+  ensureProcessLibrary();
+
+  console.log('');
+  console.log('[babysitter] Installation complete! Restart Gemini CLI to activate.');
+}
+
+function installSdk() {
+  const versions = getVersions();
+  if (!versions.sdkVersion || versions.sdkVersion === 'unknown') return;
+
+  console.log(`[babysitter] Ensuring babysitter SDK (${versions.sdkVersion}) is available...`);
+  const result = spawnSync('npm', ['i', '-g', `@a5c-ai/babysitter-sdk@${versions.sdkVersion}`, '--loglevel=error'], {
+    stdio: 'inherit',
+    shell: true,
+  });
+  if (result.status === 0) {
+    console.log('[babysitter] SDK installed successfully.');
+  } else {
+    console.log('[babysitter] SDK global install failed — the SessionStart hook will attempt install on first use.');
+  }
+}
+
+function ensureProcessLibrary() {
+  try {
+    const raw = runBabysitterCli(['process-library:active', '--state-dir', getGlobalStateDir(), '--json']);
+    const active = JSON.parse(raw);
+    if (active.binding?.dir) {
+      console.log(`[babysitter]   process library: ${active.binding.dir}`);
+    }
+    if (active.defaultSpec?.cloneDir) {
+      console.log(`[babysitter]   process library clone: ${active.defaultSpec.cloneDir}`);
+    }
+  } catch {
+    // Process library bootstrap is best-effort
+    console.log('[babysitter] Process library bootstrap skipped (babysitter CLI not available yet).');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Uninstall
+// ---------------------------------------------------------------------------
+
+function uninstall() {
+  if (!requireGeminiCli()) return;
+
+  console.log(`[babysitter] Running: gemini extensions uninstall ${EXTENSION_NAME}`);
+
+  const result = spawnSync('gemini', ['extensions', 'uninstall', EXTENSION_NAME], {
+    stdio: 'inherit',
+    shell: true,
+    timeout: 30000,
+  });
+
+  if (result.status !== 0) {
+    console.error(`[babysitter] gemini extensions uninstall failed (exit ${result.status}).`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('[babysitter] Extension removed. Restart Gemini CLI to complete uninstallation.');
+}
+
+// ---------------------------------------------------------------------------
+// Status
+// ---------------------------------------------------------------------------
+
+function status() {
+  const extensionDir = getExtensionDir();
+  const exists = fs.existsSync(extensionDir);
+  let symlinked = false;
+  try {
+    symlinked = fs.lstatSync(extensionDir).isSymbolicLink();
+  } catch {
+    // Does not exist
+  }
+
+  console.log(`Extension directory: ${extensionDir}`);
+  console.log(`Installed: ${exists ? 'yes' : 'no'}`);
+
+  if (symlinked) {
+    const target = fs.readlinkSync(extensionDir);
+    console.log(`Mode: linked -> ${target}`);
+  } else if (exists) {
+    console.log('Mode: installed (copy)');
+  }
+
+  if (exists) {
+    const extManifest = path.join(extensionDir, 'gemini-extension.json');
+    const pluginManifest = path.join(extensionDir, 'plugin.json');
+    const versionsFile = path.join(extensionDir, 'versions.json');
+    const geminiMd = path.join(extensionDir, 'GEMINI.md');
+    const hooksDir = path.join(extensionDir, 'hooks');
+
+    console.log(`gemini-extension.json: ${fs.existsSync(extManifest) ? 'present' : 'MISSING'}`);
+    console.log(`plugin.json: ${fs.existsSync(pluginManifest) ? 'present' : 'MISSING'}`);
+    console.log(`versions.json: ${fs.existsSync(versionsFile) ? 'present' : 'MISSING'}`);
+    console.log(`GEMINI.md: ${fs.existsSync(geminiMd) ? 'present' : 'MISSING'}`);
+    console.log(`hooks/: ${fs.existsSync(hooksDir) ? 'present' : 'MISSING'}`);
+
+    if (fs.existsSync(versionsFile)) {
+      try {
+        const v = JSON.parse(fs.readFileSync(versionsFile, 'utf8'));
+        console.log(`SDK version: ${v.sdkVersion || 'unknown'}`);
+        console.log(`Extension version: ${v.extensionVersion || 'unknown'}`);
+      } catch {
+        console.log('versions.json: unreadable');
+      }
+    }
+  }
+
+  // Check CLIs
+  const geminiCheck = spawnSync('gemini', ['--version'], {
+    stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', shell: true,
+  });
+  console.log(`gemini CLI: ${geminiCheck.status === 0 ? geminiCheck.stdout.trim() : 'not found'}`);
+
+  const cliCheck = spawnSync('babysitter', ['--version'], {
+    stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', shell: true,
+  });
+  console.log(`babysitter CLI: ${cliCheck.status === 0 ? cliCheck.stdout.trim() : 'not found'}`);
+}
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+function parseInstallArgs(argv) {
+  let useLink = false;
+  for (const arg of argv) {
+    if (arg === '--link' || arg === '--symlink') {
+      useLink = true;
+    } else if (arg === '--global') {
+      // Accepted for backwards compat, no-op (global is the only target now)
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+  return { useLink };
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+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 === 'version' || command === '--version' || command === '-v') {
+    const versions = getVersions();
+    const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+    console.log(`${pkg.name}: ${pkg.version}`);
+    console.log(`extension: ${versions.extensionVersion || 'unknown'}`);
+    console.log(`sdk: ${versions.sdkVersion || 'unknown'}`);
+    return;
+  }
+
+  if (command === 'install') {
+    try {
+      const parsed = parseInstallArgs(rest);
+      install(parsed.useLink);
+    } catch (err) {
+      console.error(`[babysitter] Error: ${err.message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'uninstall') {
+    uninstall();
+    return;
+  }
+
+  if (command === 'status') {
+    status();
+    return;
+  }
+
+  console.error(`Unknown command: ${command}`);
+  printUsage();
+  process.exitCode = 1;
+}
+
+main();

package/bin/postinstall.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * postinstall hook — runs after `npm install [-g] @a5c-ai/babysitter-gemini`.
+ *
+ * When installed globally (the expected path), this delegates to
+ * `gemini extensions install <package-root>` so Gemini CLI handles the
+ * extension installation natively. Falls back to manual copy if the
+ * `gemini` CLI is not available.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const EXTENSION_NAME = 'babysitter'; // matches gemini-extension.json "name"
+
+function isGlobalInstall() {
+  if (process.env.npm_config_global === 'true') return true;
+  const globalPrefix = process.env.npm_config_prefix || '';
+  if (globalPrefix && PACKAGE_ROOT.startsWith(globalPrefix)) return true;
+  return false;
+}
+
+function isGeminiCliAvailable() {
+  const result = spawnSync('gemini', ['--version'], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    shell: true,
+    timeout: 10000,
+  });
+  return result.status === 0;
+}
+
+function isExtensionLinked() {
+  const extensionDir = path.join(os.homedir(), '.gemini', 'extensions', EXTENSION_NAME);
+  try {
+    return fs.lstatSync(extensionDir).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  if (!isGlobalInstall()) {
+    return;
+  }
+
+  // Don't overwrite a linked extension (dev mode)
+  if (isExtensionLinked()) {
+    console.log(`[babysitter] Skipping postinstall: extension is linked (dev mode)`);
+    return;
+  }
+
+  if (!isGeminiCliAvailable()) {
+    console.warn('[babysitter] Gemini CLI not found. Run `babysitter-gemini install` after installing Gemini CLI.');
+    return;
+  }
+
+  console.log(`[babysitter] Installing extension via: gemini extensions install ${PACKAGE_ROOT}`);
+
+  const result = spawnSync('gemini', ['extensions', 'install', PACKAGE_ROOT], {
+    stdio: 'inherit',
+    shell: true,
+    timeout: 60000,
+  });
+
+  if (result.status === 0) {
+    console.log('[babysitter] Extension installed via Gemini CLI. Restart Gemini CLI to activate.');
+  } else {
+    console.warn('[babysitter] Warning: gemini extensions install failed.');
+    console.warn('[babysitter] Run `babysitter-gemini install` manually to complete setup.');
+  }
+}
+
+main();

package/bin/preuninstall.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * preuninstall hook — runs before `npm uninstall [-g] @a5c-ai/babysitter-gemini`.
+ *
+ * Delegates to `gemini extensions uninstall babysitter` so Gemini CLI handles
+ * the removal natively. Falls back to manual removal if the CLI is not available.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const EXTENSION_NAME = 'babysitter'; // matches gemini-extension.json "name"
+
+function getExtensionDir() {
+  return path.join(os.homedir(), '.gemini', 'extensions', EXTENSION_NAME);
+}
+
+function isGeminiCliAvailable() {
+  const result = spawnSync('gemini', ['--version'], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    shell: true,
+    timeout: 10000,
+  });
+  return result.status === 0;
+}
+
+function main() {
+  const extensionDir = getExtensionDir();
+
+  if (!fs.existsSync(extensionDir)) {
+    return;
+  }
+
+  // Don't remove linked extensions automatically — they point to a dev checkout
+  try {
+    if (fs.lstatSync(extensionDir).isSymbolicLink()) {
+      console.log(`[babysitter] Skipping preuninstall: extension is linked (dev mode)`);
+      console.log(`[babysitter] Remove the link manually: gemini extensions uninstall ${EXTENSION_NAME}`);
+      return;
+    }
+  } catch {
+    // Proceed
+  }
+
+  if (isGeminiCliAvailable()) {
+    console.log(`[babysitter] Uninstalling extension via: gemini extensions uninstall ${EXTENSION_NAME}`);
+    const result = spawnSync('gemini', ['extensions', 'uninstall', EXTENSION_NAME], {
+      stdio: 'inherit',
+      shell: true,
+      timeout: 30000,
+    });
+    if (result.status === 0) {
+      console.log('[babysitter] Extension removed via Gemini CLI.');
+      return;
+    }
+    console.warn('[babysitter] gemini extensions uninstall failed, falling back to manual removal.');
+  }
+
+  // Fallback: manual removal
+  try {
+    fs.rmSync(extensionDir, { recursive: true, force: true });
+    console.log(`[babysitter] Removed extension from ${extensionDir}`);
+  } catch (err) {
+    console.warn(`[babysitter] Warning: could not remove ${extensionDir}: ${err.message}`);
+  }
+}
+
+main();

package/commands/assimilate.md

@@ -0,0 +1,37 @@
+---
+description: Assimilate an external methodology, harness, or specification into babysitter process definitions with skills and agents.
+argument-hint: Target to assimilate (e.g. repo URL, harness name, or spec path)
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Grep, Glob, WebFetch, WebSearch, Search, AskUserQuestion, TodoWrite, TodoRead, Skill, BashOutput, KillShell, MultiEdit, LS
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md).
+
+Use the assimilation domain processes from the active process library to convert external sources into well-defined babysitter process definitions with accompanying skills/ and agents/ directories.
+
+If the workspace does not already have an active process-library binding, initialize it first through the shared global SDK binding:
+
+```bash
+babysitter process-library:active --json
+```
+
+Run the process after formalizing it.
+
+Available assimilation workflows:
+- **methodology-assimilation** (`specializations/meta/assimilation/workflows/methodology-assimilation`) - Learns an external methodology from its repo and converts procedural instructions, commands, and manual flows into babysitter processes with refactored skills and agents. Supports output as methodology or specialization.
+- **harness integration** (`specializations/meta/assimilation/harness/*`) - Integrates babysitter SDK with a specific AI coding harness (generic, codex, opencode, gemini-cli, openclaw, antigravity).
+
+During the interview phase, determine which assimilation workflow to use based on the user's target:
+- If the target is a **repo URL or methodology name** then use the methodology-assimilation workflow.
+- If the target is a **harness name** (e.g. codex, opencode, antigravity) then use the matching harness process.
+- If the target is a **specification or other source** then adapt the methodology-assimilation workflow for the spec format.
+- If unclear, ask the user to clarify the assimilation target and type.
+
+## After Assimilation: Contribute Back
+
+After successfully assimilating a methodology or harness integration, prompt the user to share it with the community. The assimilated process definitions, skills, and agents could benefit other babysitter users:
+
+- **Completed a methodology assimilation**: `/babysitter:contrib library contribution: assimilated [methodology-name] into babysitter process definitions`
+- **Completed a harness integration**: `/babysitter:contrib library contribution: [harness-name] harness integration`
+- **Hit issues during assimilation** (e.g. unsupported patterns, missing SDK features): `/babysitter:contrib bug report: assimilation of [target] failed because [description]` or `/babysitter:contrib feature request: [what the SDK needs to support]`
+
+Even just reporting that an assimilation didn't work well helps improve babysitter for everyone.

package/commands/call.md

@@ -0,0 +1,7 @@
+---
+description: Orchestrate a babysitter run. use this command to start babysitting a complex workflow.
+argument-hint: Specific instructions for the run.
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Grep, Glob, WebFetch, WebSearch, Search, AskUserQuestion, TodoWrite, TodoRead, Skill, BashOutput, KillShell, MultiEdit, LS
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md).

package/commands/cleanup.md

@@ -0,0 +1,20 @@
+---
+description: Clean up .a5c/runs and .a5c/processes directories. Aggregates insights from completed/failed runs into docs/run-history-insights.md, then removes old run data and orphaned process files.
+argument-hint: "[--dry-run] [--keep-days N] Optional flags. --dry-run shows what would be removed without deleting. --keep-days N keeps runs newer than N days (default 7)."
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Grep, Glob, WebFetch, WebSearch, Search, AskUserQuestion, TodoWrite, TodoRead, Skill, BashOutput, KillShell, MultiEdit, LS
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md).
+
+Create and run a cleanup process using the process at `skills\babysit\process\cradle\cleanup-runs.js/processes/cleanup-runs.js`.
+
+Implementation notes (for the process):
+- Parse arguments for `--dry-run` flag (if present, set dryRun: true in inputs) and `--keep-days N` (default: 7)
+- The process scans .a5c/runs/ for completed/failed runs, aggregates insights, writes summaries, then removes old data
+- Always show the user what will be removed before removing (in interactive mode via breakpoints)
+- In non-interactive mode (yolo), proceed with cleanup using defaults
+- The insights file goes to docs/run-history-insights.md
+- Only remove terminal runs (completed/failed) older than the keep-days threshold
+- Never remove active/in-progress runs
+- Remove orphaned process files not referenced by remaining runs
+- After cleanup, show remaining run count and disk usage

package/commands/contrib.md

@@ -0,0 +1,33 @@
+---
+description: Submit feedback or contribute to babysitter project
+argument-hint: Specific instructions for the run.
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Grep, Glob, WebFetch, WebSearch, Search, AskUserQuestion, TodoWrite, TodoRead, Skill, BashOutput, KillShell, MultiEdit, LS
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md).
+
+## Process Routing
+
+Contribution processes live under the active process library's `cradle/` directory. Resolve the active library root with `babysitter process-library:active --json` and route based on arguments:
+
+### Issue-based (opens a GitHub issue in a5c-ai/babysitter)
+ * **Bug report** → `cradle/bug-report.js#process` — Report a bug in the SDK, CLI, process library, etc.
+ * **Feature request** → `cradle/feature-request.js#process` — Request a new feature or enhancement
+ * **Documentation question** → `cradle/documentation-question.js#process` — Ask about undocumented behavior or missing docs
+
+### PR-based (forks repo, creates branch, submits PR to a5c-ai/babysitter)
+ * **Bugfix** → `cradle/bugfix.js#process` — User already has the fix for a bug
+ * **Feature implementation** → `cradle/feature-implementation-contribute.js#process` — User already has a feature implementation
+ * **Harness integration** → `cradle/feature-harness-integration-contribute.js#process` — User has a harness (CI/CD, IDE, editor) integration
+ * **Library contribution** → `cradle/library-contribution.js#process` — New or improved process/skill/subagent for the library
+ * **Documentation answer** → `cradle/documentation-contribute-answer.js#process` — User has an answer for an unanswered docs question
+
+### Router (when arguments are empty or general)
+ * **Contribute** → `cradle/contribute.js#process` — Explains contribution types and routes to the specific process
+
+## Contribution Rules
+
+ * PR-based contributions: fork the babysitter repo (a5c-ai/babysitter) for the user, ask to star if not already starred, perform changes, submit PR
+ * Issue-based contributions: gather details, search for duplicates, review, then open an issue in a5c-ai/babysitter
+ * Add breakpoints (permissions) before ALL gh actions (fork, star, submit PR/issue) to allow user review and cancellation
+ * If arguments are empty: use the `contribute.js` router process to show options and route accordingly