@knpkv/confluence-to-markdown 0.2.0 → 0.4.1

package/src/commands/git.ts

@@ -0,0 +1,114 @@
+/**
+ * Git commands (commit, log, diff) for Confluence CLI.
+ */
+import { Args, Command, Options } from "@effect/cli"
+import * as Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import { ConfluenceConfig } from "../ConfluenceConfig.js"
+import { GitService } from "../GitService.js"
+
+// === Commit command ===
+const commitMessageOption = Options.text("message").pipe(
+  Options.withAlias("m"),
+  Options.withDescription("Commit message"),
+  Options.optional
+)
+
+export const commitCommand = Command.make(
+  "commit",
+  { message: commitMessageOption },
+  ({ message }) =>
+    Effect.gen(function*() {
+      const git = yield* GitService
+      const config = yield* ConfluenceConfig
+
+      // Sync from external docs path to .confluence/ (skips if docsPath is inside .confluence/)
+      yield* git.syncFromDocs(config.docsPath, config.trackedPaths)
+
+      yield* git.addAll()
+      const msg = Option.isSome(message) ? message.value : "Manual commit"
+      const hash = yield* git.commit({ message: msg })
+      yield* Console.log(`Committed: ${hash.substring(0, 7)}`)
+    })
+).pipe(Command.withDescription("Stage and commit current changes"))
+
+// === Log command ===
+const logLimitOption = Options.integer("limit").pipe(
+  Options.withAlias("n"),
+  Options.withDescription("Number of commits to show"),
+  Options.withDefault(10)
+)
+
+const logOnelineOption = Options.boolean("oneline").pipe(
+  Options.withDescription("Show compact one-line format")
+)
+
+const logSinceOption = Options.text("since").pipe(
+  Options.withDescription("Show commits since date (e.g., '2024-01-01')"),
+  Options.optional
+)
+
+const logFileArg = Args.text({ name: "file" }).pipe(Args.optional) as Args.Args<Option.Option<string>>
+
+export const logCommand = Command.make(
+  "log",
+  { limit: logLimitOption, oneline: logOnelineOption, since: logSinceOption, file: logFileArg },
+  ({ file, limit, oneline, since }) =>
+    Effect.gen(function*() {
+      const git = yield* GitService
+      const opts = {
+        n: limit,
+        oneline,
+        ...(Option.isSome(since) ? { since: since.value } : {}),
+        ...(Option.isSome(file) ? { file: file.value } : {})
+      }
+      const commits = yield* git.log(opts)
+      if (commits.length === 0) {
+        yield* Console.log("No commits yet")
+      } else if (oneline) {
+        for (const commit of commits) {
+          yield* Console.log(`${commit.hash.substring(0, 7)} ${commit.message}`)
+        }
+      } else {
+        for (const commit of commits) {
+          yield* Console.log(`commit ${commit.hash}`)
+          yield* Console.log(`Author: ${commit.author} <${commit.email}>`)
+          yield* Console.log(`Date:   ${commit.date.toISOString()}`)
+          yield* Console.log(`\n    ${commit.message}\n`)
+        }
+      }
+    })
+).pipe(Command.withDescription("Show commit history"))
+
+// === Diff command ===
+const diffStagedOption = Options.boolean("staged").pipe(
+  Options.withDescription("Show staged changes")
+)
+
+const diffCommitOption = Options.text("commit").pipe(
+  Options.withDescription("Compare with specific commit"),
+  Options.optional
+)
+
+const diffFileArg = Args.text({ name: "file" }).pipe(Args.optional) as Args.Args<Option.Option<string>>
+
+export const diffCommand = Command.make(
+  "diff",
+  { staged: diffStagedOption, commit: diffCommitOption, file: diffFileArg },
+  ({ commit, file, staged }) =>
+    Effect.gen(function*() {
+      const git = yield* GitService
+      const opts = {
+        staged,
+        ...(Option.isSome(commit) ? { commit: commit.value } : {}),
+        ...(Option.isSome(file) ? { file: file.value } : {})
+      }
+      const diff = yield* git.diff(opts)
+      if (diff === "") {
+        yield* Console.log("No changes")
+      } else {
+        yield* Console.log(diff)
+      }
+    })
+).pipe(Command.withDescription("Show changes in working directory"))

package/src/commands/index.ts

