@konvert7/klint 0.37.1 → 1.0.0

package/skill/klint-rules/SKILL.md

@@ -1,264 +0,0 @@
----
-name: klint-rules
-description: Add, modify, or explain klint architecture rules for this repo. Use when asked to enforce a new structural constraint, adjust rule scope, or explain why a violation fired.
-argument-hint: <constraint to enforce>
----
-
-## Schema
-
-The full, authoritative config schema lives in the repo and is the source of truth for every field below:
-
-- YAML: <https://github.com/konvert7/klint/blob/main/klint.schema.yaml>
-- JSON: <https://github.com/konvert7/klint/blob/main/klint.schema.json>
-
-Wire it into `klint.yaml` for editor autocomplete and validation:
-
-```yaml
-# yaml-language-server: $schema=./klint.schema.yaml
-```
-
-## Workflow
-
-1. **Understand the constraint** — if scope is ambiguous, ask: which files/layers are involved? should it block or warn? are there legitimate exceptions?
-
-2. **Grep first** — verify the pattern exists and count current occurrences before touching `klint.yaml`:
-   ```sh
-   grep -rn "the-pattern" src/ --include="*.ts"
-   ```
-
-3. **Choose the right primitive:**
-
-   | The constraint is... | Primitive |
-   |---|---|
-   | Layer X must not import from layer Y | `arch.imports` + `deny` |
-   | Layer X may only import from Y and Z | `arch.imports` + `allow` |
-   | Layer X must not import an npm package or `node:` builtin | `arch.imports` + `deny-packages` |
-   | Pattern P must only appear in one designated file | `arch.singleton` + `pattern` |
-   | Pattern P must never appear inside a scoped layer | `arch.forbidden` + `pattern` |
-   | Raw HTML/JSX element must never appear in a scoped layer | `arch.forbidden` + `jsx-element` |
-   | Raw HTML/JSX element may only appear in one primitive file | `arch.singleton` + `jsx-element` |
-   | A value-shaped pattern (regex) must never appear in a scoped layer | `arch.forbidden` + `pattern: "re:…"` |
-   | No file in a layer may exceed N lines | `arch.maxLines` + `limit` |
-   | No file may be more than N% comments | `arch.maxCommentDensity` + `limit` |
-   | No comment block may stack more than N lines | `arch.maxCommentBlock` + `limit` |
-
-4. **Read `klint.yaml`** — check existing `arch.layers` and rules before adding anything. Add a new named layer to `arch.layers` if the file group doesn't exist yet.
-
-5. **Write the stanza** in `klint.yaml` under the correct `arch:` section.
-
-6. **Verify zero new violations on the current codebase:**
-   ```sh
-   bun klint/cli.ts        # in-repo
-   npx klint               # after npm install
-   ```
-   If new violations appear on existing code, fix them first or adjust the rule scope — then land the rule.
-
-7. **Write a break test** — prove the rule fires on a deliberate violation, and doesn't fire on clean code. Run the test suite to confirm.
-
-## Run tracking
-
-Every run is recorded in `.klint/stats.json` next to the config. The folder ignores itself, so never add it to `.gitignore`.
-
-| Command or flag | Use |
-|---|---|
-| `klint stats [--config <dir>]` | Print runs, violations reported and errors prevented, in total and per rule. Use it to answer "how much has klint caught?" |
-| `--hook` | Put it only in agent hook commands, e.g. `klint --json --hook`. Leave it off when you run klint yourself, so your runs count as direct. |
-| `KLINT_NO_STATS=1` | Turn recording off for a run, e.g. in a throwaway fixture. |
-
-Every violation a run reports counts as reported, repeats included; klint's own `klint/*` advisories do not. An error counts as prevented once, when a later run no longer reports it. Errors match by rule, file and message, so moving code to another line is not a fix. Warnings are not tracked.
-
-## Primitive reference
-
-### Layers
-```yaml
-arch:
-  layers:
-    core:    ["src/lib/**", "src/hooks/**"]
-    ui:      ["src/components/**"]
-    targets: ["src/targets/**"]
-```
-
-### Import boundaries
-```yaml
-arch:
-  imports:
-    # deny: block imports from one layer into another
-    - from: core
-      deny: targets
-      message: "Core must not depend on agent-specific code"
-      severity: error          # optional — default is error; use warn to record without blocking
-
-    # allow: whitelist — anything not listed is denied (npm + node: builtins always pass)
-    - from: ["src/dao/**"]
-      allow: ["src/dao/**", "src/prisma/**"]
-      message: "DAO may only import from dao or prisma"
-
-    # type-only: allow — import type {} and Python if TYPE_CHECKING: blocks stay permitted
-    - from: core
-      deny: targets
-      type-only: allow
-      message: "Core must not depend on agent-specific code"
-
-    # deny-packages: block npm packages and node: builtins, which deny/allow cannot reach
-    # because they never resolve to a project file. Composes with deny in the same rule.
-    - from: ["src/dao/**"]
-      deny-packages: ["next/headers", "node:fs"]
-      message: "Data access must not read request state or touch the filesystem"
-```
-
-`deny-packages` matches per segment: `next` covers `next/headers`, `nextra` is unaffected, and
-`next/headers` does not match `next/navigation`. Python uses dotted segments, so `os` covers
-`os.path` and blocks pip packages and stdlib modules alike. Swift uses dotted segments too, at
-module granularity, which is what makes system frameworks like `UIKit` reachable. Rust splits on
-`::`, so `tokio` covers `tokio::sync::Mutex` while `tokio_util` is unaffected. The specifier is read off the AST, so
-static imports, dynamic `import()`, and `export … from` re-exports all count while a comment
-mentioning the package does not — unlike `forbidden` + `pattern`, which is a line-based text scan.
-
-### Singleton — one designated location
-
-Pin a `pattern` (literal string) **or** a `jsx-element` (AST-matched tag) to exactly one file. Every other in-scope occurrence is a violation.
-
-```yaml
-arch:
-  singleton:
-    # pattern: literal string match — fires if it appears anywhere except `only`
-    - pattern: "process.env.API_KEY"
-      only: "src/lib/auth.ts"
-      in: ["src/**"]           # optional: limit scan scope (default: all files). string OR array
-      message: "Use the auth module instead of reading API_KEY directly"
-      severity: error          # optional — default error; use warn to record without blocking
-
-    # jsx-element: pin a raw element to its design-system primitive
-    - jsx-element: "button"     # one tag, or a list: ["button", "input"]
-      only: "src/components/ui/button.tsx"
-      in: ["src/**/*.tsx"]
-      message: "Raw <button> belongs only to the Button primitive"
-```
-
-Required: `only` + `message`, plus one of `pattern` / `jsx-element` (not both in the same stanza).
-
-### Forbidden — banned pattern in scope
-
-Block a `pattern` (literal string) **or** a `jsx-element` (AST-matched tag) inside a scoped layer.
-
-```yaml
-arch:
-  forbidden:
-    # pattern: literal substring by default; prefix with `re:` for a regex
-    - pattern: "console.log("
-      in: ["src/lib/**"]       # string OR array; supports ! negation
-      message: "Use the logger — console.log leaks into the agent event stream"
-      severity: error          # optional — default error; use warn to record without blocking
-
-    # re: prefix — match a regular expression (common JS/RE2 subset; no lookaround/backrefs)
-    - pattern: 're:\b(?:p|gap)-\['
-      in: ["src/**/*.tsx"]
-      message: "Use the spacing scale, not arbitrary bracket values like p-[18px]"
-
-    # jsx-element: forbid raw HTML elements outside the design system
-    - jsx-element: ["button", "input", "label"]
-      in: ["src/app/**/*.tsx", "src/components/**/*.tsx", "!src/components/ui/**"]
-      message: "Use the design-system primitives in @/components/ui/* instead of raw HTML elements"
-```
-
-Required: `in` + `message`, plus one of `pattern` / `jsx-element` (not both in the same stanza). A `pattern` may be a literal substring or, with the `re:` prefix, a regex; `singleton` patterns accept `re:` too.
-
-`jsx-element` matches intrinsic element names on the AST (opening and self-closing tags), so it is robust to whitespace, attributes, and naming collisions like `<buttonGroup>` — unlike a literal `pattern: "<button"` scan. It works on `.tsx`/`.jsx` files in both the TS and Rust engines.
-
-### Max lines — cap file length
-
-Limit how many physical lines a file in scope may have. Use a separate stanza per scope to give different ceilings to source and tests.
-
-```yaml
-arch:
-  maxLines:
-    - limit: 300               # positive integer; required
-      in: ["src/**"]           # string OR array; supports ! negation
-      message: "Split this module"   # optional — defaults to "File exceeds the maximum of N lines"
-      severity: error          # optional — default error; use warn to record without blocking
-
-    - limit: 600               # tests may run longer
-      in: ["tests/**"]
-```
-
-Required: `limit` + `in`. The count is **total physical lines** — blanks and comments included, not code lines — and a file over the limit is flagged at line `limit + 1`. Enforced identically in the TS and Rust engines, across every language klint scans.
-
-### Comment budget — cap explanatory prose
-
-Two ceilings on how much of a file may be comments. Use them to push intent into names and small
-functions rather than paragraphs that drift from the code they describe.
-
-```yaml
-arch:
-  # maxCommentDensity: what share of a file may be comment lines
-  maxCommentDensity:
-    - limit: 5                 # percent; required
-      in: ["src/**"]           # string OR array; supports ! negation
-      countDocComments: false  # optional — default false, so JSDoc/docstrings are exempt
-      message: "Encode intent in names and small functions, not prose"
-      severity: error          # optional — default error; use warn to record without blocking
-
-  # maxCommentBlock: how tall a single stack of comment lines may get
-  maxCommentBlock:
-    - limit: 2                 # consecutive comment lines; required
-      in: ["src/**"]
-      ignore: ["@codegen:"]    # optional — structural markers, not prose
-      message: "Extract a well-named function instead of stacking comment lines"
-```
-
-Required: `limit` + `in`. Density is a **percentage of total physical lines** (code + comments +
-blanks — the same denominator `maxLines` uses). Block height counts **consecutive** comment lines and
-is reported at the first offending line. Both exempt doc-comments by default — `/** … */` JSDoc and
-Python docstrings — so documentation is not penalised; ordinary `//`, `/* */`, and `#` comments always
-count. Set `countDocComments: true` to include them.
-
-The two are complementary: density catches a file that is 30% commented in scattered one-liners,
-block catches a ten-line essay above one function in an otherwise sparse file. Neither alone catches both.
-
-**`ignore` — comments that are machinery, not prose.** Some comments are load-bearing input to a
-build or codegen step (`// @codegen:region-start`, feature-strip markers, pragmas). They are comments to the
-lexer but structure to the project, and counting them makes both limits measure the wrong thing:
-
-```yaml
-arch:
-  maxCommentDensity:
-    - limit: 5
-      in: ["src/**"]
-      ignore: ["@codegen:"]         # literal substring, or "re:" for a regex
-```
-
-Two rules govern how an ignored line behaves, and both matter:
-
-- **It stays in the density denominator.** A marker is a physical line like code, so a 20-line file
-  with 4 markers and 1 real comment measures 1/20, not 1/16.
-- **It does not break a comment block.** `// a` / `// @marker` / `// b` / `// c` is a run of three
-  counted lines, not two runs. Otherwise sprinkling a marker every other line would defeat the cap.
-
-`ignore` tests the **physical source line**, so it only ever applies to lines already identified as
-comments — code containing the same text is untouched. Enforced identically in both engines.
-
-## Pitfalls
-
-- `pattern` in `singleton` and `forbidden` is a **literal substring** by default — it will not catch `process.env["KEY"]` (bracket notation). Either grep for both forms, or use a `re:` regex prefix to match them in one rule. Caveat: a literal pattern that itself begins with `re:` cannot be expressed (it is always read as a regex), and regexes must stay in the common JS/RE2 subset (no lookaround or backreferences) so both engines agree.
-- `maxLines.limit` counts **total physical lines** (blanks and comments included), not code lines; a trailing newline does not add a line, and both engines count identically.
-- `maxCommentDensity.limit` is a **percentage, not a line count** — `limit: 5` means 5% of the file, so a 40-line file is over budget at its third comment line. Measure before picking a number: land it as `severity: warn` first, read the reported densities, then tighten to `error`.
-- `jsx-element` matches **intrinsic** (lowercase HTML) tags only — `button`, `input`, `label`. It does not match custom React components like `<Button>`; to restrict those, use `arch.imports` against the component's module instead.
-- A `forbidden`/`singleton` stanza takes either `pattern` or `jsx-element`, never both — split into two stanzas if you need both.
-- `only` in `singleton` is relative to the project root — use forward slashes on all platforms.
-- `severity: warn` records the violation but does not block the session. Use `error` (the default) to block.
-- Path aliases (`@/*`) resolve via `tsconfig.json` `compilerOptions.paths`, including `extends` chains.
-- Adding a rule that fires on existing code is not a blocker — fix the violations first, then add the rule.
-
-## Output format
-
-After adding or modifying a rule, report:
-- The YAML stanza added
-- The grep evidence that confirmed the pattern is real
-- The test written and its result
-- The output of `bun run klint` (or `npx klint`) confirming zero new violations
-
-## Do NOT use
-
-- To fix TypeScript type errors, lint issues, or Biome violations — those are separate tools
-- To enforce naming conventions (hooks must start with `use`, components must be PascalCase) — use ESLint with the appropriate plugin
-- To write custom TypeScript AST rules in `klint.rules.ts` — that is a separate, code-level workflow

