@webappwiz/arbor 0.0.8 → 0.0.9

package/config.d.ts

@@ -1,49 +1,26 @@
-export interface Config {
-    /**
-     * The integration branch name. `merge` rebases a task onto this branch and
-     * then fast-forwards it to the result; new worktrees start from it.
-     */
+import { type InferConfig } from "webappwiz/config";
+/**
+ * The settings arbor runs a repo with. `loadConfig` builds one; everything a
+ * command needs comes off it with `get`.
+ */
+export declare const CONFIG_FACTORY: import("webappwiz/config").ConfigFactory<{
     trunk: string;
-    /** Directory holding one worktree per task, a sibling of the repo. */
     worktreeRoot: string;
-    /** Command run by `add` in the new worktree, via `sh -c`. */
     postCheckout: string | null;
-    /**
-     * Command run by `merge` after the rebase, before `preMerge`, via `sh -c`.
-     * A rebase can bring in a dependency the worktree has never installed, and
-     * whatever `preMerge` runs needs it.
-     */
     postRewrite: string | null;
-    /**
-     * Command run by `merge` after the rebase, via `sh -c`. The last gate before
-     * the branch lands: a nonzero exit rolls the branch back and leaves the base
-     * untouched. Tests are the obvious thing to put here, but arbor has no
-     * opinion; a repo with nothing to run leaves it null and merges on a green
-     * rebase alone.
-     */
     preMerge: string | null;
-    /**
-     * Command run by `merge` in the main tree after the base fast-forwards, via
-     * `sh -c`. The branch has already landed and the worktree is gone: a nonzero
-     * exit reports the failure but rolls nothing back.
-     */
     postMerge: string | null;
-    /** How long since its last heartbeat before a task's lease is up for grabs. */
     leaseStalenessMs: number;
-    /** Failed `merge` attempts a task gets before it must escalate or be removed. */
     mergeRetryCount: number;
-    /**
-     * How many removed task names to keep, so `rm` can say "already removed"
-     * rather than "never existed". A flat cap with no age policy: losing the
-     * oldest costs a nicer message and nothing else.
-     */
     removedCapacity: number;
-    /** How many entries `arbor log` keeps before the oldest fall off. */
     logCapacity: number;
-}
+}>;
+export type Config = InferConfig<typeof CONFIG_FACTORY>;
+/** The plain shape behind a `Config`: what a config file exports a part of. */
+export type ConfigRecord = ReturnType<Config["toRecord"]>;
 /**
  * Identity, for the types. `export default defineConfig({ ... })` in
  * `arbor.config.ts` gets the key names and their types checked, and completion
  * while writing it; a bare object literal gets neither.
  */
-export declare function defineConfig(config: Partial<Config>): Partial<Config>;
+export declare function defineConfig(config: Partial<ConfigRecord>): Partial<ConfigRecord>;

package/config.js