@@ -0,0 +1,10 @@
+/**
+ * CLI commands for confluence-to-markdown.
+ */
+export { authCommand } from "./auth.js"
+export { cloneCommand } from "./clone.js"
+export { deleteCommand } from "./delete.js"
+export { commitCommand, diffCommand, logCommand } from "./git.js"
+export { newCommand } from "./new.js"
+export { getAuth } from "./shared.js"
+export { pullCommand, pushCommand, statusCommand } from "./sync.js"

package/src/commands/layers.ts

@@ -0,0 +1,211 @@
+/**
+ * Layer definitions for CLI commands.
+ */
+import * as NodeContext from "@effect/platform-node/NodeContext"
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as NodeTerminal from "@effect/platform-node/NodeTerminal"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type { PageId } from "../Brand.js"
+import { ConfluenceAuth, layer as ConfluenceAuthLayer } from "../ConfluenceAuth.js"
+import { ConfluenceClient, type ConfluenceClientConfig, layer as ConfluenceClientLayer } from "../ConfluenceClient.js"
+import {
+  ConfluenceConfig,
+  layer as ConfluenceConfigLayer,
+  layerFromValues as ConfluenceConfigLayerFromValues
+} from "../ConfluenceConfig.js"
+import { GitService, layer as GitServiceLayer } from "../GitService.js"
+import { UserCacheLayer } from "../internal/userCache.js"
+import { layer as LocalFileSystemLayer } from "../LocalFileSystem.js"
+import { layer as MarkdownConverterLayer } from "../MarkdownConverter.js"
+import { layer as SyncEngineLayer, SyncEngine } from "../SyncEngine.js"
+import { getAuth } from "./shared.js"
+
+// Dummy config layer for help/init
+const DummyConfigLayer = ConfluenceConfigLayerFromValues({
+  rootPageId: "dummy" as PageId,
+  baseUrl: "https://dummy.atlassian.net",
+  docsPath: ".confluence/docs",
+  excludePatterns: [],
+  saveSource: false,
+  trackedPaths: ["**/*.md"]
+})
+
+// Dummy client layer for help/init (will fail if actually used)
+const DummyConfluenceClientLayer = Layer.succeed(
+  ConfluenceClient,
+  ConfluenceClient.of({
+    getPage: () => Effect.dieMessage("Not configured"),
+    getChildren: () => Effect.dieMessage("Not configured"),
+    getAllChildren: () => Effect.dieMessage("Not configured"),
+    createPage: () => Effect.dieMessage("Not configured"),
+    updatePage: () => Effect.dieMessage("Not configured"),
+    deletePage: () => Effect.dieMessage("Not configured"),
+    getPageVersions: () => Effect.dieMessage("Not configured"),
+    getUser: () => Effect.dieMessage("Not configured"),
+    getSpaceId: () => Effect.dieMessage("Not configured"),
+    setEditorVersion: () => Effect.dieMessage("Not configured")
+  })
+)
+
+// Dummy sync engine that will fail if actually used
+const DummySyncEngineLayer = Layer.succeed(
+  SyncEngine,
+  SyncEngine.of({
+    pull: () => Effect.dieMessage("Not configured - run 'confluence clone' first"),
+    push: (_options: { dryRun: boolean; message?: string }) =>
+      Effect.dieMessage("Not configured - run 'confluence clone' first"),
+    status: () => Effect.dieMessage("Not configured - run 'confluence clone' first")
+  })
+)
+
+// Dummy git layer for auth/minimal
+const notConfigured = () => Effect.dieMessage("Not configured - run 'confluence clone' first")
+const DummyGitServiceLayer = Layer.succeed(
+  GitService,
+  GitService.of({
+    validateGit: notConfigured,
+    init: notConfigured,
+    isInitialized: () => Effect.succeed(false),
+    status: notConfigured,
+    commit: notConfigured,
+    log: notConfigured,
+    diff: notConfigured,
+    addAll: notConfigured,
+    hasConflicts: () => Effect.succeed(false),
+    mergeContinue: notConfigured,
+    syncFromDocs: notConfigured,
+    syncToDocs: notConfigured,
+    getHead: notConfigured,
+    getCurrentBranch: notConfigured,
+    createBranch: notConfigured,
+    checkout: notConfigured,
+    reset: notConfigured,
+    deleteBranch: notConfigured,
+    getParent: notConfigured,
+    cherryPick: (_ref: string, _options?: { strategy?: "ours" | "theirs" }) => notConfigured(),
+    getChangedFiles: notConfigured,
+    showFile: notConfigured,
+    amend: notConfigured,
+    logRange: notConfigured,
+    branchExists: notConfigured,
+    updateBranch: notConfigured,
+    merge: notConfigured,
+    getDeletedFiles: notConfigured,
+    getFileContentAt: notConfigured
+  })
+)
+
+// Dummy auth layer for init/help
+const DummyConfluenceAuthLayer = Layer.succeed(
+  ConfluenceAuth,
+  ConfluenceAuth.of({
+    configure: () => Effect.dieMessage("Not configured"),
+    isConfigured: () => Effect.succeed(false),
+    login: () => Effect.dieMessage("Not configured"),
+    logout: () => Effect.dieMessage("Not configured"),
+    getAccessToken: () => Effect.dieMessage("Not configured"),
+    getCloudId: () => Effect.dieMessage("Not configured"),
+    getCurrentUser: () => Effect.succeed(null),
+    isLoggedIn: () => Effect.succeed(false)
+  })
+)
+
+// Auth layer with HTTP client
+const AuthLive = ConfluenceAuthLayer.pipe(Layer.provide(NodeHttpClient.layer))
+
+// Build client layer dynamically based on auth
+const ConfluenceClientLive = Layer.unwrapEffect(
+  Effect.gen(function*() {
+    const auth = yield* getAuth()
+    const config = yield* ConfluenceConfig
+
+    const clientConfig: ConfluenceClientConfig = {
+      baseUrl: config.baseUrl,
+      auth
+    }
+
+    return ConfluenceClientLayer(clientConfig)
+  })
+)
+
+/**
+ * Full app layer with all services.
+ */
+export const AppLayer = SyncEngineLayer.pipe(
+  Layer.provideMerge(UserCacheLayer),
+  Layer.provideMerge(GitServiceLayer),
+  Layer.provideMerge(ConfluenceClientLive),
+  Layer.provideMerge(MarkdownConverterLayer),
+  Layer.provideMerge(LocalFileSystemLayer),
+  Layer.provideMerge(ConfluenceConfigLayer()),
+  Layer.provideMerge(AuthLive),
+  Layer.provideMerge(NodeHttpClient.layer),
+  Layer.provideMerge(NodeContext.layer)
+)
+
+/**
+ * Auth-only layer for login/logout commands.
+ */
+export const AuthOnlyLayer = DummySyncEngineLayer.pipe(
+  Layer.provideMerge(UserCacheLayer),
+  Layer.provideMerge(DummyGitServiceLayer),
+  Layer.provideMerge(DummyConfluenceClientLayer),
+  Layer.provideMerge(AuthLive),
+  Layer.provideMerge(MarkdownConverterLayer),
+  Layer.provideMerge(LocalFileSystemLayer),
+  Layer.provideMerge(DummyConfigLayer),
+  Layer.provideMerge(NodeHttpClient.layer),
+  Layer.provideMerge(NodeContext.layer)
+)
+
+/**
+ * Minimal layer for help - uses real GitService for clone.
+ */
+export const MinimalLayer = DummySyncEngineLayer.pipe(
+  Layer.provideMerge(UserCacheLayer),
+  Layer.provideMerge(GitServiceLayer),
+  Layer.provideMerge(DummyConfluenceClientLayer),
+  Layer.provideMerge(DummyConfluenceAuthLayer),
+  Layer.provideMerge(MarkdownConverterLayer),
+  Layer.provideMerge(LocalFileSystemLayer),
+  Layer.provideMerge(DummyConfigLayer),
+  Layer.provideMerge(NodeTerminal.layer),
+  Layer.provideMerge(NodeContext.layer)
+)
+
+/**
+ * Clone layer - needs auth + git but builds SyncEngine dynamically.
+ */
+export const CloneLayer = DummySyncEngineLayer.pipe(
+  Layer.provideMerge(UserCacheLayer),
+  Layer.provideMerge(GitServiceLayer),
+  Layer.provideMerge(DummyConfluenceClientLayer),
+  Layer.provideMerge(AuthLive),
+  Layer.provideMerge(MarkdownConverterLayer),
+  Layer.provideMerge(LocalFileSystemLayer),
+  Layer.provideMerge(DummyConfigLayer),
+  Layer.provideMerge(NodeHttpClient.layer),
+  Layer.provideMerge(NodeTerminal.layer),
+  Layer.provideMerge(NodeContext.layer)
+)
+
+/**
+ * Determine which layer to use based on command.
+ */
+export const getLayerType = (): "full" | "auth" | "clone" | "minimal" => {
+  const cmd = process.argv[2]
+  // auth commands need auth layer only
+  if (cmd === "auth") {
+    return "auth"
+  }
+  // clone needs auth + git but not config-dependent services
+  if (cmd === "clone") {
+    return "clone"
+  }
+  // --help, -h, --version don't need config
+  if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "--version") {
+    return "minimal"
+  }
+  return "full"
+}

