@pmelab/gtd 62.1.0 → 64.0.0

package/src/twins/index.ts

@@ -1,5 +1,9 @@
 export { InMemRepo } from "./InMemRepo.js"
 export {
+  inMemPath,
+  inMemoryHost,
+  IN_MEMORY_PID,
+  IN_MEMORY_SCRATCH,
   makeInMemoryWorkspaceOps,
   testLayers,
   type CommandTable,
@@ -13,3 +17,4 @@ export { strictGitOperations } from "./StrictGitOperations.js"
 export { fakeGitOperations } from "./FakeGitOperations.js"
 export { takePinBeat } from "./PinBeats.js"
 export { inMemPinFile } from "./PinFile.js"
+export { inMemorySyncIo } from "./SyncIo.js"

package/src/workflow/discovery.test.ts

@@ -2,7 +2,7 @@ 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 { Effect, Layer } from "effect"
+import { Effect, Layer, type Path } from "effect"
 import { afterEach, describe, expect, it } from "vitest"
 import { GitService, Host, Narrator, Workspace, NodeServices } from "../platform/index.js"
 import { InMemRepo, testLayers } from "../twins/index.js"
@@ -34,7 +34,7 @@ const config = (imports: string): string =>
   ].join("\n")
 
 const loadWith = (
-  layer: Layer.Layer<ConfigService | Narrator | Workspace | Host | ConfigDiscovery>,
+  layer: Layer.Layer<ConfigService | Narrator | Workspace | Host | Path.Path | ConfigDiscovery>,
 ) =>
   Effect.runPromise(
     Effect.flatMap(ConfigService, (service) => service.load).pipe(
@@ -63,15 +63,16 @@ const live = (): Tier => {
       }
       const host = Host.layer({ root, home: root, env: {} })
       const git = GitService.Live.pipe(Layer.provide(Layer.merge(host, NodeServices.layer)))
-      const workspace = Workspace.Live.pipe(Layer.provide(Layer.merge(host, git)))
+      const workspace = Workspace.Live.pipe(
+        Layer.provide(Layer.mergeAll(host, git, NodeServices.layer)),
+      )
       return loadWith(
         Layer.mergeAll(
           ConfigService.Live,
           ConfigDiscovery.Live,
-          host,
           workspace,
           Narrator.layer(() => {}, false),
-        ),
+        ).pipe(Layer.provideMerge(host), Layer.provideMerge(NodeServices.layer)),
       )
     },
     dispose: () => rmSync(root, { recursive: true, force: true }),

package/src/workflow/discovery.ts

