oh-my-opencode 5.1.51 → 5.1.55

package/dist/skills/programming/scripts/python/new-script.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env bun
+/**
+ * Generate a PEP 723 Python script with all boilerplate pre-filled: uv shebang,
+ * inline metadata (requires-python + dependencies), the mandatory "How to run"
+ * block, `from __future__ import annotations`, and a main() guard.
+ *
+ * ─── How to run ───
+ * 1. Install Bun: curl -fsSL https://bun.sh/install | bash
+ * 2. Run:
+ *      bun run new-script.ts my_tool
+ *      bun run new-script.ts my_tool --output ./scripts/my_tool.py
+ *      bun run new-script.ts my_tool --deps 'httpx2[http2,brotli,zstd]' --deps rich --deps polars
+ *      bun run new-script.ts my_tool --py 3.13
+ * ──────────────────
+ *
+ * Writes to <os tmpdir>/uv-scripts/<name>.py unless --output is given.
+ * Exit codes: 0 written, 2 usage error.
+ */
+
+import { chmodSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+import { assertNever } from "../shared/run-tool.ts";
+
+const USAGE = `Usage: bun run new-script.ts <name> [--output <path>] [--deps <dep>]... [--py <version>]
+
+Arguments:
+  name          Script name (without .py extension)
+
+Options:
+  -o, --output  Output path (default: OS temp directory)
+  -d, --deps    Dependency to include (repeat --deps for each)
+  --py          Minimum Python version (default: 3.13)
+  -h, --help    Show this help`;
+
+type ScriptOptions = {
+  readonly name: string;
+  readonly output: string | undefined;
+  readonly deps: readonly string[];
+  readonly py: string;
+};
+
+type Cli =
+  | { readonly kind: "run"; readonly options: ScriptOptions }
+  | { readonly kind: "help" }
+  | { readonly kind: "usage"; readonly problem: string };
+
+function parseCli(): Cli {
+  try {
+    const { values, positionals } = parseArgs({
+      args: Bun.argv.slice(2),
+      options: {
+        output: { type: "string", short: "o" },
+        deps: { type: "string", short: "d", multiple: true, default: [] },
+        py: { type: "string", default: "3.13" },
+        help: { type: "boolean", short: "h", default: false },
+      },
+      allowPositionals: true,
+      strict: true,
+    });
+    if (values.help) return { kind: "help" };
+    const [name, ...extra] = positionals;
+    if (name === undefined || extra.length > 0) return { kind: "usage", problem: "expected exactly one script name" };
+    return { kind: "run", options: { name, output: values.output, deps: values.deps, py: values.py } };
+  } catch (error) {
+    if (error instanceof TypeError) return { kind: "usage", problem: error.message };
+    throw error;
+  }
+}
+
+function renderScript(pythonVersion: string, deps: readonly string[], filename: string): string {
+  const depsBlock =
+    deps.length > 0
+      ? deps.map((dep) => `#     "${dep}",\n`).join("")
+      : '#     # add deps here, e.g.: "httpx2[http2,brotli,zstd]"\n';
+  const argsHint = "";
+  return `#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=${pythonVersion}"
+# dependencies = [
+${depsBlock}# ]
+# ///
+
+# ─── How to run ───
+# 1. Install uv (if not installed):
+#      curl -LsSf https://astral.sh/uv/install.sh | sh
+# 2. Run directly (no venv, no pip install needed):
+#      uv run ${filename} ${argsHint}
+# 3. Or make executable and run:
+#      chmod +x ${filename} && ./${filename}
+# ──────────────────
+
+from __future__ import annotations
+
+
+def main() -> None:
+    """TODO: implement."""
+
+
+if __name__ == "__main__":
+    main()
+`;
+}
+
+function writeScript({ name, output, deps, py }: ScriptOptions): void {
+  const filename = name.endsWith(".py") ? name : `${name}.py`;
+  const dest = output ?? join(tmpdir(), "uv-scripts", filename);
+  mkdirSync(dirname(dest), { recursive: true });
+  writeFileSync(dest, renderScript(py, deps, filename));
+  if (process.platform !== "win32") chmodSync(dest, statSync(dest).mode | 0o111);
+
+  console.log(`✓ Created: ${dest}`);
+  console.log(`  Run: uv run ${dest}`);
+}
+
+function main(): number {
+  const cli = parseCli();
+  switch (cli.kind) {
+    case "help":
+      console.log(USAGE);
+      return 0;
+    case "usage":
+      console.error(`Error: ${cli.problem}\n\n${USAGE}`);
+      return 2;
+    case "run":
+      writeScript(cli.options);
+      return 0;
+    default:
+      return assertNever(cli);
+  }
+}
+
+process.exit(main());

package/dist/skills/programming/scripts/rust/new-project.ts

@@ -0,0 +1,215 @@
+#!/usr/bin/env bun
+/**
+ * Scaffold a new Rust project with strict lints, deny.toml, rustfmt.toml, and
+ * rust-toolchain.toml pre-configured. The generated project passes its own
+ * fmt + clippy gate before any code is written.
+ *
+ * ─── How to run ───
+ * 1. Install Bun:  curl -fsSL https://bun.sh/install | bash
+ * 2. Install Rust: https://rustup.rs (cargo >= 1.85, edition 2024)
+ * 3. Run:
+ *      bun run new-project.ts myproject
+ *      bun run new-project.ts myproject --path ./workspace
+ * ──────────────────
+ *
+ * Exit codes: 0 created, 1 cargo or scaffold failure, 2 usage error.
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { assertNever, runTool } from "../shared/run-tool.ts";
+
+const USAGE = `Usage: bun run new-project.ts <name> [--path <dir>]
+
+Arguments:
+  name          Name of the new Rust project
+
+Options:
+  -p, --path    Parent directory where the project folder is created (default: cwd)
+  -h, --help    Show this help`;
+
+const RUST_TOOLCHAIN_TOML = `[toolchain]
+channel = "stable"
+components = ["rustfmt", "clippy", "rust-src"]
+profile = "default"
+`;
+
+const CARGO_TOML_LINTS = `
+[lints.rust]
+unsafe_op_in_unsafe_fn = "deny"
+missing_docs = "warn"
+missing_debug_implementations = "warn"
+unreachable_pub = "warn"
+unused_must_use = "deny"
+elided_lifetimes_in_paths = "warn"
+non_ascii_idents = "deny"
+trivial_numeric_casts = "warn"
+unused_lifetimes = "warn"
+single_use_lifetimes = "warn"
+unexpected_cfgs = { level = "deny", check-cfg = ["cfg(loom)"] }
+
+[lints.clippy]
+all = { level = "deny", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+undocumented_unsafe_blocks = "deny"
+multiple_unsafe_ops_per_block = "deny"
+unwrap_used = "deny"
+expect_used = "deny"
+panic = "deny"
+todo = "deny"
+unimplemented = "deny"
+dbg_macro = "deny"
+print_stdout = "warn"
+print_stderr = "warn"
+allow_attributes = "deny"
+allow_attributes_without_reason = "deny"
+let_underscore_must_use = "deny"
+indexing_slicing = "deny"
+mem_forget = "deny"
+clone_on_ref_ptr = "warn"
+module_name_repetitions = { level = "allow" }
+must_use_candidate = { level = "allow" }
+`;
+
+const DENY_TOML = `[advisories]
+yanked = "deny"
+
+[licenses]
+private = { ignore = true }  # publish = false crates carry no license field
+allow = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unicode-3.0", "Zlib"]
+
+[bans]
+multiple-versions = "warn"
+wildcards = "deny"
+
+[sources]
+unknown-registry = "deny"
+unknown-git = "deny"
+`;
+
+const MAIN_RS = `//! Command-line entry point.
+
+use std::io::Write as _;
+
+fn main() -> std::io::Result<()> {
+    writeln!(std::io::stdout().lock(), "Hello, world!")
+}
+`;
+
+const RUSTFMT_TOML = `edition = "2024"
+max_width = 100
+use_field_init_shorthand = true
+use_try_shorthand = true
+`;
+
+const EDITION_LINE = 'edition = "2024"\n';
+
+type ProjectOptions = { readonly name: string; readonly path: string };
+
+type Cli =
+  | { readonly kind: "run"; readonly options: ProjectOptions }
+  | { readonly kind: "help" }
+  | { readonly kind: "usage"; readonly problem: string };
+
+class ScaffoldError extends Error {
+  constructor(
+    readonly kind: "cargo-unavailable" | "cargo-init-failed" | "edition-too-old",
+    message: string,
+  ) {
+    super(message);
+    this.name = "ScaffoldError";
+  }
+}
+
+function parseCli(): Cli {
+  try {
+    const { values, positionals } = parseArgs({
+      args: Bun.argv.slice(2),
+      options: {
+        path: { type: "string", short: "p", default: process.cwd() },
+        help: { type: "boolean", short: "h", default: false },
+      },
+      allowPositionals: true,
+      strict: true,
+    });
+    if (values.help) return { kind: "help" };
+    const [name, ...extra] = positionals;
+    if (name === undefined || extra.length > 0) return { kind: "usage", problem: "expected exactly one project name" };
+    return { kind: "run", options: { name, path: values.path } };
+  } catch (error) {
+    if (error instanceof TypeError) return { kind: "usage", problem: error.message };
+    throw error;
+  }
+}
+
+function cargoInit(projectDir: string, name: string): void {
+  const init = runTool("cargo", ["init", projectDir, "--name", name]);
+  switch (init.kind) {
+    case "ok":
+      return;
+    case "unavailable":
+      throw new ScaffoldError("cargo-unavailable", `cargo not found (${init.reason}). Install Rust via https://rustup.rs`);
+    case "failed":
+      throw new ScaffoldError("cargo-init-failed", `cargo init failed:\n${init.stderr}`);
+    default:
+      return assertNever(init);
+  }
+}
+
+function scaffold({ name, path }: ProjectOptions): void {
+  const projectDir = join(path, name);
+  console.error(`Creating project ${name} at ${projectDir}`);
+  cargoInit(projectDir, name);
+
+  writeFileSync(join(projectDir, "rust-toolchain.toml"), RUST_TOOLCHAIN_TOML);
+  console.error("  wrote rust-toolchain.toml");
+
+  const cargoToml = join(projectDir, "Cargo.toml");
+  const manifest = readFileSync(cargoToml, "utf8");
+  if (!manifest.includes(EDITION_LINE)) {
+    throw new ScaffoldError("edition-too-old", "cargo did not create an edition 2024 package; install Rust >= 1.85");
+  }
+  const withMsrv = manifest.replace(EDITION_LINE, `${EDITION_LINE}rust-version = "1.85"\npublish = false\n`);
+  writeFileSync(cargoToml, withMsrv + CARGO_TOML_LINTS);
+  writeFileSync(join(projectDir, "src", "main.rs"), MAIN_RS);
+  console.error("  appended [lints] to Cargo.toml");
+
+  writeFileSync(join(projectDir, "deny.toml"), DENY_TOML);
+  console.error("  wrote deny.toml");
+
+  writeFileSync(join(projectDir, "rustfmt.toml"), RUSTFMT_TOML);
+  console.error("  wrote rustfmt.toml");
+
+  console.error(`\nDone! cd ${projectDir} && cargo check`);
+}
+
+function main(): number {
+  const cli = parseCli();
+  switch (cli.kind) {
+    case "help":
+      console.log(USAGE);
+      return 0;
+    case "usage":
+      console.error(`Error: ${cli.problem}\n\n${USAGE}`);
+      return 2;
+    case "run":
+      break;
+    default:
+      return assertNever(cli);
+  }
+  try {
+    scaffold(cli.options);
+    return 0;
+  } catch (error) {
+    if (error instanceof ScaffoldError) {
+      console.error(`Error: ${error.message}`);
+      return 1;
+    }
+    throw error;
+  }
+}
+
+process.exit(main());

package/dist/skills/programming/scripts/scaffolders.test.ts

@@ -0,0 +1,96 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const runRoot = mkdtempSync(join(process.env.RUN_TMP ?? tmpdir(), "programming-scaffolders-"));
+const emptyBin = join(runRoot, "empty-bin");
+mkdirSync(emptyBin);
+
+afterAll(() => rmSync(runRoot, { recursive: true, force: true }));
+
+async function scaffold(script: string, args: readonly string[]) {
+  const child = Bun.spawn([process.execPath, join(import.meta.dir, script), ...args], {
+    cwd: runRoot,
+    env: { ...process.env, PATH: emptyBin },
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+  const [stderr, code] = await Promise.all([new Response(child.stderr).text(), child.exited]);
+  return { stderr, code };
+}
+
+function pep723Metadata(source: string): unknown {
+  const block = /^# \/\/\/ script\n((?:#.*\n)*?)# \/\/\/$/m.exec(source)?.[1] ?? "";
+  return Bun.TOML.parse(block.replace(/^# ?/gm, ""));
+}
+
+describe("#given the Bun scaffolders run offline", () => {
+  test("#when new-script gets --deps and --py #then it writes an executable PEP 723 script declaring them", async () => {
+    const dest = join(runRoot, "scripts", "tool.py");
+
+    const result = await scaffold("python/new-script.ts", ["tool", "--output", dest, "-d", "polars", "--deps", "duckdb", "--py", "3.12"]);
+
+    expect(result.code).toBe(0);
+    expect(pep723Metadata(readFileSync(dest, "utf8"))).toEqual({ "requires-python": ">=3.12", dependencies: ["polars", "duckdb"] });
+    expect(statSync(dest).mode & 0o111).toBe(process.platform === "win32" ? 0 : 0o111);
+  });
+
+  test("#when go is not on PATH #then go new-project writes the fallback go.mod and substitutes the templates", async () => {
+    const project = join(runRoot, "svc");
+
+    const result = await scaffold("go/new-project.ts", ["svc", "--path", runRoot, "--module", "example.com/acme/svc", "--purpose", "billing"]);
+
+    expect(result.code).toBe(0);
+    expect(readFileSync(join(project, "go.mod"), "utf8")).toBe("module example.com/acme/svc\n\ngo 1.23\n");
+    expect(readFileSync(join(project, "cmd", "server", "main.go"), "utf8")).toContain('"example.com/acme/svc/internal/cmd"');
+    const agents = readFileSync(join(project, "AGENTS.md"), "utf8");
+    expect(agents).toContain(" billing ");
+    expect(agents).not.toMatch(/\$\{?[_a-z]/i);
+    expect(readFileSync(join(project, "README.md"), "utf8").split("\n")[0]).toBe("# svc");
+  });
+
+  test("#when the go templates were checked out with CRLF #then every generated file is LF", async () => {
+    // A CRLF checkout (git autocrlf) must not leak into the scaffolded project: its own .editorconfig says end_of_line = lf.
+    const scriptsCopy = join(runRoot, "crlf-scripts");
+    for (const dir of ["go", "shared"]) cpSync(join(import.meta.dir, dir), join(scriptsCopy, dir), { recursive: true });
+    const templatesDir = join(scriptsCopy, "go", "templates");
+    for (const file of readdirSync(templatesDir)) {
+      const path = join(templatesDir, file);
+      writeFileSync(path, readFileSync(path, "utf8").replace(/\r?\n/g, "\r\n"));
+    }
+    const project = join(runRoot, "crlf-svc");
+
+    const child = Bun.spawn([process.execPath, join(scriptsCopy, "go", "new-project.ts"), "crlf-svc", "--path", runRoot, "--module", "example.com/acme/crlf", "--purpose", "billing"], {
+      cwd: runRoot,
+      env: { ...process.env, PATH: emptyBin },
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    const [stderr, code] = await Promise.all([new Response(child.stderr).text(), child.exited]);
+
+    expect(code, stderr).toBe(0);
+    const generated = readdirSync(project, { recursive: true, withFileTypes: true })
+      .filter((entry) => entry.isFile())
+      .map((entry) => join(entry.parentPath, entry.name));
+    expect(generated.length).toBe(11);
+    const withCr = generated.filter((file) => readFileSync(file, "utf8").includes("\r"));
+    expect(withCr).toEqual([]);
+    expect(readFileSync(join(project, "README.md"), "utf8").split("\n")[0]).toBe("# crlf-svc");
+  });
+
+  test("#when cargo is not on PATH #then rust new-project exits 1 naming cargo", async () => {
+    const result = await scaffold("rust/new-project.ts", ["rsapp", "--path", runRoot]);
+
+    expect(result.code).toBe(1);
+    expect(result.stderr).toMatch(/\bcargo\b/);
+  });
+
+  test("#when uv is not on PATH #then python new-project exits 1 naming uv and creates nothing", async () => {
+    const result = await scaffold("python/new-project.ts", ["pyapp", "--path", runRoot]);
+
+    expect(result.code).toBe(1);
+    expect(result.stderr).toMatch(/\buv\b/);
+    expect(existsSync(join(runRoot, "pyapp"))).toBe(false);
+  });
+});

package/dist/skills/programming/scripts/shared/run-tool.ts

@@ -0,0 +1,19 @@
+/** Shared by the Python, Rust, and Go scaffolders: run uv/cargo/go and classify the outcome. */
+
+import { spawnSync } from "node:child_process";
+
+export type ToolOutcome =
+  | { readonly kind: "ok" }
+  | { readonly kind: "unavailable"; readonly reason: string }
+  | { readonly kind: "failed"; readonly status: number | null; readonly stderr: string };
+
+export function runTool(command: string, args: readonly string[], cwd?: string): ToolOutcome {
+  const result = spawnSync(command, args, { cwd, encoding: "utf8" });
+  if (result.error !== undefined) return { kind: "unavailable", reason: result.error.message };
+  if (result.status === 0) return { kind: "ok" };
+  return { kind: "failed", status: result.status, stderr: result.stderr };
+}
+
+export function assertNever(value: never): never {
+  throw new Error(`Unhandled variant: ${JSON.stringify(value)}`);
+}

package/dist/skills/programming/scripts/typescript/check-test-junk-rules.ts

@@ -0,0 +1,140 @@
+import { extname } from "node:path"
+
+export type RuleId =
+  | "source-grep"
+  | "prose-pin"
+  | "fixed-sleep"
+  | "focused"
+  | "skipped"
+  | "self-compare"
+  | "lower-bound"
+
+export type Language = "typescript" | "python" | "rust" | "go"
+
+export type ReadKind = "prose" | "source"
+
+export type LineRule = {
+  readonly rule: RuleId
+  readonly languages: readonly Language[]
+  readonly pattern: RegExp
+  readonly message: string
+}
+
+export const RULE_IDS: readonly RuleId[] = [
+  "source-grep",
+  "prose-pin",
+  "fixed-sleep",
+  "focused",
+  "skipped",
+  "self-compare",
+  "lower-bound",
+]
+
+export function languageOf(file: string): Language | undefined {
+  switch (extname(file)) {
+    case ".ts":
+    case ".tsx":
+    case ".mts":
+    case ".cts":
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return "typescript"
+    case ".py":
+      return "python"
+    case ".rs":
+      return "rust"
+    case ".go":
+      return "go"
+    default:
+      return undefined
+  }
+}
+
+const SLEEP_MESSAGE = "fixed sleep: wait on the event or state change, not on the clock"
+const SKIP_MESSAGE = "skipped test: fix the test or delete it with its proof; never park it"
+const LOWER_BOUND_MESSAGE = "lower bound on a cardinality: removing one item stays green; pin the exact set"
+
+export const LINE_RULES: readonly LineRule[] = [
+  {
+    rule: "fixed-sleep",
+    languages: ["typescript"],
+    pattern: /\bsetTimeout\s*\(\s*(resolve|res|r|done|cb)\s*,\s*[1-9]|\bawait\s+(Bun\.)?sleep\s*\(\s*[1-9]|new Promise\s*\(\s*\(?\s*\w*\s*\)?\s*=>\s*setTimeout\s*\(\s*\w+\s*,\s*[1-9]/,
+    message: SLEEP_MESSAGE,
+  },
+  { rule: "fixed-sleep", languages: ["python"], pattern: /\btime\.sleep\s*\(|\bawait\s+(asyncio|anyio|trio)\.sleep\s*\(\s*[0-9]/, message: SLEEP_MESSAGE },
+  { rule: "fixed-sleep", languages: ["rust"], pattern: /\bthread::sleep\s*\(|\btokio::time::sleep\s*\(/, message: SLEEP_MESSAGE },
+  { rule: "fixed-sleep", languages: ["go"], pattern: /\btime\.Sleep\s*\(/, message: SLEEP_MESSAGE },
+  {
+    rule: "focused",
+    languages: ["typescript"],
+    pattern: /\b(test|it|describe)\.only\s*\(/,
+    message: "focused test: the rest of the suite is skipped silently",
+  },
+  { rule: "skipped", languages: ["typescript"], pattern: /\b(test|it|describe)\.skip\s*\(|\b(xit|xdescribe|xtest)\s*\(/, message: SKIP_MESSAGE },
+  { rule: "skipped", languages: ["python"], pattern: /@pytest\.mark\.skip\b|\bpytest\.skip\s*\(|\bunittest\.skip\b/, message: SKIP_MESSAGE },
+  { rule: "skipped", languages: ["rust"], pattern: /#\[ignore\b/, message: SKIP_MESSAGE },
+  { rule: "skipped", languages: ["go"], pattern: /\bt\.Skip(f|Now)?\s*\(/, message: SKIP_MESSAGE },
+  {
+    rule: "lower-bound",
+    languages: ["typescript"],
+    pattern: /\.(length|size|count)\s*\)\s*\.(toBeGreaterThan\s*\(\s*[1-9]|toBeGreaterThanOrEqual\s*\(\s*([2-9]|\d{2,}))/,
+    message: LOWER_BOUND_MESSAGE,
+  },
+  {
+    rule: "lower-bound",
+    languages: ["python"],
+    pattern: /\bassert\s+len\s*\(.+\)\s*(>\s*[1-9]|>=\s*([2-9]|\d{2,}))/,
+    message: LOWER_BOUND_MESSAGE,
+  },
+]
+
+export const SELF_COMPARE: Readonly<Record<Language, RegExp>> = {
+  typescript: /\bexpect\s*\(\s*([^()]+?)\s*\)\s*\.(toBe|toEqual|toStrictEqual)\s*\(\s*\1\s*\)/,
+  python: /\bassert\s+([A-Za-z_][\w.]*)\s*==\s*\1\s*(#|$)/,
+  rust: /\bassert_eq!\s*\(\s*([^,()]+?)\s*,\s*\1\s*\)/,
+  go: /\b(Equal|Exactly)\s*\(\s*t\s*,\s*([^,()]+?)\s*,\s*\2\s*\)/,
+}
+
+const SOURCE_EXTENSIONS = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|py|rs|go)$/
+const PROSE_EXTENSIONS = /\.(md|mdc|txt|prompt)$/
+const READ_ASSIGNMENT = /\b(?:const|let|var)\s+(\w+)\s*=\s*(?:await\s+)?(?:\w+\.)?(?:readFileSync|readFile|readTextSync|Bun\.file|open|read_text|read)\s*\(([^\n]*)$/
+const PYTHON_READ_ASSIGNMENT = /^\s*(\w+)\s*=\s*(?:\w+\.)?(?:open|Path|read_text)\s*\(([^\n]*)$/
+const STRING_LITERAL = /["'`]([^"'`]+)["'`]/g
+
+function readKindOf(callArguments: string): ReadKind | undefined {
+  for (const literal of callArguments.matchAll(STRING_LITERAL)) {
+    const value = literal[1] ?? ""
+    if (PROSE_EXTENSIONS.test(value)) return "prose"
+    if (SOURCE_EXTENSIONS.test(value)) return "source"
+  }
+  return undefined
+}
+
+export function collectReadVariables(lines: readonly string[], language: Language): ReadonlyMap<string, ReadKind> {
+  const variables = new Map<string, ReadKind>()
+  const pattern = language === "python" ? PYTHON_READ_ASSIGNMENT : READ_ASSIGNMENT
+  for (const line of lines) {
+    const match = pattern.exec(line)
+    if (match === null) continue
+    const kind = readKindOf(match[2] ?? "")
+    if (kind !== undefined && match[1] !== undefined) variables.set(match[1], kind)
+  }
+  return variables
+}
+
+export function greppedVariable(line: string, language: Language): string | undefined {
+  if (language === "python") {
+    return /\bassert\s+(?:not\s+)?["'][^"']*["']\s+(?:not\s+)?in\s+(\w+)/.exec(line)?.[1]
+  }
+  return (
+    /\bexpect\s*\(\s*(\w+)\s*\)\s*(?:\.not)?\.(?:toContain|toMatch|toMatchSnapshot|toMatchInlineSnapshot|toInclude|toStartWith|toEndWith)\s*\(/.exec(line)?.[1] ??
+    /\bexpect\s*\(\s*(\w+)\.(?:includes|match|indexOf|search)\s*\(/.exec(line)?.[1]
+  )
+}
+
+export const READ_RULE_MESSAGES: Readonly<Record<ReadKind, { readonly rule: RuleId; readonly message: string }>> = {
+  prose: { rule: "prose-pin", message: "wording of a prompt/skill/doc is pinned; assert a machine-consumed value or write no test" },
+  source: { rule: "source-grep", message: "a source file is grepped as text; drive the module and assert behavior" },
+}