@zgeoff/chex 0.0.1 → 0.0.3

package/README.md

@@ -1,4 +1,97 @@
-# @zgeoff/chex
+<div align="center">
+  <h1>@zgeoff/chex</h1>
 
-Run a repo's pre-push checks from one versioned baseline. Not released yet: this version only
-reserves the name.
+  <p>
+    <a href="https://www.npmjs.com/package/@zgeoff/chex"><img src="https://img.shields.io/npm/v/@zgeoff/chex" alt="npm version"></a>
+    <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"></a>
+  </p>
+
+  <p>
+    <a href="../../docs/README.md">Documentation</a> •
+    <a href="../../docs/architecture/pre-push-baseline.md">The pre-push baseline</a>
+  </p>
+</div>
+
+Run each shared check of a zgeoff repo as one subcommand, and take the lefthook pre-push baseline
+that calls them with one `extends` line.
+
+Each check prints its own findings, then `cleared: <check>` when it passes or `bounced: <check>`
+when it fails, so a run of several checks names each one that failed. To start, run `chex init`,
+then `chex length links`.
+
+## Install
+
+```sh
+bun add -d @zgeoff/chex @zgeoff/rig @zgeoff/diet @commitlint/cli @zgeoff/commitlint-config
+bun x --no-install chex init
+```
+
+`chex` runs under Bun. The baseline runs the related tests through [`@zgeoff/rig`](../rig/README.md)
+and each job under the memory cap of [`@zgeoff/diet`](../diet/README.md), so a repo that takes it
+installs both, and `chex init` fails until it does. `chex commits` lints commit messages with
+`@commitlint/cli` and `@zgeoff/commitlint-config`; in a repo that lacks either one, it prints a
+notice and passes.
+
+## Commands
+
+`chex <check>...` runs each check in turn, even after one bounces, and exits with the highest exit
+code among them: 0 when each clears, 1 when a check finds a fault, and 2 when a check cannot run.
+chex also exits 2 for a check that throws or exits with any other code, such as 127 for a missing
+program. `chex <check> <args...>` hands the arguments to that one check.
+
+The docs checks read the repo's READMEs, its `docs/` tree and its skills:
+
+| Check     | Fails on                                                                                                            | Arguments      |
+| --------- | ------------------------------------------------------------------------------------------------------------------- | -------------- |
+| `prose`   | banned words, process residue and over-long paragraphs                                                              | the paths      |
+| `length`  | a README over its line limit, and warns on a doc over its cap                                                       | none           |
+| `links`   | a relative link or anchor that does not resolve                                                                     | the paths      |
+| `readmes` | a README of none of the [five kinds](../../sync/skills/docs-writing/references/readmes.md#the-five-kinds-of-readme) | none           |
+| `vision`  | a missing `docs/vision.md`, or one past 60 lines                                                                    | none           |
+| `skill`   | a skill's frontmatter, its word limit, and a link with a line anchor                                                | the skill dirs |
+
+The repo checks read the branch, the pushed commits and the repo's config:
+
+| Check              | Fails on                                                                    | Arguments       |
+| ------------------ | --------------------------------------------------------------------------- | --------------- |
+| `commits`          | a pushed commit whose message fails `@zgeoff/commitlint-config`             | `--pushed-refs` |
+| `local-paths`      | a line a pushed commit adds that holds the home folder or the host name     | `--pushed-refs` |
+| `test-timeouts`    | a `bun test` timeout above its lane's limit, in a script or a `bunfig.toml` | none            |
+| `workflows`        | nothing: it warns on each fault of the shared workflow lint, and passes     | the paths       |
+| `dependency-gates` | a stale age-gate exclude, an override or an audit ignore that nothing needs | none            |
+| `uncommitted`      | a file the branch changes that holds a change the push does not send        | none            |
+
+With no path, `prose` and `links` read every README outside `.claude/` and `.agents/`, every file
+under `docs/`, each spike's `results.md`, and the Markdown under `.agents/skills/`,
+`.claude/skills/`, `skills/` and `sync/skills/`. `--pushed-refs` reads the refs a push sends from
+stdin, as a pre-push hook gets them; without it, `commits` and `local-paths` read the branch's
+commits since its base.
+
+Some docs checks skip files whether or not you name paths, and a path you name never brings a
+skipped file back:
+
+- `prose` skips the `docs-writing`, `project-docs-writing`, `skill-writing` and `deslop` skills
+  under `.agents/skills/`, `.claude/skills/`, `skills/` and `sync/skills/`, which hold the banned
+  patterns as examples.
+- `links` skips `project-docs-writing` under `.agents/skills/` and `.claude/skills/`, and
+  `docs-writing` and `skill-writing` under `.claude/skills/` and `sync/skills/`, which link to
+  placeholder targets as examples.
+- `prose`, `links`, `readmes` and `skill` skip each file that `.gitattributes` marks
+  `linguist-vendored`.
+
+`chex init` writes the `extends` line into `lefthook.yml` and adds a `check:docs` script of
+`chex prose length links skill` when the repo has none. A second run changes nothing.
+
+## The pre-push baseline
+
+A repo's `lefthook.yml` takes the baseline with one line, which `chex init` writes:
+
+```yaml
+extends:
+  - node_modules/@zgeoff/chex/lefthook.yml
+```
+
+The baseline's jobs call `chex <check>` for the repo checks, `bun run check:docs` for the docs
+checks the repo names, `rig related` for the tests beside the changed files, and the repo's own
+`format:check` and `typecheck` scripts.
+[The pre-push baseline](../../docs/architecture/pre-push-baseline.md) describes each job.

package/lefthook.yml

@@ -0,0 +1,123 @@
+# The pre-push baseline a repo extends from its lefthook.yml, as chex init writes it:
+#
+#   extends:
+#     - node_modules/@zgeoff/chex/lefthook.yml
+#
+# It checks what the branch changes, plus the whole-tree gates that fit a
+# small host: format:check and typecheck. CI runs every whole-tree check. It
+# also runs typecheck before a commit that changes code or config, after the
+# repo's own pre-commit fixers. A repo adds its own jobs under
+# pre-commit.jobs and pre-push.jobs in lefthook.yml; they run before these.
+# Each job runs under diet's memory cap, so a run that outgrows the host fails
+# alone, with its peak memory in the output. bun x --no-install runs the
+# repo's own install of chex, diet and rig, and fails when one is missing
+# rather than download a package of that name.
+
+pre-commit:
+  # Sequential, so typecheck reads the files the fixers before it rewrote.
+  piped: true
+  jobs:
+    # lefthook skips the job when no staged file matches the glob.
+    - name: typecheck
+      glob: '*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,json,jsonc}'
+      run: bun x --no-install diet -- bun run typecheck
+
+pre-push:
+  # Sequential, to bound memory on a small host or with parallel agents.
+  piped: true
+  jobs:
+    # The jobs after this one read the files on disk, so this one fails the
+    # push when a file the branch changes or deletes holds a change that is
+    # not committed, and names each such file.
+    - name: uncommitted
+      run: bun x --no-install diet -- bun x --no-install chex uncommitted
+    - name: format:check
+      run: bun x --no-install diet -- bun run format:check
+    # Plain oxlint, without the unused-directive check: a directive for a
+    # type-aware rule reads as unused in plain mode.
+    - name: lint
+      files: bun node_modules/@zgeoff/chex/src/read-branch-files.ts
+      glob: '*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'
+      run:
+        bun x --no-install diet -- bun x --no-install oxlint --no-error-on-unmatched-pattern {files}
+    # Each file check reads only the files the branch changes that match its
+    # glob, so a file the branch leaves unchanged never fails a push. A check
+    # whose program the machine lacks prints a notice and passes: CI installs
+    # the program and runs the check on every pull request.
+    - name: shell
+      files: bun node_modules/@zgeoff/chex/src/read-branch-files.ts
+      glob: '*.sh'
+      run: |
+        for program in shellcheck shfmt; do
+          if ! command -v "$program" > /dev/null; then
+            echo "shell: skipped, because $program is not on the PATH; CI runs the check"
+            exit 0
+          fi
+        done
+        status=0
+        bun x --no-install diet -- shellcheck --external-sources --source-path=SCRIPTDIR "--source-path=$PWD" -- {files} || status=1
+        bun x --no-install diet -- shfmt -d -- {files} || status=1
+        exit "$status"
+    # The docs checks pick the docs they read themselves, so the glob only
+    # decides whether the job runs. The repo's check:docs script names the
+    # checks it takes, such as chex prose length links.
+    - name: docs
+      files: bun node_modules/@zgeoff/chex/src/read-branch-files.ts
+      glob: '*.md'
+      run: bun x --no-install diet -- bun run --silent check:docs
+    # GitHub runs no workflow from a subfolder of .github/workflows, and
+    # sync/workflow-callers holds the workflows that tools delivers. actionlint
+    # 1.7.12 rejects the concurrency queue key that GitHub documents, until
+    # rhysd/actionlint#654 ships; the ignore lapses on the same date as in CI.
+    # The workflow lint runs after actionlint, even when actionlint is missing
+    # or fails.
+    - name: workflows
+      files: bun node_modules/@zgeoff/chex/src/read-branch-files.ts
+      glob:
+        - '.github/workflows/*.{yml,yaml}'
+        - 'sync/workflow-callers/*.{yml,yaml}'
+      run: |
+        status=0
+        if ! command -v actionlint > /dev/null; then
+          echo "workflows: actionlint skipped, because it is not on the PATH; CI runs it"
+        elif [ "$(date -u +%Y%m%d)" -lt 20270122 ]; then
+          bun x --no-install diet -- actionlint -ignore 'unexpected key "queue" for "concurrency" section' -- {files} || status=1
+        else
+          bun x --no-install diet -- actionlint -- {files} || status=1
+        fi
+        bun x --no-install diet -- bun x --no-install chex workflows {files} || status=1
+        exit "$status"
+    # git lists the refs a push sends on the hook's stdin, and lefthook hands
+    # stdin only to a job that asks for it. lefthook 2.2.2 skips a pre-push
+    # job whose run substitutes no file when the checked-out branch has
+    # nothing to push (internal/run/controller/command/build_command.go,
+    # lines 47-49 and 71-80), which would skip a push of another branch. So
+    # each job lists package.json for {files}, inside a shell comment the
+    # check never sees: every repo that takes the baseline has the file, as
+    # it installs chex, and lefthook drops a listed path that does not exist.
+    - name: commits
+      files: echo package.json
+      use_stdin: true
+      run: 'bun x --no-install diet -- bun x --no-install chex commits --pushed-refs # {files}'
+    # package.json keeps this job from the same lefthook skip.
+    - name: local-paths
+      files: echo package.json
+      use_stdin: true
+      run: 'bun x --no-install diet -- bun x --no-install chex local-paths --pushed-refs # {files}'
+    - name: test-timeouts
+      run: bun x --no-install diet -- bun x --no-install chex test-timeouts
+    - name: dependency-gates
+      run: bun x --no-install diet -- bun x --no-install chex dependency-gates
+    - name: typecheck
+      run: bun x --no-install diet -- bun run typecheck
+    # A pre-push in a linked worktree exports GIT_DIR, and a test that runs git
+    # in a temp folder would inherit it and write to the real repository: a
+    # git init there sets core.bare=true. The tests run without git's
+    # repository variables. A bunfig.toml reaches the job too, because a change
+    # to it skips the related tests.
+    - name: test
+      files: bun node_modules/@zgeoff/chex/src/read-branch-files.ts
+      glob: '*.{ts,tsx,toml}'
+      run:
+        env -u GIT_DIR -u GIT_WORK_TREE -u GIT_INDEX_FILE -u GIT_COMMON_DIR bun x --no-install diet
+        -- bun x --no-install rig related {files}

package/package.json

@@ -1,17 +1,45 @@
 {
   "name": "@zgeoff/chex",
-  "version": "0.0.1",
-  "description": "Run a repo's pre-push checks from one versioned baseline",
+  "version": "0.0.3",
+  "description": "Run each shared docs and repo check as one subcommand, with the lefthook pre-push baseline that calls them",
+  "keywords": [
+    "checks",
+    "docs",
+    "lefthook",
+    "pre-push"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zgeoff/tools.git",
     "directory": "packages/chex"
   },
+  "bin": {
+    "chex": "./src/cli.ts"
+  },
   "files": [
-    "README.md"
+    "src",
+    "!src/**/*.test.ts",
+    "lefthook.yml"
   ],
+  "type": "module",
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsrs"
+  },
+  "dependencies": {
+    "@zgeoff/std": "0.3.1",
+    "ts-pattern": "5.9.2"
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.3",
+    "tiny-invariant": "1.3.3",
+    "tsrs": "0.18.0-ts7.1.0-dev.20260929",
+    "typescript": "7.0.2"
+  },
+  "engines": {
+    "bun": ">=1.3"
   }
 }

