@knpkv/jira-cli 0.1.1 → 1.0.0

package/src/JiraAuth.ts

@@ -4,7 +4,7 @@
  * **Mental model**
  *
  * - **Service pattern**: {@link JiraAuth} is a `Context.Tag` whose layer requires `HttpClient`
- *   and `CommandExecutor`. All token storage operations are pre-bound to
+ *   and `ChildProcessSpawner`. All token storage operations are pre-bound to
  *   `@knpkv/atlassian-common/config` with a `"jira-cli"` tool name.
  * - **Refresh lock**: A `Ref<Option<Deferred>>` prevents concurrent token refreshes — the
  *   first caller refreshes, others await the same Deferred.
@@ -21,10 +21,6 @@
  */
 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem"
 import * as NodePath from "@effect/platform-node/NodePath"
-import * as Command from "@effect/platform/Command"
-import * as CommandExecutor from "@effect/platform/CommandExecutor"
-import type * as Error from "@effect/platform/Error"
-import * as HttpClient from "@effect/platform/HttpClient"
 import {
   buildAuthUrl,
   buildOAuthToken,
@@ -58,19 +54,31 @@ import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
+import type * as PlatformError from "effect/PlatformError"
 import * as Redacted from "effect/Redacted"
 import * as Ref from "effect/Ref"
+import * as HttpClient from "effect/unstable/http/HttpClient"
+import { ChildProcessSpawner } from "effect/unstable/process"
 import { HttpServerFactoryLive } from "./internal/NodeLayers.js"
 import { startCallbackServer } from "./internal/oauthServer.js"
+import { openBrowser } from "./internal/openBrowser.js"
 import type { AuthMissingError } from "./JiraCliError.js"
 import { authMissing } from "./JiraCliError.js"
 
-/** Scopes for Jira CLI (includes write:jira-work for worklog) */
+/** OAuth scopes for the Jira CLI. Granular scopes must also be enabled on the app in the developer console. */
 const JIRA_CLI_SCOPES = [
+  // Read issues, search, and read versions.
   "read:jira-work",
+  // Edit issues and write worklogs.
   "write:jira-work",
+  // Edit a version (e.g. its description) via `PUT /rest/api/3/version/{id}` and
+  // manage version "Related work" links (`/rest/api/3/version/{id}/relatedwork`).
+  "manage:jira-project",
+  // Resolve account IDs to display names for Driver/Contributors/Approvers.
   "read:jira-user",
+  // Read the authenticated user's own profile (`/rest/api/3/myself`).
   "read:me",
+  // Issue a refresh token so the CLI stays logged in across runs.
   "offline_access"
 ]
 
@@ -121,40 +129,46 @@ export interface JiraAuthService {
   /** Configure OAuth client credentials */
   readonly configure: (
     config: OAuthConfig
-  ) => Effect.Effect<void, FileSystemError | HomeDirectoryError | Error.PlatformError>
+  ) => Effect.Effect<void, FileSystemError | HomeDirectoryError | PlatformError.PlatformError>
   /** Check if OAuth is configured */
-  readonly isConfigured: () => Effect.Effect<boolean, FileSystemError | HomeDirectoryError | Error.PlatformError>
+  readonly isConfigured: () => Effect.Effect<
+    boolean,
+    FileSystemError | HomeDirectoryError | PlatformError.PlatformError
+  >
   /** Start OAuth login flow. Returns list of sites if multiple are available. */
   readonly login: (
     options?: LoginOptions
   ) => Effect.Effect<
     ReadonlyArray<AccessibleSite> | void,
-    OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   >
   /** Remove stored authentication */
-  readonly logout: () => Effect.Effect<void, OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError>
+  readonly logout: () => Effect.Effect<
+    void,
+    OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
+  >
   /** Get access token, refreshing if needed */
   readonly getAccessToken: () => Effect.Effect<
     Redacted.Redacted<string>,
-    AuthMissingError | OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    AuthMissingError | OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   >
   /** Get cloud ID from stored token */
   readonly getCloudId: () => Effect.Effect<
     string,
-    AuthMissingError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    AuthMissingError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   >
   /** Get site URL from stored token */
   readonly getSiteUrl: () => Effect.Effect<
     string,
-    AuthMissingError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    AuthMissingError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   >
   /** Get current user info from stored token */
   readonly getCurrentUser: () => Effect.Effect<
     OAuthUser | null,
-    FileSystemError | HomeDirectoryError | Error.PlatformError
+    FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   >
   /** Check if user is logged in */
-  readonly isLoggedIn: () => Effect.Effect<boolean, FileSystemError | HomeDirectoryError | Error.PlatformError>
+  readonly isLoggedIn: () => Effect.Effect<boolean, FileSystemError | HomeDirectoryError | PlatformError.PlatformError>
 }
 
 /**
@@ -176,37 +190,33 @@ export interface JiraAuthService {
  *
  * @category Services
  */
