@webappwiz/cli 0.0.7 → 0.0.9

package/index-pyjg1rtk.js

@@ -0,0 +1,373 @@
+// judge.ts
+import {
+  agentCommand,
+  Files,
+  Harness,
+  prompt as reviewPrompt
+} from "@webappwiz/rules";
+import { ConsoleLogger, color as color4 } from "webappwiz/log";
+import {
+  NodeFs,
+  NodeGlob,
+  NodePs as NodePs2
+} from "webappwiz/system";
+import { SystemClock } from "webappwiz/time";
+
+// 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 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";
+}
+
+// progress.ts
+import { color as color3 } from "webappwiz/log";
+import { Duration, SystemTimer } from "webappwiz/time";
+
+// report.ts
+import { color as color2 } from "webappwiz/log";
+
+// 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
+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}`;
+}
+
+// progress.ts
+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 = color3.green("█".repeat(filled)) + color3.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 `${color3.green(spin)} ${bar}  ${color3.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 title = (rule) => /^#\s+(.+)$/m.exec(rule.document)?.[1]?.trim() ?? rule.id;
+
+class JudgeCommands {
+  rules;
+  screen;
+  log;
+  fs;
+  ps;
+  clock;
+  glob;
+  constructor(rules, opts = {}) {
+    this.rules = rules;
+    this.screen = opts.screen ?? terminal();
+    this.log = opts.log ?? new ConsoleLogger;
+    this.fs = opts.fs ?? new NodeFs;
+    this.ps = opts.ps ?? new NodePs2;
+    this.clock = opts.clock ?? new SystemClock;
+    this.glob = opts.glob ?? new NodeGlob;
+  }
+  ls() {
+    const rows = [["id", "rule", "level", "files"].map(color4.dim)];
+    for (const rule of this.rules.rules) {
+      rows.push([rule.id, title(rule), rule.level, rule.files]);
+    }
+    this.log.info(table(rows).join(`
+`));
+  }
+  show(opts) {
+    const all = this.rules.rules;
+    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 = [
+      [color4.dim("id"), rule.id],
+      [color4.dim("rule"), title(rule)],
+      [color4.dim("level"), rule.level],
+      [color4.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 { table, JudgeCommands };

package/index.js

@@ -6,17 +6,13 @@ import {
   update,
   update1 as update2,
   version
-} from "./index-6km6e845.js";
+} from "./index-g81gg9gz.js";
 import {
-  JUDGE_RULES,
-  SIGNOFF_RULES
-} from "./index-3p0t2exn.js";
-import {
-  Signoff
-} from "./index-3k3rtw49.js";
+  JUDGE_RULES
+} from "./index-htwb54c6.js";
 import {
   JudgeCommands
-} from "./index-jbrs6gqt.js";
+} from "./index-pyjg1rtk.js";
 
 // index.ts
 import { NodeFs, NodeGlob } from "webappwiz/system";
@@ -34,14 +30,7 @@ webappwiz.command("update").description("pin every webappwiz dependency in a tre
   default: version,
   description: "version to pin to"
 }).action((opts, { log, fs }) => update2({ ...opts, log, fs }));
-var judge = ({ log, fs, ps, clock, glob }) => new JudgeCommands(JUDGE_RULES, {
-  signoffRules: SIGNOFF_RULES,
-  log,
-  fs,
-  ps,
-  clock,
-  glob
-});
+var judge = ({ log, fs, ps, clock, glob }) => new JudgeCommands(JUDGE_RULES, { log, fs, ps, clock, glob });
 webappwiz.command("judge").description("check a directory against the config, one agent per glob").arg("dir", t.string(), {
   default: ".",
   description: "directory to judge (default: .)"
@@ -52,39 +41,17 @@ webappwiz.command("judge").description("check a directory against the config, on
 }).option("print", t.boolean(), {
   default: false,
   description: "print the prompts and run no agent at all"
-}).option("estimate", t.boolean(), {
-  default: false,
-  description: "print what a run would read, and run nothing"
 }).option("chunk", t.number(), {
   default: 25,
   description: "files per review"
 }).option("since", t.optional(t.string()), {
   description: "only check files added or changed since this git ref"
-}).option("budget", t.number(), {
-  default: 200000,
-  description: "confirm before reading more than this many tokens"
-}).action((opts, deps) => judge(deps).judge(opts));
-webappwiz.command("signoff").description("weigh a change against the rules that ask for a person").arg("dir", t.string(), {
-  default: ".",
-  description: "directory whose change is weighed (default: .)"
-}).option("agent", t.optional(t.enum(Object.keys(AGENTS))), {
-  description: "model to weigh it with (default: the config's agent)"
-}).option("exec", t.optional(t.string()), {
-  description: "command the prompt is passed to, instead of --agent"
-}).option("print", t.boolean(), {
+}).option("concurrency-override", t.optional(t.number()), {
+  description: "agent calls in flight at once, over the config's concurrency"
+}).option("ci", t.boolean(), {
   default: false,
-  description: "print the rules to apply yourself, and run no agent"
-}).option("since", t.string(), {
-  default: "main",
-  description: "the ref the change is measured against"
-}).option("budget", t.number(), {
-  default: 200000,
-  description: "confirm before reading more than this many tokens"
-}).action((opts, { log, ps, clock }) => new Signoff(SIGNOFF_RULES, JUDGE_RULES.agent, {
-  log,
-  ps,
-  clock
-}).run(opts));
+  description: "line-by-line output with no live progress block"
+}).action((opts, deps) => judge(deps).judge(opts));
 var rules = webappwiz.group("rules").description("list and print the rules, to run or to read yourself");
 rules.command("ls").description("list the rules").action((_opts, deps) => judge(deps).ls());
 rules.command("show").description("print one rule in full, by the id `rules ls` gives it").arg("id", t.string(), { description: "rule id" }).action((opts, deps) => judge(deps).show(opts));

