@knpkv/confluence-to-markdown 0.5.0 → 0.7.0

package/src/atlaskit-adf-schema.d.ts

@@ -0,0 +1,3 @@
+declare module "@atlaskit/adf-schema/dist/cjs/schema/default-schema.js" {
+  export { defaultSchema, defaultSchemaConfig } from "@atlaskit/adf-schema/schema-default"
+}

package/src/bin.ts

@@ -2,69 +2,43 @@
 /**
  * CLI entry point for confluence-to-markdown.
  */
-import { Command } from "@effect/cli"
+import { NodeRuntime, NodeStdio, NodeTerminal } from "@effect/platform-node"
 import * as Effect from "effect/Effect"
-import * as Logger from "effect/Logger"
-import * as LogLevel from "effect/LogLevel"
+import * as Stdio from "effect/Stdio"
+import { Command } from "effect/unstable/cli"
 import pkg from "../package.json" with { type: "json" }
 import { handleError } from "./commands/errorHandler.js"
-import {
-  authCommand,
-  cloneCommand,
-  commitCommand,
-  deleteCommand,
-  diffCommand,
-  logCommand,
-  newCommand,
-  pullCommand,
-  pushCommand,
-  statusCommand
-} from "./commands/index.js"
-import { AppLayer, AuthOnlyLayer, CloneLayer, getLayerType, MinimalLayer } from "./commands/layers.js"
-
-// === Main command ===
-const confluence = Command.make("confluence").pipe(
-  Command.withDescription("Sync Confluence pages to local markdown"),
-  Command.withSubcommands([
-    cloneCommand,
-    authCommand,
-    pullCommand,
-    pushCommand,
-    statusCommand,
-    commitCommand,
-    logCommand,
-    diffCommand,
-    newCommand,
-    deleteCommand
-  ])
-)
+import { AppLayer, AuthOnlyLayer, CloneLayer, FetchLayer, getLayerType, MinimalLayer } from "./commands/layers.js"
+import { confluenceCommand } from "./commands/root.js"
 
 // === Run CLI ===