package/src/commands/new.ts

@@ -0,0 +1,99 @@
+/**
+ * New page command for Confluence CLI.
+ */
+import { Command, Prompt } from "@effect/cli"
+import * as Path from "@effect/platform/Path"
+import * as Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import { ConfluenceConfig } from "../ConfluenceConfig.js"
+import { LocalFileSystem } from "../LocalFileSystem.js"
+import { flattenPageTree } from "./pageTree.js"
+
+/** Slugify a title for use as filename */
+const slugify = (title: string): string =>
+  title
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+
+export const newCommand = Command.make("new", {}, () =>
+  Effect.gen(function*() {
+    const localFs = yield* LocalFileSystem
+    const config = yield* ConfluenceConfig
+    const pathService = yield* Path.Path
+
+    const docsPath = pathService.join(process.cwd(), config.docsPath)
+
+    // Build page tree
+    yield* Console.log("Scanning page structure...")
+    const tree = yield* localFs.buildPageTree(docsPath, config.rootPageId, "Root")
+
+    // Check if we have any pages
+    const hasPages = tree.children.length > 0 || tree.pageId !== null
+
+    if (!hasPages) {
+      yield* Console.log("No pages found. Run 'confluence clone' or 'confluence pull' first.")
+      return
+    }
+
+    // Flatten to choices
+    const choices = flattenPageTree(tree)
+
+    // Show parent selector
+    const parent = yield* Prompt.select({
+      message: "Select parent page for the new page:",
+      choices
+    })
+
+    // Prompt for title
+    const title = yield* Prompt.text({
+      message: "Enter page title:"
+    })
+
+    if (!title.trim()) {
+      yield* Console.log("Title cannot be empty")
+      return
+    }
+
+    // Generate filename
+    const filename = `${slugify(title.trim())}.md`
+
+    // Determine file path
+    // If parent is root (path === ""), create in docsPath
+    // If parent has children, create in parent's directory
+    let filePath: string
+    if (parent.path === "") {
+      // Root level
+      filePath = pathService.join(docsPath, filename)
+    } else {
+      // Under a page - check if parent directory exists
+      const parentBasename = pathService.basename(parent.path, ".md")
+      const parentDir = pathService.dirname(parent.path)
+      const targetDir = parentDir === "." ? parentBasename : pathService.join(parentDir, parentBasename)
+      filePath = pathService.join(docsPath, targetDir, filename)
+    }
+
+    // Check if file already exists
+    const exists = yield* localFs.exists(filePath)
+    if (exists) {
+      yield* Console.log(`File already exists: ${filePath}`)
+      return
+    }
+
+    // Write new page file with title-only front-matter
+    yield* localFs.writeNewPageFile(
+      filePath,
+      { title: title.trim() },
+      "\n<!-- Write your page content here -->\n"
+    )
+
+    const relativePath = pathService.relative(process.cwd(), filePath)
+    yield* Console.log(`Created new page: ${relativePath}`)
+    yield* Console.log("")
+    yield* Console.log("Next steps:")
+    yield* Console.log("  1. Edit the file to add content")
+    yield* Console.log("  2. Run 'confluence commit' to stage changes")
+    yield* Console.log("  3. Run 'confluence push' to create on Confluence")
+  })).pipe(Command.withDescription("Create a new page to be pushed to Confluence"))

