docrev 0.6.7 → 0.7.6

package/lib/schema.js

@@ -0,0 +1,368 @@
+/**
+ * JSON Schema validation for rev.yaml configuration
+ */
+
+/**
+ * JSON Schema for rev.yaml
+ */
+export const revYamlSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'rev.yaml configuration',
+  description: 'Configuration file for docrev document workflow',
+  type: 'object',
+  properties: {
+    title: {
+      type: 'string',
+      description: 'Document title',
+    },
+    version: {
+      type: 'string',
+      description: 'Document version',
+    },
+    authors: {
+      type: 'array',
+      description: 'List of authors',
+      items: {
+        oneOf: [
+          { type: 'string' },
+          {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              affiliation: { type: 'string' },
+              email: { type: 'string', format: 'email' },
+              orcid: { type: 'string', pattern: '^\\d{4}-\\d{4}-\\d{4}-\\d{3}[0-9X]$' },
+            },
+            required: ['name'],
+          },
+        ],
+      },
+    },
+    sections: {
+      type: 'array',
+      description: 'Ordered list of section files to include',
+      items: { type: 'string', pattern: '.*\\.md$' },
+    },
+    bibliography: {
+      type: 'string',
+      description: 'Path to bibliography file (.bib)',
+      pattern: '.*\\.bib$',
+    },
+    csl: {
+      type: 'string',
+      description: 'Path to CSL citation style file',
+    },
+    crossref: {
+      type: 'object',
+      description: 'pandoc-crossref settings',
+      properties: {
+        figureTitle: { type: 'string', default: 'Figure' },
+        tableTitle: { type: 'string', default: 'Table' },
+        figPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        tblPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        eqnPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        secPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        linkReferences: { type: 'boolean', default: true },
+      },
+      additionalProperties: true,
+    },
+    pdf: {
+      type: 'object',
+      description: 'PDF output settings',
+      properties: {
+        template: { type: 'string' },
+        documentclass: {
+          type: 'string',
+          enum: ['article', 'report', 'book', 'memoir', 'scrartcl', 'scrreprt', 'scrbook'],
+          default: 'article',
+        },
+        fontsize: {
+          type: 'string',
+          pattern: '^\\d{1,2}pt$',
+          default: '12pt',
+        },
+        geometry: { type: 'string', default: 'margin=1in' },
+        linestretch: { type: 'number', minimum: 1, maximum: 3, default: 1.5 },
+        numbersections: { type: 'boolean', default: false },
+        toc: { type: 'boolean', default: false },
+        header: { type: 'string' },
+        footer: { type: 'string' },
+      },
+      additionalProperties: true,
+    },
+    docx: {
+      type: 'object',
+      description: 'Word output settings',
+      properties: {
+        reference: { type: 'string', description: 'Reference document for styling' },
+        keepComments: { type: 'boolean', default: true },
+        toc: { type: 'boolean', default: false },
+      },
+      additionalProperties: true,
+    },
+    tex: {
+      type: 'object',
+      description: 'LaTeX output settings',
+      properties: {
+        standalone: { type: 'boolean', default: true },
+      },
+      additionalProperties: true,
+    },
+  },
+  additionalProperties: true,
+};
+
+/**
+ * Validate a value against a simple schema
+ * @param {*} value - Value to validate
+ * @param {object} schema - JSON Schema
+ * @param {string} path - Current path for error messages
+ * @returns {object[]} Array of validation errors
+ */
+function validateValue(value, schema, path = '') {
+  const errors = [];
+
+  // Handle oneOf
+  if (schema.oneOf) {
+    const validForAny = schema.oneOf.some((subSchema) => {
+      const subErrors = validateValue(value, subSchema, path);
+      return subErrors.length === 0;
+    });
+    if (!validForAny) {
+      errors.push({
+        path,
+        message: `Value does not match any allowed type`,
+        value,
+      });
+    }
+    return errors;
+  }
+
+  // Type check
+  if (schema.type) {
+    const actualType = Array.isArray(value) ? 'array' : typeof value;
+    if (actualType !== schema.type) {
+      errors.push({
+        path,
+        message: `Expected ${schema.type}, got ${actualType}`,
+        value,
+      });
+      return errors; // Stop further validation if type is wrong
+    }
+  }
+
+  // String validation
+  if (schema.type === 'string' && typeof value === 'string') {
+    if (schema.pattern) {
+      const regex = new RegExp(schema.pattern);
+      if (!regex.test(value)) {
+        errors.push({
+          path,
+          message: `Value "${value}" does not match pattern ${schema.pattern}`,
+          value,
+        });
+      }
+    }
+    if (schema.enum && !schema.enum.includes(value)) {
+      errors.push({
+        path,
+        message: `Value "${value}" must be one of: ${schema.enum.join(', ')}`,
+        value,
+      });
+    }
+  }
+
+  // Number validation
+  if (schema.type === 'number' && typeof value === 'number') {
+    if (schema.minimum !== undefined && value < schema.minimum) {
+      errors.push({
+        path,
+        message: `Value ${value} is less than minimum ${schema.minimum}`,
+        value,
+      });
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+      errors.push({
+        path,
+        message: `Value ${value} is greater than maximum ${schema.maximum}`,
+        value,
+      });
+    }
+  }
+
+  // Array validation
+  if (schema.type === 'array' && Array.isArray(value)) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+      errors.push({
+        path,
+        message: `Array must have at least ${schema.minItems} items`,
+        value,
+      });
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+      errors.push({
+        path,
+        message: `Array must have at most ${schema.maxItems} items`,
+        value,
+      });
+    }
+    if (schema.items) {
+      value.forEach((item, index) => {
+        errors.push(...validateValue(item, schema.items, `${path}[${index}]`));
+      });
+    }
+  }
+
+  // Object validation
+  if (schema.type === 'object' && typeof value === 'object' && value !== null) {
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (value[key] !== undefined) {
+          errors.push(...validateValue(value[key], propSchema, path ? `${path}.${key}` : key));
+        }
+      }
+    }
+    if (schema.required) {
+      for (const key of schema.required) {
+        if (value[key] === undefined) {
+          errors.push({
+            path: path ? `${path}.${key}` : key,
+            message: `Required property "${key}" is missing`,
+            value: undefined,
+          });
+        }
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Validate rev.yaml configuration
+ * @param {object} config - Parsed configuration object
+ * @returns {{ valid: boolean, errors: object[], warnings: object[] }}
+ */
+export function validateConfig(config) {
+  const errors = validateValue(config, revYamlSchema);
+  const warnings = [];
+
+  // Additional semantic validations
+  if (config.sections && config.sections.length === 0) {
+    warnings.push({
+      path: 'sections',
+      message: 'No sections specified - build will auto-detect .md files',
+    });
+  }
+
+  if (config.bibliography && !config.bibliography.endsWith('.bib')) {
+    warnings.push({
+      path: 'bibliography',
+      message: 'Bibliography file should have .bib extension',
+    });
+  }
+
+  if (config.pdf?.linestretch && (config.pdf.linestretch < 1 || config.pdf.linestretch > 3)) {
+    warnings.push({
+      path: 'pdf.linestretch',
+      message: 'Line stretch values outside 1-3 range may produce unexpected results',
+    });
+  }
+
+  // Check for common typos
+  const knownKeys = Object.keys(revYamlSchema.properties);
+  for (const key of Object.keys(config)) {
+    if (key.startsWith('_')) continue; // Internal keys
+    if (!knownKeys.includes(key)) {
+      // Check for similar keys (possible typos)
+      const similar = knownKeys.find(
+        (k) => levenshtein(key.toLowerCase(), k.toLowerCase()) <= 2
+      );
+      if (similar) {
+        warnings.push({
+          path: key,
+          message: `Unknown property "${key}" - did you mean "${similar}"?`,
+        });
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Format validation results for display
+ * @param {{ valid: boolean, errors: object[], warnings: object[] }} result
+ * @param {object} chalk - Chalk instance for coloring
+ * @returns {string}
+ */
+export function formatValidationResult(result, chalk) {
+  const lines = [];
+
+  if (result.errors.length > 0) {
+    lines.push(chalk.red('Configuration errors:'));
+    for (const error of result.errors) {
+      lines.push(chalk.red(`  ✗ ${error.path}: ${error.message}`));
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    if (lines.length > 0) lines.push('');
+    lines.push(chalk.yellow('Warnings:'));
+    for (const warning of result.warnings) {
+      lines.push(chalk.yellow(`  ! ${warning.path}: ${warning.message}`));
+    }
+  }
+
+  if (result.valid && result.warnings.length === 0) {
+    lines.push(chalk.green('✓ Configuration is valid'));
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Levenshtein distance for typo detection
+ */
+function levenshtein(a, b) {
+  const matrix = Array(b.length + 1)
+    .fill(null)
+    .map(() => Array(a.length + 1).fill(null));
+  for (let i = 0; i <= a.length; i++) matrix[0][i] = i;
+  for (let j = 0; j <= b.length; j++) matrix[j][0] = j;
+  for (let j = 1; j <= b.length; j++) {
+    for (let i = 1; i <= a.length; i++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[j][i] = Math.min(
+        matrix[j][i - 1] + 1,
+        matrix[j - 1][i] + 1,
+        matrix[j - 1][i - 1] + cost
+      );
+    }
+  }
+  return matrix[b.length][a.length];
+}

package/lib/sections.js

@@ -4,7 +4,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import * as yaml from 'js-yaml';
+import YAML from 'yaml';
 
 /**
  * @typedef {Object} SectionConfig
@@ -124,7 +124,7 @@ function titleCase(str) {
  */
 export function loadConfig(configPath) {
   const content = fs.readFileSync(configPath, 'utf-8');
-  const config = yaml.load(content);
+  const config = YAML.parse(content);
 
   // Normalize: convert string values to full config objects
   const normalized = { ...config };
@@ -154,12 +154,7 @@ export function loadConfig(configPath) {
  * @param {object} config
  */
 export function saveConfig(configPath, config) {
-  const yamlStr = yaml.dump(config, {
-    indent: 2,
-    lineWidth: 100,
-    quotingType: '"',
-    forceQuotes: false,
-  });
+  const yamlStr = YAML.stringify(config, { indent: 2, lineWidth: 100 });
   fs.writeFileSync(configPath, yamlStr, 'utf-8');
 }
 

package/lib/templates.js

@@ -212,6 +212,135 @@ paper.md
     directories: ['figures', 'tables'],
   },
 
+  /**
+   * LaTeX-focused project with direct .tex output
+   */
+  latex: {
+    name: 'LaTeX Project',
+    description: 'LaTeX-native with journal template support',
+    files: {
+      'rev.yaml': `# LaTeX Paper Configuration
+title: "Paper Title"
+authors:
+  - name: First Author
+    affiliation: University
+    email: author@example.edu
+    orcid: 0000-0000-0000-0000
+
+sections:
+  - introduction.md
+  - methods.md
+  - results.md
+  - discussion.md
+
+bibliography: references.bib
+csl: null
+
+# LaTeX-specific settings
+pdf:
+  documentclass: article
+  classoption: [11pt, a4paper]
+  fontsize: 11pt
+  geometry: "margin=2.5cm"
+  linestretch: 1.5
+  numbersections: true
+  header-includes: |
+    \\usepackage{amsmath}
+    \\usepackage{graphicx}
+    \\usepackage{booktabs}
+    \\usepackage{hyperref}
+    \\usepackage{natbib}
+
+# TEX output settings
+tex:
+  standalone: true
+  keep-tex: true
+`,
+      'introduction.md': `# Introduction
+
+Background and motivation.
+
+## Objectives
+
+State your research questions.
+
+`,
+      'methods.md': `# Materials and Methods
+
+## Study Area
+
+Describe the study area or data sources.
+
+## Statistical Analysis
+
+All analyses were performed in R [@R2024].
+
+`,
+      'results.md': `# Results
+
+Main findings presented here.
+
+![Caption for figure](figures/fig1.pdf){#fig:main width=100%}
+
+See @fig:main for the main results.
+
+| Variable | Value | SE |
+|----------|-------|------|
+| A | 1.23 | 0.05 |
+| B | 4.56 | 0.12 |
+
+: Summary statistics {#tbl:summary}
+
+`,
+      'discussion.md': `# Discussion
+
+Interpretation of findings.
+
+## Limitations
+
+Study limitations.
+
+## Conclusions
+
+Key takeaways.
+
+`,
+      'references.bib': `@Manual{R2024,
+  title = {R: A Language and Environment for Statistical Computing},
+  author = {{R Core Team}},
+  organization = {R Foundation for Statistical Computing},
+  address = {Vienna, Austria},
+  year = {2024},
+  url = {https://www.R-project.org/}
+}
+`,
+      '.gitignore': `# Build outputs
+*.pdf
+*.docx
+paper.md
+.paper-*.md
+
+# Keep .tex for version control
+# *.tex
+
+# LaTeX auxiliary files
+*.aux
+*.bbl
+*.blg
+*.log
+*.out
+*.toc
+*.fdb_latexmk
+*.fls
+*.synctex.gz
+
+# System
+.DS_Store
+`,
+    },
+    directories: ['figures', 'tables'],
+  },
+
   /**
    * Review article structure
    */
@@ -303,3 +432,92 @@ export function listTemplates() {
     description: template.description,
   }));
 }
+
+/**
+ * Convert string to title case for headers
+ * @param {string} str
+ * @returns {string}
+ */
+function titleCase(str) {
+  return str
+    .split(/[-_\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+/**
+ * Generate a custom template with specified sections
+ * @param {string[]} sections - Array of section names (without .md extension)
+ * @param {object} baseTemplate - Base template to extend (default: paper)
+ * @returns {object}
+ */
+export function generateCustomTemplate(sections, baseTemplate = TEMPLATES.paper) {
+  const files = {};
+
+  // Generate rev.yaml with custom sections
+  const sectionsList = sections.map((s) => `  - ${s}.md`).join('\n');
+  files['rev.yaml'] = `# Paper configuration
+title: "Your Paper Title"
+authors:
+  - name: First Author
+    affiliation: Institution
+    email: author@example.com
+
+# Section files in order
+sections:
+${sectionsList}
+
+# Bibliography (optional)
+bibliography: references.bib
+csl: null  # uses default CSL
+
+# Cross-reference settings
+crossref:
+  figureTitle: Figure
+  tableTitle: Table
+  figPrefix: [Fig., Figs.]
+  tblPrefix: [Table, Tables]
+  linkReferences: true
+
+# PDF output settings
+pdf:
+  documentclass: article
+  fontsize: 12pt
+  geometry: margin=1in
+  linestretch: 1.5
+  numbersections: false
+
+# Word output settings
+docx:
+  reference: null  # path to reference.docx template
+  keepComments: true
+`;
+
+  // Generate section files
+  for (const section of sections) {
+    const header = titleCase(section);
+    files[`${section}.md`] = `# ${header}
+
+`;
+  }
+
+  // Add common files
+  files['references.bib'] = baseTemplate.files['references.bib'] || '';
+  files['.gitignore'] = baseTemplate.files['.gitignore'] || `# Build outputs
+*.pdf
+*.docx
+*.tex
+paper.md
+.paper-*.md
+
+# System
+.DS_Store
+`;
+
+  return {
+    name: 'Custom',
+    description: 'Custom sections',
+    files,
+    directories: baseTemplate.directories || ['figures'],
+  };
+}