@knpkv/confluence-to-markdown 0.2.0 → 0.4.2

package/test/integration.test.ts

@@ -0,0 +1,269 @@
+/**
+ * Integration tests for confluence-to-markdown CLI.
+ *
+ * Tests full cycle: clone -> create page -> push -> pull -> modify -> push -> re-clone -> delete -> verify
+ *
+ * Requires:
+ * - CONFLUENCE_BASE_URL: Confluence base URL
+ * - CONFLUENCE_ROOT_PAGE_ID: Test page ID
+ * - OAuth tokens in ~/.confluence/ or CONFLUENCE_API_KEY + CONFLUENCE_EMAIL env vars
+ */
+import { execFileSync } from "node:child_process"
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+import { afterAll, beforeAll, describe, expect, it } from "vitest"
+
+const CLI_PATH = path.resolve(__dirname, "../dist/bin.js")
+const BASE_URL = process.env.CONFLUENCE_BASE_URL
+const ROOT_PAGE_ID = process.env.CONFLUENCE_ROOT_PAGE_ID
+
+// Test state
+interface TestState {
+  testDir: string
+  pageFile: string | null
+  pageSlug: string | null
+  pageId: string | null
+}
+
+const state: TestState = {
+  testDir: "",
+  pageFile: null,
+  pageSlug: null,
+  pageId: null
+}
+
+// === Helper Functions ===
+
+const runCli = (args: ReadonlyArray<string>, options?: { timeout?: number }): string => {
+  return execFileSync("node", [CLI_PATH, ...args], {
+    cwd: state.testDir,
+    encoding: "utf-8",
+    timeout: options?.timeout ?? 60000
+  })
+}
+
+const findFile = (dir: string, predicate: (name: string) => boolean): string | null => {
+  if (!fs.existsSync(dir)) return null
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      const found = findFile(fullPath, predicate)
+      if (found) return found
+    } else if (predicate(entry.name)) {
+      return fullPath
+    }
+  }
+  return null
+}
+
+const findTemplate = (): string | null => {
+  const docsDir = path.join(state.testDir, ".confluence/docs")
+  return findFile(docsDir, (name) => name.toLowerCase().includes("template") && name.endsWith(".md"))
+}
+
+const findPageBySlug = (slug: string): string | null => {
+  const docsDir = path.join(state.testDir, ".confluence/docs")
+  return findFile(docsDir, (name) => name === `${slug}.md`)
+}
+
+// === Step Functions ===
+
+/**
+ * Clone pages from Confluence with full history.
+ */
+const clonePages = (): string => {
+  const output = runCli(["clone", "--root-page-id", ROOT_PAGE_ID, "--base-url", BASE_URL], { timeout: 120000 })
+
+  expect(output).toContain("Cloning pages from Confluence")
+  expect(output).toMatch(/Cloned \d+ pages with \d+ commits/)
+  expect(fs.existsSync(path.join(state.testDir, ".confluence"))).toBe(true)
+  expect(fs.existsSync(path.join(state.testDir, ".confluence/config.json"))).toBe(true)
+  expect(fs.existsSync(path.join(state.testDir, ".confluence/.git"))).toBe(true)
+
+  return output
+}
+
+/**
+ * Remove .confluence directory for fresh clone.
+ */
+const removeConfluenceDir = (): void => {
+  fs.rmSync(path.join(state.testDir, ".confluence"), { recursive: true, force: true })
+}
+
+/**
+ * Create a new page by copying template content.
+ */
+const createPageFromTemplate = (): { file: string; slug: string } => {
+  const templatePath = findTemplate()
+  expect(templatePath).not.toBeNull()
+
+  const templateContent = fs.readFileSync(templatePath!, "utf-8")
+  const contentMatch = templateContent.match(/^---[\s\S]*?---\s*([\s\S]*)$/)
+  const bodyContent = contentMatch ? contentMatch[1]!.trim() : templateContent
+
+  const templateDir = path.dirname(templatePath!)
+  const timestamp = Date.now()
+  const slug = `integration-test-${timestamp}`
+  const file = path.join(templateDir, `${slug}.md`)
+
+  const newPageContent = `---
+title: "Integration Test ${timestamp}"
+---
+
+${bodyContent}
+
+---
+Created by integration test at ${new Date().toISOString()}
+`
+  fs.writeFileSync(file, newPageContent)
+  expect(fs.existsSync(file)).toBe(true)
+
+  state.pageFile = file
+  state.pageSlug = slug
+
+  return { file, slug }
+}
+
+/**
+ * Commit current changes.
+ */
+const commitChanges = (message: string): string => {
+  const output = runCli(["commit", "-m", message])
+  expect(output).toContain("Committed:")
+  return output
+}
+
+/**
+ * Push changes to Confluence.
+ */
+const pushChanges = (): { pushed: number; created: number; deleted: number } => {
+  const output = runCli(["push"], { timeout: 90000 })
+
+  const pushedMatch = output.match(/Pushed:\s*(\d+)/)
+  const createdMatch = output.match(/Created:\s*(\d+)/)
+  const deletedMatch = output.match(/Deleted:\s*(\d+)/)
+
+  return {
+    pushed: pushedMatch ? parseInt(pushedMatch[1]!, 10) : 0,
+    created: createdMatch ? parseInt(createdMatch[1]!, 10) : 0,
+    deleted: deletedMatch ? parseInt(deletedMatch[1]!, 10) : 0
+  }
+}
+
+/**
+ * Pull changes from Confluence.
+ */
+const pullChanges = (): string => {
+  return runCli(["pull"])
+}
+
+/**
+ * Extract pageId from file front-matter.
+ */
+const extractPageId = (filePath: string): string | null => {
+  const content = fs.readFileSync(filePath, "utf-8")
+  const match = content.match(/pageId:\s*["']?(\d+)/)
+  return match ? match[1]! : null
+}
+
+/**
+ * Modify page content.
+ */
+const modifyPage = (filePath: string, marker: string): void => {
+  const content = fs.readFileSync(filePath, "utf-8")
+  fs.writeFileSync(filePath, content + `\n\n${marker}\n`)
+}
+
+/**
+ * Delete a local file.
+ */
+const deleteLocalFile = (filePath: string): void => {
+  fs.unlinkSync(filePath)
+  expect(fs.existsSync(filePath)).toBe(false)
+}
+
+// === Tests ===
+
+describe("CLI Integration - Page Creation Flow", () => {
+  beforeAll(() => {
+    state.testDir = fs.mkdtempSync(path.join(os.tmpdir(), "confluence-test-"))
+  })
+
+  afterAll(() => {
+    if (state.testDir && fs.existsSync(state.testDir)) {
+      fs.rmSync(state.testDir, { recursive: true, force: true })
+    }
+  })
+
+  it("full cycle: clone -> create -> push -> pull -> modify -> push -> re-clone -> delete -> verify", () => {
+    // 1. Clone pages from Confluence
+    clonePages()
+
+    // 2. Create new page from template
+    const { file, slug } = createPageFromTemplate()
+
+    // 3. Commit and push new page
+    commitChanges("Add integration test page")
+
+    const statusBefore = runCli(["status"])
+    expect(statusBefore).toContain("Local Only:")
+
+    const pushResult1 = pushChanges()
+    expect(pushResult1.created).toBe(1)
+
+    // Verify file has pageId after push
+    const contentAfterPush = fs.readFileSync(file, "utf-8")
+    expect(contentAfterPush).toMatch(/pageId:\s*["']?\d+/)
+    expect(contentAfterPush).toMatch(/version:\s*\d+/)
+    expect(contentAfterPush).toMatch(/contentHash:/)
+
+    const pageId = extractPageId(file)
+    expect(pageId).not.toBeNull()
+    state.pageId = pageId
+
+    // 4. Pull should be no-op (already in sync)
+    const contentBeforePull = fs.readFileSync(file, "utf-8")
+    pullChanges()
+    const contentAfterPull = fs.readFileSync(file, "utf-8")
+    expect(contentAfterPull).toBe(contentBeforePull)
+
+    // 5. Modify page, commit, and push
+    const modifyMarker = `Modified at ${Date.now()}`
+    modifyPage(file, modifyMarker)
+    commitChanges("Modify integration test page")
+
+    const pushResult2 = pushChanges()
+    expect(pushResult2.pushed).toBe(1)
+
+    const contentAfterModify = fs.readFileSync(file, "utf-8")
+    expect(contentAfterModify).toContain(modifyMarker)
+
+    // 6. Remove and re-clone - verify idempotency
+    const contentBeforeReclone = fs.readFileSync(file, "utf-8")
+    removeConfluenceDir()
+    clonePages()
+
+    const reclonedFile = findPageBySlug(slug)
+    expect(reclonedFile).not.toBeNull()
+    expect(fs.existsSync(reclonedFile!)).toBe(true)
+
+    const contentAfterReclone = fs.readFileSync(reclonedFile!, "utf-8")
+    expect(contentAfterReclone).toBe(contentBeforeReclone)
+
+    // 7. Delete page via git workflow
+    deleteLocalFile(reclonedFile!)
+    commitChanges("Delete integration test page")
+
+    const pushResult3 = pushChanges()
+    expect(pushResult3.deleted).toBe(1)
+
+    // 8. Verify deletion - re-clone should not include the page
+    removeConfluenceDir()
+    clonePages()
+
+    const deletedFile = findPageBySlug(slug)
+    expect(deletedFile).toBeNull()
+  })
+})

package/test/oauthServer.test.ts

@@ -0,0 +1,50 @@
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as HttpClient from "@effect/platform/HttpClient"
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Layer from "effect/Layer"
+import { HttpServerFactoryLive } from "../src/internal/NodeLayers.js"
+import { startCallbackServer } from "../src/internal/oauthServer.js"
+
+const HttpClientLive = NodeHttpClient.layer
+
+describe("oauthServer", () => {
+  describe("startCallbackServer", () => {
+    it.effect("starts server and returns port", () =>
+      Effect.gen(function*() {
+        const expectedState = "test-state-123"
+        const result = yield* startCallbackServer(expectedState)
+
+        expect(result.port).toBeGreaterThanOrEqual(8585)
+        expect(typeof result.codePromise).toBe("object")
+        expect(typeof result.shutdown).toBe("object")
+
+        // Clean up
+        yield* result.shutdown
+      }).pipe(Effect.provide(HttpServerFactoryLive)))
+
+    it.effect("handles successful callback with code", () =>
+      Effect.gen(function*() {
+        const expectedState = "test-state-456"
+        const { codePromise, port, shutdown } = yield* startCallbackServer(expectedState)
+
+        // Make callback request in background
+        const codeReceiver = yield* Effect.fork(codePromise)
+
+        // Simulate OAuth callback using Effect HttpClient
+        const client = yield* HttpClient.HttpClient
+        const request = HttpClientRequest.get(`http://localhost:${port}/callback`).pipe(
+          HttpClientRequest.setUrlParam("code", "auth_code_123"),
+          HttpClientRequest.setUrlParam("state", expectedState)
+        )
+        yield* client.execute(request)
+
+        const code = yield* Fiber.join(codeReceiver)
+        expect(code).toBe("auth_code_123")
+
+        yield* shutdown
+      }).pipe(Effect.provide(Layer.mergeAll(HttpServerFactoryLive, HttpClientLive))))
+  })
+})

package/test/parsers/ConfluenceParser.test.ts

@@ -0,0 +1,283 @@
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem"
+import * as NodePath from "@effect/platform-node/NodePath"
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as Path from "@effect/platform/Path"
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import { parseConfluenceHtml } from "../../src/parsers/ConfluenceParser.js"
+import { parseMarkdown } from "../../src/parsers/MarkdownParser.js"
+import { serializeToConfluence } from "../../src/serializers/ConfluenceSerializer.js"
+import { serializeToMarkdown } from "../../src/serializers/MarkdownSerializer.js"
+
+const PlatformLive = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)
+
+const getFixturesDir = Effect.gen(function*() {
+  const path = yield* Path.Path
+  return path.join(import.meta.dirname, "../fixtures")
+})
+
+const readFixture = (filename: string) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+    const fixturesDir = yield* getFixturesDir
+    return yield* fs.readFileString(path.join(fixturesDir, filename))
+  }).pipe(Effect.provide(PlatformLive))
+
+describe("ConfluenceParser", () => {
+  describe("parseConfluenceHtml", () => {
+    it.effect("parses basic headings", () =>
+      Effect.gen(function*() {
+        const html = "<h1>Title</h1><h2>Subtitle</h2>"
+        const doc = yield* parseConfluenceHtml(html)
+        expect(doc.children.length).toBe(2)
+        expect(doc.children[0]?._tag).toBe("Heading")
+      }))
+
+    it.effect("parses paragraphs", () =>
+      Effect.gen(function*() {
+        const html = "<p>Hello world</p>"
+        const doc = yield* parseConfluenceHtml(html)
+        expect(doc.children.length).toBe(1)
+        expect(doc.children[0]?._tag).toBe("Paragraph")
+      }))
+
+    it.effect("parses task lists", () =>
+      Effect.gen(function*() {
+        const html = `<ac:task-list ac:task-list-id="test">
+          <ac:task>
+            <ac:task-id>1</ac:task-id>
+            <ac:task-uuid>uuid-1</ac:task-uuid>
+            <ac:task-status>incomplete</ac:task-status>
+            <ac:task-body><span>Task 1</span></ac:task-body>
+          </ac:task>
+          <ac:task>
+            <ac:task-id>2</ac:task-id>
+            <ac:task-uuid>uuid-2</ac:task-uuid>
+            <ac:task-status>complete</ac:task-status>
+            <ac:task-body><span>Task 2</span></ac:task-body>
+          </ac:task>
+        </ac:task-list>`
+        const doc = yield* parseConfluenceHtml(html)
+        expect(doc.children.length).toBe(1)
+        const taskList = doc.children[0]
+        expect(taskList?._tag).toBe("TaskList")
+        if (taskList?._tag === "TaskList") {
+          expect(taskList.children.length).toBe(2)
+          expect(taskList.children[0]?.status).toBe("incomplete")
+          expect(taskList.children[0]?.body[0]?._tag).toBe("Text")
+          expect(taskList.children[1]?.status).toBe("complete")
+        }
+      }))
+
+    it.effect("parses images with attachments", () =>
+      Effect.gen(function*() {
+        const html = `<ac:image ac:align="center" ac:width="250" ac:alt="logo">
+          <ri:attachment ri:filename="logo.svg"/>
+        </ac:image>`
+        const doc = yield* parseConfluenceHtml(html)
+        expect(doc.children.length).toBe(1)
+        const image = doc.children[0]
+        expect(image?._tag).toBe("Image")
+        if (image?._tag === "Image") {
+          expect(image.attachment?.filename).toBe("logo.svg")
+          expect(image.align).toBe("center")
+          expect(image.width).toBe(250)
+          expect(image.alt).toBe("logo")
+        }
+      }))
+
+    it.effect("parses emoticons", () =>
+      Effect.gen(function*() {
+        const html =
+          `<p><ac:emoticon ac:emoji-shortname=":grinning:" ac:emoji-id="1f600" ac:emoji-fallback="smile"/></p>`
+        const doc = yield* parseConfluenceHtml(html)
+        expect(doc.children.length).toBe(1)
+        const para = doc.children[0]
+        expect(para?._tag).toBe("Paragraph")
+        if (para?._tag === "Paragraph") {
+          const emoticon = para.children[0]
+          expect(emoticon?._tag).toBe("Emoticon")
+          if (emoticon?._tag === "Emoticon") {
+            expect(emoticon.shortname).toBe(":grinning:")
+            expect(emoticon.emojiId).toBe("1f600")
+            expect(emoticon.fallback).toBe("smile")
+          }
+        }
+      }))
+
+    it.effect("parses user mentions", () =>
+      Effect.gen(function*() {
+        const html = `<p><ac:link><ri:user ri:account-id="557058:abc123"/></ac:link></p>`
+        const doc = yield* parseConfluenceHtml(html)
+        expect(doc.children.length).toBe(1)
+        const para = doc.children[0]
+        if (para?._tag === "Paragraph") {
+          const mention = para.children[0]
+          expect(mention?._tag).toBe("UserMention")
+          if (mention?._tag === "UserMention") {
+            expect(mention.accountId).toBe("557058:abc123")
+          }
+        }
+      }))
+
+    it.effect("parses colored text", () =>
+      Effect.gen(function*() {
+        const html = `<p><span style="color: rgb(255,0,0);">Red text</span></p>`
+        const doc = yield* parseConfluenceHtml(html)
+        const para = doc.children[0]
+        if (para?._tag === "Paragraph") {
+          const colored = para.children[0]
+          expect(colored?._tag).toBe("ColoredText")
+          if (colored?._tag === "ColoredText") {
+            expect(colored.color).toBe("rgb(255,0,0)")
+          }
+        }
+      }))
+
+    it.effect("parses highlighted text", () =>
+      Effect.gen(function*() {
+        const html = `<p><span style="background-color: rgb(255,255,0);">Highlighted</span></p>`
+        const doc = yield* parseConfluenceHtml(html)
+        const para = doc.children[0]
+        if (para?._tag === "Paragraph") {
+          const highlight = para.children[0]
+          expect(highlight?._tag).toBe("Highlight")
+          if (highlight?._tag === "Highlight") {
+            expect(highlight.backgroundColor).toBe("rgb(255,255,0)")
+          }
+        }
+      }))
+
+    it.effect("parses paragraph with alignment", () =>
+      Effect.gen(function*() {
+        const html = `<p style="text-align: center;">Centered</p>`
+        const doc = yield* parseConfluenceHtml(html)
+        const para = doc.children[0]
+        expect(para?._tag).toBe("Paragraph")
+        if (para?._tag === "Paragraph") {
+          expect(para.alignment).toBe("center")
+        }
+      }))
+
+    it.effect("parses paragraph with indent", () =>
+      Effect.gen(function*() {
+        const html = `<p style="margin-left: 30px;">Indented</p>`
+        const doc = yield* parseConfluenceHtml(html)
+        const para = doc.children[0]
+        expect(para?._tag === "Paragraph").toBe(true)
+        if (para?._tag === "Paragraph") {
+          expect(para.indent).toBe(30)
+        }
+      }))
+
+    it.effect("parses underline, subscript, superscript", () =>
+      Effect.gen(function*() {
+        const html = `<p><u>Underline</u> <sub>Sub</sub> <sup>Sup</sup></p>`
+        const doc = yield* parseConfluenceHtml(html)
+        const para = doc.children[0]
+        if (para?._tag === "Paragraph") {
+          const [u, , sub, , sup] = para.children
+          expect(u?._tag).toBe("Underline")
+          expect(sub?._tag).toBe("Subscript")
+          expect(sup?._tag).toBe("Superscript")
+        }
+      }))
+
+    it.effect("parses tables with proper cell content", () =>
+      Effect.gen(function*() {
+        const html = `<table>
+          <thead><tr><th><p>Header 1</p></th><th><p>Header 2</p></th></tr></thead>
+          <tbody><tr><td><p>Cell 1</p></td><td><p>Cell 2</p></td></tr></tbody>
+        </table>`
+        const doc = yield* parseConfluenceHtml(html)
+        const table = doc.children[0]
+        expect(table?._tag).toBe("Table")
+        if (table?._tag === "Table") {
+          // Header should have 2 cells
+          expect(table.header?.cells.length).toBe(2)
+          // First header cell should have text "Header 1"
+          const headerCell = table.header?.cells[0]
+          if (headerCell) {
+            expect(headerCell.children[0]?._tag).toBe("Text")
+            if (headerCell.children[0]?._tag === "Text") {
+              expect(headerCell.children[0].value).toBe("Header 1")
+            }
+          }
+          // Body rows
+          expect(table.rows.length).toBe(1)
+          const bodyCell = table.rows[0]?.cells[0]
+          if (bodyCell) {
+            expect(bodyCell.children[0]?._tag).toBe("Text")
+            if (bodyCell.children[0]?._tag === "Text") {
+              expect(bodyCell.children[0].value).toBe("Cell 1")
+            }
+          }
+        }
+      }))
+  })
+
+  describe("integration test fixture", () => {
+    it.effect("parses and serializes integration test fixture", () =>
+      Effect.gen(function*() {
+        const html = yield* readFixture("integration-test.html.fixture")
+        const doc = yield* parseConfluenceHtml(html)
+
+        // Doc should have children - layout markers plus actual content
+        expect(doc.children.length).toBeGreaterThan(0)
+
+        // Serialize to markdown - content should be readable (not URL-encoded)
+        const markdown = yield* serializeToMarkdown(doc)
+        // Layout markers should be present as comments
+        expect(markdown).toContain("cf:layout-start")
+        expect(markdown).toContain("cf:section:")
+        // Content should be readable markdown, not URL-encoded
+        expect(markdown).toContain("# Heading 1")
+        expect(markdown).toContain("## Heading 2")
+
+        // Serialize to confluence - should reconstruct layout structure
+        const confluenceHtml = yield* serializeToConfluence(doc)
+        expect(confluenceHtml).toContain("<ac:layout>")
+        expect(confluenceHtml).toContain("<ac:layout-section")
+        expect(confluenceHtml).toContain("<ac:layout-cell>")
+        // Note: ac:task-list may have attributes, so search for the tag name
+        expect(confluenceHtml).toContain("ac:task-list")
+        expect(confluenceHtml).toContain("<ac:task-status>incomplete</ac:task-status>")
+        expect(confluenceHtml).toContain("<ac:task-status>complete</ac:task-status>")
+        expect(confluenceHtml).toContain("ac:emoticon")
+        expect(confluenceHtml).toContain("ri:account-id")
+      }))
+  })
+
+  describe("roundtrip HTML -> MD -> HTML", () => {
+    it.effect("roundtrips integration-test.html with 1-to-1 preservation", () =>
+      Effect.gen(function*() {
+        const originalHtml = yield* readFixture("integration-test.html.fixture")
+        const doc1 = yield* parseConfluenceHtml(originalHtml)
+        const md = yield* serializeToMarkdown(doc1)
+        const doc2 = yield* parseMarkdown(md)
+        const finalHtml = yield* serializeToConfluence(doc2)
+
+        // 1-to-1 roundtrip: finalHtml should EXACTLY match originalHtml
+        expect(finalHtml).toBe(originalHtml)
+      }))
+
+    it.effect("roundtrips TOC macro", () =>
+      Effect.gen(function*() {
+        const html =
+          `<ac:structured-macro ac:name="toc"><ac:parameter ac:name="minLevel">2</ac:parameter></ac:structured-macro>`
+        const doc1 = yield* parseConfluenceHtml(html)
+        expect(doc1.children[0]?._tag).toBe("TocMacro")
+
+        const md = yield* serializeToMarkdown(doc1)
+        expect(md).toContain("[[toc]]")
+
+        const doc2 = yield* parseMarkdown(md)
+        expect(doc2.children[0]?._tag).toBe("TocMacro")
+
+        const html2 = yield* serializeToConfluence(doc2)
+        expect(html2).toContain("<ac:structured-macro ac:name=\"toc\">")
+      }))
+  })
+})