baro-ai 0.118.4 → 0.118.7

package/bin/baro

@@ -3,9 +3,21 @@
 // shebang, and a #!/bin/sh bin makes the Windows shim invoke sh.exe (absent on
 // Windows). A node shebang yields correct cmd/ps1/sh shims on every platform.
 import { spawnSync } from "node:child_process"
-import { existsSync } from "node:fs"
+import { existsSync, readFileSync } from "node:fs"
 import { homedir } from "node:os"
 import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+import { selfUpdate } from "./self-update.mjs"
+
+const argv = process.argv.slice(2)
+try {
+    const packageJson = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json")
+    const packageVersion = JSON.parse(readFileSync(packageJson, "utf8")).version
+    await selfUpdate({ packageVersion, argv })
+} catch {
+    // An update that cannot be attempted never stops baro from starting.
+}
 
 const bin = path.join(
     homedir(),
@@ -19,7 +31,7 @@ if (!existsSync(bin)) {
     process.exit(1)
 }
 
-const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" })
+const result = spawnSync(bin, argv, { stdio: "inherit" })
 if (result.error) {
     console.error(`baro: failed to launch binary: ${result.error.message}`)
     process.exit(1)

package/bin/self-update.mjs

@@ -0,0 +1,122 @@
+// A hand-started baro brings itself up to date before it runs. The runner
+// already did this for services; a person running `baro` stayed on whatever
+// they had installed until they noticed the banner.
+import { spawnSync } from "node:child_process"
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+
+const CACHE_TTL_MS = 3 * 3600_000
+const FETCH_TIMEOUT_MS = 2500
+const QUICK_COMMANDS = new Set(["--version", "-V", "--help", "-h", "connect"])
+
+export function semverLt(a, b) {
+    const parts = (v) => String(v).split(".").map((x) => Number.parseInt(x, 10) || 0)
+    const [pa, pb] = [parts(a), parts(b)]
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0)
+    }
+    return false
+}
+
+/**
+ * Why this invocation must not update, or null when it may. Automation keeps
+ * the version it was given; the runner updates itself between runs; and the
+ * staged bundles are shared, so replacing them under a live run breaks it.
+ */
+export function skipReason({ argv, env, isTTY, liveRuns }) {
+    if (env.BARO_NO_SELF_UPDATE === "1") return "BARO_NO_SELF_UPDATE=1"
+    if (env.CI) return "CI"
+    if (!isTTY) return "not a terminal"
+    if (argv.includes("--headless")) return "headless"
+    if (argv.some((arg) => QUICK_COMMANDS.has(arg))) return "quick command"
+    if (liveRuns > 0) return "another baro run is active"
+    return null
+}
+
+function baroHome() {
+    return path.join(homedir(), ".baro")
+}
+
+function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, "utf8"))
+    } catch {
+        return null
+    }
+}
+
+/** The version the binary and its bundles are actually staged at. */
+export function installedVersion(packageVersion) {
+    return readJson(path.join(baroHome(), "bin", "bundle-version.json"))?.version ?? packageVersion
+}
+
+export function liveRunCount() {
+    try {
+        const dir = path.join(baroHome(), "live")
+        return readdirSync(dir).filter((name) => {
+            const pid = readJson(path.join(dir, name))?.pid
+            if (!Number.isInteger(pid)) return false
+            try {
+                process.kill(pid, 0)
+                return true
+            } catch (error) {
+                return error.code === "EPERM"
+            }
+        }).length
+    } catch {
+        return 0
+    }
+}
+
+export async function latestVersion(now = Date.now()) {
+    const cachePath = path.join(baroHome(), "update-check.json")
+    const cached = readJson(cachePath)
+    if (cached?.latest && cached.checkedAt && now - cached.checkedAt < CACHE_TTL_MS) {
+        return cached.latest
+    }
+    try {
+        const response = await fetch("https://registry.npmjs.org/baro-ai/latest", {
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        })
+        const latest = (await response.json())?.version
+        if (typeof latest !== "string") return null
+        try {
+            mkdirSync(baroHome(), { recursive: true })
+            writeFileSync(cachePath, JSON.stringify({ latest, checkedAt: now }))
+        } catch {
+            // A read-only home only costs the next start another lookup.
+        }
+        return latest
+    } catch {
+        return null
+    }
+}
+
+/**
+ * Update when a newer baro is published. Never throws and never blocks a run
+ * for long: offline, a failed install or a root-owned global prefix all fall
+ * through to the version already installed.
+ */
+export async function selfUpdate({ packageVersion, argv, env = process.env, isTTY = process.stdin.isTTY }) {
+    const reason = skipReason({ argv, env, isTTY: Boolean(isTTY), liveRuns: 0 })
+    if (reason) return { updated: false, reason }
+    const current = installedVersion(packageVersion)
+    const latest = await latestVersion()
+    if (!latest || !semverLt(current, latest)) return { updated: false, reason: "up to date" }
+    if (liveRunCount() > 0) {
+        console.error(`baro ${latest} is available; not updating while another baro run is active.`)
+        return { updated: false, reason: "another baro run is active" }
+    }
+    console.error(`Updating baro ${current} → ${latest}…`)
+    const result = spawnSync("npm", ["install", "-g", `baro-ai@${latest}`], {
+        stdio: ["ignore", "ignore", "inherit"],
+        shell: process.platform === "win32",
+    })
+    if (result.status !== 0 || installedVersion(packageVersion) !== latest) {
+        console.error(`Could not update baro automatically. Update with: npm i -g baro-ai@latest`)
+        return { updated: false, reason: "install failed" }
+    }
+    console.error(`baro ${latest} installed.`)
+    return { updated: true, reason: null }
+}

