@pmelab/gtd 24.0.0 → 24.2.0

package/src/testkit/InMemRepo.ts

@@ -0,0 +1,467 @@
+// Pure TypeScript, no Effect, no real filesystem/git.
+import { createHash } from "node:crypto"
+
+/** Embedded in every value this fake reaches (see also `strictGitOperations`'s default message) so `scripts/assert-no-test-doubles.mjs` can catch a leak into the shipped bundle by string search. */
+export const TEST_DOUBLE_SENTINEL = "gtd:test-double:never-ship"
+
+interface Commit {
+  hash: string // 40-hex
+  message: string
+  files: Map<string, string> // full tree snapshot (path → UTF-8 content)
+  parent: string | null
+}
+
+function sha1(input: string): string {
+  return createHash("sha1").update(input).digest("hex")
+}
+
+function makeHash(message: string, parent: string | null, tree: Map<string, string>): string {
+  const treeStr = [...tree.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k}:${v}`)
+    .join("\n")
+  return sha1(`${message}\n${parent ?? "null"}\n${treeStr}`)
+}
+
+export class InMemRepo {
+  // Data-only marker read by no code path: embeds the sentinel in every
+  // instance so a leaked object still carries it.
+  readonly testDouble = TEST_DOUBLE_SENTINEL
+
+  private commits: Map<string, Commit> = new Map()
+  private branches: Map<string, string> = new Map() // branch name → hash
+  private refs: Map<string, string> = new Map() // fully qualified ref (refs/gtd/…) → hash
+  private head: string | null = null
+  private currentBranch: string = "main"
+  private worktree: Map<string, string> = new Map()
+  private index: Map<string, string> = new Map()
+
+  private getCommit(hash: string): Commit | null {
+    return this.commits.get(hash) ?? null
+  }
+
+  private headCommit(): Commit | null {
+    if (this.head === null) return null
+    return this.getCommit(this.head) ?? null
+  }
+
+  private headTree(): Map<string, string> {
+    return this.headCommit()?.files ?? new Map()
+  }
+
+  /** The tree at `ref` (HEAD's own when `ref` is omitted), empty when it resolves to nothing. */
+  private treeAt(ref: string | undefined): Map<string, string> {
+    if (ref === undefined) return this.headTree()
+    const hash = this.resolveRef(ref)
+    return hash === null ? new Map() : (this.getCommit(hash)?.files ?? new Map())
+  }
+
+  // fallow-ignore-next-line complexity
+  statusPorcelain(): string {
+    const headTree = this.headTree()
+    const lines: string[] = []
+
+    const allPaths = new Set([...headTree.keys(), ...this.index.keys(), ...this.worktree.keys()])
+
+    for (const path of [...allPaths].sort()) {
+      const inHead = headTree.has(path)
+      const inIndex = this.index.has(path)
+      const inWorktree = this.worktree.has(path)
+      const headContent = headTree.get(path)
+      const indexContent = this.index.get(path)
+      const worktreeContent = this.worktree.get(path)
+
+      let X = " "
+      if (!inHead && inIndex) {
+        X = "A"
+      } else if (inHead && !inIndex) {
+        X = "D"
+      } else if (inHead && inIndex && headContent !== indexContent) {
+        X = "M"
+      }
+
+      let Y = " "
+      if (inIndex && !inWorktree) {
+        Y = "D"
+      } else if (!inIndex && inWorktree) {
+        Y = "?"
+      } else if (inIndex && inWorktree && indexContent !== worktreeContent) {
+        Y = "M"
+      }
+
+      if (!inHead && !inIndex && inWorktree) {
+        lines.push(`?? ${path}`)
+        continue
+      }
+
+      if (X === " " && Y === " ") continue
+
+      lines.push(`${X}${Y} ${path}`)
+    }
+
+    return lines.length > 0 ? lines.join("\n") + "\n" : ""
+  }
+
+  hasCommits(): boolean {
+    return this.head !== null
+  }
+
+  // fallow-ignore-next-line complexity
+  resolveRef(ref: string): string | null {
+    if (/^[0-9a-f]{40}$/.test(ref)) {
+      return this.commits.has(ref) ? ref : null
+    }
+
+    const tildeMatch = /^(HEAD|[0-9a-f]{40})(~(\d+))?$/.exec(ref)
+    if (tildeMatch) {
+      const base = tildeMatch[1]!
+      const steps = tildeMatch[3] !== undefined ? parseInt(tildeMatch[3], 10) : 0
+      let cur: string | null = base === "HEAD" ? this.head : this.commits.has(base) ? base : null
+      for (let i = 0; i < steps; i++) {
+        if (cur === null) return null
+        cur = this.getCommit(cur)?.parent ?? null
+      }
+      return cur
+    }
+
+    const refHash = this.refs.get(ref)
+    if (refHash !== undefined) return refHash
+
+    return this.branches.get(ref) ?? null
+  }
+
+  lastCommitSubject(ref = "HEAD"): string | null {
+    const hash = this.resolveRef(ref)
+    const c = hash !== null ? this.getCommit(hash) : null
+    if (!c) return null
+    return c.message.split("\n")[0] ?? null
+  }
+
+  lastCommitMessage(): string | null {
+    const c = this.headCommit()
+    if (!c) return null
+    return c.message
+  }
+
+  /**
+   * `head` (default `this.head`, mirroring production's `"HEAD"` default) is
+   * resolved through the SAME `resolveRef` logic as any other ref — so a
+   * symbolic name, a hash, or a `~N` expression all work exactly as they
+   * would for `head === undefined`. `Edge.ts`'s `restAt` passes the review
+   * checkout window's saved-head hash here while the window is open.
+   */
+  commitHistory(
+    base?: string,
+    head?: string,
+  ): Array<{
+    hash: string
+    message: string
+    touched: ReadonlyArray<string>
+  }> {
+    const headHash = head !== undefined ? this.resolveRef(head) : this.head
+    if (headHash === null) return []
+
+    const chain: Commit[] = []
+    let cur: string | null = headHash
+    while (cur !== null) {
+      const c = this.getCommit(cur)
+      if (!c) break
+      chain.push(c)
+      cur = c.parent
+    }
+
+    chain.reverse()
+
+    // Filter to base..HEAD range if base given — resolved through `resolveRef`
+    // so a `<hash>~N`/`HEAD~N` base (not just an already-resolved hash) walks
+    // the same range a real `git log <base>..<head>` would.
+    let filtered = chain
+    if (base !== undefined) {
+      const resolvedBase = this.resolveRef(base)
+      const baseIdx = resolvedBase === null ? -1 : chain.findIndex((c) => c.hash === resolvedBase)
+      if (baseIdx === -1) {
+        return []
+      }
+      filtered = chain.slice(baseIdx + 1)
+    }
+
+    // Counts every commit whose body/diff this call computes — the perf test
+    // in Edge.test.ts pins this staying bounded (independent of repo age)
+    // rather than growing with the total commit count.
+    this.bodyReadCount += filtered.length
+
+    return filtered.map((c) => {
+      const parentTree = c.parent ? (this.getCommit(c.parent)?.files ?? new Map()) : new Map()
+      const touched = diffTrees(parentTree, c.files).map((e) => e.path)
+      return { hash: c.hash, message: c.message, touched }
+    })
+  }
+
+  /** Total commits `commitHistory` has ever computed a body/diff for, across every call — see `commitHistory`'s own comment. */
+  bodyReadCount = 0
+
+  /**
+   * `{ hash, subject }` pairs for one page of history — the fake's
+   * counterpart to the real port's `git log --skip --max-count --reverse`:
+   * walk backward (newest-first) from `head`, drop `skip`, keep at most
+   * `pageSize`, then reverse the kept page to oldest→newest. Never touches
+   * `bodyReadCount` — a subject-only read costs nothing to model as cheap.
+   */
+  subjectHistory(
+    pageSize: number,
+    skip: number,
+    head?: string,
+  ): Array<{ hash: string; subject: string }> {
+    const headHash = head !== undefined ? this.resolveRef(head) : this.head
+    if (headHash === null) return []
+
+    const chain: Commit[] = []
+    let cur: string | null = headHash
+    while (cur !== null) {
+      const c = this.getCommit(cur)
+      if (!c) break
+      chain.push(c)
+      cur = c.parent
+    }
+
+    const page = chain.slice(skip, Number.isFinite(pageSize) ? skip + pageSize : undefined)
+    page.reverse()
+    return page.map((c) => ({ hash: c.hash, subject: c.message.split("\n")[0] ?? "" }))
+  }
+
+  fileAtRef(ref: string, path: string): string | null {
+    const hash = this.resolveRef(ref)
+    if (!hash) return null
+    const c = this.getCommit(hash)
+    if (!c) return null
+    return c.files.get(path) ?? null
+  }
+
+  /**
+   * `base` (default HEAD) mirrors the port's own optional base. Tree-vs-worktree
+   * comparison already subsumes production's untracked-file filtering: a path
+   * present at `base` with identical content is simply not a difference.
+   */
+  changedPathsWorktree(base?: string): Array<{ path: string; status: string }> {
+    const baseTree = this.treeAt(base)
+    const worktreeTree = new Map(this.worktree)
+    return diffTrees(baseTree, worktreeTree)
+  }
+
+  /** The worktree content of `path`, or `undefined` when absent. A LIVE read — never a snapshot. */
+  readFile(path: string): string | undefined {
+    return this.worktree.get(path)
+  }
+
+  /** True when `path` is exactly a worktree file, or a directory prefix of one (any worktree key starts with `path/`). */
+  hasPath(path: string): boolean {
+    if (this.worktree.has(path)) return true
+    const prefix = path.endsWith("/") ? path : `${path}/`
+    for (const key of this.worktree.keys()) {
+      if (key.startsWith(prefix)) return true
+    }
+    return false
+  }
+
+  /** Every worktree path under `prefix`, sorted. `prefix === ""` returns the whole worktree. */
+  /** Every path committed at `ref`, sorted — empty when it resolves to nothing. */
+  pathsAtRef(ref: string): ReadonlyArray<string> {
+    return [...this.treeAt(ref).keys()].sort()
+  }
+
+  pathsUnder(prefix: string): ReadonlyArray<string> {
+    if (prefix === "") return [...this.worktree.keys()].sort()
+    const dirPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`
+    return [...this.worktree.keys()]
+      .filter((key) => key === prefix || key.startsWith(dirPrefix))
+      .sort()
+  }
+
+  /** `git add -A` — the index becomes exactly the current worktree. */
+  stageAll(): void {
+    this.index = new Map(this.worktree)
+  }
+
+  /** Commit whatever is currently staged (the index) verbatim, with no implicit staging first — mirrors `git commit --allow-empty -m <message>` after a soft reset. */
+  commitAsIs(message: string): void {
+    const tree = new Map(this.index)
+    const parent = this.head
+    const hash = makeHash(message, parent, tree)
+    const commit: Commit = { hash, message, files: new Map(tree), parent }
+    this.commits.set(hash, commit)
+    this.head = hash
+    this.branches.set(this.currentBranch, hash)
+  }
+
+  /** Discard every pending change, tracked or untracked: stage everything, then hard-reset (which drops the freshly-staged untracked paths too). */
+  discardPending(): void {
+    this.index = new Map(this.worktree)
+    this.resetHard()
+  }
+
+  commitAllWithPrefix(prefix: string): void {
+    this.index = new Map(this.worktree)
+
+    const tree = new Map(this.index)
+    const message = prefix
+    const parent = this.head
+    const hash = makeHash(message, parent, tree)
+
+    const commit: Commit = { hash, message, files: new Map(tree), parent }
+    this.commits.set(hash, commit)
+    this.head = hash
+    this.branches.set(this.currentBranch, hash)
+  }
+
+  // Git's empty-tree object SHA: used as squash base when there's no parent commit.
+  private static readonly EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+
+  softResetTo(ref: string): void {
+    if (ref === InMemRepo.EMPTY_TREE) {
+      this.head = null
+      this.branches.delete(this.currentBranch)
+      return
+    }
+    const hash = this.resolveRef(ref)
+    if (!hash) throw new Error(`Cannot resolve ref: ${ref}`)
+    this.head = hash
+    this.branches.set(this.currentBranch, hash)
+  }
+
+  /**
+   * `git reset --hard <ref>` — move HEAD, the index, AND the worktree to
+   * `ref`'s commit. Doubles as test-setup (a scenario simulating checking out
+   * a DIFFERENT point in history — e.g. to build two diverging tips off one
+   * shared base, so one of them is provably NOT an ancestor of the other,
+   * `gtd review <commitish>`'s ancestor guard) and as this repo's backing for
+   * the production `GitOperations.hardResetTo` (wired in `FakeGitOperations.ts`).
+   */
+  hardResetTo(ref: string): void {
+    const hash = this.resolveRef(ref)
+    if (!hash) throw new Error(`Cannot resolve ref: ${ref}`)
+    this.head = hash
+    this.branches.set(this.currentBranch, hash)
+    const tree = this.getCommit(hash)?.files ?? new Map()
+    this.index = new Map(tree)
+    this.worktree = new Map(tree)
+  }
+
+  resetHard(): void {
+    const headTree = this.headTree()
+    // Snapshot the old index before resetting it (needed to identify staged-new files).
+    const oldIndex = new Map(this.index)
+
+    this.index = new Map(headTree)
+
+    // Rebuild worktree: pure-untracked files (not in HEAD and not in old
+    // index) survive; staged-new files (in old index but not in HEAD) are
+    // removed; tracked files are restored to HEAD content.
+    const newWorktree = new Map<string, string>()
+
+    for (const [path, content] of this.worktree) {
+      if (!headTree.has(path) && !oldIndex.has(path)) {
+        newWorktree.set(path, content)
+      }
+    }
+
+    for (const [path, content] of headTree) {
+      newWorktree.set(path, content)
+    }
+
+    this.worktree = newWorktree
+  }
+
+  writeFile(path: string, content: string): void {
+    this.worktree.set(path, content)
+  }
+
+  deleteFile(path: string): void {
+    this.worktree.delete(path)
+  }
+
+  /** `git update-ref <ref> <hash>` — point a repo-local ref at a commit (resolves symbolic inputs first). */
+  updateRef(ref: string, hash: string): void {
+    this.refs.set(ref, this.resolveRef(hash) ?? hash)
+  }
+
+  /** `git update-ref -d <ref>` — idempotent removal of a repo-local ref. */
+  deleteRef(ref: string): void {
+    this.refs.delete(ref)
+  }
+
+  /**
+   * `git reset --mixed <ref>` — move HEAD and the index to `ref`'s commit,
+   * leaving the working tree untouched (so committed work re-surfaces as
+   * pending changes).
+   */
+  mixedResetTo(ref: string): void {
+    if (ref === InMemRepo.EMPTY_TREE) {
+      this.head = null
+      this.branches.delete(this.currentBranch)
+      this.index = new Map()
+      return
+    }
+    const hash = this.resolveRef(ref)
+    if (!hash) throw new Error(`Cannot resolve ref: ${ref}`)
+    this.head = hash
+    this.branches.set(this.currentBranch, hash)
+    this.index = new Map(this.getCommit(hash)?.files ?? new Map())
+  }
+
+  /** `hash` and its first-parent ancestors, nearest first. */
+  private chainFrom(hash: string): string[] {
+    const chain: string[] = []
+    for (let cur: string | null = hash; cur !== null; cur = this.getCommit(cur)?.parent ?? null) {
+      chain.push(cur)
+    }
+    return chain
+  }
+
+  /** The nearest commit on both first-parent chains, or `null`. */
+  mergeBase(a: string, b: string): string | null {
+    const ha = this.resolveRef(a)
+    const hb = this.resolveRef(b)
+    if (!ha || !hb) return null
+    const onA = new Set(this.chainFrom(ha))
+    return this.chainFrom(hb).find((hash) => onA.has(hash)) ?? null
+  }
+
+  /** True iff `a` is an ancestor of (or equal to) `b` on the first-parent chain. */
+  isAncestor(a: string, b: string): boolean {
+    const ha = this.resolveRef(a)
+    const hb = this.resolveRef(b)
+    if (!ha || !hb) return false
+    let cur: string | null = hb
+    while (cur !== null) {
+      if (cur === ha) return true
+      cur = this.getCommit(cur)?.parent ?? null
+    }
+    return false
+  }
+}
+
+/**
+ * Unlike production's `parseNameStatus` (`src/platform/Git.ts`), this never reports a
+ * rename/copy (`R`/`C`) — every change is a plain add/delete/modify. A path
+ * that git would show as a rename therefore surfaces here as a delete-of-old
+ * plus an add-of-new, never as a rename, in either tier's contract tests.
+ */
+function diffTrees(
+  treeA: Map<string, string>,
+  treeB: Map<string, string>,
+): Array<{ path: string; status: string }> {
+  const result: Array<{ path: string; status: string }> = []
+  const allPaths = new Set([...treeA.keys(), ...treeB.keys()])
+  for (const path of allPaths) {
+    const inA = treeA.has(path)
+    const inB = treeB.has(path)
+    if (!inA && inB) {
+      result.push({ path, status: "A" })
+    } else if (inA && !inB) {
+      result.push({ path, status: "D" })
+    } else if (inA && inB && treeA.get(path) !== treeB.get(path)) {
+      result.push({ path, status: "M" })
+    }
+  }
+  return result.sort((a, b) => a.path.localeCompare(b.path))
+}