package/src/commands/pageTree.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared page tree utilities for CLI commands.
+ */
+import type { PageTreeNode } from "../LocalFileSystem.js"
+
+export interface PageChoice {
+  readonly title: string
+  readonly value: {
+    readonly path: string
+    readonly pageId: string | null
+    readonly nodeTitle: string
+  }
+  readonly description?: string
+}
+
+/**
+ * Flatten page tree to choices with indentation for interactive prompts.
+ */
+export const flattenPageTree = (
+  node: PageTreeNode,
+  depth: number = 0
+): ReadonlyArray<PageChoice> => {
+  const indent = "  ".repeat(depth)
+  const prefix = depth === 0 ? "" : "├─ "
+  const choices: Array<PageChoice> = []
+
+  choices.push({
+    title: `${indent}${prefix}${node.title}`,
+    value: { path: node.path, pageId: node.pageId, nodeTitle: node.title },
+    description: node.pageId ? `Page ID: ${node.pageId}` : "Root"
+  })
+
+  for (const child of node.children) {
+    for (const choice of flattenPageTree(child, depth + 1)) {
+      choices.push(choice)
+    }
+  }
+
+  return choices
+}

package/src/commands/shared.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared utilities for CLI commands.
+ */
+import * as Config from "effect/Config"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import { ConfluenceAuth } from "../ConfluenceAuth.js"
+
+const AuthConfig = Config.all({
+  apiKey: Config.string("CONFLUENCE_API_KEY"),
+  email: Config.string("CONFLUENCE_EMAIL")
+})
+
+/**
+ * Get authentication config from env vars or OAuth.
+ */
+export const getAuth = () =>
+  Effect.gen(function*() {
+    // 1. Try env vars first (backwards compat)
+    const envAuth = yield* AuthConfig.pipe(
+      Effect.map(({ apiKey, email }) => ({ type: "token" as const, email, token: apiKey })),
+      Effect.option
+    )
+
+    if (Option.isSome(envAuth)) {
+      return envAuth.value
+    }
+
+    // 2. Try OAuth token
+    const auth = yield* ConfluenceAuth
+    const accessToken = yield* auth.getAccessToken()
+    const cloudId = yield* auth.getCloudId()
+
+    return { type: "oauth2" as const, accessToken, cloudId }
+  })

