@ncukondo/reference-manager 0.3.0 → 0.5.0

package/dist/chunks/file-watcher-B-SiUw5f.js

@@ -0,0 +1,1557 @@
+import { randomUUID, createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import { readFile, mkdir, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import * as path from "node:path";
+import { dirname } from "node:path";
+import { EventEmitter } from "node:events";
+import chokidar from "chokidar";
+function normalizeText(text) {
+  return text.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+function normalizeAuthorName(name) {
+  const normalized = normalizeText(name);
+  return normalized.slice(0, 32);
+}
+function normalizeTitleSlug(title) {
+  const normalized = normalizeText(title);
+  return normalized.slice(0, 32);
+}
+function extractAuthorName(item) {
+  if (!item.author || item.author.length === 0) {
+    return "";
+  }
+  const firstAuthor = item.author[0];
+  if (!firstAuthor) {
+    return "";
+  }
+  if (firstAuthor.family) {
+    return normalizeAuthorName(firstAuthor.family);
+  }
+  if (firstAuthor.literal) {
+    return normalizeAuthorName(firstAuthor.literal);
+  }
+  return "";
+}
+function extractYear$3(item) {
+  if (!item.issued || !item.issued["date-parts"] || item.issued["date-parts"].length === 0) {
+    return "";
+  }
+  const dateParts = item.issued["date-parts"][0];
+  if (!dateParts || dateParts.length === 0) {
+    return "";
+  }
+  const year = dateParts[0];
+  return year ? year.toString() : "";
+}
+function determineTitlePart(hasAuthor, hasYear, title) {
+  if (hasAuthor && hasYear) {
+    return "";
+  }
+  if (title) {
+    return `-${title}`;
+  }
+  if (!hasAuthor && !hasYear) {
+    return "-untitled";
+  }
+  return "";
+}
+function generateId(item) {
+  const author = extractAuthorName(item);
+  const year = extractYear$3(item);
+  const title = item.title ? normalizeTitleSlug(item.title) : "";
+  const authorPart = author || "anon";
+  const yearPart = year || "nd";
+  const titlePart = determineTitlePart(Boolean(author), Boolean(year), title);
+  return `${authorPart}-${yearPart}${titlePart}`;
+}
+function generateSuffix(index) {
+  if (index === 0) {
+    return "";
+  }
+  let suffix = "";
+  let num = index;
+  while (num > 0) {
+    num--;
+    suffix = String.fromCharCode(97 + num % 26) + suffix;
+    num = Math.floor(num / 26);
+  }
+  return suffix;
+}
+function generateIdWithCollisionCheck(item, existingIds) {
+  const baseId = generateId(item);
+  const normalizedExistingIds = existingIds.map((id) => id.toLowerCase());
+  let candidate = baseId;
+  let suffixIndex = 0;
+  while (normalizedExistingIds.includes(candidate.toLowerCase())) {
+    suffixIndex++;
+    const suffix = generateSuffix(suffixIndex);
+    candidate = `${baseId}${suffix}`;
+  }
+  return candidate;
+}
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isValidUuid(uuid) {
+  return UUID_REGEX.test(uuid);
+}
+function generateUuid() {
+  return randomUUID();
+}
+function generateTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function extractUuidFromCustom(custom) {
+  if (!custom || !custom.uuid) {
+    return null;
+  }
+  return isValidUuid(custom.uuid) ? custom.uuid : null;
+}
+function ensureUuid(custom) {
+  const existingUuid = extractUuidFromCustom(custom);
+  if (existingUuid && custom) {
+    return custom;
+  }
+  const newUuid = generateUuid();
+  return {
+    ...custom,
+    uuid: newUuid
+  };
+}
+function ensureCreatedAt(custom) {
+  if (custom.created_at) {
+    return custom;
+  }
+  if (custom.timestamp) {
+    return {
+      ...custom,
+      created_at: custom.timestamp
+    };
+  }
+  const newTimestamp = generateTimestamp();
+  return {
+    ...custom,
+    created_at: newTimestamp
+  };
+}
+function ensureTimestamp(custom) {
+  if (custom.timestamp) {
+    return custom;
+  }
+  return {
+    ...custom,
+    timestamp: custom.created_at
+  };
+}
+function ensureCustomMetadata(custom) {
+  const withUuid = ensureUuid(custom);
+  const withCreatedAt = ensureCreatedAt(withUuid);
+  const withTimestamp = ensureTimestamp(withCreatedAt);
+  return withTimestamp;
+}
+class Reference {
+  item;
+  uuid;
+  constructor(item) {
+    const customMetadata = ensureCustomMetadata(item.custom);
+    this.item = { ...item, custom: customMetadata };
+    const extractedUuid = extractUuidFromCustom(customMetadata);
+    if (!extractedUuid) {
+      throw new Error("Failed to extract UUID after ensureCustomMetadata");
+    }
+    this.uuid = extractedUuid;
+  }
+  /**
+   * Factory method to create a Reference with UUID and ID generation
+   */
+  static create(item, options) {
+    const existingIds = options?.existingIds || /* @__PURE__ */ new Set();
+    let updatedItem = item;
+    if (!item.id || item.id.trim() === "") {
+      const generatedId = generateIdWithCollisionCheck(item, Array.from(existingIds));
+      updatedItem = { ...item, id: generatedId };
+    }
+    return new Reference(updatedItem);
+  }
+  /**
+   * Get the underlying CSL-JSON item
+   */
+  getItem() {
+    return this.item;
+  }
+  /**
+   * Get the UUID (internal stable identifier)
+   */
+  getUuid() {
+    return this.uuid;
+  }
+  /**
+   * Get the ID (Pandoc citation key / BibTeX-key)
+   */
+  getId() {
+    return this.item.id;
+  }
+  /**
+   * Get the title
+   */
+  getTitle() {
+    return this.item.title;
+  }
+  /**
+   * Get the authors
+   */
+  getAuthors() {
+    return this.item.author;
+  }
+  /**
+   * Get the year from issued date
+   */
+  getYear() {
+    const issued = this.item.issued;
+    if (!issued || !issued["date-parts"] || issued["date-parts"].length === 0) {
+      return void 0;
+    }
+    const firstDate = issued["date-parts"][0];
+    return firstDate && firstDate.length > 0 ? firstDate[0] : void 0;
+  }
+  /**
+   * Get the DOI
+   */
+  getDoi() {
+    return this.item.DOI;
+  }
+  /**
+   * Get the PMID
+   */
+  getPmid() {
+    return this.item.PMID;
+  }
+  /**
+   * Get the PMCID
+   */
+  getPmcid() {
+    return this.item.PMCID;
+  }
+  /**
+   * Get the URL
+   */
+  getUrl() {
+    return this.item.URL;
+  }
+  /**
+   * Get the keyword
+   */
+  getKeyword() {
+    return this.item.keyword;
+  }
+  /**
+   * Get additional URLs from custom metadata
+   */
+  getAdditionalUrls() {
+    return this.item.custom?.additional_urls;
+  }
+  /**
+   * Get the creation timestamp from custom metadata (immutable)
+   */
+  getCreatedAt() {
+    if (!this.item.custom?.created_at) {
+      throw new Error("created_at is missing from custom metadata");
+    }
+    return this.item.custom.created_at;
+  }
+  /**
+   * Get the last modification timestamp from custom metadata
+   */
+  getTimestamp() {
+    if (!this.item.custom?.timestamp) {
+      throw new Error("timestamp is missing from custom metadata");
+    }
+    return this.item.custom.timestamp;
+  }
+  /**
+   * Update the timestamp to current time
+   * Call this whenever the reference is modified
+   */
+  touch() {
+    if (!this.item.custom) {
+      throw new Error("custom metadata is missing");
+    }
+    this.item.custom.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /**
+   * Get the type
+   */
+  getType() {
+    return this.item.type;
+  }
+}
+function computeHash(input) {
+  return createHash("sha256").update(input, "utf-8").digest("hex");
+}
+async function computeFileHash(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", (error) => reject(error));
+  });
+}
+const CslNameSchema = z.object({
+  family: z.string().optional(),
+  given: z.string().optional(),
+  literal: z.string().optional(),
+  "dropping-particle": z.string().optional(),
+  "non-dropping-particle": z.string().optional(),
+  suffix: z.string().optional()
+});
+const CslDateSchema = z.object({
+  "date-parts": z.array(z.array(z.number())).optional(),
+  raw: z.string().optional(),
+  season: z.string().optional(),
+  circa: z.boolean().optional(),
+  literal: z.string().optional()
+});
+const CslFulltextSchema = z.object({
+  pdf: z.string().optional(),
+  markdown: z.string().optional()
+});
+const CslCustomSchema = z.object({
+  uuid: z.string(),
+  created_at: z.string(),
+  timestamp: z.string(),
+  additional_urls: z.array(z.string()).optional(),
+  fulltext: CslFulltextSchema.optional(),
+  tags: z.array(z.string()).optional()
+}).passthrough();
+const CslItemSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  title: z.string().optional(),
+  author: z.array(CslNameSchema).optional(),
+  editor: z.array(CslNameSchema).optional(),
+  issued: CslDateSchema.optional(),
+  accessed: CslDateSchema.optional(),
+  "container-title": z.string().optional(),
+  volume: z.string().optional(),
+  issue: z.string().optional(),
+  page: z.string().optional(),
+  DOI: z.string().optional(),
+  PMID: z.string().optional(),
+  PMCID: z.string().optional(),
+  ISBN: z.string().optional(),
+  ISSN: z.string().optional(),
+  URL: z.string().optional(),
+  abstract: z.string().optional(),
+  publisher: z.string().optional(),
+  "publisher-place": z.string().optional(),
+  note: z.string().optional(),
+  keyword: z.array(z.string()).optional(),
+  custom: CslCustomSchema.optional()
+  // Allow additional fields
+}).passthrough();
+const CslLibrarySchema = z.array(CslItemSchema);
+function parseKeyword(keyword) {
+  if (typeof keyword !== "string") {
+    return void 0;
+  }
+  if (keyword.trim() === "") {
+    return void 0;
+  }
+  const keywords = keyword.split(";").map((k) => k.trim()).filter((k) => k !== "");
+  return keywords.length > 0 ? keywords : void 0;
+}
+async function parseCslJson(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  let rawData;
+  try {
+    rawData = JSON.parse(content);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (Array.isArray(rawData)) {
+    rawData = rawData.map((item) => {
+      if (item && typeof item === "object" && "keyword" in item) {
+        const itemWithKeyword = item;
+        return {
+          ...itemWithKeyword,
+          keyword: parseKeyword(itemWithKeyword.keyword)
+        };
+      }
+      return item;
+    });
+  }
+  const parseResult = CslLibrarySchema.safeParse(rawData);
+  if (!parseResult.success) {
+    throw new Error(`Invalid CSL-JSON structure: ${parseResult.error.message}`);
+  }
+  const library = parseResult.data;
+  const processedLibrary = library.map((item) => {
+    const updatedCustom = ensureCustomMetadata(item.custom);
+    return {
+      ...item,
+      custom: updatedCustom
+    };
+  });
+  return processedLibrary;
+}
+function serializeKeyword(keywords) {
+  if (!keywords || keywords.length === 0) {
+    return void 0;
+  }
+  return keywords.join("; ");
+}
+function serializeCslJson(library) {
+  const libraryForJson = library.map((item) => {
+    const { keyword, ...rest } = item;
+    const serializedKeyword = serializeKeyword(keyword);
+    if (serializedKeyword === void 0) {
+      return rest;
+    }
+    return {
+      ...rest,
+      keyword: serializedKeyword
+    };
+  });
+  return JSON.stringify(libraryForJson, null, 2);
+}
+async function writeCslJson(filePath, library) {
+  const dir = dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const content = serializeCslJson(library);
+  await writeFile(filePath, content, "utf-8");
+}
+class Library {
+  filePath;
+  references = [];
+  currentHash = null;
+  // Indices for fast lookup
+  uuidIndex = /* @__PURE__ */ new Map();
+  idIndex = /* @__PURE__ */ new Map();
+  doiIndex = /* @__PURE__ */ new Map();
+  pmidIndex = /* @__PURE__ */ new Map();
+  constructor(filePath, items) {
+    this.filePath = filePath;
+    for (const item of items) {
+      const ref = new Reference(item);
+      this.references.push(ref);
+      this.addToIndices(ref);
+    }
+  }
+  /**
+   * Load library from file
+   */
+  static async load(filePath) {
+    const items = await parseCslJson(filePath);
+    const library = new Library(filePath, items);
+    library.currentHash = await computeFileHash(filePath);
+    return library;
+  }
+  /**
+   * Save library to file
+   */
+  async save() {
+    const items = this.references.map((ref) => ref.getItem());
+    await writeCslJson(this.filePath, items);
+    this.currentHash = await computeFileHash(this.filePath);
+  }
+  /**
+   * Reloads the library from file if it was modified externally.
+   * Self-writes (detected via hash comparison) are skipped.
+   * @returns true if reload occurred, false if skipped (self-write detected)
+   */
+  async reload() {
+    const newHash = await computeFileHash(this.filePath);
+    if (newHash === this.currentHash) {
+      return false;
+    }
+    const items = await parseCslJson(this.filePath);
+    this.references = [];
+    this.uuidIndex.clear();
+    this.idIndex.clear();
+    this.doiIndex.clear();
+    this.pmidIndex.clear();
+    for (const item of items) {
+      const ref = new Reference(item);
+      this.references.push(ref);
+      this.addToIndices(ref);
+    }
+    this.currentHash = newHash;
+    return true;
+  }
+  /**
+   * Add a reference to the library
+   * @param item - The CSL item to add
+   * @returns The added CSL item (with generated ID and UUID)
+   */
+  async add(item) {
+    const existingIds = new Set(this.references.map((ref2) => ref2.getId()));
+    const ref = Reference.create(item, { existingIds });
+    this.references.push(ref);
+    this.addToIndices(ref);
+    return ref.getItem();
+  }
+  /**
+   * Remove a reference by citation ID or UUID.
+   * @param identifier - The citation ID or UUID of the reference to remove
+   * @param options - Remove options (byUuid to use UUID lookup)
+   * @returns Remove result with removed status and the removed item
+   */
+  async remove(identifier, options = {}) {
+    const { byUuid = false } = options;
+    const ref = byUuid ? this.uuidIndex.get(identifier) : this.idIndex.get(identifier);
+    if (!ref) {
+      return { removed: false };
+    }
+    const removedItem = ref.getItem();
+    const removed = this.removeReference(ref);
+    return { removed, removedItem };
+  }
+  /**
+   * Update a reference by citation ID or UUID.
+   * @param identifier - The citation ID or UUID of the reference to update
+   * @param updates - Partial updates to apply to the reference
+   * @param options - Update options (byUuid to use UUID lookup, onIdCollision for collision handling)
+   * @returns Update result with updated item, success status, and any ID changes
+   */
+  async update(identifier, updates, options = {}) {
+    const { byUuid = false, ...updateOptions } = options;
+    const ref = byUuid ? this.uuidIndex.get(identifier) : this.idIndex.get(identifier);
+    if (!ref) {
+      return { updated: false };
+    }
+    return this.updateReference(ref, updates, updateOptions);
+  }
+  /**
+   * Find a reference by citation ID or UUID.
+   * @param identifier - The citation ID or UUID of the reference to find
+   * @param options - Find options (byUuid to use UUID lookup)
+   * @returns The CSL item if found, undefined otherwise
+   */
+  async find(identifier, options = {}) {
+    const { byUuid = false } = options;
+    const ref = byUuid ? this.uuidIndex.get(identifier) : this.idIndex.get(identifier);
+    return ref?.getItem();
+  }
+  /**
+   * Find a reference by DOI
+   */
+  findByDoi(doi) {
+    return this.doiIndex.get(doi);
+  }
+  /**
+   * Find a reference by PMID
+   */
+  findByPmid(pmid) {
+    return this.pmidIndex.get(pmid);
+  }
+  /**
+   * Get all references
+   */
+  async getAll() {
+    return this.references.map((ref) => ref.getItem());
+  }
+  /**
+   * Get the file path
+   */
+  getFilePath() {
+    return this.filePath;
+  }
+  /**
+   * Get the current file hash
+   * Returns null if the library has not been loaded or saved yet
+   */
+  getCurrentHash() {
+    return this.currentHash;
+  }
+  /**
+   * Add reference to all indices
+   */
+  addToIndices(ref) {
+    this.uuidIndex.set(ref.getUuid(), ref);
+    this.idIndex.set(ref.getId(), ref);
+    const doi = ref.getDoi();
+    if (doi) {
+      this.doiIndex.set(doi, ref);
+    }
+    const pmid = ref.getPmid();
+    if (pmid) {
+      this.pmidIndex.set(pmid, ref);
+    }
+  }
+  /**
+   * Remove reference from all indices and array
+   */
+  removeReference(ref) {
+    const index = this.references.indexOf(ref);
+    if (index === -1) {
+      return false;
+    }
+    this.references.splice(index, 1);
+    this.removeFromIndices(ref);
+    return true;
+  }
+  /**
+   * Update a reference with partial updates.
+   * Preserves uuid and created_at, updates timestamp.
+   */
+  updateReference(ref, updates, options = {}) {
+    const index = this.references.indexOf(ref);
+    if (index === -1) {
+      return { updated: false };
+    }
+    const existingItem = ref.getItem();
+    const currentId = ref.getId();
+    const { newId, idChanged, collision } = this.resolveNewId(
+      updates.id ?? existingItem.id,
+      currentId,
+      options
+    );
+    if (collision) {
+      return { updated: false, idCollision: true };
+    }
+    const updatedItem = this.buildUpdatedItem(existingItem, updates, newId);
+    this.removeFromIndices(ref);
+    const newRef = new Reference(updatedItem);
+    this.references[index] = newRef;
+    this.addToIndices(newRef);
+    const result = { updated: true, item: newRef.getItem() };
+    if (idChanged) {
+      result.idChanged = true;
+      result.newId = newId;
+    }
+    return result;
+  }
+  /**
+   * Resolve the new ID, handling collisions based on options.
+   */
+  resolveNewId(requestedId, currentId, options) {
+    if (requestedId === currentId) {
+      return { newId: requestedId, idChanged: false, collision: false };
+    }
+    const conflictingRef = this.idIndex.get(requestedId);
+    if (!conflictingRef) {
+      return { newId: requestedId, idChanged: false, collision: false };
+    }
+    const onIdCollision = options.onIdCollision ?? "fail";
+    if (onIdCollision === "fail") {
+      return { newId: requestedId, idChanged: false, collision: true };
+    }
+    const existingIds = new Set(this.references.map((r) => r.getId()));
+    existingIds.delete(currentId);
+    const resolvedId = this.resolveIdCollision(requestedId, existingIds);
+    return { newId: resolvedId, idChanged: true, collision: false };
+  }
+  /**
+   * Build the updated CslItem, preserving uuid and created_at.
+   */
+  buildUpdatedItem(existingItem, updates, newId) {
+    return {
+      ...existingItem,
+      ...updates,
+      id: newId,
+      type: updates.type ?? existingItem.type,
+      custom: {
+        ...existingItem.custom || {},
+        ...updates.custom || {},
+        uuid: existingItem.custom?.uuid || "",
+        created_at: existingItem.custom?.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  /**
+   * Remove a reference from all indices.
+   */
+  removeFromIndices(ref) {
+    this.uuidIndex.delete(ref.getUuid());
+    this.idIndex.delete(ref.getId());
+    const doi = ref.getDoi();
+    if (doi) {
+      this.doiIndex.delete(doi);
+    }
+    const pmid = ref.getPmid();
+    if (pmid) {
+      this.pmidIndex.delete(pmid);
+    }
+  }
+  /**
+   * Generate an alphabetic suffix for ID collision resolution.
+   * 0 -> 'a', 1 -> 'b', ..., 25 -> 'z', 26 -> 'aa', etc.
+   */
+  generateSuffix(index) {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz";
+    let suffix = "";
+    let n = index;
+    do {
+      suffix = alphabet[n % 26] + suffix;
+      n = Math.floor(n / 26) - 1;
+    } while (n >= 0);
+    return suffix;
+  }
+  /**
+   * Resolve ID collision by appending alphabetic suffix.
+   */
+  resolveIdCollision(baseId, existingIds) {
+    if (!existingIds.has(baseId)) {
+      return baseId;
+    }
+    let index = 0;
+    let newId;
+    do {
+      const suffix = this.generateSuffix(index);
+      newId = `${baseId}${suffix}`;
+      index++;
+    } while (existingIds.has(newId));
+    return newId;
+  }
+}
+const VALID_FIELDS = /* @__PURE__ */ new Set([
+  "author",
+  "title",
+  "year",
+  "doi",
+  "pmid",
+  "pmcid",
+  "url",
+  "keyword",
+  "tag"
+]);
+function isWhitespace(query, index) {
+  return /\s/.test(query.charAt(index));
+}
+function isQuote(query, index) {
+  return query.charAt(index) === '"';
+}
+function tokenize(query) {
+  const tokens = [];
+  let i = 0;
+  while (i < query.length) {
+    if (isWhitespace(query, i)) {
+      i++;
+      continue;
+    }
+    const result = parseNextToken(query, i);
+    if (result.token) {
+      tokens.push(result.token);
+    }
+    i = result.nextIndex;
+  }
+  return {
+    original: query,
+    tokens
+  };
+}
+function hasWhitespaceBetween(query, start, end) {
+  for (let j = start; j < end; j++) {
+    if (isWhitespace(query, j)) {
+      return true;
+    }
+  }
+  return false;
+}
+function tryParseFieldValue(query, startIndex) {
+  const colonIndex = query.indexOf(":", startIndex);
+  if (colonIndex === -1) {
+    return null;
+  }
+  if (hasWhitespaceBetween(query, startIndex, colonIndex)) {
+    return null;
+  }
+  const fieldName = query.substring(startIndex, colonIndex);
+  if (!VALID_FIELDS.has(fieldName)) {
+    return null;
+  }
+  const afterColon = colonIndex + 1;
+  if (afterColon >= query.length || isWhitespace(query, afterColon)) {
+    return { token: null, nextIndex: afterColon };
+  }
+  if (isQuote(query, afterColon)) {
+    const quoteResult = parseQuotedValue(query, afterColon);
+    if (quoteResult.value !== null) {
+      return {
+        token: {
+          raw: query.substring(startIndex, quoteResult.nextIndex),
+          value: quoteResult.value,
+          field: fieldName,
+          isPhrase: true
+        },
+        nextIndex: quoteResult.nextIndex
+      };
+    }
+    return null;
+  }
+  const valueResult = parseUnquotedValue(query, afterColon);
+  return {
+    token: {
+      raw: query.substring(startIndex, valueResult.nextIndex),
+      value: valueResult.value,
+      field: fieldName,
+      isPhrase: false
+    },
+    nextIndex: valueResult.nextIndex
+  };
+}
+function parseQuotedToken(query, startIndex) {
+  const quoteResult = parseQuotedValue(query, startIndex);
+  if (quoteResult.value !== null) {
+    return {
+      token: {
+        raw: query.substring(startIndex, quoteResult.nextIndex),
+        value: quoteResult.value,
+        isPhrase: true
+      },
+      nextIndex: quoteResult.nextIndex
+    };
+  }
+  if (quoteResult.nextIndex > startIndex) {
+    return { token: null, nextIndex: quoteResult.nextIndex };
+  }
+  const valueResult = parseUnquotedValue(query, startIndex, true);
+  return {
+    token: {
+      raw: valueResult.value,
+      value: valueResult.value,
+      isPhrase: false
+    },
+    nextIndex: valueResult.nextIndex
+  };
+}
+function parseRegularToken(query, startIndex) {
+  const valueResult = parseUnquotedValue(query, startIndex);
+  return {
+    token: {
+      raw: valueResult.value,
+      value: valueResult.value,
+      isPhrase: false
+    },
+    nextIndex: valueResult.nextIndex
+  };
+}
+function parseNextToken(query, startIndex) {
+  const fieldResult = tryParseFieldValue(query, startIndex);
+  if (fieldResult !== null) {
+    return fieldResult;
+  }
+  if (isQuote(query, startIndex)) {
+    return parseQuotedToken(query, startIndex);
+  }
+  return parseRegularToken(query, startIndex);
+}
+function parseQuotedValue(query, startIndex) {
+  if (!isQuote(query, startIndex)) {
+    return { value: null, nextIndex: startIndex };
+  }
+  let i = startIndex + 1;
+  const valueStart = i;
+  while (i < query.length && !isQuote(query, i)) {
+    i++;
+  }
+  if (i >= query.length) {
+    return { value: null, nextIndex: startIndex };
+  }
+  const value = query.substring(valueStart, i);
+  i++;
+  if (value.trim() === "") {
+    return { value: null, nextIndex: i };
+  }
+  return { value, nextIndex: i };
+}
+function parseUnquotedValue(query, startIndex, includeQuotes = false) {
+  let i = startIndex;
+  while (i < query.length && !isWhitespace(query, i)) {
+    if (!includeQuotes && isQuote(query, i)) {
+      break;
+    }
+    i++;
+  }
+  return {
+    value: query.substring(startIndex, i),
+    nextIndex: i
+  };
+}
+function normalize(text) {
+  let normalized = text.normalize("NFKC");
+  normalized = normalized.toLowerCase();
+  normalized = normalized.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "");
+  normalized = normalized.replace(/[^\p{L}\p{N}/\s]/gu, " ");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  return normalized;
+}
+function normalizePreservingCase(text) {
+  let normalized = text.normalize("NFKC");
+  normalized = normalized.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  return normalized;
+}
+function hasConsecutiveUppercase(text) {
+  const pattern = /[A-Z]{2,}/;
+  return pattern.test(text);
+}
+function extractUppercaseSegments(text) {
+  const pattern = /[A-Z]{2,}/g;
+  const segments = [];
+  for (const match of text.matchAll(pattern)) {
+    segments.push({
+      segment: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return segments;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function allUppercaseSegmentsExist(segments, target) {
+  return segments.every((seg) => target.includes(seg.segment));
+}
+function buildMatchPattern(query, segments) {
+  const patternParts = [];
+  let lastEnd = 0;
+  for (const seg of segments) {
+    if (seg.start > lastEnd) {
+      const beforePart = query.slice(lastEnd, seg.start);
+      if (beforePart.trim()) {
+        patternParts.push(escapeRegex(beforePart));
+      }
+    }
+    patternParts.push(`(?:${escapeRegex(seg.segment)})`);
+    lastEnd = seg.end;
+  }
+  if (lastEnd < query.length) {
+    const afterPart = query.slice(lastEnd);
+    if (afterPart.trim()) {
+      patternParts.push(escapeRegex(afterPart));
+    }
+  }
+  return patternParts.join(".*?");
+}
+function matchWithUppercaseSensitivity(query, target) {
+  if (query === "") {
+    return true;
+  }
+  if (target === "") {
+    return false;
+  }
+  const normalizedQuery = normalizeWhitespace(query);
+  const normalizedTarget = normalizeWhitespace(target);
+  if (!hasConsecutiveUppercase(normalizedQuery)) {
+    return normalizedTarget.toLowerCase().includes(normalizedQuery.toLowerCase());
+  }
+  const segments = extractUppercaseSegments(normalizedQuery);
+  if (!allUppercaseSegmentsExist(segments, target)) {
+    return false;
+  }
+  const pattern = buildMatchPattern(normalizedQuery, segments);
+  try {
+    const regex = new RegExp(pattern, "i");
+    return regex.test(normalizedTarget);
+  } catch {
+    return normalizedTarget.toLowerCase().includes(normalizedQuery.toLowerCase());
+  }
+}
+const ID_FIELDS = /* @__PURE__ */ new Set(["DOI", "PMID", "PMCID", "URL"]);
+function extractYear$2(reference) {
+  if (reference.issued?.["date-parts"]?.[0]?.[0]) {
+    return String(reference.issued["date-parts"][0][0]);
+  }
+  return "0000";
+}
+function extractAuthors(reference) {
+  if (!reference.author || reference.author.length === 0) {
+    return "";
+  }
+  return reference.author.map((author) => {
+    const family = author.family || "";
+    const given = author.given || "";
+    return given ? `${family} ${given}` : family;
+  }).join(" ");
+}
+function getFieldValue(reference, field) {
+  if (field === "year") {
+    return extractYear$2(reference);
+  }
+  if (field === "author") {
+    return extractAuthors(reference);
+  }
+  const value = reference[field];
+  if (typeof value === "string") {
+    return value;
+  }
+  if (field.startsWith("custom.")) {
+    const customField = field.substring(7);
+    const customValue = reference.custom?.[customField];
+    if (typeof customValue === "string") {
+      return customValue;
+    }
+  }
+  return null;
+}
+function matchUrl(queryValue, reference) {
+  if (reference.URL === queryValue) {
+    return {
+      field: "URL",
+      strength: "exact",
+      value: reference.URL
+    };
+  }
+  const additionalUrls = reference.custom?.additional_urls;
+  if (Array.isArray(additionalUrls)) {
+    for (const url of additionalUrls) {
+      if (typeof url === "string" && url === queryValue) {
+        return {
+          field: "custom.additional_urls",
+          strength: "exact",
+          value: url
+        };
+      }
+    }
+  }
+  return null;
+}
+function matchKeyword(queryValue, reference) {
+  if (!reference.keyword || !Array.isArray(reference.keyword)) {
+    return null;
+  }
+  const normalizedQuery = normalizePreservingCase(queryValue);
+  for (const keyword of reference.keyword) {
+    if (typeof keyword === "string") {
+      const normalizedKeyword = normalizePreservingCase(keyword);
+      if (matchWithUppercaseSensitivity(normalizedQuery, normalizedKeyword)) {
+        return {
+          field: "keyword",
+          strength: "partial",
+          value: keyword
+        };
+      }
+    }
+  }
+  return null;
+}
+function matchTag(queryValue, reference) {
+  if (!reference.custom?.tags || !Array.isArray(reference.custom.tags)) {
+    return null;
+  }
+  const normalizedQuery = normalizePreservingCase(queryValue);
+  for (const tag of reference.custom.tags) {
+    if (typeof tag === "string") {
+      const normalizedTag = normalizePreservingCase(tag);
+      if (matchWithUppercaseSensitivity(normalizedQuery, normalizedTag)) {
+        return {
+          field: "tag",
+          strength: "partial",
+          value: tag
+        };
+      }
+    }
+  }
+  return null;
+}
+const FIELD_MAP = {
+  author: "author",
+  title: "title",
+  doi: "DOI",
+  pmid: "PMID",
+  pmcid: "PMCID"
+};
+function matchYearField(tokenValue, reference) {
+  const year = extractYear$2(reference);
+  if (year === tokenValue) {
+    return {
+      field: "year",
+      strength: "exact",
+      value: year
+    };
+  }
+  return null;
+}
+function matchFieldValue(field, tokenValue, reference) {
+  const fieldValue = getFieldValue(reference, field);
+  if (fieldValue === null) {
+    return null;
+  }
+  if (ID_FIELDS.has(field)) {
+    if (fieldValue === tokenValue) {
+      return {
+        field,
+        strength: "exact",
+        value: fieldValue
+      };
+    }
+    return null;
+  }
+  const normalizedFieldValue = normalizePreservingCase(fieldValue);
+  const normalizedQuery = normalizePreservingCase(tokenValue);
+  if (matchWithUppercaseSensitivity(normalizedQuery, normalizedFieldValue)) {
+    return {
+      field,
+      strength: "partial",
+      value: fieldValue
+    };
+  }
+  return null;
+}
+function matchSpecificField(token, reference) {
+  const matches = [];
+  const fieldToSearch = token.field;
+  if (fieldToSearch === "url") {
+    const urlMatch = matchUrl(token.value, reference);
+    if (urlMatch) matches.push(urlMatch);
+    return matches;
+  }
+  if (fieldToSearch === "year") {
+    const yearMatch = matchYearField(token.value, reference);
+    if (yearMatch) matches.push(yearMatch);
+    return matches;
+  }
+  if (fieldToSearch === "keyword") {
+    const keywordMatch = matchKeyword(token.value, reference);
+    if (keywordMatch) matches.push(keywordMatch);
+    return matches;
+  }
+  if (fieldToSearch === "tag") {
+    const tagMatch = matchTag(token.value, reference);
+    if (tagMatch) matches.push(tagMatch);
+    return matches;
+  }
+  const actualField = FIELD_MAP[fieldToSearch] || fieldToSearch;
+  const match = matchFieldValue(actualField, token.value, reference);
+  if (match) matches.push(match);
+  return matches;
+}
+const STANDARD_SEARCH_FIELDS = [
+  "title",
+  "author",
+  "container-title",
+  "publisher",
+  "DOI",
+  "PMID",
+  "PMCID",
+  "abstract"
+];
+function matchSingleField(field, tokenValue, reference) {
+  if (field === "year") {
+    return matchYearField(tokenValue, reference);
+  }
+  if (field === "URL") {
+    return matchUrl(tokenValue, reference);
+  }
+  if (field === "keyword") {
+    return matchKeyword(tokenValue, reference);
+  }
+  if (field === "tag") {
+    return matchTag(tokenValue, reference);
+  }
+  return matchFieldValue(field, tokenValue, reference);
+}
+function matchAllFields(token, reference) {
+  const matches = [];
+  const specialFields = ["year", "URL", "keyword", "tag"];
+  for (const field of specialFields) {
+    const match = matchSingleField(field, token.value, reference);
+    if (match) matches.push(match);
+  }
+  for (const field of STANDARD_SEARCH_FIELDS) {
+    const match = matchFieldValue(field, token.value, reference);
+    if (match) matches.push(match);
+  }
+  return matches;
+}
+function matchToken(token, reference) {
+  if (token.field) {
+    return matchSpecificField(token, reference);
+  }
+  return matchAllFields(token, reference);
+}
+function matchReference(reference, tokens) {
+  if (tokens.length === 0) {
+    return null;
+  }
+  const tokenMatches = [];
+  let overallStrength = "none";
+  for (const token of tokens) {
+    const matches = matchToken(token, reference);
+    if (matches.length === 0) {
+      return null;
+    }
+    const tokenStrength = matches.some((m) => m.strength === "exact") ? "exact" : "partial";
+    if (tokenStrength === "exact") {
+      overallStrength = "exact";
+    } else if (tokenStrength === "partial" && overallStrength === "none") {
+      overallStrength = "partial";
+    }
+    tokenMatches.push({
+      token,
+      matches
+    });
+  }
+  const score = overallStrength === "exact" ? 100 + tokenMatches.length : 50 + tokenMatches.length;
+  return {
+    reference,
+    tokenMatches,
+    overallStrength,
+    score
+  };
+}
+function search(references, tokens) {
+  const results = [];
+  for (const reference of references) {
+    const match = matchReference(reference, tokens);
+    if (match) {
+      results.push(match);
+    }
+  }
+  return results;
+}
+function extractYear$1(reference) {
+  if (reference.issued?.["date-parts"]?.[0]?.[0]) {
+    return String(reference.issued["date-parts"][0][0]);
+  }
+  return "0000";
+}
+function extractFirstAuthorFamily(reference) {
+  if (!reference.author || reference.author.length === 0) {
+    return "";
+  }
+  return reference.author[0]?.family || "";
+}
+function extractTitle(reference) {
+  return reference.title || "";
+}
+function compareStrength(a, b) {
+  const strengthOrder = { exact: 2, partial: 1, none: 0 };
+  return strengthOrder[b] - strengthOrder[a];
+}
+function compareYear(a, b) {
+  const yearA = extractYear$1(a);
+  const yearB = extractYear$1(b);
+  return Number(yearB) - Number(yearA);
+}
+function compareAuthor(a, b) {
+  const authorA = extractFirstAuthorFamily(a).toLowerCase();
+  const authorB = extractFirstAuthorFamily(b).toLowerCase();
+  if (authorA === "" && authorB !== "") return 1;
+  if (authorA !== "" && authorB === "") return -1;
+  return authorA.localeCompare(authorB);
+}
+function compareTitle(a, b) {
+  const titleA = extractTitle(a).toLowerCase();
+  const titleB = extractTitle(b).toLowerCase();
+  if (titleA === "" && titleB !== "") return 1;
+  if (titleA !== "" && titleB === "") return -1;
+  return titleA.localeCompare(titleB);
+}
+function sortResults(results) {
+  const indexed = results.map((result, index) => ({ result, index }));
+  const sorted = indexed.sort((a, b) => {
+    const strengthDiff = compareStrength(a.result.overallStrength, b.result.overallStrength);
+    if (strengthDiff !== 0) return strengthDiff;
+    const yearDiff = compareYear(a.result.reference, b.result.reference);
+    if (yearDiff !== 0) return yearDiff;
+    const authorDiff = compareAuthor(a.result.reference, b.result.reference);
+    if (authorDiff !== 0) return authorDiff;
+    const titleDiff = compareTitle(a.result.reference, b.result.reference);
+    if (titleDiff !== 0) return titleDiff;
+    return a.index - b.index;
+  });
+  return sorted.map((item) => item.result);
+}
+function normalizeDoi(doi) {
+  const normalized = doi.replace(/^https?:\/\/doi\.org\//i, "").replace(/^https?:\/\/dx\.doi\.org\//i, "").replace(/^doi:/i, "");
+  return normalized;
+}
+function extractYear(item) {
+  const dateParts = item.issued?.["date-parts"]?.[0];
+  if (!dateParts || dateParts.length === 0) {
+    return null;
+  }
+  return String(dateParts[0]);
+}
+function normalizeAuthors(item) {
+  if (!item.author || item.author.length === 0) {
+    return null;
+  }
+  const authorStrings = item.author.map((author) => {
+    const family = author.family || "";
+    const givenInitial = author.given ? author.given.charAt(0) : "";
+    return `${family} ${givenInitial}`.trim();
+  });
+  return normalize(authorStrings.join(" "));
+}
+function checkDoiMatch(item, existing) {
+  if (!item.DOI || !existing.DOI) {
+    return null;
+  }
+  const normalizedItemDoi = normalizeDoi(item.DOI);
+  const normalizedExistingDoi = normalizeDoi(existing.DOI);
+  if (normalizedItemDoi === normalizedExistingDoi) {
+    return {
+      type: "doi",
+      existing,
+      details: {
+        doi: normalizedExistingDoi
+      }
+    };
+  }
+  return null;
+}
+function checkPmidMatch(item, existing) {
+  if (!item.PMID || !existing.PMID) {
+    return null;
+  }
+  if (item.PMID === existing.PMID) {
+    return {
+      type: "pmid",
+      existing,
+      details: {
+        pmid: existing.PMID
+      }
+    };
+  }
+  return null;
+}
+function checkTitleAuthorYearMatch(item, existing) {
+  const itemTitle = item.title ? normalize(item.title) : null;
+  const existingTitle = existing.title ? normalize(existing.title) : null;
+  const itemAuthors = normalizeAuthors(item);
+  const existingAuthors = normalizeAuthors(existing);
+  const itemYear = extractYear(item);
+  const existingYear = extractYear(existing);
+  if (!itemTitle || !existingTitle || !itemAuthors || !existingAuthors || !itemYear || !existingYear) {
+    return null;
+  }
+  if (itemTitle === existingTitle && itemAuthors === existingAuthors && itemYear === existingYear) {
+    return {
+      type: "title-author-year",
+      existing,
+      details: {
+        normalizedTitle: existingTitle,
+        normalizedAuthors: existingAuthors,
+        year: existingYear
+      }
+    };
+  }
+  return null;
+}
+function checkSingleDuplicate(item, existing) {
+  const doiMatch = checkDoiMatch(item, existing);
+  if (doiMatch) {
+    return doiMatch;
+  }
+  const pmidMatch = checkPmidMatch(item, existing);
+  if (pmidMatch) {
+    return pmidMatch;
+  }
+  return checkTitleAuthorYearMatch(item, existing);
+}
+function detectDuplicate(item, existingReferences) {
+  const matches = [];
+  const itemUuid = item.custom?.uuid;
+  for (const existing of existingReferences) {
+    if (itemUuid && existing.custom?.uuid === itemUuid) {
+      continue;
+    }
+    const match = checkSingleDuplicate(item, existing);
+    if (match) {
+      matches.push(match);
+    }
+  }
+  return {
+    isDuplicate: matches.length > 0,
+    matches
+  };
+}
+const DEFAULT_DEBOUNCE_MS = 500;
+const DEFAULT_POLL_INTERVAL_MS = 5e3;
+const DEFAULT_RETRY_DELAY_MS = 200;
+const DEFAULT_MAX_RETRIES = 10;
+function shouldIgnore(filePath) {
+  const basename = path.basename(filePath);
+  if (basename.endsWith(".tmp")) return true;
+  if (basename.endsWith(".bak")) return true;
+  if (basename.includes(".conflict.")) return true;
+  if (basename.endsWith(".lock")) return true;
+  if (basename.startsWith(".") && basename.endsWith(".swp")) return true;
+  if (basename.endsWith("~")) return true;
+  return false;
+}
+class FileWatcher extends EventEmitter {
+  watchPath;
+  debounceMs;
+  pollIntervalMs;
+  usePolling;
+  retryDelayMs;
+  maxRetries;
+  watcher = null;
+  watching = false;
+  debounceTimers = /* @__PURE__ */ new Map();
+  constructor(watchPath, options) {
+    super();
+    this.watchPath = watchPath;
+    this.debounceMs = options?.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.pollIntervalMs = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.usePolling = options?.usePolling ?? false;
+    this.retryDelayMs = options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    this.maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  }
+  /**
+   * Start watching for file changes
+   */
+  async start() {
+    if (this.watching) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.watcher = chokidar.watch(this.watchPath, {
+        ignored: shouldIgnore,
+        persistent: true,
+        usePolling: this.usePolling,
+        interval: this.pollIntervalMs,
+        ignoreInitial: true,
+        awaitWriteFinish: false
+      });
+      this.watcher.on("ready", () => {
+        this.watching = true;
+        this.emit("ready");
+        resolve();
+      });
+      this.watcher.on("error", (error) => {
+        this.emit("error", error);
+        if (!this.watching) {
+          reject(error);
+        }
+      });
+      this.watcher.on("change", (filePath) => {
+        this.handleFileChange(filePath);
+      });
+      this.watcher.on("add", (filePath) => {
+        this.handleFileChange(filePath);
+      });
+    });
+  }
+  /**
+   * Handle file change with debouncing
+   */
+  handleFileChange(filePath) {
+    const existingTimer = this.debounceTimers.get(filePath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(filePath);
+      this.emit("change", filePath);
+      this.tryParseJsonFile(filePath);
+    }, this.debounceMs);
+    this.debounceTimers.set(filePath, timer);
+  }
+  /**
+   * Try to parse JSON file with retries
+   */
+  async tryParseJsonFile(filePath) {
+    if (path.extname(filePath).toLowerCase() !== ".json") {
+      return;
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        this.emit("parsed", filePath, parsed);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < this.maxRetries) {
+          await this.delay(this.retryDelayMs);
+        }
+      }
+    }
+    this.emit("parseError", filePath, lastError);
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Stop watching for file changes
+   */
+  close() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+    this.watching = false;
+  }
+  /**
+   * Get the watched path
+   */
+  getPath() {
+    return this.watchPath;
+  }
+  /**
+   * Check if the watcher is currently active
+   */
+  isWatching() {
+    return this.watching;
+  }
+  /**
+   * Get the debounce time in milliseconds
+   */
+  getDebounceMs() {
+    return this.debounceMs;
+  }
+  /**
+   * Get the poll interval in milliseconds
+   */
+  getPollIntervalMs() {
+    return this.pollIntervalMs;
+  }
+  /**
+   * Get the retry delay in milliseconds
+   */
+  getRetryDelayMs() {
+    return this.retryDelayMs;
+  }
+  /**
+   * Get the maximum number of retries
+   */
+  getMaxRetries() {
+    return this.maxRetries;
+  }
+}
+export {
+  CslLibrarySchema as C,
+  FileWatcher as F,
+  Library as L,
+  Reference as R,
+  computeHash as a,
+  sortResults as b,
+  computeFileHash as c,
+  detectDuplicate as d,
+  CslItemSchema as e,
+  serializeCslJson as f,
+  generateId as g,
+  generateIdWithCollisionCheck as h,
+  normalizeText as i,
+  generateUuid as j,
+  isValidUuid as k,
+  ensureCustomMetadata as l,
+  extractUuidFromCustom as m,
+  normalize as n,
+  parseCslJson as p,
+  search as s,
+  tokenize as t,
+  writeCslJson as w
+};
+//# sourceMappingURL=file-watcher-B-SiUw5f.js.map