docrev 0.8.1 → 0.8.5

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

@@ -18,14 +18,70 @@ import {
   convertHardcodedRefs,
   inlineDiffPreview,
 } from './context.js';
+import type { Command } from 'commander';
+import * as readline from 'readline';
+
+interface DetectedSection {
+  header: string;
+  content: string;
+  file: string;
+}
+
+interface ImportStats {
+  insertions: number;
+  deletions: number;
+  substitutions: number;
+  comments: number;
+  total: number;
+}
+
+interface BootstrapOptions {
+  output: string;
+  dryRun?: boolean;
+}
+
+interface ImportOptions {
+  output?: string;
+  author?: string;
+  dryRun?: boolean;
+}
+
+interface ExtractOptions {
+  output?: string;
+}
+
+interface SplitOptions {
+  config: string;
+  dir: string;
+  dryRun?: boolean;
+}
+
+interface SyncOptions {
+  config: string;
+  dir: string;
+  crossref?: boolean;
+  diff?: boolean;
+  force?: boolean;
+  dryRun?: boolean;
+}
+
+interface MergeOptions {
+  base?: string;
+  output?: string;
+  names?: string;
+  strategy: string;
+  diffLevel: 'sentence' | 'word';
+  dryRun?: boolean;
+  sections?: boolean;
+}
 
 /**
  * Detect sections from Word document text
  * Looks for common academic paper section headers
  */