package/src/commands/sync.ts

@@ -0,0 +1,129 @@
+/**
+ * Sync commands (pull, push, status) for Confluence CLI.
+ */
+import { Command, Options } from "@effect/cli"
+import * as Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import { GitService } from "../GitService.js"
+import { SyncEngine } from "../SyncEngine.js"
+
+// === Pull command ===
+const forceOption = Options.boolean("force").pipe(
+  Options.withAlias("f"),
+  Options.withDescription("Overwrite local changes")
+)
+
+const replayHistoryOption = Options.boolean("replay-history").pipe(
+  Options.withDescription("Replay version history as individual git commits")
+)
+
+export const pullCommand = Command.make(
+  "pull",
+  { force: forceOption, replayHistory: replayHistoryOption },
+  ({ force, replayHistory }) =>
+    Effect.gen(function*() {
+      const engine = yield* SyncEngine
+      yield* Console.log("Pulling pages from Confluence...")
+      const onProgress = (current: number, total: number, message: string) => {
+        process.stdout.write(`\r  Replaying history: ${current}/${total} - ${message}`)
+      }
+      const result = yield* engine.pull({
+        force,
+        replayHistory,
+        ...(replayHistory ? { onProgress } : {})
+      })
+      if (replayHistory) {
+        process.stdout.write("\r" + " ".repeat(80) + "\r")
+      }
+      yield* Console.log(`Pulled ${result.pulled} pages`)
+      if (result.commits > 0) {
+        yield* Console.log(`Created ${result.commits} git commits`)
+      }
+      if (result.errors.length > 0) {
+        yield* Console.error("Errors:", result.errors.join("\n"))
+      }
+    })
+).pipe(Command.withDescription("Download pages from Confluence to local markdown"))
+
+// === Push command ===
+const dryRunOption = Options.boolean("dry-run").pipe(
+  Options.withAlias("n"),
+  Options.withDescription("Show changes without applying")
+)
+
+export const pushCommand = Command.make(
+  "push",
+  { dryRun: dryRunOption },
+  ({ dryRun }) =>
+    Effect.gen(function*() {
+      const engine = yield* SyncEngine
+      const git = yield* GitService
+
+      // Check for uncommitted changes
+      const gitStatus = yield* git.status()
+      if (gitStatus.hasChanges) {
+        yield* Console.log("Uncommitted changes detected. Run 'confluence commit' first.")
+        return
+      }
+
+      yield* Console.log(dryRun ? "Dry run - showing changes..." : "Pushing changes to Confluence...")
+      const result = yield* engine.push({ dryRun })
+      if (result.pushed === 0 && result.created === 0 && result.deleted === 0) {
+        yield* Console.log("Nothing to push")
+      } else {
+        yield* Console.log(`Pushed: ${result.pushed}, Created: ${result.created}, Deleted: ${result.deleted}`)
+      }
+      if (result.errors.length > 0) {
+        yield* Console.error("Errors:", result.errors.join("\n"))
+      }
+    })
+).pipe(Command.withDescription("Upload local markdown changes to Confluence"))
+
+// === Status command ===
+export const statusCommand = Command.make("status", {}, () =>
+  Effect.gen(function*() {
+    const engine = yield* SyncEngine
+    const git = yield* GitService
+
+    // Show git status
+    const gitInit = yield* git.isInitialized()
+    if (gitInit) {
+      const gitStatus = yield* git.status()
+      const commitCount = yield* git.log({ n: 1 }).pipe(
+        Effect.map((commits) => commits.length > 0 ? "has commits" : "no commits"),
+        Effect.catchAll(() => Effect.succeed("unknown"))
+      )
+      yield* Console.log(`Git: initialized (${commitCount})`)
+      if (gitStatus.hasChanges) {
+        const staged = gitStatus.entries.filter((e) => e.staged).length
+        const unstaged = gitStatus.entries.filter((e) => !e.staged).length
+        yield* Console.log(`  Changes: ${staged} staged, ${unstaged} unstaged`)
+      }
+      if (gitStatus.hasConflicts) {
+        yield* Console.log(`  Conflicts: ${gitStatus.conflictedFiles.length} files`)
+      }
+    } else {
+      yield* Console.log("Git: not initialized (run 'confluence git init')")
+    }
+
+    const result = yield* engine.status()
+    yield* Console.log(`
+Sync Status:
+  Synced:          ${result.synced}
+  Local Modified:  ${result.localModified}
+  Remote Modified: ${result.remoteModified}
+  Conflicts:       ${result.conflicts}
+  Local Only:      ${result.localOnly}
+  Remote Only:     ${result.remoteOnly}
+`)
+    if (result.files.length > 0 && result.synced < result.files.length) {
+      yield* Console.log("Changed files:")
+      for (const file of result.files) {
+        if (file._tag !== "Synced" && file._tag !== "RemoteOnly") {
+          yield* Console.log(`  [${file._tag}] ${file.path}`)
+        } else if (file._tag === "RemoteOnly") {
+          yield* Console.log(`  [${file._tag}] ${file.page.title}`)
+        }
+      }
+    }
+  })).pipe(Command.withDescription("Show sync status"))

