create-confluence-sync 1.0.0

package/src/hook.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createApiClient } from './api.js';
+import { loadTree, saveTree } from './tree.js';
+import { pull, push, detectHidden } from './sync.js';
+import {
+  getChangedFiles,
+  getDeletedFiles,
+  getCurrentBranch,
+  createBranch,
+  switchBranch,
+  commitAll,
+  mergeBranch,
+  deleteBranch,
+} from './git.js';
+
+const PREFIX = '[confluence-sync]';
+
+function log(message) {
+  console.log(`${PREFIX} ${message}`);
+}
+
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.confluence', 'config.json');
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config not found: ${configPath}`);
+  }
+  const raw = fs.readFileSync(configPath, 'utf-8');
+  return JSON.parse(raw);
+}
+
+async function main() {
+  // Guard: prevent recursion
+  if (process.env.CONFLUENCE_SYNC_RUNNING === '1') {
+    return;
+  }
+  process.env.CONFLUENCE_SYNC_RUNNING = '1';
+
+  // Normalize projectRoot (Windows backslashes)
+  const rawRoot = process.argv[2];
+  if (!rawRoot) {
+    console.error(`${PREFIX} Error: projectRoot argument is required`);
+    process.exit(1);
+  }
+  const projectRoot = path.resolve(rawRoot.replace(/\\/g, '/'));
+
+  // Load config
+  const config = loadConfig(projectRoot);
+
+  // Determine changed .xhtml files from the last commit
+  const changedFiles = getChangedFiles(projectRoot);
+  if (changedFiles.length === 0) {
+    return; // commit does not touch documentation
+  }
+
+  log('Starting sync...');
+  log(`Changed files: ${changedFiles.length}`);
+
+  // Load tree
+  const tree = loadTree(projectRoot);
+
+  // Create API client
+  const apiClient = createApiClient(config);
+
+  // Detect hidden (only check files deleted in this commit)
+  const deletedFiles = getDeletedFiles(projectRoot);
+  const hiddenCount = detectHidden(tree, projectRoot, deletedFiles);
+  if (hiddenCount > 0) {
+    log(`Hidden: ${hiddenCount} pages marked as hidden`);
+  }
+
+  // --- Pull (Confluence -> Local) ---
+  const savedBranch = getCurrentBranch(projectRoot);
+
+  // Clean up stale branch from a previous failed merge
+  try {
+    deleteBranch(projectRoot, 'confluence/pull');
+  } catch {
+    // Branch doesn't exist — normal case
+  }
+
+  createBranch(projectRoot, 'confluence/pull');
+
+  const pullResult = await pull(apiClient, tree, projectRoot, config.space);
+  saveTree(projectRoot, tree);
+  commitAll(projectRoot, `${PREFIX} pull from Confluence`);
+
+  log(`Pull: ${pullResult.created} created, ${pullResult.updated} updated, ${pullResult.deleted} deleted`);
+
+  // Switch back to working branch and merge
+  switchBranch(projectRoot, savedBranch);
+
+  try {
+    mergeBranch(projectRoot, 'confluence/pull');
+  } catch (err) {
+    if (err.message.includes('conflict') || err.message.includes('CONFLICT')) {
+      log('Merge conflict detected! Resolve conflicts manually, then commit.');
+      log('The confluence/pull branch has been kept for reference.');
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  deleteBranch(projectRoot, 'confluence/pull');
+
+  // --- Push (Local -> Confluence) ---
+  const pushResult = await push(apiClient, tree, projectRoot, config.space, changedFiles);
+  saveTree(projectRoot, tree);
+  commitAll(projectRoot, `${PREFIX} push to Confluence + update tree`);
+
+  log(`Push: ${pushResult.created} created, ${pushResult.updated} updated`);
+  log('Sync complete!');
+}
+
+main().catch((err) => {
+  console.error(`${PREFIX} Error: ${err.message}`);
+  process.exit(1);
+});

package/src/sync.js

@@ -0,0 +1,278 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  addPage,
+  hidePage,
+  getPageByPath,
+  getChangedPages,
+  getDeletedLocalFiles,
+  buildPath,
+  pathToParentId,
+  sanitizeName,
+} from './tree.js';
+
+export async function pull(apiClient, tree, projectRoot, spaceKey) {
+  const remotePages = await apiClient.getPageTree(spaceKey);
+  const { created, updated, deleted } = getChangedPages(tree, remotePages);
+
+  for (const pageId of created) {
+    const filePath = buildPath(tree, pageId, remotePages, spaceKey);
+    if (!filePath) continue;
+
+    const content = await apiClient.getPageContent(pageId);
+    const absolutePath = path.resolve(projectRoot, filePath);
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, content.body, 'utf-8');
+    console.log(`Created: ${filePath}`);
+
+    const attachments = await apiClient.getPageAttachments(pageId);
+
+    addPage(tree, pageId, {
+      title: remotePages[pageId].title,
+      path: filePath,
+      parentId: remotePages[pageId].parentId,
+      version: content.version,
+      attachments: attachments.map((a) => ({
+        id: a.id,
+        title: a.title,
+        version: a.version,
+        downloaded: false,
+      })),
+    });
+  }
+
+  for (const pageId of updated) {
+    const page = tree.pages[pageId];
+    const newPath = buildPath(tree, pageId, remotePages, spaceKey);
+    const filePath = newPath || page.path;
+    const content = await apiClient.getPageContent(pageId);
+
+    if (newPath && newPath !== page.path) {
+      const oldAbsolute = path.resolve(projectRoot, page.path);
+      try { await fs.unlink(oldAbsolute); } catch {}
+    }
+
+    const absolutePath = path.resolve(projectRoot, filePath);
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, content.body, 'utf-8');
+    console.log(`Updated: ${filePath}`);
+
+    const attachments = await apiClient.getPageAttachments(pageId);
+
+    addPage(tree, pageId, {
+      title: remotePages[pageId].title,
+      path: filePath,
+      parentId: remotePages[pageId].parentId,
+      version: content.version,
+      attachments: attachments.map((a) => ({
+        id: a.id,
+        title: a.title,
+        version: a.version,
+        downloaded: false,
+      })),
+    });
+  }
+
+  for (const pageId of deleted) {
+    const page = tree.pages[pageId];
+    if (!page) continue;
+
+    const absolutePath = path.resolve(projectRoot, page.path);
+    try { await fs.unlink(absolutePath); } catch {}
+
+    let dir = path.dirname(absolutePath);
+    while (dir !== projectRoot && dir !== path.dirname(dir)) {
+      try {
+        await fs.rmdir(dir);
+        dir = path.dirname(dir);
+      } catch {
+        break;
+      }
+    }
+
+    console.log(`  Deleted: ${page.path}`);
+    delete tree.pages[pageId];
+  }
+
+  // Restore: download pages that are in tree, not hidden, but missing from disk
+  for (const [pageId, page] of Object.entries(tree.pages)) {
+    if (page.hidden || !remotePages[pageId]) continue;
+    const absolutePath = path.resolve(projectRoot, page.path);
+    try {
+      await fs.access(absolutePath);
+    } catch {
+      // File missing on disk — download it
+      try {
+        const content = await apiClient.getPageContent(pageId);
+        await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+        await fs.writeFile(absolutePath, content.body, 'utf-8');
+        page.version = content.version;
+        page.lastSynced = new Date().toISOString();
+        console.log(`Restored: ${page.path}`);
+      } catch (err) {
+        console.error(`Error restoring ${page.title}: ${err.message}`);
+      }
+    }
+  }
+
+  // Tree cleanup: remove hidden pages that no longer exist in Confluence
+  for (const pageId of Object.keys(tree.pages)) {
+    if (tree.pages[pageId].hidden && !remotePages[pageId]) {
+      console.log(`Cleaned up: ${tree.pages[pageId].title} (removed from Confluence)`);
+      delete tree.pages[pageId];
+    }
+  }
+
+  // Tree cleanup: detect renamed pages and move files on disk
+  let renamed = 0;
+  for (const pageId of Object.keys(tree.pages)) {
+    const page = tree.pages[pageId];
+    if (page.hidden || !remotePages[pageId]) continue;
+
+    const remoteTitle = remotePages[pageId].title;
+    if (page.title === remoteTitle) continue;
+
+    const oldPath = page.path;
+    const newFsName = sanitizeName(remoteTitle);
+    const newPath = buildPath(tree, pageId, remotePages, tree.space);
+
+    if (!newPath || newPath === oldPath) continue;
+
+    const oldAbsolute = path.resolve(projectRoot, oldPath);
+    const newAbsolute = path.resolve(projectRoot, newPath);
+
+    try {
+      await fs.mkdir(path.dirname(newAbsolute), { recursive: true });
+      await fs.rename(oldAbsolute, newAbsolute);
+      console.log(`Renamed: ${oldPath} → ${newPath}`);
+    } catch (err) {
+      console.log(`Rename failed (${oldPath} → ${newPath}): ${err.message}`);
+      continue;
+    }
+
+    page.title = remoteTitle;
+    page.fsName = newFsName;
+    page.path = newPath;
+    renamed++;
+  }
+
+  tree.lastSync = new Date().toISOString();
+
+  return { created: created.length, updated: updated.length, deleted: deleted.length, renamed };
+}
+
+export async function push(apiClient, tree, projectRoot, spaceKey, changedFiles) {
+  let created = 0;
+  let updated = 0;
+
+  for (const filePath of changedFiles) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const absolutePath = path.resolve(projectRoot, normalized);
+    const body = await fs.readFile(absolutePath, 'utf-8');
+    const existing = getPageByPath(tree, normalized);
+
+    if (existing) {
+      const result = await apiClient.updatePage(
+        existing.pageId, existing.title, body, existing.version
+      );
+      console.log(`Pushed update: ${normalized}`);
+
+      tree.pages[existing.pageId].version = result.version;
+      tree.pages[existing.pageId].lastSynced = new Date().toISOString();
+      updated++;
+    } else {
+      const parentId = pathToParentId(tree, normalized);
+      const parts = normalized.split('/');
+      const fileName = parts[parts.length - 1];
+      const title = fileName.replace(/\.xhtml$/, '');
+
+      const result = await apiClient.createPage(spaceKey, parentId, title, body);
+      console.log(`Pushed new: ${normalized}`);
+
+      addPage(tree, result.id, {
+        title,
+        path: normalized,
+        parentId,
+        version: result.version,
+      });
+      created++;
+    }
+  }
+
+  tree.lastSync = new Date().toISOString();
+
+  return { created, updated };
+}
+
+export function detectHidden(tree, projectRoot, deletedFiles) {
+  let count = 0;
+
+  if (deletedFiles && deletedFiles.length > 0) {
+    // Fast path: only check files we know were deleted in the commit
+    for (const filePath of deletedFiles) {
+      const normalized = filePath.replace(/\\/g, '/');
+      const page = getPageByPath(tree, normalized);
+      if (page && !page.hidden) {
+        console.log(`Hidden: ${normalized}`);
+        hidePage(tree, page.pageId);
+        count++;
+      }
+    }
+  } else {
+    // Fallback: check all pages (used when no git diff available)
+    const deletedIds = getDeletedLocalFiles(tree, projectRoot);
+    for (const pageId of deletedIds) {
+      console.log(`Hidden: ${tree.pages[pageId].path}`);
+      hidePage(tree, pageId);
+      count++;
+    }
+  }
+
+  return count;
+}
+
+export async function initialPull(apiClient, tree, projectRoot, spaceKey) {
+  const remotePages = await apiClient.getPageTree(spaceKey);
+  let count = 0;
+
+  for (const pageId of Object.keys(remotePages)) {
+    const filePath = buildPath(tree, pageId, remotePages, spaceKey);
+    if (!filePath) continue;
+
+    try {
+      const content = await apiClient.getPageContent(pageId);
+      const absolutePath = path.resolve(projectRoot, filePath);
+      await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+      await fs.writeFile(absolutePath, content.body, 'utf-8');
+      console.log(`Synced: ${filePath}`);
+
+      let attachments = [];
+      try {
+        attachments = await apiClient.getPageAttachments(pageId);
+      } catch {
+        // some pages may not support attachments
+      }
+
+      addPage(tree, pageId, {
+        title: remotePages[pageId].title,
+        path: filePath,
+        parentId: remotePages[pageId].parentId,
+        version: content.version,
+        attachments: attachments.map((a) => ({
+          id: a.id,
+          title: a.title,
+          version: a.version,
+          downloaded: false,
+        })),
+      });
+
+      count++;
+    } catch (err) {
+      console.error(`Error syncing page ${pageId} (${remotePages[pageId]?.title}): ${err.message}`);
+    }
+  }
+
+  tree.lastSync = new Date().toISOString();
+
+  return count;
+}

package/src/tree.js

@@ -0,0 +1,171 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const TREE_PATH = path.join('.confluence', 'tree.json');
+
+function emptyTree() {
+  return { space: '', baseUrl: '', lastSync: null, pages: {} };
+}
+
+export function loadTree(projectRoot) {
+  const filePath = path.join(projectRoot, TREE_PATH);
+  if (!fs.existsSync(filePath)) return emptyTree();
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  return JSON.parse(raw);
+}
+
+export function saveTree(projectRoot, tree) {
+  const dirPath = path.join(projectRoot, '.confluence');
+  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+  const filePath = path.join(projectRoot, TREE_PATH);
+  fs.writeFileSync(filePath, JSON.stringify(tree, null, 2), 'utf-8');
+}
+
+export function addPage(tree, pageId, data) {
+  const id = String(pageId);
+  const existing = tree.pages[id] || {};
+  const fsName = data.fsName ?? sanitizeName(data.title);
+  tree.pages[id] = {
+    title: data.title,
+    fsName,
+    path: data.path,
+    parentId: data.parentId ?? existing.parentId ?? null,
+    version: data.version ?? existing.version ?? 1,
+    lastSynced: new Date().toISOString(),
+    hidden: data.hidden ?? existing.hidden ?? false,
+    attachments: data.attachments ?? existing.attachments ?? [],
+  };
+}
+
+export function hidePage(tree, pageId) {
+  const id = String(pageId);
+  if (tree.pages[id]) tree.pages[id].hidden = true;
+}
+
+export function unhidePage(tree, pageId) {
+  const id = String(pageId);
+  if (tree.pages[id]) tree.pages[id].hidden = false;
+}
+
+export function getPageByPath(tree, filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  for (const [pageId, pageData] of Object.entries(tree.pages)) {
+    if (pageData.path === normalized) {
+      return { pageId, ...pageData };
+    }
+  }
+  return null;
+}
+
+export function getPageById(tree, pageId) {
+  const id = String(pageId);
+  return tree.pages[id] ?? null;
+}
+
+export function getChangedPages(tree, remotePages) {
+  const updated = [];
+  const created = [];
+  const deleted = [];
+
+  for (const [pageId, remote] of Object.entries(remotePages)) {
+    const local = tree.pages[pageId];
+    if (!local) {
+      created.push(pageId);
+    } else if (local.hidden) {
+      continue;
+    } else if (remote.version > local.version) {
+      updated.push(pageId);
+    }
+  }
+
+  for (const [pageId, local] of Object.entries(tree.pages)) {
+    if (!remotePages[pageId] && !local.hidden) {
+      deleted.push(pageId);
+    }
+  }
+
+  return { updated, created, deleted };
+}
+
+export function getNewLocalFiles(tree, projectRoot, docsDir) {
+  const knownPaths = new Set();
+  for (const page of Object.values(tree.pages)) {
+    knownPaths.add(page.path);
+  }
+
+  const results = [];
+  const resolvedDocsDir = path.resolve(projectRoot, docsDir);
+
+  function scan(dir) {
+    if (!fs.existsSync(dir)) return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scan(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.xhtml')) {
+        const relativePath = path.relative(projectRoot, fullPath).replace(/\\/g, '/');
+        if (!knownPaths.has(relativePath)) {
+          results.push(relativePath);
+        }
+      }
+    }
+  }
+
+  scan(resolvedDocsDir);
+  return results;
+}
+
+export function getDeletedLocalFiles(tree, projectRoot) {
+  const result = [];
+  for (const [pageId, page] of Object.entries(tree.pages)) {
+    if (page.hidden) continue;
+    const absolutePath = path.resolve(projectRoot, page.path);
+    if (!fs.existsSync(absolutePath)) {
+      result.push(pageId);
+    }
+  }
+  return result;
+}
+
+export function sanitizeName(name) {
+  return name
+    .replace(/[<>:"/\\|?*]/g, '_')
+    .replace(/\s+$/, '')
+    .replace(/\.+$/, '')
+    .substring(0, 100);
+}
+
+export function buildPath(tree, pageId, remotePages, spaceKey) {
+  const segments = [];
+  let currentId = pageId;
+
+  while (currentId) {
+    const remote = remotePages[currentId];
+    if (!remote) break;
+    segments.unshift(sanitizeName(remote.title));
+    currentId = remote.parentId;
+  }
+
+  const title = remotePages[pageId]?.title;
+  if (!title) return null;
+
+  const safeName = sanitizeName(title);
+  const parts = ['docs', spaceKey, ...segments, `${safeName}.xhtml`];
+  return parts.join('/');
+}
+
+export function pathToParentId(tree, filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const parts = normalized.split('/');
+  const parentDir = parts.slice(0, -2).join('/');
+
+  for (const [pageId, page] of Object.entries(tree.pages)) {
+    const pageDir = page.path.split('/').slice(0, -1).join('/');
+    if (pageDir === parentDir) {
+      return pageId;
+    }
+  }
+
+  return null;
+}