@peaske7/readit 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,1040 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli/index.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import * as fs2 from "fs/promises";
-import * as os3 from "os";
-import { join as join4, resolve as resolve3 } from "path";
-import { Command } from "commander";
-import open from "open";
-
-// src/lib/comment-storage.ts
-import * as crypto from "crypto";
-import * as os from "os";
-import * as path from "path";
-var FORMAT_VERSION = 1;
-var HASH_LENGTH = 16;
-var MAX_SELECTION_LENGTH = 1e3;
-var TRUNCATION_MARKER = "\n...\n";
-var ANCHOR_PREFIX_LENGTH = 200;
-function truncateSelection(text) {
-  if (text.length <= MAX_SELECTION_LENGTH) {
-    return text;
-  }
-  const half = Math.floor(
-    (MAX_SELECTION_LENGTH - TRUNCATION_MARKER.length) / 2
-  );
-  return text.slice(0, half) + TRUNCATION_MARKER + text.slice(-half);
-}
-function getCommentPath(sourcePath) {
-  const absolute = path.resolve(sourcePath);
-  const normalized = absolute.replace(/^\//, "").replace(/^[A-Z]:[\\/]/, "");
-  const ext = path.extname(normalized);
-  const withoutExt = normalized.slice(0, -ext.length || void 0);
-  return path.join(
-    os.homedir(),
-    ".readit",
-    "comments",
-    `${withoutExt}.comments.md`
-  );
-}
-function computeHash(content) {
-  return crypto.createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH);
-}
-function getLineNumber(content, offset) {
-  if (offset <= 0 || content.length === 0) return 1;
-  const clampedOffset = Math.min(offset, content.length);
-  return content.slice(0, clampedOffset).split("\n").length;
-}
-function getLineHint(content, startOffset, endOffset) {
-  const startLine = getLineNumber(content, startOffset);
-  const endLine = getLineNumber(content, endOffset);
-  return startLine === endLine ? `L${startLine}` : `L${startLine}-${endLine}`;
-}
-function parseCommentFile(content) {
-  const result = {
-    source: "",
-    hash: "",
-    version: FORMAT_VERSION,
-    comments: []
-  };
-  if (!content.trim()) {
-    return result;
-  }
-  const frontMatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (frontMatterMatch) {
-    const frontMatter = frontMatterMatch[1];
-    const sourceMatch = frontMatter.match(/^source:\s*(.+)$/m);
-    const hashMatch = frontMatter.match(/^hash:\s*(.+)$/m);
-    const versionMatch = frontMatter.match(/^version:\s*(\d+)$/m);
-    if (sourceMatch) result.source = sourceMatch[1].trim();
-    if (hashMatch) result.hash = hashMatch[1].trim();
-    if (versionMatch) result.version = Number.parseInt(versionMatch[1], 10);
-    if (result.version > FORMAT_VERSION) {
-      throw new Error(
-        `Comment file requires readit v${result.version} or higher. Current version supports format v${FORMAT_VERSION}.`
-      );
-    }
-  }
-  const bodyContent = content.replace(/^---\n[\s\S]*?\n---\n*/, "");
-  const blocks = bodyContent.split(/\n---\n/).filter((block) => block.trim());
-  for (const block of blocks) {
-    const comment = parseCommentBlock(block);
-    if (comment) {
-      result.comments.push(comment);
-    }
-  }
-  return result;
-}
-function parseCommentBlock(block) {
-  const metadataMatch = block.match(/<!--\s*c:([^|]+)\|([^|]+)\|([^>]+)\s*-->/);
-  if (!metadataMatch) {
-    return void 0;
-  }
-  const [, id, lineHint, createdAt] = metadataMatch;
-  const anchorMatch = block.match(/<!--\s*anchor:(.+?)\s*-->/);
-  const anchorPrefix = anchorMatch ? anchorMatch[1] : void 0;
-  const blockquoteMatch = block.match(/^>\s*(.+(?:\n>\s*.+)*)$/m);
-  if (!blockquoteMatch) {
-    return void 0;
-  }
-  const selectedText = blockquoteMatch[1].split("\n").map((line) => line.replace(/^>\s*/, "")).join("\n");
-  const afterBlockquote = block.slice(
-    block.indexOf(blockquoteMatch[0]) + blockquoteMatch[0].length
-  );
-  const commentBody = afterBlockquote.trim();
-  return {
-    id,
-    selectedText,
-    comment: commentBody,
-    createdAt: createdAt.trim(),
-    lineHint,
-    anchorPrefix,
-    // Offsets will be resolved by anchor matching when loading
-    startOffset: 0,
-    endOffset: 0
-  };
-}
-function serializeComments(file) {
-  const lines = [];
-  lines.push("---");
-  lines.push(`source: ${file.source}`);
-  lines.push(`hash: ${file.hash}`);
-  lines.push(`version: ${file.version}`);
-  lines.push("---");
-  lines.push("");
-  for (const comment of file.comments) {
-    lines.push(serializeComment(comment));
-    lines.push("");
-    lines.push("---");
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function serializeComment(comment) {
-  const lines = [];
-  const lineHint = comment.lineHint || "L0";
-  lines.push(`<!-- c:${comment.id}|${lineHint}|${comment.createdAt} -->`);
-  if (comment.anchorPrefix) {
-    lines.push(`<!-- anchor:${comment.anchorPrefix} -->`);
-  }
-  const quotedLines = comment.selectedText.split("\n").map((line) => `> ${line}`);
-  lines.push(...quotedLines);
-  if (comment.comment) {
-    lines.push("");
-    lines.push(comment.comment);
-  }
-  return lines.join("\n");
-}
-function createComment(selectedText, commentText, startOffset, endOffset, sourceContent) {
-  const id = crypto.randomUUID().slice(0, 8);
-  const lineHint = getLineHint(sourceContent, startOffset, endOffset);
-  const now = /* @__PURE__ */ new Date();
-  const createdAt = now.toISOString();
-  const needsTruncation = selectedText.length > MAX_SELECTION_LENGTH;
-  return {
-    id,
-    selectedText: truncateSelection(selectedText),
-    comment: commentText,
-    createdAt,
-    startOffset,
-    endOffset,
-    lineHint,
-    // Store first N chars for anchor matching when text is truncated
-    anchorPrefix: needsTruncation ? selectedText.slice(0, ANCHOR_PREFIX_LENGTH) : void 0
-  };
-}
-
-// src/server/index.ts
-import { watch } from "fs";
-import * as fs from "fs/promises";
-import * as os2 from "os";
-import * as path2 from "path";
-import { basename, dirname, join as join3 } from "path";
-import { fileURLToPath } from "url";
-import express from "express";
-
-// src/types/index.ts
-var AnchorConfidences = {
-  EXACT: "exact",
-  NORMALIZED: "normalized",
-  FUZZY: "fuzzy",
-  UNRESOLVED: "unresolved"
-};
-var FontFamilies = {
-  SERIF: "serif",
-  SANS_SERIF: "sans-serif"
-};
-
-// src/lib/anchor.ts
-var DEFAULT_SEARCH_WINDOW = 500;
-var DEFAULT_FUZZY_THRESHOLD = 5;
-var MAX_FUZZY_TEXT_LENGTH = 200;
-var FUZZY_SEARCH_WINDOW = 2e3;
-function normalizeWhitespace(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function levenshteinDistance(a, b, maxDistance) {
-  if (a.length > b.length) {
-    [a, b] = [b, a];
-  }
-  const m = a.length;
-  const n = b.length;
-  if (m === 0) return n;
-  if (n === 0) return m;
-  if (maxDistance !== void 0 && Math.abs(m - n) > maxDistance) {
-    return Number.POSITIVE_INFINITY;
-  }
-  let prevRow = new Array(m + 1);
-  let currRow = new Array(m + 1);
-  for (let i = 0; i <= m; i++) {
-    prevRow[i] = i;
-  }
-  for (let j = 1; j <= n; j++) {
-    currRow[0] = j;
-    let rowMin = currRow[0];
-    for (let i = 1; i <= m; i++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      currRow[i] = Math.min(
-        prevRow[i] + 1,
-        // deletion
-        currRow[i - 1] + 1,
-        // insertion
-        prevRow[i - 1] + cost
-        // substitution
-      );
-      rowMin = Math.min(rowMin, currRow[i]);
-    }
-    if (maxDistance !== void 0 && rowMin > maxDistance) {
-      return Number.POSITIVE_INFINITY;
-    }
-    [prevRow, currRow] = [currRow, prevRow];
-  }
-  return prevRow[m];
-}
-function getLineOffset(content, lineNumber) {
-  if (lineNumber <= 1) return 0;
-  let currentLine = 1;
-  for (let i = 0; i < content.length; i++) {
-    if (content[i] === "\n") {
-      currentLine++;
-      if (currentLine === lineNumber) {
-        return i + 1;
-      }
-    }
-  }
-  return content.length;
-}
-function parseLineHint(lineHint) {
-  const match = lineHint.match(/^L(\d+)(?:-(\d+))?$/);
-  if (!match) {
-    return { start: 1, end: 1 };
-  }
-  const start = Number.parseInt(match[1], 10);
-  const end = match[2] ? Number.parseInt(match[2], 10) : start;
-  return { start, end };
-}
-function findAnchor({
-  source,
-  selectedText,
-  lineHint,
-  searchWindow = DEFAULT_SEARCH_WINDOW
-}) {
-  if (!selectedText || !source) {
-    return void 0;
-  }
-  const { start: hintLine } = parseLineHint(lineHint);
-  const lineOffset = getLineOffset(source, hintLine);
-  const windowStart = Math.max(0, lineOffset - searchWindow);
-  const windowEnd = Math.min(source.length, lineOffset + searchWindow);
-  const window = source.slice(windowStart, windowEnd);
-  const localIndex = window.indexOf(selectedText);
-  if (localIndex !== -1) {
-    const start = windowStart + localIndex;
-    const end = start + selectedText.length;
-    return {
-      start,
-      end,
-      line: getLineNumber(source, start),
-      confidence: AnchorConfidences.EXACT
-    };
-  }
-  const globalIndex = source.indexOf(selectedText);
-  if (globalIndex !== -1) {
-    return {
-      start: globalIndex,
-      end: globalIndex + selectedText.length,
-      line: getLineNumber(source, globalIndex),
-      confidence: AnchorConfidences.EXACT
-    };
-  }
-  return void 0;
-}
-function buildNormalizedPositionMap(text) {
-  const toOriginal = [];
-  let normalized = "";
-  let inWhitespace = false;
-  for (let i = 0; i < text.length; i++) {
-    const char = text[i];
-    const isSpace = /\s/.test(char);
-    if (isSpace) {
-      if (!inWhitespace && normalized.length > 0) {
-        normalized += " ";
-        toOriginal.push(i);
-      }
-      inWhitespace = true;
-    } else {
-      normalized += char;
-      toOriginal.push(i);
-      inWhitespace = false;
-    }
-  }
-  if (normalized.endsWith(" ")) {
-    normalized = normalized.slice(0, -1);
-    toOriginal.pop();
-  }
-  return { normalized, toOriginal };
-}
-function findAnchorNormalized({
-  source,
-  selectedText,
-  lineHint,
-  searchWindow = FUZZY_SEARCH_WINDOW
-}) {
-  if (!selectedText || !source) {
-    return void 0;
-  }
-  const normalizedText = normalizeWhitespace(selectedText);
-  if (!normalizedText) {
-    return void 0;
-  }
-  if (normalizedText === selectedText) {
-    return void 0;
-  }
-  const { start: hintLine } = parseLineHint(lineHint);
-  const lineOffset = getLineOffset(source, hintLine);
-  const windowStart = Math.max(0, lineOffset - searchWindow);
-  const windowEnd = Math.min(source.length, lineOffset + searchWindow);
-  const window = source.slice(windowStart, windowEnd);
-  const { normalized: normalizedWindow, toOriginal } = buildNormalizedPositionMap(window);
-  const normalizedIndex = normalizedWindow.indexOf(normalizedText);
-  if (normalizedIndex !== -1) {
-    const originalStart = windowStart + toOriginal[normalizedIndex];
-    const endNormIndex = normalizedIndex + normalizedText.length - 1;
-    let originalEnd = windowStart + toOriginal[endNormIndex] + 1;
-    while (originalEnd < source.length && /\s/.test(source[originalEnd])) {
-      originalEnd++;
-    }
-    return {
-      start: originalStart,
-      end: originalEnd,
-      line: getLineNumber(source, originalStart),
-      confidence: AnchorConfidences.NORMALIZED
-    };
-  }
-  const { normalized: fullNormalized, toOriginal: fullToOriginal } = buildNormalizedPositionMap(source);
-  const globalIndex = fullNormalized.indexOf(normalizedText);
-  if (globalIndex !== -1) {
-    const originalStart = fullToOriginal[globalIndex];
-    const endNormIndex = globalIndex + normalizedText.length - 1;
-    let originalEnd = fullToOriginal[endNormIndex] + 1;
-    while (originalEnd < source.length && /\s/.test(source[originalEnd])) {
-      originalEnd++;
-    }
-    return {
-      start: originalStart,
-      end: originalEnd,
-      line: getLineNumber(source, originalStart),
-      confidence: AnchorConfidences.NORMALIZED
-    };
-  }
-  return void 0;
-}
-function findAnchorFuzzy({
-  source,
-  selectedText,
-  lineHint,
-  threshold = DEFAULT_FUZZY_THRESHOLD
-}) {
-  if (!selectedText || !source) {
-    return void 0;
-  }
-  const textLen = selectedText.length;
-  if (textLen > MAX_FUZZY_TEXT_LENGTH) {
-    return void 0;
-  }
-  let bestMatch;
-  let bestDistance = threshold + 1;
-  let searchStart = 0;
-  let searchEnd = source.length;
-  if (lineHint) {
-    const { start: hintLine } = parseLineHint(lineHint);
-    const lineOffset = getLineOffset(source, hintLine);
-    searchStart = Math.max(0, lineOffset - FUZZY_SEARCH_WINDOW);
-    searchEnd = Math.min(source.length, lineOffset + FUZZY_SEARCH_WINDOW);
-  }
-  const minLen = Math.max(1, textLen - threshold);
-  const maxLen = textLen + threshold;
-  for (let len = minLen; len <= maxLen; len++) {
-    for (let i = searchStart; i <= searchEnd - len; i++) {
-      const candidate = source.slice(i, i + len);
-      const distance = levenshteinDistance(
-        selectedText,
-        candidate,
-        bestDistance - 1
-      );
-      if (distance < bestDistance) {
-        bestDistance = distance;
-        bestMatch = {
-          start: i,
-          end: i + len,
-          line: getLineNumber(source, i),
-          confidence: AnchorConfidences.FUZZY,
-          distance
-        };
-        if (distance === 0) {
-          return bestMatch;
-        }
-      }
-    }
-  }
-  return bestMatch;
-}
-function findAnchorWithFallback({
-  source,
-  selectedText,
-  lineHint,
-  fuzzyThreshold
-}) {
-  const exactMatch = findAnchor({ source, selectedText, lineHint });
-  if (exactMatch) {
-    return exactMatch;
-  }
-  const normalizedMatch = findAnchorNormalized({
-    source,
-    selectedText,
-    lineHint
-  });
-  if (normalizedMatch) {
-    return normalizedMatch;
-  }
-  return findAnchorFuzzy({
-    source,
-    selectedText,
-    lineHint,
-    threshold: fuzzyThreshold
-  });
-}
-
-// src/server/index.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function isErrnoException(err) {
-  return err instanceof Error && "code" in err;
-}
-async function readCommentsFromFile(filePath, sourceContent) {
-  const commentPath = getCommentPath(filePath);
-  try {
-    const content = await fs.readFile(commentPath, "utf-8");
-    const file = parseCommentFile(content);
-    return file.comments.map((comment) => {
-      const textForMatching = comment.anchorPrefix || comment.selectedText;
-      const anchor = findAnchorWithFallback({
-        source: sourceContent,
-        selectedText: textForMatching,
-        lineHint: comment.lineHint || "L1"
-      });
-      if (anchor) {
-        return {
-          ...comment,
-          startOffset: anchor.start,
-          endOffset: anchor.end,
-          lineHint: `L${anchor.line}`,
-          anchorConfidence: anchor.confidence
-        };
-      }
-      return {
-        ...comment,
-        anchorConfidence: AnchorConfidences.UNRESOLVED
-      };
-    });
-  } catch (err) {
-    if (isErrnoException(err) && err.code === "ENOENT") {
-      return [];
-    }
-    throw err;
-  }
-}
-async function writeCommentsToFile(filePath, sourceContent, comments) {
-  const commentPath = getCommentPath(filePath);
-  const commentDir = dirname(commentPath);
-  await fs.mkdir(commentDir, { recursive: true });
-  const file = {
-    source: filePath,
-    hash: computeHash(sourceContent),
-    version: 1,
-    comments
-  };
-  const content = serializeComments(file);
-  const tempPath = `${commentPath}.tmp`;
-  await fs.writeFile(tempPath, content, "utf-8");
-  await fs.rename(tempPath, commentPath);
-}
-async function deleteCommentFile(filePath) {
-  const commentPath = getCommentPath(filePath);
-  try {
-    await fs.unlink(commentPath);
-  } catch (err) {
-    if (!isErrnoException(err) || err.code !== "ENOENT") {
-      throw err;
-    }
-  }
-}
-function getSettingsPath(sourcePath) {
-  const absolute = path2.resolve(sourcePath);
-  const normalized = absolute.replace(/^\//, "").replace(/^[A-Z]:[\\/]/, "");
-  return path2.join(
-    os2.homedir(),
-    ".readit",
-    "settings",
-    `${normalized}.settings.json`
-  );
-}
-var DEFAULT_SETTINGS = {
-  version: 1,
-  fontFamily: FontFamilies.SERIF
-};
-async function readSettingsFromFile(filePath) {
-  const settingsPath = getSettingsPath(filePath);
-  try {
-    const content = await fs.readFile(settingsPath, "utf-8");
-    return JSON.parse(content);
-  } catch (err) {
-    if (isErrnoException(err) && err.code === "ENOENT") {
-      return DEFAULT_SETTINGS;
-    }
-    throw err;
-  }
-}
-async function writeSettingsToFile(filePath, settings) {
-  const settingsPath = getSettingsPath(filePath);
-  const settingsDir = dirname(settingsPath);
-  await fs.mkdir(settingsDir, { recursive: true });
-  const tempPath = `${settingsPath}.tmp`;
-  await fs.writeFile(tempPath, JSON.stringify(settings, null, 2), "utf-8");
-  await fs.rename(tempPath, settingsPath);
-}
-function isValidFontFamily(value) {
-  return value === FontFamilies.SERIF || value === FontFamilies.SANS_SERIF;
-}
-async function handleGetComments(ctx, res) {
-  try {
-    const comments = await readCommentsFromFile(
-      ctx.filePath,
-      ctx.getCurrentContent()
-    );
-    res.json({ comments });
-  } catch (err) {
-    console.error("Failed to read comments:", err);
-    res.status(500).json({ error: "Failed to read comments" });
-  }
-}
-async function handleAddComment(ctx, req, res) {
-  try {
-    const {
-      selectedText,
-      comment: commentText,
-      startOffset,
-      endOffset
-    } = req.body;
-    if (!selectedText || typeof commentText !== "string" || startOffset === void 0 || endOffset === void 0) {
-      res.status(400).json({ error: "Missing required fields" });
-      return;
-    }
-    const currentContent = ctx.getCurrentContent();
-    const newComment = createComment(
-      selectedText,
-      commentText,
-      startOffset,
-      endOffset,
-      currentContent
-    );
-    const existingComments = await readCommentsFromFile(
-      ctx.filePath,
-      currentContent
-    );
-    const allComments = [...existingComments, newComment];
-    await writeCommentsToFile(ctx.filePath, currentContent, allComments);
-    res.status(201).json({ comment: newComment });
-  } catch (err) {
-    console.error("Failed to add comment:", err);
-    res.status(500).json({ error: "Failed to add comment" });
-  }
-}
-async function handleUpdateComment(ctx, req, res) {
-  try {
-    const { id } = req.params;
-    const { comment: commentText } = req.body;
-    if (typeof commentText !== "string") {
-      res.status(400).json({ error: "Missing comment text" });
-      return;
-    }
-    const currentContent = ctx.getCurrentContent();
-    const existingComments = await readCommentsFromFile(
-      ctx.filePath,
-      currentContent
-    );
-    const commentIndex = existingComments.findIndex((c) => c.id === id);
-    if (commentIndex === -1) {
-      res.status(404).json({ error: "Comment not found" });
-      return;
-    }
-    const updatedComments = existingComments.map(
-      (c, i) => i === commentIndex ? { ...c, comment: commentText.trim() } : c
-    );
-    await writeCommentsToFile(ctx.filePath, currentContent, updatedComments);
-    res.json({ comment: updatedComments[commentIndex] });
-  } catch (err) {
-    console.error("Failed to update comment:", err);
-    res.status(500).json({ error: "Failed to update comment" });
-  }
-}
-async function handleDeleteComment(ctx, req, res) {
-  try {
-    const { id } = req.params;
-    const currentContent = ctx.getCurrentContent();
-    const existingComments = await readCommentsFromFile(
-      ctx.filePath,
-      currentContent
-    );
-    const filteredComments = existingComments.filter((c) => c.id !== id);
-    if (filteredComments.length === existingComments.length) {
-      res.status(404).json({ error: "Comment not found" });
-      return;
-    }
-    if (filteredComments.length === 0) {
-      await deleteCommentFile(ctx.filePath);
-    } else {
-      await writeCommentsToFile(ctx.filePath, currentContent, filteredComments);
-    }
-    res.json({ success: true });
-  } catch (err) {
-    console.error("Failed to delete comment:", err);
-    res.status(500).json({ error: "Failed to delete comment" });
-  }
-}
-async function handleClearComments(ctx, res) {
-  try {
-    await deleteCommentFile(ctx.filePath);
-    res.json({ success: true });
-  } catch (err) {
-    console.error("Failed to clear comments:", err);
-    res.status(500).json({ error: "Failed to clear comments" });
-  }
-}
-async function handleGetRawComments(ctx, res) {
-  const commentPath = getCommentPath(ctx.filePath);
-  try {
-    const content = await fs.readFile(commentPath, "utf-8");
-    res.json({ content, path: commentPath });
-  } catch (err) {
-    if (isErrnoException(err) && err.code === "ENOENT") {
-      res.json({ content: null, path: commentPath });
-      return;
-    }
-    console.error("Failed to read raw comments:", err);
-    res.status(500).json({ error: "Failed to read raw comments" });
-  }
-}
-async function handleReanchorComment(ctx, req, res) {
-  try {
-    const { id } = req.params;
-    const { selectedText, startOffset, endOffset } = req.body;
-    if (!selectedText || startOffset === void 0 || endOffset === void 0) {
-      res.status(400).json({ error: "Missing required fields" });
-      return;
-    }
-    const currentContent = ctx.getCurrentContent();
-    const existingComments = await readCommentsFromFile(
-      ctx.filePath,
-      currentContent
-    );
-    const commentIndex = existingComments.findIndex((c) => c.id === id);
-    if (commentIndex === -1) {
-      res.status(404).json({ error: "Comment not found" });
-      return;
-    }
-    const lineHint = getLineHint(currentContent, startOffset, endOffset);
-    const truncatedText = truncateSelection(selectedText);
-    const updatedComment = {
-      ...existingComments[commentIndex],
-      selectedText: truncatedText,
-      startOffset,
-      endOffset,
-      lineHint,
-      anchorConfidence: AnchorConfidences.EXACT,
-      // Store anchor prefix for future matching if text was truncated
-      anchorPrefix: selectedText.length > 1e3 ? selectedText.slice(0, 200) : void 0
-    };
-    const updatedComments = existingComments.map(
-      (c, i) => i === commentIndex ? updatedComment : c
-    );
-    await writeCommentsToFile(ctx.filePath, currentContent, updatedComments);
-    res.json({ comment: updatedComment });
-  } catch (err) {
-    console.error("Failed to re-anchor comment:", err);
-    res.status(500).json({ error: "Failed to re-anchor comment" });
-  }
-}
-function createApp(options) {
-  const app = express();
-  let currentContent = options.content;
-  const documentStreamClients = /* @__PURE__ */ new Set();
-  let debounceTimer = null;
-  let watcher = null;
-  try {
-    watcher = watch(options.filePath, async (eventType) => {
-      if (eventType !== "change") return;
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(async () => {
-        try {
-          const newContent = await fs.readFile(options.filePath, "utf-8");
-          if (newContent !== currentContent) {
-            currentContent = newContent;
-            console.log("File changed, notifying clients...");
-            for (const client of documentStreamClients) {
-              client.write("data: update\n\n");
-            }
-          }
-        } catch (err) {
-          console.error("Failed to read updated file:", err);
-        }
-      }, 100);
-    });
-  } catch (err) {
-    console.warn("File watching not available:", err);
-  }
-  app.use(express.json());
-  const isDev = process.env.NODE_ENV === "development";
-  if (isDev) {
-    app.get("/", (_req, res) => {
-      res.redirect("http://localhost:5173");
-    });
-  } else {
-    const distPath = __dirname;
-    app.use(express.static(distPath));
-    app.get("/{*path}", (req, res, next) => {
-      if (req.path.startsWith("/api")) {
-        return next();
-      }
-      res.sendFile(join3(distPath, "index.html"));
-    });
-  }
-  app.get("/api/document", (_req, res) => {
-    res.json({
-      content: currentContent,
-      type: options.type,
-      filePath: options.filePath,
-      fileName: basename(options.filePath),
-      clean: options.clean || false
-    });
-  });
-  app.get("/api/document/stream", (req, res) => {
-    res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    });
-    res.write("data: connected\n\n");
-    documentStreamClients.add(res);
-    req.on("close", () => {
-      documentStreamClients.delete(res);
-    });
-  });
-  app.get("/api/health", (_req, res) => {
-    res.json({ status: "ok" });
-  });
-  const ctx = {
-    filePath: options.filePath,
-    getCurrentContent: () => currentContent
-  };
-  app.get("/api/comments", (_req, res) => handleGetComments(ctx, res));
-  app.get("/api/comments/raw", (_req, res) => handleGetRawComments(ctx, res));
-  app.post("/api/comments", (req, res) => handleAddComment(ctx, req, res));
-  app.put(
-    "/api/comments/:id",
-    (req, res) => handleUpdateComment(ctx, req, res)
-  );
-  app.put(
-    "/api/comments/:id/reanchor",
-    (req, res) => handleReanchorComment(ctx, req, res)
-  );
-  app.delete(
-    "/api/comments/:id",
-    (req, res) => handleDeleteComment(ctx, req, res)
-  );
-  app.delete("/api/comments", (_req, res) => handleClearComments(ctx, res));
-  app.get("/api/settings", async (_req, res) => {
-    try {
-      const settings = await readSettingsFromFile(ctx.filePath);
-      res.json(settings);
-    } catch (err) {
-      console.error("Failed to read settings:", err);
-      res.status(500).json({ error: "Failed to read settings" });
-    }
-  });
-  app.put("/api/settings", async (req, res) => {
-    try {
-      const { fontFamily } = req.body;
-      if (!isValidFontFamily(fontFamily)) {
-        res.status(400).json({ error: "Invalid font family" });
-        return;
-      }
-      const settings = {
-        version: 1,
-        fontFamily
-      };
-      await writeSettingsToFile(ctx.filePath, settings);
-      res.json(settings);
-    } catch (err) {
-      console.error("Failed to save settings:", err);
-      res.status(500).json({ error: "Failed to save settings" });
-    }
-  });
-  app.get("/api/heartbeat", (req, res) => {
-    res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    });
-    res.write("data: connected\n\n");
-    const interval = setInterval(() => {
-      res.write("data: ping\n\n");
-    }, 5e3);
-    req.on("close", () => {
-      clearInterval(interval);
-      if (isDev) return;
-      setTimeout(() => {
-        console.log("\nBrowser disconnected, shutting down...");
-        process.exit(0);
-      }, 100);
-    });
-  });
-  return { app, watcher };
-}
-function tryListenOnPort(app, port, host) {
-  return new Promise((resolve4, reject) => {
-    const server = app.listen(port, host);
-    server.on("listening", () => {
-      const displayHost = host === "0.0.0.0" ? "localhost" : host;
-      resolve4({ port, url: `http://${displayHost}:${port}`, server });
-    });
-    server.on("error", reject);
-  });
-}
-async function startServerWithFallback(app, preferredPort, host) {
-  const MAX_PORT = 65535;
-  for (let port = preferredPort; port <= MAX_PORT; port++) {
-    try {
-      return await tryListenOnPort(app, port, host);
-    } catch (err) {
-      if (err.code === "EADDRINUSE") {
-        console.log(`Port ${port} is busy, trying ${port + 1}...`);
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw new Error(`No available port found starting from ${preferredPort}`);
-}
-async function startServer(options) {
-  const { app, watcher } = createApp(options);
-  const result = await startServerWithFallback(app, options.port, options.host);
-  result.server.on("close", () => {
-    watcher?.close();
-  });
-  return result;
-}
-
-// src/cli/index.ts
-var program = new Command();
-function getFileType(filePath) {
-  if (filePath.endsWith(".md") || filePath.endsWith(".markdown")) {
-    return "markdown";
-  }
-  if (filePath.endsWith(".html") || filePath.endsWith(".htm")) {
-    return "html";
-  }
-  return null;
-}
-function isPermissionError(err) {
-  return err instanceof Error && "code" in err && err.code === "EACCES";
-}
-function findCommentFiles(dir) {
-  const results = [];
-  try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      const fullPath = join4(dir, entry);
-      try {
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-          results.push(...findCommentFiles(fullPath));
-        } else if (entry.endsWith(".comments.md")) {
-          results.push(fullPath);
-        }
-      } catch (err) {
-        if (isPermissionError(err)) {
-          console.warn(`Warning: Permission denied: ${fullPath}`);
-        }
-      }
-    }
-  } catch (err) {
-    if (isPermissionError(err)) {
-      console.warn(`Warning: Permission denied: ${dir}`);
-    }
-  }
-  return results;
-}
-program.name("readit").description("Review Markdown and HTML documents with inline comments").version("0.1.3");
-program.command("list").description("List all files with comments").action(async () => {
-  const readitDir = join4(os3.homedir(), ".readit", "comments");
-  if (!existsSync(readitDir)) {
-    console.log("No comments found.");
-    return;
-  }
-  const commentFiles = findCommentFiles(readitDir);
-  if (commentFiles.length === 0) {
-    console.log("No comments found.");
-    return;
-  }
-  console.log(`
-Found ${commentFiles.length} file(s) with comments:
-`);
-  for (const file of commentFiles) {
-    try {
-      const content = readFileSync(file, "utf-8");
-      const parsed = parseCommentFile(content);
-      const commentCount = parsed.comments.length;
-      const sourcePath = parsed.source || "(unknown source)";
-      console.log(`  ${sourcePath}`);
-      console.log(
-        `    ${commentCount} comment${commentCount !== 1 ? "s" : ""}`
-      );
-      console.log();
-    } catch {
-    }
-  }
-});
-program.command("show <file>").description("Show comments for a file").action(async (file) => {
-  const filePath = resolve3(process.cwd(), file);
-  const commentPath = getCommentPath(filePath);
-  if (!existsSync(commentPath)) {
-    console.log(`No comments found for: ${filePath}`);
-    return;
-  }
-  try {
-    const content = await fs2.readFile(commentPath, "utf-8");
-    const parsed = parseCommentFile(content);
-    if (parsed.comments.length === 0) {
-      console.log(`No comments found for: ${filePath}`);
-      return;
-    }
-    console.log(`
-Comments for: ${filePath}`);
-    console.log(`${"\u2500".repeat(60)}
-`);
-    for (let i = 0; i < parsed.comments.length; i++) {
-      const comment = parsed.comments[i];
-      console.log(`[${i + 1}] ${comment.lineHint || "L?"}`);
-      console.log(
-        `Selected: "${comment.selectedText.slice(0, 80)}${comment.selectedText.length > 80 ? "..." : ""}"`
-      );
-      console.log(`Comment: ${comment.comment}`);
-      console.log(`Created: ${comment.createdAt}`);
-      console.log();
-    }
-  } catch (err) {
-    console.error(
-      "error: failed to read comments:",
-      err instanceof Error ? err.message : err
-    );
-    process.exit(1);
-  }
-});
-program.argument("<file>", "Markdown or HTML file to review").option("-p, --port <number>", "Port to run server on", "4567").option("--host <address>", "Host address to bind to", "127.0.0.1").option("--no-open", "Don't automatically open browser").option("--clean", "Clear all existing comments on startup").action(
-  async (file, options) => {
-    const filePath = resolve3(process.cwd(), file);
-    if (!existsSync(filePath)) {
-      console.error(`error: file not found: ${filePath}`);
-      process.exit(1);
-    }
-    const fileType = getFileType(file);
-    if (!fileType) {
-      console.error(
-        "error: file must be a Markdown (.md, .markdown) or HTML (.html, .htm) file"
-      );
-      process.exit(1);
-    }
-    const content = readFileSync(filePath, "utf-8");
-    const preferredPort = Number.parseInt(options.port, 10);
-    if (Number.isNaN(preferredPort) || preferredPort < 1 || preferredPort > 65535) {
-      console.error(`error: invalid port number: ${options.port}`);
-      process.exit(1);
-    }
-    try {
-      const { url, server } = await startServer({
-        content,
-        type: fileType,
-        filePath,
-        port: preferredPort,
-        host: options.host,
-        clean: options.clean
-      });
-      console.log(`
-readit - Document Review Tool
-
-  File: ${filePath}
-  Type: ${fileType}
-  URL:  ${url}
-
-  Server running. Close browser tab to stop.
-  Press Ctrl+C to force stop.
-`);
-      if (options.open) {
-        open(url);
-      }
-      process.on("SIGINT", () => {
-        console.log("\n\nShutting down...");
-        server.close();
-        process.exit(0);
-      });
-    } catch (error) {
-      console.error(
-        "error: failed to start server:",
-        error instanceof Error ? error.message : error
-      );
-      process.exit(1);
-    }
-  }
-);
-program.parse();