package/judge.d.ts

@@ -1,11 +1,8 @@
-import { type Rule, type RuleSet } from "@webappwiz/rules";
+import { type RuleSet } from "@webappwiz/rules";
 import { type Logger } from "webappwiz/log";
 import { type Fs, type Glob, type Ps } from "webappwiz/system";
 import { type Clock } from "webappwiz/time";
-/** Asked before a run spends more than it was allowed to. */
-export interface Confirm {
-    confirm(question: string): boolean | Promise<boolean>;
-}
+import { type Screen } from "./progress.js";
 export interface ShowOptions {
     /** The rule to print, as `rules ls` lists it. */
     id: string;
@@ -17,27 +14,19 @@ export interface JudgeOptions {
     exec?: string;
     /** Print the prompts to the logger and spawn nothing. */
     print?: boolean;
-    /** Print what a run would read and stop. */
-    estimate?: boolean;
     /** Files per review. */
     chunk: number;
     /** Narrows the run to what git says has changed since this ref. */
     since?: string;
-    /** Tokens a run may read before it asks whether you meant it. */
-    budget: number;
+    /** Agent calls in flight at once, over the config's `concurrency`. */
+    "concurrency-override"?: number;
+    /** Line-by-line output with no live block, the way a log wants it. */
+    ci?: boolean;
 }
-/**
- * Answers on the terminal, and answers no without one: a run nobody is watching
- * should stop and say the number rather than block forever waiting to be told
- * to go ahead.
- */
-export declare const ask: Confirm;
 /** What a `JudgeCommands` runs through, and what else it lists. */
 export interface JudgeCommandsOptions {
-    /** Rules only a reader applies, listed beside the ones a run checks. */
-    signoffRules?: Rule[];
-    /** Who is asked before a run goes over budget; the terminal by default. */
-    confirmer?: Confirm;
+    /** Where live progress draws; this process's terminal by default. */
+    screen?: Screen;
     log?: Logger;
     fs?: Fs;
     ps?: Ps;
@@ -46,24 +35,18 @@ export interface JudgeCommandsOptions {
 }
 export declare class JudgeCommands {
     private rules;
-    private signoffRules;
-    private confirmer;
+    private screen;
     private log;
     private fs;
     private ps;
     private clock;
     private glob;
     constructor(rules: RuleSet, opts?: JudgeCommandsOptions);
-    /**
-     * Lists every rule there is, one row each, ids first for citing. The rules a
-     * run checks and the ones only a reader applies are one list with a SET
-     * column, because "what rules are there" is one question.
-     */
+    /** Lists every rule there is, one row each, ids first for citing. */
     ls(): void;
     /**
      * Prints one rule in full: what it covers, and the document an agent is
-     * given, verbatim. Take the id from `rules ls` or from a finding. This is
-     * how a reader applies a rule nothing runs for them.
+     * given, verbatim. Take the id from `rules ls` or from a finding.
      */
     show(opts: ShowOptions): void;
     /**
@@ -72,28 +55,9 @@ export declare class JudgeCommands {
      * it spawns nothing and prints the prompts instead, for an agent that would
      * rather hand them to subagents of its own.
      *
-     * `since` narrows the run to what git says has changed, and `budget` caps
-     * what it may read before asking whether you meant it. Under `estimate` it
-     * prints that size and stops, which is the answer to "what would this cost"
-     * without having to guess a budget low enough to be refused.
+     * `since` narrows the run to what git says has changed.
      */
     judge(opts: JudgeOptions): Promise<void>;
-    /**
-     * Measures what one call cost over the files it was handed and leaves that
-     * behind, so the next `--estimate` on this agent has something better than a
-     * floor. Per call rather than per token, because that is how the charge
-     * falls: an agent pays for its own system prompt once per spawn, whatever it
-     * was asked to read, so a figure taken from a two-call run still holds for a
-     * fifteen-call one.
-     *
-     * A run nobody priced records nothing, and a failed write is said aloud
-     * rather than thrown: the agents have already been paid for by this point,
-     * and losing the measurement costs the next estimate accuracy, not the run.
-     */
-    private record;
     /** The agent a command runs with: what it was told, else the config's. */
     private agent;
-    /** The model a run asks, or undefined for an `--exec` command, which is a
-     * model nothing here can name or price. */
-    private model;
 }

package/judge.js

@@ -1,8 +1,6 @@
 import {
-  JudgeCommands,
-  ask
-} from "./index-jbrs6gqt.js";
+  JudgeCommands
+} from "./index-pyjg1rtk.js";
 export {
-  ask,
   JudgeCommands
 };

package/mode.d.ts

@@ -1,6 +1,6 @@
 /** What a command does with the plan it has made. */
-export type Mode = "print" | "estimate" | "run";
-/** The flags that choose between the three, on top of the two that name an
+export type Mode = "print" | "run";
+/** The flags that choose between the two, on top of the two that name an
  * agent. */
 export interface ModeOptions {
     /** A model to ask. */
@@ -9,15 +9,13 @@ export interface ModeOptions {
     exec?: string;
     /** Print to the logger and spawn nothing. */
     print?: boolean;
-    /** Print what a run would read, and spawn nothing. */
-    estimate?: boolean;
 }
 /**
- * Which of the three a caller asked for, with running the default: a command
+ * Which of the two a caller asked for, with running the default: a command
  * given nothing but a directory is one somebody means to run.
  *
  * Naming two is an error rather than a quiet winner. All of these say what to
  * do with one plan, and letting one silently beat the other would leave a
  * caller unsure which of the two things they asked for they got.
  */
-export declare function mode({ print, estimate, agent, exec }: ModeOptions): Mode;
+export declare function mode({ print, agent, exec }: ModeOptions): Mode;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@webappwiz/cli",
-	"version": "0.0.7",
-	"description": "The webappwiz CLI: judge code against rules, sign off a diff, and manage agent skills",
+	"version": "0.0.9",
+	"description": "The webappwiz CLI: judge code against rules and manage agent skills",
 	"license": "MIT",
 	"author": "Jared Johnson",
 	"repository": {
@@ -17,8 +17,8 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@webappwiz/rules": "^0.0.7",
-		"webappwiz": "^0.0.7"
+		"@webappwiz/rules": "^0.0.9",
+		"webappwiz": "^0.0.9"
 	},
 	"peerDependencies": {
 		"typescript": "^7"
@@ -41,10 +41,6 @@
 		"./judge": {
 			"types": "./judge.d.ts",
 			"default": "./judge.js"
-		},
-		"./signoff": {
-			"types": "./signoff.d.ts",
-			"default": "./signoff.js"
 		}
 	},
 	"bin": {