@knpkv/confluence-to-markdown 0.2.0

package/src/bin.ts

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+/**
+ * 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 * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+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 {
+  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"))
+
+// === 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)
+)
+
+// === Run CLI ===
+const cli = Command.run(confluence, {
+  name: pkg.name,
+  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
+  }
+  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/index.ts

@@ -0,0 +1,35 @@
+/**
+ * @knpkv/confluence-to-markdown
+ *
+ * Sync Confluence Cloud pages to local GitHub Flavored Markdown files.
+ *
+ * @packageDocumentation
+ */
+
+export * from "./Brand.js"
+export {
+  ConfluenceClient,
+  type ConfluenceClientConfig,
+  type CreatePageRequest,
+  layer as ConfluenceClientLayer,
+  type UpdatePageRequest
+} from "./ConfluenceClient.js"
+export {
+  ConfluenceConfig,
+  createConfigFile,
+  layer as ConfluenceConfigLayer,
+  layerFromValues as ConfluenceConfigLayerFromValues
+} from "./ConfluenceConfig.js"
+export * from "./ConfluenceError.js"
+export { layer as LocalFileSystemLayer, type LocalFile, LocalFileSystem } from "./LocalFileSystem.js"
+export { layer as MarkdownConverterLayer, MarkdownConverter } from "./MarkdownConverter.js"
+export * from "./Schemas.js"
+export {
+  layer as SyncEngineLayer,
+  type PullResult,
+  type PushResult,
+  type StatusResult,
+  SyncEngine,
+  type SyncResult,
+  type SyncStatus
+} from "./SyncEngine.js"

package/src/internal/frontmatter.ts

@@ -0,0 +1,98 @@
+/**
+ * Front-matter parsing and serialization utilities.
+ *
+ * @module
+ * @internal
+ */
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import matter from "gray-matter"
+import { FrontMatterError } from "../ConfluenceError.js"
+import type { NewPageFrontMatter, PageFrontMatter } from "../Schemas.js"
+import { NewPageFrontMatterSchema, PageFrontMatterSchema } from "../Schemas.js"
+
+/**
+ * Parsed markdown file with front-matter.
+ */
+export interface ParsedMarkdown {
+  readonly frontMatter: PageFrontMatter | NewPageFrontMatter | null
+  readonly content: string
+  readonly isNew: boolean
+}
+
+/**
+ * Parse a markdown file with YAML front-matter.
+ *
+ * @param filePath - Path to the file (for error messages)
+ * @param content - The file content
+ * @returns Parsed markdown with front-matter and content
+ *
+ * @internal
+ */
+export const parseMarkdown = (
+  filePath: string,
+  content: string
+): Effect.Effect<ParsedMarkdown, FrontMatterError> =>
+  Effect.gen(function*() {
+    const parsed = yield* Effect.try({
+      try: () => matter(content),
+      catch: (cause) => new FrontMatterError({ path: filePath, cause })
+    })
+
+    // If no front-matter or empty, treat as new page
+    if (!parsed.data || Object.keys(parsed.data).length === 0) {
+      return {
+        frontMatter: null,
+        content: parsed.content.trim(),
+        isNew: true
+      }
+    }
+
+    // Try to parse as existing page front-matter
+    const existingResult = yield* Schema.decodeUnknown(PageFrontMatterSchema)(parsed.data).pipe(
+      Effect.map((fm) => ({
+        frontMatter: fm,
+        content: parsed.content.trim(),
+        isNew: false
+      })),
+      Effect.catchAll(() =>
+        // Try to parse as new page front-matter
+        Schema.decodeUnknown(NewPageFrontMatterSchema)(parsed.data).pipe(
+          Effect.map((fm) => ({
+            frontMatter: fm as NewPageFrontMatter,
+            content: parsed.content.trim(),
+            isNew: true
+          })),
+          Effect.catchAll((cause) => Effect.fail(new FrontMatterError({ path: filePath, cause })))
+        )
+      )
+    )
+
+    return existingResult
+  })
+
+/**
+ * Serialize markdown with YAML front-matter.
+ *
+ * @param frontMatter - The front-matter data
+ * @param content - The markdown content
+ * @returns The serialized markdown file content
+ *
+ * @internal
+ */
+export const serializeMarkdown = (
+  frontMatter: PageFrontMatter,
+  content: string
+): string => {
+  const fm = {
+    pageId: frontMatter.pageId,
+    version: frontMatter.version,
+    title: frontMatter.title,
+    updated: frontMatter.updated.toISOString(),
+    ...(frontMatter.parentId !== undefined ? { parentId: frontMatter.parentId } : {}),
+    ...(frontMatter.position !== undefined ? { position: frontMatter.position } : {}),
+    contentHash: frontMatter.contentHash
+  }
+
+  return matter.stringify(content, fm)
+}

