unitbob 0.2.0 → 0.2.2

package/dist/runner/bdd.js

@@ -35,13 +35,23 @@ async function runCucumberRuby(projectRoot) {
     const features = join(BEHAVIORAL_ROOT, 'features');
     const steps = join(BEHAVIORAL_ROOT, 'step_definitions');
     const localBin = join(projectRoot, 'bin', 'cucumber');
+    const sidecarGemfile = join(projectRoot, BEHAVIORAL_ROOT, 'Gemfile');
+    const hasSidecarGemfile = existsSync(sidecarGemfile);
     const command = executable(localBin) ? localBin : 'bundle';
     const base = executable(localBin) ? [] : ['exec', 'cucumber'];
     const args = [...base, features, '--require', steps, '--format', 'message', '--out', CUCUMBER_REPORT];
+    const env = {
+        ...process.env,
+        RAILS_ENV: 'test',
+        UNITBOB_REPO_ROOT: projectRoot,
+    };
+    if (hasSidecarGemfile) {
+        env.BUNDLE_GEMFILE = join(BEHAVIORAL_ROOT, 'Gemfile');
+    }
     const result = await runProcess(command, args, {
         cwd: projectRoot,
         timeoutMs: BDD_TIMEOUT_MS,
-        env: { ...process.env, RAILS_ENV: 'test', UNITBOB_REPO_ROOT: projectRoot },
+        env,
     });
     return finalize(result, command, args, projectRoot, CUCUMBER_REPORT);
 }
