code-yeongyu/oh-my-openagent / packages/shared-skills/skills/programming
programming
FlaggedApplies strict, modern language practice (typed errors, exhaustive match, tests that can fail) for Python, Rust, TypeScript, JavaScript, and Go. Use for work on .py, .rs, .ts, .js, or .go files, and whenever a test or spec file is written, reshaped, reviewed, or deleted: the four-question test authoring gate and the junk-test classes live here.
scripts/scaffolders.test.ts
View on GitHubimport { 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)
})
})
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |