@knpkv/confluence-to-markdown 0.5.0 → 0.7.0

package/src/SyncEngine.ts

@@ -3,10 +3,15 @@
  *
  * @module
  */
-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 type * as PlatformError from "effect/PlatformError"
+import * as Result from "effect/Result"
+import * as Schema from "effect/Schema"
+import type * as Terminal from "effect/Terminal"
 import { PageId } from "./Brand.js"
 import { ConfluenceClient } from "./ConfluenceClient.js"
 import { ConfluenceConfig } from "./ConfluenceConfig.js"
@@ -14,6 +19,14 @@ import type { ApiError, ConversionError, FrontMatterError, RateLimitError } from
 import { FileSystemError, StructureError } from "./ConfluenceError.js"
 import type { GitServiceError } from "./GitService.js"
 import { GitService } from "./GitService.js"
+import type { AdfMetadataSidecar } from "./internal/adfMetadata.js"
+import {
+  AdfMetadataSidecarSchema,
+  collectAdfMetadataHrefs,
+  externalizeAdfMetadata,
+  hydrateAdfMetadata
+} from "./internal/adfMetadata.js"
+import { parseMarkdown } from "./internal/frontmatter.js"
 import { computeHash, HashServiceLive } from "./internal/hashUtils.js"
 import { UserCache } from "./internal/userCache.js"
 import { LocalFileSystem } from "./LocalFileSystem.js"
@@ -40,7 +53,11 @@ export type SyncStatus =
 /**
  * Progress callback for version replay.
  */
-export type ProgressCallback = (current: number, total: number, message: string) => void
+export type ProgressCallback = (
+  current: number,
+  total: number,
+  message: string
+) => Effect.Effect<void, PlatformError.PlatformError, Terminal.Terminal>
 
 /**
  * Options for pull operation.
@@ -101,6 +118,26 @@ type SyncError =
   | GitServiceError
   | StructureError
 
+/**
+ * Pretty-print an ADF JSON wire string for the `.source.json` companion file.
+ * Falls back to the raw string if it can't be parsed as JSON.
+ */
+const prettyAdf = (raw: string): string => {
+  try {
+    return JSON.stringify(JSON.parse(raw), null, 2)
+  } catch {
+    return raw
+  }
+}
+
+/**
+ * Hash a markdown body in the form `readMarkdownFile` will later return it.
+ * `parseMarkdown` trims the body when reading, so the hash we store on
+ * frontmatter must hash the trimmed body too — otherwise every subsequent
+ * read sees a "changed" file and `push` keeps pushing a no-op update.
+ */
+const hashBody = (markdown: string) => computeHash(markdown.trim()).pipe(Effect.provide(HashServiceLive))
+
 /**
  * Sync engine service for Confluence <-> Markdown operations.
  *
@@ -118,15 +155,15 @@ type SyncError =
  *
  * @category Sync
  */
-export class SyncEngine extends Context.Tag(
-  "@knpkv/confluence-to-markdown/SyncEngine"
-)<
+export class SyncEngine extends Context.Service<
   SyncEngine,
   {
     /**
      * Pull pages from Confluence to local markdown.
      */
-    readonly pull: (options: PullOptions) => Effect.Effect<PullResult, SyncError>
+    readonly pull: (
+      options: PullOptions
+    ) => Effect.Effect<PullResult, SyncError | PlatformError.PlatformError, Terminal.Terminal>
 
     /**
      * Push local markdown changes to Confluence.
@@ -138,7 +175,7 @@ export class SyncEngine extends Context.Tag(
      */
     readonly status: () => Effect.Effect<StatusResult, SyncError>
   }
