@webappwiz/cli 0.0.7 → 0.0.9

package/progress.d.ts

@@ -0,0 +1,64 @@
+import { type Timer } from "webappwiz/time";
+/**
+ * Where live progress draws. `tty` is whether a line can be redrawn in
+ * place: without one, judge stays line-by-line and never writes here.
+ */
+export interface Screen {
+    tty: boolean;
+    write(text: string): void;
+}
+/** The terminal this process writes to. */
+export declare const terminal: () => Screen;
+/** A run as the status line shows it: how far along, what it is on, what it
+ * has spent, and what it has found. */
+export interface RunView {
+    /** Calls finished. */
+    done: number;
+    /** Calls the run will make in all. */
+    total: number;
+    /** Files the calls out right now are reading. Every review names at least
+     * one, so zero here is the same as nothing running. */
+    files: number;
+    /** Tokens spent so far, when any agent has reported usage. */
+    tokens?: number;
+    /** Violations found so far; said aloud once the first call is home. */
+    problems: number;
+}
+/** The spinner's walk, one step per tick while any call is out. */
+export declare const FRAMES: string[];
+/**
+ * The status line. Pure, so what it says is testable without a terminal:
+ * the `Progress` around it only draws and redraws it. `frame` indexes the
+ * spinner's walk; with nothing running there is nothing to spin.
+ */
+export declare function render(view: RunView, frame?: number): string;
+/** What a `Progress` paces its spinner with; the real one by default. */
+export interface ProgressOptions {
+    timer?: Timer;
+}
+/**
+ * The live line a run draws while agents are out: progress over the calls
+ * and the tokens they have spent, redrawn on every event and spun on a
+ * tick between them. `stop` takes the line down, and whatever prints next
+ * lands where it was.
+ */
+export declare class Progress {
+    private screen;
+    private total;
+    private done;
+    private files;
+    private problems;
+    private tokens;
+    private drawn;
+    private frame;
+    private ticking;
+    constructor(screen: Screen, total: number, opts?: ProgressOptions);
+    /** A call went out over this many files. */
+    started(files: number): void;
+    /** A call came home: the files it read, what it spent, what it found. */
+    finished(files: number, spent?: number, problems?: number): void;
+    /** Takes the line down for good; call it before printing the report. */
+    stop(): void;
+    private erase;
+    private draw;
+}

package/report.d.ts

@@ -1,6 +1,5 @@
 import type { Violation } from "@webappwiz/rules";
 import type { Duration } from "webappwiz/time";
-import { type Overheads } from "./cost.js";
 export declare const count: (total: number, word: string) => string;
 /**
  * Where one printed document stops and the next starts, named so a reader
@@ -11,7 +10,8 @@ export declare const count: (total: number, word: string) => string;
  * the last document wants as much as the others want an opening one.
  */
 export declare const divider: (name?: string) => string;
-export declare const usd: (amount: number) => string;
+/** How every token figure prints: "14K", not "14,000". */
+export declare const compact: Intl.NumberFormat;
 /**
  * What a plan costs to read, at the four-bytes-a-token rule of thumb. Rough on
  * purpose: an estimate that needed a tokenizer, or an API call to count, would
@@ -19,28 +19,10 @@ export declare const usd: (amount: number) => string;
  * decision it informs is only ever "is this the order of magnitude I meant".
  */
 export declare const tokens: (bytes: number) => number;
