@nickmeriano/task 0.7.1 → 0.9.0

package/src/check.test.ts

@@ -0,0 +1,328 @@
+/**
+ * `task check` exists for the write paths the CLI never sees — git merges and
+ * hand-edits — so its tests are those: files written slightly wrong, links
+ * whose target one branch deleted, tickets a merge duplicated into the board
+ * *and* the archive. Plus the sharp edge fixed alongside it: unknown
+ * frontmatter keys now survive a rewrite instead of being dropped.
+ */
+
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { checkBoards } from "./check.ts"
+import { initProject } from "./file-store.ts"
+import { parseTicket, serializeTicket } from "./ticket-doc.ts"
+
+function tempRoot(): string {
+  const dir = mkdtempSync(join(tmpdir(), "task-check-"))
+  process.on("exit", () => rmSync(dir, { recursive: true, force: true }))
+  return dir
+}
+
+test("a board the CLI wrote is clean", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "clean", prefix: "CLN" })
+  store.createGoal({ title: "Ship it", description: "the why" })
+  const a = store.create({ title: "First", description: "with a body", goal: "ship-it" })
+  const b = store.create({ title: "Second", status: "backlog", tags: ["x"] })
+  store.link(b.key, "blocked_by", a.key)
+  store.addComment(a.key, "hello", "claude")
+  store.update(a.key, { status: "done" })
+  store.archive(a.key)
+
+  const result = checkBoards(root, false)
+  assert.deepEqual(result.issues, [])
+  assert.equal(result.boards, 1)
+  assert.equal(result.files, 4) // two tickets + one comment + one goal
+})
+
+test("ask files are linted like comments; the retired flag reads as an unknown key", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "owed", prefix: "OWE" })
+  const t = store.create({ title: "Owes things", status: "in_progress" })
+  store.addAsk(t.key, "Mint the token", "claude")
+  assert.deepEqual(checkBoards(root, false).issues, [], "a CLI-written ask is clean")
+
+  const asksDir = join(root, ".task", "tickets", t.key, "asks")
+  // Hand-edit shapes: an ask that says nothing, a resolution that isn't a
+  // timestamp, a key nothing reads, and mere drift (unquoted author).
+  writeFileSync(join(asksDir, "z-empty.md"), '---\nauthor: "x"\ncreated: 2026-08-27T00:00:00.000Z\n---\n\n\n')
+  writeFileSync(
+    join(asksDir, "z-bad.md"),
+    '---\nauthor: "x"\ncreated: 2026-08-27T00:00:00.000Z\nresolved: yesterday-ish\nurgency: high\n---\n\nDo the thing\n',
+  )
+  const found = checkBoards(root, false)
+  const messages = found.issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /empty ask/.test(m)), "empty ask reported")
+  assert.ok(messages.some((m) => /resolved is not a valid timestamp/.test(m)), "bad resolution reported")
+  assert.ok(messages.some((m) => /unknown frontmatter key "urgency"/.test(m)), "unknown key reported")
+
+  // The retired pre-0.8 boolean isn't a field anymore — a file still carrying
+  // it (deep history, an ancient branch) reads as an unknown key: flagged,
+  // preserved through rewrites, never interpreted.
+  const ticketPath = join(root, ".task", "tickets", t.key, "ticket.md")
+  writeFileSync(
+    ticketPath,
+    readFileSync(ticketPath, "utf8").replace("status: in_progress", "status: in_progress\nneeds_human: true"),
+  )
+  const flagged = checkBoards(root, true)
+  const unknown = flagged.issues.find((issue) => /unknown frontmatter key "needs_human"/.test(issue.message))
+  assert.ok(unknown, "retired key flagged as unknown")
+  assert.match(readFileSync(ticketPath, "utf8"), /needs_human: true/)
+})
+
+test("finds what merges and hand-edits leave behind, and --fix repairs the mechanical part", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "rough", prefix: "RGH" })
+  const a = store.create({ title: "Kept", status: "todo" })
+  const b = store.create({ title: "Points at a ghost", status: "todo" })
+  const c = store.create({ title: "Broken later", status: "todo" })
+
+  // A dangling reference: link b to a ticket, then lose the ticket the way a
+  // merge would — the directory vanishes without the store's delete cascade.
+  store.link(b.key, "blocked_by", a.key)
+  const ticketPath = (key: string) => join(root, ".task", "tickets", key, "ticket.md")
+  const bText = readFileSync(ticketPath(b.key), "utf8")
+  writeFileSync(
+    ticketPath(b.key),
+    bText.replace(`blocked_by: ["${a.key}"]`, `blocked_by: ["${a.key}", "zz9zz", "zz9zz"]`),
+  )
+
+  // A hand-edit that still parses but isn't canonical (bare goal string).
+  store.createGoal({ title: "Launch" })
+  const cText = readFileSync(ticketPath(c.key), "utf8")
+  writeFileSync(ticketPath(c.key), cText.replace("status: todo", "status: todo\ngoal: launch"))
+
+  // A file that doesn't parse at all, in a well-formed key directory.
+  mkdirSync(join(root, ".task", "tickets", "zzz9x"))
+  writeFileSync(ticketPath("zzz9x"), "---\nstatus: todoo\nposition: 0\ncreated: x\nupdated: x\n---\n\n# Bad status\n")
+
+  const found = checkBoards(root, false)
+  const messages = found.issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /RGH-zz9zz, which doesn't exist/.test(m)), "dangling ref reported")
+  assert.ok(messages.some((m) => /not in canonical form/.test(m)), "drift reported")
+  assert.ok(messages.some((m) => /invalid status "todoo"/.test(m)), "parse error reported")
+  assert.ok(messages.some((m) => /not a valid timestamp/.test(m)) === false, "unparseable file isn't double-reported")
+
+  const fixed = checkBoards(root, true)
+  assert.ok(fixed.fixed.length >= 2, "fix rewrote the repairable files")
+  // The dangling ref is pruned, the real one kept; the drift is normalized.
+  assert.ok(readFileSync(ticketPath(b.key), "utf8").includes(`blocked_by: ["${a.key}"]\n`))
+  assert.match(readFileSync(ticketPath(c.key), "utf8"), /goal: "launch"/)
+
+  // What remains is exactly what needs a human: the unparseable file.
+  const after = checkBoards(root, false)
+  assert.deepEqual(
+    after.issues.filter((issue) => issue.fixable),
+    [],
+  )
+  assert.equal(after.issues.length, 1)
+  assert.match(after.issues[0].message, /invalid status/)
+})
+
+test("merge artifacts across the archive are reported, never auto-fixed", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "dup", prefix: "DUP" })
+  const t = store.create({ title: "Archived on one branch" })
+  store.update(t.key, { status: "done" })
+  store.archive(t.key)
+  // The other branch kept editing it — the merge keeps both directories.
+  mkdirSync(join(root, ".task", "tickets", t.key), { recursive: true })
+  writeFileSync(
+    join(root, ".task", "tickets", t.key, "ticket.md"),
+    readFileSync(join(root, ".task", "archive", t.key, "ticket.md")),
+  )
+
+  const result = checkBoards(root, true)
+  assert.ok(result.issues.some((issue) => /also exists in tickets\//.test(issue.message)))
+  assert.deepEqual(result.fixed, [])
+})
+
+test("a ticket parked in the archive while still open is flagged", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "arc", prefix: "ARC" })
+  const t = store.create({ title: "Half archived", status: "todo" })
+  renameSync(
+    join(root, ".task", "tickets", t.key),
+    (mkdirSync(join(root, ".task", "archive"), { recursive: true }),
+    join(root, ".task", "archive", t.key)),
+  )
+  const result = checkBoards(root, false)
+  assert.ok(result.issues.some((issue) => /archived but still todo/.test(issue.message)))
+})
+
+test("unknown frontmatter keys are reported — and survive a rewrite round-trip", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "extra", prefix: "EXT" })
+  const t = store.create({ title: "Carries a custom field", status: "todo" })
+  const path = join(root, ".task", "tickets", t.key, "ticket.md")
+  writeFileSync(
+    path,
+    readFileSync(path, "utf8").replace("status: todo", 'status: todo\nowner: "nick"'),
+  )
+
+  const result = checkBoards(root, false)
+  assert.ok(result.issues.some((issue) => /unknown frontmatter key "owner"/.test(issue.message)))
+
+  // The sharp edge this fixed: an ordinary update used to drop the key.
+  store.update(t.key, { title: "Renamed" })
+  const text = readFileSync(path, "utf8")
+  assert.match(text, /owner: "nick"/)
+  assert.match(text, /# Renamed/)
+  // And the parse carries it explicitly.
+  assert.deepEqual(parseTicket(text, "test").extras, [["owner", '"nick"']])
+  // Round-trip is bytes-stable, so check won't flag the rewritten file.
+  assert.equal(serializeTicket(parseTicket(text, "test")), text)
+  assert.deepEqual(checkBoards(root, false).issues.map((issue) => issue.message), [
+    'unknown frontmatter key "owner" — preserved on rewrite, but nothing reads it',
+  ])
+})
+
+test("the pre-0.8 milestone key is refused by name — no migration machinery", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "old", prefix: "OLD" })
+  const t = store.create({ title: "From an old board", status: "todo" })
+  const path = join(root, ".task", "tickets", t.key, "ticket.md")
+  writeFileSync(
+    path,
+    readFileSync(path, "utf8").replace("status: todo", 'status: todo\nmilestone: "launch"'),
+  )
+
+  // The strict parse refuses the retired spelling with the rename in the
+  // error; check surfaces exactly that, unfixable, and --fix leaves the file
+  // alone — renaming the key is the human's one edit.
+  const found = checkBoards(root, true)
+  const refusal = found.issues.find((issue) =>
+    /`milestone:` is the pre-0\.8 spelling.*rename the key to `goal:`/.test(issue.message),
+  )
+  assert.ok(refusal, "retired spelling refused by name")
+  assert.equal(refusal.fixable, false)
+  assert.match(readFileSync(path, "utf8"), /milestone: "launch"/)
+
+  writeFileSync(path, readFileSync(path, "utf8").replace('milestone: "launch"', 'goal: "launch"'))
+  store.createGoal({ title: "Launch" })
+  checkBoards(root, true)
+  assert.deepEqual(checkBoards(root, false).issues, [])
+})
+
+test("goal files are linted, and drift in them is fixable", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "gol", prefix: "GOL" })
+  store.createGoal({ title: "Tidy", description: "fine" })
+  // A hand-dropped goal: parseable, bad timestamp, non-canonical spacing, and
+  // a slug the CLI would never mint.
+  writeFileSync(
+    join(root, ".task", "goals", "Bad Slug.md"),
+    "---\ncreated: not-a-date\nupdated: 2026-08-15T17:00:00.000Z\n---\n# Handmade\n\nbody\n",
+  )
+
+  const result = checkBoards(root, false)
+  const messages = result.issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /not a valid goal slug/.test(m)))
+  assert.ok(messages.some((m) => /created is not a valid timestamp/.test(m)))
+  assert.ok(result.issues.some((issue) => issue.fixable), "spacing drift is fixable")
+
+  checkBoards(root, true)
+  assert.match(
+    readFileSync(join(root, ".task", "goals", "Bad Slug.md"), "utf8"),
+    /---\n\n# Handmade/,
+  )
+})
+
+test("comment files are linted too", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "com", prefix: "COM" })
+  const t = store.create({ title: "Talked about" })
+  store.addComment(t.key, "fine", "claude")
+  const dir = join(root, ".task", "tickets", t.key, "comments")
+  // A hand-dropped comment: parseable, wrong created, non-canonical spacing.
+  writeFileSync(join(dir, "2026-08-15T170000-other.md"), '---\nauthor: "other"\ncreated: not-a-date\n---\nbody\n')
+
+  const result = checkBoards(root, false)
+  assert.ok(result.issues.some((issue) => /created is not a valid timestamp/.test(issue.message)))
+})
+
+test("config lints: retired claimPrefix refuses, boards is root-only, prefixes must agree", () => {
+  const root = tempRoot()
+  initProject(root, { name: "cfg", prefix: "CFG" })
+  const rootConfig = join(root, ".task", "config.json")
+  const raw = JSON.parse(readFileSync(rootConfig, "utf8")) as Record<string, unknown>
+  raw.claimPrefix = "claude/task/"
+  raw.boards = ["CFG", "SUB"]
+  writeFileSync(rootConfig, `${JSON.stringify(raw, null, 2)}\n`)
+
+  // A nested board that disagrees on the namespace and carries its own
+  // boards list — both are repo-level decisions the root board owns.
+  mkdirSync(join(root, "pkg"), { recursive: true })
+  initProject(join(root, "pkg"), { name: "sub", prefix: "SUB" })
+  const subConfig = join(root, "pkg", ".task", "config.json")
+  const subRaw = JSON.parse(readFileSync(subConfig, "utf8")) as Record<string, unknown>
+  subRaw.boards = ["SUB"]
+  subRaw.claims = { branchPrefix: "task/claim/" }
+  writeFileSync(subConfig, `${JSON.stringify(subRaw, null, 2)}\n`)
+
+  // The retired key with no claims.branchPrefix beside it: claimNamespace
+  // refuses by name, check surfaces that refusal, and --fix touches nothing —
+  // renaming the key is the human's one edit. The root's namespace being
+  // unreadable also means the sub-board mismatch lint has no reference to
+  // compare against; the root-only boards lint still fires.
+  const found = checkBoards(root, true)
+  const messages = found.issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /`claimPrefix` in \.task\/config\.json is the pre-0\.8 spelling/.test(m)))
+  assert.ok(messages.some((m) => /"boards" is root-only/.test(m)))
+  assert.ok(found.issues.every((issue) => !issue.fixable || !/claimPrefix/.test(issue.message)))
+  const untouched = JSON.parse(readFileSync(rootConfig, "utf8")) as { claimPrefix?: string }
+  assert.equal(untouched.claimPrefix, "claude/task/")
+})
+
+test("a stray claimPrefix beside claims.branchPrefix is inert and flagged", () => {
+  const root = tempRoot()
+  initProject(root, { name: "dup", prefix: "DUP" })
+  const configPath = join(root, ".task", "config.json")
+  const raw = JSON.parse(readFileSync(configPath, "utf8")) as Record<string, unknown>
+  raw.claimPrefix = "old/ns/"
+  raw.claims = { branchPrefix: "new/ns/", maxOpenCount: 2 }
+  writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`)
+
+  const messages = checkBoards(root, false).issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /`claims\.branchPrefix` wins; delete the leftover key/.test(m)))
+})
+
+test("numeric ticket dirs are called out as pre-TAS-42 — junk entries separately", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "mig", prefix: "MIG" })
+  store.create({ title: "A modern ticket", status: "todo" })
+
+  // A pre-migration ticket, imported by merging a branch cut before the id
+  // cutover: numeric directory, numeric blocked_by.
+  mkdirSync(join(root, ".task", "tickets", "42"), { recursive: true })
+  writeFileSync(
+    join(root, ".task", "tickets", "42", "ticket.md"),
+    "---\nstatus: todo\nposition: 0\ncreated: 2026-08-15T16:00:33.758Z\nupdated: 2026-08-15T16:00:33.758Z\n---\n\n# Old-format ticket\n",
+  )
+  // And something that was never a ticket directory at all.
+  mkdirSync(join(root, ".task", "tickets", "Not A Key"), { recursive: true })
+
+  const messages = checkBoards(root, false).issues.map((issue) => issue.message)
+  assert.ok(
+    messages.some((m) => /numeric ticket directory — the pre-TAS-42 sequential-id format/.test(m)),
+    "pre-migration dir named with the migration fix",
+  )
+  assert.ok(
+    messages.some((m) => /ticket directories are named by their key/.test(m)),
+    "junk entry reported as unexpected",
+  )
+
+  // A modern file whose blocked_by still carries numbers is refused by the
+  // strict parser with the migration named — surfaced through check.
+  const modern = store.create({ title: "Bad link format", status: "todo" })
+  const path = join(root, ".task", "tickets", modern.key, "ticket.md")
+  writeFileSync(
+    path,
+    readFileSync(path, "utf8").replace("status: todo", "status: todo\nblocked_by: [7]"),
+  )
+  const after = checkBoards(root, false).issues.map((issue) => issue.message)
+  assert.ok(after.some((m) => /pre-TAS-42 id format, which is no longer read/.test(m)))
+})