->() {}
+>()("@knpkv/confluence-to-markdown/SyncEngine") {}
 
 /**
  * Layer that provides SyncEngine.
@@ -148,7 +185,14 @@ export class SyncEngine extends Context.Tag(
 export const layer: Layer.Layer<
   SyncEngine,
   never,
-  ConfluenceClient | ConfluenceConfig | MarkdownConverter | LocalFileSystem | Path.Path | GitService | UserCache
+  | ConfluenceClient
+  | ConfluenceConfig
+  | MarkdownConverter
+  | LocalFileSystem
+  | Path.Path
+  | GitService
+  | UserCache
+  | FileSystem.FileSystem
 > = Layer.effect(
   SyncEngine,
   Effect.gen(function*() {
@@ -157,10 +201,69 @@ export const layer: Layer.Layer<
     const converter = yield* MarkdownConverter
     const localFs = yield* LocalFileSystem
     const pathService = yield* Path.Path
+    const fs = yield* FileSystem.FileSystem
     const git = yield* GitService
     const userCache = yield* UserCache
 
-    const docsPath = pathService.join(process.cwd(), config.docsPath)
+    const cwd = pathService.resolve(".")
+    const docsPath = pathService.join(cwd, config.docsPath)
+
+    const adfMetadataPath = (filePath: string, pageId?: string): string =>
+      pageId
+        ? pathService.join(pathService.dirname(filePath), `${pageId}.adf.json`)
+        : filePath.replace(/\.md$/, ".adf.json")
+
+    const adfMetadataHref = (filePath: string, pageId?: string): string =>
+      `./${pathService.basename(adfMetadataPath(filePath, pageId))}`
+
+    const prepareMarkdownForFile = (filePath: string, markdown: string, pageId?: string) =>
+      externalizeAdfMetadata(markdown, adfMetadataHref(filePath, pageId))
+
+    const writePreparedMarkdownWithAdfMetadata = (
+      filePath: string,
+      frontMatter: PageFrontMatter,
+      prepared: ReturnType<typeof externalizeAdfMetadata>
+    ): Effect.Effect<void, FileSystemError> =>
+      Effect.gen(function*() {
+        yield* localFs.writeMarkdownFile(filePath, frontMatter, prepared.markdown)
+        const sidecarPath = adfMetadataPath(filePath, frontMatter.pageId)
+        if (prepared.sidecar !== null) {
+          yield* localFs.writeFile(
+            sidecarPath,
+            JSON.stringify(prepared.sidecar, null, 2) + "\n"
+          )
+        } else if (yield* localFs.exists(sidecarPath)) {
+          yield* localFs.deleteFile(sidecarPath)
+        }
+      })
+
+    const readAdfMetadataSidecar = (sidecarPath: string): Effect.Effect<AdfMetadataSidecar | null, FileSystemError> =>
+      Effect.gen(function*() {
+        const exists = yield* localFs.exists(sidecarPath)
+        if (!exists) return null
+        const raw = yield* fs.readFileString(sidecarPath).pipe(
+          Effect.mapError((cause) => new FileSystemError({ operation: "read", path: sidecarPath, cause }))
+        )
+        const parsed = yield* Effect.try({
+          try: () => JSON.parse(raw) as unknown,
+          catch: (cause) => new FileSystemError({ operation: "read", path: sidecarPath, cause })
+        })
+        return yield* Schema.decodeUnknownEffect(AdfMetadataSidecarSchema)(parsed).pipe(
+          Effect.mapError((cause) => new FileSystemError({ operation: "read", path: sidecarPath, cause }))
+        )
+      })
+
+    const hydrateMarkdownForFile = (filePath: string, markdown: string): Effect.Effect<string, FileSystemError> =>
+      Effect.gen(function*() {
+        const sidecars = new Map<string, AdfMetadataSidecar>()
+        const dir = pathService.dirname(filePath)
+        for (const href of collectAdfMetadataHrefs(markdown)) {
+          const sidecarPath = pathService.resolve(dir, href)
+          const sidecar = yield* readAdfMetadataSidecar(sidecarPath)
+          if (sidecar !== null) sidecars.set(href, sidecar)
+        }
+        return hydrateAdfMetadata(markdown, sidecars)
+      })
 
     /**
      * Build a map of relative path (without .md) to pageId for resolving parents.
@@ -320,25 +423,30 @@ export const layer: Layer.Layer<
      */
     const getUser = (accountId: string): Effect.Effect<AtlassianUser | undefined, ApiError | RateLimitError> =>
       userCache.getOrFetch(accountId, client.getUser).pipe(
-        Effect.catchAll(() => Effect.succeed(undefined))
+        Effect.catchCause(() => Effect.succeed(undefined))
       )
 
     /**
      * Convert version content to markdown and front-matter.
      */
     const versionToMarkdown = (
+      filePath: string,
       pageId: PageId,
       version: PageVersionContent,
       title: string,
       parentId?: string,
       position?: number
-    ): Effect.Effect<{ markdown: string; frontMatter: PageFrontMatter }, SyncError> =>
+    ): Effect.Effect<{
+      markdown: string
+      frontMatter: PageFrontMatter
+      prepared: ReturnType<typeof externalizeAdfMetadata>
+    }, SyncError> =>
       Effect.gen(function*() {
-        const htmlContent = version.body?.storage?.value ?? ""
-        const markdown = yield* converter.htmlToMarkdown(htmlContent, {
-          includeRawSource: config.saveSource
-        })
-        const contentHash = yield* computeHash(markdown).pipe(Effect.provide(HashServiceLive))
+        const adfJson = version.body?.atlas_doc_format?.value ?? ""
+        const rawMarkdown = yield* converter.adfToMarkdown(adfJson)
+        const prepared = prepareMarkdownForFile(filePath, rawMarkdown, pageId)
+        const { markdown } = prepared
+        const contentHash = yield* hashBody(markdown)
 
         // Get author info
         const author = version.authorId ? yield* getUser(version.authorId) : undefined
@@ -356,7 +464,7 @@ export const layer: Layer.Layer<
           ...(author?.email ? { authorEmail: author.email } : {})
         }
 
-        return { markdown, frontMatter }
+        return { markdown, frontMatter, prepared }
       })
 
     /**
@@ -369,7 +477,11 @@ export const layer: Layer.Layer<
       options: PullOptions,
       gitInitialized: boolean,
       knownParentId?: string
-    ): Effect.Effect<{ pulled: number; commits: number }, SyncError> =>
+    ): Effect.Effect<
+      { pulled: number; commits: number },
+      SyncError | PlatformError.PlatformError,
+      Terminal.Terminal
+    > =>
       Effect.gen(function*() {
         const pageId = page.id as PageId
         // Get children to determine if this is a folder
@@ -430,11 +542,11 @@ export const layer: Layer.Layer<
             versionIdx++
             // Report progress
             if (options.onProgress) {
-              options.onProgress(versionIdx, totalVersions, `${fullPage.title} v${versionInfo.number}`)
+              yield* options.onProgress(versionIdx, totalVersions, `${fullPage.title} v${versionInfo.number}`)
             }
 
             // Check if body content is available from the versions list
-            const bodyContent = versionInfo.page?.body?.storage?.value
+            const bodyContent = versionInfo.page?.body?.atlas_doc_format?.value
             if (!bodyContent) {
               // No body content available - history replay not supported
               historyReplayFailed = true
@@ -448,13 +560,14 @@ export const layer: Layer.Layer<
               createdAt: versionInfo.createdAt,
               message: versionInfo.message,
               body: {
-                storage: {
+                atlas_doc_format: {
                   value: bodyContent,
-                  representation: "storage" as const
+                  representation: "atlas_doc_format" as const
                 }
               }
             }
-            const { frontMatter, markdown } = yield* versionToMarkdown(
+            const { frontMatter, prepared } = yield* versionToMarkdown(
+              filePath,
               pageId,
               versionContent,
               versionInfo.page?.title ?? fullPage.title,
@@ -463,12 +576,12 @@ export const layer: Layer.Layer<
             )
 
             // Write file
-            yield* localFs.writeMarkdownFile(filePath, frontMatter, markdown)
+            yield* writePreparedMarkdownWithAdfMetadata(filePath, frontMatter, prepared)
 
-            // Save source HTML if configured
-            if (config.saveSource && versionContent.body?.storage?.value) {
-              const sourceFilePath = filePath.replace(/\.md$/, ".html")
-              yield* localFs.writeFile(sourceFilePath, versionContent.body.storage.value)
+            // Save source ADF JSON if configured
+            if (config.saveSource && versionContent.body?.atlas_doc_format?.value) {
+              const sourceFilePath = filePath.replace(/\.md$/, ".source.json")
+              yield* localFs.writeFile(sourceFilePath, prettyAdf(versionContent.body.atlas_doc_format.value))
             }
 
             // Commit this version
@@ -501,10 +614,8 @@ export const layer: Layer.Layer<
           }
 
           // Simple pull without history replay
-          const htmlContent = fullPage.body?.storage?.value ?? ""
-          let markdown = yield* converter.htmlToMarkdown(htmlContent, {
-            includeRawSource: config.saveSource
-          })
+          const adfJson = fullPage.body?.atlas_doc_format?.value ?? ""
+          let rawMarkdown = yield* converter.adfToMarkdown(adfJson)
 
           // Add child page links for index pages
           if (hasChildren && config.spaceKey) {
@@ -514,10 +625,12 @@ export const layer: Layer.Layer<
                 return `- [${child.title}](${pageUrl})`
               })
               .join("\n")
-            markdown = markdown.trim() + "\n\n## Child Pages\n\n" + childLinks + "\n"
+            rawMarkdown = rawMarkdown.trim() + "\n\n## Child Pages\n\n" + childLinks + "\n"
           }
 
-          const contentHash = yield* computeHash(markdown).pipe(Effect.provide(HashServiceLive))
+          const prepared = prepareMarkdownForFile(filePath, rawMarkdown, pageId)
+          const { markdown } = prepared
+          const contentHash = yield* hashBody(markdown)
 
           // Get author info
           const author = fullPage.version.authorId ? yield* getUser(fullPage.version.authorId) : undefined
@@ -536,12 +649,12 @@ export const layer: Layer.Layer<
             ...(author?.email ? { authorEmail: author.email } : {})
           }
 
-          yield* localFs.writeMarkdownFile(filePath, frontMatter, markdown)
+          yield* writePreparedMarkdownWithAdfMetadata(filePath, frontMatter, prepared)
 
-          // Save source HTML if configured
-          if (config.saveSource && htmlContent) {
-            const sourceFilePath = filePath.replace(/\.md$/, ".html")
-            yield* localFs.writeFile(sourceFilePath, htmlContent)
+          // Save source ADF JSON if configured
+          if (config.saveSource && adfJson) {
+            const sourceFilePath = filePath.replace(/\.md$/, ".source.json")
+            yield* localFs.writeFile(sourceFilePath, prettyAdf(adfJson))
           }
         }
 
@@ -558,7 +671,9 @@ export const layer: Layer.Layer<
         return { pulled: 1 + childPulled, commits: totalCommits + childCommits }
       })
 
-    const pull = (options: PullOptions): Effect.Effect<PullResult, SyncError> =>
+    const pull = (
+      options: PullOptions
+    ): Effect.Effect<PullResult, SyncError | PlatformError.PlatformError, Terminal.Terminal> =>
       Effect.gen(function*() {
         yield* localFs.ensureDir(docsPath)
 
@@ -576,31 +691,55 @@ export const layer: Layer.Layer<
           yield* git.checkout("origin/confluence")
         }
 
-        const rootPage = yield* client.getPage(config.rootPageId)
-        const result = yield* pullPage(rootPage, docsPath, options, gitInitialized)
+        const pullAndMerge = Effect.gen(function*() {
+          const rootPage = yield* client.getPage(config.rootPageId)
+          const result = yield* pullPage(rootPage, docsPath, options, gitInitialized)
 
-        // If git is initialized and we have changes but didn't replay history, auto-commit
-        if (gitInitialized && !options.replayHistory && result.pulled > 0) {
-          yield* git.addAll()
-          yield* git.commit({
-            message: `Pull from Confluence (${result.pulled} page${result.pulled !== 1 ? "s" : ""})`
-          }).pipe(Effect.catchTag("GitNoChangesError", () => Effect.void))
-        }
+          // If git is initialized and we have changes but didn't replay history, auto-commit
+          if (gitInitialized && !options.replayHistory && result.pulled > 0) {
+            yield* git.addAll()
+            yield* git.commit({
+              message: `Pull from Confluence (${result.pulled} page${result.pulled !== 1 ? "s" : ""})`
+            }).pipe(Effect.catchTag("GitNoChangesError", () => Effect.void))
+          }
 
-        // Two-branch model: merge origin/confluence into current branch
-        if (hasRemoteBranch && originalBranch && originalBranch !== "origin/confluence") {
-          yield* git.checkout(originalBranch)
-          yield* git.merge("origin/confluence", {
-            message: `Merge remote changes from Confluence`
-          }).pipe(Effect.catchAll(() => Effect.void)) // May fail if no changes
-        }
+          // Two-branch model: merge origin/confluence into current branch
+          if (hasRemoteBranch && originalBranch && originalBranch !== "origin/confluence") {
+            yield* git.checkout(originalBranch)
+            yield* git.merge("origin/confluence", {
+              message: `Merge remote changes from Confluence`
+            }).pipe(Effect.catchIf(() => true, () => Effect.void)) // May fail if no changes
+          }
 
-        return {
-          pulled: result.pulled,
-          skipped: 0,
-          commits: result.commits,
-          errors: [] as ReadonlyArray<string>
-        }
+          return {
+            pulled: result.pulled,
+            skipped: 0,
+            commits: result.commits,
+            errors: [] as ReadonlyArray<string>
+          }
+        })
+
+        // Any failure after the origin/confluence checkout (API, conversion,
+        // git) must not strand the repo on a detached HEAD — same protection
+        // as findUnpushedCommits. On success this re-checkout is a no-op.
+        // The restore itself can fail (a half-written pull leaves dirty files
+        // that differ between branches); that must be loud, not swallowed.
+        return yield* pullAndMerge.pipe(
+          Effect.ensuring(
+            hasRemoteBranch && originalBranch
+              ? git.checkout(originalBranch).pipe(
+                Effect.catchCause((cause) =>
+                  Effect.logWarning(
+                    `pull: could not restore branch '${originalBranch}' — the repo may still be on origin/confluence. ` +
+                      `Restore manually with \`git checkout ${originalBranch}\` (stash local changes first if needed). Cause: ${
+                        String(cause)
+                      }`
+                  )
+                )
+              )
+              : Effect.void
+          )
+        )
       })
 
     /**
@@ -627,22 +766,18 @@ export const layer: Layer.Layer<
 
           // For new pages, re-parse front-matter to get title
           // The localFile only has the content (body), not the original front-matter
-          const title = yield* Effect.tryPromise({
-            try: async () => {
-              const fs = await import("node:fs/promises")
-              const matter = await import("gray-matter")
-              const rawFile = await fs.readFile(filePath, "utf-8")
-              const parsed = matter.default(rawFile)
-              return (parsed.data as { title?: string }).title ?? baseName
-            },
-            catch: (cause) => new FileSystemError({ operation: "read", path: filePath, cause })
-          })
+          const rawFile = yield* fs.readFileString(filePath).pipe(
+            Effect.mapError((cause) => new FileSystemError({ operation: "read", path: filePath, cause }))
+          )
+          const parsed = yield* parseMarkdown(filePath, rawFile)
+          const title = parsed.frontMatter?.title ?? baseName
 
           // Resolve parent from directory structure
           const parentId = yield* resolveParent(filePath, pageIdMap)
 
-          // Convert markdown to HTML
-          const html = yield* converter.markdownToHtml(localFile.content)
+          // Convert markdown to ADF
+          const hydratedContent = yield* hydrateMarkdownForFile(filePath, localFile.content)
+          const adfValue = yield* converter.markdownToAdf(hydratedContent)
 
           // Create the page
           const createdPage = yield* client.createPage({
@@ -650,14 +785,14 @@ export const layer: Layer.Layer<
             parentId,
             title,
             body: {
-              representation: "storage",
-              value: html
+              representation: "atlas_doc_format",
+              value: adfValue
             }
           })
 
           // Set editor version to v2 (new editor)
           yield* client.setEditorVersion(createdPage.id as PageId, "v2").pipe(
-            Effect.catchAll((error) => {
+            Effect.catchIf(() => true, (error) => {
               // Log warning but don't fail the push
               return Effect.logWarning(`Failed to set editor v2 for page ${createdPage.id}: ${error.message}`)
             })
@@ -665,11 +800,11 @@ export const layer: Layer.Layer<
 
           // Fetch canonical content back from Confluence
           const canonicalPage = yield* client.getPage(createdPage.id as PageId)
-          const canonicalHtml = canonicalPage.body?.storage?.value ?? ""
-          const canonicalMarkdown = yield* converter.htmlToMarkdown(canonicalHtml, {
-            includeRawSource: config.saveSource
-          })
-          const canonicalHash = yield* computeHash(canonicalMarkdown).pipe(Effect.provide(HashServiceLive))
+          const canonicalAdf = canonicalPage.body?.atlas_doc_format?.value ?? ""
+          const rawCanonicalMarkdown = yield* converter.adfToMarkdown(canonicalAdf)
+          const preparedCanonicalMarkdown = prepareMarkdownForFile(filePath, rawCanonicalMarkdown, createdPage.id)
+          const { markdown: canonicalMarkdown } = preparedCanonicalMarkdown
+          const canonicalHash = yield* hashBody(canonicalMarkdown)
 
           // Write canonical content with full front-matter
           const newFrontMatter: PageFrontMatter = {
@@ -680,7 +815,7 @@ export const layer: Layer.Layer<
             parentId: parentId as PageId,
             contentHash: canonicalHash
           }
-          yield* localFs.writeMarkdownFile(filePath, newFrontMatter, canonicalMarkdown)
+          yield* writePreparedMarkdownWithAdfMetadata(filePath, newFrontMatter, preparedCanonicalMarkdown)
 
           // Update pageIdMap with new page
           const key = relativePath.replace(/\.md$/, "")
@@ -698,7 +833,8 @@ export const layer: Layer.Layer<
 
         // Fetch current version to avoid conflicts
         const remotePage = yield* client.getPage(fm.pageId)
-        const html = yield* converter.markdownToHtml(localFile.content)
+        const hydratedContent = yield* hydrateMarkdownForFile(filePath, localFile.content)
+        const adfValue = yield* converter.markdownToAdf(hydratedContent)
         const updatedPage = yield* client.updatePage({
           id: fm.pageId,
           title: fm.title,
@@ -708,18 +844,18 @@ export const layer: Layer.Layer<
             message: revisionMessage
           },
           body: {
-            representation: "storage",
-            value: html
+            representation: "atlas_doc_format",
+            value: adfValue
           }
         })
 
         // Fetch canonical content back from Confluence
         const canonicalPage = yield* client.getPage(fm.pageId)
-        const canonicalHtml = canonicalPage.body?.storage?.value ?? ""
-        const canonicalMarkdown = yield* converter.htmlToMarkdown(canonicalHtml, {
-          includeRawSource: config.saveSource
-        })
-        const canonicalHash = yield* computeHash(canonicalMarkdown).pipe(Effect.provide(HashServiceLive))
+        const canonicalAdf = canonicalPage.body?.atlas_doc_format?.value ?? ""
+        const rawCanonicalMarkdown = yield* converter.adfToMarkdown(canonicalAdf)
+        const preparedCanonicalMarkdown = prepareMarkdownForFile(filePath, rawCanonicalMarkdown, fm.pageId)
+        const { markdown: canonicalMarkdown } = preparedCanonicalMarkdown
+        const canonicalHash = yield* hashBody(canonicalMarkdown)
 
         // Write canonical content with updated front-matter
         const newFrontMatter: PageFrontMatter = {
@@ -728,7 +864,7 @@ export const layer: Layer.Layer<
           updated: new Date(canonicalPage.version.createdAt ?? new Date().toISOString()),
           contentHash: canonicalHash
         }
-        yield* localFs.writeMarkdownFile(filePath, newFrontMatter, canonicalMarkdown)
+        yield* writePreparedMarkdownWithAdfMetadata(filePath, newFrontMatter, preparedCanonicalMarkdown)
 
         return { pushed: true, created: false }
       })
@@ -759,34 +895,45 @@ export const layer: Layer.Layer<
         const allCommits = yield* git.log({ n: 100 })
         if (allCommits.length === 0) return []
 
-        const unpushed: Array<{ hash: string; message: string }> = []
-
-        for (const commit of allCommits) {
-          yield* git.checkout(commit.hash)
-
-          let hasChanges = false
-          for (const filePath of files) {
-            const exists = yield* localFs.exists(filePath)
-            if (!exists) continue
+        // We checkout each commit to compare content; restore HEAD before returning
+        // so subsequent pushFile() calls see the working-tree content the user staged,
+        // not whatever commit we last inspected.
+        const originalBranch = yield* git.getCurrentBranch()
+
+        const collect = Effect.gen(function*() {
+          const unpushed: Array<{ hash: string; message: string }> = []
+          for (const commit of allCommits) {
+            yield* git.checkout(commit.hash)
+
+            let hasChanges = false
+            for (const filePath of files) {
+              const exists = yield* localFs.exists(filePath)
+              if (!exists) continue
+
+              const localFile = yield* localFs.readMarkdownFile(filePath)
+              if (!localFile.frontMatter) {
+                hasChanges = true
+                break
+              }
 
-            const localFile = yield* localFs.readMarkdownFile(filePath)
-            if (!localFile.frontMatter) {
-              hasChanges = true
-              break
+              const currentHash = yield* computeHash(localFile.content).pipe(Effect.provide(HashServiceLive))
+              if (currentHash !== localFile.frontMatter.contentHash) {
+                hasChanges = true
+                break
+              }
             }
 
-            const currentHash = yield* computeHash(localFile.content).pipe(Effect.provide(HashServiceLive))
-            if (currentHash !== localFile.frontMatter.contentHash) {
-              hasChanges = true
-              break
-            }
+            if (!hasChanges) break
+            unpushed.push({ hash: commit.hash, message: commit.message })
           }
+          return unpushed.reverse()
+        })
 
-          if (!hasChanges) break
-          unpushed.push({ hash: commit.hash, message: commit.message })
-        }
-
-        return unpushed.reverse()
+        return yield* collect.pipe(
+          Effect.ensuring(
+            originalBranch ? git.checkout(originalBranch).pipe(Effect.ignore) : Effect.void
+          )
+        )
       })
 
     const push = (options: { dryRun: boolean; message?: string }): Effect.Effect<PushResult, SyncError> =>
@@ -827,13 +974,12 @@ export const layer: Layer.Layer<
               spaceId,
               pageIdMap
             ).pipe(
-              Effect.catchAll((error) =>
+              Effect.catchIf(() => true, (error) =>
                 Effect.succeed({
                   pushed: false,
                   created: false,
                   error: `Failed: ${error._tag}`
-                })
-              )
+                }))
             )
             if (result.error) errors.push(result.error)
             if (result.pushed) pushed++
@@ -890,13 +1036,13 @@ export const layer: Layer.Layer<
                 const match = content.match(/pageId:\s*['"]?(\d+)['"]?/)
                 return match ? match[1] : null
               }),
-              Effect.catchAll(() => Effect.succeed(null))
+              Effect.catchIf(() => true, () => Effect.succeed(null))
             )
 
             if (pageIdFromOrigin) {
               yield* client.deletePage(PageId(pageIdFromOrigin)).pipe(
                 Effect.tap(() => Effect.sync(() => deleted++)),
-                Effect.catchAll((error) => {
+                Effect.catchIf(() => true, (error) => {
                   errors.push(`Failed to delete page ${pageIdFromOrigin}: ${error.message}`)
                   return Effect.void
                 })
@@ -907,13 +1053,12 @@ export const layer: Layer.Layer<
 
         for (const filePath of sortedFiles) {
           const result = yield* pushFile(filePath, revisionMessage, spaceId, pageIdMap).pipe(
-            Effect.catchAll((error) =>
+            Effect.catchIf(() => true, (error) =>
               Effect.succeed({
                 pushed: false,
                 created: false,
                 error: `Failed to push ${filePath}: ${error._tag}`
-              })
-            )
+              }))
           )
           if (result.error) errors.push(result.error)
           if (result.pushed) pushed++
@@ -923,7 +1068,7 @@ export const layer: Layer.Layer<
         // Amend the last commit with canonical content
         yield* git.addAll()
         yield* git.amend({ noEdit: true }).pipe(
-          Effect.catchAll(() => Effect.void)
+          Effect.catchIf(() => true, () => Effect.void)
         )
 
         // Two-branch model: update origin/confluence to match HEAD
@@ -959,15 +1104,15 @@ export const layer: Layer.Layer<
           const currentHash = yield* computeHash(localFile.content).pipe(Effect.provide(HashServiceLive))
 
           // Fetch remote page
-          const remotePage = yield* Effect.either(client.getPage(fm.pageId))
+          const remotePage = yield* Effect.result(client.getPage(fm.pageId))
 
-          if (remotePage._tag === "Left") {
+          if (Result.isFailure(remotePage)) {
             statuses.push({ _tag: "LocalOnly", path: filePath, title: fm.title })
             localOnly++
             continue
           }
 
-          const page = remotePage.right
+          const page = remotePage.success
           const localChanged = currentHash !== fm.contentHash
           const remoteChanged = page.version.number > fm.version