@knpkv/confluence-to-markdown 0.2.0 → 0.4.1

package/src/bin.ts

@@ -2,237 +2,41 @@
 /**
  * CLI entry point for confluence-to-markdown.
  */
-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 NodeRuntime from "@effect/platform-node/NodeRuntime"
-import * as NodeTerminal from "@effect/platform-node/NodeTerminal"
-import * as Config from "effect/Config"
-import * as Console from "effect/Console"
+import { Command } from "@effect/cli"
 import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
+import * as Logger from "effect/Logger"
+import * as LogLevel from "effect/LogLevel"
 import pkg from "../package.json" with { type: "json" }
-import type { PageId } from "./Brand.js"
-import { ConfluenceClient, type ConfluenceClientConfig, layer as ConfluenceClientLayer } from "./ConfluenceClient.js"
+import { handleError } from "./commands/errorHandler.js"
 import {
-  ConfluenceConfig,
-  createConfigFile,
-  layer as ConfluenceConfigLayer,
-  layerFromValues as ConfluenceConfigLayerFromValues
-} from "./ConfluenceConfig.js"
-import { AuthMissingError, ConfigError } from "./ConfluenceError.js"
-import { layer as LocalFileSystemLayer } from "./LocalFileSystem.js"
-import { layer as MarkdownConverterLayer } from "./MarkdownConverter.js"
-import { layer as SyncEngineLayer, SyncEngine } from "./SyncEngine.js"
-
-// === Auth config ===
-const AuthConfig = Config.all({
-  apiKey: Config.string("CONFLUENCE_API_KEY"),
-  email: Config.string("CONFLUENCE_EMAIL")
-})
-
-const getAuth = (): Effect.Effect<ConfluenceClientConfig["auth"], AuthMissingError> =>
-  AuthConfig.pipe(
-    Effect.map(({ apiKey, email }) => ({ type: "token" as const, email, token: apiKey })),
-    Effect.mapError(() => new AuthMissingError())
-  )
-
-// === Init command ===
-const rootPageIdOption = Options.text("root-page-id").pipe(
-  Options.withDescription("Confluence root page ID to sync from"),
-  Options.optional
-)
-const baseUrlOption = Options.text("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 initCommand = Command.make(
-  "init",
-  { rootPageId: rootPageIdOption, baseUrl: baseUrlOption },
-  ({ baseUrl, rootPageId }) =>
-    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):" })
-
-      const pageId = yield* validatePageId(rawPageId)
-      const url = yield* validateBaseUrl(rawUrl)
-
-      const path = yield* createConfigFile(pageId, url)
-      yield* Console.log(`Created configuration file: ${path}`)
-    })
-).pipe(Command.withDescription("Initialize .confluence.json configuration"))
-
-// === Pull command ===
-const forceOption = Options.boolean("force").pipe(
-  Options.withAlias("f"),
-  Options.withDescription("Overwrite local changes")
-)
-
-const pullCommand = Command.make("pull", { force: forceOption }, ({ force }) =>
-  Effect.gen(function*() {
-    const engine = yield* SyncEngine
-    yield* Console.log("Pulling pages from Confluence...")
-    const result = yield* engine.pull({ force })
-    yield* Console.log(`Pulled ${result.pulled} pages`)
-    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")
-)
-
-const pushCommand = Command.make("push", { dryRun: dryRunOption }, ({ dryRun }) =>
-  Effect.gen(function*() {
-    const engine = yield* SyncEngine
-    yield* Console.log(dryRun ? "Dry run - showing changes..." : "Pushing changes to Confluence...")
-    const result = yield* engine.push({ dryRun })
-    yield* Console.log(`Pushed: ${result.pushed}, Created: ${result.created}, Skipped: ${result.skipped}`)
-    if (result.errors.length > 0) {
-      yield* Console.error("Errors:", result.errors.join("\n"))
-    }
-  })).pipe(Command.withDescription("Upload local markdown changes to Confluence"))
-
-// === Sync command ===
-const syncCommand = Command.make("sync", {}, () =>
-  Effect.gen(function*() {
-    const engine = yield* SyncEngine
-    yield* Console.log("Syncing with Confluence...")
-    const result = yield* engine.sync()
-    yield* Console.log(`Pulled: ${result.pulled}, Pushed: ${result.pushed}, Created: ${result.created}`)
-    if (result.conflicts > 0) {
-      yield* Console.warn(`Conflicts: ${result.conflicts}`)
-    }
-    if (result.errors.length > 0) {
-      yield* Console.error("Errors:", result.errors.join("\n"))
-    }
-  })).pipe(Command.withDescription("Bidirectional sync with conflict detection"))
-
-// === Status command ===
-const statusCommand = Command.make("status", {}, () =>
-  Effect.gen(function*() {
-    const engine = yield* SyncEngine
-    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"))
+  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([initCommand, pullCommand, pushCommand, syncCommand, statusCommand])
-)
-
-// === Build app layer ===
-// Dummy config layer for help/init
-const DummyConfigLayer = ConfluenceConfigLayerFromValues({
-  rootPageId: "dummy" as PageId,
-  baseUrl: "https://dummy.atlassian.net",
-  docsPath: ".docs/confluence",
-  excludePatterns: []
-})
-
-// 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")
-  })
-)
-
-// Dummy sync engine that will fail if actually used
-const DummySyncEngineLayer = Layer.succeed(
-  SyncEngine,
-  SyncEngine.of({
-    pull: () => Effect.dieMessage("Not configured - run 'confluence init' first"),
-    push: () => Effect.dieMessage("Not configured - run 'confluence init' first"),
-    sync: () => Effect.dieMessage("Not configured - run 'confluence init' first"),
-    status: () => Effect.dieMessage("Not configured - run 'confluence init' first")
-  })
-)
-
-// 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
-const AppLayer = SyncEngineLayer.pipe(
-  Layer.provideMerge(ConfluenceClientLive),
-  Layer.provideMerge(MarkdownConverterLayer),
-  Layer.provideMerge(LocalFileSystemLayer),
-  Layer.provideMerge(ConfluenceConfigLayer()),
-  Layer.provideMerge(NodeHttpClient.layer),
-  Layer.provideMerge(NodeContext.layer)
-)
-
-// Minimal layer for init/help (dummy services, won't be invoked)
-const MinimalLayer = DummySyncEngineLayer.pipe(
-  Layer.provideMerge(DummyConfluenceClientLayer),
-  Layer.provideMerge(MarkdownConverterLayer),
-  Layer.provideMerge(LocalFileSystemLayer),
-  Layer.provideMerge(DummyConfigLayer),
-  Layer.provideMerge(NodeTerminal.layer),
-  Layer.provideMerge(NodeContext.layer)
+  Command.withSubcommands([
+    cloneCommand,
+    authCommand,
+    pullCommand,
+    pushCommand,
+    statusCommand,
+    commitCommand,
+    logCommand,
+    diffCommand,
+    newCommand,
+    deleteCommand
+  ])
 )
 
 // === Run CLI ===
@@ -241,29 +45,26 @@ const cli = Command.run(confluence, {
   version: pkg.version
 })
 
-// Check if we need the full layer based on command
-const needsFullLayer = () => {
-  const args = process.argv
-  const cmd = args[2]
-  // init, --help, -h, --version don't need config
-  if (!cmd || cmd === "init" || cmd === "--help" || cmd === "-h" || cmd === "--version") {
-    return false
+const layerType = getLayerType()
+const layer = layerType === "full"
+  ? AppLayer
+  : layerType === "auth"
+  ? AuthOnlyLayer
+  : layerType === "clone"
+  ? CloneLayer
+  : 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)
   }
-  return true
-}
-
-const main = Effect.suspend(() => cli(process.argv))
-
-if (needsFullLayer()) {
-  main.pipe(
-    Effect.provide(AppLayer),
-    Effect.tapErrorCause(Effect.logError),
-    NodeRuntime.runMain
-  )
-} else {
-  main.pipe(
-    Effect.provide(MinimalLayer),
-    Effect.tapErrorCause(Effect.logError),
-    NodeRuntime.runMain
-  )
-}
+})

