docrev 0.8.1 → 0.8.5

package/lib/{comment-realign.js → comment-realign.ts}

@@ -7,10 +7,78 @@ import * as fs from 'fs';
 import AdmZip from 'adm-zip';
 import { parseStringPromise } from 'xml2js';
 
+interface CommentData {
+  author: string;
+  text: string;
+}
+
+interface CommentWithPosition {
+  id: string;
+  position: number;
+  author: string;
+  text: string;
+}
+
+interface Paragraph {
+  text: string;
+  comments: CommentWithPosition[];
+}
+
+interface MdParagraph {
+  text: string;
+  start: number;
+  end: number;
+}
+
+interface ParagraphMatch {
+  index: number;
+  score: number;
+  paragraph: MdParagraph;
+}
+
+interface WordContext {
+  before: string[];
+  after: string[];
+}
+
+interface CommentInsertion {
+  position: number;
+  text: string;
+  commentText: string;
+  hasReplies: boolean;
+  debug: string;
+}
+
+interface RealignOptions {
+  dryRun?: boolean;
+  author?: string;
+  replyAuthor?: string;
+}
+
+interface RealignResult {
+  success: boolean;
+  dryRun?: boolean;
+  insertions: number;
+  matched?: number;
+  unmatched?: number;
+}
+
+interface RealignMarkdownOptions {
+  author?: string;
+  replyAuthor?: string;
+}
+
+interface RealignMarkdownResult {
+  success: boolean;
+  markdown: string;
+  insertions: number;
+  error?: string;
+}
+
 /**
  * Extract paragraphs with their full text and comment positions from DOCX
  */