-export class JiraAuth extends Context.Tag("@knpkv/jira-cli/JiraAuth")<
+export class JiraAuth extends Context.Service<
   JiraAuth,
   JiraAuthService
->() {}
+>()("@knpkv/jira-cli/JiraAuth") {}
 
 const make = Effect.gen(function*() {
   const httpClient = yield* HttpClient.HttpClient
-  const commandExecutor = yield* CommandExecutor.CommandExecutor
+  const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner
 
   // Ref to track ongoing refresh operation to prevent concurrent refreshes
   const refreshLock = yield* Ref.make<
     Option.Option<
-      Deferred.Deferred<OAuthToken, OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError>
+      Deferred.Deferred<OAuthToken, OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError>
     >
   >(
     Option.none()
   )
 
   const openBrowserImpl = (url: string): Effect.Effect<void, OAuthError> =>
-    Command.make("open", url).pipe(
-      Command.exitCode,
-      Effect.catchAll(() => Command.make("xdg-open", url).pipe(Command.exitCode)),
-      Effect.catchAll(() => Command.make("cmd", "/c", "start", "", url).pipe(Command.exitCode)),
-      Effect.provide(Layer.succeed(CommandExecutor.CommandExecutor, commandExecutor)),
-      Effect.asVoid,
+    openBrowser(url).pipe(
+      Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, childProcessSpawner),
       Effect.mapError((cause) => new OAuthError({ step: "authorize", cause }))
     )
 
   const getConfig = (): Effect.Effect<
     OAuthConfig,
-    OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   > =>
     Effect.gen(function*() {
       const config = yield* loadOAuthConfigOp()
@@ -224,7 +234,7 @@ const make = Effect.gen(function*() {
   const refreshTokenImpl = (
     token: OAuthToken,
     config: OAuthConfig
-  ): Effect.Effect<OAuthToken, OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError> =>
+  ): Effect.Effect<OAuthToken, OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError> =>
     Effect.gen(function*() {
       const updated = yield* refreshToken(token, config).pipe(
         Effect.provide(Layer.succeed(HttpClient.HttpClient, httpClient))
@@ -243,9 +253,10 @@ const make = Effect.gen(function*() {
 
   const configure = (
     config: OAuthConfig
-  ): Effect.Effect<void, FileSystemError | HomeDirectoryError | Error.PlatformError> => saveOAuthConfigOp(config)
+  ): Effect.Effect<void, FileSystemError | HomeDirectoryError | PlatformError.PlatformError> =>
+    saveOAuthConfigOp(config)
 
-  const isConfigured = (): Effect.Effect<boolean, FileSystemError | HomeDirectoryError | Error.PlatformError> =>
+  const isConfigured = (): Effect.Effect<boolean, FileSystemError | HomeDirectoryError | PlatformError.PlatformError> =>
     Effect.gen(function*() {
       const config = yield* loadOAuthConfigOp()
       return config !== null
@@ -255,7 +266,7 @@ const make = Effect.gen(function*() {
     options?: LoginOptions
   ): Effect.Effect<
     ReadonlyArray<AccessibleSite> | void,
-    OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   > =>
     Effect.gen(function*() {
       const config = yield* getConfig()
@@ -276,7 +287,7 @@ const make = Effect.gen(function*() {
       const code = yield* codePromise.pipe(
         Effect.timeout("5 minutes"),
         Effect.catchTag(
-          "TimeoutException",
+          "TimeoutError",
           () => Effect.fail(new OAuthError({ step: "authorize", cause: "Authorization timed out" }))
         ),
         Effect.ensuring(shutdown)
@@ -340,7 +351,10 @@ const make = Effect.gen(function*() {
       return undefined
     })
 
-  const logout = (): Effect.Effect<void, OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError> =>
+  const logout = (): Effect.Effect<
+    void,
+    OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
+  > =>
     Effect.gen(function*() {
       const token = yield* loadTokenOp()
       if (token === null) {
@@ -352,7 +366,7 @@ const make = Effect.gen(function*() {
       if (config !== null) {
         yield* revokeTokenImpl(token, config).pipe(
           Effect.tap(() => Effect.log("Token revoked with Atlassian")),
-          Effect.catchAll((error) => Effect.log(`Warning: Failed to revoke token: ${error.message}`))
+          Effect.catch((error) => Effect.log(`Warning: Failed to revoke token: ${error.message}`))
         )
       }
 
@@ -361,7 +375,7 @@ const make = Effect.gen(function*() {
 
   const getAccessToken = (): Effect.Effect<
     Redacted.Redacted<string>,
-    AuthMissingError | OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    AuthMissingError | OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   > =>
     Effect.gen(function*() {
       const token = yield* loadTokenOp()
@@ -376,7 +390,7 @@ const make = Effect.gen(function*() {
       // Atomically check-then-set refresh lock to avoid TOCTOU race
       const deferred = yield* Deferred.make<
         OAuthToken,
-        OAuthError | FileSystemError | HomeDirectoryError | Error.PlatformError
+        OAuthError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
       >()
       const existing = yield* Ref.modify(refreshLock, (current) =>
         Option.isSome(current)
@@ -418,7 +432,7 @@ const make = Effect.gen(function*() {
 
   const getCloudId = (): Effect.Effect<
     string,
-    AuthMissingError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    AuthMissingError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   > =>
     Effect.gen(function*() {
       const token = yield* loadTokenOp()
@@ -430,7 +444,7 @@ const make = Effect.gen(function*() {
 
   const getSiteUrl = (): Effect.Effect<
     string,
-    AuthMissingError | FileSystemError | HomeDirectoryError | Error.PlatformError
+    AuthMissingError | FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   > =>
     Effect.gen(function*() {
       const token = yield* loadTokenOp()
@@ -442,14 +456,14 @@ const make = Effect.gen(function*() {
 
   const getCurrentUser = (): Effect.Effect<
     OAuthUser | null,
-    FileSystemError | HomeDirectoryError | Error.PlatformError
+    FileSystemError | HomeDirectoryError | PlatformError.PlatformError
   > =>
     Effect.gen(function*() {
       const token = yield* loadTokenOp()
       return token?.user ?? null
     })
 
-  const isLoggedIn = (): Effect.Effect<boolean, FileSystemError | HomeDirectoryError | Error.PlatformError> =>
+  const isLoggedIn = (): Effect.Effect<boolean, FileSystemError | HomeDirectoryError | PlatformError.PlatformError> =>
     Effect.gen(function*() {
       const token = yield* loadTokenOp()
       return token !== null

package/src/JiraCliError.ts

@@ -42,3 +42,27 @@ export class WriteError extends Data.TaggedError("WriteError")<{
   readonly message: string
   readonly cause?: unknown
 }> {}
+
+/**
+ * Error when reading or writing Jira Markdown Sync workspace state.
+ *
+ * @category Errors
+ */
+export class SyncWorkspaceError extends Data.TaggedError("SyncWorkspaceError")<{
+  readonly message: string
+  readonly path?: string | undefined
+  readonly cause?: unknown
+}> {}
+
+/**
+ * Error when local Jira Markdown Sync configuration or data fails validation.
+ *
+ * @category Errors
+ */
+export class SyncValidationError extends Data.TaggedError("SyncValidationError")<{
+  readonly message: string
+  readonly issueKey?: string | undefined
+  readonly field?: string | undefined
+  readonly path?: string | undefined
+  readonly cause?: unknown
+}> {}

package/src/MarkdownWriter.ts

@@ -5,15 +5,15 @@
  *
  * - **Two output modes**: {@link MarkdownWriterShape.writeMulti} creates one `.md` per issue;
  *   {@link MarkdownWriterShape.writeSingle} combines all into `jira-export.md`.
- * - **Effect service**: Requires `FileSystem` and `Path` from `@effect/platform`.
+ * - **Effect service**: Requires `FileSystem` and `Path` from `effect`.
  *
  * @module
  */
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as Path from "@effect/platform/Path"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
 import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
 import { buildCombinedMarkdown, serializeIssue } from "./internal/frontmatter.js"
 import type { Issue } from "./IssueService.js"
 import { WriteError } from "./JiraCliError.js"
@@ -53,10 +53,10 @@ export interface MarkdownWriterShape {
  *
  * @category Services
  */
-export class MarkdownWriter extends Context.Tag("@knpkv/jira-cli/MarkdownWriter")<
+export class MarkdownWriter extends Context.Service<
   MarkdownWriter,
   MarkdownWriterShape
->() {}
+>()("@knpkv/jira-cli/MarkdownWriter") {}
 
 const make = Effect.gen(function*() {
   const fs = yield* FileSystem.FileSystem
@@ -64,16 +64,12 @@ const make = Effect.gen(function*() {
 
   const ensureDir = (dir: string): Effect.Effect<void, WriteError> =>
     fs.makeDirectory(dir, { recursive: true }).pipe(
-      Effect.catchAll((cause) =>
-        Effect.fail(new WriteError({ path: dir, message: "Failed to create directory", cause }))
-      )
+      Effect.catch((cause) => Effect.fail(new WriteError({ path: dir, message: "Failed to create directory", cause })))
     )
 
   const writeFile = (filePath: string, content: string): Effect.Effect<void, WriteError> =>
     fs.writeFileString(filePath, content).pipe(
-      Effect.catchAll((cause) =>
-        Effect.fail(new WriteError({ path: filePath, message: "Failed to write file", cause }))
-      )
+      Effect.catch((cause) => Effect.fail(new WriteError({ path: filePath, message: "Failed to write file", cause })))
     )
 
   const writeMulti: MarkdownWriterShape["writeMulti"] = (issues, outputDir) =>

package/src/SyncWorkspace.ts

@@ -0,0 +1,185 @@
+/**
+ * Local workspace I/O for Jira Markdown Sync.
+ *
+ * @module
+ */
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
+import { parseSyncBaseline, serializeSyncBaseline } from "./internal/sync/baseline.js"
+import { makeDefaultWorkspaceConfig, parseWorkspaceConfig, serializeWorkspaceConfig } from "./internal/sync/config.js"
+import { makeEmptyManifest, parseSyncManifest, serializeSyncManifest } from "./internal/sync/manifest.js"
+import {
+  baselineFilePath,
+  conventionDocumentPath,
+  resolveWorkspacePaths,
+  type SyncWorkspacePaths
+} from "./internal/sync/paths.js"
+import type { SyncBaseline, SyncManifest, WorkspaceConfig } from "./internal/sync/types.js"
+import { SyncWorkspaceError } from "./JiraCliError.js"
+
+export interface InitWorkspaceInput {
+  readonly root: string
+  readonly siteUrl: string
+}
+
+export interface SyncWorkspaceShape {
+  readonly init: (input: InitWorkspaceInput) => Effect.Effect<SyncWorkspacePaths, SyncWorkspaceError>
+  readonly paths: (root: string, config?: Pick<WorkspaceConfig, "documentsDir">) => Effect.Effect<SyncWorkspacePaths>
+  readonly readConfig: (root: string) => Effect.Effect<WorkspaceConfig, SyncWorkspaceError>
+  readonly writeConfig: (root: string, config: WorkspaceConfig) => Effect.Effect<void, SyncWorkspaceError>
+  readonly readManifest: (root: string) => Effect.Effect<SyncManifest, SyncWorkspaceError>
+  readonly writeManifest: (root: string, manifest: SyncManifest) => Effect.Effect<void, SyncWorkspaceError>
+  readonly readBaseline: (root: string, issueId: string) => Effect.Effect<SyncBaseline, SyncWorkspaceError>
+  readonly writeBaseline: (
+    root: string,
+    baseline: SyncBaseline
+  ) => Effect.Effect<void, SyncWorkspaceError>
+  readonly conventionDocumentPath: (root: string, issueKey: string) => Effect.Effect<string, SyncWorkspaceError>
+}
+
+export class SyncWorkspace extends Context.Service<
+  SyncWorkspace,
+  SyncWorkspaceShape
+>()("@knpkv/jira-cli/SyncWorkspace") {}
+
+const mapWorkspaceError = (message: string, path?: string | undefined) => (cause: unknown) =>
+  new SyncWorkspaceError({ message, path, cause })
+
+const make = Effect.gen(function*() {
+  const fs = yield* FileSystem.FileSystem
+  const path = yield* Path.Path
+
+  const paths: SyncWorkspaceShape["paths"] = (root, config) => Effect.succeed(resolveWorkspacePaths(path, root, config))
+
+  const ensureDir = (dir: string): Effect.Effect<void, SyncWorkspaceError> =>
+    fs.makeDirectory(dir, { recursive: true }).pipe(
+      Effect.mapError(mapWorkspaceError("Failed to create sync workspace directory", dir)),
+      Effect.asVoid
+    )
+
+  const writeFile = (filePath: string, content: string): Effect.Effect<void, SyncWorkspaceError> =>
+    Effect.gen(function*() {
+      const dir = path.dirname(filePath)
+      yield* ensureDir(dir)
+      const tempPath = `${filePath}.tmp.${Date.now()}`
+      yield* fs.writeFileString(tempPath, content).pipe(
+        Effect.mapError(mapWorkspaceError("Failed to write sync workspace file", filePath))
+      )
+      yield* fs.rename(tempPath, filePath).pipe(
+        Effect.mapError(mapWorkspaceError("Failed to replace sync workspace file", filePath))
+      )
+    })
+
+  const readFile = (filePath: string): Effect.Effect<string, SyncWorkspaceError> =>
+    fs.readFileString(filePath).pipe(
+      Effect.mapError(mapWorkspaceError("Failed to read sync workspace file", filePath))
+    )
+
+  const init: SyncWorkspaceShape["init"] = ({ root, siteUrl }) =>
+    Effect.gen(function*() {
+      const config = makeDefaultWorkspaceConfig(siteUrl)
+      const workspacePaths = resolveWorkspacePaths(path, root, config)
+      yield* ensureDir(workspacePaths.documentsDir)
+      yield* ensureDir(workspacePaths.metadataDir)
+      yield* ensureDir(workspacePaths.baselinesDir)
+      yield* ensureDir(workspacePaths.historyDir)
+      yield* writeFile(workspacePaths.configFile, serializeWorkspaceConfig(config))
+      yield* writeFile(workspacePaths.manifestFile, serializeSyncManifest(makeEmptyManifest(siteUrl)))
+      return workspacePaths
+    })
+
+  const readConfig: SyncWorkspaceShape["readConfig"] = (root) =>
+    Effect.gen(function*() {
+      const workspacePaths = resolveWorkspacePaths(path, root)
+      const content = yield* readFile(workspacePaths.configFile)
+      return yield* parseWorkspaceConfig(workspacePaths.configFile, content).pipe(
+        Effect.mapError((cause) =>
+          new SyncWorkspaceError({
+            message: cause.message,
+            path: "path" in cause ? cause.path : workspacePaths.configFile,
+            cause
+          })
+        )
+      )
+    })
+
+  const writeConfig: SyncWorkspaceShape["writeConfig"] = (root, config) =>
+    Effect.gen(function*() {
+      const workspacePaths = resolveWorkspacePaths(path, root, config)
+      yield* ensureDir(workspacePaths.metadataDir)
+      yield* writeFile(workspacePaths.configFile, serializeWorkspaceConfig(config))
+    })
+
+  const readManifest: SyncWorkspaceShape["readManifest"] = (root) =>
+    Effect.gen(function*() {
+      const workspacePaths = resolveWorkspacePaths(path, root)
+      const content = yield* readFile(workspacePaths.manifestFile)
+      return yield* parseSyncManifest(workspacePaths.manifestFile, content).pipe(
+        Effect.mapError((cause) =>
+          new SyncWorkspaceError({
+            message: cause.message,
+            path: "path" in cause ? cause.path : workspacePaths.manifestFile,
+            cause
+          })
+        )
+      )
+    })
+
+  const writeManifest: SyncWorkspaceShape["writeManifest"] = (root, manifest) =>
+    Effect.gen(function*() {
+      const workspacePaths = resolveWorkspacePaths(path, root)
+      yield* ensureDir(workspacePaths.metadataDir)
+      yield* writeFile(workspacePaths.manifestFile, serializeSyncManifest(manifest))
+    })
+
+  const readBaseline: SyncWorkspaceShape["readBaseline"] = (root, issueId) =>
+    Effect.gen(function*() {
+      const workspacePaths = resolveWorkspacePaths(path, root)
+      const filePath = baselineFilePath(path, workspacePaths, issueId)
+      const content = yield* readFile(filePath)
+      return yield* parseSyncBaseline(filePath, content).pipe(
+        Effect.mapError((cause) =>
+          new SyncWorkspaceError({
+            message: cause.message,
+            path: "path" in cause ? cause.path : filePath,
+            cause
+          })
+        )
+      )
+    })
+
+  const writeBaseline: SyncWorkspaceShape["writeBaseline"] = (root, baseline) =>
+    Effect.gen(function*() {
+      const workspacePaths = resolveWorkspacePaths(path, root)
+      const filePath = baselineFilePath(path, workspacePaths, baseline.issueId)
+      yield* ensureDir(workspacePaths.baselinesDir)
+      yield* writeFile(filePath, serializeSyncBaseline(baseline))
+    })
+
+  const getConventionDocumentPath: SyncWorkspaceShape["conventionDocumentPath"] = (root, issueKey) =>
+    Effect.gen(function*() {
+      const config = yield* readConfig(root)
+      const workspacePaths = resolveWorkspacePaths(path, root, config)
+      return conventionDocumentPath(path, workspacePaths, issueKey)
+    })
+
+  return SyncWorkspace.of({
+    init,
+    paths,
+    readConfig,
+    writeConfig,
+    readManifest,
+    writeManifest,
+    readBaseline,
+    writeBaseline,
+    conventionDocumentPath: getConventionDocumentPath
+  })
+})
+
+export const layer: Layer.Layer<SyncWorkspace, never, FileSystem.FileSystem | Path.Path> = Layer.effect(
+  SyncWorkspace,
+  make
+)