docrev 0.8.1 → 0.8.5

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

@@ -5,17 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import YAML from 'yaml';
-
-/**
- * @typedef {Object} SectionConfig
- * @property {string} header - Primary header text to match
- * @property {string[]} [aliases] - Alternative header texts
- * @property {number} [order] - Sort order for building
- */
-
-/**
- * @typedef {Object<string, SectionConfig|string>} SectionsConfig
- */
+import type { SectionConfig, SectionsConfig, ExtractedSection } from './types.js';
 
 /**
  * Default section order (common academic paper structure)
@@ -40,10 +30,8 @@ const DEFAULT_ORDER = [
 
 /**
  * Extract header from a markdown file
- * @param {string} filePath
- * @returns {string|null}
  */
-export function extractHeader(filePath) {
+export function extractHeader(filePath: string): string | null {
   if (!fs.existsSync(filePath)) return null;
 
   const content = fs.readFileSync(filePath, 'utf-8');
@@ -51,7 +39,7 @@ export function extractHeader(filePath) {
 
   for (const line of lines) {
     const match = line.match(/^#\s+(.+)$/);
-    if (match) {
+    if (match && match[1]) {
       return match[1].trim();
     }
   }
@@ -61,18 +49,18 @@ export function extractHeader(filePath) {
 
 /**
  * Generate sections.yaml from existing .md files
- * @param {string} directory
- * @param {string[]} [excludePatterns]
- * @returns {object}
  */
-export function generateConfig(directory, excludePatterns = ['paper.md', 'README.md', 'CLAUDE.md']) {
+export function generateConfig(
+  directory: string,
+  excludePatterns: string[] = ['paper.md', 'README.md', 'CLAUDE.md']
+): SectionsConfig {
   const files = fs.readdirSync(directory).filter((f) => {
     if (!f.endsWith('.md')) return false;
     if (excludePatterns.some((p) => f.toLowerCase().includes(p.toLowerCase()))) return false;
     return true;
   });
 
-  const sections = {};
+  const sections: Record<string, SectionConfig> = {};
 
   for (const file of files) {
     const filePath = path.join(directory, file);
@@ -92,11 +80,11 @@ export function generateConfig(directory, excludePatterns = ['paper.md', 'README
 
   // Sort by order
   const sorted = Object.entries(sections)
-    .sort((a, b) => a[1].order - b[1].order)
+    .sort((a, b) => (a[1].order ?? 999) - (b[1].order ?? 999))
     .reduce((acc, [k, v]) => {
       acc[k] = v;
       return acc;
-    }, {});
+    }, {} as Record<string, SectionConfig>);
 
   return {
     version: 1,
@@ -107,10 +95,8 @@ export function generateConfig(directory, excludePatterns = ['paper.md', 'README
 
 /**
  * Convert string to title case
- * @param {string} str
- * @returns {string}
  */
-function titleCase(str) {
+function titleCase(str: string): string {
   return str
     .split(/[-_\s]+/)
     .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
@@ -119,16 +105,17 @@ function titleCase(str) {
 
 /**
  * Load sections config from yaml file
- * @param {string} configPath
- * @returns {object}
  */
-export function loadConfig(configPath) {
+export function loadConfig(configPath: string): SectionsConfig {
   const content = fs.readFileSync(configPath, 'utf-8');
   const config = YAML.parse(content);
 
   // Normalize: convert string values to full config objects
-  const normalized = { ...config };
-  normalized.sections = {};
+  const normalized: SectionsConfig = {
+    version: config.version || 1,
+    description: config.description,
+    sections: {},
+  };
 
   for (const [file, value] of Object.entries(config.sections || {})) {
     if (typeof value === 'string') {
@@ -137,10 +124,11 @@ export function loadConfig(configPath) {
         aliases: [],
       };
     } else {
+      const typedValue = value as SectionConfig;
       normalized.sections[file] = {
-        header: value.header,
-        aliases: value.aliases || [],
-        order: value.order,
+        header: typedValue.header,
+        aliases: typedValue.aliases || [],
+        order: typedValue.order,
       };
     }
   }
@@ -150,22 +138,21 @@ export function loadConfig(configPath) {
 
 /**
  * Save sections config to yaml file
- * @param {string} configPath
- * @param {object} config
  */
-export function saveConfig(configPath, config) {
+export function saveConfig(configPath: string, config: SectionsConfig): void {
   const yamlStr = YAML.stringify(config, { indent: 2, lineWidth: 100 });
   fs.writeFileSync(configPath, yamlStr, 'utf-8');
 }
 
 /**
  * Match a heading to a section file
- * @param {string} heading - Heading text from Word
- * @param {object} sections - Sections config
- * @returns {{file: string, config: SectionConfig}|null}
  */
-export function matchHeading(heading, sections) {
-  const normalizedHeading = heading.toLowerCase().trim();
+export function matchHeading(
+  heading: string,
+  sections: Record<string, SectionConfig>
+): { file: string; config: SectionConfig } | null {
+  // Strip markdown header prefix (# or ##, etc.) before matching
+  const normalizedHeading = heading.replace(/^#{1,6}\s+/, '').toLowerCase().trim();
 
   for (const [file, config] of Object.entries(sections)) {
     // Check primary header
@@ -196,37 +183,44 @@ export function matchHeading(heading, sections) {
 
 /**
  * Extract sections from Word document text
- * @param {string} text - Extracted text from Word
- * @param {object} sections - Sections config
- * @returns {Array<{file: string, header: string, content: string, matched: boolean}>}
  */
-export function extractSectionsFromText(text, sections) {
-  const result = [];
-
-  // Find all headings (lines that look like headers - typically short, at start of "paragraph")
-  const paragraphs = text.split(/\n\n+/);
-  let currentSection = null;
-  let currentContent = [];
-
-  for (const para of paragraphs) {
-    const trimmed = para.trim();
-
-    // Detect if this paragraph is a heading
-    // Heuristics: short (< 100 chars), no periods, matches a known section
-    const isLikelyHeading = trimmed.length < 100 && !trimmed.includes('.') && trimmed.length > 0;
-
-    let matchedSection = null;
-    if (isLikelyHeading) {
+export function extractSectionsFromText(
+  text: string,
+  sections: Record<string, SectionConfig>
+): ExtractedSection[] {
+  const result: ExtractedSection[] = [];
+
+  // Process line by line to detect markdown headers
+  const lines = text.split('\n');
+  let currentSection: { file: string; header: string } | null = null;
+  let currentContent: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const trimmed = line.trim();
+
+    // Explicitly check for markdown headers (# Header)
+    const headerMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+
+    let matchedSection: { file: string; config: SectionConfig } | null = null;
+    if (headerMatch) {
+      // This is a markdown header - try to match it to a section
+      matchedSection = matchHeading(trimmed, sections);
+    } else if (trimmed.length > 0 && trimmed.length < 100 && !trimmed.includes('.')) {
+      // Fallback: check if short text without periods matches a section (for plain text headings)
       matchedSection = matchHeading(trimmed, sections);
     }
 
     if (matchedSection) {
       // Save previous section
       if (currentSection) {
+        // Include header in content for proper diffing
+        const fullContent = currentSection.header + '\n\n' + currentContent.join('\n').trim();
         result.push({
           file: currentSection.file,
           header: currentSection.header,
-          content: currentContent.join('\n\n'),
+          content: fullContent.trim(),
           matched: true,
         });
       }
@@ -237,16 +231,18 @@ export function extractSectionsFromText(text, sections) {
       };
       currentContent = [];
     } else {
-      currentContent.push(para);
+      currentContent.push(line);
     }
   }
 
   // Save last section
   if (currentSection) {
+    // Include header in content for proper diffing
+    const fullContent = currentSection.header + '\n\n' + currentContent.join('\n').trim();
     result.push({
       file: currentSection.file,
       header: currentSection.header,
-      content: currentContent.join('\n\n'),
+      content: fullContent.trim(),
       matched: true,
     });
   }
@@ -256,12 +252,12 @@ export function extractSectionsFromText(text, sections) {
 
 /**
  * Parse annotated paper.md and split back to section files
- * @param {string} paperContent - Content of annotated paper.md
- * @param {object} sections - Sections config
- * @returns {Map<string, string>} - Map of filename → content
  */
-export function splitAnnotatedPaper(paperContent, sections) {
-  const result = new Map();
+export function splitAnnotatedPaper(
+  paperContent: string,
+  sections: Record<string, SectionConfig>
+): Map<string, string> {
+  const result = new Map<string, string>();
 
   // Look for section markers: <!-- @section:filename.md -->
   const markerPattern = /<!--\s*@section:(\S+\.md)\s*-->/g;
@@ -271,8 +267,9 @@ export function splitAnnotatedPaper(paperContent, sections) {
     // Use markers
     for (let i = 0; i < markers.length; i++) {
       const marker = markers[i];
+      if (!marker || !marker[1]) continue;
       const file = marker[1];
-      const start = marker.index + marker[0].length;
+      const start = (marker.index || 0) + marker[0].length;
       const end = markers[i + 1]?.index || paperContent.length;
 
       let content = paperContent.slice(start, end).trim();
@@ -285,13 +282,13 @@ export function splitAnnotatedPaper(paperContent, sections) {
   } else {
     // Fall back to header detection
     const lines = paperContent.split('\n');
-    let currentFile = null;
-    let currentContent = [];
+    let currentFile: string | null = null;
+    let currentContent: string[] = [];
 
     for (const line of lines) {
       const headerMatch = line.match(/^#\s+(.+)$/);
 
-      if (headerMatch) {
+      if (headerMatch && headerMatch[1]) {
         // Save previous section
         if (currentFile) {
           result.set(currentFile, currentContent.join('\n').trim());
@@ -324,10 +321,8 @@ export function splitAnnotatedPaper(paperContent, sections) {
 
 /**
  * Get ordered list of section files from config
- * @param {object} config
- * @returns {string[]}
  */
-export function getOrderedSections(config) {
+export function getOrderedSections(config: SectionsConfig): string[] {
   const entries = Object.entries(config.sections || {});
 
   return entries