package/src/testkit/Layers.test.ts

@@ -0,0 +1,58 @@
+import { Effect } from "effect"
+import { describe, expect, it } from "vitest"
+import { ConfigDiscovery, LEGACY_RC_FILES, walkUp } from "../workflow/index.js"
+import { InMemRepo } from "./index.js"
+import { testLayers } from "./Layers.js"
+
+// The in-memory `ConfigDiscovery` counterpart walks the SAME root→home chain
+// and looks for the SAME `LEGACY_RC_FILES` as `ConfigDiscovery.Live` — both
+// imported from it, never copied.
+
+const ROOT = "/home/user/project/sub"
+const MIDDLE = "/home/user/project"
+const HOME = "/home/user"
+const ABOVE_HOME = "/home"
+
+/** Writes `content` at `dir/name`, using a repo-relative key inside `ROOT` and an absolute literal key outside it — matching `makeInMemoryWorkspaceOps.atPath`'s own root-relative/ancestor split. */
+const seed = (repo: InMemRepo, dir: string, name: string, content: string): void => {
+  const filepath = `${dir}/${name}`
+  const key = filepath.startsWith(`${ROOT}/`) ? filepath.slice(ROOT.length + 1) : filepath
+  repo.writeFile(key, content)
+}
+
+const runDiscovery = <A>(
+  repo: InMemRepo,
+  f: (d: ConfigDiscovery["Type"]) => Effect.Effect<A, Error>,
+) =>
+  Effect.runPromise(
+    Effect.gen(function* () {
+      const discovery = yield* ConfigDiscovery
+      return yield* f(discovery)
+    }).pipe(Effect.provide(testLayers(repo, { root: ROOT, home: HOME }))),
+  )
+
+describe("the in-memory ConfigDiscovery counterpart", () => {
+  it("finds every leftover rc file on the shared walk, innermost first", async () => {
+    const repo = new InMemRepo()
+    seed(repo, HOME, LEGACY_RC_FILES[1]!, "{}\n")
+    seed(repo, ROOT, LEGACY_RC_FILES[0]!, "vars: {}\n")
+    seed(repo, ROOT, LEGACY_RC_FILES[1]!, "{}\n")
+    seed(repo, ABOVE_HOME, LEGACY_RC_FILES[0]!, "never-walked: true\n")
+    const found = (await runDiscovery(repo, (d) => d.legacyRcFiles(ROOT, HOME))).map((f) => f.path)
+    expect(walkUp(ROOT, HOME)).toEqual([ROOT, MIDDLE, HOME])
+    expect(found).toEqual([
+      `${ROOT}/${LEGACY_RC_FILES[0]}`,
+      `${ROOT}/${LEGACY_RC_FILES[1]}`,
+      `${HOME}/${LEGACY_RC_FILES[1]}`,
+    ])
+  })
+
+  it("also searches home when the walk never reaches it", async () => {
+    const repo = new InMemRepo()
+    seed(repo, HOME, LEGACY_RC_FILES[1]!, "{}\n")
+    const found = (
+      await runDiscovery(repo, (d) => d.legacyRcFiles("/elsewhere/project", HOME))
+    ).map((f) => f.path)
+    expect(found).toEqual([`${HOME}/${LEGACY_RC_FILES[1]}`])
+  })
+})