docrev 0.9.5 → 0.9.7

package/lib/anchor-match.ts

@@ -0,0 +1,238 @@
+/**
+ * Anchor matching primitives shared between sync (insertion) and
+ * verify-anchors (drift reporting). The functions are pure: given an
+ * anchor string and surrounding context, locate candidate positions in
+ * a target text using progressively looser strategies.
+ */
+
+export type AnchorStrategy =
+  | 'direct'
+  | 'normalized'
+  | 'stripped'
+  | 'partial-start'
+  | 'partial-start-stripped'
+  | 'context-both'
+  | 'context-before'
+  | 'context-after'
+  | 'split-match'
+  | 'empty-anchor'
+  | 'failed';
+
+export interface AnchorSearchResult {
+  occurrences: number[];
+  matchedAnchor: string | null;
+  strategy: AnchorStrategy;
+  stripped?: boolean;
+}
+
+/**
+ * Strip CriticMarkup so the matcher sees plain prose instead of
+ * `{++inserted++}`/`{--deleted--}`/etc. Used when an anchor lives
+ * underneath previously imported track changes.
+ */
+export function stripCriticMarkup(text: string): string {
+  return text
+    .replace(/\{\+\+([^+]*)\+\+\}/g, '$1')        // insertions: keep new text
+    .replace(/\{--([^-]*)--\}/g, '')              // deletions: remove old text
+    .replace(/\{~~([^~]*)~>([^~]*)~~\}/g, '$2')   // substitutions: keep new text
+    .replace(/\{>>[\s\S]*?<<\}/g, '')             // comments: remove (non-greedy; comment text may contain '<')
+    .replace(/\[([^\]]*)\]\{\.mark\}/g, '$1');    // marked text: keep text
+}
+
+/**
+ * Return every starting index where `needle` occurs in `haystack`.
+ * Empty needles return no occurrences (empty matches are not useful
+ * for anchor placement).
+ */
+export function findAllOccurrences(haystack: string, needle: string): number[] {
+  if (!needle || needle.length === 0) return [];
+  const occurrences: number[] = [];
+  let idx = 0;
+  while ((idx = haystack.indexOf(needle, idx)) !== -1) {
+    occurrences.push(idx);
+    idx += 1;
+  }
+  return occurrences;
+}
+
+/**
+ * Find candidate positions for `anchor` in `text`, falling back through
+ * progressively looser strategies (whitespace normalization, stripped
+ * CriticMarkup, partial-prefix, surrounding context, word splitting).
+ *
+ * The returned `strategy` lets callers distinguish a clean direct hit
+ * from a fuzzy approximation — useful for drift reporting.
+ */
+export function findAnchorInText(
+  anchor: string,
+  text: string,
+  before: string = '',
+  after: string = ''
+): AnchorSearchResult {
+  // Empty anchor: skip directly to context-based matching
+  if (!anchor || anchor.trim().length === 0) {
+    if (before || after) {
+      const beforeLower = (before || '').toLowerCase();
+      const afterLower = (after || '').toLowerCase();
+      const textLower = text.toLowerCase();
+
+      if (before && after) {
+        const beforeIdx = textLower.indexOf(beforeLower.slice(-50));
+        if (beforeIdx !== -1) {
+          const searchStart = beforeIdx + beforeLower.slice(-50).length;
+          const afterIdx = textLower.indexOf(afterLower.slice(0, 50), searchStart);
+          if (afterIdx !== -1 && afterIdx - searchStart < 500) {
+            return { occurrences: [searchStart], matchedAnchor: null, strategy: 'context-both' };
+          }
+        }
+      }
+
+      if (before) {
+        const beforeIdx = textLower.lastIndexOf(beforeLower.slice(-30));
+        if (beforeIdx !== -1) {
+          return {
+            occurrences: [beforeIdx + beforeLower.slice(-30).length],
+            matchedAnchor: null,
+            strategy: 'context-before',
+          };
+        }
+      }
+
+      if (after) {
+        const afterIdx = textLower.indexOf(afterLower.slice(0, 30));
+        if (afterIdx !== -1) {
+          return { occurrences: [afterIdx], matchedAnchor: null, strategy: 'context-after' };
+        }
+      }
+    }
+    return { occurrences: [], matchedAnchor: null, strategy: 'empty-anchor' };
+  }
+
+  const anchorLower = anchor.toLowerCase();
+  const textLower = text.toLowerCase();
+
+  // Strategy 1: direct match
+  let occurrences = findAllOccurrences(textLower, anchorLower);
+  if (occurrences.length > 0) {
+    return { occurrences, matchedAnchor: anchor, strategy: 'direct' };
+  }
+
+  // Strategy 2: normalized whitespace
+  const normalizedAnchor = anchor.replace(/\s+/g, ' ').toLowerCase();
+  const normalizedText = text.replace(/\s+/g, ' ').toLowerCase();
+  const idx = normalizedText.indexOf(normalizedAnchor);
+  if (idx !== -1) {
+    return { occurrences: [idx], matchedAnchor: anchor, strategy: 'normalized' };
+  }
+
+  // Strategy 3: match in stripped CriticMarkup version
+  const strippedText = stripCriticMarkup(text);
+  const strippedLower = strippedText.toLowerCase();
+  occurrences = findAllOccurrences(strippedLower, anchorLower);
+  if (occurrences.length > 0) {
+    return { occurrences, matchedAnchor: anchor, strategy: 'stripped', stripped: true };
+  }
+
+  // Strategy 4: first N words of anchor (long anchors)
+  const words = anchor.split(/\s+/);
+  if (words.length > 3) {
+    for (let n = Math.min(6, words.length); n >= 3; n--) {
+      const partialAnchor = words.slice(0, n).join(' ').toLowerCase();
+      if (partialAnchor.length >= 15) {
+        occurrences = findAllOccurrences(textLower, partialAnchor);
+        if (occurrences.length > 0) {
+          return { occurrences, matchedAnchor: words.slice(0, n).join(' '), strategy: 'partial-start' };
+        }
+        occurrences = findAllOccurrences(strippedLower, partialAnchor);
+        if (occurrences.length > 0) {
+          return {
+            occurrences,
+            matchedAnchor: words.slice(0, n).join(' '),
+            strategy: 'partial-start-stripped',
+            stripped: true,
+          };
+        }
+      }
+    }
+  }
+
+  // Strategy 5: context (before/after) only
+  if (before || after) {
+    const beforeLower = before.toLowerCase();
+    const afterLower = after.toLowerCase();
+
+    if (before && after) {
+      const beforeIdx = textLower.indexOf(beforeLower.slice(-50));
+      if (beforeIdx !== -1) {
+        const searchStart = beforeIdx + beforeLower.slice(-50).length;
+        const afterIdx = textLower.indexOf(afterLower.slice(0, 50), searchStart);
+        if (afterIdx !== -1 && afterIdx - searchStart < 500) {
+          return { occurrences: [searchStart], matchedAnchor: null, strategy: 'context-both' };
+        }
+      }
+    }
+
+    if (before) {
+      const beforeIdx = textLower.lastIndexOf(beforeLower.slice(-30));
+      if (beforeIdx !== -1) {
+        return {
+          occurrences: [beforeIdx + beforeLower.slice(-30).length],
+          matchedAnchor: null,
+          strategy: 'context-before',
+        };
+      }
+    }
+
+    if (after) {
+      const afterIdx = textLower.indexOf(afterLower.slice(0, 30));
+      if (afterIdx !== -1) {
+        return { occurrences: [afterIdx], matchedAnchor: null, strategy: 'context-after' };
+      }
+    }
+  }
+
+  // Strategy 6: split anchor on transition characters
+  const splitPatterns = [' ', ', ', '. ', ' - ', ' – '];
+  for (const sep of splitPatterns) {
+    if (anchor.includes(sep)) {
+      const parts = anchor.split(sep).filter(p => p.length >= 4);
+      for (const part of parts) {
+        const partLower = part.toLowerCase();
+        occurrences = findAllOccurrences(textLower, partLower);
+        if (occurrences.length > 0 && occurrences.length < 5) {
+          return { occurrences, matchedAnchor: part, strategy: 'split-match' };
+        }
+      }
+    }
+  }
+
+  return { occurrences: [], matchedAnchor: null, strategy: 'failed' };
+}
+
+/**
+ * Classify a strategy as a clean hit, a fuzzy/drifted hit, or no hit.
+ * Used by `verify-anchors` to summarize per-comment match quality.
+ */
+export type AnchorMatchQuality = 'clean' | 'drift' | 'context-only' | 'unmatched';
+
+export function classifyStrategy(strategy: AnchorStrategy, occurrences: number): AnchorMatchQuality {
+  if (occurrences === 0) return 'unmatched';
+  switch (strategy) {
+    case 'direct':
+    case 'normalized':
+      return 'clean';
+    case 'stripped':
+    case 'partial-start':
+    case 'partial-start-stripped':
+    case 'split-match':
+      return 'drift';
+    case 'context-both':
+    case 'context-before':
+    case 'context-after':
+      return 'context-only';
+    case 'empty-anchor':
+    case 'failed':
+    default:
+      return 'unmatched';
+  }
+}