package/tools/generate-homebrew-formula.ts

@@ -1,64 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-
-interface FormulaOptions {
-  version: string;
-  darwinArm64Sha: string;
-  darwinX64Sha: string;
-}
-
-export function homebrewFormula(options: FormulaOptions): string {
-  const version = options.version.replace(/^v/, "");
-
-  return `# typed: false
-# frozen_string_literal: true
-
-class Klint < Formula
-  desc "Architecture-as-Code linter for TypeScript, Python, and Swift projects"
-  homepage "https://github.com/konvert7/klint"
-  version "${version}"
-  license "MIT"
-
-  if Hardware::CPU.arm?
-    url "https://github.com/konvert7/klint/releases/download/v${version}/klint-${version}-darwin-arm64.tar.gz"
-    sha256 "${options.darwinArm64Sha}"
-  else
-    url "https://github.com/konvert7/klint/releases/download/v${version}/klint-${version}-darwin-x64.tar.gz"
-    sha256 "${options.darwinX64Sha}"
-  end
-
-  def install
-    binary = File.exist?("klint") ? "klint" : Dir["klint-*/klint"].first
-    odie "klint binary not found" unless binary
-    bin.install binary => "klint"
-  end
-
-  test do
-    assert_match "klint-rs", shell_output("#{bin}/klint --version")
-  end
-end
-`;
-}
-
-if (import.meta.main) {
-  const args = process.argv.slice(2);
-  const output = requireValue(args, "--output");
-  const formula = homebrewFormula({
-    version: requireValue(args, "--version"),
-    darwinArm64Sha: requireValue(args, "--darwin-arm64-sha"),
-    darwinX64Sha: requireValue(args, "--darwin-x64-sha"),
-  });
-
-  const path = resolve(output);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, formula);
-}
-
-function requireValue(args: string[], name: string): string {
-  const index = args.indexOf(name);
-  const value = index >= 0 ? args[index + 1] : undefined;
-  if (!value) {
-    throw new Error(`${name} is required`);
-  }
-  return value;
-}

