@pmelab/gtd 26.1.0 → 27.1.0

package/src/replay/judgeDiffShape.test.ts

@@ -0,0 +1,208 @@
+import { afterEach, describe, expect, it } from "vitest"
+import {
+  installContext,
+  judgeDiffShape,
+  type Change,
+  type FlowContext,
+  type JudgeAnswer,
+  type StepRequest,
+} from "../flows/index.js"
+import { globMatches } from "../wire/index.js"
+
+// Lives in replay, which wires `matches: globMatches` (flows tests may not import wire).
+afterEach(() => installContext(undefined))
+
+const change = (
+  path: string,
+  status: Change["status"],
+  before?: string,
+  after?: string,
+): Change => ({
+  path,
+  status,
+  before,
+  after,
+})
+
+const install = (
+  verdict: { shape?: JudgeAnswer | undefined; truncated?: string[] } | "none",
+  vars: Record<string, string> = {},
+) => {
+  const requests: StepRequest[] = []
+  installContext({
+    matches: globMatches,
+    vars,
+    step: async (request: StepRequest) => {
+      requests.push(request)
+      return {
+        answers: { shape: verdict === "none" ? undefined : verdict.shape },
+        truncated: verdict === "none" ? [] : (verdict.truncated ?? []),
+      }
+    },
+  } as unknown as FlowContext)
+  return requests
+}
+
+const naive = [
+  change("src/a.ts", "modified", "a1", "a2"),
+  change("z/new.ts", "added", undefined, "new"),
+  change("b/old.ts", "deleted", "old", undefined),
+]
+
+describe("judgeDiffShape", () => {
+  it("answers land with no judge step when nothing strays", async () => {
+    const requests = install("none")
+    const result = await judgeDiffShape("shape", {
+      changes: naive,
+      allow: ["src/**", "z/**", "b/**"],
+    })
+    expect(result).toEqual({ choice: "land", strays: [], unreadable: [], judgment: undefined })
+    expect(requests).toEqual([])
+  })
+
+  it("makes every path a stray when allow is empty", async () => {
+    install({ shape: { answer: "land", p: 0.9 } })
+    const result = await judgeDiffShape("shape", { changes: naive, allow: [] })
+    expect(result.strays).toEqual(["b/old.ts", "src/a.ts", "z/new.ts"])
+  })
+
+  it("asks one choice question named shape with the three labels in its criteria", async () => {
+    const requests = install({ shape: { answer: "land", p: 0.9 } })
+    await judgeDiffShape("shape", { changes: naive, allow: ["src/**"] })
+    expect(requests).toHaveLength(1)
+    const request = requests[0]
+    if (request?.kind !== "judge") throw new Error("expected a judge step")
+    expect(request.name).toBe("shape")
+    expect(request.questions).toHaveLength(1)
+    const q = request.questions[0]
+    expect(q).toMatchObject({ id: "shape", primitive: "choice" })
+    for (const label of ["land", "refactor-first", "reject"]) expect(q?.criteria).toContain(label)
+    expect(q?.criteria).toContain("strays a refactor could absorb never count as reject")
+  })
+
+  it("carries exactly four evidence keys, with stray content before/after and in-allowlist paths only", async () => {
+    const requests = install({ shape: { answer: "land", p: 0.9 } })
+    await judgeDiffShape("shape", { changes: naive, allow: ["src/**"] })
+    const request = requests[0]
+    if (request?.kind !== "judge") throw new Error("expected a judge step")
+    expect(Object.keys(request.evidence).sort()).toEqual([
+      "allow",
+      "inAllowlist",
+      "strayContent",
+      "strays",
+    ])
+    expect(request.evidence.strays).toBe(JSON.stringify(["b/old.ts", "z/new.ts"], null, 2))
+    expect(request.evidence.allow).toBe(JSON.stringify(["src/**"], null, 2))
+    expect(request.evidence.inAllowlist).toBe(JSON.stringify(["src/a.ts"], null, 2))
+    expect(request.evidence.strayContent).toBe(
+      [
+        "=== b/old.ts (deleted)",
+        "--- before",
+        "old",
+        "=== z/new.ts (added)",
+        "--- after",
+        "new",
+      ].join("\n"),
+    )
+    expect(request.evidence.strayContent).not.toContain("a2")
+  })
+
+  it("keeps modified strays' before and after", async () => {
+    const requests = install({ shape: { answer: "land", p: 0.9 } })
+    await judgeDiffShape("shape", { changes: naive, allow: ["b/**", "z/**"] })
+    const request = requests[0]
+    if (request?.kind !== "judge") throw new Error("expected a judge step")
+    expect(request.evidence.strayContent).toBe(
+      "=== src/a.ts (modified)\n--- before\na1\n--- after\na2",
+    )
+  })
+
+  it.each(["land", "refactor-first", "reject"] as const)(
+    "returns %s at or above minP",
+    async (label) => {
+      install({ shape: { answer: label, p: 0.7 } })
+      const result = await judgeDiffShape("shape", { changes: naive, allow: [] })
+      expect(result.choice).toBe(label)
+    },
+  )
+
+  it("falls back to refactor-first below minP", async () => {
+    install({ shape: { answer: "reject", p: 0.69 } })
+    expect((await judgeDiffShape("shape", { changes: naive, allow: [] })).choice).toBe(
+      "refactor-first",
+    )
+  })
+
+  it("falls back to refactor-first on no verdict or an unknown answer", async () => {
+    install("none")
+    expect((await judgeDiffShape("shape", { changes: naive, allow: [] })).choice).toBe(
+      "refactor-first",
+    )
+    install({ shape: { answer: "yolo", p: 1 } })
+    expect((await judgeDiffShape("shape", { changes: naive, allow: [] })).choice).toBe(
+      "refactor-first",
+    )
+  })
+
+  it("prefers the minP option, then vars.judgeShapeMinP, then 0.7", async () => {
+    const verdict = { shape: { answer: "land", p: 0.9 } }
+    install(verdict, { judgeShapeMinP: "0.95" })
+    expect((await judgeDiffShape("s", { changes: naive, allow: [] })).choice).toBe("refactor-first")
+    expect((await judgeDiffShape("s", { changes: naive, allow: [], minP: 0.5 })).choice).toBe(
+      "land",
+    )
+    install(verdict, {})
+    expect((await judgeDiffShape("s", { changes: naive, allow: [] })).choice).toBe("land")
+    install({ shape: { answer: "land", p: 0.6 } }, {})
+    expect((await judgeDiffShape("s", { changes: naive, allow: [] })).choice).toBe("refactor-first")
+  })
+
+  it("never lands a blank judgeShapeMinP", async () => {
+    install({ shape: { answer: "land", p: 1 } }, { judgeShapeMinP: "" })
+    expect((await judgeDiffShape("s", { changes: naive, allow: [] })).choice).toBe("refactor-first")
+  })
+
+  it("takes refactor-first on truncated evidence and still returns the judgment", async () => {
+    install({ shape: { answer: "land", p: 0.9 }, truncated: ["strayContent"] })
+    const result = await judgeDiffShape("s", { changes: naive, allow: [] })
+    expect(result.choice).toBe("refactor-first")
+    expect(result.judgment?.truncated).toEqual(["strayContent"])
+  })
+
+  it.each([
+    ["modified without before", change("m.ts", "modified", undefined, "a")],
+    ["modified without after", change("m.ts", "modified", "a", undefined)],
+    ["added without after", change("m.ts", "added", undefined, undefined)],
+    ["deleted without before", change("m.ts", "deleted", undefined, undefined)],
+  ])("takes refactor-first with no judge step for %s", async (_label, bad) => {
+    const requests = install({ shape: { answer: "land", p: 1 } })
+    const result = await judgeDiffShape("s", {
+      changes: [change("z.ts", "added", undefined, "z"), bad],
+      allow: [],
+    })
+    expect(result).toEqual({
+      choice: "refactor-first",
+      strays: ["m.ts", "z.ts"],
+      unreadable: ["m.ts"],
+      judgment: undefined,
+    })
+    expect(requests).toEqual([])
+  })
+
+  it("reads each lazy side once, so the readable check and the judged content agree", async () => {
+    let reads = 0
+    const lazy: Change = {
+      path: "l.ts",
+      status: "modified",
+      before: "b",
+      get after() {
+        reads++
+        return reads === 1 ? "a" : undefined
+      },
+    }
+    install({ shape: { answer: "land", p: 0.9 } })
+    const result = await judgeDiffShape("s", { changes: [lazy], allow: [] })
+    expect(reads).toBe(1)
+    expect(result.choice).toBe("land")
+  })
+})

