imdone-core 2.1.5 → 2.1.10

package/lib/adapters/parsers/content-transformer.js

@@ -1,11 +1,161 @@
 import { Eta } from "eta"
 import uniqid from 'uniqid';
+import { logger } from '../logger.js';
 
 function removeDisplayComments(description) {
-  return description.replace(/<!--\s*\[([\s\S]*?)\]\s*-->/g, '$1');
+  const startTime = Date.now();
+  logger.debug(`[INSTRUMENT] removeDisplayComments START - contentLength: ${description?.length || 0}`);
+
+  // State machine implementation to avoid catastrophic backtracking
+  // Looking for pattern: <!-- [ content ] -->
+  let result = '';
+  const len = description.length;
+  let i = 0;
+  let iterations = 0;
+
+  while (i < len) {
+    iterations++;
+    if (iterations % 10000 === 0) {
+      logger.debug(`[INSTRUMENT] removeDisplayComments - iteration ${iterations}, position ${i}/${len}`);
+    }
+    // Check for HTML comment start: <!--
+    if (i <= len - 4 &&
+        description[i] === '<' &&
+        description[i + 1] === '!' &&
+        description[i + 2] === '-' &&
+        description[i + 3] === '-') {
+
+      const commentStart = i;
+      i += 4; // Skip <!--
+
+      // Skip whitespace
+      while (i < len && /\s/.test(description[i])) {
+        i++;
+      }
+
+      // Check for opening bracket
+      if (i < len && description[i] === '[') {
+        i++; // Skip [
+        const contentStart = i;
+
+        // Find closing bracket followed by optional whitespace and -->
+        while (i < len) {
+          if (description[i] === ']') {
+            const contentEnd = i;
+            i++; // Skip ]
+
+            // Skip whitespace
+            while (i < len && /\s/.test(description[i])) {
+              i++;
+            }
+
+            // Check for comment end: -->
+            if (i <= len - 3 &&
+                description[i] === '-' &&
+                description[i + 1] === '-' &&
+                description[i + 2] === '>') {
+              // Found complete pattern - extract content
+              result += description.substring(contentStart, contentEnd);
+              i += 3; // Skip -->
+              break;
+            }
+          }
+          i++;
+        }
+
+        // If we didn't find the complete pattern, include what we had
+        if (i >= len) {
+          result += description.substring(commentStart, i);
+        }
+        continue;
+      }
+
+      // No opening bracket after <!--, include the comment start and continue
+      result += description.substring(commentStart, i);
+      continue;
+    }
+
+    result += description[i];
+    i++;
+  }
+
+  const elapsed = Date.now() - startTime;
+  logger.debug(`[INSTRUMENT] removeDisplayComments END - elapsed: ${elapsed}ms, iterations: ${iterations}`);
+  return result;
 }
 
-function escapeCodeBlocks(content) {
+function escapeCodeBlocks(content, useRegex = false) {
+  if (useRegex) {
+    // Old regex-based implementation (can cause catastrophic backtracking)
+    // Kept for testing/comparison purposes only
+    return _escapeCodeBlocksRegex(content);
+  }
+
+  // New state machine implementation (safe from catastrophic backtracking)
+  let codeBlocks = [];
+  let result = '';
+  const len = content.length;
+  let i = 0;
+
+  while (i < len) {
+    // Check for code block (```)
+    if (content[i] === '`' && content[i + 1] === '`' && content[i + 2] === '`') {
+      const start = i;
+      i += 3; // Skip opening ```
+
+      // Find closing ```
+      while (i < len - 2) {
+        if (content[i] === '`' && content[i + 1] === '`' && content[i + 2] === '`') {
+          i += 3; // Include closing ```
+          const match = content.substring(start, i);
+          const key = `__CODE_BLOCK_${codeBlocks.length}__`;
+          codeBlocks.push(match);
+          result += key;
+          break;
+        }
+        i++;
+      }
+      // If we didn't find a closing ```, include what we have
+      if (i >= len - 2 && content[i - 3] !== '`') {
+        result += content.substring(start, i);
+      }
+      continue;
+    }
+
+    // Check for inline code (`)
+    if (content[i] === '`') {
+      const start = i;
+      i++; // Skip opening `
+
+      // Find closing `
+      while (i < len) {
+        if (content[i] === '`') {
+          i++; // Include closing `
+          const match = content.substring(start, i);
+          const key = `__CODE_BLOCK_${codeBlocks.length}__`;
+          codeBlocks.push(match);
+          result += key;
+          break;
+        }
+        i++;
+      }
+      // If we didn't find a closing `, include what we have
+      if (i >= len && content[i - 1] !== '`') {
+        result += content.substring(start, i);
+      }
+      continue;
+    }
+
+    result += content[i];
+    i++;
+  }
+
+  return { content: result, codeBlocks };
+}
+
+function _escapeCodeBlocksRegex(content) {
+  // OLD IMPLEMENTATION - DO NOT USE IN PRODUCTION
+  // This regex can cause catastrophic backtracking with nested backticks
   const codeBlockRegex = /(```[\s\S]*?```|`[^`]*`)/g;
   let codeBlocks = [];
 
@@ -28,41 +178,105 @@ function restoreCodeBlocks(content, codeBlocks) {
 }
 
 /**
- * Interpolates the content with the provided data.
+ * Interpolates the content with the provided data using state machine parsing.
  * @param {string} content - The content to interpolate.
  * @param {object} data - The data to use for interpolation.
  * @param {object} opts - The options for interpolation.
  * @returns {object} - The interpolated content, whether there was interpolation, and error tokens.
  */
 export function interpolate(content, data, opts = { tags: ['${', '}'] }) {
+  const startTime = Date.now();
+  logger.debug(`[INSTRUMENT] interpolate START - contentLength: ${content?.length || 0}, tags: ${JSON.stringify(opts.tags)}`);
+
   const errorTokens = {};
   const { tags } = opts;
-  // /(?<![`\\])\${([\s\S]+?)}/g
-  const regex = new RegExp(`(?<![\`\\\\])\\${tags[0]}([\\s\\S]+?)${tags[1]}`, 'g');
+  const [startTag, endTag] = tags;
   let hasInterpolation = false;
 
