create-confluence-sync 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-confluence-sync",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Bidirectional Confluence Server documentation sync via Git. Edit XHTML locally, commit, auto-sync with Confluence.",
   "type": "module",
   "bin": {

package/src/api.js

@@ -184,6 +184,32 @@ export function createApiClient(config) {
     };
   }
 
+  async function movePage(pageId, newParentId, title, body, currentVersion) {
+    const payload = {
+      type: 'page',
+      title,
+      version: { number: currentVersion + 1 },
+      body: {
+        storage: {
+          value: body,
+          representation: 'storage',
+        },
+      },
+      ancestors: [{ id: String(newParentId) }],
+    };
+
+    const data = await jsonRequest(
+      baseUrl, token, 'PUT',
+      `/rest/api/content/${pageId}`,
+      payload
+    );
+
+    return {
+      id: String(data.id),
+      version: data.version.number,
+    };
+  }
+
   async function downloadAttachment(downloadPath) {
     const { buffer } = await request(baseUrl, token, 'GET', downloadPath);
     return buffer;
@@ -201,6 +227,7 @@ export function createApiClient(config) {
     getPageAttachments,
     createPage,
     updatePage,
+    movePage,
     deletePage,
     downloadAttachment,
   };

package/src/git.js

@@ -23,6 +23,24 @@ function getDeletedFiles(projectRoot) {
   return output.split('\n').filter(f => f.endsWith('.xhtml'));
 }
 
+function getRenamedFiles(projectRoot) {
+  let output;
+  try {
+    output = exec(projectRoot, 'git -c core.quotePath=false diff --name-status -M HEAD~1 HEAD');
+  } catch {
+    return [];
+  }
+  if (!output) return [];
+  const renames = [];
+  for (const line of output.split('\n')) {
+    const match = line.match(/^R\d+\t(.+)\t(.+)$/);
+    if (match && match[2].endsWith('.xhtml')) {
+      renames.push({ from: match[1], to: match[2] });
+    }
+  }
+  return renames;
+}
+
 function getChangedFilesUncommitted(projectRoot) {
   const output = exec(projectRoot, 'git diff --name-only HEAD');
   if (!output) return [];
@@ -123,6 +141,7 @@ function initRepo(projectRoot) {
 export {
   getChangedFiles,
   getDeletedFiles,
+  getRenamedFiles,
   getChangedFilesUncommitted,
   createBranch,
   switchBranch,

package/src/hook.js

@@ -6,6 +6,7 @@ import { pull, push, detectHidden } from './sync.js';
 import {
   getChangedFiles,
   getDeletedFiles,
+  getRenamedFiles,
   getCurrentBranch,
   createBranch,
   switchBranch,
@@ -60,9 +61,13 @@ async function main() {
   // Create API client
   const apiClient = createApiClient(config);
 
-  // Detect hidden (only check files deleted in this commit)
+  // Detect renames (must happen before detectHidden to exclude renamed files)
+  const renames = getRenamedFiles(projectRoot);
+  const renamedFromPaths = new Set(renames.map(r => r.from.replace(/\\/g, '/')));
+
+  // Detect hidden (only check files deleted in this commit, excluding renames)
   const deletedFiles = getDeletedFiles(projectRoot);
-  const hiddenCount = detectHidden(tree, projectRoot, deletedFiles);
+  const hiddenCount = detectHidden(tree, projectRoot, deletedFiles, renamedFromPaths);
   if (hiddenCount > 0) {
     log(`Hidden: ${hiddenCount} pages marked as hidden`);
   }
@@ -102,11 +107,11 @@ async function main() {
   deleteBranch(projectRoot, 'confluence/pull');
 
   // --- Push (Local -> Confluence) ---
-  const pushResult = await push(apiClient, tree, projectRoot, config.space, changedFiles);
+  const pushResult = await push(apiClient, tree, projectRoot, config.space, changedFiles, renames);
   saveTree(projectRoot, tree);
   commitAll(projectRoot, `${PREFIX} push to Confluence + update tree`);
 
-  log(`Push: ${pushResult.created} created, ${pushResult.updated} updated`);
+  log(`Push: ${pushResult.created} created, ${pushResult.updated} updated, ${pushResult.moved} moved/renamed`);
   log('Sync complete!');
 }
 

package/src/sync.js

@@ -161,11 +161,61 @@ export async function pull(apiClient, tree, projectRoot, spaceKey) {
   return { created: created.length, updated: updated.length, deleted: deleted.length, renamed };
 }
 
-export async function push(apiClient, tree, projectRoot, spaceKey, changedFiles) {
+export async function push(apiClient, tree, projectRoot, spaceKey, changedFiles, renames = []) {
   let created = 0;
   let updated = 0;
+  let moved = 0;
 
-  for (let filePath of changedFiles) {
+  // --- Handle renames/moves before the main loop ---
+  const renamedFromPaths = new Set(renames.map(r => r.from.replace(/\\/g, '/')));
+  const renamedToPaths = new Set(renames.map(r => r.to.replace(/\\/g, '/')));
+
+  for (const { from, to } of renames) {
+    const fromNorm = from.replace(/\\/g, '/');
+    const toNorm = to.replace(/\\/g, '/');
+    const existing = getPageByPath(tree, fromNorm);
+
+    if (!existing) continue;
+
+    const pageId = existing.pageId;
+    const newTitle = path.basename(toNorm).replace(/\.xhtml$/, '');
+    const newParentId = pathToParentId(tree, toNorm);
+
+    const absolutePath = path.resolve(projectRoot, toNorm);
+    const body = await fs.readFile(absolutePath, 'utf-8');
+
+    let result;
+    const parentChanged = newParentId && newParentId !== existing.parentId;
+
+    if (parentChanged) {
+      result = await apiClient.movePage(pageId, newParentId, newTitle, body, existing.version);
+      console.log(`Moved: ${fromNorm} → ${toNorm}`);
+    } else {
+      result = await apiClient.updatePage(pageId, newTitle, body, existing.version);
+      console.log(`Renamed: ${fromNorm} → ${toNorm}`);
+    }
+
+    addPage(tree, pageId, {
+      title: newTitle,
+      fsName: sanitizeName(newTitle),
+      path: toNorm,
+      parentId: parentChanged ? newParentId : existing.parentId,
+      version: result.version,
+    });
+    moved++;
+  }
+
+  // Sort by path depth — create parents before children
+  const sorted = [...changedFiles].sort((a, b) => {
+    const depthA = a.replace(/\\/g, '/').split('/').length;
+    const depthB = b.replace(/\\/g, '/').split('/').length;
+    return depthA - depthB;
+  });
+
+  for (let filePath of sorted) {
+    // Skip files that are part of a rename operation
+    const normalizedCheck = filePath.replace(/\\/g, '/');
+    if (renamedToPaths.has(normalizedCheck)) continue;
     let normalized = filePath.replace(/\\/g, '/');
     let absolutePath = path.resolve(projectRoot, normalized);
 
@@ -220,16 +270,17 @@ export async function push(apiClient, tree, projectRoot, spaceKey, changedFiles)
 
   tree.lastSync = new Date().toISOString();
 
-  return { created, updated };
+  return { created, updated, moved };
 }
 
-export function detectHidden(tree, projectRoot, deletedFiles) {
+export function detectHidden(tree, projectRoot, deletedFiles, excludePaths = new Set()) {
   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, '/');
+      if (excludePaths.has(normalized)) continue;
       const page = getPageByPath(tree, normalized);
       if (page && !page.hidden) {
         console.log(`Hidden: ${normalized}`);