package/src/step/index.ts

@@ -3,3 +3,4 @@ export { accessRefusal } from "./accessRefusal.js"
 export { planStart } from "./planStart.js"
 export type { GitWrite, LandStep, Outcome } from "./LandStep.js"
 export type { Landing, RepoSnapshot } from "./RepoSnapshot.js"
+export { strayPaths } from "./strayPaths.js"

package/src/step/strayPaths.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest"
+import { strayPaths } from "./index.js"
+
+describe("strayPaths", () => {
+  it("returns the paths no glob matches, sorted", () => {
+    expect(strayPaths(["src/a.ts", "z.md", "a.md"], ["src/**"])).toEqual(["a.md", "z.md"])
+  })
+
+  it("an empty allowlist returns every touched path", () => {
+    expect(strayPaths(["b", "a"], [])).toEqual(["a", "b"])
+  })
+
+  it("an empty touched list returns []", () => {
+    expect(strayPaths([], ["src/**"])).toEqual([])
+    expect(strayPaths([], [])).toEqual([])
+  })
+})

package/src/step/strayPaths.ts

@@ -0,0 +1,8 @@
+import { globMatches } from "../wire/index.js"
+
+/** Globs use the `access.write` dialect (`globMatches`). */
+export const strayPaths = (
+  touched: ReadonlyArray<string>,
+  allow: ReadonlyArray<string>,
+): ReadonlyArray<string> =>
+  touched.filter((path) => !allow.some((glob) => globMatches(path, glob))).sort()

