@pmelab/gtd 64.1.1 → 64.2.0

package/src/steering/freeform.test.ts

@@ -234,7 +234,7 @@ describe("freeFormFormat.annotate", () => {
     const attach = (content: string, text: string): string => {
       const r = freeFormFormat.annotate(content, anchor, text)
       if (!r.ok) throw new Error("refused")
-      return applyEdits(content, r.edits)
+      return applyEditsExact(content, r.edits)
     }
     const created = attach("Paragraph one.\n", "first")
     expect(created).toMatch(/\[\^na\w+\]:\n    - H: first\n/)
@@ -309,3 +309,53 @@ describe("freeFormFormat — thread outline", () => {
     ])
   })
 })
+
+describe("freeFormFormat — task tick", () => {
+  const tick = (content: string, line: number): string => {
+    const r = freeFormFormat.apply(content, { kind: "paragraph", line }, { checked: true })
+    if (!r.ok) throw new Error(r.reason)
+    return applyEditsExact(content, r.edits)
+  }
+
+  it("ticks one box, leaving every other line byte-identical", () => {
+    const doc = "Tick exactly one event:\n\n- [ ] APPROVE\n- [ ] REJECT\n- [ ] CANCEL\n"
+    expect(tick(doc, 2)).toBe(doc.replace("- [ ] APPROVE", "- [x] APPROVE"))
+  })
+
+  it("moves the pick within one list only, leaving nested and other lists alone", () => {
+    const doc = "- [x] a\n  - [x] n1\n  - [ ] n2\n- [ ] b\n\n1. [x] other\n2. [ ] other2\n"
+    expect(tick(doc, 2)).toBe(
+      "- [x] a\n  - [ ] n1\n  - [x] n2\n- [ ] b\n\n1. [x] other\n2. [ ] other2\n",
+    )
+    expect(tick(doc, 3)).toBe(
+      "- [ ] a\n  - [x] n1\n  - [ ] n2\n- [x] b\n\n1. [x] other\n2. [ ] other2\n",
+    )
+  })
+
+  it("ticks a box that sits on the line after a bare marker", () => {
+    const doc = "-\n  [ ] a\n-\n  [x] b\n"
+    expect(tick(doc, 0)).toBe("-\n  [x] a\n-\n  [ ] b\n")
+  })
+
+  it("ticks an ordered item and keeps CRLF; a ticked box is a no-op; a fenced box refuses", () => {
+    expect(tick("1. [ ] a\r\n2. [ ] b\r\n", 1)).toBe("1. [ ] a\r\n2. [x] b\r\n")
+    const done = "- [x] a\n- [ ] b\n"
+    expect(tick(done, 0)).toBe(done)
+    expect(
+      freeFormFormat.apply("```\n- [ ] a\n```\n", { kind: "paragraph", line: 1 }, { checked: true })
+        .ok,
+    ).toBe(false)
+  })
+
+  it("refuses to clear a box, whatever the anchor, and a tick round-trips byte-exact", () => {
+    const doc = "- [x] a\n- [ ] b\n"
+    expect(freeFormFormat.apply(doc, { kind: "paragraph", line: 0 }, { checked: false })).toEqual({
+      ok: false,
+      reason: "pick-never-clears",
+    })
+    const moved = tick(doc, 1)
+    expect(moved).toBe("- [ ] a\n- [x] b\n")
+    const back = freeFormFormat.apply(moved, { kind: "paragraph", line: 0 }, { checked: true })
+    expect(back.ok && applyEditsExact(moved, back.edits)).toBe(doc)
+  })
+})

package/src/steering/freeform.ts

