@pmelab/gtd 60.0.0 → 60.1.0

package/src/platform/WorktreeState.test.ts

@@ -12,10 +12,9 @@ import { mkdtempSync, realpathSync } from "node:fs"
 import { execSync } from "node:child_process"
 import { tmpdir } from "node:os"
 import { Effect, Layer } from "effect"
-import { NodeContext } from "@effect/platform-node"
 import { describe, expect, it } from "vitest"
 import { loopLogPath, worktreeGitDir } from "./WorktreeState.js"
-import { GitService, Host, Workspace } from "./index.js"
+import { GitService, Host, Workspace, NodeServices } from "./index.js"
 import { InMemRepo, testLayers } from "../twins/index.js"
 
 const provide = <A>(
@@ -112,7 +111,7 @@ describe("worktreeGitDir [real git]", () => {
 
   const runIn = (root: string) => {
     const hostLayer = Host.layer({ root, home: root, env: {} })
-    const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeContext.layer)))
+    const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
     const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
     return Effect.runPromise(
       worktreeGitDir.pipe(Effect.provide(Layer.mergeAll(hostLayer, workspaceLayer))),

package/src/platform/WorktreeState.ts

@@ -17,7 +17,7 @@ export const worktreeGitDir: Effect.Effect<string, never, Host | Workspace> = Ef
     const workspace = yield* Workspace
     const content = yield* workspace
       .read(".git")
-      .pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+      .pipe(Effect.catch(() => Effect.succeed(undefined)))
     const pointer = content === undefined ? null : GITDIR_POINTER.exec(content)
     if (pointer === null) return ".git"
     const gitdir = pointer[1]!.trim()

package/src/platform/index.ts

@@ -4,7 +4,7 @@
  * home, env, scratch). `GitService` moved in alongside `Workspace` since
  * `committed` IS `git.readFileAtRef` — one module owns every read.
  *
- * Seam rule, stated once: a seam is a `Context.Tag` unless the consuming
+ * Seam rule, stated once: a seam is a `Context.Service` unless the consuming
  * code is synchronous, non-Effect code that cannot `yield*` — replay's flow
  * reads are that exception, and use the `*Sync` members.
  */
@@ -19,6 +19,7 @@ export {
 } from "./Git.js"
 export { Narrator, GtdError, GtdUsageError, renderFailure } from "./Commentary.js"
 export { CommandRunner } from "./CommandRunner.js"
+export * as NodeServices from "./NodeServices.js"
 export { loopLogPath } from "./WorktreeState.js"
 export {
   HISTORY_REF,

package/src/step/planStart.ts

@@ -158,11 +158,11 @@ const resolveBase = (
     const git = yield* GitService
     const rendered = value.trim()
     const target = rendered === "" ? yield* git.defaultBranch() : rendered
-    const resolvedBase = yield* Effect.either(git.resolveRef(target))
-    if (resolvedBase._tag === "Left") {
+    const resolvedBase = yield* Effect.result(git.resolveRef(target))
+    if (resolvedBase._tag === "Failure") {
       return refusal(`${commandLabel}: "${target}" does not resolve to a commit`)
     }
-    const mergeBase = yield* git.mergeBase(resolvedBase.right, "HEAD")
+    const mergeBase = yield* git.mergeBase(resolvedBase.success, "HEAD")
     if (Option.isNone(mergeBase)) {
       return refusal(`${commandLabel}: "${target}" shares no common ancestor with HEAD`)
     }

package/src/twins/EmittedScripts.test.ts

@@ -180,7 +180,7 @@ for (const makeTier of gitTiers) {
       // As a landing renders it: under `set -eu`, which a failing update-ref relies on to stop.
       const keepTurn = (ref: string, message: string) =>
         ScriptSurface.render([{ kind: "gitWrite", write: { kind: "keepTurn", ref, message } }])
-      const git = <A>(f: (g: GitService["Type"]) => Effect.Effect<A, Error>) =>
+      const git = <A>(f: (g: GitService["Service"]) => Effect.Effect<A, Error>) =>
         t.provide(Effect.flatMap(GitService, f))
       const keptTip = async () => {
         const marker = await git((g) => g.lastCommitMessage())

package/src/twins/GitTiers.ts

@@ -18,8 +18,7 @@ import { execFileSync, execSync, spawnSync } from "node:child_process"
 // `TEST_DOUBLE_SENTINEL` check.
 import { afterEach, beforeEach, describe, expect, it } from "vitest"
 import { Effect, Exit, Option } from "effect"
-import { NodeContext } from "@effect/platform-node"
-import { Narrator, GitService, Host, type GitOperations } from "../platform/index.js"
+import { Narrator, GitService, Host, type GitOperations, NodeServices } from "../platform/index.js"
 import {
   commitAll,
   commitAsIs,
@@ -165,7 +164,7 @@ const makeLiveTier = (initialCommit = true): GitTier => {
       eff.pipe(
         Effect.provide(GitService.Live),
         Effect.provide(Host.layer({ root, home: root, env: {} })),
-        Effect.provide(NodeContext.layer),
+        Effect.provide(NodeServices.layer),
         Effect.provide(noopNarratorLayer),
       ),
     )
@@ -177,7 +176,7 @@ const makeLiveTier = (initialCommit = true): GitTier => {
       eff.pipe(
         Effect.provide(GitService.Live),
         Effect.provide(Host.layer({ root, home: root, env: {} })),
-        Effect.provide(NodeContext.layer),
+        Effect.provide(NodeServices.layer),
         Effect.provide(noopNarratorLayer),
       ),
     )
@@ -1266,7 +1265,7 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
             Effect.flatMap(GitService, (g) => g.gitDir()).pipe(
               Effect.provide(GitService.Live),
               Effect.provide(Host.layer({ root: siblingDir, home: siblingDir, env: {} })),
-              Effect.provide(NodeContext.layer),
+              Effect.provide(NodeServices.layer),
             ),
           )
           expect(siblingGitDir).not.toBe(mainGitDir)
@@ -1297,14 +1296,14 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
             Effect.flatMap(GitService, (g) => g.gitCommonDir()).pipe(
               Effect.provide(GitService.Live),
               Effect.provide(Host.layer({ root: siblingDir, home: siblingDir, env: {} })),
-              Effect.provide(NodeContext.layer),
+              Effect.provide(NodeServices.layer),
             ),
           )
           const siblingGitDir = await Effect.runPromise(
             Effect.flatMap(GitService, (g) => g.gitDir()).pipe(
               Effect.provide(GitService.Live),
               Effect.provide(Host.layer({ root: siblingDir, home: siblingDir, env: {} })),
-              Effect.provide(NodeContext.layer),
+              Effect.provide(NodeServices.layer),
             ),
           )
           expect(siblingCommonDir).toBe(mainCommonDir)

package/src/twins/Layers.test.ts

@@ -23,7 +23,7 @@ const seed = (repo: InMemRepo, dir: string, name: string, content: string): void
 
 const runDiscovery = <A>(
   repo: InMemRepo,
-  f: (d: ConfigDiscovery["Type"]) => Effect.Effect<A, Error>,
+  f: (d: ConfigDiscovery["Service"]) => Effect.Effect<A, Error>,
 ) =>
   Effect.runPromise(
     Effect.gen(function* () {

package/src/twins/Layers.ts

@@ -21,6 +21,7 @@ import {
 import {
   ConfigDiscovery,
   ConfigService,
+  EngineCore,
   LEGACY_RC_FILES,
   legacyRcDirs,
   WORKFLOW_MODULE,
@@ -30,7 +31,7 @@ import { fakeGitOperations } from "./FakeGitOperations.js"
 import { InMemRepo } from "./InMemRepo.js"
 
 // Read off the CLI's own port rather than imported from the composition root.
-type CommandRequirements = Layer.Layer.Success<ReturnType<CliIo["layers"]>>
+type CommandRequirements = Layer.Success<ReturnType<CliIo["layers"]>>
 import { ToolCommands, type CliIo } from "../cli/index.js"
 
 const toError = (e: unknown): Error => (e instanceof Error ? e : new Error(String(e)))
@@ -167,6 +168,11 @@ const makeInMemoryConfigDiscovery = (
   })
 }
 
+/** The in-memory counterpart to the shipped `gtd.core.mjs`: an ES module that needs nothing but Node. */
+const IN_MEMORY_ENGINE = `#!/usr/bin/env node
+import "node:process"
+`
+
 /** One scripted `bash` command's canned behavior, keyed by the RENDERED command string a scenario's `Given` step declares. */
 export type ScriptedCommand =
   | {
@@ -207,13 +213,13 @@ export interface TestWorldOptions {
   /** Gates `narrate` above — defaults to `true` (fires whenever a sink is given) since these tests aren't exercising `Cli.ts`'s own `--verbose` gate. `src/twins/cliIo.ts` overrides this with the real decoded flag. */
   readonly verbose?: boolean
   /** Real or fake driver and tool commands — each one left out fails when called. */
-  readonly tools?: Partial<ToolCommands["Type"]>
+  readonly tools?: Partial<ToolCommands["Service"]>
 }
 
 const missingTool = (name: string) => () =>
   Effect.fail(new Error(`gtd ${name}: ToolCommands has no test double wired into testLayers()`))
 
-const missingToolCommands: ToolCommands["Type"] = {
+const missingToolCommands: ToolCommands["Service"] = {
   ui: missingTool("ui"),
   lsp: missingTool("lsp"),
   judge: () =>
@@ -264,6 +270,7 @@ export function testLayers(
     }),
     ConfigService.Live,
     makeInMemoryConfigDiscovery(repo, root),
+    Layer.succeed(EngineCore, { source: Effect.succeed(IN_MEMORY_ENGINE) }),
     Narrator.layer(opts.narrate ?? (() => {}), opts.verbose ?? true),
     // Drivers and tools are unit-tested in their own folders; a call reaching
     // one of these is a test gap, not silence. A test opts into one via `tools`.

package/src/twins/cliIo.ts

@@ -4,6 +4,8 @@ import { testLayers } from "./Layers.js"
 
 export interface CapturedCliResult {
   readonly stdout: string
+  /** stdout as written, for a binary artifact `stdout` would decode. */
+  readonly stdoutBytes: Uint8Array
   readonly stderr: string
   readonly exitCode: number
 }
@@ -11,14 +13,14 @@ export interface CapturedCliResult {
 export const makeCapturingCliIo = (
   repo: InMemRepo,
   env: Readonly<Record<string, string | undefined>> = {},
-  tools: Partial<ToolCommands["Type"]> = {},
+  tools: Partial<ToolCommands["Service"]> = {},
 ): { readonly io: CliIo; readonly result: () => CapturedCliResult } => {
-  let stdout = ""
+  let stdout: Buffer = Buffer.alloc(0)
   let stderr = ""
   let exitCode = 0
   const io: CliIo = {
     stdout: (chunk) => {
-      stdout += chunk
+      stdout = Buffer.concat([stdout, Buffer.from(chunk)])
     },
     stderr: (chunk) => {
       stderr += chunk
@@ -32,5 +34,8 @@ export const makeCapturingCliIo = (
     layers: (verbose) =>
       testLayers(repo, { env, narrate: (line) => (stderr += line), verbose, tools }),
   }
-  return { io, result: () => ({ stdout, stderr, exitCode }) }
+  return {
+    io,
+    result: () => ({ stdout: stdout.toString("utf8"), stdoutBytes: stdout, stderr, exitCode }),
+  }
 }

package/src/workflow/discovery.test.ts

@@ -2,15 +2,14 @@ import { execSync } from "node:child_process"
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { dirname, join } from "node:path"
-import { NodeContext } from "@effect/platform-node"
 import { Effect, Layer } from "effect"
 import { afterEach, describe, expect, it } from "vitest"
-import { GitService, Host, Narrator, Workspace } from "../platform/index.js"
+import { GitService, Host, Narrator, Workspace, NodeServices } from "../platform/index.js"
 import { InMemRepo, testLayers } from "../twins/index.js"
 import { ConfigDiscovery, ConfigService } from "./index.js"
 
 // A config and the local modules it imports load the same from disk, where
-// jiti resolves them, and from an in-memory discovery, where the loader
+// rolldown resolves them, and from an in-memory discovery, where the loader
 // resolves them itself — the same workflows, the same fingerprint, the same
 // failure for a module that is not there.
 type Files = Readonly<Record<string, string>>
@@ -63,7 +62,7 @@ const live = (): Tier => {
         writeFileSync(join(root, path), content)
       }
       const host = Host.layer({ root, home: root, env: {} })
-      const git = GitService.Live.pipe(Layer.provide(Layer.merge(host, NodeContext.layer)))
+      const git = GitService.Live.pipe(Layer.provide(Layer.merge(host, NodeServices.layer)))
       const workspace = Workspace.Live.pipe(Layer.provide(Layer.merge(host, git)))
       return loadWith(
         Layer.mergeAll(
@@ -121,7 +120,24 @@ for (const make of [live, inMemory]) {
       })
     })
 
-    it("leaves a specifier in a string alone, and loads a skipped require never", async () => {
+    it("imports a local module and a gtd subpath dynamically as the flow runs", async () => {
+      t = make()
+      const loaded = await t.load({
+        "gtd.config.ts": [
+          'import { human } from "@pmelab/gtd/flows"',
+          "export default async () => {",
+          '  const { WIRE_SCHEMA } = await import("@pmelab/gtd/wire")',
+          '  const { first } = await import("./first.js")',
+          "  await human(`${first}-${WIRE_SCHEMA}`)",
+          "}",
+          "",
+        ].join("\n"),
+        "first.ts": 'export const first = "idle"\n',
+      })
+      expect(Object.keys(loaded.fingerprint).sort()).toEqual(["first.ts", "gtd.config.ts"])
+    })
+
+    it("leaves a specifier in a string alone, and runs a skipped require never", async () => {
       t = make()
       const loaded = await t.load({
         "gtd.config.ts": config(
@@ -134,14 +150,15 @@ for (const make of [live, inMemory]) {
         "optional.ts": 'throw new Error("optional ran")\n',
       })
       expect(loaded.names).toEqual(["named"])
-      expect(Object.keys(loaded.fingerprint)).toEqual(["gtd.config.ts"])
+      // Bundled, so watched, though it never runs.
+      expect(Object.keys(loaded.fingerprint).sort()).toEqual(["gtd.config.ts", "optional.ts"])
     })
 
     it("fails on an import that is not there, naming it", async () => {
       t = make()
       await expect(
         t.load({ "gtd.config.ts": config('import { brief } from "./missing.js"') }),
-      ).rejects.toThrow(/Cannot find module '\.\/missing\.js'/)
+      ).rejects.toThrow(/Could not resolve '\.\/missing\.js'/)
     })
   })
 }

package/src/workflow/discovery.ts

@@ -110,18 +110,17 @@ const workflowModule = (
   })
 
 /**
- * The discovery seam — a `Context.Tag`, not part of `WorkflowFiles` (that
+ * The discovery seam — a `Context.Service`, not part of `WorkflowFiles` (that
  * port is a plain sync record for `compileWorkflow`'s own content-file-ref
  * reads; discovery is effectful and environment-dependent: `.Live` reads
  * REAL disk, so an `@inmem` scenario's fake
  * `Workspace` — a pure in-memory `Map`, no real files anywhere on disk —
  * cannot back it. `src/twins/Layers.ts` provides the in-memory
  * counterpart instead, mirroring how `Workspace`/`Host`/`GitService` already
- * each have a production and a fake layer behind one Tag.
+ * each have a production and a fake layer behind one service.
  */
-export class ConfigDiscovery extends Context.Tag("ConfigDiscovery")<
-  ConfigDiscovery,
-  ConfigDiscoveryOps
->() {
+export class ConfigDiscovery extends Context.Service<ConfigDiscovery, ConfigDiscoveryOps>()(
+  "ConfigDiscovery",
+) {
   static Live = Layer.succeed(ConfigDiscovery, { legacyRcFiles, workflowModule })
 }

package/src/workflow/index.ts

@@ -34,3 +34,4 @@ export {
   type StateName,
 } from "./Workflow.js"
 export { changedConfigFiles, contentHash, type ConfigFingerprint } from "./fingerprint.js"
+export { EngineCore, pin, readPin } from "./pin.js"

package/src/workflow/load.test.ts

@@ -4,8 +4,7 @@ import { join } from "node:path"
 import { tmpdir } from "node:os"
 import { afterEach, beforeEach, describe, expect, it } from "vitest"
 import { Cause, Effect, Exit, Layer } from "effect"
-import { NodeContext } from "@effect/platform-node"
-import { Narrator, GitService, Host, Workspace } from "../platform/index.js"
+import { Narrator, GitService, Host, Workspace, NodeServices } from "../platform/index.js"
 import {
   ConfigDiscovery,
   ConfigService,
@@ -23,7 +22,7 @@ type Env = Readonly<Record<string, string>>
 
 const baseLayer = (dir: string, env: Env = {}) => {
   const hostLayer = Host.layer({ root: dir, home: homeDir, env })
-  const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeContext.layer)))
+  const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
   const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
   return Layer.mergeAll(hostLayer, gitLayer, workspaceLayer)
 }
@@ -442,6 +441,64 @@ describe("ConfigService", () => {
     expect(Object.keys(cfg.fingerprint).sort()).toEqual(["gtd.config.ts", "steps.ts"])
   })
 
+  it("an ES module package gets the shipped gtd, a CommonJS one stays Node's, each module keeps its location", async () => {
+    const vendor = join(projectDir, "vendor", "wf")
+    const pkg = (name: string, manifest: object, file: string, source: string) => {
+      const dir = join(vendor, "node_modules", name)
+      mkdirSync(dir, { recursive: true })
+      writeFileSync(join(dir, "package.json"), JSON.stringify({ name, ...manifest }))
+      writeFileSync(join(dir, file), source)
+    }
+    // No @pmelab/gtd installed: only the shipped copy can serve this import.
+    pkg(
+      "dep",
+      { type: "module", exports: { import: "./index.js" } },
+      "index.js",
+      `import { human } from "@pmelab/gtd/flows"\nexport const file = typeof human\n`,
+    )
+    pkg("ts-dep", { main: "index.ts" }, "index.ts", `export const suffix: string = "ts"\n`)
+    pkg("cjs-dep", {}, "index.js", `module.exports = require("node:path").basename(__dirname)\n`)
+    writeFileSync(
+      join(vendor, "index.ts"),
+      [
+        `import { basename, dirname } from "node:path"`,
+        `import { fileURLToPath } from "node:url"`,
+        `import { file as base } from "dep"`,
+        `import { suffix } from "ts-dep"`,
+        `import cjs from "cjs-dep"`,
+        `const where = basename(dirname(fileURLToPath(import.meta.url)))`,
+        `export const file = [base, suffix, cjs, where].join("-")`,
+        ``,
+      ].join("\n"),
+    )
+    writeFileSync(
+      join(projectDir, "gtd.config.ts"),
+      [
+        `import { file } from "./vendor/wf/index.js"`,
+        optionedWorkflow("first", "{ steering: { [`.gtd/${file}.md`]: 'qa' } }"),
+      ].join("\n"),
+    )
+
+    const cfg = await getConfig()
+
+    expect(cfg.workflow.steering[".gtd/function-ts-cjs-dep-wf.md"]).toBe("qa")
+    expect(Object.keys(cfg.fingerprint).sort()).toEqual(["gtd.config.ts", "vendor/wf/index.ts"])
+  })
+
+  it("a config may require and require.resolve a local module", async () => {
+    writeFileSync(join(projectDir, "steps.ts"), `export const file = "required"\n`)
+    writeFileSync(
+      join(projectDir, "gtd.config.ts"),
+      [
+        `const { file } = require("./steps.js")`,
+        `const found = require("node:path").basename(require.resolve("./steps.ts"))`,
+        optionedWorkflow("first", "{ steering: { [`.gtd/${file}-${found}.md`]: 'qa' } }"),
+      ].join("\n"),
+    )
+
+    expect((await getConfig()).workflow.steering[".gtd/required-steps.ts.md"]).toBe("qa")
+  })
+
   it("the fingerprint covers gtd.config.ts but no gtd module it imports", async () => {
     const cfg = await getConfig()