unitbob 0.1.6 → 0.1.8

package/README.md

@@ -0,0 +1,45 @@
+# Unitbob
+
+A living map of your app's business parts. Each important seam gets an automatic
+test — a "lamp" on the map. Green means fine, red means something broke.
+
+You work through Claude Code. You need: Node 18+, Python 3.10+.
+
+---
+
+## Install (once)
+
+**With a prompt:**
+```
+Add the Unitbob plugin marketplace: sergeygershun/unitbob-connector
+Install the unitbob plugin
+```
+
+**With commands (in the terminal):**
+```
+claude plugin marketplace add sergeygershun/unitbob-connector
+claude plugin install unitbob@unitbob
+```
+
+Restart the session so the commands load.
+
+---
+
+## Full cycle
+
+| Step | With a prompt (just type in chat) | With a command |
+|------|-----------------------------------|----------------|
+| 1. Build the map | `Build my Unitbob map` | `/unitbob:map` |
+| 2. Generate tests | `Generate the guardrail tests` | `/unitbob:suite` |
+| 3. Run the checks | `Run the checks` | `/unitbob:check` |
+| 4. Fix a red lamp | `Fix guardrail <id>` | `/unitbob:fix <id>` |
+| 5. Open the map | `Open my Unitbob map` | `/unitbob:show` |
+
+---
+
+## How to read it
+
+- **Green lamp** — the behavior works.
+- **Red lamp** — something the structure relied on broke. Copy its `id` and run
+  step 4.
+- The project links itself by folder name — nothing to set up by hand.

package/dist/files/guardrails.js

@@ -7,6 +7,11 @@ export const HELPER_FILE = 'unitbob_helper.rb';
 // the project's own .rspec (stray --require lines, extra stdout formatters)
 // out of guardrail runs, whose JSON output must stay parseable.
 export const OPTIONS_FILE = 'rspec.opts';
+// RSpec writes its JSON report here via `--out`, not to stdout: the app under
+// test can print to stdout during a run (Rails logging, deprecation notices, a
+// stray `puts`), which corrupts a stdout-parsed JSON document. A dedicated file
+// isolates the report from anything else the process emits.
+export const RESULT_FILE = 'rspec_result.json';
 // The boot file the generated suite requires (spec 29). Connector-owned and
 // versioned with it — never scaffolded into the project, never part of the
 // suite digest (that covers `spec_rb` bytes only). Delegates to the project's

package/dist/link.js

@@ -7,9 +7,9 @@ import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, resolve, sep } from 'node:path';
 import { CONFIG_FILE, readLocalRepoId, writeConfigFile } from "./config.js";
 import { registerRepo, WireError } from "./wire.js";
-// Grill decision #1: hosted deployment is deferred; the local brain is the only
-// server for now, so the URL is a literal.
-export const DEFAULT_SERVER = 'http://localhost:3000';
+// Public Unitbob brain used by default. Local development can still pass an
+// explicit server URL or edit `.unitbob.json`.
+export const DEFAULT_SERVER = 'https://unitbob-73a4082838d3.herokuapp.com';
 // Make sure this project is linked, resolving the repo by name on every run
 // (cheap — the server find-or-creates) and reconciling with the local file:
 //   - no working link (file missing / repo_id 0 / non-int) → register, write

package/dist/runner/rspec.js

@@ -1,7 +1,7 @@
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { runProcess } from "../proc.js";
-import { GUARDRAILS_DIR, OPTIONS_FILE, SUITE_FILE } from "../files/guardrails.js";
+import { GUARDRAILS_DIR, OPTIONS_FILE, RESULT_FILE, SUITE_FILE } from "../files/guardrails.js";
 export const RSPEC_TIMEOUT_MS = 10 * 60 * 1000;
 // Spec 26: the Unitbob file runs in a defined order with a fixed seed so a
 // green→red flip can never come from run-order nondeterminism. It does not inherit
@@ -11,11 +11,14 @@ export const RSPEC_SEED = '1';
 // never the project's full suite — under RAILS_ENV=test with a fixed order/seed.
 // --options points at the materialized empty file so the project's own .rspec
 // (a --require of a helper we replaced, an extra stdout formatter) can neither
-// break the boot nor corrupt the JSON output.
+// break the boot nor corrupt the JSON output. The JSON report goes to `--out`
+// (a file), not stdout, so the app's own stdout writes during the run can never
+// corrupt it.
 export async function runRspecSuite(projectRoot) {
     const suitePath = join(GUARDRAILS_DIR, SUITE_FILE);
     const optionsPath = join(GUARDRAILS_DIR, OPTIONS_FILE);
-    return invokeRspec(projectRoot, [
+    const resultPath = join(GUARDRAILS_DIR, RESULT_FILE);
+    const { result, command, args } = await invokeRspec(projectRoot, [
         suitePath,
         '--options',
         optionsPath,
@@ -25,7 +28,21 @@ export async function runRspecSuite(projectRoot) {
         RSPEC_SEED,
         '--format',
         'json',
+        '--out',
+        resultPath,
     ]);
+    return { ...result, command, args, jsonReport: readReport(join(projectRoot, resultPath)) };
+}
+// Read the `--out` report file back verbatim. A missing or unreadable file is a
+// clean empty string, not a throw: the caller falls back to stdout/stderr and
+// reports a suite error, exactly as it would for unparseable output.
+function readReport(path) {
+    try {
+        return existsSync(path) ? readFileSync(path, 'utf8') : '';
+    }
+    catch {
+        return '';
+    }
 }
 // Prefer the project's own `bin/rspec`; fall back to `bundle exec rspec`. Every
 // run sets RAILS_ENV=test so guardrails execute against the Rails test
@@ -40,7 +57,7 @@ async function invokeRspec(projectRoot, rspecArgs) {
         timeoutMs: RSPEC_TIMEOUT_MS,
         env: { ...process.env, RAILS_ENV: 'test', UNITBOB_REPO_ROOT: projectRoot },
     });
-    return { ...result, command, args };
+    return { result, command, args };
 }
 function executable(path) {
     try {

package/dist/verbs/run.js

@@ -32,6 +32,7 @@ export async function run(config, _args, deps) {
         code: null,
         command: 'rspec',
         args: [],
+        jsonReport: '',
     }));
     const payload = rawRunPayload(suite.suite_digest, result);
     const summary = await d.postRun(payload);
@@ -39,8 +40,11 @@ export async function run(config, _args, deps) {
     if (summary.map_url)
         d.stdout.write(`${summary.map_url}\n`);
 }
+// The RSpec JSON report comes from the `--out` file (`jsonReport`), which the app
+// under test cannot pollute. Stdout is only a fallback for a runner double that
+// emits its report there; anything unparseable is a genuine suite error.
 function rawRunPayload(suiteDigest, result) {
-    const parsed = parseJsonObject(result.stdout);
+    const parsed = parseJsonObject(result.jsonReport) ?? parseJsonObject(result.stdout);
     if (parsed)
         return { suite_digest: suiteDigest, rspec_json: boundFailures(parsed) };
     return {

package/dist/verbs/show.js

@@ -1,5 +1,5 @@
 export function repoUrl(config) {
-    return `${config.server}/repos/${config.repoId}`;
+    return `${config.server}/repos/${config.repoId}#map`;
 }
 export async function show(config) {
     process.stdout.write(`${repoUrl(config)}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unitbob",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "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": {