-function detectSectionsFromWord(text) {
+function detectSectionsFromWord(text: string): DetectedSection[] {
   const lines = text.split('\n');
-  const sections = [];
+  const sections: DetectedSection[] = [];
 
   const headerPatterns = [
     /^(Abstract|Summary)$/i,
@@ -50,9 +106,9 @@ function detectSectionsFromWord(text) {
 
   const numberedHeaderPattern = /^(\d+\.?\s+)(Abstract|Introduction|Background|Methods?|Materials|Results?|Discussion|Conclusions?|References|Acknowledgements?|Appendix)/i;
 
-  let currentSection = null;
-  let currentContent = [];
-  let preambleContent = [];
+  let currentSection: string | null = null;
+  let currentContent: string[] = [];
+  let preambleContent: string[] = [];
 
   for (const line of lines) {
     const trimmed = line.trim();
@@ -131,7 +187,7 @@ function detectSectionsFromWord(text) {
 /**
  * Convert a section header to a filename
  */
-function headerToFilename(header) {
+function headerToFilename(header: string): string {
   return header
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
@@ -142,7 +198,7 @@ function headerToFilename(header) {
 /**
  * Bootstrap a new project from a Word document
  */
-async function bootstrapFromWord(docx, options) {
+async function bootstrapFromWord(docx: string, options: BootstrapOptions): Promise<void> {
   const outputDir = path.resolve(options.output);
 
   console.log(chalk.cyan(`Bootstrapping project from ${path.basename(docx)}...\n`));
@@ -167,7 +223,7 @@ async function bootstrapFromWord(docx, options) {
       fs.mkdirSync(outputDir, { recursive: true });
     }
 
-    const sectionFiles = [];
+    const sectionFiles: string[] = [];
     for (const section of sections) {
       const filePath = path.join(outputDir, section.file);
       const content = `# ${section.header}\n\n${section.content.trim()}\n`;
@@ -231,17 +287,17 @@ async function bootstrapFromWord(docx, options) {
       console.log(chalk.dim('  rev build          # Build PDF and DOCX'));
     }
   } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    if (process.env.DEBUG) console.error(err.stack);
+    const error = err as Error;
+    console.error(chalk.red(`Error: ${error.message}`));
+    if (process.env.DEBUG) console.error(error.stack);
     process.exit(1);
   }
 }
 
 /**
  * Register section commands with the program
- * @param {import('commander').Command} program
  */
-export function register(program) {
+export function register(program: Command): void {
   // ==========================================================================
   // IMPORT command - Import from Word (bootstrap or diff mode)
   // ==========================================================================
@@ -254,14 +310,14 @@ export function register(program) {
     .option('-o, --output <dir>', 'Output directory for bootstrap mode', '.')
     .option('-a, --author <name>', 'Author name for changes (diff mode)', 'Reviewer')
     .option('--dry-run', 'Preview without saving')
-    .action(async (docx, original, options) => {
+    .action(async (docx: string, original: string | undefined, options: ImportOptions) => {
       if (!fs.existsSync(docx)) {
         console.error(chalk.red(`Error: Word file not found: ${docx}`));
         process.exit(1);
       }
 
       if (!original) {
-        await bootstrapFromWord(docx, options);
+        await bootstrapFromWord(docx, options as BootstrapOptions);
         return;
       }
 
@@ -307,8 +363,9 @@ export function register(program) {
         console.log(`  3. ${chalk.bold('rev build docx')}  - Rebuild Word doc`);
 
       } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        if (process.env.DEBUG) console.error(err.stack);
+        const error = err as Error;
+        console.error(chalk.red(`Error: ${error.message}`));
+        if (process.env.DEBUG) console.error(error.stack);
         process.exit(1);
       }
     });
@@ -322,7 +379,7 @@ export function register(program) {
     .description('Extract plain text from Word document (no diff)')
     .argument('<docx>', 'Word document')
     .option('-o, --output <file>', 'Output file (default: stdout)')
-    .action(async (docx, options) => {
+    .action(async (docx: string, options: ExtractOptions) => {
       if (!fs.existsSync(docx)) {
         console.error(chalk.red(`Error: File not found: ${docx}`));
         process.exit(1);
@@ -339,7 +396,8 @@ export function register(program) {
           process.stdout.write(result.value);
         }
       } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
+        const error = err as Error;
+        console.error(chalk.red(`Error: ${error.message}`));
         process.exit(1);
       }
     });
@@ -355,7 +413,7 @@ export function register(program) {
     .option('-c, --config <file>', 'Sections config file', 'sections.yaml')
     .option('-d, --dir <directory>', 'Output directory for section files', '.')
     .option('--dry-run', 'Preview without writing files')
-    .action((file, options) => {
+    .action((file: string, options: SplitOptions) => {
       if (!fs.existsSync(file)) {
         console.error(chalk.red(`File not found: ${file}`));
         process.exit(1);
@@ -389,7 +447,7 @@ export function register(program) {
 
         console.log(`  ${chalk.bold(sectionFile)} (${lines} lines)`);
         if (annotations.total > 0) {
-          const parts = [];
+          const parts: string[] = [];
           if (annotations.inserts > 0) parts.push(chalk.green(`+${annotations.inserts}`));
           if (annotations.deletes > 0) parts.push(chalk.red(`-${annotations.deletes}`));
           if (annotations.substitutes > 0) parts.push(chalk.yellow(`~${annotations.substitutes}`));
@@ -426,7 +484,7 @@ export function register(program) {
     .option('--no-diff', 'Skip showing diff preview')
     .option('--force', 'Overwrite files without conflict warning')
     .option('--dry-run', 'Preview without writing files')
-    .action(async (docx, sections, options) => {
+    .action(async (docx: string | undefined, sections: string[], options: SyncOptions) => {
       // Auto-detect most recent docx or pdf if not provided
       if (!docx) {
         const docxFiles = findFiles('.docx');
@@ -439,7 +497,7 @@ export function register(program) {
         }
         const sorted = allFiles
           .map(f => ({ name: f, mtime: fs.statSync(f).mtime }))
-          .sort((a, b) => b.mtime - a.mtime);
+          .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         docx = sorted[0].name;
         console.log(fmt.status('info', `Using most recent: ${docx}`));
         console.log();
@@ -482,7 +540,7 @@ export function register(program) {
             const config = loadConfig(configPath);
             const mainSection = config.sections?.[0];
 
-            if (mainSection) {
+            if (mainSection && typeof mainSection === 'string') {
               const mainPath = path.join(options.dir, mainSection);
               if (fs.existsSync(mainPath)) {
                 console.log(chalk.dim(`Use 'rev pdf-comments ${docx} --append ${mainSection}' to add comments to markdown.`));
@@ -491,8 +549,9 @@ export function register(program) {
           }
         } catch (err) {
           spin.stop();
-          console.error(fmt.status('error', `Failed to extract PDF comments: ${err.message}`));
-          if (process.env.DEBUG) console.error(err.stack);
+          const error = err as Error;
+          console.error(fmt.status('error', `Failed to extract PDF comments: ${error.message}`));
+          if (process.env.DEBUG) console.error(error.stack);
           process.exit(1);
         }
         return;
@@ -509,8 +568,7 @@ export function register(program) {
 
       try {
         const config = loadConfig(configPath);
-        const mammoth = await import('mammoth');
-        const { importFromWord, extractWordComments, extractCommentAnchors, insertCommentsIntoMarkdown } = await import('../import.js');
+        const { importFromWord, extractWordComments, extractCommentAnchors, insertCommentsIntoMarkdown, extractFromWord } = await import('../import.js');
 
         let registry = null;
         let totalRefConversions = 0;
@@ -519,10 +577,30 @@ export function register(program) {
         }
 
         const comments = await extractWordComments(docx);
-        const anchors = await extractCommentAnchors(docx);
+        const { anchors, fullDocText: xmlDocText } = await extractCommentAnchors(docx);
+
+        // Use pandoc for extraction to preserve markdown formatting (bold, tables, etc.)
+        // Mammoth only extracts plain text which loses all formatting
+        const wordExtraction = await extractFromWord(docx, { mediaDir: options.dir });
+        let wordText = wordExtraction.text;
+        const wordTables = wordExtraction.tables || [];
+
+        // Restore crossref on FULL text BEFORE splitting into sections
+        // This ensures duplicate labels from track changes are handled correctly
+        // (the same figure may appear multiple times in old/new versions)
+        const { restoreCrossrefFromWord, restoreImagesFromRegistry } = await import('../import.js');
+        const crossrefResult = restoreCrossrefFromWord(wordText, options.dir);
+        wordText = crossrefResult.text;
+        if (crossrefResult.restored > 0) {
+          console.log(`Restored ${crossrefResult.restored} crossref reference(s)`);
+        }
 
-        const wordResult = await mammoth.extractRawText({ path: docx });
-        const wordText = wordResult.value;
+        // Also restore images from registry using shared restoredLabels
+        const imageRestoreResult = restoreImagesFromRegistry(wordText, options.dir, crossrefResult.restoredLabels);
+        wordText = imageRestoreResult.text;
+        if (imageRestoreResult.restored > 0) {
+          console.log(`Restored ${imageRestoreResult.restored} image(s) from registry`);
+        }
 
         let wordSections = extractSectionsFromText(wordText, config.sections);
 
@@ -554,7 +632,7 @@ export function register(program) {
 
         // Conflict detection
         if (!options.force && !options.dryRun) {
-          const conflicts = [];
+          const conflicts: Array<{ file: string; annotations: number }> = [];
           for (const section of wordSections) {
             const sectionPath = path.join(options.dir, section.file);
             if (fs.existsSync(sectionPath)) {
@@ -576,16 +654,15 @@ export function register(program) {
             }
             console.log();
 
-            const rl = await import('readline');
-            const readline = rl.createInterface({
+            const rl = readline.createInterface({
               input: process.stdin,
               output: process.stdout,
             });
 
-            const answer = await new Promise((resolve) =>
-              readline.question(chalk.cyan('Continue and overwrite? [y/N] '), resolve)
+            const answer = await new Promise<string>((resolve) =>
+              rl.question(chalk.cyan('Continue and overwrite? [y/N] '), resolve)
             );
-            readline.close();
+            rl.close();
 
             if (answer.toLowerCase() !== 'y') {
               console.log(chalk.dim('Aborted. Use --force to skip this check.'));
@@ -595,9 +672,92 @@ export function register(program) {
           }
         }
 
-        const sectionResults = [];
+        const sectionResults: Array<{
+          file: string;
+          header: string;
+          status: string;
+          stats?: ImportStats;
+          refs?: number;
+        }> = [];
         let totalChanges = 0;
 
+        // Calculate section boundaries in the XML document text for comment filtering
+        // Comment positions (docPosition) are relative to xmlDocText, NOT wordText
+        // So we must find section headers in xmlDocText to get matching boundaries
+        const sectionBoundaries: Array<{ file: string; start: number; end: number }> = [];
+        const xmlLower = xmlDocText.toLowerCase();
+
+        // Standard section header keywords to search for in XML
+        // Map from file name pattern to search terms
+        const sectionKeywords: Record<string, string[]> = {
+          'abstract': ['abstract', 'summary'],
+          'introduction': ['introduction', 'background'],
+          'methods': ['methods', 'materials and methods', 'methodology'],
+          'results': ['results'],
+          'discussion': ['discussion'],
+          'conclusion': ['conclusion', 'conclusions'],
+        };
+
+        // Helper: find section header (skip labels like "Methods:" in structured abstracts)
+        // Real section headers are NOT followed by ":" immediately
+        function findSectionHeader(text: string, keyword: string, startFrom: number = 0): number {
+          const lower = text.toLowerCase();
+          let idx = startFrom;
+          while ((idx = lower.indexOf(keyword, idx)) !== -1) {
+            // Check what follows the keyword
+            const afterKeyword = text.slice(idx + keyword.length, idx + keyword.length + 5);
+            // Skip if followed by ":" (this is a label, not a section header)
+            // Real headers are followed by text content, a newline, or a subheading
+            if (!afterKeyword.startsWith(':') && !afterKeyword.startsWith(' :')) {
+              return idx;
+            }
+            idx++;
+          }
+          return -1;
+        }
+
+        for (const section of wordSections) {
+          const fileBase = section.file.replace(/\.md$/i, '').toLowerCase();
+
+          // Get keywords for this section
+          const keywords = sectionKeywords[fileBase] || [fileBase];
+
+          // Find the first valid keyword that exists in XML (not a label)
+          let headerIdx = -1;
+          for (const kw of keywords) {
+            const idx = findSectionHeader(xmlDocText, kw, 0);
+            if (idx >= 0 && (headerIdx < 0 || idx < headerIdx)) {
+              headerIdx = idx;
+            }
+          }
+
+          if (headerIdx >= 0) {
+            // Find the next section's start to determine end boundary
+            let nextHeaderIdx = xmlDocText.length;
+            const sectionIdx = wordSections.indexOf(section);
+            if (sectionIdx < wordSections.length - 1) {
+              const nextFileBase = wordSections[sectionIdx + 1].file.replace(/\.md$/i, '').toLowerCase();
+              const nextKeywords = sectionKeywords[nextFileBase] || [nextFileBase];
+              for (const nkw of nextKeywords) {
+                const foundNext = findSectionHeader(xmlDocText, nkw, headerIdx + 10);
+                if (foundNext >= 0 && foundNext < nextHeaderIdx) {
+                  nextHeaderIdx = foundNext;
+                }
+              }
+            }
+
+            sectionBoundaries.push({
+              file: section.file,
+              start: headerIdx,
+              end: nextHeaderIdx
+            });
+
+          }
+        }
+
+        // Document length is the XML text length (same coordinate system as docPosition)
+        const docLength = xmlDocText.length;
+
         for (const section of wordSections) {
           const sectionPath = path.join(options.dir, section.file);
 
@@ -606,7 +766,7 @@ export function register(program) {
               file: section.file,
               header: section.header,
               status: 'skipped',
-              stats: null,
+              stats: undefined,
             });
             continue;
           }
@@ -614,11 +774,12 @@ export function register(program) {
           const result = await importFromWord(docx, sectionPath, {
             sectionContent: section.content,
             author: 'Reviewer',
+            wordTables: wordTables,
           });
 
           let { annotated, stats } = result;
 
-          let refConversions = [];
+          let refConversions: Array<{ from: string; to: string }> = [];
           if (registry && options.crossref !== false) {
             const crossrefResult = convertHardcodedRefs(annotated, registry);
             annotated = crossrefResult.converted;
@@ -628,10 +789,54 @@ export function register(program) {
 
           let commentsInserted = 0;
           if (comments.length > 0 && anchors.size > 0) {
-            annotated = insertCommentsIntoMarkdown(annotated, comments, anchors, { quiet: true });
-            commentsInserted = (annotated.match(/\{>>/g) || []).length - (result.annotated?.match(/\{>>/g) || []).length;
-            if (commentsInserted > 0) {
-              stats.comments = (stats.comments || 0) + commentsInserted;
+            // Filter comments to only those that belong to this section
+            // Use exact position matching: docPosition is in xmlDocText coordinates,
+            // and sectionBoundaries are also in xmlDocText coordinates (same source!)
+            const boundary = sectionBoundaries.find(b => b.file === section.file);
+            const isFirstSection = wordSections.indexOf(section) === 0;
+            const firstBoundaryStart = sectionBoundaries.length > 0 ? Math.min(...sectionBoundaries.map(b => b.start)) : 0;
+
+            const sectionComments = comments.filter((c: any) => {
+              const anchorData = anchors.get(c.id);
+              if (!anchorData) return false;
+
+              // Use exact position - no scaling needed since both are in xmlDocText coordinates
+              if (anchorData.docPosition !== undefined && boundary) {
+                // Include comments within section boundaries
+                if (anchorData.docPosition >= boundary.start && anchorData.docPosition < boundary.end) {
+                  return true;
+                }
+                // Also include "outside" comments (before first section) in the first section file
+                if (isFirstSection && anchorData.docPosition < firstBoundaryStart) {
+                  return true;
+                }
+              }
+
+              return false;
+            });
+
+            if (process.env.DEBUG) {
+              console.log(`[DEBUG] ${section.file}: ${sectionComments.length} comments to place (boundary: ${boundary?.start}-${boundary?.end})`);
+            }
+
+            if (sectionComments.length > 0) {
+              // Use a more robust pattern that handles < in comment text
+              const commentPattern = /\{>>.*?<<\}/gs;
+              const beforeCount = (annotated.match(commentPattern) || []).length;
+              annotated = insertCommentsIntoMarkdown(annotated, sectionComments, anchors, {
+                quiet: !process.env.DEBUG,
+                sectionBoundary: boundary  // Pass section boundary for position-based insertion
+              });
+              const afterCount = (annotated.match(commentPattern) || []).length;
+              commentsInserted = afterCount - beforeCount;
+
+              if (process.env.DEBUG) {
+                console.log(`[DEBUG] ${section.file}: inserted ${commentsInserted} of ${sectionComments.length} comments`);
+              }
+
+              if (commentsInserted > 0) {
+                stats.comments = (stats.comments || 0) + commentsInserted;
+              }
             }
           }
 
@@ -645,7 +850,7 @@ export function register(program) {
             refs: refConversions.length,
           });
 
-          if (!options.dryRun && (stats.total > 0 || refConversions.length > 0)) {
+          if (!options.dryRun) {
             fs.writeFileSync(sectionPath, annotated, 'utf-8');
           }
         }
@@ -662,7 +867,7 @@ export function register(program) {
               '',
             ];
           }
-          const s = r.stats;
+          const s = r.stats!;
           return [
             chalk.bold(r.file),
             r.header.length > 25 ? r.header.slice(0, 22) + '...' : r.header,
@@ -670,7 +875,7 @@ export function register(program) {
             s.deletions > 0 ? chalk.red(`-${s.deletions}`) : chalk.dim('-'),
             s.substitutions > 0 ? chalk.yellow(`~${s.substitutions}`) : chalk.dim('-'),
             s.comments > 0 ? chalk.blue(`#${s.comments}`) : chalk.dim('-'),
-            r.refs > 0 ? chalk.magenta(`@${r.refs}`) : chalk.dim('-'),
+            r.refs! > 0 ? chalk.magenta(`@${r.refs}`) : chalk.dim('-'),
           ];
         });
 
@@ -703,7 +908,7 @@ export function register(program) {
         if (options.dryRun) {
           console.log(fmt.box(chalk.yellow('Dry run - no files written'), { padding: 0 }));
         } else if (totalChanges > 0 || totalRefConversions > 0 || comments.length > 0) {
-          const summaryLines = [];
+          const summaryLines: string[] = [];
           summaryLines.push(`${chalk.bold(wordSections.length)} sections processed`);
           if (totalChanges > 0) summaryLines.push(`${chalk.bold(totalChanges)} annotations imported`);
           if (comments.length > 0) summaryLines.push(`${chalk.bold(comments.length)} comments placed`);
@@ -720,8 +925,9 @@ export function register(program) {
         }
       } catch (err) {
         spin.stop();
-        console.error(fmt.status('error', err.message));
-        if (process.env.DEBUG) console.error(err.stack);
+        const error = err as Error;
+        console.error(fmt.status('error', error.message));
+        if (process.env.DEBUG) console.error(error.stack);
         process.exit(1);
       }
     });
@@ -741,7 +947,7 @@ export function register(program) {
     .option('--diff-level <level>', 'Diff granularity: sentence or word (default: sentence)', 'sentence')
     .option('--dry-run', 'Show conflicts without writing')
     .option('--sections', 'Split merged output back to section files')
-    .action(async (docxFiles, options) => {
+    .action(async (docxFiles: string[], options: MergeOptions) => {
       const {
         mergeThreeWay,
         formatConflict,
@@ -766,7 +972,7 @@ export function register(program) {
       if (!basePath) {
         // Try to use .rev/base.docx
         const projectDir = process.cwd();
-        basePath = getBaseDocument(projectDir);
+        basePath = getBaseDocument(projectDir) ?? undefined;
 
         if (basePath) {
           baseSource = 'auto (.rev/base.docx)';
@@ -862,16 +1068,15 @@ export function register(program) {
               console.log(formatConflict(conflict, baseText));
               console.log();
 
-              const rl = await import('readline');
-              const readline = rl.createInterface({
+              const rl = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout,
               });
 
-              const answer = await new Promise((resolve) =>
-                readline.question(chalk.cyan(`  Choose (1-${conflict.changes.length}, s=skip): `), resolve)
+              const answer = await new Promise<string>((resolve) =>
+                rl.question(chalk.cyan(`  Choose (1-${conflict.changes.length}, s=skip): `), resolve)
               );
-              readline.close();
+              rl.close();
 
               if (answer.toLowerCase() !== 's' && !isNaN(parseInt(answer))) {
                 const choice = parseInt(answer) - 1;
@@ -923,8 +1128,9 @@ export function register(program) {
         }
       } catch (err) {
         spin.stop();
-        console.error(fmt.status('error', err.message));
-        if (process.env.DEBUG) console.error(err.stack);
+        const error = err as Error;
+        console.error(fmt.status('error', error.message));
+        if (process.env.DEBUG) console.error(error.stack);
         process.exit(1);
       }
     });
@@ -946,7 +1152,7 @@ export function register(program) {
         return;
       }
 
-      const unresolved = data.conflicts.filter(c => c.resolved === null);
+      const unresolved = data.conflicts.filter((c: any) => c.resolved === null);
 
       if (unresolved.length === 0) {
         console.log(fmt.status('success', 'All conflicts resolved!'));
@@ -963,7 +1169,7 @@ export function register(program) {
         console.log(chalk.bold(`Conflict ${conflict.id}:`));
         // Show abbreviated info
         console.log(chalk.dim(`  Original: "${conflict.original.slice(0, 50)}${conflict.original.length > 50 ? '...' : ''}"`));
-        console.log(chalk.dim(`  Options: ${conflict.changes.map(c => c.reviewer).join(', ')}`));
+        console.log(chalk.dim(`  Options: ${conflict.changes.map((c: any) => c.reviewer).join(', ')}`));
         console.log();
       }
 
@@ -980,7 +1186,7 @@ export function register(program) {
     .description('Resolve merge conflicts interactively')
     .option('--theirs', 'Accept all changes from last reviewer')
     .option('--ours', 'Accept all changes from first reviewer')
-    .action(async (options) => {
+    .action(async (options: { theirs?: boolean; ours?: boolean }) => {
       const { loadConflicts, saveConflicts, clearConflicts, resolveConflict, formatConflict } = await import('../merge.js');
       const projectDir = process.cwd();
       const data = loadConflicts(projectDir);
@@ -990,7 +1196,7 @@ export function register(program) {
         return;
       }
 
-      const unresolved = data.conflicts.filter(c => c.resolved === null);
+      const unresolved = data.conflicts.filter((c: any) => c.resolved === null);
 
       if (unresolved.length === 0) {
         console.log(fmt.status('success', 'All conflicts already resolved!'));
@@ -1036,16 +1242,15 @@ export function register(program) {
           console.log(formatConflict(conflict, baseText));
           console.log();
 
-          const rl = await import('readline');
-          const readline = rl.createInterface({
+          const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
           });
 
-          const answer = await new Promise((resolve) =>
-            readline.question(chalk.cyan(`  Choose (1-${conflict.changes.length}, s=skip, q=quit): `), resolve)
+          const answer = await new Promise<string>((resolve) =>
+            rl.question(chalk.cyan(`  Choose (1-${conflict.changes.length}, s=skip, q=quit): `), resolve)
           );
-          readline.close();
+          rl.close();
 
           if (answer.toLowerCase() === 'q') {
             console.log(chalk.dim('\n  Saving progress...'));
@@ -1065,7 +1270,7 @@ export function register(program) {
 
         saveConflicts(projectDir, data.conflicts, data.base);
 
-        const remaining = data.conflicts.filter(c => c.resolved === null).length;
+        const remaining = data.conflicts.filter((c: any) => c.resolved === null).length;
         if (remaining === 0) {
           console.log(fmt.status('success', '\nAll conflicts resolved!'));
           clearConflicts(projectDir);