package/src/commands/auth.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 { ConfluenceAuth } from "../ConfluenceAuth.js"
+
+// === Auth create command ===
+const createCommand = Command.make("create", {}, () =>
+  Effect.gen(function*() {
+    yield* Console.log(`
+Creating OAuth app in Atlassian Developer Console...
+
+1. Browser will open to create a new OAuth 2.0 (3LO) app
+2. Enter app name (e.g., "Confluence CLI")
+3. After creation, go to "Permissions" and add:
+   - Confluence API (granular): read:page:confluence, write:page:confluence, delete:page:confluence
+   - User Identity API: read:me
+4. Go to "Authorization" and set callback URL:
+   http://localhost:8585/callback
+5. Go to "Settings" and copy Client ID and Secret
+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())
+          }
+        })
+      )
+    )
+  })).pipe(Command.withDescription("Create OAuth app in Atlassian Developer Console"))
+
+// === Auth configure command ===
+const clientIdOption = Options.text("client-id").pipe(
+  Options.withDescription("OAuth client ID from Atlassian Developer Console"),
+  Options.optional
+)
+const clientSecretOption = Options.text("client-secret").pipe(
+  Options.withDescription("OAuth client secret"),
+  Options.optional
+)
+
+const configureCommand = Command.make(
+  "configure",
+  { clientId: clientIdOption, clientSecret: clientSecretOption },
+  ({ clientId, clientSecret }) =>
+    Effect.gen(function*() {
+      const auth = yield* ConfluenceAuth
+
+      const rawClientId = Option.isSome(clientId)
+        ? clientId.value
+        : yield* Prompt.text({ message: "Enter OAuth client ID:" })
+      const rawClientSecret = Option.isSome(clientSecret)
+        ? clientSecret.value
+        : yield* Prompt.text({ message: "Enter OAuth client secret:" })
+
+      yield* auth.configure({ clientId: rawClientId, clientSecret: rawClientSecret })
+      yield* Console.log("OAuth configured. Run 'confluence auth login' to authenticate.")
+    })
+).pipe(Command.withDescription("Configure OAuth client credentials"))
+
+// === Auth login command ===
+const siteOption = Options.text("site").pipe(
+  Options.withDescription("Confluence site URL to use (for accounts with multiple sites)"),
+  Options.optional
+)
+
+const loginCommand = Command.make("login", { site: siteOption }, ({ site }) =>
+  Effect.gen(function*() {
+    const auth = yield* ConfluenceAuth
+    const result = yield* auth.login(Option.isSome(site) ? { siteUrl: site.value } : undefined)
+    if (Array.isArray(result) && result.length > 0) {
+      yield* Console.log("\nRe-run with --site to select a specific site.")
+    }
+  })).pipe(Command.withDescription("Authenticate with Atlassian via OAuth"))
+
+// === Auth logout command ===
+const logoutCommand = Command.make("logout", {}, () =>
+  Effect.gen(function*() {
+    const auth = yield* ConfluenceAuth
+    yield* auth.logout()
+    yield* Console.log("Logged out")
+  })).pipe(Command.withDescription("Remove stored authentication"))
+
+// === Auth status command ===
+const statusCommand = Command.make("status", {}, () =>
+  Effect.gen(function*() {
+    const auth = yield* ConfluenceAuth
+    const user = yield* auth.getCurrentUser()
+    if (user) {
+      yield* Console.log(`Logged in as: ${user.name} (${user.email})`)
+    } else {
+      yield* Console.log("Not logged in. Use 'confluence auth login' to authenticate.")
+    }
+  })).pipe(Command.withDescription("Show authentication status"))
+
+// === Auth command group ===
+export const authCommand = Command.make("auth").pipe(
+  Command.withDescription("Manage OAuth authentication"),
+  Command.withSubcommands([
+    createCommand,
+    configureCommand,
+    loginCommand,
+    logoutCommand,
+    statusCommand
+  ])
+)

package/src/commands/clone.ts

@@ -0,0 +1,145 @@
+/**
+ * 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 Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+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 { 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"
+
+const rootPageIdOption = Options.text("root-page-id").pipe(
+  Options.withDescription("Confluence root page ID to sync from"),
+  Options.optional
+)
+
+const baseUrlOption = Options.text("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`
+      })
+    )
+}
+
+export const cloneCommand = Command.make(
+  "clone",
+  { rootPageId: rootPageIdOption, baseUrl: baseUrlOption },
+  ({ baseUrl, rootPageId }) =>
+    Effect.gen(function*() {
+      const git = yield* GitService
+
+      // Fail if .confluence already exists
+      const isGitInit = yield* git.isInitialized()
+      if (isGitInit) {
+        return yield* Effect.fail(
+          new ConfigError({ message: "Already cloned. Use 'confluence pull' to update." })
+        )
+      }
+
+      // Validate git is installed
+      yield* Console.log("Checking git installation...")
+      const gitVersion = yield* git.validateGit().pipe(
+        Effect.mapError(() =>
+          new ConfigError({ message: "Git is required but not installed. Please install git first." })
+        )
+      )
+      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 pageId = yield* validatePageId(rawPageId)
+      const url = yield* validateBaseUrl(rawUrl)
+
+      const path = yield* createConfigFile(pageId, url)
+      yield* Console.log(`Created configuration file: ${path}`)
+
+      // Initialize git repo
+      yield* Console.log("Initializing git repository...")
+      yield* git.init().pipe(
+        Effect.mapError(() => new ConfigError({ message: "Failed to initialize git repository" }))
+      )
+
+      // Build services dynamically with the new config
+      yield* Console.log("Cloning pages from Confluence with full history...")
+
+      // Get auth
+      const auth = yield* getAuth()
+      const clientConfig: ConfluenceClientConfig = { baseUrl: url, auth }
+
+      // Build layers for the clone operation
+      const configLayer = ConfluenceConfigLayerFromValues({
+        rootPageId: pageId as PageId,
+        baseUrl: url,
+        docsPath: ".confluence/docs",
+        excludePatterns: [],
+        saveSource: false,
+        trackedPaths: ["**/*.md"]
+      })
+
+      const clientLayer = ConfluenceClientLayer(clientConfig).pipe(
+        Layer.provide(NodeHttpClient.layer)
+      )
+
+      const cloneLayer = SyncEngineLayer.pipe(
+        Layer.provideMerge(UserCacheLayer),
+        Layer.provideMerge(GitServiceLayer),
+        Layer.provideMerge(clientLayer),
+        Layer.provideMerge(MarkdownConverterLayer),
+        Layer.provideMerge(LocalFileSystemLayer),
+        Layer.provideMerge(configLayer),
+        Layer.provideMerge(NodeContext.layer)
+      )
+
+      const result = yield* Effect.gen(function*() {
+        const engine = yield* SyncEngine
+        const gitService = yield* GitService
+        const pullResult = yield* engine.pull({
+          force: true,
+          replayHistory: true,
+          onProgress: (current, total, message) => {
+            process.stdout.write(`\r  Replaying history: ${current}/${total} - ${message}`)
+          }
+        })
+
+        // Create origin/confluence branch at HEAD to track remote state
+        yield* gitService.createBranch("origin/confluence")
+
+        return pullResult
+      }).pipe(Effect.provide(cloneLayer))
+
+      // Clear progress line and print final result
+      process.stdout.write("\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

@@ -0,0 +1,57 @@
+/**
+ * Delete command for Confluence CLI.
+ *
+ * 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 { ConfluenceConfig } from "../ConfluenceConfig.js"
+import { LocalFileSystem } from "../LocalFileSystem.js"
+import { flattenPageTree } from "./pageTree.js"
+
+export const deleteCommand = Command.make("delete", {}, () =>
+  Effect.gen(function*() {
+    const localFs = yield* LocalFileSystem
+    const config = yield* ConfluenceConfig
+    const pathService = yield* Path.Path
+    const fs = yield* FileSystem.FileSystem
+
+    const docsPath = pathService.join(process.cwd(), config.docsPath)
+
+    // Interactive mode - show page tree, delete local file
+    yield* Console.log("Scanning page structure...")
+    const tree = yield* localFs.buildPageTree(docsPath, config.rootPageId, "Root")
+
+    // Flatten to choices (exclude pages without pageId - they're not on Confluence)
+    const allChoices = flattenPageTree(tree)
+    const choices = allChoices.filter((c) => c.value.pageId !== null)
+
+    if (choices.length === 0) {
+      yield* Console.log("No pages found to delete. Run 'confluence clone' or 'confluence pull' first.")
+      return
+    }
+
+    const selected = yield* Prompt.select({
+      message: "Select page to delete:",
+      choices
+    })
+
+    if (!selected.pageId || !selected.path) {
+      yield* Console.log("Selected page has no pageId - cannot delete.")
+      return
+    }
+
+    // Delete local file
+    const filePath = pathService.join(docsPath, selected.path)
+    yield* fs.remove(filePath)
+
+    yield* Console.log(`Deleted: ${selected.path}`)
+    yield* Console.log("")
+    yield* Console.log("Next steps:")
+    yield* Console.log("  1. Run 'confluence commit' to stage the deletion")
+    yield* Console.log("  2. Run 'confluence push' to delete from Confluence")
+  })).pipe(Command.withDescription("Delete a page locally (push to remove from Confluence)"))

package/src/commands/errorHandler.ts

@@ -0,0 +1,32 @@
+/**
+ * CLI error handler.
+ *
+ * We use custom error handling instead of built-in options because:
+ * - Cause.pretty() includes stack traces which are noisy for CLI users
+ * - Logger.pretty is for logging, not error output
+ * - NodeRuntime.runMain error reporting shows full cause structure
+ */
+import * as Cause from "effect/Cause"
+
+/**
+ * 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`)
+    }
+  }
+}