package/src/internal/hashUtils.ts

@@ -0,0 +1,19 @@
+/**
+ * Content hashing utilities for change detection.
+ *
+ * @module
+ * @internal
+ */
+import * as crypto from "node:crypto"
+import type { ContentHash } from "../Brand.js"
+
+/**
+ * Compute SHA256 hash of content.
+ *
+ * @param content - The content to hash
+ * @returns The hex-encoded SHA256 hash
+ *
+ * @internal
+ */
+export const computeHash = (content: string): ContentHash =>
+  crypto.createHash("sha256").update(content, "utf8").digest("hex") as ContentHash

package/src/internal/pathUtils.ts

@@ -0,0 +1,77 @@
+/**
+ * Path utilities for converting page titles to file paths.
+ *
+ * @module
+ * @internal
+ */
+import * as path from "node:path"
+
+/**
+ * Convert a page title to a URL-safe slug.
+ * Prevents path traversal by only allowing alphanumeric characters and hyphens.
+ *
+ * @param title - The page title
+ * @returns A slugified version of the title
+ *
+ * @internal
+ */
+export const slugify = (title: string): string => {
+  const slug = title
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "") // Remove diacritics
+    .replace(/[^a-z0-9]+/g, "-") // Replace non-alphanumeric with hyphens (prevents ../ path traversal)
+    .replace(/^-+|-+$/g, "") // Trim leading/trailing hyphens
+    .substring(0, 100) // Limit length
+
+  // Ensure we have a valid slug (not empty after sanitization)
+  return slug || "untitled"
+}
+
+/**
+ * Convert a page to a local file path.
+ *
+ * @param title - The page title
+ * @param hasChildren - Whether the page has child pages
+ * @param parentPath - The parent directory path
+ * @returns The local file path for the page
+ *
+ * @internal
+ */
+export const pageToPath = (
+  title: string,
+  hasChildren: boolean,
+  parentPath: string
+): string => {
+  const slug = slugify(title)
+  return hasChildren
+    ? path.join(parentPath, slug, "index.md")
+    : path.join(parentPath, `${slug}.md`)
+}
+
+/**
+ * Get the directory path for a page (used when creating children).
+ *
+ * @param title - The page title
+ * @param parentPath - The parent directory path
+ * @returns The directory path for the page's children
+ *
+ * @internal
+ */
+export const pageToDir = (title: string, parentPath: string): string => {
+  const slug = slugify(title)
+  return path.join(parentPath, slug)
+}
+
+/**
+ * Extract page slug from a file path.
+ *
+ * @param filePath - The file path
+ * @returns The page slug
+ *
+ * @internal
+ */
+export const pathToSlug = (filePath: string): string => {
+  const basename = path.basename(filePath, ".md")
+  return basename === "index" ? path.basename(path.dirname(filePath)) : basename
+}