package/lib/annotations.ts

@@ -91,16 +91,20 @@ function isCommentFalsePositive(commentContent: string, fullText: string, positi
   // Contains markdown figure reference syntax
   if (/\{#fig:|!\[/.test(commentContent)) return true;
 
-  // Contains URL patterns (likely a link, not a comment)
-  if (/https?:\/\/|www\./i.test(commentContent) && commentContent.length < 150) return true;
+  // Real comments typically have "Author:" at start. Accept hyphens, apostrophes,
+  // periods, and Unicode letters so names like "Jens-Christian Svenning" or
+  // "Camilla T Colding-Jørgensen" don't get rejected. See gcol33/docrev#1.
+  const hasAuthorPrefix = /^[\p{L}][\p{L}\s\-'.]{0,30}:\s/u.test(commentContent.trim());
+  const hasResolvedMark = /^[✓✔]\s/.test(commentContent.trim());
+
+  // Contains URL patterns (likely a link, not a comment) — only filter when
+  // there is no real author prefix, since reviewers legitimately cite URLs/DOIs.
+  if (!hasAuthorPrefix && /https?:\/\/|www\./i.test(commentContent) && commentContent.length < 150) return true;
 
   // Looks like code (contains programming patterns)
   if (/function\s*\(|=>|import\s+|export\s+|const\s+|let\s+|var\s+/.test(commentContent)) return true;
 
   // Very long without clear author pattern (likely caption, not comment)
-  // Real comments typically have "Author:" at start and are shorter
-  const hasAuthorPrefix = /^[A-Za-z][A-Za-z\s]{0,20}:\s/.test(commentContent.trim());
-  const hasResolvedMark = /^[✓✔]\s/.test(commentContent.trim());
   if (!hasAuthorPrefix && !hasResolvedMark && commentContent.length > MAX_COMMENT_CONTENT_LENGTH) return true;
 
   // Looks like a figure caption (starts with "Fig" or contains typical caption words)

package/lib/commands/file-ops.ts

@@ -0,0 +1,372 @@
+/**
+ * File operation commands: backup, archive, export, clean
+ *
+ * Commands that create, move, or delete project files.
+ */
+
+import type { Command } from 'commander';
+import {
+  chalk,
+  fs,
+  path,
+  fmt,
+  findFiles,
+  loadBuildConfig,
+} from './context.js';
+
+// Use the actual BuildConfig from build.ts which allows string|Author[]
+type BuildConfig = ReturnType<typeof loadBuildConfig>;
+
+interface ZipLike {
+  addLocalFile(localPath: string, zipPath?: string): void;
+}
+
+/**
+ * Recursively add directory contents to a zip archive, filtering by predicate
+ */
+function addDirToZip(
+  zip: ZipLike,
+  dir: string,
+  shouldInclude: (name: string) => boolean,
+  zipPath = '',
+): void {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const entryZipPath = path.join(zipPath, entry.name);
+
+    if (!shouldInclude(entry.name)) continue;
+
+    if (entry.isDirectory()) {
+      addDirToZip(zip, fullPath, shouldInclude, entryZipPath);
+    } else {
+      zip.addLocalFile(fullPath, zipPath || undefined);
+    }
+  }
+}
+
+// Options interfaces
+interface BackupOptions {
+  name?: string;
+  output?: string;
+}
+
+interface ArchiveOptions {
+  dir?: string;
+  by?: string;
+  rename?: boolean;
+  dryRun?: boolean;
+}
+
+interface ExportOptions {
+  output?: string;
+  includeOutput?: boolean;
+}
+
+interface CleanOptions {
+  dryRun?: boolean;
+  all?: boolean;
+}
+
+/**
+ * Register file-ops commands with the program
+ */
+export function register(program: Command): void {
+  // ==========================================================================
+  // BACKUP command - Timestamped project backup
+  // ==========================================================================
+
+  program
+    .command('backup')
+    .description('Create timestamped project backup')
+    .option('-n, --name <name>', 'Custom backup name')
+    .option('-o, --output <dir>', 'Output directory', '.')
+    .action(async (options: BackupOptions) => {
+      const { default: AdmZip } = await import('adm-zip');
+      const zip = new AdmZip();
+
+      const date = new Date().toISOString().slice(0, 10);
+      const name = options.name || `backup-${date}`;
+      const outputPath = path.join(options.output || '.', `${name}.zip`);
+
+      // Files to exclude
+      const excludePatterns = [
+        'node_modules', '.git', '.DS_Store', '*.zip',
+        'paper.md' // Generated file
+      ];
+
+      const shouldInclude = (file: string): boolean => {
+        for (const pattern of excludePatterns) {
+          if (file.includes(pattern.replace('*', ''))) return false;
+        }
+        return true;
+      };
+
+      addDirToZip(zip, '.', shouldInclude);
+
+      zip.writeZip(outputPath);
+      console.log(fmt.status('success', `Backup created: ${outputPath}`));
+    });
+
+  // ==========================================================================
+  // ARCHIVE command - Archive reviewer docx files
+  // ==========================================================================
+
+  program
+    .command('archive')
+    .description('Move reviewer .docx files to archive folder')
+    .argument('[files...]', 'Specific files to archive (default: all .docx)')
+    .option('-d, --dir <folder>', 'Archive folder name', 'archive')
+    .option('--by <name>', 'Reviewer name (auto-detected if single commenter)')
+    .option('--no-rename', 'Keep original filenames')
+    .option('--dry-run', 'Preview without moving files')
+    .action(async (files: string[] | undefined, options: ArchiveOptions) => {
+      const { extractWordComments } = await import('../import.js');
+      const { default: YAML } = await import('yaml');
+
+      // Find docx files to archive
+      let docxFiles = files && files.length > 0
+        ? files.filter(f => f.endsWith('.docx') && fs.existsSync(f))
+        : findFiles('.docx');
+
+      // Exclude our own build outputs
+      let projectSlug: string | null = null;
+      const configPath = path.join(process.cwd(), 'rev.yaml');
+      if (fs.existsSync(configPath)) {
+        try {
+          const config = YAML.parse(fs.readFileSync(configPath, 'utf-8'));
+          if (config.title) {
+            projectSlug = config.title
+              .toLowerCase()
+              .replace(/[^a-z0-9]+/g, '-')
+              .replace(/^-|-$/g, '')
+              .slice(0, 50);
+          }
+        } catch (e) {
+          // Ignore config errors
+        }
+      }
+
+      // Filter out build outputs
+      if (projectSlug && (!files || files.length === 0)) {
+        const buildPatterns = [
+          `${projectSlug}.docx`,
+          `${projectSlug}_comments.docx`,
+          `${projectSlug}-changes.docx`,
+          'paper.docx',
+          'paper_comments.docx',
+          'paper-changes.docx',
+        ];
+        const excluded: string[] = [];
+        docxFiles = docxFiles.filter(f => {
+          const base = path.basename(f).toLowerCase();
+          const isBuilt = buildPatterns.includes(base);
+          if (isBuilt) excluded.push(f);
+          return !isBuilt;
+        });
+        if (excluded.length > 0) {
+          console.log(chalk.dim(`  Skipping build outputs: ${excluded.join(', ')}`));
+          console.log();
+        }
+      }
+
+      if (docxFiles.length === 0) {
+        console.log(fmt.status('info', 'No .docx files to archive.'));
+        return;
+      }
+
+      const projectTitle = projectSlug;
+
+      // Create archive folder
+      const archiveDir = path.resolve(options.dir || 'archive');
+      if (!options.dryRun && !fs.existsSync(archiveDir)) {
+        fs.mkdirSync(archiveDir, { recursive: true });
+      }
+
+      console.log(fmt.header('Archive'));
+      console.log();
+
+      const moved: string[] = [];
+      for (const file of docxFiles) {
+        const stat = fs.statSync(file);
+        const mtime = stat.mtime;
+        const timestamp = mtime.toISOString().slice(0, 19).replace(/[-:]/g, '').replace('T', '_');
+
+        // Determine reviewer name
+        let reviewer: string | null = options.by || null;
+        if (!reviewer && options.rename !== false) {
+          try {
+            const comments = await extractWordComments(file);
+            const authors = [...new Set(comments.map(c => c.author).filter(a => a && a !== 'Unknown'))];
+            if (authors.length === 1) {
+              reviewer = authors[0].replace(/[^a-zA-Z0-9]/g, '-').replace(/^-|-$/g, '');
+            }
+          } catch (e) {
+            // Ignore extraction errors
+          }
+        }
+
+        // Generate new name
+        let newName: string;
+        if (options.rename === false) {
+          newName = path.basename(file);
+        } else {
+          const base = path.basename(file, '.docx');
+          if (/^\d{8}_\d{6}_/.test(base)) {
+            newName = path.basename(file);
+          } else {
+            const namePart = projectTitle || base;
+            if (reviewer) {
+              newName = `${timestamp}_${reviewer}_${namePart}.docx`;
+            } else {
+              newName = `${timestamp}_${namePart}.docx`;
+            }
+          }
+        }
+
+        const destPath = path.join(archiveDir, newName);
+
+        if (options.dryRun) {
+          console.log(`  ${chalk.dim(file)} → ${chalk.cyan(path.join(options.dir || 'archive', newName))}`);
+        } else {
+          // Handle name collision
+          let finalPath = destPath;
+          let counter = 1;
+          while (fs.existsSync(finalPath)) {
+            const ext = path.extname(newName);
+            const base = path.basename(newName, ext);
+            finalPath = path.join(archiveDir, `${base}_${counter}${ext}`);
+            counter++;
+          }
+          fs.renameSync(file, finalPath);
+          console.log(`  ${chalk.dim(file)} → ${chalk.green(path.relative(process.cwd(), finalPath))}`);
+        }
+        moved.push(file);
+      }
+
+      console.log();
+      if (options.dryRun) {
+        console.log(fmt.status('info', `Would archive ${moved.length} file(s). Run without --dry-run to proceed.`));
+      } else {
+        console.log(fmt.status('success', `Archived ${moved.length} file(s) to ${options.dir || 'archive'}/`));
+      }
+    });
+
+  // ==========================================================================
+  // EXPORT command - Export project as distributable zip
+  // ==========================================================================
+
+  program
+    .command('export')
+    .description('Export project as distributable zip')
+    .option('-o, --output <file>', 'Output filename')
+    .option('--include-output', 'Include built PDF/DOCX files')
+    .action(async (options: ExportOptions) => {
+      const { default: AdmZip } = await import('adm-zip');
+      const { build } = await import('../build.js');
+
+      let config: Partial<BuildConfig> = {};
+      try {
+        config = loadBuildConfig('.') || {};
+      } catch {
+        // Not in a rev project, that's ok
+      }
+
+      // Build first if including output
+      if (options.includeOutput) {
+        console.log(chalk.dim('Building documents...'));
+        await build('.', ['pdf', 'docx']);
+      }
+
+      const zip = new AdmZip();
+      const projectName = config.title?.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() || 'project';
+      const outputPath = options.output || `${projectName}-export.zip`;
+
+      const exclude = ['node_modules', '.git', '.DS_Store', '*.zip'];
+
+      const shouldInclude = (name: string): boolean => {
+        if (!options.includeOutput && (name.endsWith('.pdf') || name.endsWith('.docx'))) {
+          return false;
+        }
+        for (const pattern of exclude) {
+          if (name === pattern || name.includes(pattern.replace('*', ''))) return false;
+        }
+        return true;
+      };
+
+      addDirToZip(zip, '.', shouldInclude);
+
+      zip.writeZip(outputPath);
+      console.log(fmt.status('success', `Exported: ${outputPath}`));
+    });
+
+  // ==========================================================================
+  // CLEAN command - Remove generated files
+  // ==========================================================================
+
+  program
+    .command('clean')
+    .description('Remove generated files (paper.md, PDFs, DOCXs)')
+    .option('-n, --dry-run', 'Show what would be deleted without deleting')
+    .option('--all', 'Also remove backup and export zips')
+    .action((options: CleanOptions) => {
+      let config: Partial<BuildConfig> = {};
+      try {
+        config = loadBuildConfig('.') || {};
+      } catch {
+        // Not in a rev project, that's ok
+      }
+
+      const projectName = config.title?.toLowerCase().replace(/\s+/g, '-') || 'paper';
+
+      // Files to clean
+      const patterns = [
+        'paper.md',
+        '*.pdf',
+        `${projectName}.docx`,
+        `${projectName}.pdf`,
+        `${projectName}.tex`,
+        '.paper-*.md', // Temp build files
+      ];
+
+      if (options.all) {
+        patterns.push('*.zip', 'backup-*.zip', '*-export.zip');
+      }
+
+      const toDelete: string[] = [];
+
+      for (const pattern of patterns) {
+        if (pattern.includes('*')) {
+          const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+          const files = fs.readdirSync('.').filter(f => regex.test(f));
+          toDelete.push(...files);
+        } else if (fs.existsSync(pattern)) {
+          toDelete.push(pattern);
+        }
+      }
+
+      if (toDelete.length === 0) {
+        console.log(chalk.dim('No generated files to clean.'));
+        return;
+      }
+
+      console.log(fmt.header('Clean'));
+      console.log();
+
+      for (const file of toDelete) {
+        if (options.dryRun) {
+          console.log(chalk.dim(`  Would delete: ${file}`));
+        } else {
+          fs.unlinkSync(file);
+          console.log(chalk.red(`  Deleted: ${file}`));
+        }
+      }
+
+      console.log();
+      if (options.dryRun) {
+        console.log(chalk.dim(`Would delete ${toDelete.length} file(s). Run without --dry-run to delete.`));
+      } else {
+        console.log(fmt.status('success', `Cleaned ${toDelete.length} file(s)`));
+      }
+    });
+}

package/lib/commands/index.ts

@@ -10,24 +10,42 @@ import { register as registerCoreCommands } from './core.js';
 import { register as registerCommentCommands } from './comments.js';
 import { register as registerInitCommands } from './init.js';
 import { register as registerSectionCommands } from './sections.js';
+import { register as registerSyncCommands } from './sync.js';
+import { register as registerVerifyAnchorsCommands } from './verify-anchors.js';
+import { register as registerMergeResolveCommands } from './merge-resolve.js';
 import { register as registerBuildCommands } from './build.js';
 import { register as registerResponseCommands } from './response.js';
 import { register as registerCitationCommands } from './citations.js';
 import { register as registerDoiCommands } from './doi.js';
 import { register as registerHistoryCommands } from './history.js';
 import { register as registerUtilityCommands } from './utilities.js';
+import { register as registerProjectInfoCommands } from './project-info.js';
+import { register as registerFileOpsCommands } from './file-ops.js';
+import { register as registerPreviewCommands } from './preview.js';
+import { register as registerQualityCommands } from './quality.js';
+import { register as registerWordToolsCommands } from './word-tools.js';
+import { register as registerTextOpsCommands } from './text-ops.js';
 
 export {
   registerCoreCommands,
   registerCommentCommands,
   registerInitCommands,
   registerSectionCommands,
+  registerSyncCommands,
+  registerVerifyAnchorsCommands,
+  registerMergeResolveCommands,
   registerBuildCommands,
   registerResponseCommands,
   registerCitationCommands,
   registerDoiCommands,
   registerHistoryCommands,
   registerUtilityCommands,
+  registerProjectInfoCommands,
+  registerFileOpsCommands,
+  registerPreviewCommands,
+  registerQualityCommands,
+  registerWordToolsCommands,
+  registerTextOpsCommands,
 };
 
 // Re-export context utilities for use by the main CLI
@@ -51,10 +69,19 @@ export function registerAllCommands(program: Command, pkg?: PackageJson): void {
   registerCommentCommands(program);
   registerInitCommands(program);
   registerSectionCommands(program);
+  registerSyncCommands(program);
+  registerVerifyAnchorsCommands(program);
+  registerMergeResolveCommands(program);
   registerBuildCommands(program, pkg || {});
   registerResponseCommands(program);
   registerCitationCommands(program);
   registerDoiCommands(program);
   registerHistoryCommands(program);
   registerUtilityCommands(program, pkg || {});
+  registerProjectInfoCommands(program);
+  registerFileOpsCommands(program);
+  registerPreviewCommands(program);
+  registerQualityCommands(program);
+  registerWordToolsCommands(program);
+  registerTextOpsCommands(program);
 }