@@ -1,7 +1,8 @@
-// config.ts
-function defineConfig(config) {
-  return config;
-}
-export {
+import {
+  CONFIG_FACTORY,
   defineConfig
+} from "./index-84xjmns8.js";
+export {
+  defineConfig,
+  CONFIG_FACTORY
 };

package/index-84xjmns8.js

@@ -0,0 +1,20 @@
+// config.ts
+import { Config as WizConfig } from "webappwiz/config";
+import { t } from "webappwiz/t";
+var CONFIG_FACTORY = WizConfig.factory({
+  trunk: t.string(),
+  worktreeRoot: t.string(),
+  postCheckout: t.nullable(t.string()),
+  postRewrite: t.nullable(t.string()),
+  preMerge: t.nullable(t.string()),
+  postMerge: t.nullable(t.string()),
+  leaseStalenessMs: t.number(),
+  mergeRetryCount: t.number(),
+  removedCapacity: t.number(),
+  logCapacity: t.number()
+});
+function defineConfig(config) {
+  return config;
+}
+
+export { CONFIG_FACTORY, defineConfig };

package/index.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env bun
 // @bun
+import {
+  CONFIG_FACTORY
+} from "./index-84xjmns8.js";
 
 // index.ts
 import { BunHttpServer } from "webappwiz/http/bun";
@@ -69,7 +72,7 @@ async function add({
   config,
   log,
   fs
-}, task, { base = config.trunk } = {}) {
+}, task, { base = config.get("trunk") } = {}) {
   if (!NAME.test(task)) {
     fail("usage", `invalid task name '${task}': use lowercase letters, digits and dashes`, { task });
   }
@@ -85,7 +88,7 @@ async function add({
   }
   const added = await service.add(task, { base });
   if (added.code !== 0) {
-    const missingTrunk = base === config.trunk && !await service.git.branchExists(base);
+    const missingTrunk = base === config.get("trunk") && !await service.git.branchExists(base);
     fail("usage", missingTrunk ? `trunk '${base}' is not a branch in this repo: set \`trunk\` in arbor.config.ts` : `git worktree add failed: ${added.stderr}`, { task });
   }
   const worktree = await (await service.find(task)).take({ base });
@@ -99,13 +102,14 @@ ${PLAN_FILE}
 `.trimStart());
   }
   await fs.write(`${worktree.path}/${PLAN_FILE}`, PLAN(task));
-  if (config.postCheckout) {
-    const { exitCode } = await shell.stream(config.postCheckout, {
+  const postCheckout = config.get("postCheckout");
+  if (postCheckout) {
+    const { exitCode } = await shell.stream(postCheckout, {
       cwd: worktree.path,
       env: {
         ARBOR_TASK: task,
         ARBOR_WORKTREE: worktree.path,
-        ARBOR_TRUNK: config.trunk
+        ARBOR_TRUNK: config.get("trunk")
       }
     });
     if (exitCode !== 0) {
@@ -578,8 +582,8 @@ async function merge({
   if (dirty.length > 0) {
     fail("dirty", `'${task}' has uncommitted changes: commit them before merging`, { task, paths: dirty });
   }
-  if (worktree.mergeAttempts >= config.mergeRetryCount) {
-    fail("budget_exhausted", `'${task}' has used its ${config.mergeRetryCount} merge attempts: run \`arbor escalate <reason>\`, and a human can grant another ${config.mergeRetryCount} with \`arbor retry ${task}\`; or \`arbor rm ${task}\` and start over against current ${base}`, { task, mergeAttempts: worktree.mergeAttempts });
+  if (worktree.mergeAttempts >= config.get("mergeRetryCount")) {
+    fail("budget_exhausted", `'${task}' has used its ${config.get("mergeRetryCount")} merge attempts: run \`arbor escalate <reason>\`, and a human can grant another ${config.get("mergeRetryCount")} with \`arbor retry ${task}\`; or \`arbor rm ${task}\` and start over against current ${base}`, { task, mergeAttempts: worktree.mergeAttempts });
   }
   if (worktree.leaseHeldByOther) {
     fail("lease_held", `'${task}' is held by pid ${worktree.lease?.pid} on ${worktree.lease?.hostname}: another agent is driving this tree`, { task, lease: worktree.lease });
@@ -604,7 +608,7 @@ async function merge({
     ].join(`
 `), { task, paths });
   }
-  const gate = [config.postRewrite, config.preMerge].filter(Boolean).join(" && ");
+  const gate = [config.get("postRewrite"), config.get("preMerge")].filter(Boolean).join(" && ");
   const gated = gate ? await shell.run(gate, {
     cwd: worktree.path,
     env: {
@@ -645,8 +649,9 @@ ${gated.stderr}`)
     fail("usage", `landed '${task}' on ${base} (${head}) but could not discard its worktree: ${discarded.stderr || discarded.stdout}
 Run \`arbor rm ${task}\` to clean up.`, { task });
   }
-  if (config.postMerge) {
-    const ran = await shell.run(config.postMerge, {
+  const postMerge = config.get("postMerge");
+  if (postMerge) {
+    const ran = await shell.run(postMerge, {
       cwd: git.root,
       env: { ARBOR_TASK: task }
     });
@@ -870,7 +875,7 @@ import { NodeFs as NodeFs5 } from "webappwiz/system";
 async function loadConfig(root, opts = {}) {
   const found = await file(opts.fs ?? new NodeFs5, root);
   const trunk = found.trunk ?? await (opts.git ?? new Git(root)).defaultBranch() ?? "main";
-  return { ...defaults(root, trunk), ...found };
+  return CONFIG_FACTORY.create({ ...defaults(root, trunk), ...found });
 }
 function defaults(root, trunk) {
   return {
@@ -951,7 +956,7 @@ class Worktree {
     if (!lease) {
       return false;
     }
-    if (Date.now() - Date.parse(lease.heartbeatAt) >= config.leaseStalenessMs) {
+    if (Date.now() - Date.parse(lease.heartbeatAt) >= config.get("leaseStalenessMs")) {
       return false;
     }
     return lease.hostname === ps.hostname ? ps.alive(lease.pid) : true;
@@ -1072,10 +1077,10 @@ class WorktreeService {
     await this.fs.mkdir(this.removedDir);
   }
   get trunk() {
-    return this.config.trunk;
+    return this.config.get("trunk");
   }
   pathFor(task) {
-    return resolve2(this.config.worktreeRoot, task);
+    return resolve2(this.config.get("worktreeRoot"), task);
   }
   branchFor(task) {
     return `${BRANCH_PREFIX}${task}`;
@@ -1117,8 +1122,8 @@ class WorktreeService {
     }
     return found;
   }
-  async add(task, { base = this.config.trunk } = {}) {
-    await this.fs.mkdir(this.config.worktreeRoot);
+  async add(task, { base = this.config.get("trunk") } = {}) {
+    await this.fs.mkdir(this.config.get("worktreeRoot"));
     return this.git.addWorktree(this.branchFor(task), this.pathFor(task), base);
   }
   async discard(worktree) {
@@ -1155,7 +1160,7 @@ class WorktreeService {
     return raw?.trim() ?? null;
   }
   async rememberRemoved(task, at = new Date().toISOString()) {
-    const { removedCapacity } = this.config;
+    const removedCapacity = this.config.get("removedCapacity");
     await this.fs.write(this.removedPath(task), `${at}
 `);
     const names = await this.fs.readdir(this.removedDir).catch(() => []);
@@ -1204,10 +1209,10 @@ function repository(at) {
         fs,
         ps,
         log: log2,
-        stalenessMs: config.leaseStalenessMs
+        stalenessMs: config.get("leaseStalenessMs")
       }),
       shell: new Shell({ ps }),
-      journal: new Journal(`${arborDir}/log.jsonl`, config.logCapacity, {
+      journal: new Journal(`${arborDir}/log.jsonl`, config.get("logCapacity"), {
         fs
       })
     });
@@ -1231,7 +1236,7 @@ async function retry({
   const worktree = await found.save({ status: "working", mergeAttempts: 0 });
   log2.info([
     `${color9.green("retry")} ${worktree.task}`,
-    `  attempts: 0 of ${config.mergeRetryCount}`,
+    `  attempts: 0 of ${config.get("mergeRetryCount")}`,
     `  status:   working`,
     "",
     `Run \`arbor claim ${worktree.task}\` to pick it up.`

package/load-config.d.ts

@@ -1,5 +1,5 @@
 import { type Fs } from "webappwiz/system";
-import type { Config } from "./config.js";
+import { type Config } from "./config.js";
 import { Git } from "./git.js";
 export interface LoadConfigOptions {
     /** What `arbor.config.ts` is looked for through; the real one by default. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webappwiz/arbor",
-	"version": "0.0.8",
+	"version": "0.0.9",
 	"description": "Runs several AI coding agents on one repository at once, each in its own git worktree",
 	"license": "MIT",
 	"author": "Jared Johnson",
@@ -17,7 +17,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"webappwiz": "^0.0.8"
+		"webappwiz": "^0.0.9"
 	},
 	"main": "./index.js",
 	"types": "./index.d.ts",