@@ -50,9 +60,11 @@ async function runCucumberRuby(projectRoot) {
 async function runCucumberJs(projectRoot) {
     const features = join(BEHAVIORAL_ROOT, 'features');
     const steps = join(BEHAVIORAL_ROOT, 'step_definitions', '**', '*');
-    const command = 'npx';
+    const sidecarBin = join(projectRoot, BEHAVIORAL_ROOT, 'node_modules', '.bin', 'cucumber-js');
+    const command = executable(sidecarBin) ? sidecarBin : 'npx';
+    const baseArgs = executable(sidecarBin) ? [] : ['cucumber-js'];
     const args = [
-        'cucumber-js',
+        ...baseArgs,
         features,
         '--require',
         steps,
@@ -75,8 +87,10 @@ async function runPytestBdd(projectRoot, mainPath) {
     writeFileSync(join(projectRoot, PYTEST_BDD_PLUGIN_FILE), PYTEST_BDD_PLUGIN);
     const command = await pickPython(projectRoot);
     const stepsDir = join(BEHAVIORAL_ROOT, 'step_definitions');
-    const args = ['-m', 'pytest', '-c', PYTEST_INI_FILE, '-p', 'no:cacheprovider', '-p',
-        pluginModule(), stepsDir, '--rootdir', projectRoot];
+    const isVenvPytest = command.endsWith('/pytest');
+    const args = isVenvPytest
+        ? ['-c', PYTEST_INI_FILE, '-p', 'no:cacheprovider', '-p', pluginModule(), stepsDir, '--rootdir', projectRoot]
+        : ['-m', 'pytest', '-c', PYTEST_INI_FILE, '-p', 'no:cacheprovider', '-p', pluginModule(), stepsDir, '--rootdir', projectRoot];
     const result = await runProcess(command, args, {
         cwd: projectRoot,
         timeoutMs: BDD_TIMEOUT_MS,
@@ -104,6 +118,10 @@ function finalize(result, command, args, projectRoot, reportRel) {
     };
 }
 async function pickPython(projectRoot) {
+    const sidecarVenvPytest = join(projectRoot, BEHAVIORAL_ROOT, '.venv', 'bin', 'pytest');
+    if (executable(sidecarVenvPytest)) {
+        return sidecarVenvPytest;
+    }
     const probe = await runProcess('python3', ['-m', 'pytest', '--version'], {
         cwd: projectRoot,
         timeoutMs: 10_000,

package/dist/runner/provision.js

@@ -0,0 +1,116 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { runProcess } from "../proc.js";
+const defaultDeps = {
+    runCmd: (command, args, options) => runProcess(command, args, { cwd: options.cwd, timeoutMs: 120_000, env: { ...process.env, ...options.env } }),
+};
+export async function ensureRunner(projectRoot, runner, deps = defaultDeps) {
+    const behavioralDir = join(projectRoot, '.unitbob', 'behavioral');
+    mkdirSync(behavioralDir, { recursive: true });
+    switch (runner) {
+        case 'cucumber':
+            return provisionRuby(projectRoot, behavioralDir, deps);
+        case 'cucumber-js':
+            return provisionJs(projectRoot, behavioralDir, deps);
+        case 'pytest-bdd':
+            return provisionPython(projectRoot, behavioralDir, deps);
+        default:
+            return { status: 'fixable', message: `Unsupported BDD runner "${runner}".` };
+    }
+}
+async function provisionRuby(projectRoot, behavioralDir, deps) {
+    const sidecarGemfile = join(behavioralDir, 'Gemfile');
+    const sidecarContent = '# Sidecar Gemfile generated by Unitbob (Spec 32-1)\n' +
+        'eval_gemfile File.expand_path("../../../Gemfile", __FILE__)\n' +
+        'gem "cucumber", "~> 9.0", require: false\n';
+    if (!existsSync(sidecarGemfile) || readFileSync(sidecarGemfile, 'utf8') !== sidecarContent) {
+        writeFileSync(sidecarGemfile, sidecarContent);
+    }
+    const gemfileRel = '.unitbob/behavioral/Gemfile';
+    const env = { BUNDLE_GEMFILE: gemfileRel };
+    // Try project local bin/bundle, then bundle
+    const localBundle = join(projectRoot, 'bin', 'bundle');
+    const cmd = existsSync(localBundle) ? localBundle : 'bundle';
+    const result = await deps.runCmd(cmd, ['install'], { cwd: projectRoot, env }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: String(err),
+    }));
+    if (result.code === 0) {
+        return { status: 'provisioned' };
+    }
+    return {
+        status: 'fixable',
+        message: 'Bundler failed to provision Cucumber sidecar gem.',
+        checklist: ['Ensure bundler is installed (`gem install bundler`) and run `bundle install` manually inside `.unitbob/behavioral/`.'],
+    };
+}
+async function provisionPython(projectRoot, behavioralDir, deps) {
+    const venvDir = join(behavioralDir, '.venv');
+    const venvPip = join(venvDir, 'bin', 'pip');
+    const venvPytest = join(venvDir, 'bin', 'pytest');
+    if (existsSync(venvPytest)) {
+        return { status: 'provisioned' };
+    }
+    // Ladder: uv -> python3 -m venv --system-site-packages
+    const uvResult = await deps.runCmd('uv', ['venv', venvDir, '--system-site-packages'], { cwd: projectRoot }).catch(() => ({ code: 1 }));
+    let venvCreated = uvResult.code === 0;
+    if (!venvCreated) {
+        const venvResult = await deps
+            .runCmd('python3', ['-m', 'venv', '--system-site-packages', venvDir], { cwd: projectRoot })
+            .catch(() => ({ code: 1 }));
+        venvCreated = venvResult.code === 0;
+    }
+    if (!venvCreated) {
+        return {
+            status: 'fixable',
+            message: 'Failed to create virtual environment under .unitbob/behavioral/.venv.',
+            checklist: ['Install python3-venv or uv: `python3 -m venv --help` or `pip install uv`.'],
+        };
+    }
+    // Install pytest-bdd into the sidecar venv
+    const pipResult = await deps.runCmd(venvPip, ['install', 'pytest-bdd'], { cwd: projectRoot }).catch(() => ({ code: 1 }));
+    if (pipResult.code === 0 || existsSync(venvPytest)) {
+        return { status: 'provisioned' };
+    }
+    return {
+        status: 'fixable',
+        message: 'Failed to install pytest-bdd into .unitbob/behavioral/.venv.',
+        checklist: [`Run \`${venvPip} install pytest-bdd\` manually to provision the runner.`],
+    };
+}
+async function provisionJs(projectRoot, behavioralDir, deps) {
+    const sidecarPkg = join(behavioralDir, 'package.json');
+    const sidecarContent = JSON.stringify({
+        name: 'unitbob-behavioral-sidecar',
+        private: true,
+        devDependencies: {
+            '@cucumber/cucumber': '^10.0.0',
+            'ts-node': '^10.9.0',
+        },
+    }, null, 2) + '\n';
+    if (!existsSync(sidecarPkg) || readFileSync(sidecarPkg, 'utf8') !== sidecarContent) {
+        writeFileSync(sidecarPkg, sidecarContent);
+    }
+    const cucumberBin = join(behavioralDir, 'node_modules', '.bin', 'cucumber-js');
+    if (existsSync(cucumberBin)) {
+        return { status: 'provisioned' };
+    }
+    // Fallback ladder: npm -> pnpm -> yarn
+    const managers = [
+        { cmd: 'npm', args: ['install', '--prefix', '.unitbob/behavioral'] },
+        { cmd: 'pnpm', args: ['install', '--prefix', '.unitbob/behavioral'] },
+        { cmd: 'yarn', args: ['install', '--cwd', '.unitbob/behavioral'] },
+    ];
+    for (const mgr of managers) {
+        const res = await deps.runCmd(mgr.cmd, mgr.args, { cwd: projectRoot }).catch(() => ({ code: 1 }));
+        if (res.code === 0 || existsSync(cucumberBin)) {
+            return { status: 'provisioned' };
+        }
+    }
+    return {
+        status: 'fixable',
+        message: 'Failed to install @cucumber/cucumber sidecar dependency.',
+        checklist: ['Install dependencies manually: `npm install --prefix .unitbob/behavioral`.'],
+    };
+}

package/dist/verbs/suitePrepare.js

@@ -1,6 +1,9 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { materializeHelper } from "../files/guardrails.js";
 import { recipeNameFor, writeSuiteBuildRequest } from "../files/suiteBuild.js";
 import { anyStackPrecheck } from "../runner/precheck.js";
+import { ensureRunner } from "../runner/provision.js";
 import { Wire } from "../wire.js";
 // Confirm at least one supported stack is present, materialize the Ruby boot
 // helper a generated RSpec suite would require, then fetch both peer assignments
@@ -16,6 +19,7 @@ export async function suitePrepare(config, _args = [], deps) {
         getRecipe: (name) => wire.getRecipe(name),
         getSuitePacketsBatch: () => wire.getSuitePacketsBatch(),
         precheck: anyStackPrecheck,
+        ensureRunner: deps?.ensureRunner ?? ensureRunner,
         stdout: process.stdout,
         ...deps,
     };
@@ -24,7 +28,27 @@ export async function suitePrepare(config, _args = [], deps) {
         throw new Error(check.message ?? 'Unsupported runtime.');
     materializeHelper(config.projectRoot);
     const packets = await actual.getSuitePacketsBatch();
-    const branches = await Promise.all(packets.map(async (packet) => ({
+    // Spec 32-1: Zero-touch sidecar provision for behavioral BDD runners during build preflight.
+    // A `fixable` outcome (no package manager available to install the runner) is an infrastructure
+    // blocker the vibecoder clears with one command. Per the spec it must NOT surface as a
+    // build_error dead-end, must NOT abort the build, and must NOT block the structural peer. So we
+    // drop only the unprovisioned behavioral branch from this run, keep everything else buildable,
+    // and print a fixable checklist after the request is written.
+    const fixableNotices = [];
+    const buildable = [];
+    for (const packet of packets) {
+        const runner = packet.runner ?? (packet.suite_kind === 'behavioral' ? inferBddRunner(config.projectRoot) : undefined);
+        if (runner && (packet.suite_kind === 'behavioral' || ['cucumber', 'cucumber-js', 'pytest-bdd'].includes(runner))) {
+            const prov = await actual.ensureRunner(config.projectRoot, runner);
+            if (prov.status === 'fixable') {
+                const steps = prov.checklist?.length ? `\n    - ${prov.checklist.join('\n    - ')}` : '';
+                fixableNotices.push(`  Behavioral runner "${runner}" not installed: ${prov.message ?? ''}${steps}`);
+                continue;
+            }
+        }
+        buildable.push(packet);
+    }
+    const branches = await Promise.all(buildable.map(async (packet) => ({
         suite_kind: packet.suite_kind,
         source_digest: packet.source_digest,
         path_root: packet.path_root,
@@ -34,7 +58,22 @@ export async function suitePrepare(config, _args = [], deps) {
     const request = writeSuiteBuildRequest(config.projectRoot, branches);
     const kinds = branches.map((branch) => branch.suite_kind).join(' and ');
     actual.stdout.write(`Suite build request written to ${request.project_root}/.unitbob/suite-build/request.json\n`);
-    actual.stdout.write(`Next: build both peer suites (${kinds}) following each branch's \`recipe\` and \`assignment\`, ` +
+    actual.stdout.write(`Next: build ${branches.length === 1 ? 'the' : 'both'} peer ${branches.length === 1 ? 'suite' : 'suites'} (${kinds}) following each branch's \`recipe\` and \`assignment\`, ` +
         `write your answer to ${request.output_path} as a branches array, run each locally to green, ` +
         'then run `unitbob put-suite-build`.\n');
+    // A fixable runner blocker is not a failure: the structural suite still builds this run. Tell the
+    // vibecoder the one command that unblocks the behavioral peer, then re-run suite-prepare.
+    if (fixableNotices.length > 0) {
+        actual.stdout.write('\nBehavioral suite skipped this run — its BDD runner is not installed yet. ' +
+            'This is a fixable setup step, not a build failure, and it does not affect the structural suite:\n' +
+            fixableNotices.join('\n') +
+            '\nFix the above, then re-run `unitbob suite-prepare` to build the behavioral peer.\n');
+    }
+}
+function inferBddRunner(projectRoot) {
+    if (existsSync(join(projectRoot, 'package.json')))
+        return 'cucumber-js';
+    if (['pyproject.toml', 'requirements.txt', 'Pipfile'].some((f) => existsSync(join(projectRoot, f))))
+        return 'pytest-bdd';
+    return 'cucumber';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unitbob",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Unitbob connector — thin local hands for the Unitbob Rails brain. Owns no domain logic: it runs tools, relays bytes over the wire, and prints what the server returns.",
   "type": "module",
   "bin": {