imdone-core 2.2.0 → 2.3.0

package/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm test:*)",
+      "Bash(node test-debug.js:*)",
+      "Bash(cat:*)",
+      "Bash(node test-ignore-patterns.js:*)",
+      "Bash(node test-ignore-patterns-detailed.js:*)",
+      "Bash(node test-ignore-patterns-fixed.js:*)"
+    ]
+  }
+}

package/README.md

@@ -2,9 +2,9 @@
 [![Downloads](https://img.shields.io/npm/dm/imdone-core.svg)](https://npmjs.org/package/imdone-core)
 ![Build Status](https://github.com/imdone/imdone-core/actions/workflows/ci.yml/badge.svg)
 
-Imdone is text based kanban processor with a simple syntax that uses [comment tags like TODO and FIXME](https://en.wikipedia.org/wiki/Comment_%28computer_programming%29#Tags) and [todo.txt format](https://github.com/todotxt/todo.txt#todotxt-format). This model allows the user to create and modify tasks using the keyboard and automatically establishes a link between their tasks and work.  Get [imdone](https://imdone.io) or use the cli to see your projects board and this library in action.
+Imdone is text based kanban processor with a simple syntax that uses [comment tags like TODO and FIXME](https://en.wikipedia.org/wiki/Comment_%28computer_programming%29#Tags) and [todo.txt format](https://github.com/todotxt/todo.txt#todotxt-format). This model allows the user to create and modify tasks using the keyboard and automatically establishes a link between their tasks and work.  Get [imdone kanban](https://imdone.io/docs/imdone-kanban/) or use the [cli](https://imdone.io/docs/imdone-cli/) to see your projects board and this library in action.
 
-![imdone-screenshot.png (5120×2838)](https://imdone.io/docs/images/card-anatomy.png)
+![imdone-screenshot.png (5120×2838)](https://imdone.io/docs/imdone-kanban/images/card-anatomy.png)
 
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

package/lib/adapters/parsers/file/LocalFileParserFactory.js

@@ -28,7 +28,7 @@ export async function getFileParser (filePath, config, readStream) {
       readStream,
       filePath,
       lang,
-      config.lists
+      config.code?.include_lists || ['TODO', 'DOING', 'DONE', 'NOTE']
     )
     await parser.init()
     return parser

package/lib/adapters/parsers/file/ReadStreamCodeParser.js

@@ -1,10 +1,7 @@
 import path from 'node:path'
 import { ReadStreamTaskParser } from './ReadStreamTaskParser.js'
-import { CodeStyleTaskParser } from '../task/CodeStyleTaskParser.js'
 import { languages } from '../../../languages.js'
-import extractComments from 'multilang-extract-comments'
-import eol from 'eol'
-import { Readable } from 'node:stream'
+import { CodeStyleTaskParser } from '../task/CodeStyleTaskParser.js'
 
 // TODO Move to readstream parsing for code to improve performance
 // <!--
@@ -18,109 +15,217 @@ export class ReadStreamCodeParser extends ReadStreamTaskParser {
     this.lists = lists
     this.filePath = filePath
     this.lang = lang
-    this.taskParsers = [new CodeStyleTaskParser()]
   }
 
   async init() {
-    const code = await streamToString(this.readStream)
     // TODO Getting tokens from lists should be done higher up in the controller
     // <!--
     // order:-10
     // -->
-    const tokens = this.lists.filter(list => !list.filter).map(list => list.name)
-    this.cards = this.parseCards(code, tokens)
+    const tokens = this.lists
+      .map((list) => {
+        if (typeof list === 'string') return list
+        if (!list || typeof list !== 'object') return undefined
+        return list.name
+      })
+      .filter(Boolean)
+    this.cards = await this.parseCards(tokens)
   }
 
   async readTask() {
     return this.cards.shift()
   }
 
-  parseCards(code, tokens = ['TODO']) {
-    const comments = this.parseComments(code);
-    const cards = [];
-  
+  async parseCards(tokens = ['TODO']) {
+    const comments = await this.parseComments()
+    const cards = []
+    const listNames = tokens.map((token) =>
+      typeof token === 'string' ? token : token?.name
+    ).filter(Boolean)
+    const parser = new CodeStyleTaskParser({
+      includeList: (list) => listNames.includes(list),
+      listExists: (list) => listNames.includes(list),
+      lists: listNames.map((name) => ({ name })),
+    })
+
     Object.keys(comments).forEach((comment) => {
-      const { begin, end, content } = comments[comment];
-      const line = begin;
-      const lastLine = end; // TODO lastLine should not be - 1
-                            // <!--
-                            // order:-140
-                            // -->
-      const lines = content.split('\n');
-  
-      // Check if the comment contains "TODO"
-      lines.forEach(codeLine => {
-        if (tokens.find((token) => codeLine.includes(token))) {
-          // Get all lines from start to end
-          
-          cards.push({
-            content,
-            line,
-            lastLine,
-          });
+      const {
+        begin,
+        end,
+        content,
+        inBlockComment,
+        singleLineBlockComment,
+      } = comments[comment]
+
+      const lines = content.split('\n')
+      let activeTask = null
+      let taskLines = []
+
+      const flushActiveTask = (lineNo) => {
+        if (!activeTask) return
+        cards.push({
+          ...activeTask,
+          content: `${taskLines.join('\n')}\n`,
+          line: activeTask.line,
+          lastLine: lineNo,
+          inBlockComment,
+          singleLineBlockComment,
+        })
+        activeTask = null
+        taskLines = []
+      }
+
+      lines.forEach((line, index) => {
+        const lineNo = begin + index
+        const parsedTask = parser.parseLine(line, lineNo)
+
+        if (parsedTask) {
+          flushActiveTask(lineNo - 1)
+          activeTask = parsedTask
+          taskLines = [line]
+          return
+        }
+
+        if (activeTask) {
+          taskLines.push(line)
         }
-      });
-    });
-    return cards;
+      })
+
+      flushActiveTask(end)
+    })
+    return cards
   }
   
-  parseComments(code) {
-    const options = getLanguageOptions(this.filePath);
-    const comments = extractComments(code, options);
-    return comments;
+  async parseComments() {
+    const options = getLanguageOptions(this.filePath, this.lang);
+    const comments = [];
+    let lineNo = 0;
+    let singleLineComment;
+    let blockComment;
+
+    const finishSingleLineComment = () => {
+      if (!singleLineComment) return
+      comments.push(singleLineComment)
+      singleLineComment = undefined
+    }
+
+    for await (const line of this.readInterface) {
+      lineNo++
+
+      if (blockComment) {
+        appendBlockCommentLine(blockComment, line, options)
+        if (line.includes(options.block.end)) {
+          blockComment.end = lineNo
+          comments.push(blockComment)
+          blockComment = undefined
+        }
+        continue
+      }
+
+      const blockStartIndex = getBlockStartIndex(line, options)
+      const singleLineIndex = getSingleLineCommentIndex(line, options)
+      const blockStartsFirst = blockStartIndex > -1 && (singleLineIndex === -1 || blockStartIndex < singleLineIndex)
+
+      if (blockStartsFirst) {
+        finishSingleLineComment()
+        blockComment = {
+          begin: lineNo,
+          end: lineNo,
+          contentLines: [],
+          inBlockComment: true,
+        }
+        appendBlockCommentLine(blockComment, line, options)
+        if (line.includes(options.block.end)) {
+          comments.push(blockComment)
+          blockComment = undefined
+        }
+      } else if (singleLineIndex > -1) {
+        const content = line.slice(singleLineIndex + options.singleLineComment.length)
+        if (!singleLineComment || singleLineComment.end !== lineNo - 1) {
+          finishSingleLineComment()
+          singleLineComment = {
+            begin: lineNo,
+            end: lineNo,
+            contentLines: [],
+            inBlockComment: false,
+          }
+        }
+        singleLineComment.end = lineNo
+        singleLineComment.contentLines.push(trimCommentLine(content))
+      } else {
+        finishSingleLineComment()
+      }
+    }
+
+    finishSingleLineComment()
+    if (blockComment) comments.push(blockComment)
+
+    return comments.reduce((acc, comment, index) => {
+      acc[index] = {
+        begin: comment.begin,
+        end: comment.end,
+        content: formatCommentContent(comment.contentLines),
+        inBlockComment: comment.inBlockComment,
+        singleLineBlockComment: comment.inBlockComment && comment.begin === comment.end,
+      }
+      return acc
+    }, {})
   }
   
 }
 
+function getBlockStartIndex(line, options) {
+  if (!options.block.start || !options.block.end) return -1
+  return line.indexOf(options.block.start)
+}
 
-function getLanguageOptions(filePath) {
-  const extension = path.extname(filePath)
-  const language = languages[extension]
-  
-  
-  const {
-      name,
-      symbol,
-      block,
-    } = language || 
-    { 
-      name: 'text', 
-      symbol: '', 
-      block: {
-        start: undefined,
-        end: undefined,
-        ignore: undefined,
-      }
-    };
-  // Use lang to get comment patterns
-
-  const {
-    start,
-    ignore: middle,
-    end
-  } = block || {};
-  
-  return language && {
-    pattern: {
-      name,
-      nameMatchers: extension && [extension] || [],
-      singleLineComment: symbol && [{ start: symbol }] || [],
-      multiLineComment: start && end && [{ start, middle, end }] || [],
-    },
-  };
+function getSingleLineCommentIndex(line, options) {
+  if (!options.singleLineComment) return -1
+  return line.indexOf(options.singleLineComment)
 }
 
-async function streamToString(stream) {
-  const chunks = []
+function appendBlockCommentLine(comment, line, options) {
+  const startIndex = line.indexOf(options.block.start)
+  const contentStart = startIndex > -1 ? startIndex + options.block.start.length : 0
+  const endIndex = line.indexOf(options.block.end, contentStart)
+  const contentEnd = endIndex > -1 ? endIndex : line.length
+  const content = line.slice(contentStart, contentEnd)
+
+  comment.contentLines.push(trimCommentLine(content, options.block.ignore))
+}
 
-  for await (const chunk of stream) {
-    chunks.push(Buffer.from(chunk))
+function trimCommentLine(line, ignoreToken) {
+  let trimmed = line.trimStart()
+  if (ignoreToken && trimmed.startsWith(ignoreToken)) {
+    trimmed = trimmed.slice(ignoreToken.length).trimStart()
   }
+  return trimmed.trimEnd()
+}
+
+function formatCommentContent(lines) {
+  const trimmedLines = trimBlankCommentLines(lines)
+  if (!trimmedLines.length) return ''
+  return `${trimmedLines.join('\n')}\n`
+}
 
-  return Buffer.concat(chunks).toString('utf-8')
+function trimBlankCommentLines(lines) {
+  const trimmedLines = [...lines]
+  while (trimmedLines[0] === '') trimmedLines.shift()
+  while (trimmedLines[trimmedLines.length - 1] === '') trimmedLines.pop()
+  return trimmedLines
 }
 
-function stringToStream(string) {
-  const lines = eol.split(string).map((line) => line + String(eol.auto))
-  return Readable.from(lines)
+function getLanguageOptions(filePath, lang) {
+  const extension = path.extname(filePath)
+  const language = lang || languages[extension]
+  const block = language?.block || {}
+
+  return {
+    singleLineComment: language?.symbol || '',
+    block: {
+      start: block.start,
+      ignore: block.ignore,
+      end: block.end,
+    },
+  }
 }

package/lib/adapters/parsers/file/ReadStreamMarkdownParser.js

@@ -1,17 +1,92 @@
 import { ReadStreamTaskParser } from './ReadStreamTaskParser.js'
 import { HashStyleTaskParser } from '../task/HashStyleTaskParser.js'
 import { MarkdownStyleTaskParser } from '../task/MarkdownStyleTaskParser.js'
-// const CheckStyleTaskParser = require('../task/CheckStyleTaskParser')
+import { CheckStyleTaskParser } from '../task/CheckStyleTaskParser.js'
+import { loadYAML } from '../../yaml.js'
+
+const FRONTMATTER_DELIMITER = '---'
+const CODE_FENCE_PATTERN = /^\s*(```|~~~)/
+const INLINE_CODE_SPAN_PATTERN = /`[^`]*`/g
 
 export class ReadStreamMarkdownParser extends ReadStreamTaskParser {
   constructor(readStream, config) {
     super(readStream, config)
+    this.frontmatterLines = []
+    this.collectingFrontmatter = false
+    this.frontmatterClosed = false
+    this.ignoredByFrontmatter = false
+    this.currentLineIsFrontmatter = false
+    this.currentLineIsCodeFence = false
+    this.inCodeFence = false
     this.taskParsers = [
       new HashStyleTaskParser(config),
       new MarkdownStyleTaskParser(config),
     ]
-    // if (config.isAddCheckBoxTasks()) {
-    //   this.taskParsers.push(new CheckStyleTaskParser())
-    // }
+    if (config.isAddCheckBoxTasks()) {
+      this.taskParsers.push(new CheckStyleTaskParser(config))
+    }
+  }
+
+  onLineRead(line) {
+    this.updateFrontmatterState(line)
+    this.updateCodeFenceState(line)
+  }
+
+  shouldParseTaskLine() {
+    return !this.ignoredByFrontmatter &&
+      !this.currentLineIsFrontmatter &&
+      !this.currentLineIsCodeFence
+  }
+
+  getLineForTaskParsing(line) {
+    return line.replace(INLINE_CODE_SPAN_PATTERN, (match) => ' '.repeat(match.length))
+  }
+
+  updateFrontmatterState(line) {
+    const trimmed = line.trim()
+    this.currentLineIsFrontmatter = false
+
+    if (this.lineNo === 1 && isFrontmatterDelimiter(trimmed)) {
+      this.collectingFrontmatter = true
+      this.currentLineIsFrontmatter = true
+      return
+    }
+
+    if (!this.collectingFrontmatter) return
+
+    this.currentLineIsFrontmatter = true
+
+    if (isFrontmatterDelimiter(trimmed)) {
+      this.collectingFrontmatter = false
+      this.frontmatterClosed = true
+      this.updateIgnoredByFrontmatter()
+      return
+    }
+
+    this.frontmatterLines.push(line)
+  }
+
+  updateIgnoredByFrontmatter() {
+    if (!this.frontmatterClosed) return
+    const data = parseFrontmatter(this.frontmatterLines)
+    this.ignoredByFrontmatter = !!(data.imdone_ignore || data['kanban-plugin'])
+  }
+
+  updateCodeFenceState(line) {
+    const isFence = CODE_FENCE_PATTERN.test(line)
+    this.currentLineIsCodeFence = this.inCodeFence || isFence
+    if (isFence) this.inCodeFence = !this.inCodeFence
+  }
+}
+
+function isFrontmatterDelimiter(trimmedLine) {
+  return trimmedLine === FRONTMATTER_DELIMITER
+}
+
+function parseFrontmatter(lines) {
+  try {
+    return loadYAML(lines.join('\n')) || {}
+  } catch (error) {
+    return {}
   }
 }

package/lib/adapters/parsers/file/ReadStreamTaskParser.js

@@ -16,11 +16,13 @@ export class ReadStreamTaskParser {
       crlfDelay: Infinity,
       console: false,
     })
+    this.lineIterator = this.readInterface[Symbol.asyncIterator]()
   }
 
   async readTask() {
     let taskOrStreamDone = false
     this.task = this.nextTask || null
+    this.nextTask = null
     this.blankLines = 0
 
     try {
@@ -29,6 +31,7 @@ export class ReadStreamTaskParser {
         let { value, done } = this.line
         if (this.line && !done) {
           this.lineNo++
+          this.onLineRead(value)
           const endOfTask = this.isEndOfTask(value)
           if (this.task && endOfTask) {
             taskOrStreamDone = true
@@ -51,7 +54,19 @@ export class ReadStreamTaskParser {
   }
 
   async readLine() {
-    return this.readInterface[Symbol.asyncIterator]().next()
+    return this.lineIterator.next()
+  }
+
+  onLineRead() {
+    // Hook for parsers that need line-aware state.
+  }
+
+  shouldParseTaskLine() {
+    return true
+  }
+
+  getLineForTaskParsing(line) {
+    return line
   }
 
   isEndOfTask(line) {
@@ -76,9 +91,12 @@ export class ReadStreamTaskParser {
   }
 
   getTaskFromLine(line) {
+    if (!this.shouldParseTaskLine(line)) return
+    const originalLine = line
+    line = this.getLineForTaskParsing(line)
     let task
     this.taskParsers.find((taskParser) => {
-      task = taskParser.parseLine(line, this.lineNo, this.task)
+      task = taskParser.parseLine(line, this.lineNo, this.task, originalLine)
       return task
     })
     return task

package/lib/adapters/parsers/task/CheckStyleTaskParser.js

@@ -1,8 +1,8 @@
 import { TaskParser } from "./TaskParser.js"
 
 export class CheckStyleTaskParser extends TaskParser {
-  constructor() {
-    super()
+  constructor(config) {
+    super('CHECKBOX', config)
   }
 
   get pattern() {
@@ -20,6 +20,7 @@ export class CheckStyleTaskParser extends TaskParser {
     return {
       beforeText,
       text,
+      list: checked ? this.config.getDoneList() : this.config.getDefaultList(),
       line,
       checked,
       type: this.config.getNewCardSyntax(),

package/lib/adapters/parsers/task/CodeStyleTaskParser.js

@@ -6,7 +6,7 @@ export class CodeStyleTaskParser extends TaskParser {
   }
 
   get pattern() {
-    return /^(.*?[ #]?)([a-zA-Z-_]+?)(:)(-?[\d.]+(?:e-?\d+)?)?[ \t]+(.+)$/gm
+    return /^(.*?[ #]?)([A-Z]+[A-Z-_]+?)(:)?(-?[\d.]+(?:e-?\d+)?)?[ \t]+(.+)$/gm
   }
 
   parse(lineContent, line, matchResult) {

package/lib/adapters/parsers/task/HashStyleTaskParser.js

@@ -8,7 +8,7 @@ export class HashStyleTaskParser extends TaskParser {
 
   get pattern() {
     const config = this.config
-    return getHashStyleRegex(config.tokenPrefix, config.orderMeta)
+    return getHashStyleRegex(config.tokenPrefix)
   }
 
   parse(lineContent, line, matchResult) {

package/lib/adapters/parsers/task/TaskParser.js

@@ -24,10 +24,15 @@ export class TaskParser {
     throw new Error('Unimplemented')
   }
 
-  parseLine(lineContent, line, task) {
+  parseLine(lineContent, line, task, originalLineContent = lineContent) {
     const re = new RegExp(this.pattern)
     const result = re.exec(lineContent)
-    const parseResult = result && this.parse(lineContent, line, result, task)
+    if (!result) return
+
+    const originalResult = originalLineContent === lineContent
+      ? result
+      : new RegExp(this.pattern).exec(originalLineContent.slice(result.index)) || result
+    const parseResult = this.parse(originalLineContent, line, originalResult, task)
 
     if (parseResult && this.config.lists && !this.config.listExists(parseResult.list)) {
       return

package/lib/file.js

@@ -852,7 +852,7 @@ export class File extends Emitter {
         } else text = task.text
         if (/[a-z]/.test(task.list)) task.type = Task.Types.HASHTAG
         const tokenPrefix = task.type === Task.Types.HASHTAG ? config.tokenPrefix : ''
-        var taskContent = getRawTask({tokenPrefix, orderMeta: config.orderMeta, list: task.list, order: task.order, text, type: task.type})
+        var taskContent = getRawTask({tokenPrefix, orderMeta: config.orderMeta, hasColon: task.hasColon, list: task.list, order: task.order, text, type: task.type})
         task.line = this.getLineNumber(index)
         task.id = getTaskId(self.getPath(), task.line, task.text)
         this.setContent(beforeContent + taskContent + afterContent)
@@ -1508,4 +1508,4 @@ export class File extends Emitter {
   isResultInMarkdownCode (positions, index) {
     return positions.some(pos => index >= pos.start && index < pos.end);
   };
-}
+}

package/lib/migrate-config.js

@@ -149,13 +149,14 @@ export function buildMigrateConfig (repo, defaultSettings = _defaultSettings) {
         config.settings.kudosProbability = 0.33
       }
 
-      const defaultCardsSettings = cloneDeep(defaultSettings.cards)
+      const defaultSettingsCopy = cloneDeep(defaultSettings)
+      const defaultCardsSettings = cloneDeep(defaultSettingsCopy.cards)
       const cardsSettings = cloneDeep(config.settings.cards)
 
-      delete defaultSettings.cards
+      delete defaultSettingsCopy.cards
       delete config.settings.cards
 
-      config.settings = { ...defaultSettings, ...config.settings }
+      config.settings = { ...defaultSettingsCopy, ...config.settings }
       config.settings.cards = {
         ...defaultCardsSettings,
         ...cardsSettings,

package/lib/repository.js

@@ -37,8 +37,140 @@ import { appContext } from './context/ApplicationContext.js'
 import { computeChecksum } from './checksum.js'
 import { getTasksToModify } from './get-tasks-to-modify.js'
 import { logger } from './adapters/logger.js'
+import { getFileParser } from './adapters/parsers/file/LocalFileParserFactory.js'
+import { CodeStyleTaskParser } from './adapters/parsers/task/CodeStyleTaskParser.js'
 const { ERRORS, ASYNC_LIMIT, DEFAULT_FILE_PATTERN} = constants
 const DEFAULT_SORT = [{ asc: u => isNumber(u.order) ? u.order : Infinity }, { asc: u => u.text }]
+const STREAM_FALLBACK_REASONS = {
+  BLOCK_COMMENT_WRITE_BACK_CONTEXT_UNSUPPORTED: 'block-comment-write-back-context-unsupported',
+}
+
+async function readStreamTasks(filePath, config) {
+  const parser = await getFileParser(filePath, config)
+  const tasks = []
+  let task
+  try {
+    while ((task = await parser.readTask())) {
+      tasks.push(task)
+    }
+  } finally {
+    parser.close()
+  }
+  return tasks
+}
+
+function parseCodeStreamTask(streamTask, config) {
+  if (!streamTask.content) return
+  const firstTaskLine = streamTask.content
+    .split(/\r?\n/)
+    .find((line) => line.trim())
+  if (!firstTaskLine) return
+
+  const parser = new CodeStyleTaskParser({
+    ...config,
+    includeList: (list) => config.includeList(list),
+    listExists: (list) => config.includeList(list),
+  })
+  const parsed = parser.parseLine(firstTaskLine, streamTask.line)
+  if (!parsed) return
+
+  parsed.lastLine = streamTask.lastLine
+  return parsed
+}
+
+function toFileTask({ file, streamTask, config }) {
+  const parsedTask = streamTask.text
+    ? streamTask
+    : parseCodeStreamTask(streamTask, config)
+  if (!parsedTask) return
+
+  const lineContent = file.getContentLines()[parsedTask.line - 1] || ''
+  const type = parsedTask.type || Task.Types.CODE
+  const taskStartOnLine = getTaskStartOnLine({ lineContent, parsedTask, type, config })
+  const linePos = file.getLinePos(parsedTask.line)
+  const tokenPrefix = type === Task.Types.HASHTAG ? config.tokenPrefix : ''
+  const rawTask = parsedTask.rawTask || getOriginalRawTask({
+    lineContent,
+    parsedTask,
+    taskStartOnLine,
+    type,
+    tokenPrefix,
+    config,
+  })
+
+  return file.extractTaskWithDescription({
+    taskStartOnLine,
+    rawTask,
+    config,
+    list: parsedTask.list,
+    text: parsedTask.text,
+    order: parsedTask.order,
+    line: parsedTask.line,
+    type,
+    hasColon: !!parsedTask.colon,
+    content: file.getContent().substring(linePos),
+    pos: linePos + taskStartOnLine,
+  })
+}
+
+function getTaskStartOnLine({ lineContent, parsedTask, type, config }) {
+  if (parsedTask.beforeText) return parsedTask.beforeText.length
+  if (type === Task.Types.CODE) {
+    return Math.max(0, lineContent.indexOf(parsedTask.list))
+  }
+  if (type === Task.Types.HASHTAG) {
+    const taskTokenIndex = lineContent.indexOf(`${config.tokenPrefix}${parsedTask.list}`)
+    if (taskTokenIndex > -1) return taskTokenIndex
+  }
+  return 0
+}
+
+function getOriginalRawTask({
+  lineContent,
+  parsedTask,
+  taskStartOnLine,
+  type,
+  tokenPrefix,
+  config,
+}) {
+  if (type !== Task.Types.CODE) {
+    return lineContent.slice(taskStartOnLine)
+  }
+
+  return getRawTask({
+    tokenPrefix,
+    orderMeta: config.orderMeta,
+    beforeText: parsedTask.beforeText,
+    hasColon: !!parsedTask.colon,
+    list: parsedTask.list,
+    order: parsedTask.order,
+    text: parsedTask.text,
+    type,
+  })
+}
+
+function attachStreamTasks({ file, streamTasks, config }) {
+  file.tasks = []
+  streamTasks.forEach((streamTask) => {
+    const task = toFileTask({ file, streamTask, config })
+    if (!task) return
+    file.addTask(task)
+    file.emit('task.found', task)
+  })
+}
+
+function getStreamWriteBackFallbackReason(streamTasks) {
+  if (streamTasks.some((streamTask) => streamTask.inBlockComment)) {
+    return STREAM_FALLBACK_REASONS.BLOCK_COMMENT_WRITE_BACK_CONTEXT_UNSUPPORTED
+  }
+}
+
+function emitParserDiagnostic(repo, file, diagnostic) {
+  repo.emit('file.parser', {
+    path: file.path,
+    ...diagnostic,
+  })
+}
 
 function getTasksByList (
   repo,
@@ -768,41 +900,38 @@ export class Repository extends Emitter {
 
     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`)
+    const streamTasks = await readStreamTasks(this.getFullPath(file), this.getConfig())
+    const fallbackReason = getStreamWriteBackFallbackReason(streamTasks)
+    if (fallbackReason) {
+      file.extractAndTransformTasks(this.getConfig())
+      emitParserDiagnostic(this, file, {
+        mode: 'legacy-fallback',
+        reason: fallbackReason,
+      })
 
-    if (!file.isModified() || fileContent === file.content) {
       this.resetFile(file)
-      const totalTime = Date.now() - extractStartTime
-      logger.debug(`[INSTRUMENT] extractTasks END (no changes) - total ${totalTime}ms`)
+      const fallbackTotalTime = Date.now() - extractStartTime
+      logger.debug(`[INSTRUMENT] extractTasks END (legacy-fallback) - total ${fallbackTotalTime}ms`)
       return file
     }
 
-    logger.debug(`[INSTRUMENT] About to call file.extractTasks`)
-    file.extractTasks(this.getConfig())
-
-    const extractTime = Date.now()
-    logger.debug(`[INSTRUMENT] file.extractTasks took ${extractTime - transformTime}ms`)
+    const fileContent = file.content
+    attachStreamTasks({ file, streamTasks, config: this.getConfig() })
+    file.transformTasks(this.getConfig())
+    emitParserDiagnostic(this, file, {
+      mode: 'stream',
+    })
 
-    if (file.modified) {
-      logger.debug(`[INSTRUMENT] About to writeFile`)
+    if (file.isModified() && fileContent !== file.content) {
+      logger.debug('[INSTRUMENT] About to writeFile (stream re-extract flow)')
       await this.writeFile(file)
-      logger.debug(`[INSTRUMENT] writeFile took ${Date.now() - extractTime}ms`)
+      file.extractTasks(this.getConfig())
     }
 
     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`)
-
+    const streamTotalTime = Date.now() - extractStartTime
+    logger.debug(`[INSTRUMENT] extractTasks END (stream) - total ${streamTotalTime}ms`)
     return file
   }
 

package/lib/utils/module-import.js

@@ -1,5 +1,31 @@
 import { pathToFileURL } from 'node:url'
 
+const WINDOWS_DRIVE_PATH = /^[a-zA-Z]:[\\/]/
+const WINDOWS_UNC_PATH = /^\\\\[^\\]+\\[^\\]+/
+
 export function toFileImportSpecifier(filePath) {
+  const value = String(filePath)
+  if (/^(file|data|node):/i.test(value)) return value
+  if (WINDOWS_DRIVE_PATH.test(value)) return windowsDrivePathToFileURL(value)
+  if (WINDOWS_UNC_PATH.test(value)) return windowsUncPathToFileURL(value)
+
   return pathToFileURL(filePath).href
 }
+
+function windowsDrivePathToFileURL(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, '/')
+  return `file:///${encodePathSegments(normalizedPath)}`
+}
+
+function windowsUncPathToFileURL(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, '/').replace(/^\/+/, '')
+  const [host, ...pathSegments] = normalizedPath.split('/')
+  return `file://${host}/${pathSegments.map(encodeURIComponent).join('/')}`
+}
+
+function encodePathSegments(filePath) {
+  return filePath
+    .split('/')
+    .map(segment => /^[a-zA-Z]:$/.test(segment) ? segment : encodeURIComponent(segment))
+    .join('/')
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imdone-core",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "imdone-core",
   "repository": {
     "type": "git",
@@ -10,10 +10,10 @@
   "types": "types/index.d.ts",
   "type": "module",
   "bin": {
-    "imdone-cli": "lib/cli.js"
+    "imdone-core": "lib/cli.js"
   },
   "scripts": {
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "node scripts/prepublish-only.js",
     "build": "npm run pre-commit && npm run coverage",
     "build:docs": "doctoc --github --notitle README.md",
     "build:docs:index": "node scripts/index-markdown.js",

package/scripts/prepublish-only.js

@@ -0,0 +1,30 @@
+import { spawn } from 'node:child_process'
+
+const TRUE_VALUES = new Set(['1', 'true', 'yes', 'on'])
+
+function isTruthy(value) {
+  return TRUE_VALUES.has(String(value || '').toLowerCase())
+}
+
+function shouldSkipPrepublishOnly() {
+  return isTruthy(process.env.NO_PREPUBLISH)
+}
+
+if (shouldSkipPrepublishOnly()) {
+  console.log('Skipping prepublishOnly because skip prepublish override is enabled.')
+  process.exit(0)
+}
+
+const build = spawn('npm', ['run', 'build'], {
+  stdio: 'inherit',
+  shell: process.platform === 'win32',
+})
+
+build.on('exit', (code) => {
+  process.exit(code ?? 1)
+})
+
+build.on('error', (error) => {
+  console.error(`Unable to run prepublishOnly build: ${error.message}`)
+  process.exit(1)
+})

package/types/adapters/parsers/file/ReadStreamCodeParser.d.ts

@@ -3,11 +3,9 @@ export class ReadStreamCodeParser extends ReadStreamTaskParser {
     lists: any;
     filePath: any;
     lang: any;
-    taskParsers: CodeStyleTaskParser[];
     init(): Promise<void>;
     cards: any[] | undefined;
-    parseCards(code: any, tokens?: string[]): any[];
-    parseComments(code: any): any;
+    parseCards(tokens?: string[]): Promise<any[]>;
+    parseComments(): Promise<{}>;
 }
 import { ReadStreamTaskParser } from './ReadStreamTaskParser.js';
-import { CodeStyleTaskParser } from '../task/CodeStyleTaskParser.js';

package/types/adapters/parsers/file/ReadStreamMarkdownParser.d.ts

@@ -1,6 +1,17 @@
 export class ReadStreamMarkdownParser extends ReadStreamTaskParser {
     constructor(readStream: any, config: any);
+    frontmatterLines: any[];
+    collectingFrontmatter: boolean;
+    frontmatterClosed: boolean;
+    ignoredByFrontmatter: boolean;
+    currentLineIsFrontmatter: boolean;
+    currentLineIsCodeFence: boolean;
+    inCodeFence: boolean;
     taskParsers: (HashStyleTaskParser | MarkdownStyleTaskParser)[];
+    onLineRead(line: any): void;
+    updateFrontmatterState(line: any): void;
+    updateIgnoredByFrontmatter(): void;
+    updateCodeFenceState(line: any): void;
 }
 import { ReadStreamTaskParser } from './ReadStreamTaskParser.js';
 import { HashStyleTaskParser } from '../task/HashStyleTaskParser.js';

package/types/adapters/parsers/file/ReadStreamTaskParser.d.ts

@@ -7,10 +7,14 @@ export class ReadStreamTaskParser {
     lineNo: number;
     blankLines: number;
     readInterface: ReadLine.Interface;
+    lineIterator: NodeJS.AsyncIterator<string, any, any>;
     readTask(): Promise<any>;
+    nextTask: any;
     readLine(): Promise<IteratorResult<string, any>>;
+    onLineRead(): void;
+    shouldParseTaskLine(): boolean;
+    getLineForTaskParsing(line: any): any;
     isEndOfTask(line: any): boolean;
-    nextTask: any;
     getTaskFromLine(line: any): undefined;
     addLineToTask(line: any): void;
     trimLinesToEndTask(): void;

package/types/adapters/parsers/task/CheckStyleTaskParser.d.ts

@@ -1,9 +1,10 @@
 export class CheckStyleTaskParser extends TaskParser {
-    constructor();
+    constructor(config: any);
     get pattern(): RegExp;
     parse(lineContent: any, line: any, matchResult: any, task: any): {
         beforeText: any;
         text: any;
+        list: any;
         line: any;
         checked: any;
         type: any;

package/types/adapters/parsers/task/TaskParser.d.ts

@@ -3,5 +3,5 @@ export class TaskParser {
     config: any;
     type: any;
     get pattern(): void;
-    parseLine(lineContent: any, line: any, task: any): any;
+    parseLine(lineContent: any, line: any, task: any, originalLineContent?: any): any;
 }