package/test/Brand.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import { ContentHash, PageId, PageIdSchema, SpaceKey, SpaceKeySchema } from "../src/Brand.js"
+
+describe("Brand", () => {
+  describe("PageId", () => {
+    it("accepts valid page IDs", () => {
+      expect(PageId("123456")).toBe("123456")
+      expect(PageId("abc-def")).toBe("abc-def")
+    })
+
+    it("rejects empty strings", () => {
+      expect(() => PageId("")).toThrow()
+    })
+  })
+
+  describe("PageIdSchema", () => {
+    it("decodes valid page IDs", () => {
+      const result = Schema.decodeEither(PageIdSchema)("123456")
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects empty strings", () => {
+      const result = Schema.decodeEither(PageIdSchema)("")
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("SpaceKey", () => {
+    it("accepts valid space keys", () => {
+      expect(SpaceKey("MYSPACE")).toBe("MYSPACE")
+      expect(SpaceKey("DEV")).toBe("DEV")
+    })
+
+    it("rejects empty strings", () => {
+      expect(() => SpaceKey("")).toThrow()
+    })
+  })
+
+  describe("SpaceKeySchema", () => {
+    it("decodes uppercase alphanumeric keys", () => {
+      const result = Schema.decodeEither(SpaceKeySchema)("MYSPACE123")
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects lowercase keys", () => {
+      const result = Schema.decodeEither(SpaceKeySchema)("myspace")
+      expect(Either.isLeft(result)).toBe(true)
+    })
+
+    it("rejects keys with special characters", () => {
+      const result = Schema.decodeEither(SpaceKeySchema)("MY-SPACE")
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("ContentHash", () => {
+    it("accepts valid 64-char hex hashes", () => {
+      const validHash = "a".repeat(64)
+      expect(ContentHash(validHash)).toBe(validHash)
+    })
+
+    it("rejects short hashes", () => {
+      expect(() => ContentHash("abc123")).toThrow()
+    })
+
+    it("rejects empty strings", () => {
+      expect(() => ContentHash("")).toThrow()
+    })
+  })
+})

package/test/MarkdownConverter.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import { layer as MarkdownConverterLayer, MarkdownConverter } from "../src/MarkdownConverter.js"
+
+describe("MarkdownConverter", () => {
+  describe("htmlToMarkdown", () => {
+    it.effect("converts basic HTML to markdown", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html = "<p>Hello <strong>world</strong></p>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("Hello")
+        expect(markdown).toContain("**world**")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts headings", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html = "<h1>Title</h1><h2>Subtitle</h2>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("# Title")
+        expect(markdown).toContain("## Subtitle")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts lists", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html = "<ul><li>Item 1</li><li>Item 2</li></ul>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("* Item 1")
+        expect(markdown).toContain("* Item 2")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts links", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html = "<a href=\"https://example.com\">Link</a>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("[Link](https://example.com)")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts code blocks", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html = "<pre><code>const x = 1;</code></pre>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("```")
+        expect(markdown).toContain("const x = 1;")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("strips Confluence macros with rich-text-body", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html =
+          "<ac:structured-macro ac:name=\"info\"><ac:rich-text-body><p>Content</p></ac:rich-text-body></ac:structured-macro>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("Content")
+        expect(markdown).not.toContain("ac:structured-macro")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts Confluence code macros to code blocks", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html =
+          "<ac:structured-macro ac:name=\"code\"><ac:plain-text-body><![CDATA[const x = 1;]]></ac:plain-text-body></ac:structured-macro>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("const x = 1;")
+        expect(markdown).toContain("```")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+  })
+
+  describe("markdownToHtml", () => {
+    it.effect("converts basic markdown to HTML", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const markdown = "Hello **world**"
+        const html = yield* converter.markdownToHtml(markdown)
+        expect(html).toContain("<strong>world</strong>")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts headings", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const markdown = "# Title\n\n## Subtitle"
+        const html = yield* converter.markdownToHtml(markdown)
+        expect(html).toContain("<h1>Title</h1>")
+        expect(html).toContain("<h2>Subtitle</h2>")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts GFM tables", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const markdown = "| A | B |\n|---|---|\n| 1 | 2 |"
+        const html = yield* converter.markdownToHtml(markdown)
+        expect(html).toContain("<table>")
+        expect(html).toContain("<th>A</th>")
+        expect(html).toContain("<td>1</td>")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+
+    it.effect("converts task lists", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const markdown = "- [ ] Todo\n- [x] Done"
+        const html = yield* converter.markdownToHtml(markdown)
+        expect(html).toContain("checkbox")
+      }).pipe(Effect.provide(MarkdownConverterLayer)))
+  })
+})