oh-my-opencode 5.1.51 → 5.1.55

package/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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/packages/omo-codex/plugin/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" },
+}

package/packages/omo-codex/plugin/skills/programming/scripts/typescript/check-test-junk.ts

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+/**
+ * Flag test files for the junk classes a regex can see (the rest need a reader):
+ *
+ *   source-grep    - a value read from a source file (.ts/.js/.py/.rs/.go/...) is grepped
+ *                    (toContain / toMatch / includes / `in`); byte equality between two reads is not flagged
+ *   prose-pin      - a value read from a prompt/skill/markdown file has its wording pinned
+ *                    (toContain / not.toContain / toMatch / toMatchSnapshot / `in`)
+ *   fixed-sleep    - setTimeout-as-wait, sleep(N), time.sleep, thread::sleep, time.Sleep
+ *   focused        - test.only / it.only / describe.only (a focused test silently skips the suite)
+ *   skipped        - .skip / xit / xdescribe / @pytest.mark.skip / #[ignore] / t.Skip
+ *   self-compare   - expect(x).toBe(x) / assert x == x / assert_eq!(x, x)
+ *   lower-bound    - toBeGreaterThan(N>=1) / toBeGreaterThanOrEqual(N>=2) on a length/size/count
+ *                    (removing one item stays green; a plain non-empty check is not flagged)
+ *
+ * Opt out per line with a trailing comment naming the rule and the reason:
+ *   // test-junk-ok: fixed-sleep debounce window is the behavior under test
+ *
+ * Usage:
+ *   bun run scripts/typescript/check-test-junk.ts [--json] <file-or-dir>...
+ *
+ * Exit codes: 0 no findings, 1 findings, 2 input error.
+ * Each class is explained in references/testing/junk-classes.md; a finding here is a candidate
+ * to prove with references/testing/README.md "test your test", not an automatic deletion.
+ */
+
+import { readdirSync, readFileSync, statSync } from "node:fs"
+import { basename, extname, join } from "node:path"
+import process from "node:process"
+
+import {
+  collectReadVariables,
+  greppedVariable,
+  languageOf,
+  LINE_RULES,
+  READ_RULE_MESSAGES,
+  RULE_IDS,
+  SELF_COMPARE,
+  type RuleId,
+} from "./check-test-junk-rules"
+
+export type { RuleId } from "./check-test-junk-rules"
+
+export type Finding = {
+  readonly file: string
+  readonly line: number
+  readonly rule: RuleId
+  readonly message: string
+}
+
+const EXCLUDED_DIRS: ReadonlySet<string> = new Set([".git", "node_modules", "dist", "build", "target", "__pycache__", ".venv", "vendor"])
+
+const TEST_FILE_PATTERNS: readonly RegExp[] = [
+  /\.(test|spec)\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/,
+  /_test\.go$/,
+  /(^|\/)test_[^/]*\.py$/,
+  /(^|\/)[^/]*_test\.py$/,
+  /\.rs$/,
+]
+
+const OPT_OUT = /test-junk-ok:\s*([a-z-]+)/
+
+function isTestFile(file: string): boolean {
+  if (!TEST_FILE_PATTERNS.some((pattern) => pattern.test(file))) return false
+  // Rust unit tests live inside source files; only files declaring a test module count.
+  return extname(file) !== ".rs" || /#\[cfg\(test\)\]|#\[test\]/.test(readFileSync(file, "utf8"))
+}
+
+function* walk(root: string): Generator<string> {
+  if (statSync(root).isFile()) {
+    yield root
+    return
+  }
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!EXCLUDED_DIRS.has(entry.name)) yield* walk(join(root, entry.name))
+    } else if (entry.isFile()) {
+      yield join(root, entry.name)
+    }
+  }
+}
+
+function optedOut(line: string, rule: RuleId): boolean {
+  const match = OPT_OUT.exec(line)
+  return match !== null && match[1] === rule
+}
+
+function scanFile(file: string): readonly Finding[] {
+  const language = languageOf(file)
+  if (language === undefined) return []
+  const lines = readFileSync(file, "utf8").split("\n")
+  const readVariables = collectReadVariables(lines, language)
+  const findings: Finding[] = []
+  const report = (line: number, rule: RuleId, message: string): void => {
+    if (!optedOut(lines[line - 1] ?? "", rule)) findings.push({ file, line, rule, message })
+  }
+
+  lines.forEach((source, index) => {
+    const line = index + 1
+    for (const rule of LINE_RULES) {
+      if (rule.languages.includes(language) && rule.pattern.test(source)) report(line, rule.rule, rule.message)
+    }
+    if (SELF_COMPARE[language].test(source)) {
+      report(line, "self-compare", "the expected value is the value under test; derive it from the input")
+    }
+    const grepped = greppedVariable(source, language)
+    const kind = grepped === undefined ? undefined : readVariables.get(grepped)
+    if (kind !== undefined) report(line, READ_RULE_MESSAGES[kind].rule, READ_RULE_MESSAGES[kind].message)
+  })
+  return findings
+}
+
+function scan(paths: readonly string[]): readonly Finding[] {
+  const findings: Finding[] = []
+  for (const root of paths) {
+    for (const file of walk(root)) {
+      if (isTestFile(file)) findings.push(...scanFile(file))
+    }
+  }
+  return findings
+}
+
+function main(argv: readonly string[]): number {
+  const json = argv.includes("--json")
+  const paths = argv.filter((arg) => arg !== "--json")
+  if (paths.length === 0) {
+    console.error(`usage: ${basename(import.meta.path)} [--json] <file-or-dir>...`)
+    return 2
+  }
+  for (const path of paths) {
+    try {
+      statSync(path)
+    } catch {
+      console.error(`error: ${path} does not exist`)
+      return 2
+    }
+  }
+  const findings = scan(paths)
+  if (json) {
+    console.log(JSON.stringify({ findings, rules: RULE_IDS }, null, 2))
+  } else {
+    for (const finding of findings) console.log(`${finding.file}:${finding.line} ${finding.rule} ${finding.message}`)
+    console.log(findings.length === 0 ? "check-test-junk: no findings" : `check-test-junk: ${findings.length} finding(s)`)
+  }
+  return findings.length === 0 ? 0 : 1
+}
+
+if (import.meta.main) process.exit(main(process.argv.slice(2)))