package/tools/prepare-native-release.ts

@@ -1,166 +0,0 @@
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { nativePackages } from "../core/native-binary";
-
-interface PackageJson {
-  name: string;
-  version: string;
-  private?: boolean;
-  optionalDependencies?: Record<string, string>;
-}
-
-interface Options {
-  version: string;
-  outDir: string;
-  requireBinaries: boolean;
-  keep: boolean;
-}
-
-const root = fileURLToPath(new URL("..", import.meta.url));
-const options = parseArgs();
-
-if (existsSync(options.outDir)) {
-  rmSync(options.outDir, { recursive: true, force: true });
-}
-mkdirSync(options.outDir, { recursive: true });
-
-try {
-  const releaseRootPackageJson = prepareRootPackageJson();
-  const nativeResults = nativePackages().map(prepareNativePackage);
-
-  validateRootPackageJson(releaseRootPackageJson);
-  for (const result of nativeResults) validateNativePackage(result.packageJson);
-
-  const missing = nativeResults
-    .filter((result) => !result.binaryCopied)
-    .map((result) => result.packageJson.name);
-
-  if (options.requireBinaries && missing.length > 0) {
-    fail(`Missing native release binaries:\n${missing.join("\n")}`);
-  }
-
-  const missingMessage =
-    missing.length > 0
-      ? `missing binaries: ${missing.join(", ")}`
-      : "missing binaries: none";
-  const outputLines = [
-    `native release dry-run ok (${options.version})`,
-    `output: ${options.outDir}`,
-    `native packages: ${nativeResults.length}`,
-    missingMessage,
-  ];
-  process.stdout.write(`${outputLines.join("\n")}\n`);
-} finally {
-  if (!options.keep) {
-    rmSync(options.outDir, { recursive: true, force: true });
-  }
-}
-
-function prepareRootPackageJson(): PackageJson {
-  const packageJson = readPackageJson(join(root, "package.json"));
-  packageJson.version = options.version;
-  delete packageJson.optionalDependencies;
-
-  const outPath = join(options.outDir, "package.json");
-  writeJson(outPath, packageJson);
-  return packageJson;
-}
-
-function prepareNativePackage(nativePackage: ReturnType<typeof nativePackages>[number]): {
-  binaryCopied: boolean;
-  packageJson: PackageJson;
-} {
-  const packageDirName = `${nativePackage.platform}-${nativePackage.arch}`;
-  const sourceDir = join(root, "npm", "native", packageDirName);
-  const outDir = join(options.outDir, "npm", "native", packageDirName);
-  mkdirSync(outDir, { recursive: true });
-
-  const packageJson = readPackageJson(join(sourceDir, "package.json"));
-  packageJson.version = options.version;
-  packageJson.private = false;
-  writeJson(join(outDir, "package.json"), packageJson);
-
-  const sourceBinary = join(sourceDir, nativePackage.binaryPath);
-  const outBinary = join(outDir, nativePackage.binaryPath);
-  const binaryCopied = existsSync(sourceBinary);
-  if (binaryCopied) {
-    mkdirSync(dirname(outBinary), { recursive: true });
-    copyFileSync(sourceBinary, outBinary);
-  }
-
-  return { binaryCopied, packageJson };
-}
-
-function validateRootPackageJson(packageJson: PackageJson): void {
-  const optionalDependencies = packageJson.optionalDependencies ?? {};
-  for (const nativePackage of nativePackages()) {
-    if (nativePackage.packageName in optionalDependencies) {
-      fail(
-        `Root package must not consume dark native package ${nativePackage.packageName}`
-      );
-    }
-  }
-}
-
-function validateNativePackage(packageJson: PackageJson): void {
-  if (packageJson.version !== options.version) {
-    fail(
-      `${packageJson.name} version is ${packageJson.version}, expected ${options.version}`
-    );
-  }
-  if (packageJson.private !== false) {
-    fail(`${packageJson.name} private must be false in release prep output`);
-  }
-}
-
-function readPackageJson(path: string): PackageJson {
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as PackageJson;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    fail(`Failed to read package JSON at ${path}: ${message}`);
-  }
-}
-
-function writeJson(path: string, value: unknown): void {
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-function parseArgs(): Options {
-  const args = process.argv.slice(2);
-  const version = valueAfter(args, "--version");
-  if (!version) {
-    fail(
-      "Usage: bun tools/prepare-native-release.ts --version <version> [--out <dir>] [--require-binaries] [--keep]"
-    );
-  }
-
-  return {
-    version,
-    outDir: resolve(
-      valueAfter(args, "--out") ?? mkdtempSync(join(tmpdir(), "klint-native-release-"))
-    ),
-    requireBinaries: args.includes("--require-binaries"),
-    keep: args.includes("--keep"),
-  };
-}
-
-function valueAfter(args: string[], name: string): string | undefined {
-  const index = args.indexOf(name);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-function fail(message: string): never {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}

package/tools/prepare-nuget-release.ts

@@ -1,62 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-interface Options {
-  version: string;
-  root: string;
-}
-
-const repoRoot = fileURLToPath(new URL("..", import.meta.url));
-const options = parseArgs();
-const csprojPath = join(options.root, "nuget", "Klint.Tool.csproj");
-
-const csproj = readFileSync(csprojPath, "utf-8");
-const nextCsproj = replaceRequired(
-  csproj,
-  /<Version>.+<\/Version>/,
-  `<Version>${options.version}</Version>`,
-  csprojPath
-);
-writeFileSync(csprojPath, nextCsproj);
-
-process.stdout.write(
-  `prepared NuGet release metadata: Konvert7.Klint@${options.version}\n`
-);
-
-function parseArgs(): Options {
-  const args = process.argv.slice(2);
-  const version = valueAfter(args, "--version");
-  if (!version) {
-    fail(
-      "Usage: bun tools/prepare-nuget-release.ts --version <version> [--root <repo-root>]"
-    );
-  }
-
-  return {
-    version,
-    root: resolve(valueAfter(args, "--root") ?? repoRoot),
-  };
-}
-
-function replaceRequired(
-  input: string,
-  pattern: RegExp,
-  replacement: string,
-  path: string
-): string {
-  if (!pattern.test(input)) {
-    fail(`Expected release metadata pattern ${pattern} in ${path}`);
-  }
-  return input.replace(pattern, replacement);
-}
-
-function valueAfter(args: string[], name: string): string | undefined {
-  const index = args.indexOf(name);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-function fail(message: string): never {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}

package/tools/prepare-python-release.ts

@@ -1,76 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-interface Options {
-  name: string;
-  root: string;
-  version: string;
-}
-
-const repoRoot = fileURLToPath(new URL("..", import.meta.url));
-const options = parseArgs();
-const pythonRoot = join(options.root, "python");
-const pyprojectPath = join(pythonRoot, "pyproject.toml");
-const initPath = join(pythonRoot, "klint", "__init__.py");
-
-const pyproject = readFileSync(pyprojectPath, "utf-8");
-const nextPyproject = replaceRequired(
-  replaceRequired(pyproject, /^name = ".+"$/m, `name = "${options.name}"`, pyprojectPath),
-  /^version = ".+"$/m,
-  `version = "${options.version}"`,
-  pyprojectPath
-);
-writeFileSync(pyprojectPath, nextPyproject);
-
-const init = readFileSync(initPath, "utf-8");
-const nextInit = replaceRequired(
-  init,
-  /^__version__ = ".+"$/m,
-  `__version__ = "${options.version}"`,
-  initPath
-);
-writeFileSync(initPath, nextInit);
-
-process.stdout.write(
-  `prepared Python release metadata: ${options.name}@${options.version}\n`
-);
-
-function parseArgs(): Options {
-  const args = process.argv.slice(2);
-  const name = valueAfter(args, "--name");
-  const version = valueAfter(args, "--version");
-  if (!name || !version) {
-    fail(
-      "Usage: bun tools/prepare-python-release.ts --name <package-name> --version <version> [--root <repo-root>]"
-    );
-  }
-
-  return {
-    name,
-    version,
-    root: resolve(valueAfter(args, "--root") ?? repoRoot),
-  };
-}
-
-function replaceRequired(
-  input: string,
-  pattern: RegExp,
-  replacement: string,
-  path: string
-): string {
-  if (!pattern.test(input)) {
-    fail(`Expected release metadata pattern ${pattern} in ${path}`);
-  }
-  return input.replace(pattern, replacement);
-}
-
-function valueAfter(args: string[], name: string): string | undefined {
-  const index = args.indexOf(name);
-  return index >= 0 ? args[index + 1] : undefined;
-}
-
-function fail(message: string): never {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}