package/src/testkit/FakeGitOperations.ts

@@ -76,6 +76,8 @@ const makeGitReaderOps = (repo: InMemRepo, root: string): GitReaderOperations =>
     Effect.succeed(repo.subjectHistory(pageSize, skip, head)),
 
   changedPaths: (base?: string) => Effect.succeed(repo.changedPathsWorktree(base)),
+
+  diffPaths: (base: string, tip: string) => tryCatch(() => repo.diffPaths(base, tip)),
 })
 
 const failOn = (output: string | undefined): void => {

package/src/testkit/GitTiers.ts

@@ -409,6 +409,7 @@ export const CONTRACT_COVERED_OPERATIONS: ReadonlySet<keyof GitOperations> = new
   "subjectHistory",
   "readFileAtRef",
   "changedPaths",
+  "diffPaths",
   "commitAllWithPrefix",
   "softResetTo",
   "commitAsIs",
@@ -434,7 +435,7 @@ const PATHOLOGICAL_PATHS: ReadonlyArray<{ label: string; path: string }> = [
 ]
 
 /**
- * Exercise all 21 `GitOperations` methods identically against `makeTier()` —
+ * Exercise every `GitOperations` methods identically against `makeTier()` —
  * called once per tier by `src/platform/Git.test.ts`. A capability-gated group
  * (`t.capabilities.X`) is skipped, not faked, on a tier that can't support it.
  */
@@ -480,6 +481,7 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
         g.readFileAtRef("HEAD", "second.txt"),
         g.changedPaths(),
         g.changedPaths("HEAD~1"),
+        g.diffPaths("HEAD~1", "HEAD"),
       ]),
     )
     expect(await t.observe.snapshot()).toBe(before)
@@ -988,6 +990,70 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
     })
   })
 