@@ -1,6 +1,5 @@
-import { existsSync, readFileSync, statSync } from "node:fs"
-import { dirname, join } from "node:path"
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Layer, Path } from "effect"
+import { Host, nodeSyncIo, type SyncIo } from "../platform/index.js"
 
 /** The workflow module found on the cwd→home walk, with its source. */
 export interface WorkflowModule {
@@ -50,17 +49,21 @@ export const LEGACY_RC_FILES = [
 ]
 
 /** The directories searched for a leftover rc file: the walk, plus `home` when the walk misses it. */
-export const legacyRcDirs = (root: string, home: string): readonly string[] => {
-  const chain = walkUp(root, home)
+export const legacyRcDirs = (path: Path.Path, root: string, home: string): readonly string[] => {
+  const chain = walkUp(path, root, home)
   return chain.includes(home) ? chain : [...chain, home]
 }
 
-const legacyRcFileAt = (path: string): LegacyRcFile | undefined => {
+const legacyRcFileAt = (
+  io: SyncIo,
+  path: string,
+  uid: number | undefined,
+): LegacyRcFile | undefined => {
   try {
-    const stat = statSync(path)
-    if (!stat.isFile()) return undefined
+    const stat = io.stat(path)
+    if (stat?.type !== "file") return undefined
     // Above home, a shared directory (`/tmp`) can hold another user's file.
-    return { path, owned: process.getuid === undefined || stat.uid === process.getuid() }
+    return { path, owned: uid === undefined || stat.uid === uid }
   } catch {
     return undefined
   }
@@ -74,40 +77,43 @@ const legacyRcFileAt = (path: string): LegacyRcFile | undefined => {
  * shared implementation, not a second copy in `src/twins/Layers.ts` that
  * could silently diverge.
  */
-export const walkUp = (from: string, home: string): ReadonlyArray<string> => {
+export const walkUp = (path: Path.Path, from: string, home: string): ReadonlyArray<string> => {
   const chain: Array<string> = []
   let dir = from
   while (true) {
     chain.push(dir)
     if (dir === home) break
-    const parent = dirname(dir)
+    const parent = path.dirname(dir)
     if (parent === dir) break // filesystem root
     dir = parent
   }
   return chain
 }
 
-const legacyRcFiles = (root: string, home: string): Effect.Effect<readonly LegacyRcFile[], Error> =>
-  Effect.sync(() =>
-    legacyRcDirs(root, home).flatMap((dir) =>
-      LEGACY_RC_FILES.flatMap((name) => legacyRcFileAt(join(dir, name)) ?? []),
+const liveDiscovery = (
+  io: SyncIo,
+  path: Path.Path,
+  uid: number | undefined,
+): ConfigDiscoveryOps => ({
+  legacyRcFiles: (root, home) =>
+    Effect.sync(() =>
+      legacyRcDirs(path, root, home).flatMap((dir) =>
+        LEGACY_RC_FILES.flatMap((name) => legacyRcFileAt(io, path.join(dir, name), uid) ?? []),
+      ),
     ),
-  )
-
-const workflowModule = (
-  root: string,
-  home: string,
-): Effect.Effect<WorkflowModule | undefined, Error> =>
-  Effect.try({
-    try: () => {
-      for (const dir of walkUp(root, home)) {
-        const filepath = join(dir, WORKFLOW_MODULE)
-        if (existsSync(filepath)) return { filepath, source: readFileSync(filepath, "utf8") }
-      }
-      return undefined
-    },
-    catch: (e) => (e instanceof Error ? e : new Error(String(e))),
-  })
+  workflowModule: (root, home) =>
+    Effect.try({
+      try: () => {
+        for (const dir of walkUp(path, root, home)) {
+          const filepath = path.join(dir, WORKFLOW_MODULE)
+          const source = io.readText(filepath)
+          if (source !== undefined) return { filepath, source }
+        }
+        return undefined
+      },
+      catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+    }),
+})
 
 /**
  * The discovery seam — a `Context.Service`, not part of `WorkflowFiles` (that
@@ -122,5 +128,10 @@ const workflowModule = (
 export class ConfigDiscovery extends Context.Service<ConfigDiscovery, ConfigDiscoveryOps>()(
   "ConfigDiscovery",
 ) {
-  static Live = Layer.succeed(ConfigDiscovery, { legacyRcFiles, workflowModule })
+  static Live = Layer.effect(
+    ConfigDiscovery,
+    Effect.gen(function* () {
+      return liveDiscovery(nodeSyncIo, yield* Path.Path, (yield* Host).uid)
+    }),
+  )
 }

package/src/workflow/fingerprint.test.ts

@@ -9,6 +9,8 @@ import {
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { describe, expect, it } from "vitest"
+import { nodeSyncIo } from "../platform/index.js"
+import { inMemPath } from "../twins/index.js"
 import { changedConfigFiles, configFingerprint } from "./fingerprint.js"
 
 const read = (path: string): string | undefined => {
@@ -27,6 +29,8 @@ describe("the config fingerprint", () => {
     writeFileSync(join(root, "lib", "flow.ts"), "export const a = 1\n")
 
     const fingerprint = configFingerprint(
+      nodeSyncIo,
+      inMemPath,
       [join(root, "gtd.config.ts"), join(root, "lib", "flow.ts"), join(root, "gone.ts")],
       root,
       read,
@@ -38,7 +42,13 @@ describe("the config fingerprint", () => {
     expect(
       changedConfigFiles(
         fingerprint,
-        configFingerprint([join(root, "gtd.config.ts"), join(root, "lib", "flow.ts")], root, read),
+        configFingerprint(
+          nodeSyncIo,
+          inMemPath,
+          [join(root, "gtd.config.ts"), join(root, "lib", "flow.ts")],
+          root,
+          read,
+        ),
       ),
     ).toEqual(["lib/flow.ts"])
   })
@@ -50,7 +60,15 @@ describe("the config fingerprint", () => {
     symlinkSync(real, link)
 
     expect(
-      Object.keys(configFingerprint([join(realpathSync(real), "gtd.config.ts")], link, read)),
+      Object.keys(
+        configFingerprint(
+          nodeSyncIo,
+          inMemPath,
+          [join(realpathSync(real), "gtd.config.ts")],
+          link,
+          read,
+        ),
+      ),
     ).toEqual(["gtd.config.ts"])
   })
 
@@ -58,7 +76,9 @@ describe("the config fingerprint", () => {
     const root = mkdtempSync(join(tmpdir(), "gtd-fingerprint-"))
     writeFileSync(join(root, "a\x1b.ts"), "export const a = 1\n")
 
-    expect(configFingerprint([join(root, "a\x1b.ts")], root, read)).toEqual({})
+    expect(configFingerprint(nodeSyncIo, inMemPath, [join(root, "a\x1b.ts")], root, read)).toEqual(
+      {},
+    )
   })
 
   it("names a file only one side has as changed", () => {

package/src/workflow/fingerprint.ts

@@ -1,6 +1,5 @@
-import { createHash } from "node:crypto"
-import { realpathSync } from "node:fs"
-import { relative, sep } from "node:path"
+import type { Path } from "effect"
+import type { SyncIo } from "../platform/index.js"
 
 /** Path (relative to `root`) → content hash of every file a config load touched. */
 export type ConfigFingerprint = Readonly<Record<string, string>>
@@ -12,12 +11,9 @@ const HASH_LENGTH = 16
 // eslint-disable-next-line no-control-regex -- the control range IS the point
 const CONTROL_CHARACTER = /[\x00-\x1f\x7f-\x9f]/
 
-const contentHash = (content: string | Buffer): string =>
-  createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH)
-
-const realOr = (path: string): string => {
+const realOr = (io: SyncIo, path: string): string => {
   try {
-    return realpathSync(path)
+    return io.realPath(path)
   } catch {
     return path
   }
@@ -28,17 +24,19 @@ const realOr = (path: string): string => {
 // Paths are real paths: a loader may report `/private/var/…` for a root
 // reached through the `/var` symlink, and the two must still relate.
 export const configFingerprint = (
+  io: SyncIo,
+  paths: Path.Path,
   files: readonly string[],
   root: string,
   read: (path: string) => string | undefined,
 ): ConfigFingerprint => {
   const fingerprint: Record<string, string> = {}
-  const realRoot = realOr(root)
+  const realRoot = realOr(io, root)
   for (const file of files) {
-    const path = relative(realRoot, realOr(file)).split(sep).join("/")
+    const path = paths.relative(realRoot, realOr(io, file)).split(paths.sep).join("/")
     if (CONTROL_CHARACTER.test(path)) continue
     const content = read(file)
-    if (content !== undefined) fingerprint[path] = contentHash(content)
+    if (content !== undefined) fingerprint[path] = io.hash("sha256", content).slice(0, HASH_LENGTH)
   }
   return fingerprint
 }

package/src/workflow/load.test.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, mkdtempSync, rmSync, writeFileSync, mkdirSync
 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 { Cause, Effect, Exit, Layer, type Path } from "effect"
 import { Narrator, GitService, Host, Workspace, NodeServices } from "../platform/index.js"
 import {
   ConfigDiscovery,
@@ -23,7 +23,9 @@ 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, NodeServices.layer)))
-  const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
+  const workspaceLayer = Workspace.Live.pipe(
+    Layer.provide(Layer.mergeAll(hostLayer, gitLayer, NodeServices.layer)),
+  )
   return Layer.mergeAll(hostLayer, gitLayer, workspaceLayer)
 }
 
@@ -34,18 +36,25 @@ const layer = (dir: string, env: Env = {}) =>
   Layer.mergeAll(
     ConfigService.Live,
     ConfigDiscovery.Live,
-    baseLayer(dir, env),
     Narrator.layer(() => {}, false),
-  )
+  ).pipe(Layer.provideMerge(baseLayer(dir, env)), Layer.provideMerge(NodeServices.layer))
 
 const run = <A>(
-  eff: Effect.Effect<A, Error, ConfigService | ConfigDiscovery | Narrator | Workspace | Host>,
+  eff: Effect.Effect<
+    A,
+    Error,
+    ConfigService | ConfigDiscovery | Narrator | Workspace | Host | Path.Path
+  >,
   dir: string = projectDir,
   env: Env = {},
 ) => Effect.runPromise(eff.pipe(Effect.provide(layer(dir, env))))
 
 const runExit = <A>(
-  eff: Effect.Effect<A, Error, ConfigService | ConfigDiscovery | Narrator | Workspace | Host>,
+  eff: Effect.Effect<
+    A,
+    Error,
+    ConfigService | ConfigDiscovery | Narrator | Workspace | Host | Path.Path
+  >,
   dir: string = projectDir,
 ) => Effect.runPromiseExit(eff.pipe(Effect.provide(layer(dir))))
 
@@ -265,6 +274,7 @@ describe("ConfigService", () => {
             others,
             baseLayer(projectDir),
             Narrator.layer((m) => warnings.push(m), false),
+            NodeServices.layer,
           ),
         ),
       ),