docrev 0.6.13 → 0.7.6

package/completions/rev.ps1

@@ -0,0 +1,210 @@
+# PowerShell completion for rev (docrev)
+# Install: Add to $PROFILE:
+#   . (rev completions powershell)
+# Or copy output to profile manually
+
+$script:revCommands = @(
+    'build', 'new', 'import', 'sections', 'extract', 'review', 'status',
+    'comments', 'resolve', 'reply', 'strip', 'refs', 'migrate', 'config',
+    'install', 'doi', 'citations', 'equations', 'figures', 'response',
+    'anonymize', 'validate', 'merge', 'diff', 'history', 'help', 'init',
+    'split', 'sync', 'word-count', 'wc', 'stats', 'search', 'backup',
+    'archive', 'export', 'preview', 'watch', 'lint', 'grammar', 'spelling',
+    'annotate', 'apply', 'comment', 'completions', 'clean', 'check', 'open',
+    'next', 'prev', 'first', 'last', 'todo', 'accept', 'reject',
+    'pdf-comments', 'install-cli-skill', 'uninstall-cli-skill', 'doctor', 'upgrade'
+)
+
+$script:buildFormats = @('pdf', 'docx', 'tex', 'all')
+$script:doiActions = @('check', 'lookup', 'fetch', 'add')
+$script:eqActions = @('list', 'extract', 'convert', 'from-word')
+$script:helpTopics = @('workflow', 'syntax', 'commands')
+$script:previewFormats = @('pdf', 'docx')
+$script:shells = @('bash', 'zsh', 'powershell')
+
+Register-ArgumentCompleter -Native -CommandName rev -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $tokens = $commandAst.CommandElements
+    $command = $null
+
+    # Find the subcommand (skip 'rev' itself)
+    if ($tokens.Count -gt 1) {
+        $command = $tokens[1].Extent.Text
+    }
+
+    # Get the current word being completed
+    $currentWord = $wordToComplete
+
+    # If we're completing the first argument (subcommand)
+    if ($tokens.Count -le 2 -and -not $currentWord.StartsWith('-')) {
+        $script:revCommands | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+        return
+    }
+
+    # Context-specific completions
+    switch ($command) {
+        'build' {
+            if ($currentWord.StartsWith('-')) {
+                @('--toc', '--show-changes', '--clean', '--dual') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+                }
+            } else {
+                $script:buildFormats | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+                }
+            }
+        }
+        'new' {
+            @('--list', '--template', '-s') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        'doi' {
+            $script:doiActions | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+        { $_ -in @('equations', 'eq') } {
+            $script:eqActions | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+        'validate' {
+            @('--list', '--journal') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        'help' {
+            $script:helpTopics | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+        'config' {
+            @('user', 'sections') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+        { $_ -in @('word-count', 'wc') } {
+            @('--limit', '--journal') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        'preview' {
+            $script:previewFormats | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+        'watch' {
+            if ($currentWord.StartsWith('-')) {
+                @('--no-open') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+                }
+            } else {
+                @('pdf', 'docx', 'all') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+                }
+            }
+        }
+        'completions' {
+            $script:shells | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+        'comments' {
+            @('--pending', '-p', '--resolved', '-r', '--export', '-e', '--author') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+            # Also complete .md files
+            Get-ChildItem -Filter "*.md" -ErrorAction SilentlyContinue | ForEach-Object {
+                if ($_.Name -like "$currentWord*") {
+                    [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                }
+            }
+        }
+        { $_ -in @('resolve', 'reply') } {
+            @('-n', '-m', '--number', '--message', '--author', '-a') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+            Get-ChildItem -Filter "*.md" -ErrorAction SilentlyContinue | ForEach-Object {
+                if ($_.Name -like "$currentWord*") {
+                    [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                }
+            }
+        }
+        { $_ -in @('accept', 'reject') } {
+            @('-n', '-a', '--all') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+            Get-ChildItem -Filter "*.md" -ErrorAction SilentlyContinue | ForEach-Object {
+                if ($_.Name -like "$currentWord*") {
+                    [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                }
+            }
+        }
+        'pdf-comments' {
+            @('--append', '-a', '--json', '--by-page', '--by-author') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+            Get-ChildItem -Filter "*.pdf" -ErrorAction SilentlyContinue | ForEach-Object {
+                if ($_.Name -like "$currentWord*") {
+                    [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                }
+            }
+        }
+        'grammar' {
+            @('--learn', '--forget', '--list', '--rules', '--no-scientific', '--severity') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        'spelling' {
+            @('--british', '--learn', '--learn-project', '--list') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        'sync' {
+            Get-ChildItem -Filter "*.docx" -ErrorAction SilentlyContinue | ForEach-Object {
+                if ($_.Name -like "$currentWord*") {
+                    [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                }
+            }
+            Get-ChildItem -Filter "*.pdf" -ErrorAction SilentlyContinue | ForEach-Object {
+                if ($_.Name -like "$currentWord*") {
+                    [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                }
+            }
+        }
+        'archive' {
+            @('--by', '--dry-run') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        'backup' {
+            @('--name', '--output') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        'todo' {
+            @('--by-author') | Where-Object { $_ -like "$currentWord*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+            }
+        }
+        default {
+            # Default file completion for most commands that take files
+            if (-not $currentWord.StartsWith('-')) {
+                Get-ChildItem -Filter "*.md" -ErrorAction SilentlyContinue | ForEach-Object {
+                    if ($_.Name -like "$currentWord*") {
+                        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                    }
+                }
+                Get-ChildItem -Filter "*.docx" -ErrorAction SilentlyContinue | ForEach-Object {
+                    if ($_.Name -like "$currentWord*") {
+                        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ProviderItem', $_.Name)
+                    }
+                }
+            }
+        }
+    }
+}

package/lib/annotations.js

@@ -20,45 +20,75 @@ const PATTERNS = {
 
 /**
  * Check if a potential comment is actually a false positive
- * (e.g., figure caption, nested inside other annotation, etc.)
+ * (e.g., figure caption, nested inside other annotation, code block, etc.)
  * @param {string} commentContent - The content inside {>>...<<}
  * @param {string} fullText - The full document text
  * @param {number} position - Position of the comment in the text
  * @returns {boolean} true if this is a false positive (not a real comment)
  */
 function isCommentFalsePositive(commentContent, fullText, position) {
+  // Check if inside a code block (fenced or indented)
+  const textBefore = fullText.slice(Math.max(0, position - 2000), position);
+  const textAfter = fullText.slice(position, Math.min(fullText.length, position + 2000));
+
+  // Count unclosed fenced code blocks (``` or ~~~)
+  const fenceOpens = (textBefore.match(/^```|^~~~/gm) || []).length;
+  const fenceCloses = (textBefore.match(/```$|~~~$/gm) || []).length;
+  if (fenceOpens > fenceCloses) return true; // Inside code block
+
+  // Check if on an indented line (4+ spaces or tab at line start = code)
+  const lineStart = textBefore.lastIndexOf('\n') + 1;
+  const linePrefix = fullText.slice(lineStart, position);
+  if (/^(\t|    )/.test(linePrefix)) return true; // Indented code
+
+  // Check if inside inline code backticks
+  const backticksBefore = (linePrefix.match(/`/g) || []).length;
+  if (backticksBefore % 2 === 1) return true; // Inside inline code
+
   // Check if nested inside a deletion or insertion block
-  // Look backwards for unclosed {-- or {++ before this position
-  const textBefore = fullText.slice(Math.max(0, position - 500), position);
+  const nearTextBefore = fullText.slice(Math.max(0, position - 500), position);
 
   // Count unclosed deletion markers
-  const delOpens = (textBefore.match(/\{--/g) || []).length;
-  const delCloses = (textBefore.match(/--\}/g) || []).length;
+  const delOpens = (nearTextBefore.match(/\{--/g) || []).length;
+  const delCloses = (nearTextBefore.match(/--\}/g) || []).length;
   if (delOpens > delCloses) return true; // Nested inside deletion
 
   // Count unclosed insertion markers
-  const insOpens = (textBefore.match(/\{\+\+/g) || []).length;
-  const insCloses = (textBefore.match(/\+\+\}/g) || []).length;
+  const insOpens = (nearTextBefore.match(/\{\+\+/g) || []).length;
+  const insCloses = (nearTextBefore.match(/\+\+\}/g) || []).length;
   if (insOpens > insCloses) return true; // Nested inside insertion
 
   // Heuristics for figure captions and other false positives:
 
   // Contains image/figure path patterns
-  if (/\(figures?\/|\(images?\/|\.png|\.jpg|\.pdf/i.test(commentContent)) return true;
+  if (/\(figures?\/|\(images?\/|\.png|\.jpg|\.jpeg|\.gif|\.svg|\.pdf/i.test(commentContent)) return true;
 
   // 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;
+
+  // 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}:/.test(commentContent.trim());
-  if (!hasAuthorPrefix && commentContent.length > 200) return true;
+  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 > 200) return true;
 
   // Looks like a figure caption (starts with "Fig" or contains typical caption words)
-  if (/^(Fig\.?|Figure|Table|Sankey|Diagram|Proportion|Distribution)/i.test(commentContent.trim())) {
+  if (/^(Fig\.?|Figure|Table|Sankey|Diagram|Proportion|Distribution|Map|Chart|Graph|Plot|Panel)/i.test(commentContent.trim())) {
     return true;
   }
 
+  // Contains LaTeX-like patterns (likely equation, not comment)
+  if (/\\[a-z]+\{|\\frac|\\sum|\\int|\\begin\{/.test(commentContent)) return true;
+
+  // Looks like BibTeX entry (not a comment)
+  if (/@article\{|@book\{|@inproceedings\{/i.test(commentContent)) return true;
+
   return false;
 }
 

package/lib/build.js

@@ -11,7 +11,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync, spawn } from 'child_process';
-import yaml from 'js-yaml';
+import YAML from 'yaml';
 import { stripAnnotations } from './annotations.js';
 import { buildRegistry, labelToDisplay, detectDynamicRefs } from './crossref.js';
 import { processVariables, hasVariables } from './variables.js';
@@ -66,7 +66,7 @@ export function loadConfig(directory) {
 
   try {
     const content = fs.readFileSync(configPath, 'utf-8');
-    const userConfig = yaml.load(content) || {};
+    const userConfig = YAML.parse(content) || {};
 
     // Deep merge with defaults
     const config = {
@@ -110,7 +110,7 @@ export function findSections(directory, configSections = []) {
   const sectionsYamlPath = path.join(directory, 'sections.yaml');
   if (fs.existsSync(sectionsYamlPath)) {
     try {
-      const sectionsConfig = yaml.load(fs.readFileSync(sectionsYamlPath, 'utf-8'));
+      const sectionsConfig = YAML.parse(fs.readFileSync(sectionsYamlPath, 'utf-8'));
       if (sectionsConfig.sections) {
         return Object.entries(sectionsConfig.sections)
           .sort((a, b) => (a[1].order ?? 999) - (b[1].order ?? 999))
@@ -153,7 +153,7 @@ export function combineSections(directory, config, options = {}) {
   // Add YAML frontmatter
   const frontmatter = buildFrontmatter(config);
   parts.push('---');
-  parts.push(yaml.dump(frontmatter).trim());
+  parts.push(YAML.stringify(frontmatter).trim());
   parts.push('---');
   parts.push('');
 
@@ -371,6 +371,80 @@ export function hasPandoc() {
   }
 }
 
+/**
+ * Check if LaTeX is available (for PDF generation)
+ * @returns {boolean}
+ */
+export function hasLatex() {
+  try {
+    execSync('pdflatex --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    try {
+      execSync('xelatex --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Get installation instructions for missing dependencies
+ * @param {string} dependency - 'pandoc', 'latex', 'pandoc-crossref'
+ * @returns {string}
+ */
+export function getInstallInstructions(dependency) {
+  const platform = process.platform;
+  const instructions = {
+    pandoc: {
+      darwin: 'brew install pandoc',
+      win32: 'winget install JohnMacFarlane.Pandoc',
+      linux: 'sudo apt install pandoc',
+    },
+    latex: {
+      darwin: 'brew install --cask mactex-no-gui',
+      win32: 'Install MiKTeX from https://miktex.org/download',
+      linux: 'sudo apt install texlive-latex-base texlive-fonts-recommended',
+    },
+    'pandoc-crossref': {
+      darwin: 'brew install pandoc-crossref',
+      win32: 'Download from https://github.com/lierdakil/pandoc-crossref/releases',
+      linux: 'Download from https://github.com/lierdakil/pandoc-crossref/releases',
+    },
+  };
+
+  const platformInstructions = instructions[dependency];
+  if (!platformInstructions) return '';
+
+  return platformInstructions[platform] || platformInstructions.linux;
+}
+
+/**
+ * Check dependencies and return status
+ * @returns {{ pandoc: boolean, latex: boolean, crossref: boolean, messages: string[] }}
+ */
+export function checkDependencies() {
+  const status = {
+    pandoc: hasPandoc(),
+    latex: hasLatex(),
+    crossref: hasPandocCrossref(),
+    messages: [],
+  };
+
+  if (!status.pandoc) {
+    status.messages.push(`Pandoc not found. Install with: ${getInstallInstructions('pandoc')}`);
+  }
+  if (!status.latex) {
+    status.messages.push(`LaTeX not found (required for PDF). Install with: ${getInstallInstructions('latex')}`);
+  }
+  if (!status.crossref) {
+    status.messages.push(`pandoc-crossref not found (optional, for figure/table refs). Install with: ${getInstallInstructions('pandoc-crossref')}`);
+  }
+
+  return status;
+}
+
 /**
  * Write crossref.yaml if needed
  * @param {string} directory
@@ -380,7 +454,7 @@ function ensureCrossrefConfig(directory, config) {
   const crossrefPath = path.join(directory, 'crossref.yaml');
 
   if (!fs.existsSync(crossrefPath) && hasPandocCrossref()) {
-    fs.writeFileSync(crossrefPath, yaml.dump(config.crossref), 'utf-8');
+    fs.writeFileSync(crossrefPath, YAML.stringify(config.crossref), 'utf-8');
   }
 }
 
@@ -446,12 +520,25 @@ export async function runPandoc(inputPath, format, config, options = {}) {
  * @param {string} directory
  * @param {string[]} formats - ['pdf', 'docx', 'tex'] or ['all']
  * @param {object} options
- * @returns {Promise<{results: object[], paperPath: string}>}
+ * @returns {Promise<{results: object[], paperPath: string, warnings: string[]}>}
  */
 export async function build(directory, formats = ['pdf', 'docx'], options = {}) {
+  const warnings = [];
+
   // Check pandoc
   if (!hasPandoc()) {
-    throw new Error('pandoc not found. Run `rev install` to install dependencies.');
+    const instruction = getInstallInstructions('pandoc');
+    throw new Error(`Pandoc not found. Install with: ${instruction}\nOr run: rev doctor`);
+  }
+
+  // Check LaTeX if PDF is requested
+  if ((formats.includes('pdf') || formats.includes('all')) && !hasLatex()) {
+    warnings.push(`LaTeX not found - PDF generation may fail. Install with: ${getInstallInstructions('latex')}`);
+  }
+
+  // Check pandoc-crossref
+  if (!hasPandocCrossref()) {
+    warnings.push('pandoc-crossref not found - figure/table numbering will not work');
   }
 
   // Load config (use passed config if provided, otherwise load from file)
@@ -483,7 +570,7 @@ export async function build(directory, formats = ['pdf', 'docx'], options = {})
     }
   }
 
-  return { results, paperPath };
+  return { results, paperPath, warnings };
 }
 
 /**