docrev 0.8.1 → 0.8.5

package/lib/{equations.js → equations.ts}

@@ -14,13 +14,14 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import AdmZip from 'adm-zip';
 import { parseString } from 'xml2js';
+import type { Equation, EquationStats, WordEquationResult } from './types.js';
 
 const execAsync = promisify(exec);
 const parseXml = promisify(parseString);
 
 // Dynamic import for mathml-to-latex (ESM)
-let MathMLToLaTeX = null;
-async function getMathMLConverter() {
+let MathMLToLaTeX: any = null;
+async function getMathMLConverter(): Promise<any> {
   if (!MathMLToLaTeX) {
     try {
       const module = await import('mathml-to-latex');
@@ -34,12 +35,9 @@ async function getMathMLConverter() {
 
 /**
  * Extract all equations from markdown text
- * @param {string} text
- * @param {string} file - Source file name
- * @returns {Array<{type: 'inline'|'display', content: string, line: number, file: string}>}
  */
-export function extractEquations(text, file = '') {
-  const equations = [];
+export function extractEquations(text: string, file: string = ''): Equation[] {
+  const equations: Equation[] = [];
   const lines = text.split('\n');
 
   let inDisplayMath = false;
@@ -48,6 +46,7 @@ export function extractEquations(text, file = '') {
 
   for (let lineNum = 0; lineNum < lines.length; lineNum++) {
     const line = lines[lineNum];
+    if (!line) continue;
 
     // Skip code blocks
     if (line.trim().startsWith('```')) continue;
@@ -55,16 +54,19 @@ export function extractEquations(text, file = '') {
     // Handle inline math ($...$) in a segment of text
     // Careful not to match $$ or escaped \$
     const inlinePattern = /(?<![\$\\])\$(?!\$)([^$\n]+)\$(?!\$)/g;
-    const extractInline = (segment) => {
+    const extractInline = (segment: string): void => {
       let match;
       inlinePattern.lastIndex = 0;
       while ((match = inlinePattern.exec(segment)) !== null) {
-        equations.push({
-          type: 'inline',
-          content: match[1].trim(),
-          line: lineNum + 1,
-          file,
-        });
+        const content = match[1];
+        if (content) {
+          equations.push({
+            type: 'inline',
+            content: content.trim(),
+            line: lineNum + 1,
+            file,
+          });
+        }
       }
     };
 
@@ -75,24 +77,26 @@ export function extractEquations(text, file = '') {
       if (!inDisplayMath && parts.length >= 3) {
         // Single-line display math: $$content$$
         // Also extract inline math from surrounding text
-        extractInline(parts[0]); // Text before $$
+        if (parts[0]) extractInline(parts[0]); // Text before $$
         for (let i = 1; i < parts.length; i += 2) {
-          if (parts[i].trim()) {
+          const part = parts[i];
+          if (part && part.trim()) {
             equations.push({
               type: 'display',
-              content: parts[i].trim(),
+              content: part.trim(),
               line: lineNum + 1,
               file,
             });
           }
         }
         // Extract inline from text after the last $$
-        if (parts.length % 2 === 1 && parts[parts.length - 1]) {
-          extractInline(parts[parts.length - 1]);
+        const lastPart = parts[parts.length - 1];
+        if (parts.length % 2 === 1 && lastPart) {
+          extractInline(lastPart);
         }
       } else if (!inDisplayMath) {
         // Start of multi-line display math
-        extractInline(parts[0]); // Text before $$
+        if (parts[0]) extractInline(parts[0]); // Text before $$
         inDisplayMath = true;
         displayMathStart = lineNum + 1;
         displayMathContent = parts[1] || '';
@@ -110,8 +114,9 @@ export function extractEquations(text, file = '') {
         }
         displayMathContent = '';
         // Text after $$ on closing line
-        if (parts[1]) {
-          extractInline(parts[1]);
+        const afterPart = parts[1];
+        if (afterPart) {
+          extractInline(afterPart);
         }
       }
       continue;
@@ -132,11 +137,9 @@ export function extractEquations(text, file = '') {
 /**
  * Generate a markdown document with numbered equations
  * Useful for creating an equation reference sheet
- * @param {Array} equations
- * @returns {string}
  */
-export function generateEquationSheet(equations) {
-  const lines = [];
+export function generateEquationSheet(equations: Equation[]): string {
+  const lines: string[] = [];
   lines.push('# Equations');
   lines.push('');
 
@@ -144,12 +147,12 @@ export function generateEquationSheet(equations) {
   let inlineNum = 0;
 
   // Group by file
-  const byFile = new Map();
+  const byFile = new Map<string, Equation[]>();
   for (const eq of equations) {
     if (!byFile.has(eq.file)) {
       byFile.set(eq.file, []);
     }
-    byFile.get(eq.file).push(eq);
+    byFile.get(eq.file)!.push(eq);
   }
 
   for (const [file, fileEqs] of byFile) {
@@ -183,14 +186,18 @@ export function generateEquationSheet(equations) {
   return lines.join('\n');
 }
 
+interface ConvertToWordOptions {
+  preserveLatex?: boolean;
+}
+
 /**
  * Convert markdown with equations to Word using pandoc
- * @param {string} inputPath - Input markdown file
- * @param {string} outputPath - Output docx file
- * @param {object} options
- * @returns {Promise<{success: boolean, message: string}>}
  */
-export async function convertToWord(inputPath, outputPath, options = {}) {
+export async function convertToWord(
+  inputPath: string,
+  outputPath: string,
+  options: ConvertToWordOptions = {}
+): Promise<{ success: boolean; message: string }> {
   const { preserveLatex = false } = options;
 
   // Check pandoc is available
@@ -217,18 +224,18 @@ export async function convertToWord(inputPath, outputPath, options = {}) {
   try {
     await execAsync(args.join(' '));
     return { success: true, message: `Created ${outputPath}` };
-  } catch (err) {
+  } catch (err: any) {
     return { success: false, message: err.message };
   }
 }
 
 /**
  * Create a simple equations-only document
- * @param {string} inputPath - Source markdown
- * @param {string} outputPath - Output path (md or docx)
- * @returns {Promise<{success: boolean, message: string, stats: object}>}
  */
-export async function createEquationsDoc(inputPath, outputPath) {
+export async function createEquationsDoc(
+  inputPath: string,
+  outputPath: string
+): Promise<{ success: boolean; message: string; stats: { display: number; inline: number } | null }> {
   if (!fs.existsSync(inputPath)) {
     return { success: false, message: `File not found: ${inputPath}`, stats: null };
   }
@@ -264,13 +271,11 @@ export async function createEquationsDoc(inputPath, outputPath) {
 
 /**
  * Get equation statistics for a file or directory
- * @param {string[]} files
- * @returns {object}
  */
-export function getEquationStats(files) {
+export function getEquationStats(files: string[]): EquationStats {
   let totalDisplay = 0;
   let totalInline = 0;
-  const byFile = [];
+  const byFile: Array<{ file: string; display: number; inline: number }> = [];
 
   for (const file of files) {
     if (!fs.existsSync(file)) continue;
@@ -299,11 +304,8 @@ export function getEquationStats(files) {
 /**
  * Extract equations from a Word document using Pandoc
  * Converts OMML (Office Math Markup) to LaTeX
- *
- * @param {string} docxPath - Path to Word document
- * @returns {Promise<{success: boolean, equations: Array<{type: string, latex: string, position: number}>, error?: string}>}
  */
-export async function extractEquationsFromWord(docxPath) {
+export async function extractEquationsFromWord(docxPath: string): Promise<WordEquationResult> {
   if (!fs.existsSync(docxPath)) {
     return { success: false, equations: [], error: `File not found: ${docxPath}` };
   }
@@ -336,11 +338,8 @@ export async function extractEquationsFromWord(docxPath) {
 /**
  * Direct OMML extraction from Word document (fallback if Pandoc fails)
  * Parses document.xml for <m:oMath> elements and attempts conversion
- *
- * @param {string} docxPath
- * @returns {Promise<{success: boolean, equations: Array, error?: string}>}
  */
-async function extractEquationsFromWordDirect(docxPath) {
+async function extractEquationsFromWordDirect(docxPath: string): Promise<WordEquationResult> {
   try {
     const zip = new AdmZip(docxPath);
     const documentEntry = zip.getEntry('word/document.xml');
@@ -356,15 +355,16 @@ async function extractEquationsFromWordDirect(docxPath) {
     const matches = documentXml.match(ommlPattern) || [];
 
     if (matches.length === 0) {
-      return { success: true, equations: [], message: 'No equations found' };
+      return { success: true, equations: [] };
     }
 
     // Try to convert OMML to LaTeX via MathML intermediate
     const Converter = await getMathMLConverter();
-    const equations = [];
+    const equations: WordEquationResult['equations'] = [];
 
     for (let i = 0; i < matches.length; i++) {
       const omml = matches[i];
+      if (!omml) continue;
 
       // Attempt OMML → MathML → LaTeX conversion
       // Note: This is a simplified approach; full OMML→MathML requires XSLT
@@ -391,7 +391,7 @@ async function extractEquationsFromWordDirect(docxPath) {
     }
 
     return { success: true, equations };
-  } catch (err) {
+  } catch (err: any) {
     return { success: false, equations: [], error: err.message };
   }
 }
@@ -399,19 +399,15 @@ async function extractEquationsFromWordDirect(docxPath) {
 /**
  * Check if OMML represents display math (equation on its own line)
  */
-function isDisplayMath(omml) {
+function isDisplayMath(omml: string): boolean {
   return omml.includes('<m:oMathPara') || omml.includes('m:jc');
 }
 
 /**
  * Convert OMML to LaTeX (simplified approach)
  * For complex equations, Pandoc method is more reliable
- *
- * @param {string} omml - OMML XML string
- * @param {Function} Converter - MathMLToLaTeX converter
- * @returns {Promise<string|null>}
  */
-async function ommlToLatex(omml, Converter) {
+async function ommlToLatex(omml: string, Converter: any): Promise<string | null> {
   if (!Converter) return null;
 
   // Extract key elements from OMML and build approximate MathML
@@ -433,7 +429,7 @@ async function ommlToLatex(omml, Converter) {
  * Convert OMML to MathML (simplified)
  * Maps common OMML elements to MathML equivalents
  */
-function ommlToMathML(omml) {
+function ommlToMathML(omml: string): string | null {
   // Remove namespace prefixes for easier parsing
   let xml = omml
     .replace(/<m:/g, '<')
@@ -442,7 +438,7 @@ function ommlToMathML(omml) {
     .replace(/<\/w:/g, '</w_');
 
   // Map OMML elements to MathML
-  const mappings = [
+  const mappings: Array<[RegExp, string]> = [
     [/<oMath[^>]*>/gi, '<math xmlns="http://www.w3.org/1998/Math/MathML">'],
     [/<\/oMath>/gi, '</math>'],
     [/<r>/gi, '<mi>'],
@@ -487,10 +483,10 @@ function ommlToMathML(omml) {
 
 /**
  * Get equation summary from Word document
- * @param {string} docxPath
- * @returns {Promise<{count: number, display: number, inline: number, converted: number}>}
  */
-export async function getWordEquationStats(docxPath) {
+export async function getWordEquationStats(
+  docxPath: string
+): Promise<{ count: number; display: number; inline: number; converted: number; error?: string }> {
   const result = await extractEquationsFromWord(docxPath);
 
   if (!result.success) {

package/lib/{errors.js → errors.ts}

@@ -3,16 +3,21 @@
  */
 
 import chalk from 'chalk';
-import path from 'path';
-import fs from 'fs';
+import * as path from 'path';
+import * as fs from 'fs';
+
+interface BuildContext {
+  bibPath?: string;
+  format?: string;
+}
 
 /**
  * Format an error message with optional suggestions
- * @param {string} message - Main error message
- * @param {string[]} suggestions - Actionable suggestions
- * @returns {string}
+ * @param message - Main error message
+ * @param suggestions - Actionable suggestions
+ * @returns Formatted error string
  */
-export function formatError(message, suggestions = []) {
+export function formatError(message: string, suggestions: string[] = []): string {
   const lines = [chalk.red(`Error: ${message}`)];
 
   if (suggestions.length > 0) {
@@ -27,11 +32,11 @@ export function formatError(message, suggestions = []) {
 
 /**
  * Get actionable suggestions for file not found errors
- * @param {string} filePath - The file path that wasn't found
- * @returns {string[]}
+ * @param filePath - The file path that wasn't found
+ * @returns Array of suggestions
  */
-export function getFileNotFoundSuggestions(filePath) {
-  const suggestions = [];
+export function getFileNotFoundSuggestions(filePath: string): string[] {
+  const suggestions: string[] = [];
   const ext = path.extname(filePath).toLowerCase();
   const dir = path.dirname(filePath);
   const base = path.basename(filePath);
@@ -75,11 +80,11 @@ export function getFileNotFoundSuggestions(filePath) {
 
 /**
  * Get actionable suggestions for dependency errors
- * @param {string} dependency - The missing dependency
- * @returns {string[]}
+ * @param dependency - The missing dependency
+ * @returns Array of suggestions
  */
-export function getDependencySuggestions(dependency) {
-  const suggestions = [];
+export function getDependencySuggestions(dependency: string): string[] {
+  const suggestions: string[] = [];
   const platform = process.platform;
 
   switch (dependency.toLowerCase()) {
@@ -133,12 +138,12 @@ export function getDependencySuggestions(dependency) {
 
 /**
  * Get actionable suggestions for configuration errors
- * @param {string} field - The problematic config field
- * @param {string} issue - What's wrong with it
- * @returns {string[]}
+ * @param field - The problematic config field
+ * @param issue - What's wrong with it
+ * @returns Array of suggestions
  */
-export function getConfigSuggestions(field, issue) {
-  const suggestions = [];
+export function getConfigSuggestions(field: string, issue: string): string[] {
+  const suggestions: string[] = [];
 
   switch (field) {
     case 'bibliography':
@@ -180,11 +185,11 @@ export function getConfigSuggestions(field, issue) {
 
 /**
  * Get suggestions for comment/annotation errors
- * @param {string} issue - The issue type
- * @returns {string[]}
+ * @param issue - The issue type
+ * @returns Array of suggestions
  */
-export function getAnnotationSuggestions(issue) {
-  const suggestions = [];
+export function getAnnotationSuggestions(issue: string): string[] {
+  const suggestions: string[] = [];
 
   switch (issue) {
     case 'no_comments':
@@ -218,12 +223,12 @@ export function getAnnotationSuggestions(issue) {
 
 /**
  * Get suggestions for build errors
- * @param {string} issue - The build issue
- * @param {object} context - Additional context
- * @returns {string[]}
+ * @param issue - The build issue
+ * @param context - Additional context
+ * @returns Array of suggestions
  */
-export function getBuildSuggestions(issue, context = {}) {
-  const suggestions = [];
+export function getBuildSuggestions(issue: string, context: BuildContext = {}): string[] {
+  const suggestions: string[] = [];
 
   switch (issue) {
     case 'no_sections':
@@ -265,12 +270,12 @@ export function getBuildSuggestions(issue, context = {}) {
 
 /**
  * Find similar filenames using Levenshtein distance
- * @param {string} target - Target filename
- * @param {string[]} candidates - Available filenames
- * @param {number} limit - Max results
- * @returns {string[]}
+ * @param target - Target filename
+ * @param candidates - Available filenames
+ * @param limit - Max results
+ * @returns Array of similar filenames
  */
-function findSimilarFiles(target, candidates, limit = 3) {
+function findSimilarFiles(target: string, candidates: string[], limit: number = 3): string[] {
   const scored = candidates
     .map(c => ({ name: c, distance: levenshtein(target.toLowerCase(), c.toLowerCase()) }))
     .filter(c => c.distance <= 3) // Only reasonably similar
@@ -281,54 +286,57 @@ function findSimilarFiles(target, candidates, limit = 3) {
 
 /**
  * Simple Levenshtein distance
+ * @param a - First string
+ * @param b - Second string
+ * @returns Edit distance
  */
-function levenshtein(a, b) {
+function levenshtein(a: string, b: string): number {
   if (a.length === 0) return b.length;
   if (b.length === 0) return a.length;
 
-  const matrix = [];
+  const matrix: number[][] = [];
 
   for (let i = 0; i <= b.length; i++) {
     matrix[i] = [i];
   }
 
   for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
+    matrix[0]![j] = j;
   }
 
   for (let i = 1; i <= b.length; i++) {
     for (let j = 1; j <= a.length; j++) {
       if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
+        matrix[i]![j] = matrix[i - 1]![j - 1]!;
       } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          matrix[i][j - 1] + 1,
-          matrix[i - 1][j] + 1
+        matrix[i]![j] = Math.min(
+          matrix[i - 1]![j - 1]! + 1,
+          matrix[i]![j - 1]! + 1,
+          matrix[i - 1]![j]! + 1
         );
       }
     }
   }
 
-  return matrix[b.length][a.length];
+  return matrix[b.length]![a.length]!;
 }
 
 /**
  * Print error and exit
- * @param {string} message - Error message
- * @param {string[]} suggestions - Suggestions
+ * @param message - Error message
+ * @param suggestions - Suggestions
  */
-export function exitWithError(message, suggestions = []) {
+export function exitWithError(message: string, suggestions: string[] = []): never {
   console.error(formatError(message, suggestions));
   process.exit(1);
 }
 
 /**
  * Validate file exists with helpful error
- * @param {string} filePath - File to check
- * @param {string} fileType - Type description for error message
+ * @param filePath - File to check
+ * @param fileType - Type description for error message
  */
-export function requireFile(filePath, fileType = 'File') {
+export function requireFile(filePath: string, fileType: string = 'File'): void {
   if (!fs.existsSync(filePath)) {
     exitWithError(
       `${fileType} not found: ${filePath}`,