@webappwiz/cli 0.0.6 → 0.0.8

package/README.md

@@ -59,16 +59,17 @@ of files.
 
 ```bash
 bunx @webappwiz/cli judge . --agent haiku
-bunx @webappwiz/cli judge . --estimate        # what would this read, and cost
 bunx @webappwiz/cli judge . --print           # print the prompts, spawn nothing
 bunx @webappwiz/cli judge . --since main      # only what changed
+bunx @webappwiz/cli judge . --ci              # plain lines, no live block
 ```
 
 Each rule's code half runs first, free, and only what it escalates reaches an
-agent. `--budget` caps what a run may read before it asks whether you meant it;
-`--estimate` answers that without having to guess a budget low enough to be
-refused. `--print`, `--estimate` and running are three things to do with one
-plan, so passing two of them is an error rather than one quietly winning. Code excuses itself from a rule with a `rule-ignore <id>: <reason>`
+agent. On a terminal a run draws a live status line (a bar over the calls,
+how many are out, and the tokens spent so far), then dumps the report in one
+block; `--ci`, or any output that is not a terminal, prints line by line as
+reviews finish instead. `--print` and running are two things to do with one
+plan, so passing both is an error rather than one quietly winning. Code excuses itself from a rule with a `rule-ignore <id>: <reason>`
 comment above the line, or `rule-ignore-file <id>: <reason>` for the file.
 
 ## update
@@ -100,11 +101,15 @@ bunx @webappwiz/cli skills update ./project
 ```
 
 ```
