create-confluence-sync 1.0.0

package/src/cli.js

@@ -0,0 +1,496 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { input, password, select, confirm, checkbox } from '@inquirer/prompts';
+import { createApiClient } from './api.js';
+import { loadTree, saveTree, unhidePage } from './tree.js';
+import { initialPull, pull, push, detectHidden } from './sync.js';
+import { initRepo, installHook, commitAll } from './git.js';
+import { generateAgentsMd } from './agents-md.js';
+
+const projectRoot = process.cwd();
+
+function parseArgs() {
+  const args = { positional: [] };
+  const argv = process.argv.slice(2);
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--url' && argv[i + 1]) {
+      args.url = argv[++i];
+    } else if (argv[i] === '--token' && argv[i + 1]) {
+      args.token = argv[++i];
+    } else if (argv[i] === '--space' && argv[i + 1]) {
+      args.space = argv[++i];
+    } else if (argv[i] === '--yes' || argv[i] === '-y') {
+      args.yes = true;
+    } else if (!argv[i].startsWith('-')) {
+      args.positional.push(argv[i]);
+    }
+  }
+
+  return args;
+}
+
+function loadConfig() {
+  const configPath = path.join(projectRoot, '.confluence', 'config.json');
+  if (!fs.existsSync(configPath)) {
+    console.error('Error: .confluence/config.json not found. Run setup first (node cli.js).');
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+}
+
+function printBanner() {
+  console.log('');
+  console.log('╔══════════════════════════════════════╗');
+  console.log('║     Confluence Sync — Setup          ║');
+  console.log('╚══════════════════════════════════════╝');
+  console.log('');
+}
+
+// --- Command handlers ---
+
+async function cmdSpaces() {
+  const config = loadConfig();
+  const apiClient = createApiClient(config);
+  const spaces = await apiClient.getSpaces();
+  const result = spaces.map((s) => ({ key: s.key, name: s.name }));
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function cmdTree() {
+  const config = loadConfig();
+  const apiClient = createApiClient(config);
+  const pages = await apiClient.getPageTree(config.space);
+  console.log(JSON.stringify(pages, null, 2));
+}
+
+async function cmdPage(pageId) {
+  if (!pageId) {
+    console.error('Usage: node cli.js page <pageId>');
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const apiClient = createApiClient(config);
+  const content = await apiClient.getPageContent(pageId);
+  console.log(JSON.stringify(content, null, 2));
+}
+
+async function cmdSync(file) {
+  const config = loadConfig();
+  const apiClient = createApiClient(config);
+  const tree = loadTree(projectRoot);
+
+  // Redirect console.log to stderr so sync progress logs don't pollute JSON stdout
+  const origLog = console.log;
+  console.log = (...args) => console.error(...args);
+
+  try {
+    let result;
+    detectHidden(tree, projectRoot);
+    if (file) {
+      result = await push(apiClient, tree, projectRoot, config.space, [file]);
+    } else {
+      result = await pull(apiClient, tree, projectRoot, config.space);
+    }
+    saveTree(projectRoot, tree);
+
+    // Restore and output clean JSON to stdout
+    console.log = origLog;
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    console.log = origLog;
+    throw err;
+  }
+}
+
+async function cmdDelete(pageId) {
+  if (!pageId) {
+    console.error('Usage: node cli.js delete <pageId>');
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const apiClient = createApiClient(config);
+  const result = await apiClient.deletePage(pageId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function cmdLocalTree() {
+  const tree = loadTree(projectRoot);
+  console.log(JSON.stringify(tree, null, 2));
+}
+
+function buildHiddenTree(tree) {
+  // Collect all hidden pages
+  const hiddenPages = {};
+  for (const [pageId, page] of Object.entries(tree.pages)) {
+    if (page.hidden) {
+      hiddenPages[pageId] = page;
+    }
+  }
+
+  if (Object.keys(hiddenPages).length === 0) return [];
+
+  const hiddenIds = new Set(Object.keys(hiddenPages));
+
+  // Build children map (only among hidden pages)
+  const childrenMap = {}; // parentId -> [pageId, ...]
+  const roots = [];
+
+  for (const pageId of Object.keys(hiddenPages)) {
+    const page = hiddenPages[pageId];
+    const parentId = page.parentId ? String(page.parentId) : null;
+
+    // If parent is also hidden, this is a child node; otherwise it's a root
+    if (parentId && hiddenIds.has(parentId)) {
+      if (!childrenMap[parentId]) childrenMap[parentId] = [];
+      childrenMap[parentId].push(pageId);
+    } else {
+      roots.push(pageId);
+    }
+  }
+
+  // Recursively flatten tree into choices with indentation
+  const choices = [];
+
+  function walk(pageId, depth) {
+    const page = hiddenPages[pageId];
+    const indent = '  '.repeat(depth);
+    choices.push({
+      name: `${indent}${page.title}`,
+      value: pageId,
+    });
+
+    const children = childrenMap[pageId] || [];
+    // Sort children alphabetically by title
+    children.sort((a, b) => hiddenPages[a].title.localeCompare(hiddenPages[b].title));
+    for (const childId of children) {
+      walk(childId, depth + 1);
+    }
+  }
+
+  // Sort roots alphabetically
+  roots.sort((a, b) => hiddenPages[a].title.localeCompare(hiddenPages[b].title));
+  for (const rootId of roots) {
+    walk(rootId, 0);
+  }
+
+  return choices;
+}
+
+function findPagesByTitle(tree, title) {
+  // Find all hidden pages where title matches OR any ancestor title matches
+  const result = [];
+
+  for (const [pageId, page] of Object.entries(tree.pages)) {
+    if (!page.hidden) continue;
+
+    // Check if this page's title matches
+    if (page.title === title) {
+      result.push(pageId);
+      continue;
+    }
+
+    // Check if any ancestor has the matching title
+    let currentId = page.parentId ? String(page.parentId) : null;
+    while (currentId) {
+      const ancestor = tree.pages[currentId];
+      if (!ancestor) break;
+      if (ancestor.title === title) {
+        result.push(pageId);
+        break;
+      }
+      currentId = ancestor.parentId ? String(ancestor.parentId) : null;
+    }
+  }
+
+  return result;
+}
+
+async function cmdRestore(name) {
+  const config = loadConfig();
+  const apiClient = createApiClient(config);
+  const tree = loadTree(projectRoot);
+
+  // Step 1: sync (pull) to bring tree up to date
+  console.log('Синхронизация...');
+  detectHidden(tree, projectRoot);
+  await pull(apiClient, tree, projectRoot, config.space);
+  saveTree(projectRoot, tree);
+
+  if (name) {
+    // --- Command mode: restore by title ---
+    const pageIds = findPagesByTitle(tree, name);
+
+    if (pageIds.length === 0) {
+      console.log(`Нет скрытых страниц с названием "${name}".`);
+      return;
+    }
+
+    for (const pageId of pageIds) {
+      console.log(`Восстановлено: ${tree.pages[pageId].title}`);
+      unhidePage(tree, pageId);
+    }
+
+    saveTree(projectRoot, tree);
+
+    // Re-sync to download restored pages
+    console.log('Скачивание восстановленных страниц...');
+    await pull(apiClient, tree, projectRoot, config.space);
+    saveTree(projectRoot, tree);
+
+    console.log(`Восстановлено страниц: ${pageIds.length}`);
+  } else {
+    // --- Interactive mode ---
+    const choices = buildHiddenTree(tree);
+
+    if (choices.length === 0) {
+      console.log('Нет скрытых страниц.');
+      return;
+    }
+
+    const selected = await checkbox({
+      message: 'Выберите страницы для восстановления:',
+      choices,
+    });
+
+    if (selected.length === 0) {
+      console.log('Ничего не выбрано.');
+      return;
+    }
+
+    for (const pageId of selected) {
+      console.log(`Восстановлено: ${tree.pages[pageId].title}`);
+      unhidePage(tree, pageId);
+    }
+
+    saveTree(projectRoot, tree);
+
+    // Re-sync to download restored pages
+    console.log('Скачивание восстановленных страниц...');
+    await pull(apiClient, tree, projectRoot, config.space);
+    saveTree(projectRoot, tree);
+
+    console.log(`Восстановлено страниц: ${selected.length}`);
+  }
+}
+
+// --- Setup wizard (existing flow) ---
+
+async function setupWizard(args) {
+  printBanner();
+
+  // --- Шаг 1-2: URL и Token ---
+
+  const baseUrl = args.url || await input({
+    message: 'Confluence URL:',
+    validate: (v) => v.startsWith('http') || 'URL должен начинаться с http/https',
+  });
+
+  const token = args.token || await password({
+    message: 'Personal Access Token:',
+    mask: '*',
+  });
+
+  // --- Шаг 3: Проверка подключения ---
+
+  const apiClient = createApiClient({ baseUrl, token });
+
+  let spaces;
+  try {
+    console.log('');
+    console.log('Проверяю подключение...');
+    spaces = await apiClient.getSpaces();
+
+    if (!spaces || spaces.length === 0) {
+      throw new Error('Нет доступных пространств. Проверьте токен и права доступа.');
+    }
+
+    console.log(`Подключено. Доступно пространств: ${spaces.length}`);
+    console.log('');
+  } catch (err) {
+    console.error(`\nОшибка подключения: ${err.message}`);
+    process.exit(1);
+  }
+
+  // --- Шаг 4: Выбор space ---
+
+  let spaceKey;
+
+  if (args.space) {
+    const found = spaces.find((s) => s.key === args.space);
+    if (!found) {
+      console.error(`Space "${args.space}" не найден. Доступные: ${spaces.map((s) => s.key).join(', ')}`);
+      process.exit(1);
+    }
+    spaceKey = args.space;
+  } else {
+    spaceKey = await select({
+      message: 'Выберите пространство:',
+      choices: spaces.map((s) => ({
+        name: `${s.key} — ${s.name}`,
+        value: s.key,
+      })),
+    });
+  }
+
+  const spaceName = spaces.find((s) => s.key === spaceKey)?.name || spaceKey;
+
+  // --- Шаг 5: Подтверждение ---
+
+  console.log('');
+  console.log('Будет создана синхронизация:');
+  console.log(`  URL: ${baseUrl}`);
+  console.log(`  Space: ${spaceKey} — ${spaceName}`);
+  console.log(`  Директория: ./docs/${spaceKey}/`);
+  console.log('');
+
+  if (!args.yes) {
+    const ok = await confirm({ message: 'Продолжить?' });
+    if (!ok) {
+      console.log('Отменено.');
+      process.exit(0);
+    }
+  }
+
+  // --- Шаг 6: Инициализация ---
+
+  console.log('');
+  console.log('Начинаю синхронизацию...');
+  console.log('');
+
+  // 6.1 Создать директорию docs/{spaceKey}/
+  const docsDir = path.join(projectRoot, 'docs', spaceKey);
+
+  if (!fs.existsSync(docsDir)) {
+    fs.mkdirSync(docsDir, { recursive: true });
+  }
+
+  // 6.2 Записать config.json
+  const configDir = path.join(projectRoot, '.confluence');
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  const config = { baseUrl, token, space: spaceKey };
+  fs.writeFileSync(path.join(configDir, 'config.json'), JSON.stringify(config, null, 2), 'utf-8');
+
+  // 6.3 Первичный pull
+  const tree = {
+    space: spaceKey,
+    baseUrl,
+    lastSync: null,
+    pages: {},
+  };
+
+  let pageCount;
+  try {
+    pageCount = await initialPull(apiClient, tree, projectRoot, spaceKey);
+  } catch (err) {
+    console.error(`\nОшибка при загрузке страниц: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 6.4 Сохранить tree.json
+  saveTree(projectRoot, tree);
+
+  // 6.5 npm init + install package
+  try {
+    console.log('Установка зависимостей...');
+    execSync('npm init -y', { cwd: projectRoot, stdio: 'ignore' });
+    execSync('npm install create-confluence-sync', { cwd: projectRoot, stdio: 'inherit' });
+  } catch (err) {
+    console.error(`\nОшибка установки пакета: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 6.6 git init
+  try {
+    initRepo(projectRoot);
+  } catch (err) {
+    console.error(`\nОшибка инициализации git: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 6.6 .gitignore
+  fs.writeFileSync(
+    path.join(projectRoot, '.gitignore'),
+    'node_modules/\n.confluence/config.json\n',
+    'utf-8'
+  );
+
+  // 6.7 Установить hook
+  try {
+    installHook(projectRoot);
+  } catch (err) {
+    console.error(`\nОшибка установки git hook: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 6.8 Генерация AGENTS.md
+  try {
+    generateAgentsMd(projectRoot, config, tree);
+  } catch (err) {
+    console.error(`\nОшибка генерации AGENTS.md: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 6.9 Начальный коммит
+  try {
+    commitAll(projectRoot, 'Initial confluence sync');
+  } catch (err) {
+    console.error(`\nОшибка начального коммита: ${err.message}`);
+    process.exit(1);
+  }
+
+  // --- Шаг 7: Done ---
+
+  console.log('');
+  console.log(`✓ Синхронизация настроена!`);
+  console.log(`  Директория: ./docs/${spaceKey}/`);
+  console.log(`  Страниц: ${pageCount}`);
+  console.log('');
+  console.log('  Теперь можно редактировать файлы и коммитить — синхронизация автоматическая.');
+  console.log('');
+}
+
+// --- Main ---
+
+const COMMANDS = {
+  spaces: cmdSpaces,
+  tree: cmdTree,
+  page: cmdPage,
+  sync: cmdSync,
+  delete: cmdDelete,
+  'local-tree': cmdLocalTree,
+  restore: cmdRestore,
+};
+
+async function run() {
+  const args = parseArgs();
+  const command = args.positional[0];
+
+  if (command && COMMANDS[command]) {
+    const handler = COMMANDS[command];
+    const cmdArgs = args.positional.slice(1);
+
+    // Commands that take an argument pass it; others get no args
+    if (command === 'page' || command === 'delete') {
+      await handler(cmdArgs[0]);
+    } else if (command === 'sync' || command === 'restore') {
+      await handler(cmdArgs[0]); // undefined if no arg = default mode
+    } else {
+      await handler();
+    }
+  } else {
+    await setupWizard(args);
+  }
+}
+
+run().catch((err) => {
+  console.error(`\nНеожиданная ошибка: ${err.message}`);
+  process.exit(1);
+});

package/src/git.js

@@ -0,0 +1,137 @@
+import { execSync } from 'child_process';
+import { writeFileSync, chmodSync } from 'fs';
+import { join } from 'path';
+
+function exec(projectRoot, command) {
+  try {
+    return execSync(command, { cwd: projectRoot, encoding: 'utf-8' }).trim();
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString().trim() : err.message;
+    throw new Error(`Git command failed: ${command}\n${stderr}`);
+  }
+}
+
+function getChangedFiles(projectRoot) {
+  const output = exec(projectRoot, 'git diff --name-only HEAD~1 HEAD');
+  if (!output) return [];
+  return output.split('\n').filter(f => f.endsWith('.xhtml'));
+}
+
+function getDeletedFiles(projectRoot) {
+  const output = exec(projectRoot, 'git diff --name-only --diff-filter=D HEAD~1 HEAD');
+  if (!output) return [];
+  return output.split('\n').filter(f => f.endsWith('.xhtml'));
+}
+
+function getChangedFilesUncommitted(projectRoot) {
+  const output = exec(projectRoot, 'git diff --name-only HEAD');
+  if (!output) return [];
+  return output.split('\n').filter(f => f.endsWith('.xhtml'));
+}
+
+function createBranch(projectRoot, name) {
+  try {
+    exec(projectRoot, `git checkout -b ${name}`);
+  } catch {
+    exec(projectRoot, `git checkout ${name}`);
+  }
+}
+
+function switchBranch(projectRoot, name) {
+  exec(projectRoot, `git checkout ${name}`);
+}
+
+function getCurrentBranch(projectRoot) {
+  return exec(projectRoot, 'git rev-parse --abbrev-ref HEAD');
+}
+
+function commitAll(projectRoot, message) {
+  exec(projectRoot, 'git add -A');
+
+  const status = exec(projectRoot, 'git status --porcelain');
+  if (!status) return false;
+
+  const escaped = message.replace(/"/g, '\\"');
+  try {
+    execSync(`git commit -m "${escaped}"`, {
+      cwd: projectRoot,
+      encoding: 'utf-8',
+      env: { ...process.env, CONFLUENCE_SYNC_RUNNING: '1' },
+    });
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString().trim() : err.message;
+    throw new Error(`Git commit failed: ${stderr}`);
+  }
+
+  return true;
+}
+
+function mergeBranch(projectRoot, source) {
+  try {
+    exec(projectRoot, `git merge ${source}`);
+    return true;
+  } catch (err) {
+    if (err.message.includes('CONFLICT') || err.message.includes('conflict')) {
+      throw new Error(
+        `Merge conflict while merging "${source}". Resolve conflicts manually and commit the result.`
+      );
+    }
+    throw err;
+  }
+}
+
+function deleteBranch(projectRoot, name) {
+  exec(projectRoot, `git branch -D ${name}`);
+}
+
+function stageFiles(projectRoot, files) {
+  if (!files || files.length === 0) return;
+  const paths = files.map(f => `"${f}"`).join(' ');
+  exec(projectRoot, `git add ${paths}`);
+}
+
+function installHook(projectRoot) {
+  const hookContent = `#!/bin/sh
+if [ "$CONFLUENCE_SYNC_RUNNING" = "1" ]; then
+  exit 0
+fi
+export CONFLUENCE_SYNC_RUNNING=1
+node "$(dirname "$0")/../../node_modules/create-confluence-sync/src/hook.js" "$(git rev-parse --show-toplevel)"
+`;
+
+  const hookPath = join(projectRoot, '.git', 'hooks', 'post-commit');
+  writeFileSync(hookPath, hookContent, 'utf-8');
+
+  try {
+    chmodSync(hookPath, 0o755);
+  } catch {
+    // chmod may not work on Windows, hook file is still written
+  }
+}
+
+function hasChanges(projectRoot) {
+  const output = exec(projectRoot, 'git status --porcelain');
+  return output.length > 0;
+}
+
+function initRepo(projectRoot) {
+  exec(projectRoot, 'git init');
+  exec(projectRoot, 'git config core.longpaths true');
+  return true;
+}
+
+export {
+  getChangedFiles,
+  getDeletedFiles,
+  getChangedFilesUncommitted,
+  createBranch,
+  switchBranch,
+  getCurrentBranch,
+  commitAll,
+  mergeBranch,
+  deleteBranch,
+  stageFiles,
+  installHook,
+  hasChanges,
+  initRepo,
+};