docrev 0.9.5 → 0.9.6

package/lib/commands/quality.ts

@@ -0,0 +1,517 @@
+/**
+ * Quality commands: lint, grammar, check
+ *
+ * Commands for checking project quality before submission.
+ */
+
+import type { Command } from 'commander';
+import {
+  chalk,
+  fs,
+  path,
+  fmt,
+  loadBuildConfig,
+  getComments,
+} from './context.js';
+
+// Use the actual BuildConfig from build.ts which allows string|Author[]
+type BuildConfig = ReturnType<typeof loadBuildConfig>;
+
+// Options interfaces
+interface LintOptions {
+  fix?: boolean;
+}
+
+interface GrammarOptions {
+  learn?: string;
+  forget?: string;
+  list?: boolean;
+  rules?: boolean;
+  scientific?: boolean;
+  severity?: string;
+}
+
+interface CheckOptions {
+  fix?: boolean;
+  severity?: string;
+}
+
+// Grammar issue interface (from grammar.ts)
+interface GrammarIssue {
+  rule: string;
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+  line: number;
+  column: number;
+  match: string;
+  context: string;
+  file?: string;
+}
+
+// Grammar summary interface (from grammar.ts)
+interface GrammarSummary {
+  total: number;
+  errors: number;
+  warnings: number;
+  info: number;
+  byRule?: Record<string, number>;
+}
+
+// Lint issue interface
+interface LintIssue {
+  type: 'error' | 'warning';
+  message: string;
+  fix?: string | null;
+  file?: string;
+}
+
+// Build result interface - matches build.ts export
+interface BuildResult {
+  format: string;
+  success: boolean;
+  outputPath?: string;
+  error?: string;
+}
+
+// Full build result interface - matches build.ts FullBuildResult
+interface FullBuildResult {
+  results: BuildResult[];
+  paperPath: string;
+  warnings: string[];
+  forwardRefsResolved: number;
+  refsAutoInjected?: boolean;
+}
+
+/**
+ * Register quality commands with the program
+ */
+export function register(program: Command): void {
+  // ==========================================================================
+  // LINT command - Check for common issues
+  // ==========================================================================
+
+  program
+    .command('lint')
+    .description('Check for common issues in the project')
+    .option('--fix', 'Auto-fix issues where possible')
+    .action(async (_options: LintOptions) => {
+      let config: Partial<BuildConfig> = {};
+      try {
+        config = loadBuildConfig('.') || {};
+      } catch {
+        // Not in a rev project, that's ok
+      }
+      let sections = config.sections || [];
+
+      if (sections.length === 0) {
+        sections = fs.readdirSync('.').filter(f =>
+          f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+        );
+      }
+
+      const issues: LintIssue[] = [];
+      const warnings: LintIssue[] = [];
+
+      // Collect all content
+      let allText = '';
+      for (const section of sections) {
+        if (fs.existsSync(section)) {
+          allText += fs.readFileSync(section, 'utf-8') + '\n';
+        }
+      }
+
+      // Check 1: Broken cross-references
+      const figAnchors = new Set<string>();
+      const tblAnchors = new Set<string>();
+      const eqAnchors = new Set<string>();
+
+      const anchorPattern = /\{#(fig|tbl|eq):([^}]+)\}/g;
+      let match: RegExpExecArray | null;
+      while ((match = anchorPattern.exec(allText)) !== null) {
+        if (match[1] === 'fig') figAnchors.add(match[2]);
+        else if (match[1] === 'tbl') tblAnchors.add(match[2]);
+        else if (match[1] === 'eq') eqAnchors.add(match[2]);
+      }
+
+      const refPattern = /@(fig|tbl|eq):([a-zA-Z0-9_-]+)/g;
+      while ((match = refPattern.exec(allText)) !== null) {
+        const type = match[1];
+        const label = match[2];
+        const anchors = type === 'fig' ? figAnchors : type === 'tbl' ? tblAnchors : eqAnchors;
+
+        if (!anchors.has(label)) {
+          issues.push({
+            type: 'error',
+            message: `Broken reference: @${type}:${label}`,
+            fix: null
+          });
+        }
+      }
+
+      // Check 2: Orphaned figures
+      for (const label of figAnchors) {
+        if (!allText.includes(`@fig:${label}`)) {
+          warnings.push({
+            type: 'warning',
+            message: `Unreferenced figure: {#fig:${label}}`,
+          });
+        }
+      }
+
+      // Check 3: Missing citations
+      const bibPath = config.bibliography || 'references.bib';
+      if (fs.existsSync(bibPath)) {
+        const bibContent = fs.readFileSync(bibPath, 'utf-8');
+        const bibKeys = new Set<string>();
+        const bibPattern = /@\w+\s*\{\s*([^,]+)/g;
+        while ((match = bibPattern.exec(bibContent)) !== null) {
+          bibKeys.add(match[1].trim());
+        }
+
+        const citePattern = /@([a-zA-Z][a-zA-Z0-9_-]*)(?![:\w])/g;
+        while ((match = citePattern.exec(allText)) !== null) {
+          const key = match[1];
+          if (!bibKeys.has(key) && !['fig', 'tbl', 'eq'].includes(key)) {
+            issues.push({
+              type: 'error',
+              message: `Missing citation: @${key}`,
+            });
+          }
+        }
+      }
+
+      // Check 4: Unresolved comments
+      const comments = getComments(allText);
+      const pending = comments.filter(c => !c.resolved);
+      if (pending.length > 0) {
+        warnings.push({
+          type: 'warning',
+          message: `${pending.length} unresolved comment${pending.length === 1 ? '' : 's'}`,
+        });
+      }
+
+      // Check 5: Empty sections
+      for (const section of sections) {
+        if (fs.existsSync(section)) {
+          const content = fs.readFileSync(section, 'utf-8').trim();
+          if (content.length < 50) {
+            warnings.push({
+              type: 'warning',
+              message: `Section appears empty: ${section}`,
+            });
+          }
+        }
+      }
+
+      // Output results
+      console.log(fmt.header('Lint Results'));
+      console.log();
+
+      if (issues.length === 0 && warnings.length === 0) {
+        console.log(chalk.green('✓ No issues found'));
+        return;
+      }
+
+      for (const issue of issues) {
+        console.log(chalk.red(`  ✗ ${issue.message}`));
+      }
+
+      for (const warning of warnings) {
+        console.log(chalk.yellow(`  ⚠ ${warning.message}`));
+      }
+
+      console.log();
+      console.log(chalk.dim(`${issues.length} error${issues.length === 1 ? '' : 's'}, ${warnings.length} warning${warnings.length === 1 ? '' : 's'}`));
+
+      if (issues.length > 0) {
+        process.exit(1);
+      }
+    });
+
+  // ==========================================================================
+  // GRAMMAR command - Check grammar and style
+  // ==========================================================================
+
+  program
+    .command('grammar')
+    .description('Check grammar and style issues')
+    .argument('[files...]', 'Markdown files to check')
+    .option('--learn <word>', 'Add word to custom dictionary')
+    .option('--forget <word>', 'Remove word from custom dictionary')
+    .option('--list', 'List custom dictionary words')
+    .option('--rules', 'List available grammar rules')
+    .option('--no-scientific', 'Disable scientific writing rules')
+    .option('-s, --severity <level>', 'Minimum severity: error, warning, info', 'info')
+    .action(async (files: string[] | undefined, options: GrammarOptions) => {
+      const {
+        checkGrammar,
+        getGrammarSummary,
+        loadDictionary,
+        addToDictionary,
+        removeFromDictionary,
+        listRules,
+      } = await import('../grammar.js');
+
+      // Handle dictionary management
+      if (options.learn) {
+        const added = addToDictionary(options.learn);
+        if (added) {
+          console.log(fmt.status('success', `Added "${options.learn}" to dictionary`));
+        } else {
+          console.log(chalk.dim(`"${options.learn}" already in dictionary`));
+        }
+        return;
+      }
+
+      if (options.forget) {
+        const removed = removeFromDictionary(options.forget);
+        if (removed) {
+          console.log(fmt.status('success', `Removed "${options.forget}" from dictionary`));
+        } else {
+          console.log(chalk.yellow(`"${options.forget}" not in dictionary`));
+        }
+        return;
+      }
+
+      if (options.list) {
+        const words = loadDictionary();
+        console.log(fmt.header('Custom Dictionary'));
+        console.log();
+        if (words.size === 0) {
+          console.log(chalk.dim('  No custom words defined'));
+          console.log(chalk.dim('  Use --learn <word> to add words'));
+        } else {
+          const sorted = [...words].sort();
+          for (const word of sorted) {
+            console.log(`  ${word}`);
+          }
+          console.log();
+          console.log(chalk.dim(`${words.size} word(s)`));
+        }
+        return;
+      }
+
+      if (options.rules) {
+        const rules = listRules(options.scientific);
+        console.log(fmt.header('Grammar Rules'));
+        console.log();
+        for (const rule of rules) {
+          const icon = rule.severity === 'error' ? chalk.red('●') :
+                       rule.severity === 'warning' ? chalk.yellow('●') :
+                       chalk.blue('●');
+          console.log(`  ${icon} ${chalk.bold(rule.id)}`);
+          console.log(chalk.dim(`     ${rule.message}`));
+        }
+        return;
+      }
+
+      // Get files to check
+      let mdFiles = files;
+      if (!mdFiles || mdFiles.length === 0) {
+        let config: Partial<BuildConfig> = {};
+        try {
+          config = loadBuildConfig('.') || {};
+        } catch {
+          // Not in a rev project
+        }
+        mdFiles = config.sections || [];
+
+        if (mdFiles.length === 0) {
+          mdFiles = fs.readdirSync('.').filter(f =>
+            f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+          );
+        }
+      }
+
+      if (mdFiles.length === 0) {
+        console.error(chalk.red('No markdown files found'));
+        process.exit(1);
+      }
+
+      console.log(fmt.header('Grammar Check'));
+      console.log();
+
+      const severityLevels: Record<string, number> = { error: 3, warning: 2, info: 1 };
+      const minSeverity = severityLevels[options.severity || 'info'] || 1;
+
+      let allIssues: GrammarIssue[] = [];
+
+      for (const file of mdFiles) {
+        if (!fs.existsSync(file)) continue;
+
+        const text = fs.readFileSync(file, 'utf-8');
+        const issues = checkGrammar(text, { scientific: options.scientific });
+
+        // Filter by severity
+        const filtered = issues.filter((i: GrammarIssue) => severityLevels[i.severity] >= minSeverity);
+
+        if (filtered.length > 0) {
+          console.log(chalk.cyan.bold(file));
+
+          for (const issue of filtered) {
+            const icon = issue.severity === 'error' ? chalk.red('●') :
+                         issue.severity === 'warning' ? chalk.yellow('●') :
+                         chalk.blue('●');
+
+            console.log(`  ${chalk.dim(`L${issue.line}:`)} ${icon} ${issue.message}`);
+            console.log(chalk.dim(`      "${issue.match}" in: ${issue.context.slice(0, 60)}...`));
+          }
+          console.log();
+          allIssues.push(...filtered.map(i => ({ ...i, file })));
+        }
+      }
+
+      const summary = getGrammarSummary(allIssues);
+
+      if (summary.total === 0) {
+        console.log(chalk.green('✓ No issues found'));
+      } else {
+        console.log(chalk.dim(`Found ${summary.total} issue(s): ${summary.errors} errors, ${summary.warnings} warnings, ${summary.info} info`));
+        console.log();
+        console.log(chalk.dim('Tip: Use --learn <word> to add words to dictionary'));
+      }
+    });
+
+  // ==========================================================================
+  // CHECK command - Pre-submission check
+  // ==========================================================================
+
+  program
+    .command('check')
+    .description('Run all checks before submission (lint + grammar + citations)')
+    .option('--fix', 'Auto-fix issues where possible')
+    .option('-s, --severity <level>', 'Minimum grammar severity', 'warning')
+    .action(async (options: CheckOptions) => {
+      const { validateCitations } = await import('../citations.js');
+      const { checkGrammar, getGrammarSummary } = await import('../grammar.js');
+
+      console.log(fmt.header('Pre-Submission Check'));
+      console.log();
+
+      let hasErrors = false;
+      let totalIssues = 0;
+
+      // 1. Run lint
+      console.log(chalk.cyan.bold('1. Linting...'));
+      let config: Partial<BuildConfig> = {};
+      try {
+        config = loadBuildConfig('.') || {};
+      } catch {
+        // Not in a rev project
+      }
+
+      let sections = config.sections || [];
+      if (sections.length === 0) {
+        sections = fs.readdirSync('.').filter(f =>
+          f.endsWith('.md') && !['README.md', 'CLAUDE.md', 'paper.md'].includes(f)
+        );
+      }
+
+      const lintIssues: { file: string; message: string }[] = [];
+      const lintWarnings: { file: string; message: string }[] = [];
+
+      for (const file of sections) {
+        if (!fs.existsSync(file)) continue;
+        const content = fs.readFileSync(file, 'utf-8');
+
+        // Check for broken cross-references
+        const refs = content.match(/@(fig|tbl|eq|sec):\w+/g) || [];
+        const anchors = content.match(/\{#(fig|tbl|eq|sec):[^}]+\}/g) || [];
+        const anchorLabels = anchors.map(a => a.match(/#([^}]+)/)![1]);
+
+        for (const ref of refs) {
+          const label = ref.slice(1);
+          if (!anchorLabels.includes(label)) {
+            lintIssues.push({ file, message: `Broken reference: ${ref}` });
+          }
+        }
+
+        // Check for unresolved comments
+        const unresolvedComments = (content.match(/\{>>[^<]*<<\}/g) || [])
+          .filter(c => !c.includes('[RESOLVED]'));
+        if (unresolvedComments.length > 0) {
+          lintWarnings.push({ file, message: `${unresolvedComments.length} unresolved comment(s)` });
+        }
+      }
+
+      if (lintIssues.length > 0) {
+        for (const issue of lintIssues) {
+          console.log(chalk.red(`   ✗ ${issue.file}: ${issue.message}`));
+        }
+        hasErrors = true;
+        totalIssues += lintIssues.length;
+      }
+      for (const warning of lintWarnings) {
+        console.log(chalk.yellow(`   ⚠ ${warning.file}: ${warning.message}`));
+        totalIssues++;
+      }
+      if (lintIssues.length === 0 && lintWarnings.length === 0) {
+        console.log(chalk.green('   ✓ No lint issues'));
+      }
+      console.log();
+
+      // 2. Run grammar check
+      console.log(chalk.cyan.bold('2. Grammar check...'));
+
+      const severityLevels: Record<string, number> = { error: 3, warning: 2, info: 1 };
+      const minSeverity = severityLevels[options.severity || 'warning'] || 2;
+      let grammarIssues: GrammarIssue[] = [];
+
+      for (const file of sections) {
+        if (!fs.existsSync(file)) continue;
+        const text = fs.readFileSync(file, 'utf-8');
+        const issues = checkGrammar(text, { scientific: true });
+        const filtered = issues.filter((i: GrammarIssue) => severityLevels[i.severity] >= minSeverity);
+        grammarIssues.push(...filtered.map(i => ({ ...i, file })));
+      }
+
+      const grammarSummary = getGrammarSummary(grammarIssues);
+      if (grammarSummary.errors > 0) {
+        hasErrors = true;
+      }
+      totalIssues += grammarSummary.total;
+
+      if (grammarSummary.total > 0) {
+        console.log(chalk.yellow(`   ⚠ ${grammarSummary.total} grammar issue(s): ${grammarSummary.errors} errors, ${grammarSummary.warnings} warnings`));
+      } else {
+        console.log(chalk.green('   ✓ No grammar issues'));
+      }
+      console.log();
+
+      // 3. Run citation check
+      console.log(chalk.cyan.bold('3. Citation check...'));
+      const bibFile = config.bibliography || 'references.bib';
+      if (fs.existsSync(bibFile)) {
+        const existingSections = sections.filter(f => fs.existsSync(f));
+
+        const result = validateCitations(existingSections, bibFile);
+
+        if (result.missing.length > 0) {
+          console.log(chalk.red(`   ✗ ${result.missing.length} missing citation(s): ${result.missing.slice(0, 3).join(', ')}${result.missing.length > 3 ? '...' : ''}`));
+          hasErrors = true;
+          totalIssues += result.missing.length;
+        }
+        if (result.unused.length > 0) {
+          console.log(chalk.yellow(`   ⚠ ${result.unused.length} unused citation(s)`));
+          totalIssues += result.unused.length;
+        }
+        if (result.missing.length === 0 && result.unused.length === 0) {
+          console.log(chalk.green('   ✓ All citations valid'));
+        }
+      } else {
+        console.log(chalk.dim('   - No bibliography file found'));
+      }
+      console.log();
+
+      // Summary
+      console.log(chalk.bold('Summary'));
+      if (hasErrors) {
+        console.log(chalk.red(`   ${totalIssues} issue(s) found. Please fix before submission.`));
+        process.exit(1);
+      } else if (totalIssues > 0) {
+        console.log(chalk.yellow(`   ${totalIssues} warning(s). Review before submission.`));
+      } else {
+        console.log(chalk.green('   ✓ All checks passed! Ready for submission.'));
+      }
+    });
+}