docrev 0.3.0 → 0.5.0

package/lib/grammar.js

@@ -0,0 +1,290 @@
+/**
+ * Grammar checker module with custom dictionary support
+ *
+ * Features:
+ * - Common grammar/style issues detection
+ * - Custom dictionary for project-specific terms
+ * - Learn mode to add words to dictionary
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Default dictionary location
+const DEFAULT_DICT_NAME = '.rev-dictionary';
+
+/**
+ * Common grammar/style rules
+ */
+const GRAMMAR_RULES = [
+  {
+    id: 'passive-voice',
+    pattern: /\b(is|are|was|were|be|been|being)\s+(being\s+)?\w+ed\b/gi,
+    message: 'Possible passive voice',
+    severity: 'info',
+  },
+  {
+    id: 'weasel-words',
+    pattern: /\b(very|really|quite|extremely|fairly|rather|somewhat|just)\b/gi,
+    message: 'Weasel word - consider removing or being more specific',
+    severity: 'warning',
+  },
+  {
+    id: 'weak-start',
+    pattern: /^\s*(There (is|are|was|were)|It is)\b/gmi,
+    message: 'Weak sentence start - consider restructuring',
+    severity: 'info',
+  },
+  {
+    id: 'duplicate-words',
+    pattern: /\b(\w+)\s+\1\b/gi,
+    message: 'Duplicate word',
+    severity: 'error',
+  },
+  {
+    id: 'split-infinitive',
+    pattern: /\bto\s+(\w+ly)\s+\w+\b/gi,
+    message: 'Split infinitive',
+    severity: 'info',
+  },
+  {
+    id: 'sentence-length',
+    pattern: /[^.!?]*[.!?]/g,
+    check: (match) => {
+      const words = match.trim().split(/\s+/).length;
+      return words > 40;
+    },
+    message: 'Long sentence (>40 words) - consider breaking up',
+    severity: 'warning',
+  },
+  {
+    id: 'cliches',
+    pattern: /\b(at the end of the day|in terms of|it goes without saying|needless to say|as a matter of fact|first and foremost|last but not least)\b/gi,
+    message: 'Cliche - consider rephrasing',
+    severity: 'warning',
+  },
+  {
+    id: 'hedging',
+    pattern: /\b(seems to|appears to|tends to|might|may|could possibly|would seem)\b/gi,
+    message: 'Hedging language - be more direct if appropriate',
+    severity: 'info',
+  },
+  {
+    id: 'redundancy',
+    pattern: /\b(basic fundamentals|end result|free gift|future plans|past history|completely unique|absolutely essential|close proximity|each and every|first began|true fact|advance planning|final outcome)\b/gi,
+    message: 'Redundant phrase',
+    severity: 'warning',
+  },
+];
+
+/**
+ * Scientific writing specific rules
+ */
+const SCIENTIFIC_RULES = [
+  {
+    id: 'first-person',
+    pattern: /\b(I|we|my|our)\b/gi,
+    message: 'First person pronoun - check if appropriate for your journal',
+    severity: 'info',
+  },
+  {
+    id: 'significant',
+    pattern: /\bsignificant(ly)?\b(?!\s+(P|p|α|difference|effect|increase|decrease|correlation))/gi,
+    message: '"Significant" without statistical context - clarify or use different word',
+    severity: 'warning',
+  },
+  {
+    id: 'prove',
+    pattern: /\b(prove[ds]?|proof)\b/gi,
+    message: 'Avoid "prove" in science - use "demonstrate", "show", "suggest"',
+    severity: 'warning',
+  },
+  {
+    id: 'obviously',
+    pattern: /\b(obviously|clearly|of course)\b/gi,
+    message: 'If obvious, no need to say so; if not obvious, this doesn\'t help',
+    severity: 'warning',
+  },
+];
+
+/**
+ * Load custom dictionary from file
+ * @param {string} directory - Directory to search for dictionary
+ * @returns {Set<string>} Set of custom words
+ */
+export function loadDictionary(directory = '.') {
+  const dictPath = path.join(directory, DEFAULT_DICT_NAME);
+  const words = new Set();
+
+  if (fs.existsSync(dictPath)) {
+    const content = fs.readFileSync(dictPath, 'utf-8');
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      const word = line.trim().toLowerCase();
+      if (word && !word.startsWith('#')) {
+        words.add(word);
+      }
+    }
+  }
+
+  return words;
+}
+
+/**
+ * Save custom dictionary to file
+ * @param {Set<string>} words - Set of words
+ * @param {string} directory - Directory to save dictionary
+ */
+export function saveDictionary(words, directory = '.') {
+  const dictPath = path.join(directory, DEFAULT_DICT_NAME);
+
+  const header = `# Custom dictionary for docrev
+# Add one word per line
+# Lines starting with # are comments
+`;
+
+  const content = header + [...words].sort().join('\n') + '\n';
+  fs.writeFileSync(dictPath, content, 'utf-8');
+}
+
+/**
+ * Add word to custom dictionary
+ * @param {string} word - Word to add
+ * @param {string} directory - Directory containing dictionary
+ * @returns {boolean} True if word was added (not already present)
+ */
+export function addToDictionary(word, directory = '.') {
+  const words = loadDictionary(directory);
+  const normalizedWord = word.trim().toLowerCase();
+
+  if (words.has(normalizedWord)) {
+    return false;
+  }
+
+  words.add(normalizedWord);
+  saveDictionary(words, directory);
+  return true;
+}
+
+/**
+ * Remove word from custom dictionary
+ * @param {string} word - Word to remove
+ * @param {string} directory - Directory containing dictionary
+ * @returns {boolean} True if word was removed
+ */
+export function removeFromDictionary(word, directory = '.') {
+  const words = loadDictionary(directory);
+  const normalizedWord = word.trim().toLowerCase();
+
+  if (!words.has(normalizedWord)) {
+    return false;
+  }
+
+  words.delete(normalizedWord);
+  saveDictionary(words, directory);
+  return true;
+}
+
+/**
+ * Check text for grammar/style issues
+ * @param {string} text - Text to check
+ * @param {object} options - Options
+ * @param {boolean} options.scientific - Include scientific writing rules
+ * @param {string} options.directory - Directory for custom dictionary
+ * @returns {Array<{rule: string, message: string, severity: string, line: number, match: string}>}
+ */
+export function checkGrammar(text, options = {}) {
+  const { scientific = true, directory = '.' } = options;
+  const customDict = loadDictionary(directory);
+  const issues = [];
+
+  // Get all rules
+  const rules = scientific ? [...GRAMMAR_RULES, ...SCIENTIFIC_RULES] : GRAMMAR_RULES;
+
+  // Split into lines for line number tracking
+  const lines = text.split('\n');
+
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+
+    // Skip code blocks and YAML frontmatter
+    if (line.trim().startsWith('```') || line.trim().startsWith('---')) {
+      continue;
+    }
+
+    // Skip lines that are just markdown syntax
+    if (/^[#\-*>|]/.test(line.trim()) && line.trim().length < 5) {
+      continue;
+    }
+
+    for (const rule of rules) {
+      const pattern = new RegExp(rule.pattern.source, rule.pattern.flags);
+      let match;
+
+      while ((match = pattern.exec(line)) !== null) {
+        // Check if rule has additional check function
+        if (rule.check && !rule.check(match[0])) {
+          continue;
+        }
+
+        // Skip if word is in custom dictionary
+        const word = match[0].toLowerCase();
+        if (customDict.has(word)) {
+          continue;
+        }
+
+        issues.push({
+          rule: rule.id,
+          message: rule.message,
+          severity: rule.severity,
+          line: lineNum + 1,
+          column: match.index + 1,
+          match: match[0],
+          context: line.trim(),
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Get grammar check summary
+ * @param {Array} issues - List of issues from checkGrammar
+ * @returns {object} Summary stats
+ */
+export function getGrammarSummary(issues) {
+  const summary = {
+    total: issues.length,
+    errors: 0,
+    warnings: 0,
+    info: 0,
+    byRule: {},
+  };
+
+  for (const issue of issues) {
+    if (issue.severity === 'error') summary.errors++;
+    else if (issue.severity === 'warning') summary.warnings++;
+    else summary.info++;
+
+    summary.byRule[issue.rule] = (summary.byRule[issue.rule] || 0) + 1;
+  }
+
+  return summary;
+}
+
+/**
+ * List available grammar rules
+ * @param {boolean} scientific - Include scientific rules
+ * @returns {Array<{id: string, message: string, severity: string}>}
+ */
+export function listRules(scientific = true) {
+  const rules = scientific ? [...GRAMMAR_RULES, ...SCIENTIFIC_RULES] : GRAMMAR_RULES;
+  return rules.map(r => ({
+    id: r.id,
+    message: r.message,
+    severity: r.severity,
+  }));
+}

package/lib/journals.js

@@ -130,6 +130,191 @@ export const JOURNAL_PROFILES = {
       impactStatement: true,
     },
   },
+
+  'cell': {
+    name: 'Cell',
+    url: 'https://www.cell.com/cell/authors',
+    requirements: {
+      wordLimit: { main: 7000, abstract: 150, title: null },
+      references: { max: 100, doiRequired: true },
+      figures: { max: 7, combinedWithTables: true },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Results', 'Discussion'],
+        graphicalAbstract: true,
+        highlights: true,
+      },
+      authors: { maxInitial: null, correspondingRequired: true },
+    },
+  },
+
+  'current-biology': {
+    name: 'Current Biology',
+    url: 'https://www.cell.com/current-biology/authors',
+    requirements: {
+      wordLimit: { main: 5000, abstract: 150, title: 150 },
+      references: { max: 60, doiRequired: true },
+      figures: { max: 4, combinedWithTables: true },
+      sections: {
+        required: ['Summary', 'Results', 'Discussion'],
+      },
+      authors: { maxInitial: null, correspondingRequired: true },
+    },
+  },
+
+  'conservation-biology': {
+    name: 'Conservation Biology',
+    url: 'https://conbio.onlinelibrary.wiley.com/hub/journal/15231739/homepage/forauthors.html',
+    requirements: {
+      wordLimit: { main: 7000, abstract: 300, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: 6, combinedWithTables: true },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 5, max: 10 },
+    },
+  },
+
+  'biological-conservation': {
+    name: 'Biological Conservation',
+    url: 'https://www.elsevier.com/journals/biological-conservation/0006-3207/guide-for-authors',
+    requirements: {
+      wordLimit: { main: 8000, abstract: 400, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      highlights: true,
+      keywords: { min: 4, max: 6 },
+    },
+  },
+
+  'journal-of-ecology': {
+    name: 'Journal of Ecology',
+    url: 'https://besjournals.onlinelibrary.wiley.com/hub/journal/13652745/author-guidelines',
+    requirements: {
+      wordLimit: { main: 7000, abstract: 350, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 4, max: 8 },
+    },
+  },
+
+  'functional-ecology': {
+    name: 'Functional Ecology',
+    url: 'https://besjournals.onlinelibrary.wiley.com/hub/journal/13652435/author-guidelines',
+    requirements: {
+      wordLimit: { main: 7000, abstract: 350, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 4, max: 8 },
+    },
+  },
+
+  'global-change-biology': {
+    name: 'Global Change Biology',
+    url: 'https://onlinelibrary.wiley.com/page/journal/13652486/homepage/forauthors.html',
+    requirements: {
+      wordLimit: { main: 7000, abstract: 300, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: 8, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 4, max: 8 },
+    },
+  },
+
+  'oikos': {
+    name: 'Oikos',
+    url: 'https://nsojournals.onlinelibrary.wiley.com/hub/journal/16000706/author-guidelines',
+    requirements: {
+      wordLimit: { main: 8000, abstract: 350, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 4, max: 10 },
+    },
+  },
+
+  'oecologia': {
+    name: 'Oecologia',
+    url: 'https://www.springer.com/journal/442/submission-guidelines',
+    requirements: {
+      wordLimit: { main: 8000, abstract: 250, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 4, max: 6 },
+    },
+  },
+
+  'biological-invasions': {
+    name: 'Biological Invasions',
+    url: 'https://www.springer.com/journal/10530/submission-guidelines',
+    requirements: {
+      wordLimit: { main: null, abstract: 250, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 4, max: 6 },
+    },
+  },
+
+  'diversity-distributions': {
+    name: 'Diversity and Distributions',
+    url: 'https://onlinelibrary.wiley.com/page/journal/14724642/homepage/forauthors.html',
+    requirements: {
+      wordLimit: { main: 6000, abstract: 300, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: 6, combinedWithTables: true },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 4, max: 8 },
+      biosketch: true,
+    },
+  },
+
+  'neobiota': {
+    name: 'NeoBiota',
+    url: 'https://neobiota.pensoft.net/about#Author_Guidelines',
+    requirements: {
+      wordLimit: { main: null, abstract: 350, title: null },
+      references: { max: null, doiRequired: true },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+      keywords: { min: 6, max: 12 },
+    },
+  },
+
+  'peerj': {
+    name: 'PeerJ',
+    url: 'https://peerj.com/about/author-instructions/',
+    requirements: {
+      wordLimit: { main: null, abstract: 500, title: null },
+      references: { max: null, doiRequired: false },
+      figures: { max: null, combinedWithTables: false },
+      sections: {
+        required: ['Abstract', 'Introduction', 'Methods', 'Results', 'Discussion'],
+      },
+    },
+  },
 };
 
 /**

package/lib/merge.js

@@ -6,7 +6,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { diffWords } from 'diff';
-import { extractTextFromWord, extractCommentsFromWord } from './import.js';
+import { extractFromWord, extractWordComments } from './import.js';
 
 /**
  * Represents a change from a reviewer
@@ -304,13 +304,13 @@ export async function mergeReviewerDocs(originalPath, reviewerDocs, options = {}
       throw new Error(`Reviewer file not found: ${doc.path}`);
     }
 
-    const wordText = await extractTextFromWord(doc.path);
+    const { text: wordText } = await extractFromWord(doc.path);
     const changes = extractChanges(originalText, wordText, doc.name);
     allChanges.push(changes);
 
     // Also extract comments
     try {
-      const comments = await extractCommentsFromWord(doc.path);
+      const comments = await extractWordComments(doc.path);
       allComments.push(...comments.map(c => ({ ...c, reviewer: doc.name })));
     } catch {
       // Comments extraction failed, continue without

package/lib/scientific-words.js

@@ -0,0 +1,73 @@
+/**
+ * Common scientific and academic words not in standard dictionaries
+ * These words are accepted by Word's spellchecker
+ */
+
+export const scientificWords = new Set([
+  // Biology/Ecology
+  'abiotic', 'biotic', 'biogeographic', 'biogeography', 'phenotypic', 'phenotype',
+  'anthropogenic', 'propagule', 'propagules', 'herbivory', 'herbivore', 'herbivores',
+  'ruderal', 'ruderals', 'refugia', 'refugium', 'hotspot', 'hotspots',
+  'biodiversity', 'ecosystem', 'ecosystems', 'ecotype', 'ecotypes',
+  'taxonomic', 'phylogenetic', 'phylogeny', 'morphological', 'morphology',
+  'allometric', 'allometry', 'biomass', 'biome', 'biomes',
+  'invasibility', 'invasive', 'invasives', 'neophyte', 'neophytes',
+  'archaeophyte', 'archaeophytes', 'naturalisation', 'naturalization',
+  'colonisation', 'colonization', 'dispersal', 'fecundity',
+  'phenology', 'phenological', 'ontogeny', 'ontogenetic',
+  'mesic', 'xeric', 'hydric', 'riparian', 'riverine',
+  'subalpine', 'alpine', 'boreal', 'temperate', 'tropical',
+  'heathland', 'heathlands', 'scrubland', 'scrublands', 'grassland', 'grasslands',
+  'broadleaf', 'broadleaved', 'coniferous', 'deciduous', 'evergreen',
+  'autochory', 'autochorous', 'zoochory', 'zoochorous',
+  'anemochory', 'anemochorous', 'hydrochory', 'hydrochorous',
+  'anthropochory', 'anthropochorous', 'hemerochor', 'hemerochorist',
+  'helophyte', 'helophytes', 'hydrophyte', 'hydrophytes',
+  'therophyte', 'therophytes', 'geophyte', 'geophytes',
+  'chamaephyte', 'chamaephytes', 'phanerophyte', 'phanerophytes',
+
+  // Statistics
+  'logit', 'logistic', 'probit', 'frequentist', 'bayesian',
+  'overdispersion', 'underdispersion', 'heteroscedasticity', 'homoscedasticity',
+  'multicollinearity', 'autocorrelation', 'covariate', 'covariates',
+  'parameterization', 'parameterisation', 'reparameterization',
+  'bootstrapping', 'resampling', 'imputation', 'interpolation',
+  'standardized', 'standardised', 'normalized', 'normalised',
+  'discretized', 'discretised', 'categorized', 'categorised',
+
+  // Compound words
+  'overrepresentation', 'underrepresentation', 'overrepresented', 'underrepresented',
+  'outcompete', 'outcompetes', 'outcompeted', 'outcompeting',
+  'subdataset', 'subgroup', 'subgroups', 'subtype', 'subtypes',
+  'dataset', 'datasets', 'datapoint', 'datapoints',
+  'spatiotemporal', 'spatio', 'geospatial',
+  'timestep', 'timesteps', 'timeframe', 'timeframes',
+  'warmup', 'backend', 'frontend', 'workflow', 'workflows',
+  'fallback', 'fallbacks', 'tradeoff', 'tradeoffs',
+
+  // Academic writing
+  'interpretability', 'reproducibility', 'replicability',
+  'hypothesise', 'hypothesised', 'hypothesize', 'hypothesized',
+  'analyse', 'analysed', 'analyze', 'analyzed',
+  'prioritise', 'prioritised', 'prioritize', 'prioritized',
+  'characterise', 'characterised', 'characterize', 'characterized',
+  'generalise', 'generalised', 'generalize', 'generalized',
+  'parameterise', 'parameterised', 'parameterize', 'parameterized',
+  'visualise', 'visualised', 'visualize', 'visualized',
+  'modelling', 'modeling', 'modelled', 'modeled',
+
+  // Geography
+  'unvegetated', 'landform', 'landforms', 'topographic', 'topography',
+  'elevational', 'latitudinal', 'longitudinal', 'altitudinal',
+
+  // Technical
+  'doi', 'dois', 'pdf', 'pdfs', 'csv', 'xlsx',
+  'pandoc', 'markdown', 'bibtex', 'crossref',
+
+  // R packages and tools
+  'brms', 'cmdstanr', 'rstanarm', 'lme', 'glmm', 'glmer', 'lmer',
+  'ggplot', 'dplyr', 'tidyr', 'tidyverse', 'rmarkdown',
+
+  // Common in papers
+  'foci', 'et', 'al', 'cf', 'eg', 'ie', 'vs',
+]);