@webappwiz/cli 0.0.10 → 0.0.11

package/index-pyjg1rtk.js

@@ -1,373 +0,0 @@
-// 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/judge.d.ts

@@ -1,63 +0,0 @@
-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";
-import { type Screen } from "./progress.js";
-export interface ShowOptions {
-    /** The rule to print, as `rules ls` lists it. */
-    id: string;
-}
-export interface JudgeOptions {
-    /** The directory to check, and what paths in the report are relative to. */
-    dir: string;
-    agent?: string;
-    exec?: string;
-    /** Print the prompts to the logger and spawn nothing. */
-    print?: boolean;
-    /** Files per review. */
-    chunk: number;
-    /** Narrows the run to what git says has changed since this ref. */
-    since?: string;
-    /** 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;
-}
-/** What a `JudgeCommands` runs through, and what else it lists. */
-export interface JudgeCommandsOptions {
-    /** Where live progress draws; this process's terminal by default. */
-    screen?: Screen;
-    log?: Logger;
-    fs?: Fs;
-    ps?: Ps;
-    clock?: Clock;
-    glob?: Glob;
-}
-export declare class JudgeCommands {
-    private rules;
-    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. */
-    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.
-     */
-    show(opts: ShowOptions): void;
-    /**
-     * Runs the rules over a directory with the agent you name, as `agent` or
-     * `exec`, falling back to the config's. Exits 1 on any error. Under `print`
-     * 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.
-     */
-    judge(opts: JudgeOptions): Promise<void>;
-    /** The agent a command runs with: what it was told, else the config's. */
-    private agent;
-}

package/judge.js

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

package/mode.d.ts

@@ -1,21 +0,0 @@
-/** What a command does with the plan it has made. */
-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. */
-    agent?: string;
-    /** A command to hand the prompt to instead. */
-    exec?: string;
-    /** Print to the logger and spawn nothing. */
-    print?: boolean;
-}
-/**
- * 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, agent, exec }: ModeOptions): Mode;

package/progress.d.ts

@@ -1,64 +0,0 @@
-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,69 +0,0 @@
-import type { Violation } from "@webappwiz/rules";
-import type { Duration } from "webappwiz/time";
-export declare const count: (total: number, word: string) => string;
-/**
- * Where one printed document stops and the next starts, named so a reader
- * knows which one they are in without scrolling back.
- *
- * What `--print` writes is pages of markdown with headings of its own, so a
- * heading is not enough to mark a boundary. Unnamed, this is the closing line
- * the last document wants as much as the others want an opening one.
- */
-export declare const divider: (name?: string) => 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
- * be one more thing to install and one more thing to be wrong about, and the
- * decision it informs is only ever "is this the order of magnitude I meant".
- */
-export declare const tokens: (bytes: number) => number;
-/**
- * The plan, before the first agent starts. Counts calls rather than reviews
- * because a call is what a run spawns, and it is the denominator of the
- * `[n/total]` headings below.
- */
-export interface Planned {
-    files: number;
-    rules: number;
-    calls: number;
-    /** Tokens the plan can see, which is a floor on what the run reads. */
-    estimate: number;
-    /** Agent calls in flight at once, which is what the wall clock turns on. */
-    concurrency?: number;
-    /** The command the run will spawn. */
-    agent?: 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 read. */
-export interface Finished {
-    /** The ids of the rules the review checked. */
-    rules: string[];
-    /** How many files this review's agent was told to read. */
-    files: number;
-    violations: Violation[];
-    /** How long this review's agent took. */
-    took: Duration;
-    /** 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;
-}
-/**
- * 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, 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, tokens?: number): string;

package/rules.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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.
- *
- * A constant rather than a config file, because rules reach the harness as
- * objects. A project with its own rules writes its own list and hands it to
- * `JudgeCommands` or to `Check` directly, rather than pointing a flag at a
- * module for one of these to import.
- */
-export declare const JUDGE_RULES: import("@webappwiz/rules").RuleSet;

package/rules.js

@@ -1,6 +0,0 @@
-import {
-  JUDGE_RULES
-} from "./index-htwb54c6.js";
-export {
-  JUDGE_RULES
-};