package/dist/cli.mjs

@@ -44719,6 +44719,18 @@ function javaRuns(env) {
     return false;
   }
 }
+function resolveJvmBuildTool(cwd, kind, probe2 = {}) {
+  const env = probe2.env ?? process.env;
+  const windows = (probe2.platform ?? process.platform) === "win32";
+  if (!(probe2.javaRuns ?? javaRuns)(env)) return null;
+  return kind === "maven" ? wrapperOrTool(cwd, windows ? "mvnw.cmd" : "mvnw", "mvn", env, windows) : wrapperOrTool(cwd, windows ? "gradlew.bat" : "gradlew", "gradle", env, windows);
+}
+function isMavenRepository(cwd) {
+  return MAVEN_FILES.some((name) => existsSync4(join7(cwd, name)));
+}
+function isGradleRepository(cwd) {
+  return GRADLE_FILES.some((name) => existsSync4(join7(cwd, name)));
+}
 function wrapperOrTool(cwd, wrapper, tool, env, windows) {
   if (isFile(join7(cwd, wrapper))) return windows ? `.\\${wrapper}` : `./${wrapper}`;
   return onPath(tool, env, windows) ? tool : null;
@@ -45011,6 +45023,10 @@ function dispatchDeclared(cwd, requirement, parsed, packageManagers, insideDdev)
       args: ["diff", "--no-ext-diff", "--no-textconv", "--check"]
     };
   }
+  if (tool === "mvn" || tool === "./mvnw") return translateMaven(cwd, requirement, parsed);
+  if (tool === "gradle" || tool === "./gradlew") {
+    return translateGradle(cwd, requirement, parsed);
+  }
   if (tool === "composer") return translateComposer(cwd, requirement, parsed);
   if (tool === "vendor/bin/phpunit") {
     return translatePhpunit(cwd, requirement, parsed);
@@ -45026,7 +45042,7 @@ function dispatchDeclared(cwd, requirement, parsed, packageManagers, insideDdev)
   }
   return incomplete(
     requirement,
-    "unsupported declared test; allowed tools are npm/pnpm/yarn, exact npx rstest run paths, cargo, node, git diff --check, composer, vendor/bin/phpunit, and ddev exec"
+    "unsupported declared test; allowed tools are npm/pnpm/yarn, exact npx rstest run paths, cargo, node, mvn, gradle, git diff --check, composer, vendor/bin/phpunit, and ddev exec"
   );
 }
 var CD_PREFIX = /^cd\s+([^\s&]+)\s*&&\s*([^]*)$/;
@@ -45639,6 +45655,95 @@ function translateCargo(cwd, requirement, parsed) {
     args
   };
 }
