@nickmeriano/task 0.7.0 → 0.8.0

package/src/check.test.ts

@@ -0,0 +1,271 @@
+/**
+ * `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.number, "blocked_by", a.number)
+  store.addComment(a.number, "hello", "claude")
+  store.update(a.number, { status: "done" })
+  store.archive(a.number)
+
+  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("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" })
+  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.number, "blocked_by", a.number)
+  const ticketPath = (n: number) => join(root, ".task", "tickets", String(n), "ticket.md")
+  const bText = readFileSync(ticketPath(b.number), "utf8")
+  writeFileSync(ticketPath(b.number), bText.replace("blocked_by: [1]", "blocked_by: [1, 99, 99]"))
+
+  // A hand-edit that still parses but isn't canonical (bare goal string).
+  store.createGoal({ title: "Launch" })
+  const cText = readFileSync(ticketPath(3), "utf8")
+  writeFileSync(ticketPath(3), cText.replace("status: todo", "status: todo\ngoal: launch"))
+
+  // A file that doesn't parse at all.
+  mkdirSync(join(root, ".task", "tickets", "4"))
+  writeFileSync(ticketPath(4), "---\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-99, 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.match(readFileSync(ticketPath(b.number), "utf8"), /blocked_by: \[1\]\n/)
+  assert.match(readFileSync(ticketPath(3), "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.number, { status: "done" })
+  store.archive(t.number)
+  // The other branch kept editing it — the merge keeps both directories.
+  mkdirSync(join(root, ".task", "tickets", String(t.number)), { recursive: true })
+  writeFileSync(
+    join(root, ".task", "tickets", String(t.number), "ticket.md"),
+    readFileSync(join(root, ".task", "archive", String(t.number), "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", String(t.number)),
+    (mkdirSync(join(root, ".task", "archive"), { recursive: true }),
+    join(root, ".task", "archive", String(t.number))),
+  )
+  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", String(t.number), "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.number, { 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 flagged by name, and --fix is the migration", () => {
+  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", String(t.number), "ticket.md")
+  writeFileSync(
+    path,
+    readFileSync(path, "utf8").replace("status: todo", 'status: todo\nmilestone: "launch"'),
+  )
+
+  const found = checkBoards(root, false)
+  const migration = found.issues.find((issue) => /`milestone:` is now `goal:`/.test(issue.message))
+  assert.ok(migration?.fixable, "migration flagged as fixable")
+  // The old key parses as the goal, so the ref lint also fires until the goal
+  // file exists — stated with both ways out, never auto-pruned.
+  assert.ok(
+    found.issues.some((issue) => /goal "launch" doesn't exist/.test(issue.message) && !issue.fixable),
+  )
+
+  store.createGoal({ title: "Launch" })
+  checkBoards(root, true)
+  const text = readFileSync(path, "utf8")
+  assert.match(text, /goal: "launch"/)
+  assert.doesNotMatch(text, /milestone/)
+  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.number, "fine", "claude")
+  const dir = join(root, ".task", "tickets", String(t.number), "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: legacy claimPrefix migrates, 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`)
+
+  const found = checkBoards(root, false)
+  const messages = found.issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /`claimPrefix` is now `claims\.branchPrefix`/.test(m)))
+  assert.ok(messages.some((m) => /"boards" is root-only/.test(m)))
+  assert.ok(messages.some((m) => /disagrees with the root board's "claude\/task\/"/.test(m)))
+
+  // --fix migrates the legacy key in place; the human decisions remain.
+  const fixed = checkBoards(root, true)
+  assert.ok(fixed.fixed.includes(".task/config.json"))
+  const migrated = JSON.parse(readFileSync(rootConfig, "utf8")) as {
+    claimPrefix?: string
+    claims?: { branchPrefix?: string }
+    boards?: string[]
+    prefix: string
+  }
+  assert.equal(migrated.claimPrefix, undefined)
+  assert.equal(migrated.claims?.branchPrefix, "claude/task/")
+  assert.deepEqual(migrated.boards, ["CFG", "SUB"])
+  assert.equal(migrated.prefix, "CFG")
+
+  const remaining = checkBoards(root, false).issues.map((issue) => issue.message)
+  assert.ok(!remaining.some((m) => /`claimPrefix` is now/.test(m)), "nag gone after migration")
+  assert.ok(remaining.some((m) => /"boards" is root-only/.test(m)), "root-only lint stays")
+  assert.ok(remaining.some((m) => /disagrees with the root board's/.test(m)), "mismatch stays")
+})
+
+test("an existing claims.branchPrefix wins over the legacy key on migration", () => {
+  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`)
+
+  checkBoards(root, true)
+  const migrated = JSON.parse(readFileSync(configPath, "utf8")) as {
+    claimPrefix?: string
+    claims?: { branchPrefix?: string; maxOpenCount?: number }
+  }
+  assert.equal(migrated.claimPrefix, undefined)
+  assert.equal(migrated.claims?.branchPrefix, "new/ns/")
+  assert.equal(migrated.claims?.maxOpenCount, 2)
+})