package/src/build-init-package.ts

@@ -0,0 +1,57 @@
+import { isRecord } from '@zgeoff/std';
+
+// The baseline's jobs run chex, the related tests through rig, and each job under diet's memory cap.
+export const baselinePackages = ['@zgeoff/chex', '@zgeoff/rig', '@zgeoff/diet'] as const;
+export const docsScript = 'chex prose length links skill';
+
+export type PackageOutcome =
+  | { readonly kind: 'missing'; readonly packages: readonly string[] }
+  | { readonly kind: 'unchanged' }
+  | { readonly kind: 'changed'; readonly text: string }
+  | { readonly kind: 'refused'; readonly reason: string };
+
+export function buildInitPackage(text: string): PackageOutcome {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return {
+      kind: 'refused',
+      reason: `package.json is not JSON: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+
+  if (!isRecord(parsed)) {
+    return { kind: 'refused', reason: 'package.json is not a JSON object' };
+  }
+
+  const installed = new Set([
+    ...listKeys(parsed['dependencies']),
+    ...listKeys(parsed['devDependencies']),
+  ]);
+
+  const missing = baselinePackages.filter((name) => !installed.has(name));
+
+  if (missing.length > 0) {
+    return { kind: 'missing', packages: missing };
+  }
+
+  const scripts = parsed['scripts'] ?? {};
+
+  if (!isRecord(scripts)) {
+    return { kind: 'refused', reason: 'the scripts of package.json are not a JSON object' };
+  }
+
+  if (scripts['check:docs'] !== undefined) {
+    return { kind: 'unchanged' };
+  }
+
+  const edited = { ...parsed, scripts: { ...scripts, 'check:docs': docsScript } };
+
+  return { kind: 'changed', text: `${JSON.stringify(edited, null, 2)}\n` };
+}
+
+function listKeys(value: unknown): string[] {
+  return isRecord(value) ? Object.keys(value) : [];
+}

package/src/build-init-plan.ts

@@ -0,0 +1,96 @@
+import { match } from 'ts-pattern';
+import type { PackageOutcome } from './build-init-package.ts';
+import { buildInitPackage, docsScript } from './build-init-package.ts';
+import type { LefthookOutcome } from './build-lefthook-extends.ts';
+import { baselinePath, buildLefthookExtends } from './build-lefthook-extends.ts';
+
+export interface InitWrite {
+  readonly file: 'lefthook.yml' | 'package.json';
+  readonly text: string;
+}
+
+export type InitPlan =
+  | { readonly kind: 'refused'; readonly reasons: readonly string[] }
+  | {
+      readonly kind: 'apply';
+      readonly writes: readonly InitWrite[];
+      readonly notes: readonly string[];
+    };
+
+// Plans both edits before either is written, so a refused edit leaves the repo as it was.
+export function buildInitPlan(
+  packageText: string | undefined,
+  lefthookText: string | undefined,
+): InitPlan {
+  if (packageText === undefined) {
+    return {
+      kind: 'refused',
+      reasons: ['the folder has no package.json; run chex init from the repo root'],
+    };
+  }
+
+  return match<PackageOutcome, InitPlan>(buildInitPackage(packageText))
+    .with({ kind: 'missing' }, (outcome) => ({
+      kind: 'refused',
+      reasons: [
+        `the baseline needs ${outcome.packages.join(', ')} installed; run bun add -d ${outcome.packages.join(' ')}`,
+      ],
+    }))
+    .with({ kind: 'unchanged' }, () => buildPlanFromSteps([buildLefthookStep(lefthookText)]))
+    .with({ kind: 'changed' }, (outcome) =>
+      buildPlanFromSteps([
+        buildLefthookStep(lefthookText),
+        {
+          reasons: [],
+          writes: [{ file: 'package.json', text: outcome.text }],
+          notes: [`package.json runs "${docsScript}" as check:docs`],
+        },
+      ]),
+    )
+    .with({ kind: 'refused' }, (outcome) =>
+      buildPlanFromSteps([
+        buildLefthookStep(lefthookText),
+        { reasons: [outcome.reason], writes: [], notes: [] },
+      ]),
+    )
+    .exhaustive();
+}
+
+interface InitStep {
+  readonly reasons: readonly string[];
+  readonly writes: readonly InitWrite[];
+  readonly notes: readonly string[];
+}
+
+function buildPlanFromSteps(steps: readonly InitStep[]): InitPlan {
+  const reasons = steps.flatMap((step) => step.reasons);
+
+  if (reasons.length > 0) {
+    return { kind: 'refused', reasons };
+  }
+
+  const writes = steps.flatMap((step) => step.writes);
+
+  return {
+    kind: 'apply',
+    writes,
+    notes:
+      writes.length === 0
+        ? ['the repo already takes the baseline; nothing to change']
+        : steps.flatMap((step) => step.notes),
+  };
+}
+
+const keptStep: InitStep = { reasons: [], writes: [], notes: [] };
+
+function buildLefthookStep(lefthookText: string | undefined): InitStep {
+  return match<LefthookOutcome, InitStep>(buildLefthookExtends(lefthookText))
+    .with({ kind: 'unchanged' }, () => keptStep)
+    .with({ kind: 'changed' }, (outcome) => ({
+      reasons: [],
+      writes: [{ file: 'lefthook.yml', text: outcome.text }],
+      notes: [`lefthook.yml extends ${baselinePath}`],
+    }))
+    .with({ kind: 'refused' }, (outcome) => ({ reasons: [outcome.reason], writes: [], notes: [] }))
+    .exhaustive();
+}

package/src/build-lefthook-extends.ts

@@ -0,0 +1,117 @@
+import { isRecord } from '@zgeoff/std';
+
+export const baselinePath = 'node_modules/@zgeoff/chex/lefthook.yml';
+
+export type LefthookOutcome =
+  | { readonly kind: 'unchanged' }
+  | { readonly kind: 'changed'; readonly text: string }
+  | { readonly kind: 'refused'; readonly reason: string };
+
+const extendsLine = /^extends:[ \t]*(?:#.*)?$/mu;
+
+// A one-line flow list, such as `extends: [.lefthook/local.yml]`, with an optional comment after it.
+const inlineExtends = /^(?<open>extends:[ \t]*\[)(?<items>[^\]\n]*)(?<close>\][ \t]*(?:#.*)?)$/mu;
+
+// Edits the text rather than writing parsed YAML back, so the repo's comments and layout stay.
+export function buildLefthookExtends(text: string | undefined): LefthookOutcome {
+  if (text === undefined) {
+    return { kind: 'changed', text: `extends:\n  - ${baselinePath}\n` };
+  }
+
+  const config = parseConfig(text);
+
+  if (config === undefined) {
+    return { kind: 'refused', reason: 'lefthook.yml is not a YAML mapping' };
+  }
+
+  const extended = config['extends'];
+
+  if (extended === undefined) {
+    return checkEdit(config, buildFirstExtends(text));
+  }
+
+  if (Array.isArray(extended) && extended.includes(baselinePath)) {
+    return { kind: 'unchanged' };
+  }
+
+  const inline = inlineExtends.exec(text);
+
+  if (Array.isArray(extended) && inline !== null) {
+    return checkEdit(config, buildInlineExtends(text, inline));
+  }
+
+  const match = extendsLine.exec(text);
+
+  if (!Array.isArray(extended) || match === null) {
+    return {
+      kind: 'refused',
+      reason: `lefthook.yml writes extends in a form chex init does not edit; add ${baselinePath} to its list`,
+    };
+  }
+
+  const end = match.index + match[0].length;
+
+  return checkEdit(config, `${text.slice(0, end)}\n  - ${baselinePath}${text.slice(end)}`);
+}
+
+function parseConfig(text: string): Record<string, unknown> | undefined {
+  let parsed: unknown;
+
+  try {
+    parsed = Bun.YAML.parse(text);
+  } catch {
+    return undefined;
+  }
+
+  if (parsed === null) {
+    return {};
+  }
+
+  return isRecord(parsed) ? parsed : undefined;
+}
+
+// A flow mapping or a second YAML document reads differently once a block key joins the text.
+function checkEdit(config: Record<string, unknown>, edited: string): LefthookOutcome {
+  const editedConfig = parseConfig(edited);
+
+  if (editedConfig !== undefined) {
+    const { extends: editedExtends, ...editedRest } = editedConfig;
+    const { extends: _, ...rest } = config;
+
+    if (
+      Array.isArray(editedExtends) &&
+      editedExtends.includes(baselinePath) &&
+      Bun.deepEquals(editedRest, rest, true)
+    ) {
+      return { kind: 'changed', text: edited };
+    }
+  }
+
+  return {
+    kind: 'refused',
+    reason: `lefthook.yml is laid out in a form chex init does not edit; add an extends list that names ${baselinePath}`,
+  };
+}
+
+const documentStart = /^(?:[ \t]*(?:#.*)?\n)*---[ \t]*(?:#.*)?(?=\n|$)/u;
+
+function buildFirstExtends(text: string): string {
+  const start = documentStart.exec(text);
+
+  if (start === null) {
+    return `extends:\n  - ${baselinePath}\n\n${text}`;
+  }
+
+  const end = start[0].length;
+
+  return `${text.slice(0, end)}\nextends:\n  - ${baselinePath}\n${text.slice(end)}`;
+}
+
+function buildInlineExtends(text: string, inline: RegExpExecArray): string {
+  const groups = inline.groups ?? {};
+  const items = groups['items'] ?? '';
+  const listed = items.trim() === '' ? baselinePath : `${items.trimEnd()}, ${baselinePath}`;
+  const end = inline.index + inline[0].length;
+
+  return `${text.slice(0, inline.index)}${groups['open'] ?? ''}${listed}${groups['close'] ?? ''}${text.slice(end)}`;
+}

package/src/check-names.ts

@@ -0,0 +1,18 @@
+export const docsCheckNames = ['prose', 'length', 'links', 'readmes', 'vision', 'skill'] as const;
+
+// The docs checks come first, so a usage message lists them before the repo checks.
+export const checkNames = [
+  ...docsCheckNames,
+  'commits',
+  'local-paths',
+  'test-timeouts',
+  'workflows',
+  'dependency-gates',
+  'uncommitted',
+] as const;
+
+export type CheckName = (typeof checkNames)[number];
+
+export function isCheckName(value: string): value is CheckName {
+  return checkNames.some((name) => name === value);
+}

package/src/cli.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+import { rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readOptionalText } from '@zgeoff/std';
+import { runDependencyGatesCommand } from './dependency-gates/run-dependency-gates-check.ts';
+import { makeCheckRunner } from './make-check-runner.ts';
+import { runChex } from './run-chex.ts';
+import { runCommitsCommand } from './run-commits-check.ts';
+import { runInit } from './run-init.ts';
+import { runLocalPathsCommand } from './run-local-paths-check.ts';
+import { runTestTimeoutsCommand } from './run-test-timeouts-check.ts';
+import { runUncommittedCommand } from './run-uncommitted-check.ts';
+import { runWorkflowsCommand } from './run-workflows-check.ts';
+import { writeTextFile } from './write-text-file.ts';
+
+process.exitCode = await runChex(process.argv.slice(2), {
+  runCheck: makeCheckRunner({
+    docsFolder: join(import.meta.dir, 'docs'),
+    runScript: (argv) => Bun.spawn([...argv], { stdio: ['inherit', 'inherit', 'inherit'] }).exited,
+    repoChecks: {
+      commits: runCommitsCommand,
+      'local-paths': runLocalPathsCommand,
+      'test-timeouts': runTestTimeoutsCommand,
+      workflows: runWorkflowsCommand,
+      'dependency-gates': runDependencyGatesCommand,
+      uncommitted: runUncommittedCommand,
+    },
+  }),
+  runInit: () =>
+    runInit({
+      repoRoot: process.cwd(),
+      readText: readOptionalText,
+      writeText: writeTextFile,
+      renameFile: (from, to) => rename(from, to),
+      removeFile: (path) => rm(path, { force: true }),
+      writeOutput: (text) => {
+        process.stdout.write(text);
+      },
+      writeError: (text) => {
+        process.stderr.write(text);
+      },
+    }),
+  writeOutput: (text) => {
+    process.stdout.write(text);
+  },
+  writeError: (text) => {
+    process.stderr.write(text);
+  },
+});