-/**
- * Why the estimate is a floor: each call pays for the agent's own system
- * prompt and for whatever it re-reads as it works, none of which is knowable
- * from here.
- */
-export declare function overBudget(estimate: number, budget: number, cost?: number): string;
-/**
- * The whole of what `--estimate` prints: the plan, then what it costs on each
- * agent that has a price.
- *
- * Two columns, because the floor alone is misleading. It prices the files a
- * plan can see, and a call also pays for the agent's own system prompt every
- * time, which on a small repo is most of the bill. `overheads` carries what
- * past runs measured that per-call charge to be, so an agent that has been run
- * here gets a second figure worth trusting.
- */
-export declare function estimate(files: number, rules: number, calls: number, tokens: number, overheads: Overheads): string[];
 /**
  * The plan, before the first agent starts. Counts calls rather than reviews
- * because a call is what a run is billed for, and it is the denominator of the
- * `[n/total]` headings below. Without an `agent` it is the whole of what
- * `--estimate` prints, so it names no command it is not going to run.
+ * because a call is what a run spawns, and it is the denominator of the
+ * `[n/total]` headings below.
  */
 export interface Planned {
     files: number;
@@ -50,14 +32,12 @@ export interface Planned {
     estimate: number;
     /** Agent calls in flight at once, which is what the wall clock turns on. */
     concurrency?: number;
-    /** What those calls are predicted to cost, when the agent has a price. */
-    cost?: number;
     /** The command the run will spawn. */
     agent?: string;
 }
-export declare function planned({ files, rules, calls, estimate, concurrency, cost, agent, }: Planned): string[];
+export declare function planned({ files, rules, calls, estimate, concurrency, agent, }: Planned): string[];
 /** A finished review as the report prints it: what the call covered, what it
- * found, and what it cost. */
+ * found, and what it read. */
 export interface Finished {
     /** The ids of the rules the review checked. */
     rules: string[];
@@ -66,8 +46,12 @@ export interface Finished {
     violations: Violation[];
     /** How long this review's agent took. */
     took: Duration;
-    /** Dollars this review's call was billed, when the agent reported a figure. */
-    cost?: number;
+    /** Tokens this review's call touched, when the agent reported usage. */
+    tokens?: number;
+    /** Which worker ran the call, 0-based. */
+    worker: number;
+    /** Tokens that worker has touched so far, this review included. */
+    workerTokens?: number;
     done: number;
     total: number;
 }
@@ -75,11 +59,11 @@ export interface Finished {
  * A finished review, as it should print the moment its agent returns: a status
  * line sizing the call, then one finding per violation.
  */
-export declare function finished({ rules, files, violations, took, cost, done, total, }: Finished): string[];
+export declare function finished({ rules, files, violations, took, tokens, worker, workerTokens, done, total, }: Finished): string[];
 /**
  * One violation: a location a reader can click, what the code does that the
  * rule forbids, and the line it happens on. The heading above names only the
  * glob, so the finding says which of its rules this one breaks.
  */
 export declare function finding(violation: Violation): string[];
-export declare function summary(violations: Violation[], took: Duration, cost?: number): string;
+export declare function summary(violations: Violation[], took: Duration, tokens?: number): string;

package/rules.d.ts

@@ -1,4 +1,3 @@
-import { type Rule } from "@webappwiz/rules";
 /**
  * Every rule webappwiz judges itself by, named one by one. There is no preset
  * to spread and nothing runs implicitly: a rule is here or it does not run.
@@ -9,12 +8,3 @@ import { type Rule } from "@webappwiz/rules";
  * module for one of these to import.
  */
 export declare const JUDGE_RULES: import("@webappwiz/rules").RuleSet;
-/**
- * What an agent weighs before merging a change, rather than what it checks a
- * file against: whether the change needs a person to look at it.
- *
- * No command runs these. They are documents an agent reads and applies itself,
- * which is why they carry no glob and no check, and `wiz rules show` prints
- * them the same as any other.
- */
-export declare const SIGNOFF_RULES: Rule[];

package/rules.js

@@ -1,8 +1,6 @@
 import {
-  JUDGE_RULES,
-  SIGNOFF_RULES
-} from "./index-3p0t2exn.js";
+  JUDGE_RULES
+} from "./index-htwb54c6.js";
 export {
-  SIGNOFF_RULES,
   JUDGE_RULES
 };

package/webappwiz.js

@@ -4,17 +4,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";
 
 // webappwiz.ts
 import { AGENTS } from "@webappwiz/rules";
@@ -28,14 +24,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: .)"
@@ -46,39 +35,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/cost.d.ts

@@ -1,45 +0,0 @@
-import { type Fs } from "webappwiz/system";
-/** The agents an estimate can price, which is every one `--agent` accepts. */
-export declare const priced: () => string[];
-/**
- * What those tokens cost to read on that agent, or undefined for an agent with
- * no published price, which is any `--exec` command.
- *
- * A floor twice over: it counts input only, and only the input a plan can see.
- */
-export declare function floor(agent: string, tokens: number): number | undefined;
-/**
- * Dollars a single call costs beyond the files it was given, per agent.
- *
- * Everything the floor cannot see is charged per call, not per byte: the agent
- * pays for its own system prompt every time it is spawned, and on this project
- * that is most of a small call's bill. Measuring it per call is what lets a
- * figure taken from a two-call run stand up to a fifteen-call one.
- */
-export type Overheads = Record<string, number>;
-/**
- * What past runs in `root` measured, empty until one has finished there. A
- * missing or unreadable file is empty rather than an error: a calibration is a
- * convenience, and losing it costs the caller a worse estimate, not a run.
- */
-export interface OverheadsOptions {
-    /** What the record is read through; the real filesystem by default. */
-    fs?: Fs;
-}
-export declare function overheads(dir: string, opts?: OverheadsOptions): Promise<Overheads>;
-/**
- * Records what a call on this agent costs over its floor, so the next
- * `--estimate` has something better than one. Other agents are left alone,
- * since each is a separate measurement.
- */
-export interface CalibrateOptions {
-    /** What the record is written through; the real filesystem by default. */
-    fs?: Fs;
-}
-export declare function calibrate(dir: string, agent: string, call: number, opts?: CalibrateOptions): Promise<void>;
-/**
- * What a plan costs on one agent: the price of the files it names, plus what
- * every call charges on top. Undefined for an agent with no listed price, and
- * the floor alone until a run has measured one.
- */
-export declare function predict(agent: string, tokens: number, calls: number, measured: Overheads): number | undefined;

package/index-3k3rtw49.js

@@ -1,128 +0,0 @@
-import {
-  ask,
-  count,
-  diff,
-  divider,
-  mode,
-  overBudget,
-  tokens,
-  usd
-} from "./index-jbrs6gqt.js";
-
-// signoff.ts
-import {
-  agentCommand,
-  Harness,
-  prompt as reviewPrompt
-} from "@webappwiz/rules";
-import { ConsoleLogger, color } from "webappwiz/log";
-import { NodePs } from "webappwiz/system";
-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;
-  }
-  async run(opts) {
-    if (mode(opts) === "print") {
-      this.print();
-      return;
-    }
-    const dir = opts.dir.replace(/\/+$/, "") || "/";
-    const { patch, added } = await diff(dir, opts.since, { ps: this.ps });
-    if (patch === "" && added.length === 0) {
-      this.log.info(`nothing has changed since ${opts.since}`);
-      return;
-    }
-    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.say(await this.judge(review, agent, dir));
-  }
-  async judge(review, agent, dir) {
-    const harness = new Harness({
-      log: this.log,
-      ps: this.ps,
-      clock: this.clock
-    });
-    harness.events.on("finished", ({ took, cost }) => {
-      const spent = cost === undefined ? "" : `  ${usd(cost)}`;
-      this.log.info(color.gray(`read in ${took.human()}${spent}`));
-    });
-    return await harness.run([review], agent, { cwd: dir });
-  }
-  say(findings) {
-    if (findings.length === 0) {
-      this.log.info(color.green("✓ nothing in this change needs a person"));
-      return;
-    }
-    for (const finding of findings) {
-      const where = finding.file === undefined ? "" : `${color.bold(finding.file + (finding.line === undefined ? "" : `:${finding.line}`))}  `;
-      this.log.info(`  ${where}${finding.message} ${color.gray(`(${finding.rule})`)}`);
-    }
-    throw new Error(`${count(findings.length, "reason")} to escalate rather than merge`);
-  }
-  review(patch, added, ref) {
-    const draft = {
-      rules: this.rules,
-      label: "signoff",
-      context: [
-        `The change, as \`git diff ${ref}\` prints it:`,
-        `\`\`\`diff
-${patch}
-\`\`\``,
-        ...added.length === 0 ? [] : [
-          "These files are new and are in no diff yet. Read each one from " + "your working directory:",
-          added.map((file) => `- ${file}`).join(`
-`)
-        ]
-      ].join(`
-
-`),
-      instructions: WEIGHING
-    };
-    return { ...draft, bytes: Buffer.byteLength(reviewPrompt(draft)) };
-  }
-  print() {
-    if (this.rules.length === 0) {
-      this.log.info("no signoff rules");
-      return;
-    }
-    this.log.info("Weigh your change against each rule below. Anything that needs " + "review goes to a person instead of trunk.");
-    for (const rule of this.rules) {
-      this.log.info(`
-${divider(rule.id)}
-`);
-      this.log.info(rule.document.trim());
-    }
-    this.log.info(`
-${divider()}`);
-  }
-}
-var WEIGHING = [
-  "These rules decide one thing: whether this change can merge on its own, " + "or needs a person to look at it first.",
-  "",
-  "Each rule's `Ships` section is what merges with nobody looking, and its " + "`Needs review` section is what does not. Report a violation only for " + "what the `Needs review` side covers, and only where the change " + "actually does it.",
-  "",
-  "These rules are about the change as a whole, so leave `file` and `line` " + "out unless one place in the change is the whole of the answer."
-].join(`
-`);
-
-export { Signoff };