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/format-extract.test.ts
View on GitHubimport { afterAll, beforeAll, describe, expect, test } from "bun:test"
import { readFileSync } from "node:fs"
import { createServer, type Server } from "node:http"
import type { AddressInfo } from "node:net"
import { once } from "node:events"
import { join } from "node:path"
import { DESIGN_SPEC_SECTIONS } from "./contracts.mjs"
import { renderDesignSpec } from "./design-spec.mjs"
import {
UnsupportedFormatError,
extractFromHtml,
extractFromMarkdown,
extractFromPath,
fetchHtml,
} from "./format-extract.mjs"
const FIXTURES = join(import.meta.dir, "tests", "fixtures")
const HTML_PATH = join(FIXTURES, "reference-report.html")
const MD_PATH = join(FIXTURES, "reference.md")
const html = readFileSync(HTML_PATH, "utf8")
const markdown = readFileSync(MD_PATH, "utf8")
const UNSUPPORTED = "unsupported: point at the HTML or Markdown source"
function sectionBody(spec: string, heading: string): string {
const start = spec.indexOf(`## ${heading}\n`)
const rest = spec.slice(start + heading.length + 4)
const next = rest.search(/^## /m)
return next === -1 ? rest : rest.slice(0, next)
}
function bulletLines(body: string): string[] {
return body.split("\n").filter((line) => line.startsWith("- "))
}
describe("extractFromHtml on the reference report", () => {
const extract = extractFromHtml(html, { origin: HTML_PATH })
test("#given light and dark token blocks #when extracted #then both maps carry at least 8 tokens", () => {
expect(extract.tokens.light.size).toBeGreaterThanOrEqual(8)
expect(extract.tokens.dark.size).toBeGreaterThanOrEqual(8)
expect(extract.tokens.light.get("--bg")).toBe("#faf6ef")
expect(extract.tokens.dark.get("--accent")).toBe("#f8b878")
})
test("#given body, heading, and code font rules #when extracted #then the three stacks resolve through var()", () => {
expect(extract.fonts).toEqual({
body: '"Inter Display", "Noto Sans KR", sans-serif',
heading: "Fraunces, Georgia, serif",
mono: '"Iosevka Term", ui-monospace, monospace',
})
})
test("#given two min-width media queries #when extracted #then breakpoints are [560, 640]", () => {
expect(extract.breakpoints).toEqual([560, 640])
})
test("#given 01-style h2 numbering and [S1] markers #when extracted #then numbering, citation, and lineage are detected", () => {
expect(extract.headingNumbering).toBe("double-digit")
expect(extract.citationStyle).toBe("bracket-S")
expect(extract.lineageMode).toBe("inline")
})
test("#given img and svg inside .fig containers #when extracted #then figureContainers contains fig", () => {
expect(extract.figureContainers).toContain("fig")
})
test("#given the fixture headings #when extracted #then the skeleton has one entry per h1 and h2", () => {
const count = (html.match(/<h[12][\s>]/g) ?? []).length
expect(extract.skeleton).toHaveLength(count)
expect(extract.skeleton[0]).toEqual({ level: 1, text: "How a small team ships every week" })
expect(extract.skeleton[1]).toEqual({ level: 2, text: "01 The release cadence" })
})
test("#given body size, line height, and a measure token #when extracted #then measure is resolved", () => {
expect(extract.measure).toEqual({ fontSize: "17px", lineHeight: "1.7", maxWidth: "720px" })
})
test("#given repeated hex colors #when extracted #then at most 8 colors are ranked by count with selector roles", () => {
expect(extract.colors.length).toBeLessThanOrEqual(8)
const counts = extract.colors.map((color: { count: number }) => color.count)
expect(counts).toEqual([...counts].sort((a, b) => b - a))
const accent = extract.colors.find((color: { hex: string }) => color.hex === "#c2410c")
expect(accent?.roles).toEqual(expect.arrayContaining(["accent", "link"]))
const background = extract.colors.find((color: { hex: string }) => color.hex === "#faf6ef")
expect(background?.roles).toContain("background")
})
test("#given the source #when extracted #then origin and utf-8 byte count are recorded", () => {
expect(extract.origin).toBe(HTML_PATH)
expect(extract.bytes).toBe(Buffer.byteLength(html, "utf8"))
})
test("#given the extract #when rendered #then the 8 design-spec sections appear in contract order", () => {
const spec = renderDesignSpec(extract)
const positions = DESIGN_SPEC_SECTIONS.map((heading: string) => spec.indexOf(`\n## ${heading}\n`))
expect(positions.every((at: number) => at > 0)).toBe(true)
expect(positions).toEqual([...positions].sort((a, b) => a - b))
expect(sectionBody(spec, "Tokens")).toContain("--bg: #faf6ef;")
expect(sectionBody(spec, "Tokens")).not.toContain("TODO: ask")
})
})
describe("extractFromMarkdown on the reference markdown", () => {
const extract = extractFromMarkdown(markdown, { origin: MD_PATH })
test("#given h1, h2, h3, and a fenced pseudo-heading #when extracted #then the skeleton keeps h1 and h2 outside fences", () => {
expect(extract.skeleton).toEqual([
{ level: 1, text: "작은 팀은 어떻게 매주 배포하는가" },
{ level: 2, text: "01 배포 주기" },
{ level: 2, text: "02 리뷰 없이 일하는 방식" },
{ level: 2, text: "03 출처" },
])
})
test("#given [S1] markers and 01-style headings #when extracted #then citation style and numbering are detected", () => {
expect(extract.citationStyle).toBe("bracket-S")
expect(extract.headingNumbering).toBe("double-digit")
})
test("#given markdown input #when rendered #then every CSS-derived line reads TODO: ask", () => {
const spec = renderDesignSpec(extract)
for (const heading of ["Tokens", "Typography", "Layout"]) {
const lines = bulletLines(sectionBody(spec, heading))
expect(lines.length).toBeGreaterThan(0)
for (const line of lines) expect(line).toEndWith("TODO: ask")
}
expect(sectionBody(spec, "Figures")).toContain("- Containers: TODO: ask")
expect(extract.tokens.light.size + extract.tokens.dark.size).toBe(0)
})
})
describe("unsupported inputs", () => {
test("#given a .pdf path #when extracted from the path #then the typed unsupported error is thrown", () => {
const attempt = () => extractFromPath(join(FIXTURES, "reference.pdf"))
expect(attempt).toThrow(UnsupportedFormatError)
expect(attempt).toThrow(UNSUPPORTED)
})
test("#given PDF bytes passed as HTML #when extracted #then the typed unsupported error is thrown", () => {
expect(() => extractFromHtml("%PDF-1.7\n1 0 obj", { origin: "report" })).toThrow(UnsupportedFormatError)
})
test("#given an html path #when extracted from the path #then it dispatches to the HTML extractor", () => {
const extract = extractFromPath(HTML_PATH)
expect(extract.origin).toBe(HTML_PATH)
expect(extract.breakpoints).toEqual([560, 640])
})
})
describe("extractFromHtml edge cases", () => {
test("#given only external stylesheets #when rendered #then Tokens reads TODO: ask and a note names the skipped href", () => {
const source =
'<html><head><link rel="stylesheet" href="css/site.css"></head><body><h1>Only links</h1></body></html>'
const extract = extractFromHtml(source, { origin: "external.html" })
const spec = renderDesignSpec(extract)
const tokens = bulletLines(sectionBody(spec, "Tokens"))
expect(tokens.length).toBeGreaterThan(0)
for (const line of tokens) expect(line).toEndWith("TODO: ask")
expect(extract.notes.some((note: string) => note.includes("css/site.css"))).toBe(true)
expect(sectionBody(spec, "Extracted from")).toContain("css/site.css")
})
test("#given a numeric eyebrow sibling before each h2 #when extracted #then numbering is double-digit", () => {
const source =
'<body><h1>T</h1><div><span class="sec-no">01</span><h2>First</h2></div><div><span class="sec-no">02</span><h2>Second</h2></div></body>'
expect(extractFromHtml(source, { origin: "x.html" }).headingNumbering).toBe("double-digit")
})
test("#given decimal, bare, and absent h2 headings #when extracted #then numbering is decimal, none, and unknown", () => {
const numbering = (body: string) => extractFromHtml(`<body>${body}</body>`, { origin: "x.html" }).headingNumbering
expect(numbering("<h2>1. Intro</h2><h2>2. Method</h2>")).toBe("decimal")
expect(numbering("<h2>Intro</h2><h2>Method</h2>")).toBe("none")
expect(numbering("<h1>Only a title</h1>")).toBe("unknown")
})
test("#given [출처] anchors and no lineage tokens #when extracted #then citation is bracket-source and lineage is section", () => {
const source =
'<body><h2>A</h2><p>Fact one. <a class="src" href="https://example.org/a">[출처]</a></p><p>Fact two <a href="https://example.org/b">[Source 2]</a></p></body>'
const extract = extractFromHtml(source, { origin: "x.html" })
expect(extract.citationStyle).toBe("bracket-source")
expect(extract.lineageMode).toBe("section")
})
test("#given a MEASURED token with source anchors #when extracted #then lineage is inline", () => {
const source = '<body><p>Latency 42 ms MEASURED <a href="https://example.org/a">[출처]</a></p></body>'
expect(extractFromHtml(source, { origin: "x.html" }).lineageMode).toBe("inline")
})
test("#given sup footnote references #when extracted #then citation style is footnote", () => {
const source = '<body><p>Claim<sup><a href="#fn1">1</a></sup></p><ol><li id="fn1">Note</li></ol></body>'
expect(extractFromHtml(source, { origin: "x.html" }).citationStyle).toBe("footnote")
})
test("#given no citations, fonts, or headings #when rendered #then unknown fields read TODO: ask", () => {
const extract = extractFromHtml("<body><p>Plain text only.</p></body>", { origin: "x.html" })
expect(extract.citationStyle).toBe("unknown")
expect(extract.lineageMode).toBe("unknown")
expect(extract.fonts).toEqual({})
const spec = renderDesignSpec(extract)
expect(sectionBody(spec, "Citations")).toContain("- Style: TODO: ask")
expect(sectionBody(spec, "Citations")).toContain("- Lineage: TODO: ask")
expect(sectionBody(spec, "Typography")).toContain("- Heading font: TODO: ask")
})
})
describe("fetchHtml", () => {
let server: Server
let base = ""
beforeAll(async () => {
server = createServer((request, response) => {
if (request.url === "/report.html") {
response.writeHead(200, { "content-type": "text/html; charset=utf-8" })
response.end(html)
} else if (request.url === "/paper") {
response.writeHead(200, { "content-type": "application/pdf" })
response.end("%PDF-1.7")
} else {
response.writeHead(404, { "content-type": "text/plain" })
response.end("missing")
}
})
server.listen(0, "127.0.0.1")
await once(server, "listening")
base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`
})
afterAll(async () => {
server.close()
server.closeAllConnections()
await once(server, "close")
})
test("#given an html url #when fetched #then the body text is returned", async () => {
expect(await fetchHtml(`${base}/report.html`)).toBe(html)
})
test("#given a pdf response #when fetched #then the typed unsupported error is thrown", async () => {
await expect(fetchHtml(`${base}/paper`)).rejects.toThrow(UnsupportedFormatError)
})
test("#given a 404 response #when fetched #then the error names the status", async () => {
await expect(fetchHtml(`${base}/missing`)).rejects.toThrow("404")
})
})
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 |