@knpkv/confluence-to-markdown 0.5.0 → 0.7.0

package/src/internal/frontmatter.ts

@@ -6,7 +6,7 @@
  */
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import matter from "gray-matter"
+import * as yaml from "js-yaml"
 import { FrontMatterError } from "../ConfluenceError.js"
 import type { NewPageFrontMatter, PageFrontMatter } from "../Schemas.js"
 import { NewPageFrontMatterSchema, PageFrontMatterSchema } from "../Schemas.js"
@@ -20,6 +20,33 @@ export interface ParsedMarkdown {
   readonly isNew: boolean
 }
 
+const parseRawMarkdown = (content: string): { readonly data: Record<string, unknown>; readonly content: string } => {
+  if (!content.startsWith("---\n") && !content.startsWith("---\r\n")) {
+    return { data: {}, content }
+  }
+
+  const newline = content.startsWith("---\r\n") ? "\r\n" : "\n"
+  const headerStart = 3 + newline.length
+  const closingMarker = `${newline}---`
+  const closingStart = content.indexOf(closingMarker, headerStart)
+  if (closingStart === -1) {
+    return { data: {}, content }
+  }
+
+  const header = content.slice(headerStart, closingStart)
+  const afterClosingStart = closingStart + closingMarker.length
+  const afterClosing = content.startsWith("\r\n", afterClosingStart)
+    ? content.slice(afterClosingStart + 2)
+    : content.startsWith("\n", afterClosingStart)
+    ? content.slice(afterClosingStart + 1)
+    : content.slice(afterClosingStart)
+  const loaded = yaml.load(header)
+  const data = loaded !== null && typeof loaded === "object" && !Array.isArray(loaded)
+    ? loaded as Record<string, unknown>
+    : {}
+  return { data, content: afterClosing }
+}
+
 /**
  * Parse a markdown file with YAML front-matter.
  *
@@ -35,7 +62,7 @@ export const parseMarkdown = (
 ): Effect.Effect<ParsedMarkdown, FrontMatterError> =>
   Effect.gen(function*() {
     const parsed = yield* Effect.try({
-      try: () => matter(content),
+      try: () => parseRawMarkdown(content),
       catch: (cause) => new FrontMatterError({ path: filePath, cause })
     })
 
@@ -49,21 +76,21 @@ export const parseMarkdown = (
     }
 
     // Try to parse as existing page front-matter
-    const existingResult = yield* Schema.decodeUnknown(PageFrontMatterSchema)(parsed.data).pipe(
+    const existingResult = yield* Schema.decodeUnknownEffect(PageFrontMatterSchema)(parsed.data).pipe(
       Effect.map((fm) => ({
         frontMatter: fm,
         content: parsed.content.trim(),
         isNew: false
       })),
-      Effect.catchAll(() =>
+      Effect.catchCause(() =>
         // Try to parse as new page front-matter
-        Schema.decodeUnknown(NewPageFrontMatterSchema)(parsed.data).pipe(
+        Schema.decodeUnknownEffect(NewPageFrontMatterSchema)(parsed.data).pipe(
           Effect.map((fm) => ({
             frontMatter: fm as NewPageFrontMatter,
             content: parsed.content.trim(),
             isNew: true
           })),
-          Effect.catchAll((cause) => Effect.fail(new FrontMatterError({ path: filePath, cause })))
+          Effect.catchCause((cause) => Effect.fail(new FrontMatterError({ path: filePath, cause })))
         )
       )
     )
@@ -94,7 +121,7 @@ export const serializeMarkdown = (
     contentHash: frontMatter.contentHash
   }
 
-  return matter.stringify(content, fm)
+  return stringifyFrontmatter(content, fm)
 }
 
 /**
@@ -115,5 +142,15 @@ export const serializeNewPageMarkdown = (
     ...(frontMatter.parentId !== undefined ? { parentId: frontMatter.parentId } : {})
   }
 
-  return matter.stringify(content, fm)
+  return stringifyFrontmatter(content, fm)
+}
+
+const stringifyFrontmatter = (content: string, frontMatter: Record<string, unknown>): string => {
+  const header = yaml.dump(frontMatter, {
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false
+  }).trimEnd()
+  const body = content.endsWith("\n") ? content : `${content}\n`
+  return `---\n${header}\n---\n${body}`
 }

package/src/internal/gitCommands.ts

@@ -4,11 +4,10 @@
  * @module
  * @internal
  */