@@ -1,3 +1,4 @@
+import type { ListItem } from "mdast"
 import { blockNodesOf } from "./Blocks.js"
 import { eolOf } from "./Eol.js"
 import {
@@ -93,6 +94,41 @@ const appendEdit = (content: string, text: string): SteeringEdit => {
   return wholeDocumentEdit(content, newText)
 }
 
+/** Every task-list item with its sibling task items (direct children of one list only). */
+const taskGroups = (node: unknown, out: ListItem[][]): void => {
+  const n = node as { type?: string; children?: unknown[] }
+  if (n.type === "list") {
+    out.push((n.children as ListItem[]).filter((i) => i.checked === true || i.checked === false))
+  }
+  for (const c of n.children ?? []) taskGroups(c, out)
+}
+
+/** The box sits on the first child's line, which is not the marker line when a bare `-` precedes it. */
+const boxEdit = (lines: string[], item: ListItem, newText: string): SteeringEdit | undefined => {
+  const line = toLspPosition((item.children[0]?.position ?? item.position!).start).line
+  const m = /\[( |x|X)\]/.exec(lines[line] ?? "")
+  if (!m) return undefined
+  const c = m.index + 1
+  return { range: { start: { line, character: c }, end: { line, character: c + 1 } }, newText }
+}
+
+/** Pick-one tick: sets the box on `line` and unticks its ticked siblings, in one edit set. Ticking an already-ticked box is an empty edit set. */
+const tickEdits = (content: string, line: number): SteeringAnnotateResult => {
+  const lines = content.split("\n")
+  const groups: ListItem[][] = []
+  taskGroups(parseMarkdown(content), groups)
+  const startLine = (i: ListItem): number => toLspPosition(i.position!.start).line
+  const group = groups.find((g) => g.some((i) => startLine(i) === line))
+  if (!group) return { ok: false, reason: "anchor-not-found" }
+  const target = group.find((i) => startLine(i) === line)!
+  if (target.checked === true) return { ok: true, edits: [] }
+  const edits = group
+    .filter((i) => i === target || i.checked === true)
+    .map((i) => boxEdit(lines, i, i === target ? "x" : " "))
+  if (edits.some((e) => e === undefined)) return { ok: false, reason: "anchor-not-found" }
+  return { ok: true, edits: edits as SteeringEdit[] }
+}
+
 /**
  * Free-form's `apply`: only a `paragraph` anchor resolves (the only kind
  * `view` ever reports), and it only ever APPENDS, at or past the document's
@@ -104,6 +140,8 @@ const appendEdit = (content: string, text: string): SteeringEdit => {
  */
 const freeFormApply: SteeringFormat["apply"] = (content, anchor, opts): SteeringAnnotateResult => {
   if (anchor.kind !== "paragraph") return { ok: false, reason: "anchor-not-found" }
+  if (opts.checked === true) return tickEdits(content, anchor.line)
+  if (opts.checked === false) return { ok: false, reason: "pick-never-clears" }
   const text = opts.text ?? ""
   const tree = parseMarkdown(content)
   const lines = content.split(/\r?\n/)

package/src/steering/qa.test.ts

@@ -1172,7 +1172,7 @@ describe("qa.view — block nodes (package 02, T1/T2)", () => {
     expect(topItem?.text).not.toContain("Nested")
     expect(topItem?.text).not.toContain("-")
     expect(topItem?.items).toEqual([
-      { text: "Nested", inline: [{ kind: "text", value: "Nested" }] },
+      { text: "Nested", inline: [{ kind: "text", value: "Nested" }], line: 2 },
     ])
   })
 
@@ -1180,8 +1180,8 @@ describe("qa.view — block nodes (package 02, T1/T2)", () => {
     const content = ["- [ ] Not done", "- [x] Done", ""].join("\n")
     const view = qa.view(content)
     expect(view.nodes[0]?.block?.items).toEqual([
-      { text: "Not done", checked: false, inline: [{ kind: "text", value: "Not done" }] },
-      { text: "Done", checked: true, inline: [{ kind: "text", value: "Done" }] },
+      { text: "Not done", checked: false, inline: [{ kind: "text", value: "Not done" }], line: 0 },
+      { text: "Done", checked: true, inline: [{ kind: "text", value: "Done" }], line: 1 },
     ])
   })
 

package/src/steering/qa.ts

@@ -822,7 +822,7 @@ const replaceOptionTextEdit = (
  * Collapses a typed answer to the single-line shape a list-item label must
  * be. A raw textarea value's interior newlines would break `.gtd/`'s oxfmt
  * fixed point the moment they are spliced onto a `- [x] ` line, and every
- * steering file — server-written ones included — is covered by `format:check`.
+ * steering file — server-written ones included — is covered by the `check` task.
  */
 /**
  * Empty normalizes to `FREE_TEXT_PLACEHOLDER`, never `""`: an empty label

package/src/steering/review.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { FOOTNOTE_ACTION_TITLE, steeringFormatFor, viewOf } from "./internal.js"
+import { applySteeringEdits, FOOTNOTE_ACTION_TITLE, steeringFormatFor, viewOf } from "./internal.js"
 import { parseReviewDoc, unansweredNotes } from "./review.js"
 import { getParseCount } from "./internal.js"
 
@@ -1370,6 +1370,31 @@ describe("review.annotate", () => {
     expect(result.ok).toBe(true)
   })
 
+  it("a paragraph anchor on one item of a chunk's list notes that item alone", () => {
+    const summary = [
+      "# Review: abc1234",
+      "<!-- base: abc1234def5678901234567890123456789abcd -->",
+      "",
+      "## Quality lap",
+      "",
+      "Fixed automatically:",
+      "",
+      "- Rounds wrong (lens correctness)",
+      "- Missing test (lens tests)",
+      "",
+    ].join("\n")
+    const before = review.view(summary).nodes[0]!.body![1]!.block!.items!
+    expect(before.map((item) => item.line)).toEqual([7, 8])
+    const result = review.annotate(summary, { kind: "paragraph", line: 8 }, "reopen it")
+    if (!result.ok) throw new Error(result.reason)
+    const after = applySteeringEdits(summary, result.edits)
+    expect(review.validate(after)).toEqual([])
+    const items = review.view(after).nodes[0]!.body![1]!.block!.items!
+    expect(items[0]).not.toHaveProperty("thread")
+    expect(items[0]).not.toHaveProperty("note")
+    expect(items[1]!.thread?.entries).toEqual([{ author: "me", text: "reopen it" }])
+  })
+
   it("accepts a paragraph anchor in a prose-only document", () => {
     const result = review.annotate(
       "Just some prose.\n",

package/src/step/LandStep.ts

@@ -16,7 +16,7 @@ export type GitWrite =
 /** A landed step's trailing report, rendered by `GitScript.ts` into a `printf` line. */
 export type Outcome =
   | { readonly kind: "transition"; readonly from: StateName; readonly to: StateName }
-  | { readonly kind: "commit"; readonly subject: StateName | string }
+  | { readonly kind: "commit"; readonly subject: string }
   | { readonly kind: "note"; readonly text: string }
 
 /**

package/src/twins/FakeGitOperations.ts

@@ -77,6 +77,8 @@ const makeGitReaderOps = (repo: InMemRepo, root: string): GitReaderOperations =>
 
   changedPaths: (base?: string) => Effect.succeed(repo.changedPathsWorktree(base)),
 
+  untrackedPaths: () => Effect.succeed(repo.untrackedPaths()),
+
   stagedPaths: () => Effect.succeed(repo.stagedPaths()),
 
   diffPaths: (base: string, tip: string) => tryCatch(() => repo.diffPaths(base, tip)),

package/src/twins/GitTiers.ts

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os"
 import { execFileSync, execSync, spawnSync } from "node:child_process"
 // Imported directly (not just from *.test.ts) — a leak of this module into
 // the shipped CLI bundle would try to inline `vitest` and fail the build
-// loudly (`deps.alwaysBundle` in `tsdown.config.ts`), a guard alongside the
+// loudly (`deps.alwaysBundle` in `vite.config.ts`), a guard alongside the
 // `TEST_DOUBLE_SENTINEL` check.
 import { afterEach, beforeEach, describe, expect, it } from "vitest"
 import { Effect, Exit, Option } from "effect"
@@ -131,7 +131,12 @@ export interface GitTier {
 const noopNarratorLayer = Narrator.layer(() => {}, false)
 
 const gitExecIn = (dir: string, ...args: string[]): string =>
-  execSync(`git ${args.join(" ")}`, { cwd: dir, encoding: "utf8", stdio: "pipe" }).trim()
+  execSync(`git ${args.join(" ")}`, {
+    cwd: dir,
+    encoding: "utf8",
+    stdio: "pipe",
+    maxBuffer: 1 << 28,
+  }).trim()
 
 const makeLiveTier = (initialCommit = true): GitTier => {
   // realpath'd once here so `t.root` matches `git rev-parse --show-toplevel`'s
@@ -150,6 +155,7 @@ const makeLiveTier = (initialCommit = true): GitTier => {
       cwd: root,
       env: commitEnv(),
       stdio: "pipe",
+      maxBuffer: 1 << 28,
     })
   gitExec("init")
   gitExec(`config user.email "test@test.com"`)
@@ -432,6 +438,7 @@ export const CONTRACT_COVERED_OPERATIONS: ReadonlySet<keyof GitOperations> = new
   "subjectHistory",
   "readFileAtRef",
   "changedPaths",
+  "untrackedPaths",
   "stagedPaths",
   "diffPaths",
   "authorIdent",
@@ -1098,6 +1105,24 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
       expect(await runGit(t, (g) => g.changedPaths())).toEqual([])
     })
 
+    it("classifies an untracked set far past the argument limit, against an older base", async () => {
+      const long = "d".repeat(200)
+      const paths = Array.from({ length: 4000 }, (_, i) => `${long}/${long}/${long}/f${i}.txt`)
+      t.seed.commit("chore: seed", { "kept.txt": "seed" })
+      const seed = t.observe.resolveRef("HEAD")
+      t.seed.commit(
+        "chore: files",
+        Object.fromEntries(paths.map((p, i) => [p, i % 2 === 0 ? "same" : "old"])),
+      )
+      const head = t.observe.resolveRef("HEAD")
+      t.seed.mixedReset(seed)
+      paths.forEach((p, i) => t.seed.writeFile(p, i % 2 === 0 ? "same" : "new"))
+      const changed = await runGit(t, (g) => g.changedPaths(head))
+      expect(changed.length).toBe(2000)
+      expect(changed.every((c) => c.status === "M")).toBe(true)
+      expect((await runGit(t, (g) => g.untrackedPaths())).length).toBe(4000)
+    })
+
     it("ignores an edit staged and then reverted in the worktree", async () => {
       t.seed.commit("chore: seed", { "a.txt": "1" })
       t.seed.writeFile("a.txt", "2")

package/src/twins/InMemRepo.ts

@@ -298,6 +298,11 @@ export class InMemRepo {
     return diffTrees(baseTree, worktreeTree)
   }
 
+  /** Worktree paths the index does not carry. */
+  untrackedPaths(): string[] {
+    return [...this.worktree.keys()].filter((k) => !this.index.has(k))
+  }
+
   /** The index vs HEAD — the port's `stagedPaths`. */
   stagedPaths(): Array<{ path: string; status: string }> {
     return diffTrees(this.treeAt(undefined), this.index)

package/src/wire/BeatPlain.ts

@@ -32,9 +32,9 @@ const nextStatusLine = (next: BeatDocument["next"]): string =>
 
 /** Builds `{[key]: value}` for each entry whose value isn't `undefined` — the shared "omit absent optional fields" shape the header uses. */
 const definedFields = (
-  entries: readonly (readonly [string, unknown])[],
-): Record<string, unknown> => {
-  const result: Record<string, unknown> = {}
+  entries: readonly (readonly [string, string | undefined])[],
+): Record<string, string> => {
+  const result: Record<string, string> = {}
   for (const [key, value] of entries) if (value !== undefined) result[key] = value
   return result
 }

package/src/wire/Select.ts

@@ -18,7 +18,7 @@ const toSelection = (value: unknown): Selection => {
   if (typeof value === "object") {
     return { kind: "value", text: JSON.stringify(value) }
   }
-  return { kind: "value", text: String(value) }
+  return { kind: "value", text: String(value as string | number | boolean | bigint | undefined) }
 }
 
 /** A segment that resolves to no key at all (missing from an object, out-of-range or non-numeric against an array) — distinct from a present key holding `undefined`. */