package/src/index.ts

@@ -7,6 +7,7 @@
  */
 
 export * from "./Brand.js"
+export { ConfluenceAuth, type ConfluenceAuthService, layer as ConfluenceAuthLayer } from "./ConfluenceAuth.js"
 export {
   ConfluenceClient,
   type ConfluenceClientConfig,
@@ -26,10 +27,29 @@ export { layer as MarkdownConverterLayer, MarkdownConverter } from "./MarkdownCo
 export * from "./Schemas.js"
 export {
   layer as SyncEngineLayer,
+  type ProgressCallback,
+  type PullOptions,
   type PullResult,
   type PushResult,
   type StatusResult,
   SyncEngine,
-  type SyncResult,
   type SyncStatus
 } from "./SyncEngine.js"
+
+// AST types
+export * from "./ast/index.js"
+
+// Parsers
+export { parseConfluenceHtml } from "./parsers/ConfluenceParser.js"
+export { parseMarkdown } from "./parsers/MarkdownParser.js"
+
+// Serializers
+export { serializeToConfluence } from "./serializers/ConfluenceSerializer.js"
+export { serializeToMarkdown } from "./serializers/MarkdownSerializer.js"
+
+// Bi-directional schemas
+export { DocumentFromConfluence } from "./schemas/ConfluenceSchema.js"
+export { DocumentFromMarkdown } from "./schemas/MarkdownSchema.js"
+
+// Schema converter errors
+export { MigrationError, ParseError, SerializeError } from "./SchemaConverterError.js"