-import * as Command from "@effect/platform/Command"
-import type * as CommandExecutor from "@effect/platform/CommandExecutor"
-import type * as PlatformError from "@effect/platform/Error"
 import * as Effect from "effect/Effect"
-import * as String from "effect/String"
+import * as EffectString from "effect/String"
+import { ChildProcessSpawner } from "effect/unstable/process"
+import * as ChildProcess from "effect/unstable/process/ChildProcess"
 import { GitError, GitNotInstalledError } from "../GitError.js"
 
 /**
@@ -48,17 +47,26 @@ export interface GitLogEntry {
  * Convert PlatformError to GitError or GitNotInstalledError.
  */
 const mapPlatformError = (
-  error: PlatformError.PlatformError,
+  error: unknown,
   commandStr: string
 ): GitError | GitNotInstalledError => {
-  if (error._tag === "SystemError" && error.reason === "NotFound") {
+  if (
+    typeof error === "object"
+    && error !== null
+    && "_tag" in error
+    && "reason" in error
+    && error._tag === "SystemError"
+    && error.reason === "NotFound"
+  ) {
+    const message = "message" in error ? globalThis.String(error.message) : "command not found"
     return new GitNotInstalledError({
-      message: `Git not found: ${error.message}. Please install git.`
+      message: `Git not found: ${message}. Please install git.`
     })
   }
+  const message = error instanceof Error ? error.message : globalThis.String(error)
   return new GitError({
     command: commandStr,
-    message: error.message
+    message
   })
 }
 
@@ -74,15 +82,13 @@ const mapPlatformError = (
 export const runGit = (
   args: ReadonlyArray<string>,
   cwd: string
-): Effect.Effect<string, GitError | GitNotInstalledError, CommandExecutor.CommandExecutor> =>
+): Effect.Effect<string, GitError | GitNotInstalledError, ChildProcessSpawner.ChildProcessSpawner> =>
   Effect.gen(function*() {
-    const command = Command.make("git", ...args).pipe(
-      Command.workingDirectory(cwd)
-    )
-
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    const command = ChildProcess.make("git", ["-C", cwd, ...args])
     const commandStr = `git ${args.join(" ")}`
 
-    const result = yield* Command.string(command).pipe(
+    const result = yield* spawner.string(command).pipe(
       Effect.mapError((error) => mapPlatformError(error, commandStr))
     )
 
@@ -98,7 +104,7 @@ export const runGit = (
 export const runGitAllowEmpty = (
   args: ReadonlyArray<string>,
   cwd: string
-): Effect.Effect<string, GitError | GitNotInstalledError, CommandExecutor.CommandExecutor> =>
+): Effect.Effect<string, GitError | GitNotInstalledError, ChildProcessSpawner.ChildProcessSpawner> =>
   runGit(args, cwd).pipe(
     Effect.catchIf(
       (e): e is GitError => e._tag === "GitError",
@@ -115,7 +121,7 @@ export const runGitAllowEmpty = (
  * @internal
  */
 export const parseGitStatus = (output: string): ReadonlyArray<GitStatusEntry> => {
-  if (String.isEmpty(output.trim())) {
+  if (EffectString.isEmpty(output.trim())) {
     return []
   }
 
@@ -171,7 +177,7 @@ const parseStatusCode = (code: string): GitFileStatus => {
  * @internal
  */
 export const parseGitLog = (output: string): ReadonlyArray<GitLogEntry> => {
-  if (String.isEmpty(output.trim())) {
+  if (EffectString.isEmpty(output.trim())) {
     return []
   }
 

package/src/internal/hashUtils.ts

@@ -24,10 +24,10 @@ export interface HashService {
  *
  * @category Services
  */
-export class HashServiceTag extends Context.Tag("@knpkv/confluence-to-markdown/HashService")<
+export class HashServiceTag extends Context.Service<
   HashServiceTag,
   HashService
->() {}
+>()("@knpkv/confluence-to-markdown/HashService") {}
 
 /**
  * Create a HashService layer from a hash function.

package/src/internal/oauthServer.ts

@@ -3,20 +3,20 @@
  *
  * @module
  */
-import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as HttpServer from "@effect/platform/HttpServer"
-import type { ServeError } from "@effect/platform/HttpServerError"
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
 import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import type { HttpServerError } from "effect/unstable/http"
+import { HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
 import { OAuthError } from "../ConfluenceError.js"
 
 const DEFAULT_PORT = 8585
-const MAX_PORT_ATTEMPTS = 10
+const MAX_PORT = 8594
+type HttpServerInstance = Effect.Success<typeof HttpServer.HttpServer>
 
 /**
  * Factory service for creating HTTP servers.
@@ -27,7 +27,7 @@ const MAX_PORT_ATTEMPTS = 10
 export interface HttpServerFactory {
   readonly createServerLayer: (port: number) => Layer.Layer<
     HttpServer.HttpServer,
-    ServeError,
+    HttpServerError.ServeError,
     never
   >
 }
@@ -37,10 +37,10 @@ export interface HttpServerFactory {
  *
  * @category Services
  */
-export class HttpServerFactoryTag extends Context.Tag("@knpkv/confluence-to-markdown/HttpServerFactory")<
+export class HttpServerFactoryTag extends Context.Service<
   HttpServerFactoryTag,
   HttpServerFactory
->() {}
+>()("@knpkv/confluence-to-markdown/HttpServerFactory") {}
 
 /**
  * Create a HttpServerFactory layer from a layer factory function.
@@ -52,51 +52,12 @@ export class HttpServerFactoryTag extends Context.Tag("@knpkv/confluence-to-mark
  * @category Layers
  */
 export const makeHttpServerFactory = (
-  createLayerFn: (port: number) => Layer.Layer<HttpServer.HttpServer, ServeError, never>
+  createLayerFn: (port: number) => Layer.Layer<HttpServer.HttpServer, HttpServerError.ServeError, never>
 ): Layer.Layer<HttpServerFactoryTag> =>
   Layer.succeed(HttpServerFactoryTag, {
     createServerLayer: createLayerFn
   })
 
-/**
- * Check if a port is available by attempting to start a server.
- */
-const isPortAvailable = (port: number): Effect.Effect<boolean, never, HttpServerFactoryTag> =>
-  Effect.gen(function*() {
-    const factory = yield* HttpServerFactoryTag
-    const serverLayer = factory.createServerLayer(port)
-
-    // Try to acquire and immediately release
-    const result = yield* Layer.build(serverLayer).pipe(
-      Effect.scoped,
-      Effect.as(true),
-      Effect.catchAll(() => Effect.succeed(false))
-    )
-    return result
-  })
-
-/**
- * Find an available port starting from the default.
- */
-const findAvailablePort = (): Effect.Effect<number, OAuthError, HttpServerFactoryTag> =>
-  Effect.gen(function*() {
-    for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
-      const port = DEFAULT_PORT + attempt
-      const available = yield* isPortAvailable(port)
-      if (available) {
-        return port
-      }
-    }
-    return yield* Effect.fail(
-      new OAuthError({
-        step: "authorize",
-        cause: `Could not find available port (tried ${DEFAULT_PORT}-${
-          DEFAULT_PORT + MAX_PORT_ATTEMPTS - 1
-        }). Close other applications using these ports.`
-      })
-    )
-  })
-
 /**
  * Result from the OAuth callback server.
  */
@@ -122,70 +83,85 @@ export const startCallbackServer = (
 ): Effect.Effect<CallbackServerResult, OAuthError, HttpServerFactoryTag> =>
   Effect.gen(function*() {
     const factory = yield* HttpServerFactoryTag
-    const port = yield* findAvailablePort()
     const deferred = yield* Deferred.make<string, OAuthError>()
     const readyDeferred = yield* Deferred.make<void, OAuthError>()
+    const scope = yield* Scope.make()
+
+    const buildServer = (port: number): Effect.Effect<HttpServerInstance, OAuthError> =>
+      Layer.build(factory.createServerLayer(port)).pipe(
+        Scope.provide(scope),
+        Effect.map((context) => Context.get(context, HttpServer.HttpServer)),
+        Effect.catchCause((cause) =>
+          port < MAX_PORT
+            ? buildServer(port + 1)
+            : Effect.fail(new OAuthError({ step: "authorize", cause }))
+        )
+      )
 
-    const app = HttpRouter.empty.pipe(
-      HttpRouter.get(
-        "/callback",
-        Effect.gen(function*() {
-          const req = yield* HttpServerRequest.HttpServerRequest
-          const url = new URL(req.url, `http://localhost:${port}`)
-          const code = url.searchParams.get("code")
-          const state = url.searchParams.get("state")
-          const error = url.searchParams.get("error")
-          const errorDescription = url.searchParams.get("error_description")
-
-          if (error) {
-            yield* Deferred.fail(
-              deferred,
-              new OAuthError({ step: "authorize", cause: errorDescription || error })
-            )
-            return HttpServerResponse.html(
-              "<html><body><h1>Authorization Failed</h1><p>You can close this window.</p></body></html>"
-            )
-          }
-
-          if (state !== expectedState) {
-            yield* Deferred.fail(
-              deferred,
-              new OAuthError({ step: "authorize", cause: "State mismatch - possible CSRF attack" })
-            )
-            return HttpServerResponse.html(
-              "<html><body><h1>Security Error</h1><p>State verification failed.</p></body></html>"
-            )
-          }
-
-          if (!code) {
-            yield* Deferred.fail(
-              deferred,
-              new OAuthError({ step: "authorize", cause: "No authorization code received" })
-            )
-            return HttpServerResponse.html(
-              "<html><body><h1>Error</h1><p>No authorization code received.</p></body></html>"
-            )
-          }
-
-          yield* Deferred.succeed(deferred, code)
+    const server = yield* buildServer(DEFAULT_PORT)
+
+    if (server.address._tag !== "TcpAddress") {
+      return yield* Effect.fail(
+        new OAuthError({ step: "authorize", cause: "OAuth callback server did not bind to a TCP address" })
+      )
+    }
+    const port = server.address.port
+
+    const router = yield* HttpRouter.make
+    yield* router.add(
+      "GET",
+      "/callback",
+      Effect.gen(function*() {
+        const req = yield* HttpServerRequest.HttpServerRequest
+        const url = new URL(req.url, `http://localhost:${port}`)
+        const code = url.searchParams.get("code")
+        const state = url.searchParams.get("state")
+        const error = url.searchParams.get("error")
+        const errorDescription = url.searchParams.get("error_description")
+
+        if (error) {
+          yield* Deferred.fail(
+            deferred,
+            new OAuthError({ step: "authorize", cause: errorDescription || error })
+          )
           return HttpServerResponse.html(
-            "<html><body><h1>Success!</h1><p>You can close this window and return to the terminal.</p></body></html>"
+            "<html><body><h1>Authorization Failed</h1><p>You can close this window.</p></body></html>"
           )
-        })
-      )
-    )
+        }
+
+        if (state !== expectedState) {
+          yield* Deferred.fail(
+            deferred,
+            new OAuthError({ step: "authorize", cause: "State mismatch - possible CSRF attack" })
+          )
+          return HttpServerResponse.html(
+            "<html><body><h1>Security Error</h1><p>State verification failed.</p></body></html>"
+          )
+        }
+
+        if (!code) {
+          yield* Deferred.fail(
+            deferred,
+            new OAuthError({ step: "authorize", cause: "No authorization code received" })
+          )
+          return HttpServerResponse.html(
+            "<html><body><h1>Error</h1><p>No authorization code received.</p></body></html>"
+          )
+        }
 
-    const serverLayer = factory.createServerLayer(port)
+        yield* Deferred.succeed(deferred, code)
+        return HttpServerResponse.html(
+          "<html><body><h1>Success!</h1><p>You can close this window and return to the terminal.</p></body></html>"
+        )
+      })
+    )
 
-    const serverFiber = yield* HttpServer.serve(app).pipe(
-      Layer.provide(serverLayer),
-      Layer.build,
+    const serverFiber = yield* HttpServer.serveEffect(router.asHttpEffect()).pipe(
+      Effect.provideService(HttpServer.HttpServer, server),
+      Scope.provide(scope),
       Effect.tap(() => Deferred.succeed(readyDeferred, undefined)),
       Effect.tapError((err) => Deferred.fail(readyDeferred, new OAuthError({ step: "authorize", cause: err }))),
-      // Keep the layer alive until fiber is interrupted
-      Effect.flatMap(() => Effect.never),
-      Effect.scoped,
-      Effect.fork
+      Effect.forkIn(scope)
     )
 
     // Wait for server to be ready (or fail)
@@ -193,7 +169,10 @@ export const startCallbackServer = (
 
     return {
       codePromise: Deferred.await(deferred),
-      shutdown: Fiber.interrupt(serverFiber).pipe(Effect.asVoid),
+      shutdown: Fiber.interrupt(serverFiber).pipe(
+        Effect.andThen(Scope.close(scope, Exit.void)),
+        Effect.asVoid
+      ),
       port
     }
   })

package/src/internal/pathUtils.ts

@@ -4,8 +4,8 @@
  * @module
  * @internal
  */
-import * as Path from "@effect/platform/Path"
 import * as Effect from "effect/Effect"
+import * as Path from "effect/Path"
 
 /**
  * Convert a page title to a URL-safe slug.

package/src/internal/process.ts

@@ -0,0 +1,15 @@
+/**
+ * Process metadata service.
+ *
+ * @module
+ * @internal
+ */
+import * as Context from "effect/Context"
+import type * as Effect from "effect/Effect"
+
+export class ProcessArgs extends Context.Service<
+  ProcessArgs,
+  {
+    readonly argv: Effect.Effect<ReadonlyArray<string>>
+  }
+>()("@knpkv/confluence-to-markdown/ProcessArgs") {}

package/src/internal/stdio.ts

@@ -0,0 +1,22 @@
+/**
+ * Standard output helpers backed by the Effect Stdio service.
+ *
+ * @module
+ * @internal
+ */
+import * as Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import type * as PlatformError from "effect/PlatformError"
+import * as Terminal from "effect/Terminal"
+
+export const writeStdout = (
+  message: string
+): Effect.Effect<void, PlatformError.PlatformError, Terminal.Terminal> =>
+  Effect.gen(function*() {
+    const terminal = yield* Terminal.Terminal
+    yield* terminal.display(message)
+  })
+
+export const writeStderr = (
+  message: string
+): Effect.Effect<void> => Console.error(message)

package/src/internal/tokenStorage.ts

@@ -3,11 +3,12 @@
  *
  * @module
  */
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as Path from "@effect/platform/Path"
+import * as Config from "effect/Config"
 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 * as Schema from "effect/Schema"
 import { FileSystemError } from "../ConfluenceError.js"
 import { type OAuthConfig, OAuthConfigSchema, type OAuthToken, OAuthTokenSchema } from "../Schemas.js"
@@ -16,6 +17,14 @@ const TOKEN_DIR_NAME = ".confluence"
 const TOKEN_FILE_NAME = "auth.json"
 const CONFIG_FILE_NAME = "config.json"
 
+const parseJsonOrNull = (content: string): unknown | null => {
+  try {
+    return JSON.parse(content) as unknown
+  } catch {
+    return null
+  }
+}
+
 /**
  * Service for getting the home directory.
  * This allows mocking in tests.
@@ -31,21 +40,31 @@ export interface HomeDirectory {
  *
  * @category Services
  */
-export class HomeDirectoryTag extends Context.Tag("@knpkv/confluence-to-markdown/HomeDirectory")<
+export class HomeDirectoryTag extends Context.Service<
   HomeDirectoryTag,
   HomeDirectory
->() {}
+>()("@knpkv/confluence-to-markdown/HomeDirectory") {}
 
 /**
- * Default implementation using process.env.HOME.
+ * Default implementation using Effect Config.
  *
  * @category Layers
  */
-export const HomeDirectoryLive: Layer.Layer<HomeDirectoryTag> = Layer.succeed(
+const homeDirectoryPath = Config.string("HOME").pipe(
+  Config.orElse(() => Config.string("USERPROFILE")),
+  Config.orElse(() => Config.succeed("/"))
+)
+
+export const HomeDirectoryLive: Layer.Layer<HomeDirectoryTag> = Layer.effect(
   HomeDirectoryTag,
-  {
-    get: () => Effect.sync(() => process.env.HOME ?? process.env.USERPROFILE ?? "/")
-  }
+  homeDirectoryPath.pipe(
+    Effect.catchCause(() => Effect.succeed("/")),
+    Effect.map((home) =>
+      HomeDirectoryTag.of({
+        get: () => Effect.succeed(home)
+      })
+    )
+  )
 )
 
 /**
@@ -96,7 +115,7 @@ export const loadToken = (): Effect.Effect<
     const tokenPath = yield* getTokenPath()
 
     const exists = yield* fs.exists(tokenPath).pipe(
-      Effect.catchAll(() => Effect.succeed(false))
+      Effect.catchCause(() => Effect.succeed(false))
     )
     if (!exists) {
       return null
@@ -106,15 +125,11 @@ export const loadToken = (): Effect.Effect<
       Effect.mapError((cause) => new FileSystemError({ operation: "read", path: tokenPath, cause }))
     )
 
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(content)
-    } catch {
-      return null
-    }
+    const parsed = yield* Effect.sync(() => parseJsonOrNull(content))
+    if (parsed === null) return null
 
-    const decoded = yield* Schema.decodeUnknown(OAuthTokenSchema)(parsed).pipe(
-      Effect.catchAll(() => Effect.succeed(null))
+    const decoded = yield* Schema.decodeUnknownEffect(OAuthTokenSchema)(parsed).pipe(
+      Effect.catchCause(() => Effect.succeed(null))
     )
 
     return decoded
@@ -164,8 +179,7 @@ export const deleteToken = (): Effect.Effect<
     const tokenPath = yield* getTokenPath()
 
     yield* fs.remove(tokenPath).pipe(
-      Effect.catchAll(() => Effect.void),
-      Effect.mapError((cause) => new FileSystemError({ operation: "delete", path: tokenPath, cause }))
+      Effect.catchCause(() => Effect.void)
     )
   })
 
@@ -186,7 +200,7 @@ export const loadOAuthConfig = (): Effect.Effect<
     const configPath = yield* getConfigPath()
 
     const exists = yield* fs.exists(configPath).pipe(
-      Effect.catchAll(() => Effect.succeed(false))
+      Effect.catchCause(() => Effect.succeed(false))
     )
     if (!exists) {
       return null
@@ -196,15 +210,11 @@ export const loadOAuthConfig = (): Effect.Effect<
       Effect.mapError((cause) => new FileSystemError({ operation: "read", path: configPath, cause }))
     )
 
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(content)
-    } catch {
-      return null
-    }
+    const parsed = yield* Effect.sync(() => parseJsonOrNull(content))
+    if (parsed === null) return null
 
-    const decoded = yield* Schema.decodeUnknown(OAuthConfigSchema)(parsed).pipe(
-      Effect.catchAll(() => Effect.succeed(null))
+    const decoded = yield* Schema.decodeUnknownEffect(OAuthConfigSchema)(parsed).pipe(
+      Effect.catchCause(() => Effect.succeed(null))
     )
 
     return decoded

package/src/internal/userCache.ts

@@ -14,7 +14,7 @@ import type { AtlassianUser } from "../Schemas.js"
  *
  * @category Cache
  */
-export class UserCache extends Context.Tag("@knpkv/confluence-to-markdown/UserCache")<
+export class UserCache extends Context.Service<
   UserCache,
   {
     /**
@@ -40,7 +40,7 @@ export class UserCache extends Context.Tag("@knpkv/confluence-to-markdown/UserCa
      */
     readonly clear: () => Effect.Effect<void>
   }
->() {}
+>()("@knpkv/confluence-to-markdown/UserCache") {}
 
 /**
  * Create the user cache service.