-  content = content.replace(regex, (match, p1) => {
-    try {
-      const eta = new Eta({ tags, useWith: true, autoEscape: false });
-      const [startTag, endTag] = opts.tags;
-      const template = `${startTag}= ${p1} ${endTag}`;
-      const result = eta.renderString(template, data);
-      if (result !== match) {
-        hasInterpolation = true;
+  // State machine implementation to avoid catastrophic backtracking
+  let result = '';
+  const len = content.length;
+  let i = 0;
+  let iterations = 0;
+
+  while (i < len) {
+    iterations++;
+    if (iterations % 10000 === 0) {
+      logger.debug(`[INSTRUMENT] interpolate - iteration ${iterations}, position ${i}/${len}, elapsed: ${Date.now() - startTime}ms`);
+    }
+
+    // Check if we're at a potential start tag
+    // Skip if preceded by backtick or backslash
+    const prevChar = i > 0 ? content[i - 1] : '';
+    const isEscaped = prevChar === '`' || prevChar === '\\';
+
+    // Check for start tag match
+    let startTagMatches = !isEscaped && true;
+    for (let j = 0; j < startTag.length && startTagMatches; j++) {
+      if (i + j >= len || content[i + j] !== startTag[j]) {
+        startTagMatches = false;
       }
-      return result || '';
-    } catch (e) {
-      const token = `__ERROR_TOKEN_${uniqid()}__`;
-      errorTokens[token] = match;
-      return token || '';
     }
-  });
 
-  return { content, hasInterpolation, errorTokens };
+    if (startTagMatches) {
+      // Found start tag - look for matching end tag
+      const matchStart = i;
+      i += startTag.length;
+      const contentStart = i;
+
+      // Find the end tag
+      let foundEnd = false;
+      while (i < len) {
+        let endTagMatches = true;
+        for (let j = 0; j < endTag.length && endTagMatches; j++) {
+          if (i + j >= len || content[i + j] !== endTag[j]) {
+            endTagMatches = false;
+          }
+        }
+
+        if (endTagMatches) {
+          // Found end tag
+          const templateContent = content.substring(contentStart, i);
+          i += endTag.length;
+          foundEnd = true;
+
+          // Try to interpolate
+          try {
+            const eta = new Eta({ tags, useWith: true, autoEscape: false });
+            const template = `${startTag}= ${templateContent} ${endTag}`;
+            const interpolated = eta.renderString(template, data);
+            result += interpolated || '';
+            hasInterpolation = true;
+          } catch (e) {
+            // On error, preserve the original match with an error token
+            const token = `__ERROR_TOKEN_${uniqid()}__`;
+            const originalMatch = content.substring(matchStart, i);
+            errorTokens[token] = originalMatch;
+            result += token;
+          }
+          break;
+        }
+        i++;
+      }
+
+      // If no end tag found, include the start tag and continue
+      if (!foundEnd) {
+        result += content.substring(matchStart, i);
+      }
+      continue;
+    }
+
+    result += content[i];
+    i++;
+  }
+
+  const elapsed = Date.now() - startTime;
+  logger.debug(`[INSTRUMENT] interpolate END - elapsed: ${elapsed}ms, iterations: ${iterations}, hasInterpolation: ${hasInterpolation}`);
+  return { content: result, hasInterpolation, errorTokens };
 }
 
 export function encodeMarkdownLinks(content) {
-  return content.replace(/(?<!!)\[(.*?)\]\((.*?)( ".*?")?\)/g, (match, p1, p2, p3) => {
+  return content.replace(/(?<!!)\[(.*?)\]\((.*?)( ".*?")?\)/g, (_match, p1, p2, p3) => {
     // URI encode file links
     const title = p3 || '';
     const encodedUrl = p2.replace(/\s/g, '%20').replace(/\)/g, '%29').replace(/\(/g, '%28');
@@ -78,17 +292,29 @@ export function encodeMarkdownLinks(content) {
 }
 
 export function format(content, data, mustache) {
+  const formatStart = Date.now();
+  logger.debug(`[INSTRUMENT] format START - contentLength: ${content?.length || 0}, mustache: ${mustache}`);
+
   const errorTokens = {};
 
-  if (mustache) content = removeDisplayComments(content);
+  if (mustache) {
+    logger.debug(`[INSTRUMENT] format - calling removeDisplayComments`);
+    content = removeDisplayComments(content);
+  }
 
   // Escape code blocks before processing interpolation
+  logger.debug(`[INSTRUMENT] format - calling escapeCodeBlocks`);
+  const escapeStart = Date.now();
   const { content: escapedContent, codeBlocks } = escapeCodeBlocks(content);
+  logger.debug(`[INSTRUMENT] format - escapeCodeBlocks completed in ${Date.now() - escapeStart}ms`);
 
   let result = escapedContent;
   let hasInterpolation = true;
+  let interpolationRound = 0;
 
   while (hasInterpolation) {
+    interpolationRound++;
+    logger.debug(`[INSTRUMENT] format - interpolation round ${interpolationRound} with tags ['${'${'}', '}']`);
     const interpolationResult = interpolate(result, data, { tags: ['${', '}'] });
     result = interpolationResult.content;
     hasInterpolation = interpolationResult.hasInterpolation;
@@ -97,7 +323,10 @@ export function format(content, data, mustache) {
 
   if (mustache) {
     hasInterpolation = true;
+    interpolationRound = 0;
     while (hasInterpolation) {
+      interpolationRound++;
+      logger.debug(`[INSTRUMENT] format - mustache interpolation round ${interpolationRound} with tags ['{{', '}}']`);
       const interpolationResult = interpolate(result, data, { tags: ['{{', '}}'] });
       result = interpolationResult.content;
       hasInterpolation = interpolationResult.hasInterpolation;
@@ -105,6 +334,7 @@ export function format(content, data, mustache) {
     }
   }
 
+  logger.debug(`[INSTRUMENT] format - calling restoreCodeBlocks`);
   result = restoreCodeBlocks(result, codeBlocks);
 
   // Restore error tokens
@@ -112,5 +342,7 @@ export function format(content, data, mustache) {
     result = result.replace(new RegExp(token, 'g'), errorTokens[token]);
   });
 
+  const elapsed = Date.now() - formatStart;
+  logger.debug(`[INSTRUMENT] format END - elapsed: ${elapsed}ms`);
   return result;
 }

package/lib/file.js

@@ -535,16 +535,38 @@ export class File extends Emitter {
     }
   }
   extractTasks (config) {
+    // INSTRUMENTATION: Track timing for hang investigation
+    const startTime = Date.now()
+    log(`[INSTRUMENT] File.extractTasks START for ${this.path}`)
+
     this.tasks = []
     if (this.isMarkDownFile()) {
       const data = this.parseFrontMatter(config)
-      if (data.imdone_ignore || data['kanban-plugin']) return this
+      if (data.imdone_ignore || data['kanban-plugin']) {
+        log(`[INSTRUMENT] File.extractTasks END (ignored) - ${Date.now() - startTime}ms`)
+        return this
+      }
     }
+
+    const frontMatterTime = Date.now()
+    log(`[INSTRUMENT] Front matter check took ${frontMatterTime - startTime}ms`)
+
     if (this.isCodeFile()) {
+      log(`[INSTRUMENT] About to extractTasksInCodeFile`)
       this.extractTasksInCodeFile(config)
+      log(`[INSTRUMENT] extractTasksInCodeFile took ${Date.now() - frontMatterTime}ms`)
     } else {
+      log(`[INSTRUMENT] About to extractTasksInNonCodeFile`)
       this.extractTasksInNonCodeFile(config)
+      log(`[INSTRUMENT] extractTasksInNonCodeFile took ${Date.now() - frontMatterTime}ms`)
     }
+
+    const totalTime = Date.now() - startTime
+    if (totalTime > 1000) {
+      log(`[INSTRUMENT] ⚠️  SLOW File.extractTasks: ${this.path} took ${totalTime}ms`)
+    }
+    log(`[INSTRUMENT] File.extractTasks END - total ${totalTime}ms`)
+
     return this
   }
 
@@ -560,20 +582,62 @@ export class File extends Emitter {
   // order:40
   // -->
   extractTasksInCodeFile (config) {
+    // INSTRUMENTATION: Track regex iterations
+    const startTime = Date.now()
     var self = this
     var commentRegex = this.getCodeCommentRegex()
+    log(`[INSTRUMENT] getCodeCommentRegex took ${Date.now() - startTime}ms`)
+
     var result
+    var iterationCount = 0
+    const contentLength = self.getContent()?.length || 0
+    log(`[INSTRUMENT] Starting regex loop, content length: ${contentLength}`)
+
     while ((result = commentRegex.exec(self.getContent())) !== null) {
+      iterationCount++
+      if (iterationCount % 100 === 0) {
+        log(`[INSTRUMENT] Regex iteration ${iterationCount}, elapsed: ${Date.now() - startTime}ms`)
+      }
+
       var comment = result[0]
       var commentStart = result.index
       self.extractCodeStyleTasks(config, commentStart, comment)
+
+      // Safety check for infinite loop
+      if (iterationCount > 10000) {
+        log(`[INSTRUMENT] ⚠️  WARNING: Exceeded 10000 regex iterations, breaking loop`)
+        break
+      }
     }
+
+    const totalTime = Date.now() - startTime
+    log(`[INSTRUMENT] extractTasksInCodeFile END - ${iterationCount} iterations, ${totalTime}ms`)
   }
 
   extractTasksInNonCodeFile (config) {
-    this.extractHashStyleTasks(config, 0, this.getContent())
-    this.extractLinkStyleTasks(config, 0, this.getContent())
-    this.extractCheckboxTasks(config, 0, this.getContent())
+    // INSTRUMENTATION: Track each extraction method
+    const startTime = Date.now()
+    const content = this.getContent()
+    const contentLength = content?.length || 0
+    log(`[INSTRUMENT] extractTasksInNonCodeFile START, content length: ${contentLength}`)
+
+    log(`[INSTRUMENT] About to extractHashStyleTasks`)
+    this.extractHashStyleTasks(config, 0, content)
+    const hashTime = Date.now()
+    log(`[INSTRUMENT] extractHashStyleTasks took ${hashTime - startTime}ms`)
+
+    log(`[INSTRUMENT] About to extractLinkStyleTasks`)
+    this.extractLinkStyleTasks(config, 0, content)
+    const linkTime = Date.now()
+    log(`[INSTRUMENT] extractLinkStyleTasks took ${linkTime - hashTime}ms`)
+
+    log(`[INSTRUMENT] About to extractCheckboxTasks`)
+    this.extractCheckboxTasks(config, 0, content)
+    const checkboxTime = Date.now()
+    log(`[INSTRUMENT] extractCheckboxTasks took ${checkboxTime - linkTime}ms`)
+
+    const totalTime = Date.now() - startTime
+    log(`[INSTRUMENT] extractTasksInNonCodeFile END - total ${totalTime}ms`)
   }
 
   deleteBlankLine (lineNo) {
@@ -1212,8 +1276,10 @@ export class File extends Emitter {
     if (lang.block) {
       var start = escapeRegExp(lang.block.start)
       var end = escapeRegExp(lang.block.end)
-      //
-      reString = reString + '|(?<!["\'`])' + start + '(.|[\\r\\n])*?' + end
+      // Use [^] instead of (.|[\r\n]) and remove lazy quantifier for better performance
+      // [^] matches any character including newlines without the overhead of alternation
+      // Using greedy match with proper end delimiter is safer than lazy quantifier
+      reString = reString + '|(?<!["\'`])' + start + '[^]*?' + end
     }
 
     return new RegExp(reString, 'gmi')
@@ -1364,7 +1430,62 @@ export class File extends Emitter {
     return Task.isResultInMarkdownCode(positions, pos)
   }
 
-  getMarkdownCodePositions (text) {
+  getMarkdownCodePositions (text, useRegex = false) {
+    if (useRegex) {
+      // Old regex-based implementation (can cause catastrophic backtracking)
+      // Kept for testing/comparison purposes only
+      return this._getMarkdownCodePositionsRegex(text);
+    }
+
+    // New state machine implementation (safe from catastrophic backtracking)
+    const positions = [];
+    const len = text.length;
+    let i = 0;
+
+    while (i < len) {
+      // Check for code block (```)
+      if (text[i] === '`' && text[i + 1] === '`' && text[i + 2] === '`') {
+        const start = i;
+        i += 3; // Skip opening ```
+
+        // Find closing ```
+        while (i < len - 2) {
+          if (text[i] === '`' && text[i + 1] === '`' && text[i + 2] === '`') {
+            i += 3; // Include closing ```
+            positions.push({ start, end: i });
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+
+      // Check for inline code (`)
+      if (text[i] === '`') {
+        const start = i;
+        i++; // Skip opening `
+
+        // Find closing `
+        while (i < len) {
+          if (text[i] === '`') {
+            i++; // Include closing `
+            positions.push({ start, end: i });
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+
+      i++;
+    }
+
+    return positions;
+  };
+
+  _getMarkdownCodePositionsRegex (text) {
+    // OLD IMPLEMENTATION - DO NOT USE IN PRODUCTION
+    // This regex can cause catastrophic backtracking with nested backticks
     const positions = [];
     const codeBlockRe = /```[\s\S]*?```/g;
     const inlineCodeRe = /`[^`]*`/g;

package/lib/mixins/repo-fs-store.js

@@ -20,6 +20,7 @@ import _ignore from 'ignore'
 import { sort } from 'fast-sort'
 import { buildMigrateConfig } from '../migrate-config.js'
 import { loadYAML, dumpYAML } from '../adapters/yaml.js';
+import { logger } from '../adapters/logger.js'
 import realFs from 'fs'
 import { preparePathForWriting, readFile, writeFile, stat, lstat, unlink } from '../adapters/file-gateway.js'
 
@@ -320,9 +321,16 @@ export function fileSystemStoreMixin(repo, fs = realFs) {
     if (!File.isFile(file)) throw new Error(ERRORS.NOT_A_FILE)
     var filePath = repo.getFullPath(file)
 
+    const readStartTime = Date.now()
+    logger.debug(`[INSTRUMENT] readFileContent START for ${filePath}`)
+    logger.debug(`[INSTRUMENT] About to stat ${filePath}`)
     const stats = await stat(filePath)
+    logger.debug(`[INSTRUMENT] stat took ${Date.now() - readStartTime}ms for ${filePath}`)
     if (!stats.isFile()) return file
+    const beforeReadTime = Date.now()
+    logger.debug(`[INSTRUMENT] About to readFile ${filePath}`)
     const data = await readFile(filePath, 'utf8')
+    logger.debug(`[INSTRUMENT] readFile took ${Date.now() - beforeReadTime}ms for ${filePath} (${data?.length || 0} chars)`)
 
     file
       .setContentFromFile(data)
@@ -330,6 +338,7 @@ export function fileSystemStoreMixin(repo, fs = realFs) {
       .setCreatedTime(stats.birthtime)
 
     file.lineCount = eol.split(data).length
+    logger.debug(`[INSTRUMENT] readFileContent END for ${filePath} total ${Date.now() - readStartTime}ms`)
     return file
   }
 

package/lib/project.js

@@ -558,23 +558,33 @@ export class WorkerProject extends Project {
   }
   
   async addTaskToFile({path, list = this.config?.getDefaultList(), content, tags = [], contexts = [], meta = [], useCardTemplate = false}) {
+    logger.debug(`[INSTRUMENT] addTaskToFile START - path: ${path}, contentLength: ${content?.length || 0}`)
+
     const pluginMods = await this.pluginManager.onBeforeAddTask({path, list, meta, tags, contexts, content, useCardTemplate})
     path = pluginMods.path
     content = pluginMods.content
     meta = pluginMods.meta
     tags = pluginMods.tags
     contexts = pluginMods.contexts
+    logger.debug(`[INSTRUMENT] addTaskToFile - after onBeforeAddTask, contentLength: ${content?.length || 0}`)
+
     const cardData = await this.newCard({list, path, title: eol.split(content)[0], emit: false})
     const filePath = cardData.path
     if (useCardTemplate) content += cardData.template
+    logger.debug(`[INSTRUMENT] addTaskToFile - after newCard, contentLength: ${content?.length || 0}`)
 
     const boardData = await this.pluginManager.getBoardProperties();
     const data = { ...boardData, ...cardData}
+    logger.debug(`[INSTRUMENT] addTaskToFile - about to call format(), contentLength: ${content?.length || 0}`)
+    const formatStart = Date.now()
     content = format(content, data)
+    const formatTime = Date.now() - formatStart
+    logger.debug(`[INSTRUMENT] addTaskToFile - format() completed in ${formatTime}ms, contentLength: ${content?.length || 0}`)
 
     content = this.addTagsToContent(tags, content)
     content = this.addContextsToContent(contexts, content)
     content = this.addMetaToContent(meta, content)
+    logger.debug(`[INSTRUMENT] addTaskToFile - about to call repo.addTaskToFile, contentLength: ${content?.length || 0}`)
 
     return await this.repo.addTaskToFile(filePath, list, content)
   }

package/lib/repository.js

@@ -755,20 +755,54 @@ export class Repository extends Emitter {
   // order:-100
   // -->
   async extractTasks (file) {
+    // INSTRUMENTATION: Track timing for hang investigation
+    const extractStartTime = Date.now()
+    logger.debug(`[INSTRUMENT] extractTasks START for ${file.path}`)
+
     if (file.content === null) {
       await this.readFileContent(file)
     }
+
+    const readTime = Date.now()
+    logger.debug(`[INSTRUMENT] readFileContent took ${readTime - extractStartTime}ms`)
+
     file.on('task.found', this.taskFoundListener)
     file.on('task.modified', this.taskModifiedListener)
     const fileContent = file.content
+
+    logger.debug(`[INSTRUMENT] About to call extractAndTransformTasks, content length: ${fileContent?.length || 0}`)
     file.extractAndTransformTasks(this.getConfig())
+
+    const transformTime = Date.now()
+    logger.debug(`[INSTRUMENT] extractAndTransformTasks took ${transformTime - readTime}ms`)
+
     if (!file.isModified() || fileContent === file.content) {
       this.resetFile(file)
+      const totalTime = Date.now() - extractStartTime
+      logger.debug(`[INSTRUMENT] extractTasks END (no changes) - total ${totalTime}ms`)
       return file
     }
+
+    logger.debug(`[INSTRUMENT] About to call file.extractTasks`)
     file.extractTasks(this.getConfig())
-    if (file.modified) await this.writeFile(file)
+
+    const extractTime = Date.now()
+    logger.debug(`[INSTRUMENT] file.extractTasks took ${extractTime - transformTime}ms`)
+
+    if (file.modified) {
+      logger.debug(`[INSTRUMENT] About to writeFile`)
+      await this.writeFile(file)
+      logger.debug(`[INSTRUMENT] writeFile took ${Date.now() - extractTime}ms`)
+    }
+
     this.resetFile(file)
+
+    const totalTime = Date.now() - extractStartTime
+    if (totalTime > 1000) {
+      logger.warn(`[INSTRUMENT] ⚠️  SLOW extractTasks: ${file.path} took ${totalTime}ms`)
+    }
+    logger.debug(`[INSTRUMENT] extractTasks END - total ${totalTime}ms`)
+
     return file
   }
 
@@ -1081,24 +1115,35 @@ export class Repository extends Emitter {
   // order:-80
   // -->
   async writeAndExtract (file, emit) {
+    logger.debug(`[INSTRUMENT] writeAndExtract START - file: ${file.path}`)
+
     try {
+      logger.debug(`[INSTRUMENT] writeAndExtract - about to call writeFile`)
       await this.writeFile(file, emit)
+      logger.debug(`[INSTRUMENT] writeAndExtract - writeFile completed`)
     } catch (err) {
       new Error('Unable to write file:' + file.path, {cause: err})
     }
 
     try {
+      logger.debug(`[INSTRUMENT] writeAndExtract - about to call extractTasks`)
+      const extractStart = Date.now()
       await this.extractTasks(file)
+      const extractTime = Date.now() - extractStart
+      logger.debug(`[INSTRUMENT] writeAndExtract - extractTasks completed in ${extractTime}ms`)
     } catch (err) {
       new Error('Unable to extract tasks for file:' + file.path, { cause: err })
     }
 
     try {
+      logger.debug(`[INSTRUMENT] writeAndExtract - about to call addFile`)
       await this.addFile(file)
+      logger.debug(`[INSTRUMENT] writeAndExtract - addFile completed`)
     } catch (err) {
       new Error('Unable to add file after extracting tasks: ' + file.path, { cause: err })
     }
 
+    logger.debug(`[INSTRUMENT] writeAndExtract END`)
     return file
   }
 
@@ -1223,6 +1268,8 @@ export class Repository extends Emitter {
   // order:-300
   // -->
   async appendTask({file, content, list}) {
+    logger.debug(`[INSTRUMENT] appendTask START - file: ${file.path}, contentLength: ${content?.length || 0}`)
+
     const config = this.getConfig()
     const interpretedTaskPrefix = interpolate(
       config.getTaskPrefix(),
@@ -1233,6 +1280,8 @@ export class Repository extends Emitter {
     const taskSyntax = config.getNewCardSyntax()
     const taskPrefix = interpretedTaskPrefix ? `${interpretedTaskPrefix} ` : ''
     let fileContent = file.getContent()
+    logger.debug(`[INSTRUMENT] appendTask - existing file contentLength: ${fileContent?.length || 0}`)
+
     const journalTemplate = this.getConfig().journalTemplate
     fileContent = fileContent.trim()
       ? fileContent
@@ -1249,7 +1298,7 @@ export class Repository extends Emitter {
     const order = appContext().projectContext.getOrder(list)
     const description = lines.length > 1 ? Task.padDescription(lines.slice(1), taskPrefix) : []
     const { orderMeta, tokenPrefix } = config
-    const rawTask = getRawTask({tokenPrefix, orderMeta, list, order, text, type: taskSyntax})      
+    const rawTask = getRawTask({tokenPrefix, orderMeta, list, order, text, type: taskSyntax})
     const taskContent = config.orderMeta
     ? this.getTaskContent({
         description,
@@ -1263,13 +1312,20 @@ export class Repository extends Emitter {
     let appendContent = File.trimBlankLines(
       `${taskPrefix}${rawTask}${eol.lf}${taskContent}`
     )
-    
+
     fileContent = `${fileContent}${sep}`
     const cardTerminator = "\n".repeat(2)
-    file.setContent(`${fileContent}${appendContent}${cardTerminator}`)
+    const finalContent = `${fileContent}${appendContent}${cardTerminator}`;
+    logger.debug(`[INSTRUMENT] appendTask - final contentLength: ${finalContent?.length || 0}`)
+    logger.debug(`[INSTRUMENT] appendTask - about to call file.setContent`)
+    file.setContent(finalContent)
 
+    logger.debug(`[INSTRUMENT] appendTask - about to call writeAndExtract`)
     await this.writeAndExtract(file)
+    logger.debug(`[INSTRUMENT] appendTask - writeAndExtract completed`)
+
     const task = file.getTasks().find(task => task.text === text && task.list === list)
+    logger.debug(`[INSTRUMENT] appendTask END - task found: ${!!task}`)
     return { file, task }
   }
 
@@ -1279,13 +1335,18 @@ export class Repository extends Emitter {
   // order:-290
   // -->
   async addTaskToFile (filePath, list, content) {
+    logger.debug(`[INSTRUMENT] repo.addTaskToFile START - filePath: ${filePath}, contentLength: ${content?.length || 0}`)
+
     const relPath = this.getRelativePath(filePath)
     let file = this.getFile(relPath)
 
     if (file) {
+      logger.debug(`[INSTRUMENT] repo.addTaskToFile - file exists, reading content`)
       await this.readFileContent(file)
+      logger.debug(`[INSTRUMENT] repo.addTaskToFile - about to call appendTask`)
       return await this.appendTask({file, content, list})
     } else {
+      logger.debug(`[INSTRUMENT] repo.addTaskToFile - creating new file`)
       const modifiedTime = new Date()
       const createdTime = new Date()
       file = new File({
@@ -1296,6 +1357,7 @@ export class Repository extends Emitter {
         createdTime,
         project: this.project,
       })
+      logger.debug(`[INSTRUMENT] repo.addTaskToFile - about to call appendTask for new file`)
       return await this.appendTask({file, content, list})
     }
   }
@@ -1511,4 +1573,4 @@ export class Repository extends Emitter {
     const result = Repository.query(this.getTasks(), queryString)
     return Repository.getTasksByList(this, result, true)
   }
-}
+}

package/lib/task.js

@@ -128,7 +128,7 @@ export class Task {
 
   getTextAndDescription() {
     const taskContent = `${this.markdownBeforeText}${this.text}${lineEnd}${this.descriptionString}`
-    .replace(/<!--\s*\[\s*([\s\S]*?)\s*\]\s*-->/gm, '$1')
+    .replace(/<!--\s*\[\s*([\s\S]*?)\s*\]\s*-->/gm, '$1') // Safe: simple capture group, no backtracking issue
     return this.getText(
       {
         stripMeta: true,
@@ -199,13 +199,31 @@ export class Task {
     // order:-680
     // -->
     let prefix = newLine ? lineEnd : ' '
-    const commentRegex = /<!--([\s\S]*?)-->/gm
-    let result, lastIndex, index
-    while ((result = commentRegex.exec(content))) {
-      lastIndex = commentRegex.lastIndex
-      index = result.index
+
+    // Find last comment using state machine (safe from backtracking)
+    let lastIndex = -1;
+    const len = content.length;
+    let i = 0;
+
+    while (i < len - 3) {
+      // Look for comment start <!--
+      if (content[i] === '<' && content[i + 1] === '!' && content[i + 2] === '-' && content[i + 3] === '-') {
+        i += 4;
+
+        // Find comment end -->
+        while (i < len - 2) {
+          if (content[i] === '-' && content[i + 1] === '-' && content[i + 2] === '>') {
+            i += 3;
+            lastIndex = i; // Remember end of this comment
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+      i++;
     }
-  
+
     if (lastIndex > 0) {
       let before = content.slice(0, lastIndex - 3).trimEnd()
       const after = content.slice(lastIndex - 3)
@@ -434,7 +452,42 @@ export class Task {
     return linkLabelPositions.some(pos => index >= pos.start && index < pos.end);
   };
 
-  static getCommentPositions (text) {
+  static getCommentPositions (text, useRegex = false) {
+    if (useRegex) {
+      return Task._getCommentPositionsRegex(text);
+    }
+
+    // State machine implementation (safe from catastrophic backtracking)
+    const positions = [];
+    const len = text.length;
+    let i = 0;
+
+    while (i < len - 3) { // Need at least 4 chars for <!--
+      // Look for comment start <!--
+      if (text[i] === '<' && text[i + 1] === '!' && text[i + 2] === '-' && text[i + 3] === '-') {
+        const start = i;
+        i += 4; // Skip <!--
+
+        // Find comment end -->
+        while (i < len - 2) {
+          if (text[i] === '-' && text[i + 1] === '-' && text[i + 2] === '>') {
+            i += 3; // Include -->
+            positions.push({ start, end: i });
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+      i++;
+    }
+
+    return positions;
+  }
+
+  static _getCommentPositionsRegex (text) {
+    // OLD IMPLEMENTATION - DO NOT USE IN PRODUCTION
+    // This regex can cause catastrophic backtracking with nested/malformed comments
     const positions = [];
     const re = /<!--[\s\S]*?-->/g;
     let match;
@@ -517,7 +570,58 @@ export class Task {
     return task instanceof Task
   }
 
-  static getMarkdownCodePositions (text) {
+  static getMarkdownCodePositions (text, useRegex = false) {
+    if (useRegex) {
+      return Task._getMarkdownCodePositionsRegex(text);
+    }
+
+    // State machine implementation (safe from catastrophic backtracking)
+    const positions = [];
+    const len = text.length;
+    let i = 0;
+
+    while (i < len) {
+      // Check for code block (```)
+      if (text[i] === '`' && text[i + 1] === '`' && text[i + 2] === '`') {
+        const start = i;
+        i += 3;
+
+        while (i < len - 2) {
+          if (text[i] === '`' && text[i + 1] === '`' && text[i + 2] === '`') {
+            i += 3;
+            positions.push({ start, end: i });
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+
+      // Check for inline code (`)
+      if (text[i] === '`') {
+        const start = i;
+        i++;
+
+        while (i < len) {
+          if (text[i] === '`') {
+            i++;
+            positions.push({ start, end: i });
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+
+      i++;
+    }
+
+    return positions;
+  };
+
+  static _getMarkdownCodePositionsRegex (text) {
+    // OLD IMPLEMENTATION - DO NOT USE IN PRODUCTION
+    // This regex can cause catastrophic backtracking
     const re = /(```[\s\S]*?```|`[^`]+`)/g;
     let result;
     let positions = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imdone-core",
-  "version": "2.1.5",
+  "version": "2.1.10",
   "description": "imdone-core",
   "repository": {
     "type": "git",

package/types/adapters/parsers/content-transformer.d.ts

@@ -1,5 +1,5 @@
 /**
- * Interpolates the content with the provided data.
+ * Interpolates the content with the provided data using state machine parsing.
  * @param {string} content - The content to interpolate.
  * @param {object} data - The data to use for interpolation.
  * @param {object} opts - The options for interpolation.

package/types/file.d.ts

@@ -363,7 +363,11 @@ export class File extends Emitter<[never]> {
         createdTime: any;
     };
     isWithinCodeSpanOrBlock(pos: any, content: any): boolean;
-    getMarkdownCodePositions(text: any): {
+    getMarkdownCodePositions(text: any, useRegex?: boolean): {
+        start: number;
+        end: number;
+    }[];
+    _getMarkdownCodePositionsRegex(text: any): {
         start: number;
         end: number;
     }[];

package/types/task.d.ts

@@ -31,7 +31,11 @@ export class Task {
         end: number;
     }[];
     static isResultInMarkdownLinkLabel(linkLabelPositions: any, index: any): any;
-    static getCommentPositions(text: any): {
+    static getCommentPositions(text: any, useRegex?: boolean): {
+        start: number;
+        end: number;
+    }[];
+    static _getCommentPositionsRegex(text: any): {
         start: number;
         end: number;
     }[];
@@ -49,7 +53,11 @@ export class Task {
      * @return BinaryExpression
      */
     static isTask(task: any): task is Task;
-    static getMarkdownCodePositions(text: any): {
+    static getMarkdownCodePositions(text: any, useRegex?: boolean): {
+        start: number;
+        end: number;
+    }[];
+    static _getMarkdownCodePositionsRegex(text: any): {
         start: number;
         end: number;
     }[];