@ncukondo/reference-manager 0.1.0

package/dist/chunks/detector-BF8Mcc72.js

@@ -0,0 +1,1415 @@
+import { randomUUID, createHash } from "node:crypto";
+import { createReadStream, existsSync, readFileSync } from "node:fs";
+import { readFile, mkdir, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { dirname, join } from "node:path";
+import { parse } from "@iarna/toml";
+import { tmpdir, homedir } from "node:os";
+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 CslCustomSchema = z.object({
+  uuid: z.string(),
+  created_at: z.string(),
+  timestamp: z.string(),
+  additional_urls: z.array(z.string()).optional()
+});
+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);
+  }
+  /**
+   * Add a reference to the library
+   */
+  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);
+  }
+  /**
+   * Remove a reference by UUID
+   */
+  removeByUuid(uuid) {
+    const ref = this.uuidIndex.get(uuid);
+    if (!ref) {
+      return false;
+    }
+    return this.removeReference(ref);
+  }
+  /**
+   * Remove a reference by ID
+   */
+  removeById(id) {
+    const ref = this.idIndex.get(id);
+    if (!ref) {
+      return false;
+    }
+    return this.removeReference(ref);
+  }
+  /**
+   * Find a reference by UUID
+   */
+  findByUuid(uuid) {
+    return this.uuidIndex.get(uuid);
+  }
+  /**
+   * Find a reference by ID
+   */
+  findById(id) {
+    return this.idIndex.get(id);
+  }
+  /**
+   * 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
+   */
+  getAll() {
+    return [...this.references];
+  }
+  /**
+   * 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.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);
+    }
+    return true;
+  }
+}
+const logLevelSchema = z.enum(["silent", "info", "debug"]);
+const backupConfigSchema = z.object({
+  maxGenerations: z.number().int().positive(),
+  maxAgeDays: z.number().int().positive(),
+  directory: z.string().min(1)
+});
+const watchConfigSchema = z.object({
+  enabled: z.boolean(),
+  debounceMs: z.number().int().nonnegative(),
+  pollIntervalMs: z.number().int().positive(),
+  retryIntervalMs: z.number().int().positive(),
+  maxRetries: z.number().int().nonnegative()
+});
+const serverConfigSchema = z.object({
+  autoStart: z.boolean(),
+  autoStopMinutes: z.number().int().nonnegative()
+});
+const configSchema = z.object({
+  library: z.string().min(1),
+  logLevel: logLevelSchema,
+  backup: backupConfigSchema,
+  watch: watchConfigSchema,
+  server: serverConfigSchema
+});
+const partialConfigSchema = z.object({
+  library: z.string().min(1).optional(),
+  logLevel: logLevelSchema.optional(),
+  log_level: logLevelSchema.optional(),
+  // snake_case support
+  backup: z.object({
+    maxGenerations: z.number().int().positive().optional(),
+    max_generations: z.number().int().positive().optional(),
+    maxAgeDays: z.number().int().positive().optional(),
+    max_age_days: z.number().int().positive().optional(),
+    directory: z.string().min(1).optional()
+  }).optional(),
+  watch: z.object({
+    enabled: z.boolean().optional(),
+    debounceMs: z.number().int().nonnegative().optional(),
+    debounce_ms: z.number().int().nonnegative().optional(),
+    pollIntervalMs: z.number().int().positive().optional(),
+    poll_interval_ms: z.number().int().positive().optional(),
+    retryIntervalMs: z.number().int().positive().optional(),
+    retry_interval_ms: z.number().int().positive().optional(),
+    maxRetries: z.number().int().nonnegative().optional(),
+    max_retries: z.number().int().nonnegative().optional()
+  }).optional(),
+  server: z.object({
+    autoStart: z.boolean().optional(),
+    auto_start: z.boolean().optional(),
+    autoStopMinutes: z.number().int().nonnegative().optional(),
+    auto_stop_minutes: z.number().int().nonnegative().optional()
+  }).optional()
+}).passthrough();
+function normalizeBackupConfig(backup) {
+  const normalized = {};
+  const maxGenerations = backup.maxGenerations ?? backup.max_generations;
+  if (maxGenerations !== void 0) {
+    normalized.maxGenerations = maxGenerations;
+  }
+  const maxAgeDays = backup.maxAgeDays ?? backup.max_age_days;
+  if (maxAgeDays !== void 0) {
+    normalized.maxAgeDays = maxAgeDays;
+  }
+  if (backup.directory !== void 0) {
+    normalized.directory = backup.directory;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeWatchConfig(watch) {
+  const normalized = {};
+  if (watch.enabled !== void 0) {
+    normalized.enabled = watch.enabled;
+  }
+  const debounceMs = watch.debounceMs ?? watch.debounce_ms;
+  if (debounceMs !== void 0) {
+    normalized.debounceMs = debounceMs;
+  }
+  const pollIntervalMs = watch.pollIntervalMs ?? watch.poll_interval_ms;
+  if (pollIntervalMs !== void 0) {
+    normalized.pollIntervalMs = pollIntervalMs;
+  }
+  const retryIntervalMs = watch.retryIntervalMs ?? watch.retry_interval_ms;
+  if (retryIntervalMs !== void 0) {
+    normalized.retryIntervalMs = retryIntervalMs;
+  }
+  const maxRetries = watch.maxRetries ?? watch.max_retries;
+  if (maxRetries !== void 0) {
+    normalized.maxRetries = maxRetries;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeServerConfig(server) {
+  const normalized = {};
+  const autoStart = server.autoStart ?? server.auto_start;
+  if (autoStart !== void 0) {
+    normalized.autoStart = autoStart;
+  }
+  const autoStopMinutes = server.autoStopMinutes ?? server.auto_stop_minutes;
+  if (autoStopMinutes !== void 0) {
+    normalized.autoStopMinutes = autoStopMinutes;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizePartialConfig(partial) {
+  const normalized = {};
+  if (partial.library !== void 0) {
+    normalized.library = partial.library;
+  }
+  const logLevel = partial.logLevel ?? partial.log_level;
+  if (logLevel !== void 0) {
+    normalized.logLevel = logLevel;
+  }
+  if (partial.backup !== void 0) {
+    const backup = normalizeBackupConfig(
+      partial.backup
+    );
+    if (backup) {
+      normalized.backup = backup;
+    }
+  }
+  if (partial.watch !== void 0) {
+    const watch = normalizeWatchConfig(partial.watch);
+    if (watch) {
+      normalized.watch = watch;
+    }
+  }
+  if (partial.server !== void 0) {
+    const server = normalizeServerConfig(
+      partial.server
+    );
+    if (server) {
+      normalized.server = server;
+    }
+  }
+  return normalized;
+}
+function getDefaultBackupDirectory() {
+  return join(tmpdir(), "reference-manager", "backups");
+}
+function getDefaultLibraryPath() {
+  return join(homedir(), ".reference-manager", "csl.library.json");
+}
+function getDefaultUserConfigPath() {
+  return join(homedir(), ".reference-manager", "config.toml");
+}
+function getDefaultCurrentDirConfigFilename() {
+  return ".reference-manager.config.toml";
+}
+const defaultConfig = {
+  library: getDefaultLibraryPath(),
+  logLevel: "info",
+  backup: {
+    maxGenerations: 50,
+    maxAgeDays: 365,
+    directory: getDefaultBackupDirectory()
+  },
+  watch: {
+    enabled: true,
+    debounceMs: 500,
+    pollIntervalMs: 5e3,
+    retryIntervalMs: 200,
+    maxRetries: 10
+  },
+  server: {
+    autoStart: false,
+    autoStopMinutes: 0
+  }
+};
+function loadTOMLFile(path) {
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    const parsed = parse(content);
+    const validated = partialConfigSchema.parse(parsed);
+    return validated;
+  } catch (error) {
+    throw new Error(
+      `Failed to load config from ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function mergeConfigs(base, ...overrides) {
+  const result = { ...base };
+  for (const override of overrides) {
+    if (!override) continue;
+    if (override.library !== void 0) {
+      result.library = override.library;
+    }
+    if (override.logLevel !== void 0) {
+      result.logLevel = override.logLevel;
+    }
+    if (override.backup !== void 0) {
+      result.backup = {
+        ...result.backup,
+        ...override.backup
+      };
+    }
+    if (override.watch !== void 0) {
+      result.watch = {
+        ...result.watch,
+        ...override.watch
+      };
+    }
+    if (override.server !== void 0) {
+      result.server = {
+        ...result.server,
+        ...override.server
+      };
+    }
+  }
+  return result;
+}
+function fillDefaults(partial) {
+  return {
+    library: partial.library ?? defaultConfig.library,
+    logLevel: partial.logLevel ?? defaultConfig.logLevel,
+    backup: {
+      maxGenerations: partial.backup?.maxGenerations ?? defaultConfig.backup.maxGenerations,
+      maxAgeDays: partial.backup?.maxAgeDays ?? defaultConfig.backup.maxAgeDays,
+      directory: partial.backup?.directory ?? defaultConfig.backup.directory
+    },
+    watch: {
+      enabled: partial.watch?.enabled ?? defaultConfig.watch.enabled,
+      debounceMs: partial.watch?.debounceMs ?? defaultConfig.watch.debounceMs,
+      pollIntervalMs: partial.watch?.pollIntervalMs ?? defaultConfig.watch.pollIntervalMs,
+      retryIntervalMs: partial.watch?.retryIntervalMs ?? defaultConfig.watch.retryIntervalMs,
+      maxRetries: partial.watch?.maxRetries ?? defaultConfig.watch.maxRetries
+    },
+    server: {
+      autoStart: partial.server?.autoStart ?? defaultConfig.server.autoStart,
+      autoStopMinutes: partial.server?.autoStopMinutes ?? defaultConfig.server.autoStopMinutes
+    }
+  };
+}
+function loadConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const userConfigPath = options.userConfigPath ?? getDefaultUserConfigPath();
+  const userConfig = loadTOMLFile(userConfigPath);
+  const envConfigPath = process.env.REFERENCE_MANAGER_CONFIG;
+  const envConfig = envConfigPath ? loadTOMLFile(envConfigPath) : null;
+  const currentConfigPath = join(cwd, getDefaultCurrentDirConfigFilename());
+  const currentConfig = loadTOMLFile(currentConfigPath);
+  const normalizedUser = userConfig ? normalizePartialConfig(userConfig) : null;
+  const normalizedEnv = envConfig ? normalizePartialConfig(envConfig) : null;
+  const normalizedCurrent = currentConfig ? normalizePartialConfig(currentConfig) : null;
+  const merged = mergeConfigs(
+    {},
+    normalizedUser,
+    normalizedEnv,
+    normalizedCurrent,
+    options.overrides
+  );
+  const config = fillDefaults(merged);
+  try {
+    return configSchema.parse(config);
+  } catch (error) {
+    throw new Error(
+      `Invalid configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+const VALID_FIELDS = /* @__PURE__ */ new Set([
+  "author",
+  "title",
+  "year",
+  "doi",
+  "pmid",
+  "pmcid",
+  "url",
+  "keyword"
+]);
+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;
+}
+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 givenInitial = author.given ? author.given[0] : "";
+    return givenInitial ? `${family} ${givenInitial}` : 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 = normalize(queryValue);
+  for (const keyword of reference.keyword) {
+    if (typeof keyword === "string") {
+      const normalizedKeyword = normalize(keyword);
+      if (normalizedKeyword.includes(normalizedQuery)) {
+        return {
+          field: "keyword",
+          strength: "partial",
+          value: keyword
+        };
+      }
+    }
+  }
+  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 = normalize(fieldValue);
+  const normalizedQuery = normalize(tokenValue);
+  if (normalizedFieldValue.includes(normalizedQuery)) {
+    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;
+  }
+  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);
+  }
+  return matchFieldValue(field, tokenValue, reference);
+}
+function matchAllFields(token, reference) {
+  const matches = [];
+  const specialFields = ["year", "URL", "keyword"];
+  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
+  };
+}
+export {
+  generateUuid as A,
+  isValidUuid as B,
+  CslLibrarySchema as C,
+  ensureCustomMetadata as D,
+  extractUuidFromCustom as E,
+  Library as L,
+  Reference as R,
+  computeHash as a,
+  backupConfigSchema as b,
+  computeFileHash as c,
+  configSchema as d,
+  defaultConfig as e,
+  getDefaultCurrentDirConfigFilename as f,
+  getDefaultBackupDirectory as g,
+  getDefaultLibraryPath as h,
+  getDefaultUserConfigPath as i,
+  logLevelSchema as j,
+  normalize as k,
+  loadConfig as l,
+  sortResults as m,
+  normalizePartialConfig as n,
+  detectDuplicate as o,
+  partialConfigSchema as p,
+  CslItemSchema as q,
+  parseCslJson as r,
+  search as s,
+  tokenize as t,
+  serializeCslJson as u,
+  writeCslJson as v,
+  watchConfigSchema as w,
+  generateId as x,
+  generateIdWithCollisionCheck as y,
+  normalizeText as z
+};
+//# sourceMappingURL=detector-BF8Mcc72.js.map