@pmelab/gtd 59.0.1 → 60.1.0

package/src/gherkin/messages.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert"
-import type { TestRepo } from "../testkit/index.js"
+import type { BeatDocument, TestRepo } from "../testkit/index.js"
 
 const CONTENT_LINES = 5
 const SUBJECTS = 5
@@ -22,10 +22,19 @@ const beatLines = async (repo: TestRepo): Promise<string[]> => {
   }
 }
 
+/** A scripted step no drive reached, and whether a Background or the scenario scripted it. */
+export interface Unreached {
+  readonly step: string
+  readonly origin: "Background" | "scenario"
+}
+
+export const unreachedList = (steps: readonly Unreached[]): string =>
+  steps.map(({ step, origin }) => `"${step}" (${origin})`).join(", ")
+
 /** Where the process rests, for a failed outcome to end with. Never throws: it describes a failure. */
 export const restDescription = async (
   repo: () => TestRepo,
-  neverUsed: readonly string[],
+  neverUsed: readonly Unreached[],
 ): Promise<string> => {
   let lines: string[]
   try {
@@ -41,8 +50,7 @@ export const restDescription = async (
   } catch (error) {
     lines = [`unknown — ${reason(error)}`]
   }
-  if (neverUsed.length > 0)
-    lines.push(`actors never used: ${neverUsed.map((step) => `"${step}"`).join(", ")}`)
+  if (neverUsed.length > 0) lines.push(`actors never used: ${unreachedList(neverUsed)}`)
   return ["where the process rests:", ...lines.map((line) => `  ${line}`)].join("\n")
 }
 
@@ -82,3 +90,12 @@ export const assertLacks = (where: string, text: string, content: string | undef
   if (content === undefined || content.includes(text))
     assert.fail(containsFailure(where, text, content, false))
 }
+
+/** A rest at `step`; a stall there is no rest, so it points to the step that asserts one. */
+export const assertRestsAt = (beat: BeatDocument, step: string): void => {
+  if (beat.kind === "stalled")
+    assert.fail(
+      `expected a rest at "${step}", but the process stalls at "${beat.state}" — assert a stall with: the process stalls at "${beat.state}"`,
+    )
+  assert.strictEqual(beat.state, step)
+}

package/src/gherkin/more-steps.feature

@@ -0,0 +1,170 @@
+@inmem
+Feature: steps for checks, stalls, beat fields, commit bodies and the environment
+
+  Background:
+    Given a gtd config with:
+      """
+      import { agent, check, envSettings, human, scope, settings, workflow } from "@pmelab/gtd/flows"
+
+      const defaults = { title: "untitled" }
+      const envDefaults = { greeting: "hi" }
+
+      export const tested = workflow(async () => {
+        await scope({ name: "build", skills: ["tdd", "review"] }, async () => {
+          await agent("plan", "Plan.", { model: "smart" })
+        })
+        const green = await check("test", "npm test", ".gtd/FEEDBACK.md")
+        await agent(green ? "ship" : "repair", `Say ${envSettings.greeting} to ${settings.title}.`)
+        await human("done")
+      }, { defaults, envDefaults })
+
+      export default tested
+      """
+
+  Scenario: the resting step's fields are read by name
+    When gtd starts workflow "tested"
+    Then the process rests at "build.plan"
+    And the resting step's model is "smart"
+    And the resting step's idle is "false"
+    And the resting step's skills includes "review"
+    And the resting step's content includes "Plan"
+
+  Scenario: a quoted argument keeps its spaces
+    Given step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" passes
+    When gtd starts workflow "tested" with "--var 'title=a calculator'"
+    And the process is driven
+    Then the resting step's content contains "Say hi to a calculator."
+
+  Scenario: an agent step that changes nothing stalls
+    Given step "build.plan" changes nothing
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process stalls at "build.plan"
+
+  Scenario: a passing check step goes on, and a variable changed mid-process is seen from then on
+    Given step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" passes
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "ship"
+    And the resting step's content contains "Say hi to untitled."
+    Given from now on the environment variable "GTD_GREETING" is "hello"
+    Then the resting step's content contains "Say hello to untitled."
+
+  Scenario: a failing check step writes its report
+    Given the environment variable "GTD_GREETING" is "hey"
+    And step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" fails with:
+      """
+      1 test failing
+      """
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "repair"
+    And ".gtd/FEEDBACK.md" contains "1 test failing"
+    And the resting step's content contains "Say hey to untitled."
+
+  Scenario: a check step scripted at a step that is no check refuses the drive
+    Given check step "build.plan" passes
+    When gtd starts workflow "tested"
+    Then driving the process is refused with 'step "build.plan" is no check step; its actor is agent'
+
+  Scenario: commit bodies are read whole, every commit of a subject at once
+    Given the working tree is committed with the message:
+      """
+      chore: seed
+
+      Seeded by hand.
+
+      Refs: #1
+      """
+    And step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" passes
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the last commit body contains "Gtd-Step: test#1"
+    And the commit "gtd(agent): build.plan → test" has a body containing "Gtd-Step: build.plan#1"
+    And the commit "chore: seed" has a body containing "Seeded by hand."
+    And no commit body contains "never written"
+
+  Scenario: a canned command matched by pattern, a branch at a ref, and a file as committed there
+    Given a file "a.txt" with:
+      """
+      one
+      """
+    And the working tree is committed as "chore: one"
+    And a file "a.txt" with:
+      """
+      two
+      """
+    And the working tree is committed as "chore: two"
+    And a branch "old" at "HEAD~1"
+    And the command matching "^npm (test|run)" exits 1 with:
+      """
+      red
+      """
+    And step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "test" runs its script
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "repair"
+    And "a.txt" as committed at "old" contains "one"
+    And ".gtd/FEEDBACK.md" contains "red"
+
+  Scenario: text is appended to a file, and a step overwrites one only if it exists
+    Given a file "NOTES.md" with:
+      """
+      first
+      """
+    And text is appended to "NOTES.md":
+      """
+      second
+      """
+    And step "build.plan" overwrites "PLAN.md", if it exists, with:
+      """
+      never written
+      """
+    And step "build.plan" overwrites "NOTES.md", if it exists, with:
+      """
+      rewritten
+      """
+    And step "test" runs its script
+    And the command "npm test" exits 0
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "ship"
+    And "NOTES.md" contains "rewritten"
+    And "PLAN.md" does not exist
+
+  Scenario: a config given as source imports a module the scenario names
+    Given the module "src/gherkin/tiny.fixture.ts" is importable as "#workflow"
+    And a gtd config with:
+      """
+      export { tiny, tiny as default } from "#workflow"
+      """
+    And a file "IDEA.md" with:
+      """
+      a calculator
+      """
+    And step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When the process is driven
+    Then the process rests at "sign-off"

package/src/gherkin/scenario-end.feature

@@ -0,0 +1,101 @@
+@inmem
+Feature: a scenario's scripted steps must be reached by its end, not by every drive
+
+  Background:
+    Given a gtd config with:
+      """
+      import { agent, human, workflow } from "@pmelab/gtd/flows"
+
+      export const shipping = workflow(async () => {
+        await agent("plan", "Write PLAN.md.")
+        await human("sign-off")
+        await agent("ship", "Ship it.")
+        await human("done")
+      })
+
+      export default shipping
+      """
+    And step "ship" writes "SHIPPED.md" with:
+      """
+      shipped
+      """
+
+  Scenario: an actor the Background scripts, reached only by the second drive, passes
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven
+    Then the process rests at "sign-off"
+    Given step "sign-off" writes "SIGNED.md" with:
+      """
+      signed
+      """
+    When the process is driven
+    Then the process rests at "done"
+    And "SHIPPED.md" contains "shipped"
+
+  Scenario: an actor the Background scripts may go unreached in a scenario another scenario reaches it in
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven
+    Then the process rests at "sign-off"
+
+  @fails
+  Scenario: an actor the scenario scripts that no drive reaches fails it at its end
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "done" writes "DONE.md" with:
+      """
+      done
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven
+    Then the process rests at "sign-off"
+
+  @fails
+  Scenario: a lenient drive leaves an actor no drive reaches to fail the scenario at its end
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "done" writes "DONE.md" with:
+      """
+      done
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven leniently
+    Then the process rests at "sign-off"
+
+  Scenario: a refused drive excuses the actors it was handed
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "sign-off" changes nothing
+    And step "done" writes "DONE.md" with:
+      """
+      done
+      """
+    When gtd starts workflow "shipping"
+    Then driving the process is refused with 'the actor for human step "sign-off" changed nothing'
+
+  @fails
+  Scenario: an actor scripted after a refused drive, and reached by no later one, fails the scenario
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "sign-off" changes nothing
+    When gtd starts workflow "shipping"
+    Then driving the process is refused with 'the actor for human step "sign-off" changed nothing'
+    Given step "done" writes "DONE.md" with:
+      """
+      done
+      """

package/src/gherkin/testkit.feature

@@ -7,9 +7,9 @@ Feature: testkit drives any workflow against the real engine
   Background:
     Given a gtd config with:
       """
-      import { agent, human, judge, read, refuse, run } from "@pmelab/gtd/flows"
+      import { agent, human, judge, read, refuse, run, workflow } from "@pmelab/gtd/flows"
 
-      export const tiny = async () => {
+      export const tiny = workflow(async () => {
         await agent("plan", "Write PLAN.md.")
         await run("check", "npm test > .gtd/FEEDBACK.md 2>&1 && rm .gtd/FEEDBACK.md")
         if (read(".gtd/FEEDBACK.md") !== undefined) await agent("repair", "Make the suite pass.")
@@ -18,11 +18,11 @@ Feature: testkit drives any workflow against the real engine
           evidence: { plan: read("PLAN.md") ?? "" },
         })
         await human(answers.ready?.answer === "yes" ? "ship" : "rework")
-      }
+      })
 
-      export const picky = async () => {
+      export const picky = workflow(async () => {
         refuse("gtd: picky refuses every start")
-      }
+      })
 
       export default tiny
       """
@@ -83,9 +83,12 @@ Feature: testkit drives any workflow against the real engine
     And "PLAN.md" contains "add two numbers"
 
   Scenario: a judge step with queued actions refuses the drive
-    Given step "plan" changes nothing
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
     And step "check" changes nothing
-    And step "ready" is prompted with "never seen"
+    And step "ready" changes nothing
     And judge step "ready" answers:
       """
       [{ "id": "ready", "answer": true, "p": 0.9 }]
@@ -98,6 +101,79 @@ Feature: testkit drives any workflow against the real engine
     When gtd starts workflow "tiny"
     Then driving the process is refused with 'was not prompted with "Write a poem"'
 
+  Scenario: a step only asserted to be prompted is where the drive rests, and nothing lands there
+    Given step "plan" is prompted with "Write PLAN.md."
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "plan"
+    And the last commit subject is "gtd(human): plan"
+
+  Scenario: a prompt asserted beside a script is checked at every visit, before the step acts
+    Given step "check" is prompted with "npm test"
+    And step "check" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test failing
+      """
+    And step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "repair"
+
+  @fails
+  Scenario: a prompt asserted at a step no drive reaches fails the scenario at its end
+    Given step "plan" changes nothing
+    And step "repair" is prompted with "Make the suite pass."
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process stalls at "plan"
+
+  Scenario: a human step scripted to change nothing refuses the drive instead of repeating it
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "check" changes nothing
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": true, "p": 0.9 }]
+      """
+    And step "ship" changes nothing
+    When gtd starts workflow "tiny"
+    Then driving the process is refused with 'the actor for human step "ship" changed nothing'
+
+  Scenario: a lenient drive rests at an unscripted check step
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven leniently
+    Then the process rests at "check"
+    And the resting step's content contains "npm test"
+
+  Scenario: a step scripted for a later drive counts once any drive reached it
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "check" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test failing
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "repair"
+    Given step "repair" deletes ".gtd/FEEDBACK.md"
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": false, "p": 0.9 }]
+      """
+    When the process is driven
+    Then the process rests at "rework"
+
   Scenario: a start the workflow refuses is reported with its message
     Then starting workflow "picky" with "--var mode=bad" is refused with "picky refuses every start"
 

package/src/install/Install.test.ts

@@ -164,8 +164,8 @@ describe("renderBriefing", () => {
 
   it("contains the door invocation, exec'ing the loop", () => {
     const briefing = renderBriefing()
-    expect(briefing).toContain('gtd door "$@"')
-    expect(briefing).toContain("gtd doors")
+    expect(briefing).toContain('gtd start "$@"')
+    expect(briefing).toMatch(/bare `gtd start` lists/i)
     expect(briefing).toMatch(/exec.{0,20}GTD_BUILD/s)
   })
 
@@ -418,19 +418,19 @@ describe("DOOR_COMMAND", () => {
 
   it("cds to the repository root before any gtd call", () => {
     const cdIndex = DOOR_COMMAND.indexOf('cd "$(git rev-parse --show-toplevel)"')
-    const gtdIndex = DOOR_COMMAND.indexOf("gtd door")
+    const gtdIndex = DOOR_COMMAND.indexOf("gtd start")
     expect(cdIndex).toBeGreaterThan(-1)
     expect(gtdIndex).toBeGreaterThan(cdIndex)
   })
 
-  it("hands every argument to gtd door", () => {
-    expect(DOOR_COMMAND).toContain('gtd door "$@"')
+  it("hands every argument to gtd start", () => {
+    expect(DOOR_COMMAND).toContain('gtd start "$@"')
   })
 
   it("captures the emitted script via command substitution, never a pipe into sh", () => {
-    expect(DOOR_COMMAND).toContain('script="$(gtd door "$@")"')
+    expect(DOOR_COMMAND).toContain('script="$(gtd start "$@")"')
     expect(DOOR_COMMAND).toContain('sh -c "$script"')
-    expect(DOOR_COMMAND).not.toMatch(/gtd door[^\n]*\|\s*sh/)
+    expect(DOOR_COMMAND).not.toMatch(/gtd start[^\n]*\|\s*sh/)
   })
 
   it("prints usage to stderr and exits 2 when no name is given", () => {

package/src/install/Install.ts

@@ -175,7 +175,7 @@ if [ -z "\${1:-}" ]; then
   exit 2
 fi
 cd "$(git rev-parse --show-toplevel)"
-script="$(gtd door "$@")"
+script="$(gtd start "$@")"
 sh -c "$script"
 exec "$GTD_BUILD"`
 
@@ -365,7 +365,7 @@ const DRIVER_OBLIGATIONS = `
     \`--json=judge\`, pipes that rendered \`{ schema, state, questions }\` document to a
     judge model, and pipes ITS verdict (one \`{ id, answer, p }\` per pending
     question, as JSON on stdin) to \`gtd judge answer\` — the FIFTH command
-    that changes anything, alongside \`gtd land\`/\`gtd --workflow\`/\`gtd
+    that changes anything, alongside \`gtd land\`/\`gtd start\`/\`gtd
     abandon\`/\`gtd restore\`. It follows the exact same required-half /
     optional-half script contract as \`gtd land\` in obligation 8 above:
     read \`--json=script\` (and, if you want them, \`--json=settled\`/
@@ -565,9 +565,9 @@ ${EDIT_COMMAND}
 
 ### \`gtd-door <name> [args...]\` — start a process through a door and drive it
 
-Runs \`gtd door <name> [args...]\`, captured by command substitution — never a
+Runs \`gtd start <name> [args...]\`, captured by command substitution — never a
 pipe: a pipeline reports only its LAST command's exit status, so
-\`gtd door ... | sh\` under \`set -e\` would sail past a refusal and \`exec\` a
+\`gtd start ... | sh\` under \`set -e\` would sail past a refusal and \`exec\` a
 loop over a process that was never started. It runs the captured script, then
 \`exec\`s the suite's RESOLVED \`gtd-build\` path — never the literal string
 \`gtd-build\`. This is one invocation that carries the process all the way to
@@ -575,9 +575,9 @@ its next human gate, not just a starter: \`gtd-door review\` on a RED baseline
 hands off to \`gtd-build\`, which halts at the blocked gate and prints it,
 rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
-\`gtd doors\` lists the doors a repository offers (those of the workflows its
-config exports — gtd-workflows' \`default\` brings \`fix\` and
-\`review [base]\` — plus any the config declares). Refuses with
+A bare \`gtd start\` lists what a repository can start: its workflows, and
+the doors those workflows bring (gtd-workflows' \`default\` brings \`fix\`
+and \`review [base]\`) plus any the config declares. Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 
@@ -682,7 +682,7 @@ const PREREQUISITES = `
 ## Prerequisites and portability
 
 - A POSIX \`sh\` (dash, ash, bash's own POSIX mode, etc.) — gtd's own emitted
-  scripts (\`gtd land --json=script\`, \`gtd --workflow <name>\`, \`gtd abandon\`,
+  scripts (\`gtd land --json=script\`, \`gtd start <name>\`, \`gtd abandon\`,
   \`gtd restore\`, \`gtd judge answer --json=script\`) are POSIX sh; captured,
   then piped into it (see obligation 8 above). Reading
   \`gtd next --json=<path>\`/\`gtd land --json=<path>\`'s own output needs

package/src/install/Version.ts

@@ -22,6 +22,12 @@ const findPackageJson = (fromUrl: string): string => {
   throw new Error(`package.json not found by walking up from ${fromUrl}`)
 }
 
-export const GTD_VERSION: string = (
-  _require(findPackageJson(import.meta.url)) as { version: string }
-).version
+/** The global a pin's workflow registers itself under, ahead of the engine in the same file. */
+export const PIN_KEY = Symbol.for("@pmelab/gtd/pin")
+
+// Inside a pin, `import.meta.url` is the pin's own file, in the user's
+// repository: the pin registered the version it was built by before this runs.
+const pinned = (globalThis as { [PIN_KEY]?: { readonly version: string } })[PIN_KEY]?.version
+
+export const GTD_VERSION: string =
+  pinned ?? (_require(findPackageJson(import.meta.url)) as { version: string }).version

package/src/install/index.ts

@@ -1,2 +1,2 @@
 export { renderBriefing, WORKFLOWS_REPO } from "./Install.js"
-export { GTD_VERSION } from "./Version.js"
+export { GTD_VERSION, PIN_KEY } from "./Version.js"

package/src/platform/CommandRunner.ts

@@ -1,5 +1,5 @@
-import { Command, CommandExecutor } from "@effect/platform"
 import { Context, Effect, Layer, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/process"
 import { Host } from "./Host.js"
 
 /** One command run's outcome: its exit status (a signal death reported as `null`, matching `spawnSync`) and its combined output (stdout then stderr). */
@@ -23,13 +23,13 @@ interface CommandOutcome {
  * stdout/stderr, none of which this port's single-shot "run to completion"
  * shape supports.
  */
-export class CommandRunner extends Context.Tag("CommandRunner")<
+export class CommandRunner extends Context.Service<
   CommandRunner,
   {
     /** A SPAWN failure (no `bash`, unreadable cwd) fails the Effect; a non-zero EXIT is a value — how a mode command reports "invalid"/"broken" for the caller to interpret. */
     readonly bash: (command: string) => Effect.Effect<CommandOutcome, Error>
   }
->() {
+>()("CommandRunner") {
   /** A test layer over a canned `bash` implementation — no subprocess. */
   static readonly layer = (
     bash: (command: string) => Effect.Effect<CommandOutcome, Error>,
@@ -39,17 +39,19 @@ export class CommandRunner extends Context.Tag("CommandRunner")<
     CommandRunner,
     Effect.gen(function* () {
       const { root } = yield* Host
-      const executor = yield* CommandExecutor.CommandExecutor
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
       return {
         bash: (command: string) =>
           Effect.scoped(
             Effect.gen(function* () {
-              const process = yield* executor.start(
-                Command.make("bash", "-c", command).pipe(
-                  Command.workingDirectory(root),
-                  Command.stdout("pipe"),
-                  Command.stderr("pipe"),
-                ),
+              const process = yield* spawner.spawn(
+                ChildProcess.make("bash", ["-c", command], {
+                  cwd: root,
+                  stdout: "pipe",
+                  stderr: "pipe",
+                  // Not detached, like `Git.ts`'s `run`: a background job the command starts survives it.
+                  detached: false,
+                }),
               )
               const collect = (stream: typeof process.stdout) =>
                 stream.pipe(Stream.decodeText(), Stream.mkString)
@@ -60,7 +62,7 @@ export class CommandRunner extends Context.Tag("CommandRunner")<
                   // A signal death fails process.exitCode; map to null to match spawnSync's contract.
                   process.exitCode.pipe(
                     Effect.map((code): number | null => code),
-                    Effect.catchAll(() => Effect.succeed(null)),
+                    Effect.catch(() => Effect.succeed(null)),
                   ),
                 ],
                 { concurrency: "unbounded" },

package/src/platform/Commentary.ts

@@ -5,13 +5,13 @@ import { Context, Effect, Layer } from "effect"
  * layer was built, never by the call site; `warn` is its ungated
  * counterpart, always written regardless of verbosity.
  */
-export class Narrator extends Context.Tag("Narrator")<
+export class Narrator extends Context.Service<
   Narrator,
   {
     readonly narrate: (line: string) => Effect.Effect<void>
     readonly warn: (line: string) => Effect.Effect<void>
   }
->() {
+>()("Narrator") {
   /**
    * `write` is the raw stderr sink (`CliIo.stderr` in production, so the
    * in-memory `CliIo` used by `@inmem` e2e scenarios captures narration into

package/src/platform/Git.test.ts

@@ -2,11 +2,10 @@ import { execFileSync } from "node:child_process"
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
-import { NodeContext } from "@effect/platform-node"
 import { Cause, Effect, Exit, Option } from "effect"
 import { describe, expect, it } from "vitest"
 import { GitService, InvalidRefError, resolvedRefOrCorrupted } from "./Git.js"
-import { Host } from "./index.js"
+import { Host, NodeServices } from "./index.js"
 import { gitTiers, runGitServiceContract, runGitScriptContract } from "../twins/index.js"
 
 /**
@@ -78,7 +77,7 @@ describe("diffPaths [Live]", () => {
         Effect.flatMap(GitService, (g) => g.diffPaths(base, tip)).pipe(
           Effect.provide(GitService.Live),
           Effect.provide(Host.layer({ root: join(root, "sub"), home: root, env: {} })),
-          Effect.provide(NodeContext.layer),
+          Effect.provide(NodeServices.layer),
         ),
       )
       expect([...paths].sort()).toEqual(["sub/a.txt", "top.txt"])
@@ -131,7 +130,7 @@ describe("diffPaths [Live]", () => {
         Effect.flatMap(GitService, (g) => g.diffPaths(base, tip)).pipe(
           Effect.provide(GitService.Live),
           Effect.provide(Host.layer({ root: repo, home: root, env: {} })),
-          Effect.provide(NodeContext.layer),
+          Effect.provide(NodeServices.layer),
         ),
       )
       expect([...paths]).toEqual(["sub"])
@@ -155,7 +154,7 @@ describe("authorIdent [Live]", () => {
         Effect.flatMap(GitService, (g) => g.authorIdent()).pipe(
           Effect.provide(GitService.Live),
           Effect.provide(Host.layer({ root, home: root, env: {} })),
-          Effect.provide(NodeContext.layer),
+          Effect.provide(NodeServices.layer),
         ),
       )
       expect(Option.isNone(ident)).toBe(true)