+  describe("diffPaths", () => {
+    const sorted = (paths: ReadonlyArray<string>) => [...paths].sort()
+
+    it("reports added, modified and deleted paths between two commits", async () => {
+      t.seed.commit("chore: seed", { "mod.txt": "one", "del.txt": "bye" })
+      const base = t.observe.resolveRef("HEAD")
+      t.seed.writeFile("mod.txt", "two")
+      t.seed.stageAll()
+      t.seed.commitDeletion("del.txt", "chore: delete")
+      t.seed.commit("feat: add", { "add.txt": "new", "mod.txt": "two" })
+      const tip = t.observe.resolveRef("HEAD")
+      const paths = await runGit(t, (g) => g.diffPaths(base, tip))
+      expect(sorted(paths)).toEqual(["add.txt", "del.txt", "mod.txt"])
+    })
+
+    it("reports both paths of a rename", async () => {
+      t.seed.commit("chore: seed", { "old.txt": "same content unique-marker\n" })
+      const base = t.observe.resolveRef("HEAD")
+      t.seed.deleteFile("old.txt")
+      t.seed.commit("refactor: rename", { "new.txt": "same content unique-marker\n" })
+      const tip = t.observe.resolveRef("HEAD")
+      expect(sorted(await runGit(t, (g) => g.diffPaths(base, tip)))).toEqual(["new.txt", "old.txt"])
+    })
+
+    it("omits a file changed then restored between the endpoints", async () => {
+      t.seed.commit("chore: seed", { "flip.txt": "one" })
+      const base = t.observe.resolveRef("HEAD")
+      t.seed.commit("chore: change", { "flip.txt": "two" })
+      t.seed.commit("chore: restore", { "flip.txt": "one" })
+      const tip = t.observe.resolveRef("HEAD")
+      expect(await runGit(t, (g) => g.diffPaths(base, tip))).toEqual([])
+    })
+
+    it("never reports staged, unstaged or untracked changes", async () => {
+      t.seed.commit("chore: seed", { "a.txt": "a", "b.txt": "b" })
+      const base = t.observe.resolveRef("HEAD")
+      t.seed.writeFile("a.txt", "staged")
+      t.seed.stageAll()
+      t.seed.writeFile("b.txt", "unstaged")
+      t.seed.writeFile("untracked.txt", "u")
+      expect(await runGit(t, (g) => g.diffPaths(base, "HEAD"))).toEqual([])
+    })
+
+    it("is [] for diffPaths(x, x)", async () => {
+      const head = t.observe.resolveRef("HEAD")
+      expect(await runGit(t, (g) => g.diffPaths(head, head))).toEqual([])
+    })
+
+    for (const { label, path } of PATHOLOGICAL_PATHS) {
+      it(`reports a path containing ${label}, verbatim`, async () => {
+        const base = t.observe.resolveRef("HEAD")
+        t.seed.commit("feat: pathological", { [path]: "content" })
+        expect(await runGit(t, (g) => g.diffPaths(base, "HEAD"))).toEqual([path])
+      })
+    }
+
+    it("fails when either side does not resolve", async () => {
+      const bad = await runGitExit(t, (g) => g.diffPaths("totally-invalid-ref-xyz", "HEAD"))
+      expect(Exit.isFailure(bad)).toBe(true)
+      const badTip = await runGitExit(t, (g) => g.diffPaths("HEAD", "totally-invalid-ref-xyz"))
+      expect(Exit.isFailure(badTip)).toBe(true)
+    })
+  })
+
   describe("changedPaths", () => {
     it("unions a tracked modification, a tracked deletion, and an untracked addition, deduplicated by path", async () => {
       t.seed.commit("chore: seed", { "modme.txt": "orig", "delme.txt": "bye" })

package/src/testkit/InMemRepo.ts

@@ -270,6 +270,13 @@ export class InMemRepo {
     return diffTrees(baseTree, worktreeTree)
   }
 
+  diffPaths(base: string, tip: string): string[] {
+    for (const ref of [base, tip]) {
+      if (this.resolveRef(ref) === null) throw new Error(`Invalid ref: ${ref}`)
+    }
+    return diffTrees(this.treeAt(base), this.treeAt(tip)).map((e) => e.path)
+  }
+
   /** 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)

package/src/testkit/Layers.test.ts

@@ -2,7 +2,8 @@ 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"
+import { ambientFlagEnv, testLayers } from "./Layers.js"
+import { Host } from "../platform/index.js"
 
 // The in-memory `ConfigDiscovery` counterpart walks the SAME root→home chain
 // and looks for the SAME `LEGACY_RC_FILES` as `ConfigDiscovery.Live` — both
@@ -56,3 +57,35 @@ describe("the in-memory ConfigDiscovery counterpart", () => {
     expect(found).toEqual([`${HOME}/${LEGACY_RC_FILES[1]}`])
   })
 })
+
+describe("ambient GTD_FLAG_* reaches the in-memory Host", () => {
+  const hostEnv = (ambient: Record<string, string>, env?: Record<string, string>) => {
+    const before = { ...process.env }
+    Object.assign(process.env, ambient)
+    return Effect.runPromise(
+      Effect.map(Host, (h) => h.env).pipe(
+        Effect.provide(testLayers(new InMemRepo(), env ? { env } : {})),
+        Effect.ensuring(
+          Effect.sync(() => {
+            for (const k of Object.keys(ambient)) {
+              if (before[k] === undefined) delete process.env[k]
+              else process.env[k] = before[k]
+            }
+          }),
+        ),
+      ),
+    )
+  }
+
+  it("carries the ambient flag, and explicit env wins", async () => {
+    expect((await hostEnv({ GTD_FLAG_ALPHA: "1" }))["GTD_FLAG_ALPHA"]).toBe("1")
+    const env = await hostEnv({ GTD_FLAG_ALPHA: "1" }, { GTD_FLAG_ALPHA: "0" })
+    expect(env["GTD_FLAG_ALPHA"]).toBe("0")
+  })
+
+  it("picks only GTD_FLAG_* keys", () => {
+    expect(ambientFlagEnv({ GTD_FLAG_X: "1", PATH: "/bin", GTD_FLAG_U: undefined })).toEqual({
+      GTD_FLAG_X: "1",
+    })
+  })
+})

package/src/testkit/Layers.ts

@@ -216,6 +216,21 @@ const missingToolCommands: ToolCommands["Type"] = {
 export const gitTestLayer = (repo: InMemRepo, root = "/repo"): Layer.Layer<GitService> =>
   Layer.succeed(GitService, fakeGitOperations(repo, root))
 
+/**
+ * The one sanctioned leak of the real `process.env` into the in-memory `Host`:
+ * the runner's `GTD_FLAG_*` state, so a flag-on `npm test` state exercises the
+ * flag in memory as it does live. A test asserting one flag side sets the flag
+ * itself; explicit env wins.
+ */
+export const ambientFlagEnv = (
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(env).filter(
+      (e): e is [string, string] => e[0].startsWith("GTD_FLAG_") && e[1] !== undefined,
+    ),
+  )
+
 /** Every layer `makeProgram` needs — `CommandRequirements`'s return type here IS the guarantee: a new port added there fails this function's typecheck instead of silently under-providing. */
 export function testLayers(
   repo: InMemRepo,
@@ -231,7 +246,12 @@ export function testLayers(
     // symlinks against): both sides of `assertRunningFromRepoRoot`'s
     // comparison collapse to `root` when given anything, exactly like the
     // fake's `root` "resolving" to itself before this port existed.
-    Host.layer({ root, home, env: opts.env ?? {}, realPath: () => Effect.succeed(root) }),
+    Host.layer({
+      root,
+      home,
+      env: { ...ambientFlagEnv(), ...opts.env },
+      realPath: () => Effect.succeed(root),
+    }),
     ConfigService.Live,
     makeInMemoryConfigDiscovery(repo, root),
     Narrator.layer(opts.narrate ?? (() => {}), opts.verbose ?? true),

package/src/testkit/TestRepo.ts

@@ -19,7 +19,7 @@ export interface TestRepoOptions {
   readonly workflow: WorkflowModule
   /** Committed alongside the config, before any process starts. */
   readonly files?: Readonly<Record<string, string>>
-  /** The environment gtd sees; the real `process.env` is never read. */
+  /** The environment gtd sees; the real `process.env` is never read, except ambient `GTD_FLAG_*` (explicit env wins). */
   readonly env?: Readonly<Record<string, string>>
 }
 

package/src/wire/ExitCodes.test.ts

@@ -5,16 +5,24 @@ import {
   EXIT_RUNTIME_ERROR,
   EXIT_SIGINT,
   EXIT_SIGTERM,
+  EXIT_STRAYS_FOUND,
   EXIT_USAGE_ERROR,
 } from "./index.js"
 
 describe("EXIT_CODES", () => {
-  it("is frozen at exactly {0, 1, 2, 130, 143} — a new code breaks every driver", () => {
-    expect(EXIT_CODES).toEqual(new Set([0, 1, 2, 130, 143]))
+  it("is frozen at exactly {0, 1, 2, 10, 130, 143} — a new code breaks every driver", () => {
+    expect(EXIT_CODES).toEqual(new Set([0, 1, 2, 10, 130, 143]))
   })
 
   it("each named constant is a member of the set", () => {
-    for (const code of [EXIT_OK, EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR, EXIT_SIGINT, EXIT_SIGTERM]) {
+    for (const code of [
+      EXIT_OK,
+      EXIT_RUNTIME_ERROR,
+      EXIT_USAGE_ERROR,
+      EXIT_STRAYS_FOUND,
+      EXIT_SIGINT,
+      EXIT_SIGTERM,
+    ]) {
       expect(EXIT_CODES.has(code)).toBe(true)
     }
   })

package/src/wire/ExitCodes.ts

@@ -3,6 +3,8 @@ export const EXIT_OK = 0
 export const EXIT_RUNTIME_ERROR = 1
 /** gtd was invoked wrong — an unknown option/command, bad arity, a scope violation, a decode failure. */
 export const EXIT_USAGE_ERROR = 2
+/** `gtd strays` found touched paths outside the allowlist — that command's only, and it carries no other meaning. */
+export const EXIT_STRAYS_FOUND = 10
 export const EXIT_SIGINT = 130
 export const EXIT_SIGTERM = 143
 
@@ -11,6 +13,7 @@ export const EXIT_CODES: ReadonlySet<number> = new Set([
   EXIT_OK,
   EXIT_RUNTIME_ERROR,
   EXIT_USAGE_ERROR,
+  EXIT_STRAYS_FOUND,
   EXIT_SIGINT,
   EXIT_SIGTERM,
 ])

package/src/wire/Glob.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest"
+import { globMatches } from "./Glob.js"
+
+describe("globMatches", () => {
+  it("`*` stays within one segment; `**` crosses segments, zero included", () => {
+    expect(globMatches("a.md", "*.md")).toBe(true)
+    expect(globMatches("docs/a.md", "*.md")).toBe(false)
+    expect(globMatches("src/x/y/a.ts", "src/**")).toBe(true)
+    expect(globMatches("a.ts", "**/a.ts")).toBe(true)
+    expect(globMatches("x/a.ts", "**/a.ts")).toBe(true)
+  })
+
+  it("dotfiles match `*` and `**` like any other path", () => {
+    expect(globMatches(".env", "*")).toBe(true)
+    expect(globMatches("dir/.hidden", "dir/*")).toBe(true)
+    expect(globMatches(".github/ci.yml", "**")).toBe(true)
+    expect(globMatches(".github/ci.yml", "*")).toBe(false)
+  })
+
+  it("matches case-sensitively", () => {
+    expect(globMatches("README.md", "readme.md")).toBe(false)
+  })
+
+  it("`?` and `[` are literal", () => {
+    expect(globMatches("a?.txt", "a?.txt")).toBe(true)
+    expect(globMatches("ab.txt", "a?.txt")).toBe(false)
+    expect(globMatches("[a].txt", "[a].txt")).toBe(true)
+    expect(globMatches("a.txt", "[a].txt")).toBe(false)
+  })
+
+  it("`**` crosses a path containing a line break", () => {
+    expect(globMatches("weird\nname.txt", "**")).toBe(true)
+    expect(globMatches("d/a\nb", "d/**")).toBe(true)
+  })
+})

package/src/wire/Glob.ts

@@ -23,7 +23,7 @@ const compile = (glob: string): RegExp => {
       i += 2
     }
   }
-  return new RegExp(`${pattern}$`)
+  return new RegExp(`${pattern}$`, "s")
 }
 
 export const globMatches = (path: string, glob: string): boolean => compile(glob).test(path)