-SKILL  SHIPS  INSTALLED
-arbor  1.4.0  1.3.0
-other  1.4.0  -
+SKILL      SHIPS  INSTALLED
+arbor      1.4.0  1.3.0
+webappwiz  1.4.0  -
 ```
 
+Two ship: `arbor`, which lands an agent's work from its own worktree, and
+`webappwiz`, which sends an agent to the package's catalogue before it writes
+infrastructure by hand.
+
 `add` installs one skill by name. `update` refreshes the ones a project already
 has and never installs a new one: which skills a project uses is its own
 business, and a skill nobody chose should not arrive by way of an update. `ls`

package/index-4xj59vmx.js

@@ -0,0 +1,135 @@
+// changed.ts
+import { NodePs } from "webappwiz/system";
+async function changed(dir, ref, opts = {}) {
+  const ps = opts.ps ?? new NodePs;
+  const files = new Set;
+  for (const argv of [
+    ["diff", "--name-only", "--diff-filter=d", "--relative", ref],
+    ["ls-files", "--others", "--exclude-standard"]
+  ]) {
+    for (const line of (await git(ps, dir, argv)).split(`
+`)) {
+      if (line !== "") {
+        files.add(line);
+      }
+    }
+  }
+  return files;
+}
+async function diff(dir, ref, opts = {}) {
+  const ps = opts.ps ?? new NodePs;
+  const patch = await git(ps, dir, ["diff", "--relative", ref]);
+  const added = (await git(ps, dir, ["ls-files", "--others", "--exclude-standard"])).split(`
+`).filter((line) => line !== "");
+  return { patch: patch.trim(), added };
+}
+async function git(ps, dir, argv) {
+  const { exitCode, stdout, stderr } = await ps.spawnCapture([
+    "git",
+    "-C",
+    dir,
+    ...argv
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`git ${argv[0]} failed in ${dir}: ${stderr.trim() || `exit ${exitCode}`}`);
+  }
+  return stdout;
+}
+
+// mode.ts
+function mode({ print, agent, exec }) {
+  const named = [
+    print === true ? "--print" : undefined,
+    agent === undefined ? undefined : "--agent",
+    exec === undefined ? undefined : "--exec"
+  ].filter((flag) => flag !== undefined);
+  if (named.length > 1) {
+    throw new Error(`${named.join(" and ")} are different things to do with one run, so pass one`);
+  }
+  return print === true ? "print" : "run";
+}
+
+// table.ts
+import { color } from "webappwiz/log";
+var table = (rows) => {
+  const width = (cell) => color.strip(cell).length;
+  const widths = rows[0]?.map((_, i) => Math.max(...rows.map((row) => width(row[i] ?? ""))));
+  return rows.map((row) => row.map((cell, i) => cell.padEnd((widths?.[i] ?? 0) + cell.length - width(cell))).join("   ").trimEnd());
+};
+
+// report.ts
+import { color as color2 } from "webappwiz/log";
+var count = (total, word) => `${total} ${word}${total === 1 ? "" : "s"}`;
+var divider = (name) => {
+  if (name === undefined) {
+    return color2.dim("-".repeat(72));
+  }
+  const opening = `--- ${name} `;
+  return color2.dim(opening.padEnd(Math.max(72, opening.length + 3), "-"));
+};
+var compact = new Intl.NumberFormat("en", { notation: "compact" });
+var tokens = (bytes) => Math.ceil(bytes / 4);
+function planned({
+  files,
+  rules,
+  calls,
+  estimate,
+  concurrency,
+  agent
+}) {
+  const rows = [
+    [color2.dim("files"), String(files)],
+    [color2.dim("rules"), String(rules)],
+    [color2.dim("calls"), String(calls)],
+    ...concurrency === undefined ? [] : [[color2.dim("workers"), String(concurrency)]],
+    [color2.dim("reading"), `${compact.format(estimate)}+ tokens`]
+  ];
+  if (agent !== undefined) {
+    rows.push([color2.dim("agent"), agent]);
+  }
+  return ["", ...table(rows).map((line) => `  ${line}`), ""];
+}
+function finished({
+  rules,
+  files,
+  violations,
+  took,
+  tokens: tokens2,
+  worker,
+  workerTokens,
+  done,
+  total
+}) {
+  const heading = `${color2.gray(`[${done}/${total}]`)} ` + color2.gray(`(${count(rules.length, "rule")}, ${count(files, "file")})`);
+  const spent = tokens2 === undefined ? "" : `  ${compact.format(tokens2)} tokens` + (workerTokens === undefined ? "" : ` (w${worker + 1}: ${compact.format(workerTokens)})`);
+  const tail = `${color2.gray(`in ${took.human()}${spent}`)}`;
+  if (violations.length === 0) {
+    return [`${color2.green("✓")} ${heading}: clean ${tail}`];
+  }
+  return [
+    `${color2.red("✗")} ${heading}: ${count(violations.length, "problem")} ${tail}`,
+    ...violations.flatMap(finding)
+  ];
+}
+function finding(violation) {
+  const level = violation.level === "error" ? color2.red("error") : color2.yellow(violation.level);
+  const lines = [
+    `  ${color2.bold(`${violation.file}:${violation.line}`)}  ${level}  ${violation.message} ${color2.gray(`(${violation.id})`)}`
+  ];
+  if (violation.code !== "") {
+    lines.push(color2.gray(`  │ ${violation.code}`));
+  }
+  return lines;
+}
+function summary(violations, took, tokens2) {
+  const spent = tokens2 === undefined ? "" : `  ${compact.format(tokens2)} tokens total`;
+  const elapsed = color2.gray(`in ${took.human()}${spent}`);
+  if (violations.length === 0) {
+    return `${color2.green("✓ no violations")} ${elapsed}`;
+  }
+  const errors = violations.filter((violation) => violation.level === "error").length;
+  const line = `✖ ${count(violations.length, "problem")} (${count(errors, "error")}, ${count(violations.length - errors, "warning")})`;
+  return `${errors > 0 ? color2.red(line) : color2.yellow(line)} ${elapsed}`;
+}
+
+export { changed, diff, mode, table, count, divider, compact, tokens, planned, finished, summary };

package/{index-3k3rtw49.js → index-fh8js68z.js}

@@ -1,13 +1,10 @@
 import {
-  ask,
   count,
   diff,
   divider,
   mode,
-  overBudget,
-  tokens,
-  usd
-} from "./index-jbrs6gqt.js";
+  tokens
+} from "./index-4xj59vmx.js";
 
 // signoff.ts
 import {
@@ -21,14 +18,12 @@ import { SystemClock } from "webappwiz/time";
 class Signoff {
   rules;
   defaultAgent;
-  confirmer;
   log;
   ps;
   clock;
   constructor(rules, defaultAgent, opts = {}) {
     this.rules = rules;
     this.defaultAgent = defaultAgent;
-    this.confirmer = opts.confirmer ?? ask;
     this.log = opts.log ?? new ConsoleLogger;
     this.ps = opts.ps ?? new NodePs;
     this.clock = opts.clock ?? new SystemClock;
@@ -46,14 +41,7 @@ class Signoff {
     }
     const agent = agentCommand(opts.exec === undefined ? { agent: opts.agent ?? this.defaultAgent } : opts);
     const review = this.review(patch, added, opts.since);
-    const predicted = tokens(review.bytes ?? 0);
-    this.log.info(`weighing ${opts.since}..working tree against ` + `${count(this.rules.length, "rule")}, reading ` + `${predicted}+ tokens with ${agent.label}`);
-    if (predicted > opts.budget) {
-      this.log.info(overBudget(predicted, opts.budget));
-      if (!await this.confirmer.confirm("Run anyway?")) {
-        throw new Error("over budget");
-      }
-    }
+    this.log.info(`weighing ${opts.since}..working tree against ` + `${count(this.rules.length, "rule")}, reading ` + `${tokens(review.bytes ?? 0)}+ tokens with ${agent.label}`);
     this.say(await this.judge(review, agent, dir));
   }
   async judge(review, agent, dir) {
@@ -62,8 +50,8 @@ class Signoff {
       ps: this.ps,
       clock: this.clock
     });
-    harness.events.on("finished", ({ took, cost }) => {
-      const spent = cost === undefined ? "" : `  ${usd(cost)}`;
+    harness.events.on("finished", ({ took, tokens: read }) => {
+      const spent = read === undefined ? "" : `  ${read} tokens`;
       this.log.info(color.gray(`read in ${took.human()}${spent}`));
     });
     return await harness.run([review], agent, { cwd: dir });

package/{index-3p0t2exn.js → index-hz6bwqfy.js}

@@ -5,6 +5,7 @@ import {
   CommentsSayWhyNotWhat,
   DevServersFindAPort,
   DocCommentsAddressUsers,
+  ExportLeadsTheFile,
   FakesOverMocks,
   MatchersOverTestLogic,
   NamedOptionsLast,
@@ -17,17 +18,20 @@ import {
   ResourcesAreDisposable,
   SimpleTestSetup,
   TestsNotWeakened,
+  TestsOwnTheirState,
   VisualWorkTested
 } from "@webappwiz/rules/catalog";
 var JUDGE_RULES = defineRules({
   rules: [
     new NoEmDashes,
     new OneClassPerFile,
+    new ExportLeadsTheFile,
     new ParametersDeclareFields,
     new ClassesOverFunctionExports,
     new ObjectsOverCallbacks,
     new NamedOptionsLast,
     new SimpleTestSetup,
+    new TestsOwnTheirState,
     new FakesOverMocks,
     new MatchersOverTestLogic,
     new CommentsSayWhyNotWhat,

package/index-r14q0cmx.js

@@ -0,0 +1,262 @@
+import {
+  changed,
+  compact,
+  count,
+  divider,
+  finished,
+  mode,
+  planned,
+  summary,
+  table,
+  tokens
+} from "./index-4xj59vmx.js";
+
+// judge.ts
+import {
+  agentCommand,
+  Files,
+  Harness,
+  prompt as reviewPrompt
+} from "@webappwiz/rules";
+import { ConsoleLogger, color as color2 } from "webappwiz/log";
+import {
+  NodeFs,
+  NodeGlob,
+  NodePs
+} from "webappwiz/system";
+import { SystemClock } from "webappwiz/time";
+
+// progress.ts
+import { color } from "webappwiz/log";
+import { Duration, SystemTimer } from "webappwiz/time";
+var terminal = () => ({
+  tty: process.stdout.isTTY === true,
+  write: (text) => process.stdout.write(text)
+});
+var BAR = 20;
+var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function render(view, frame = 0) {
+  const spin = view.files === 0 ? " " : FRAMES[frame % FRAMES.length] ?? " ";
+  const filled = Math.round(BAR * view.done / Math.max(1, view.total));
+  const bar = color.green("█".repeat(filled)) + color.dim("░".repeat(BAR - filled));
+  const judging = view.files === 0 ? "" : ` · judging ${count(view.files, "file")}`;
+  const spent = view.tokens === undefined ? "" : ` · ${compact.format(view.tokens)} tokens`;
+  const found = view.done === 0 ? "" : ` · ${view.problems === 0 ? "clean so far" : count(view.problems, "problem")}`;
+  return `${color.green(spin)} ${bar}  ${color.gray(`${view.done}/${view.total} calls${judging}${spent}${found}`)}`;
+}
+
+class Progress {
+  screen;
+  total;
+  done = 0;
+  files = 0;
+  problems = 0;
+  tokens;
+  drawn = false;
+  frame = 0;
+  ticking;
+  constructor(screen, total, opts = {}) {
+    this.screen = screen;
+    this.total = total;
+    const timer = opts.timer ?? new SystemTimer;
+    this.ticking = timer.setInterval(() => {
+      this.frame += 1;
+      this.draw();
+    }, Duration.ms(100));
+  }
+  started(files) {
+    this.files += files;
+    this.draw();
+  }
+  finished(files, spent, problems = 0) {
+    this.files -= files;
+    this.done += 1;
+    this.problems += problems;
+    if (spent !== undefined) {
+      this.tokens = (this.tokens ?? 0) + spent;
+    }
+    this.draw();
+  }
+  stop() {
+    this.ticking.dispose();
+    this.erase();
+  }
+  erase() {
+    if (this.drawn) {
+      this.screen.write("\x1B[1A\r\x1B[0J");
+      this.drawn = false;
+    }
+  }
+  draw() {
+    const line = render({
+      done: this.done,
+      total: this.total,
+      files: this.files,
+      tokens: this.tokens,
+      problems: this.problems
+    }, this.frame);
+    this.erase();
+    this.screen.write(`${line}
+`);
+    this.drawn = true;
+  }
+}
+
+// judge.ts
+var estimated = (reviews) => tokens(reviews.reduce((bytes, review) => bytes + review.bytes, 0));
+var isFileRule = (rule) => ("files" in rule);
+var title = (rule) => /^#\s+(.+)$/m.exec(rule.document)?.[1]?.trim() ?? rule.id;
+
+class JudgeCommands {
+  rules;
+  signoffRules;
+  screen;
+  log;
+  fs;
+  ps;
+  clock;
+  glob;
+  constructor(rules, opts = {}) {
+    this.rules = rules;
+    this.signoffRules = opts.signoffRules ?? [];
+    this.screen = opts.screen ?? terminal();
+    this.log = opts.log ?? new ConsoleLogger;
+    this.fs = opts.fs ?? new NodeFs;
+    this.ps = opts.ps ?? new NodePs;
+    this.clock = opts.clock ?? new SystemClock;
+    this.glob = opts.glob ?? new NodeGlob;
+  }
+  ls() {
+    const rows = [["id", "rule", "set", "level", "files"].map(color2.dim)];
+    for (const rule of this.rules.rules) {
+      rows.push([rule.id, title(rule), "judge", rule.level, rule.files]);
+    }
+    for (const rule of this.signoffRules) {
+      rows.push([rule.id, title(rule), "signoff", "", ""]);
+    }
+    this.log.info(table(rows).join(`
+`));
+  }
+  show(opts) {
+    const all = [...this.rules.rules, ...this.signoffRules];
+    const rule = all.find((candidate) => candidate.id === opts.id);
+    if (!rule) {
+      throw new Error(`no rule "${opts.id}". Known ids: ${all.map((candidate) => candidate.id).join(", ")}`);
+    }
+    const rows = [
+      [color2.dim("id"), rule.id],
+      [color2.dim("rule"), title(rule)]
+    ];
+    if (isFileRule(rule)) {
+      rows.push([color2.dim("level"), rule.level], [color2.dim("files"), rule.files]);
+    }
+    this.log.info(table(rows).join(`
+`));
+    this.log.info("");
+    this.log.info(rule.document.trim());
+  }
+  async judge(opts) {
+    const how = mode(opts);
+    const config = this.rules;
+    const rules = config.rules;
+    const dir = opts.dir.replace(/\/+$/, "") || "/";
+    const only = opts.since === undefined ? undefined : await changed(dir, opts.since, { ps: this.ps });
+    if (only?.size === 0) {
+      this.log.info(`nothing has changed since ${opts.since}`);
+      return;
+    }
+    const files = new Files({ log: this.log, fs: this.fs, glob: this.glob });
+    const reviews = await files.plan(rules, dir, {
+      chunk: opts.chunk,
+      only
+    });
+    if (how === "print") {
+      for (const review of reviews) {
+        this.log.info(`
+${divider(`${review.label} (${count(review.files.length, "file")})`)}
+`);
+        this.log.info(reviewPrompt(review));
+      }
+      this.log.info(`
+${divider()}`);
+      return;
+    }
+    const read = new Set(reviews.flatMap((review) => review.files)).size;
+    const agent = this.agent(config, opts);
+    const concurrency = opts["concurrency-override"] ?? config.concurrency;
+    const started = this.clock.now();
+    this.log.info(planned({
+      files: read,
+      rules: rules.length,
+      calls: reviews.length,
+      estimate: estimated(reviews),
+      concurrency,
+      agent: agent.label
+    }).join(`
+`));
+    const found = [];
+    const byWorker = new Map;
+    let spent;
+    const progress = opts.ci !== true && this.screen.tty ? new Progress(this.screen, reviews.length) : undefined;
+    const deferred = [];
+    const harness = new Harness({
+      log: this.log,
+      ps: this.ps,
+      clock: this.clock
+    });
+    harness.events.on("started", ({ at }) => progress?.started(reviews[at]?.files.length ?? 0));
+    harness.events.on("finished", (review) => {
+      const at = reviews[review.at];
+      if (!at) {
+        return;
+      }
+      let workerTokens;
+      if (review.tokens !== undefined) {
+        workerTokens = (byWorker.get(review.worker) ?? 0) + review.tokens;
+        byWorker.set(review.worker, workerTokens);
+        spent = (spent ?? 0) + review.tokens;
+      }
+      const violations2 = files.violations(at, review.findings, dir);
+      found[review.at] = violations2;
+      progress?.finished(at.files.length, review.tokens, violations2.length);
+      const lines = finished({
+        rules: review.rules,
+        files: at.files.length,
+        violations: violations2,
+        took: review.took,
+        tokens: review.tokens,
+        worker: review.worker,
+        workerTokens,
+        done: review.done,
+        total: review.total
+      });
+      if (progress) {
+        deferred[review.done - 1] = lines;
+      } else {
+        for (const line of lines) {
+          this.log.info(line);
+        }
+      }
+    });
+    try {
+      await harness.run(reviews, agent, { cwd: dir, concurrency });
+    } finally {
+      progress?.stop();
+    }
+    for (const line of deferred.flat()) {
+      this.log.info(line);
+    }
+    const violations = found.flat();
+    this.log.info("");
+    this.log.info(summary(violations, this.clock.now().subtract(started), spent));
+    const errors = violations.filter((violation) => violation.level === "error").length;
+    if (errors > 0) {
+      throw new Error(count(errors, "error"));
+    }
+  }
+  agent(config, opts) {
+    return agentCommand(opts.exec === undefined ? { agent: opts.agent ?? config.agent } : opts);
+  }
+}
+
+export { JudgeCommands };