Add the Test skill: find untested code and write tests in the project's style

AI Assisted
This commit is contained in:
jparkerweb committed 2026-11-03 21:42:36 -08:00
1 parent 88c72dc2ce
commit 6cd7a7ff80
21 files changed
+753 -16

No files matched your search

+155
View File
@@ -0,0 +1,155 @@
#!/usr/bin/env node
// coverage.mjs: coverage output read into per-file numbers, for the Test skill.
//
// Reads what a project's own coverage tool already wrote: an lcov file (Node's
// test runner with the lcov reporter, Jest, Vitest, pytest-cov's lcov export)
// or the text `go tool cover -func` prints. It never runs a tool and never
// writes a file; the skill runs the coverage command first, on a yes.
import fs from "node:fs";
import path from "node:path";
import { EXIT, fail, out, parseArgs, run } from "./common.mjs";
const USAGE = `
coverage.mjs: per-file coverage from a coverage tool's output. JSON on stdout.
node coverage.mjs read --lcov <file> [--root <dir>]
node coverage.mjs read --go-func <file> [--root <dir>]
Prints { ok, format, files: [{ file, lines, hit, pct }], total },
files sorted by path, pct with one decimal.
lcov SF: / DA:<line>,<hits> / LF: / LH: / end_of_record records.
lines is LF (or the DA count when LF is missing), hit is LH
(or the DA lines with hits above 0). Paths are made relative
to --root (default: the current folder) with forward slashes;
an absolute path outside the root is kept as given. total
sums every file.
go-func "<import path>/<file>.go:<line>: <func> <pct>%" lines,
grouped by file: pct is the mean of the file's functions,
lines and hit are null. The module path from --root's go.mod
is dropped so files read as project paths. The "total:" line
is not a file: it is reported as total.
A file with no lines has pct null.
Exit: 0 ok · 1 crash · 2 bad arguments · 3 no such file · 4 not lcov or
go tool cover -func output.
`;
const pct1 = (n) => Math.round(n * 10) / 10;
const slash = (p) => p.replace(/\\/g, "/");
const isAbs = (p) => p.startsWith("/") || /^[A-Za-z]:\//.test(p);
/** A path made relative to root when it lies under it; anything else as given (relative paths with forward slashes). */
function relTo(root, file) {
const f = slash(file.trim());
if (!isAbs(f)) return f.replace(/^\.\//, "");
const r = slash(root).replace(/\/+$/, "");
const drive = /^[A-Za-z]:\//.test(f);
const under = drive ? f.toLowerCase().startsWith(`${r.toLowerCase()}/`) : f.startsWith(`${r}/`);
return under ? f.slice(r.length + 1) : file.trim();
}
function byPath(a, b) {
return a.file < b.file ? -1 : a.file > b.file ? 1 : 0;
}
/* ------------------------------------------------------------------ lcov */
function readLcov(text, root) {
if (!/^SF:/m.test(text)) return null;
const files = [];
let cur = null;
const close = () => {
if (!cur) return;
const lines = cur.lf ?? cur.da.length;
const hit = cur.lh ?? cur.da.filter((h) => h > 0).length;
files.push({ file: relTo(root, cur.sf), lines, hit, pct: lines ? pct1((hit / lines) * 100) : null });
cur = null;
};
for (const raw of text.split(/\r?\n/)) {
const line = raw.trim();
if (line.startsWith("SF:")) {
close();
cur = { sf: line.slice(3), da: [], lf: null, lh: null };
} else if (!cur) continue;
else if (line.startsWith("DA:")) {
const hits = Number(line.slice(3).split(",")[1]);
cur.da.push(Number.isFinite(hits) ? hits : 0);
} else if (line.startsWith("LF:")) cur.lf = Number(line.slice(3)) || 0;
else if (line.startsWith("LH:")) cur.lh = Number(line.slice(3)) || 0;
else if (line === "end_of_record") close();
}
close();
files.sort(byPath);
const lines = files.reduce((s, f) => s + f.lines, 0);
const hit = files.reduce((s, f) => s + f.hit, 0);
return { files, total: { lines, hit, pct: lines ? pct1((hit / lines) * 100) : null } };
}
/* --------------------------------------------------------------- go-func */
const GO_LINE = /^(.+\.go):\d+:\s+\S+\s+([\d.]+)%\s*$/;
const GO_TOTAL = /^total:\s+(?:\(statements\)\s+)?([\d.]+)%\s*$/;
function goModule(root) {
try {
const m = fs.readFileSync(path.join(root, "go.mod"), "utf8").match(/^\s*module\s+(\S+)/m);
return m ? m[1].replace(/^"|"$/g, "") : null;
} catch {
return null;
}
}
function readGoFunc(text, root) {
const lines = text.split(/\r?\n/).map((l) => l.trim());
if (!lines.some((l) => GO_LINE.test(l))) return null;
const mod = goModule(root);
const groups = new Map();
let total = null;
for (const line of lines) {
const t = line.match(GO_TOTAL);
if (t) {
total = { lines: null, hit: null, pct: pct1(Number(t[1])) };
continue;
}
const m = line.match(GO_LINE);
if (!m) continue;
let file = slash(m[1]);
if (mod && file.startsWith(`${mod}/`)) file = file.slice(mod.length + 1);
else file = relTo(root, m[1]);
(groups.get(file) || groups.set(file, []).get(file)).push(Number(m[2]));
}
const files = [...groups].map(([file, pcts]) => ({ file, lines: null, hit: null, pct: pct1(pcts.reduce((s, p) => s + p, 0) / pcts.length) }));
files.sort(byPath);
return { files, total };
}
/* ------------------------------------------------------------------ main */
run(USAGE, async (argv) => {
const args = parseArgs(argv, { values: ["lcov", "go-func", "root"] });
const [cmd, ...extra] = args._;
if (!cmd) fail(EXIT.USAGE, "missing-command", "A subcommand is required: read.", "Run with --help for usage.");
if (cmd !== "read") fail(EXIT.USAGE, "unknown-command", `Unknown subcommand "${cmd}".`, "Use: read.");
if (extra.length) fail(EXIT.USAGE, "stray-argument", `Unexpected argument(s): ${extra.join(" ")}.`, "Run with --help for usage.");
if (!args.lcov === !args["go-func"]) fail(EXIT.USAGE, "one-format", "Give exactly one of --lcov <file> or --go-func <file>.", "Run with --help for usage.");
const format = args.lcov ? "lcov" : "go-func";
const file = args.lcov || args["go-func"];
const rootArg = args.root || process.cwd();
const root = isAbs(slash(rootArg)) ? rootArg : path.resolve(rootArg);
let text;
try {
text = fs.readFileSync(file, "utf8");
} catch {
fail(EXIT.NOT_FOUND, "no-file", `Cannot read ${file}.`, "Run the coverage command first, then pass the file it wrote.");
}
const read = format === "lcov" ? readLcov(text, root) : readGoFunc(text, root);
if (!read) {
fail(
EXIT.INVALID,
"unreadable-format",
`${file} is not ${format === "lcov" ? "lcov output (no SF: lines)" : "go tool cover -func output (no .go: lines)"}.`,
"Check the coverage command's reporter writes lcov, or pass go tool cover -func output with --go-func."
);
}
out({ ok: true, format, ...read });
});