code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research
ulw-research
UnverifiedRuns maximum-saturation research with a cooperating team, claim-graph gating, and a cited, QA'd deliverable. Use when the user explicitly asks for research or a deep investigation, including any 'ulw' research wording.
scripts/fact-ledger-kinds.test.ts
View on GitHubimport { describe, expect, test } from "bun:test"
import { spawnSync } from "node:child_process"
import { readFileSync } from "node:fs"
import { join } from "node:path"
import {
KIND_COLUMNS,
KIND_RULES as RULES_TABLE,
KIND_TABLE_BEGIN,
KIND_TABLE_END,
exactFromDecimal,
renderKindTable,
} from "./fact-ledger-kinds.mjs"
import { FACT_KINDS, LEDGER_SCHEMA_VERSION, ROW_DEFAULTS, validateLedger } from "./fact-ledger-schema.mjs"
// Property tests generated from KIND_RULES: for every kind, rows built from each column's rule
// validate, and breaking exactly one column's rule is rejected with an error naming that column.
/** mulberry32: a fixed seed gives the same rows on every run. */
function prng(seed: number) {
let state = seed >>> 0
return () => {
state = (state + 0x6d2b79f5) >>> 0
let t = state
t = Math.imul(t ^ (t >>> 15), t | 1)
t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
return ((t ^ (t >>> 14)) >>> 0) / 4294967296
}
}
const KIND_RULES = RULES_TABLE as Record<string, Record<string, string>>
type Random = () => number
const int = (random: Random, max: number) => Math.floor(random() * max)
const pick = <T>(random: Random, list: T[]): T => list[int(random, list.length)]
function decimal(random: Random) {
const whole = `${pick(random, ["-", ""])}${int(random, 5000)}`
return random() < 0.5
? whole
: `${whole}.${String(int(random, 1000))
.padStart(pick(random, [1, 2, 3]), "0")
.slice(0, 3)}`
}
const rational = (random: Random) => exactFromDecimal(decimal(random))
const locator = (random: Random) => ({
artifact: `sources/S${1 + int(random, 9)}/text.txt`,
char_start: 3,
char_end: 3 + int(random, 80),
})
const sha = (random: Random) => Array.from({ length: 64 }, () => "0123456789abcdef"[int(random, 16)]).join("")
type Row = Record<string, unknown> & { value: string }
type Gen = { valid: (random: Random, row: Row) => unknown; invalid: (random: Random, row: Row) => unknown }
/** One valid and one invalid generator per rule name; an unknown rule name fails the test below. */
const GENERATORS: Record<string, Gen> = {
f_id: { valid: (r) => `F${1 + int(r, 99)}`, invalid: (r) => `Q${1 + int(r, 99)}` },
q_id: { valid: (r) => `Q${1 + int(r, 99)}`, invalid: (r) => `F${1 + int(r, 99)}` },
decimal: { valid: decimal, invalid: (r) => pick(r, ["1e3", "", null, 12, "1,000"]) },
null: { valid: () => null, invalid: (r) => pick(r, ["0", { num: "1", den: "1" }, "S1", "why"]) },
source: { valid: (r) => `S${1 + int(r, 9)}`, invalid: (r) => pick(r, [null, "F1", "S"]) },
source_or_null: { valid: (r) => pick(r, [null, `S${1 + int(r, 9)}`]), invalid: (r) => pick(r, ["F1", "S", 3]) },
locator: {
valid: locator,
invalid: (r) =>
pick(r, [null, { artifact: "", char_start: 0, char_end: 1 }, { artifact: "a", char_start: 5, char_end: 1 }]),
},
locator_or_null: {
valid: (r) => pick(r, [null, locator(r)]),
invalid: (r) => pick(r, ["here", { artifact: "", char_start: 0, char_end: 1 }]),
},
sha256: { valid: sha, invalid: (r) => pick(r, [null, "abc", "A".repeat(64)]) },
sha256_or_null: { valid: (r) => pick(r, [null, sha(r)]), invalid: (r) => pick(r, ["abc", 7]) },
string_or_null: { valid: (r) => pick(r, [null, "", "a reason"]), invalid: (r) => pick(r, [5, false, {}]) },
non_empty: { valid: () => "assumed from the filing year", invalid: (r) => pick(r, ["", null]) },
from_value: {
valid: (_r, row) => exactFromDecimal(row.value),
invalid: (r, row) => {
const exact = exactFromDecimal(row.value)
return pick(r, [
null,
{ num: `${BigInt(exact.num) + 7n}`, den: exact.den },
{ num: `${BigInt(exact.num) * 2n}`, den: `${BigInt(exact.den) * 2n}` },
])
},
},
rational_or_null: {
valid: (r) => pick(r, [null, rational(r)]),
invalid: (r) => pick(r, [{ num: "1", den: "0" }, { num: 1, den: "2" }, "1/2"]),
},
by_derive: {
valid: rational,
invalid: (r) => pick(r, [null, { num: "1", den: "0" }, { num: "x", den: "2" }, "1/2"]),
},
context_by_derive: {
valid: (_r, row) => (row.kind === "converted" ? { target: "km" } : null),
invalid: (r) => pick(r, ["km", 3, ["km"], false]),
},
source_context: {
valid: (r) => pick(r, [null, { prefix: "source ", suffix: " text" }]),
invalid: (r) => pick(r, [{ target: "km" }, { prefix: "x".repeat(33), suffix: "" }, { prefix: "", suffix: 3 }]),
},
derived_operation: { valid: () => "expr", invalid: (r) => pick(r, [null, "convert", "mean"]) },
convert_operation: { valid: () => "convert", invalid: (r) => pick(r, [null, "sum", "mean"]) },
precision: {
valid: () => ({ places: 2, sigfigs: 3 }),
invalid: (r) => pick(r, [null, { places: -1, sigfigs: 3 }, { places: 2, sigfigs: 0 }]),
},
compatibility: { valid: (_r, row) => (row.operation === "expr" ? "unchecked" : "checked"), invalid: () => "invalid" },
}
function baseRow(kind: string): Row {
const row: Record<string, unknown> = {
...structuredClone(ROW_DEFAULTS),
kind,
raw: "raw",
quote: "quoted text",
extracted_by: "fact add",
observed_at: "2026-10-23T08:00:00Z",
label: "x",
}
if (kind === "derived" || kind === "converted")
Object.assign(row, { operands: ["F1000"], derived_from: ["F1000"], formula: "F1000", render: "raw" })
return row as Row
}
/** A row whose every KIND_COLUMNS field follows its kind's rule, in column order (exact after value). */
function validRow(kind: string, random: Random) {
const row = baseRow(kind)
for (const column of KIND_COLUMNS) row[column] = GENERATORS[KIND_RULES[kind][column]].valid(random, row)
return row
}
const ledgerOf = (row: object) => ({
schemaVersion: LEDGER_SCHEMA_VERSION,
rows: [row, { ...validRow("measured", prng(42)), fact_id: "F1000", label: "dependency" }],
events: [],
})
const SEEDS = Array.from({ length: 60 }, (_, index) => index + 1)
describe("KIND_RULES covers the grammar", () => {
test("every kind has a rule for every column, and every rule has a generator", () => {
expect(Object.keys(KIND_RULES)).toEqual([...FACT_KINDS])
for (const kind of FACT_KINDS) {
expect(Object.keys(KIND_RULES[kind])).toEqual([...KIND_COLUMNS])
for (const column of KIND_COLUMNS) expect(Object.hasOwn(GENERATORS, KIND_RULES[kind][column])).toBe(true)
}
})
})
describe("rows generated from KIND_RULES", () => {
for (const kind of FACT_KINDS) {
test(`${kind}: seeded valid rows validate`, () => {
for (const seed of SEEDS) {
const row = validRow(kind, prng(seed))
expect({ seed, errors: validateLedger(ledgerOf(row)) }).toEqual({ seed, errors: [] })
}
})
for (const column of KIND_COLUMNS) {
test(`${kind}: breaking only the ${column} rule (${KIND_RULES[kind][column]}) is rejected`, () => {
for (const seed of SEEDS) {
const random = prng(seed * 7919)
const row = validRow(kind, random)
row[column] = GENERATORS[KIND_RULES[kind][column]].invalid(random, row)
const errors = validateLedger(ledgerOf(row))
expect({
seed,
value: row[column],
named: errors.some((error: string) => error.startsWith(`rows[0].${column}`)),
}).toEqual({ seed, value: row[column], named: true })
}
})
}
}
test("review MEDIUM: a measured row with value -0.50 and exact 7/1 is rejected", () => {
const row = { ...validRow("measured", prng(1)), value: "-0.50", exact: { num: "7", den: "1" } }
expect(validateLedger(ledgerOf(row)).some((error: string) => error.startsWith("rows[0].exact"))).toBe(true)
expect(validateLedger(ledgerOf({ ...row, exact: { num: "-1", den: "2" } }))).toEqual([])
})
test("source context rejects derivation fields, and assumed rows still require null context", () => {
for (const kind of ["measured", "quote", "assumed"]) {
const row = { ...validRow(kind, prng(3)), context: { target: "km" } }
expect({
kind,
named: validateLedger(ledgerOf(row)).some((error: string) => error.startsWith("rows[0].context")),
}).toEqual({ kind, named: true })
}
expect(validateLedger(ledgerOf(validRow("converted", prng(4))))).toEqual([])
expect(
validateLedger(ledgerOf({ ...validRow("derived", prng(4)), context: { target: "km" } })).length,
).toBeGreaterThan(0)
})
test("review LOW 1: a quote row with a non-null exact is rejected", () => {
const row = { ...validRow("quote", prng(2)), exact: { num: "1", den: "1" } }
expect(validateLedger(ledgerOf(row)).some((error: string) => error.startsWith("rows[0].exact"))).toBe(true)
})
})
describe("the grammar's per-kind table is rendered from KIND_RULES", () => {
const grammar = readFileSync(join(import.meta.dir, "..", "references", "fact-ledger-grammar.md"), "utf8")
test("the committed table section equals renderKindTable() byte for byte", () => {
const begin = grammar.indexOf(KIND_TABLE_BEGIN)
const end = grammar.indexOf(KIND_TABLE_END)
expect(begin).toBeGreaterThanOrEqual(0)
expect(end).toBeGreaterThan(begin)
expect(grammar.slice(begin + KIND_TABLE_BEGIN.length + 1, end)).toBe(renderKindTable())
})
test("node fact-ledger-kinds.mjs --render-grammar prints the same table", () => {
const result = spawnSync("node", [join(import.meta.dir, "fact-ledger-kinds.mjs"), "--render-grammar"], {
encoding: "utf8",
})
expect(result.status).toBe(0)
expect(result.stdout).toBe(renderKindTable())
})
})
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: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | 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: 198k | Updated | Claude CodeCodex | Verified | Install |