+var MAVEN_GOALS = /* @__PURE__ */ new Set(["test", "verify", "package", "compile", "test-compile"]);
+var MAVEN_FLAGS = /* @__PURE__ */ new Set([
+  "-B",
+  "--batch-mode",
+  "-ntp",
+  "--no-transfer-progress",
+  "-q",
+  "--quiet",
+  "-o",
+  "--offline",
+  "-e",
+  "-am",
+  "--also-make"
+]);
+var MAVEN_PROPERTY = /^-D(?:test|failIfNoTests|surefire\.failIfNoSpecifiedTests|skipITs)=[A-Za-z0-9_.,*#+!$-]+$/;
+var JVM_MODULE = /^[A-Za-z0-9_./:-]+$/;
+function translateMaven(cwd, requirement, parsed) {
+  if (!isMavenRepository(cwd)) {
+    return incomplete(requirement, "declared mvn test requires pom.xml at the repository root");
+  }
+  const args = parsed.tokens.slice(1);
+  let goals = 0;
+  for (let index = 0; index < args.length; index++) {
+    const token = args[index];
+    if (MAVEN_GOALS.has(token)) {
+      goals++;
+    } else if (token === "-pl" || token === "--projects") {
+      const module = args[++index];
+      if (!module || !JVM_MODULE.test(module) || hasParentTraversal(module)) {
+        return incomplete(requirement, "mvn -pl needs a module path inside the repository");
+      }
+    } else if (!MAVEN_FLAGS.has(token) && !MAVEN_PROPERTY.test(token)) {
+      return incomplete(
+        requirement,
+        `mvn declarations are limited to test, verify, package, compile and test-compile with batch/offline flags, -pl and -Dtest; unsupported '${token}'`
+      );
+    }
+  }
+  if (goals !== 1) {
+    return incomplete(requirement, "mvn declaration must name exactly one goal");
+  }
+  const tool = resolveJvmBuildTool(cwd, "maven");
+  if (!tool) {
+    return incomplete(requirement, "this host has no working JDK and Maven (or ./mvnw) to run the declared test");
+  }
+  return { label: ["mvn", ...args].join(" "), tool, args };
+}
+var GRADLE_TASK = /^(?::[A-Za-z0-9_-]+)*:?(?:test|check|build|assemble)$/;
+var GRADLE_FLAGS = /* @__PURE__ */ new Set([
+  "--console=plain",
+  "--offline",
+  "--no-daemon",
+  "-q",
+  "--quiet",
+  "--stacktrace",
+  "--continue"
+]);
+var GRADLE_TEST_FILTER = /^[A-Za-z0-9_.*$]+$/;
+function translateGradle(cwd, requirement, parsed) {
+  if (!isGradleRepository(cwd)) {
+    return incomplete(requirement, "declared gradle test requires a Gradle build at the repository root");
+  }
+  const args = parsed.tokens.slice(1);
+  let tasks = 0;
+  for (let index = 0; index < args.length; index++) {
+    const token = args[index];
+    if (GRADLE_TASK.test(token)) {
+      tasks++;
+    } else if (token === "--tests") {
+      const filter = args[++index];
+      if (!filter || !GRADLE_TEST_FILTER.test(filter)) {
+        return incomplete(requirement, "gradle --tests needs a class or method filter");
+      }
+    } else if (!GRADLE_FLAGS.has(token)) {
+      return incomplete(
+        requirement,
+        `gradle declarations are limited to test, check, build and assemble tasks with --tests; unsupported '${token}'`
+      );
+    }
+  }
+  if (tasks === 0) {
+    return incomplete(requirement, "gradle declaration must name a test, check, build or assemble task");
+  }
+  const tool = resolveJvmBuildTool(cwd, "gradle");
+  if (!tool) {
+    return incomplete(requirement, "this host has no working JDK and Gradle (or ./gradlew) to run the declared test");
+  }
+  return { label: ["gradle", ...args].join(" "), tool, args };
+}
 function containedPath(cwd, candidate, requireFile) {
   if (candidate === "" || candidate.startsWith("-") || candidate.startsWith("@") || isAbsolute3(candidate) || /^[A-Za-z]:\//.test(candidate) || hasParentTraversal(candidate)) return { reason: `unsafe or escaping path '${candidate}'` };
   const root = resolve5(cwd);
@@ -70765,8 +70870,13 @@ var Finalizer = class extends BaseObserver {
         hostRepoRoot: this.opts.hostRepoRoot
       });
     }
-    const verificationIncomplete = !verify.ran || verify.commands.some((command) => command.status === "skipped");
-    if (!verify.ok) {
+    const hygieneOnly = verify.ok && provesOnlyHygiene(
+      verify.commands.filter((command) => command.command !== VERDICT_COMMAND)
+    );
+    const verificationIncomplete = !hygieneOnly && (!verify.ran || verify.commands.some((command) => command.status === "skipped"));
+    if (hygieneOnly) {
+      this.log("[finalizer] not test-verified: only git diff --check ran on the merged result");
+    } else if (!verify.ok) {
       this.log(`[finalizer] \u26A0 verification failed: ${verify.failures[0]?.cmd ?? "build/test"}`);
     } else if (!verify.ran) {
       this.log("[finalizer] nothing to verify (no build/test)");
@@ -70783,6 +70893,7 @@ var Finalizer = class extends BaseObserver {
       prd,
       run,
       checkpoint,
+      hygieneOnly,
       verify,
       orderedStories,
       passed,
@@ -71075,7 +71186,14 @@ ${BARO_COAUTHOR_TRAILER}`,
     const skippedVerification = args.verify.commands.filter(
       (command) => command.status === "skipped"
     );
-    if (!args.verify.ran || skippedVerification.length > 0) {
+    if (args.hygieneOnly) {
+      lines.push("## Not test-verified");
+      lines.push("");
+      lines.push(
+        "The only check run on the merged branch was `git diff --check`. No build or test command verified it; run the project's tests before merging."
+      );
+      lines.push("");
+    } else if (!args.verify.ran || skippedVerification.length > 0) {
       lines.push("## \u26A0 Build/test verification incomplete");
       lines.push("");
       lines.push(
@@ -71207,11 +71325,12 @@ function bindAuthority2(current, authority, label) {
   }
   return authority;
 }
+var VERDICT_COMMAND = "objective verification verdict";
 function verificationResult(evidence) {
   const commands = evidence.commands.map((command) => ({ ...command }));
   if (evidence.status === "skipped" && !commands.some((command) => command.status === "skipped")) {
     commands.push({
-      command: "objective verification verdict",
+      command: VERDICT_COMMAND,
       status: "skipped",
       durationMs: 0,
       tail: "verifier reported an incomplete/skipped objective gate"