-export async function extractParagraphsWithComments(docxPath) {
+export async function extractParagraphsWithComments(docxPath: string): Promise<Paragraph[]> {
   const zip = new AdmZip(docxPath);
   const doc = zip.readAsText('word/document.xml');
   const commentsXml = zip.readAsText('word/comments.xml');
@@ -21,13 +89,13 @@ export async function extractParagraphsWithComments(docxPath) {
   if (!commentNodes) return [];
 
   const nodes = Array.isArray(commentNodes) ? commentNodes : [commentNodes];
-  const commentData = {};
+  const commentData: Record<string, CommentData> = {};
 
   for (const c of nodes) {
-    const id = c.$['w:id'];
-    const author = c.$['w:author'] || 'Unknown';
+    const id = c.$?.['w:id'] ?? '';
+    const author = c.$?.['w:author'] ?? 'Unknown';
     let text = '';
-    const extractT = (n) => {
+    const extractT = (n: any): void => {
       if (!n) return;
       if (n['w:t']) {
         const t = n['w:t'];
@@ -45,7 +113,7 @@ export async function extractParagraphsWithComments(docxPath) {
   }
 
   // Extract paragraphs with comments
-  const paragraphs = [];
+  const paragraphs: Paragraph[] = [];
   const paraPattern = /<w:p\b[^>]*>([\s\S]*?)<\/w:p>/g;
   let match;
 
@@ -55,7 +123,7 @@ export async function extractParagraphsWithComments(docxPath) {
 
     // Build paragraph text and track comment positions
     let text = '';
-    const comments = [];
+    const comments: CommentWithPosition[] = [];
 
     const tokenPattern = /<w:t[^>]*>([^<]*)<\/w:t>|<w:commentRangeStart[^>]*w:id="(\d+)"[^>]*\/?>/g;
     let tokenMatch;
@@ -88,14 +156,14 @@ export async function extractParagraphsWithComments(docxPath) {
 /**
  * Find best matching paragraph in markdown for a reference paragraph
  */
-function findMatchingParagraph(refText, mdParagraphs) {
+function findMatchingParagraph(refText: string, mdParagraphs: MdParagraph[]): ParagraphMatch | null {
   // Normalize for comparison
-  const normalize = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+  const normalize = (s: string): string => s.toLowerCase().replace(/\s+/g, ' ').trim();
   const refNorm = normalize(refText);
 
   if (refNorm.length < 20) return null;
 
-  let bestMatch = null;
+  let bestMatch: ParagraphMatch | null = null;
   let bestScore = 0;
 
   for (let i = 0; i < mdParagraphs.length; i++) {
@@ -122,20 +190,23 @@ function findMatchingParagraph(refText, mdParagraphs) {
 /**
  * Extract paragraphs from markdown (split by blank lines)
  */
-function parseMdParagraphs(markdown) {
-  const paragraphs = [];
+function parseMdParagraphs(markdown: string): MdParagraph[] {
+  const paragraphs: MdParagraph[] = [];
   const parts = markdown.split(/\n\n+/);
 
   let pos = 0;
   for (const part of parts) {
     const trimmed = part.trim();
     if (trimmed) {
-      paragraphs.push({
-        text: trimmed,
-        start: markdown.indexOf(part, pos),
-        end: markdown.indexOf(part, pos) + part.length,
-      });
-      pos = markdown.indexOf(part, pos) + part.length;
+      const partStart = markdown.indexOf(part, pos);
+      if (partStart !== -1) {
+        paragraphs.push({
+          text: trimmed,
+          start: partStart,
+          end: partStart + part.length,
+        });
+        pos = partStart + part.length;
+      }
     }
   }
 
@@ -145,7 +216,7 @@ function parseMdParagraphs(markdown) {
 /**
  * Strip existing comments from a specific author
  */
-function stripAuthorComments(text, author) {
+function stripAuthorComments(text: string, author: string): string {
   const pattern = new RegExp(`\\s*\\{>>${author}:[^<]*<<\\}`, 'g');
   return text.replace(pattern, '');
 }
@@ -153,7 +224,7 @@ function stripAuthorComments(text, author) {
 /**
  * Normalize text for matching (remove citations, extra whitespace)
  */
-function normalizeForMatching(text) {
+function normalizeForMatching(text: string): string {
   return text
     // Remove Word citation placeholders
     .replace(/\(\s*\$+\s*\)/g, '')
@@ -174,7 +245,7 @@ function normalizeForMatching(text) {
 /**
  * Find the word at or near a position in text
  */
-function getWordAtPosition(text, pos) {
+function getWordAtPosition(text: string, pos: number): WordContext {
   const before = text.slice(Math.max(0, pos - 30), pos);
   const after = text.slice(pos, pos + 30);
 
@@ -192,7 +263,7 @@ function getWordAtPosition(text, pos) {
  * Find position in markdown paragraph matching reference position
  * Uses the anchor word (word immediately before the comment) for precise matching
  */
-function findMdPosition(refText, refPos, mdText) {
+function findMdPosition(refText: string, refPos: number, mdText: string): number {
   // Get the word(s) immediately before the comment position in reference
   const refWords = getWordAtPosition(refText, refPos);
   const normalizedMd = normalizeForMatching(mdText);
@@ -218,7 +289,7 @@ function findMdPosition(refText, refPos, mdText) {
 
     if (matches.length === 1) {
       // Unique match - use this position
-      const matchEnd = matches[0].index + matches[0][0].length;
+      const matchEnd = matches[0].index! + matches[0][0].length;
       // Map back to original markdown position
       const ratio = matchEnd / Math.max(normalizedMd.length, 1);
       return Math.round(ratio * mdText.length);
@@ -228,7 +299,7 @@ function findMdPosition(refText, refPos, mdText) {
       if (afterWords.length > 0) {
         const afterPattern = afterWords[0].toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         for (const match of matches) {
-          const matchEnd = match.index + match[0].length;
+          const matchEnd = match.index! + match[0].length;
           const afterContext = normalizedMd.slice(matchEnd, matchEnd + 50);
           if (afterContext.includes(afterPattern)) {
             const ratio = matchEnd / Math.max(normalizedMd.length, 1);
@@ -237,7 +308,7 @@ function findMdPosition(refText, refPos, mdText) {
         }
       }
       // Fall back to first match
-      const matchEnd = matches[0].index + matches[0][0].length;
+      const matchEnd = matches[0].index! + matches[0][0].length;
       const ratio = matchEnd / Math.max(normalizedMd.length, 1);
       return Math.round(ratio * mdText.length);
     }
@@ -252,8 +323,8 @@ function findMdPosition(refText, refPos, mdText) {
  * Extract reply comments that follow a parent comment
  * Returns map of parent comment text -> array of reply texts
  */
-function extractReplies(markdown, parentAuthor, replyAuthor) {
-  const replies = new Map();
+function extractReplies(markdown: string, parentAuthor: string, replyAuthor: string): Map<string, string[]> {
+  const replies = new Map<string, string[]>();
   const pattern = new RegExp(
     `\\{>>${parentAuthor}:\\s*([^<]+)<<\\}((?:\\s*\\{>>${replyAuthor}:[^<]+<<\\})*)`,
     'g'
@@ -266,7 +337,7 @@ function extractReplies(markdown, parentAuthor, replyAuthor) {
 
     if (replyBlock) {
       const replyPattern = new RegExp(`\\{>>${replyAuthor}:\\s*([^<]+)<<\\}`, 'g');
-      const replyTexts = [];
+      const replyTexts: string[] = [];
       let replyMatch;
       while ((replyMatch = replyPattern.exec(replyBlock)) !== null) {
         replyTexts.push(replyMatch[1].trim());
@@ -282,11 +353,12 @@ function extractReplies(markdown, parentAuthor, replyAuthor) {
 
 /**
  * Realign comments from reference DOCX to markdown
- * @param {string} docxPath - Reference DOCX with correctly positioned comments
- * @param {string} markdownPath - Markdown to realign
- * @param {object} options - {dryRun: boolean, author: string, replyAuthor: string}
  */
-export async function realignComments(docxPath, markdownPath, options = {}) {
+export async function realignComments(
+  docxPath: string,
+  markdownPath: string,
+  options: RealignOptions = {}
+): Promise<RealignResult> {
   const { dryRun = false, author = 'Guy Colling', replyAuthor = 'Gilles Colling' } = options;
 
   // Read original markdown to extract replies before stripping
@@ -313,7 +385,7 @@ export async function realignComments(docxPath, markdownPath, options = {}) {
   const mdParagraphs = parseMdParagraphs(markdown);
 
   // Track insertions (position, text) - will insert from end to start
-  const insertions = [];
+  const insertions: CommentInsertion[] = [];
   let matched = 0;
   let unmatched = 0;
 
@@ -334,8 +406,8 @@ export async function realignComments(docxPath, markdownPath, options = {}) {
 
     for (const comment of authorComments) {
       // Find corresponding position in markdown paragraph
-      const mdPos = findMdPosition(refPara.text, comment.position, mdPara.text);
-      const absolutePos = mdPara.start + mdPos;
+      const mdPos = findMdPosition(refPara.text, comment.position, mdPara?.text ?? '');
+      const absolutePos = (mdPara?.start ?? 0) + mdPos;
 
       // Build comment mark with any replies
       let commentMark = ` {>>${comment.author}: ${comment.text}<<}`;
@@ -354,7 +426,7 @@ export async function realignComments(docxPath, markdownPath, options = {}) {
         text: commentMark,
         commentText: comment.text.slice(0, 30),
         hasReplies: !!replyTexts,
-        debug: `"${mdPara.text.slice(Math.max(0, mdPos - 20), mdPos)}|HERE|${mdPara.text.slice(mdPos, mdPos + 20)}"`,
+        debug: `"${(mdPara?.text ?? '').slice(Math.max(0, mdPos - 20), mdPos)}|HERE|${(mdPara?.text ?? '').slice(mdPos, mdPos + 20)}"`,
       });
     }
   }
@@ -386,12 +458,12 @@ export async function realignComments(docxPath, markdownPath, options = {}) {
 
 /**
  * Realign comments in markdown string (in-memory, doesn't write to file)
- * @param {string} docxPath - Reference DOCX with correctly positioned comments
- * @param {string} markdown - Markdown content to realign
- * @param {object} options - {author: string, replyAuthor: string}
- * @returns {Promise<{success: boolean, markdown: string, insertions: number}>}
  */
-export async function realignMarkdown(docxPath, markdown, options = {}) {
+export async function realignMarkdown(
+  docxPath: string,
+  markdown: string,
+  options: RealignMarkdownOptions = {}
+): Promise<RealignMarkdownResult> {
   const { author = 'Guy Colling', replyAuthor = 'Gilles Colling' } = options;
 
   try {
@@ -411,7 +483,7 @@ export async function realignMarkdown(docxPath, markdown, options = {}) {
     const mdParagraphs = parseMdParagraphs(result);
 
     // Track insertions
-    const insertions = [];
+    const insertions: Array<{ position: number; text: string }> = [];
 
     for (const refPara of refWithComments) {
       const match = findMatchingParagraph(refPara.text, mdParagraphs);
@@ -421,8 +493,8 @@ export async function realignMarkdown(docxPath, markdown, options = {}) {
       const authorComments = refPara.comments.filter((c) => c.author === author);
 
       for (const comment of authorComments) {
-        const mdPos = findMdPosition(refPara.text, comment.position, mdPara.text);
-        const absolutePos = mdPara.start + mdPos;
+        const mdPos = findMdPosition(refPara.text, comment.position, mdPara?.text ?? '');
+        const absolutePos = (mdPara?.start ?? 0) + mdPos;
 
         let commentMark = ` {>>${comment.author}: ${comment.text}<<}`;
 
@@ -447,7 +519,7 @@ export async function realignMarkdown(docxPath, markdown, options = {}) {
     }
 
     return { success: true, markdown: result, insertions: insertions.length };
-  } catch (err) {
+  } catch (err: any) {
     return { success: false, markdown, insertions: 0, error: err.message };
   }
 }

package/lib/config.ts

@@ -0,0 +1,84 @@
+/**
+ * User configuration management
+ * Stores user preferences in ~/.revrc
+ */
+
+import type { UserConfig } from './types.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const CONFIG_PATH = path.join(os.homedir(), '.revrc');
+
+/**
+ * Load user config
+ * @returns User configuration object
+ */
+export function loadUserConfig(): UserConfig {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+      return JSON.parse(content) as UserConfig;
+    }
+  } catch (e) {
+    if (process.env.DEBUG) {
+      const error = e as Error;
+      console.warn('config: Failed to parse ~/.revrc:', error.message);
+    }
+  }
+  return {};
+}
+
+/**
+ * Save user config
+ * @param config - User configuration to save
+ */
+export function saveUserConfig(config: UserConfig): void {
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+/**
+ * Get user name
+ * @returns User name or null if not set
+ */
+export function getUserName(): string | null {
+  const config = loadUserConfig();
+  return config.userName || null;
+}
+
+/**
+ * Set user name
+ * @param name - User name to set
+ */
+export function setUserName(name: string): void {
+  const config = loadUserConfig();
+  config.userName = name;
+  saveUserConfig(config);
+}
+
+/**
+ * Get config file path
+ * @returns Absolute path to config file
+ */
+export function getConfigPath(): string {
+  return CONFIG_PATH;
+}
+
+/**
+ * Get default sections for new projects
+ * @returns Array of section names or null if not set
+ */
+export function getDefaultSections(): string[] | null {
+  const config = loadUserConfig();
+  return config.defaultSections || null;
+}
+
+/**
+ * Set default sections for new projects
+ * @param sections - Array of section names (without .md extension)
+ */
+export function setDefaultSections(sections: string[]): void {
+  const config = loadUserConfig();
+  config.defaultSections = sections;
+  saveUserConfig(config);
+}