-const cli = Command.run(confluence, {
-  name: pkg.name,
+const cli = Command.runWith(confluenceCommand, {
   version: pkg.version
 })
 
-const layerType = getLayerType()
-const layer = layerType === "full"
-  ? AppLayer
-  : layerType === "auth"
-  ? AuthOnlyLayer
-  : layerType === "clone"
-  ? CloneLayer
-  : MinimalLayer
+const layerForArgv = (argv: ReadonlyArray<string>) => {
+  const layerType = getLayerType(argv)
+  return layerType === "full"
+    ? AppLayer
+    : layerType === "auth"
+    ? AuthOnlyLayer
+    : layerType === "clone"
+    ? CloneLayer
+    : layerType === "fetch"
+    ? FetchLayer
+    : MinimalLayer
+}
 
 // Suppress verbose Effect logs (e.g. token refresh messages)
-const SilentLogger = Logger.replace(Logger.defaultLogger, Logger.none)
-
-Effect.suspend(() => cli(process.argv)).pipe(
-  Effect.provide(layer),
-  Effect.provide(SilentLogger),
-  Logger.withMinimumLogLevel(LogLevel.None),
-  Effect.runPromiseExit
-).then((exit) => {
-  if (exit._tag === "Failure") {
-    handleError(exit.cause)
-    process.exit(1)
-  }
-})
+Effect.gen(function*() {
+  const stdio = yield* Stdio.Stdio
+  const args = yield* stdio.args
+  return yield* cli(args).pipe(
+    Effect.provide(layerForArgv(args))
+  )
+}).pipe(
+  Effect.provide(NodeTerminal.layer),
+  Effect.provide(NodeStdio.layer),
+  Effect.catchCause((cause) => handleError(cause)),
+  NodeRuntime.runMain({ disableErrorReporting: true })
+)

package/src/commands/auth.ts

@@ -1,12 +1,28 @@
 /**
  * Authentication commands for Confluence CLI.
  */
-import { Command, Options, Prompt } from "@effect/cli"
 import * as Console from "effect/Console"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
+import { Command, Flag as Options, Prompt } from "effect/unstable/cli"
+import { ChildProcessSpawner } from "effect/unstable/process"
+import * as ChildProcess from "effect/unstable/process/ChildProcess"
 import { ConfluenceAuth } from "../ConfluenceAuth.js"
 
+const openBrowser = (url: string) => {
+  const run = (command: ChildProcess.Command) =>
+    Effect.flatMap(ChildProcessSpawner.ChildProcessSpawner, (spawner) =>
+      spawner.exitCode(command).pipe(
+        Effect.flatMap((code) => code === 0 ? Effect.void : Effect.fail(code))
+      ))
+
+  return run(ChildProcess.make("open", [url])).pipe(
+    Effect.catchIf(() => true, () => run(ChildProcess.make("xdg-open", [url]))),
+    Effect.catchIf(() => true, () => run(ChildProcess.make("rundll32.exe", ["url.dll,FileProtocolHandler", url]))),
+    Effect.asVoid
+  )
+}
+
 // === Auth create command ===
 const createCommand = Command.make("create", {}, () =>
   Effect.gen(function*() {
@@ -24,28 +40,15 @@ Creating OAuth app in Atlassian Developer Console...
 6. Run: confluence auth configure --client-id <ID> --client-secret <SECRET>
 `)
     const url = "https://developer.atlassian.com/console/myapps/create-3lo-app/"
-    yield* Effect.promise(() =>
-      import("node:child_process").then((cp) =>
-        new Promise<void>((resolve, reject) => {
-          const platform = process.platform
-          if (platform === "darwin") {
-            cp.execFile("open", [url], (err) => err ? reject(err) : resolve())
-          } else if (platform === "win32") {
-            cp.execFile("cmd", ["/c", "start", "", url], (err) => err ? reject(err) : resolve())
-          } else {
-            cp.execFile("xdg-open", [url], (err) => err ? reject(err) : resolve())
-          }
-        })
-      )
-    )
+    yield* openBrowser(url)
   })).pipe(Command.withDescription("Create OAuth app in Atlassian Developer Console"))
 
 // === Auth configure command ===
-const clientIdOption = Options.text("client-id").pipe(
+const clientIdOption = Options.string("client-id").pipe(
   Options.withDescription("OAuth client ID from Atlassian Developer Console"),
   Options.optional
 )
-const clientSecretOption = Options.text("client-secret").pipe(
+const clientSecretOption = Options.string("client-secret").pipe(
   Options.withDescription("OAuth client secret"),
   Options.optional
 )
@@ -70,7 +73,7 @@ const configureCommand = Command.make(
 ).pipe(Command.withDescription("Configure OAuth client credentials"))
 
 // === Auth login command ===
-const siteOption = Options.text("site").pipe(
+const siteOption = Options.string("site").pipe(
   Options.withDescription("Confluence site URL to use (for accounts with multiple sites)"),
   Options.optional
 )

package/src/commands/clone.ts

@@ -1,57 +1,61 @@
 /**
  * Clone command for Confluence CLI.
  */
-import { Command, Options, Prompt } from "@effect/cli"
-import * as NodeContext from "@effect/platform-node/NodeContext"
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as NodeServices from "@effect/platform-node/NodeServices"
 import * as Console from "effect/Console"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
+import { Command, Flag as Options, Prompt } from "effect/unstable/cli"
+import { layer as AdfSchemaValidatorLayer } from "../AdfSchemaValidator.js"
+import { layer as AtlaskitTransformersLayer } from "../AtlaskitTransformers.js"
 import type { PageId } from "../Brand.js"
 import { type ConfluenceClientConfig, layer as ConfluenceClientLayer } from "../ConfluenceClient.js"
 import { createConfigFile, layerFromValues as ConfluenceConfigLayerFromValues } from "../ConfluenceConfig.js"
 import { ConfigError } from "../ConfluenceError.js"
 import { GitService, layer as GitServiceLayer } from "../GitService.js"
+import { writeStdout } from "../internal/stdio.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 { resolvePageInput } from "./pageInput.js"
 import { getAuth } from "./shared.js"
 
-const rootPageIdOption = Options.text("root-page-id").pipe(
+const ConverterPipeline = MarkdownConverterLayer.pipe(
+  Layer.provide(AtlaskitTransformersLayer),
+  Layer.provide(AdfSchemaValidatorLayer)
+)
+
+const rootPageIdOption = Options.string("root-page-id").pipe(
   Options.withDescription("Confluence root page ID to sync from"),
   Options.optional
 )
 
-const baseUrlOption = Options.text("base-url").pipe(
+const baseUrlOption = Options.string("base-url").pipe(
   Options.withDescription("Confluence Cloud base URL (e.g., https://yoursite.atlassian.net)"),
   Options.optional
 )
 
-/** Validate page ID format */
-const validatePageId = (input: string): Effect.Effect<string, ConfigError> =>
-  input.trim().length > 0
-    ? Effect.succeed(input.trim())
-    : Effect.fail(new ConfigError({ message: "Page ID cannot be empty" }))
-
-/** Validate base URL format */
-const validateBaseUrl = (input: string): Effect.Effect<string, ConfigError> => {
-  const pattern = /^https:\/\/[a-z0-9-]+\.atlassian\.net$/
-  return pattern.test(input)
-    ? Effect.succeed(input)
-    : Effect.fail(
-      new ConfigError({
-        message: `Invalid Confluence URL: ${input}. Expected format: https://yoursite.atlassian.net`
-      })
-    )
-}
+const urlOption = Options.string("url").pipe(
+  Options.withDescription("Confluence root page URL"),
+  Options.optional
+)
 
 export const cloneCommand = Command.make(
   "clone",
-  { rootPageId: rootPageIdOption, baseUrl: baseUrlOption },
-  ({ baseUrl, rootPageId }) =>
+  { rootPageId: rootPageIdOption, baseUrl: baseUrlOption, url: urlOption },
+  ({ baseUrl, rootPageId, url: pageUrl }) =>
     Effect.gen(function*() {
+      const urlInput = Option.isSome(pageUrl)
+        ? yield* resolvePageInput({
+          url: pageUrl.value,
+          pageId: Option.isSome(rootPageId) ? rootPageId.value : undefined,
+          baseUrl: Option.isSome(baseUrl) ? baseUrl.value : undefined
+        })
+        : undefined
+
       const git = yield* GitService
 
       // Fail if .confluence already exists
@@ -71,15 +75,20 @@ export const cloneCommand = Command.make(
       )
       yield* Console.log(`Found git ${gitVersion}`)
 
-      const rawPageId = Option.isSome(rootPageId)
-        ? rootPageId.value
-        : yield* Prompt.text({ message: "Enter Confluence root page ID:" })
-      const rawUrl = Option.isSome(baseUrl)
-        ? baseUrl.value
-        : yield* Prompt.text({ message: "Enter Confluence base URL (e.g., https://yoursite.atlassian.net):" })
+      const input = urlInput ??
+        (yield* Effect.gen(function*() {
+          const rawPageId = Option.isSome(rootPageId)
+            ? rootPageId.value
+            : yield* Prompt.text({ message: "Enter Confluence root page ID:" })
+          const rawUrl = Option.isSome(baseUrl)
+            ? baseUrl.value
+            : yield* Prompt.text({ message: "Enter Confluence base URL (e.g., https://yoursite.atlassian.net):" })
+
+          return yield* resolvePageInput({ pageId: rawPageId, baseUrl: rawUrl })
+        }))
 
-      const pageId = yield* validatePageId(rawPageId)
-      const url = yield* validateBaseUrl(rawUrl)
+      const pageId = input.pageId
+      const url = input.baseUrl
 
       const path = yield* createConfigFile(pageId, url)
       yield* Console.log(`Created configuration file: ${path}`)
@@ -108,17 +117,17 @@ export const cloneCommand = Command.make(
       })
 
       const clientLayer = ConfluenceClientLayer(clientConfig).pipe(
-        Layer.provide(NodeHttpClient.layer)
+        Layer.provide(NodeHttpClient.layerFetch)
       )
 
       const cloneLayer = SyncEngineLayer.pipe(
         Layer.provideMerge(UserCacheLayer),
         Layer.provideMerge(GitServiceLayer),
         Layer.provideMerge(clientLayer),
-        Layer.provideMerge(MarkdownConverterLayer),
+        Layer.provideMerge(ConverterPipeline),
         Layer.provideMerge(LocalFileSystemLayer),
         Layer.provideMerge(configLayer),
-        Layer.provideMerge(NodeContext.layer)
+        Layer.provideMerge(NodeServices.layer)
       )
 
       const result = yield* Effect.gen(function*() {
@@ -127,9 +136,8 @@ export const cloneCommand = Command.make(
         const pullResult = yield* engine.pull({
           force: true,
           replayHistory: true,
-          onProgress: (current, total, message) => {
-            process.stdout.write(`\r  Replaying history: ${current}/${total} - ${message}`)
-          }
+          onProgress: (current, total, message) =>
+            writeStdout(`\r  Replaying history: ${current}/${total} - ${message}`)
         })
 
         // Create origin/confluence branch at HEAD to track remote state
@@ -139,7 +147,7 @@ export const cloneCommand = Command.make(
       }).pipe(Effect.provide(cloneLayer))
 
       // Clear progress line and print final result
-      process.stdout.write("\r" + " ".repeat(80) + "\r")
+      yield* writeStdout("\r" + " ".repeat(80) + "\r")
       yield* Console.log(`Cloned ${result.pulled} pages with ${result.commits} commits`)
     })
 ).pipe(Command.withDescription("Clone Confluence pages with full version history"))

package/src/commands/delete.ts

@@ -4,11 +4,11 @@
  * Interactive mode: select page from tree, delete local file only.
  * Push to actually delete from Confluence.
  */
-import { Command, Prompt } from "@effect/cli"
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as Path from "@effect/platform/Path"
 import * as Console from "effect/Console"
 import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import * as Path from "effect/Path"
+import { Command, Prompt } from "effect/unstable/cli"
 import { ConfluenceConfig } from "../ConfluenceConfig.js"
 import { LocalFileSystem } from "../LocalFileSystem.js"
 import { flattenPageTree } from "./pageTree.js"
@@ -20,7 +20,8 @@ export const deleteCommand = Command.make("delete", {}, () =>
     const pathService = yield* Path.Path
     const fs = yield* FileSystem.FileSystem
 
-    const docsPath = pathService.join(process.cwd(), config.docsPath)
+    const cwd = pathService.resolve(".")
+    const docsPath = pathService.join(cwd, config.docsPath)
 
     // Interactive mode - show page tree, delete local file
     yield* Console.log("Scanning page structure...")

package/src/commands/errorHandler.ts

@@ -7,26 +7,33 @@
  * - NodeRuntime.runMain error reporting shows full cause structure
  */
 import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import { writeStderr } from "../internal/stdio.js"
 
 /**
  * Print errors to stderr without stack traces.
  */
-export const handleError = <E>(cause: Cause.Cause<E>): void => {
-  if (Cause.isEmpty(cause)) return
-
-  for (const error of Cause.failures(cause)) {
-    if (error && typeof error === "object" && "message" in error) {
-      process.stderr.write(`${(error as { message: string }).message}\n`)
-    } else {
-      process.stderr.write(`${String(error)}\n`)
-    }
-  }
-
-  for (const defect of Cause.defects(cause)) {
-    if (defect instanceof Error) {
-      process.stderr.write(`Error: ${defect.message}\n`)
-    } else {
-      process.stderr.write(`Error: ${String(defect)}\n`)
+export const handleError = <E>(
+  cause: Cause.Cause<E>
+): Effect.Effect<void> =>
+  Effect.gen(function*() {
+    for (const reason of cause.reasons) {
+      if (Cause.isFailReason(reason)) {
+        const error = reason.error
+        if (error && typeof error === "object" && "message" in error) {
+          yield* writeStderr(`${(error as { message: string }).message}\n`)
+        } else {
+          yield* writeStderr(`${String(error)}\n`)
+        }
+      } else if (Cause.isDieReason(reason)) {
+        const defect = reason.defect
+        if (defect instanceof Error) {
+          yield* writeStderr(`Error: ${defect.message}\n`)
+        } else {
+          yield* writeStderr(`Error: ${String(defect)}\n`)
+        }
+      } else {
+        yield* writeStderr("Interrupted\n")
+      }
     }
-  }
-}
+  })

package/src/commands/fetch.ts

@@ -0,0 +1,90 @@
+/**
+ * Fetch command for Confluence CLI.
+ */
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import { Command, Flag as Options } from "effect/unstable/cli"
+import type { PageId } from "../Brand.js"
+import { ConfluenceClient, type ConfluenceClientConfig, layer as ConfluenceClientLayer } from "../ConfluenceClient.js"
+import { ConfigError } from "../ConfluenceError.js"
+import { cleanMarkdown as removeRoundTripMetadata } from "../internal/cleanMarkdown.js"
+import { writeStdout } from "../internal/stdio.js"
+import { MarkdownConverter } from "../MarkdownConverter.js"
+import { resolvePageInput } from "./pageInput.js"
+import { getAuth } from "./shared.js"
+
+const urlOption = Options.string("url").pipe(
+  Options.withDescription("Confluence page URL"),
+  Options.optional
+)
+
+const pageIdOption = Options.string("page-id").pipe(
+  Options.withDescription("Confluence page ID"),
+  Options.optional
+)
+
+const baseUrlOption = Options.string("base-url").pipe(
+  Options.withDescription("Confluence Cloud base URL (e.g., https://yoursite.atlassian.net)"),
+  Options.optional
+)
+
+const cleanMarkdownOption = Options.boolean("clean-markdown").pipe(
+  Options.withDescription("Print readable markdown without Confluence round-trip metadata")
+)
+
+export const fetchPageMarkdown = (
+  pageId: PageId,
+  options: { readonly cleanMarkdown: boolean }
+) =>
+  Effect.gen(function*() {
+    const client = yield* ConfluenceClient
+    const converter = yield* MarkdownConverter
+    const page = yield* client.getPage(pageId)
+    const adfJson = page.body?.atlas_doc_format?.value
+
+    if (!adfJson) {
+      return yield* Effect.fail(new ConfigError({ message: `Page ${pageId} did not include ADF content.` }))
+    }
+
+    const markdown = yield* converter.adfToMarkdown(adfJson)
+    return options.cleanMarkdown ? removeRoundTripMetadata(markdown) : markdown
+  })
+
+const optionValue = (option: Option.Option<string>): string | undefined =>
+  Option.isSome(option) ? option.value : undefined
+
+export interface FetchCommandOptions {
+  readonly makeClientLayer?: (config: ConfluenceClientConfig) => Layer.Layer<ConfluenceClient>
+}
+
+export const makeFetchCommand = (options: FetchCommandOptions = {}) => {
+  const makeClientLayer = options.makeClientLayer ??
+    ((clientConfig: ConfluenceClientConfig) =>
+      ConfluenceClientLayer(clientConfig).pipe(
+        Layer.provide(NodeHttpClient.layerFetch)
+      ))
+
+  return Command.make(
+    "fetch",
+    { url: urlOption, pageId: pageIdOption, baseUrl: baseUrlOption, cleanMarkdown: cleanMarkdownOption },
+    ({ baseUrl, cleanMarkdown, pageId, url }) =>
+      Effect.gen(function*() {
+        const input = yield* resolvePageInput({
+          url: optionValue(url),
+          pageId: optionValue(pageId),
+          baseUrl: optionValue(baseUrl)
+        })
+        const auth = yield* getAuth()
+        const clientConfig: ConfluenceClientConfig = { baseUrl: input.baseUrl, auth }
+        const markdown = yield* fetchPageMarkdown(input.pageId as PageId, { cleanMarkdown }).pipe(
+          Effect.provide(makeClientLayer(clientConfig))
+        )
+
+        yield* writeStdout(markdown.endsWith("\n") ? markdown : `${markdown}\n`)
+      })
+  ).pipe(Command.withDescription("Fetch the latest Confluence page markdown without creating a git workspace"))
+}
+
+export const fetchCommand = makeFetchCommand()

package/src/commands/git.ts

@@ -1,15 +1,15 @@
 /**
  * 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 { Argument as Args, Command, Flag as Options } from "effect/unstable/cli"
 import { ConfluenceConfig } from "../ConfluenceConfig.js"
 import { GitService } from "../GitService.js"
 
 // === Commit command ===
-const commitMessageOption = Options.text("message").pipe(
+const commitMessageOption = Options.string("message").pipe(
   Options.withAlias("m"),
   Options.withDescription("Commit message"),
   Options.optional
@@ -44,12 +44,12 @@ const logOnelineOption = Options.boolean("oneline").pipe(
   Options.withDescription("Show compact one-line format")
 )
 
-const logSinceOption = Options.text("since").pipe(
+const logSinceOption = Options.string("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>>
+const logFileArg = Args.string("file").pipe(Args.optional)
 
 export const logCommand = Command.make(
   "log",
@@ -86,12 +86,12 @@ const diffStagedOption = Options.boolean("staged").pipe(
   Options.withDescription("Show staged changes")
 )
 
-const diffCommitOption = Options.text("commit").pipe(
+const diffCommitOption = Options.string("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>>
+const diffFileArg = Args.string("file").pipe(Args.optional)
 
 export const diffCommand = Command.make(
   "diff",

package/src/commands/index.ts

@@ -4,6 +4,7 @@
 export { authCommand } from "./auth.js"
 export { cloneCommand } from "./clone.js"
 export { deleteCommand } from "./delete.js"
+export { fetchCommand } from "./fetch.js"
 export { commitCommand, diffCommand, logCommand } from "./git.js"
 export { newCommand } from "./new.js"
 export { getAuth } from "./shared.js"