@ncukondo/reference-manager 0.1.0

package/dist/features/search/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Search feature type definitions
+ */
+import type { CslItem } from "../../core/csl-json/types.js";
+/**
+ * Field specifier for field-specific search
+ */
+export type FieldSpecifier = "author" | "title" | "year" | "doi" | "pmid" | "pmcid" | "url" | "keyword";
+/**
+ * Search token representing a parsed query element
+ */
+export interface SearchToken {
+    /** The original query text (may include quotes) */
+    raw: string;
+    /** The normalized value to search for */
+    value: string;
+    /** Field to search in (if specified with field: prefix) */
+    field?: FieldSpecifier;
+    /** Whether this is a phrase search (enclosed in quotes) */
+    isPhrase: boolean;
+}
+/**
+ * Parsed search query
+ */
+export interface SearchQuery {
+    /** Original query string */
+    original: string;
+    /** Parsed tokens */
+    tokens: SearchToken[];
+}
+/**
+ * Match strength indicator
+ */
+export type MatchStrength = "exact" | "partial" | "none";
+/**
+ * Field match result
+ */
+export interface FieldMatch {
+    /** Field name that matched */
+    field: string;
+    /** Strength of the match */
+    strength: MatchStrength;
+    /** Matched value */
+    value: string;
+}
+/**
+ * Token match result
+ */
+export interface TokenMatch {
+    /** The token that was matched */
+    token: SearchToken;
+    /** Fields that matched this token */
+    matches: FieldMatch[];
+}
+/**
+ * Search result for a single reference
+ */
+export interface SearchResult {
+    /** The reference that matched */
+    reference: CslItem;
+    /** Match information for each token */
+    tokenMatches: TokenMatch[];
+    /** Overall match strength (highest strength among all tokens) */
+    overallStrength: MatchStrength;
+    /** Match score (for sorting) */
+    score: number;
+}
+/**
+ * Search options
+ */
+export interface SearchOptions {
+    /** Sort order (default: by relevance) */
+    sortBy?: "relevance" | "year" | "author" | "title";
+    /** Limit number of results */
+    limit?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/features/search/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/features/search/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,OAAO,GACP,MAAM,GACN,KAAK,GACL,MAAM,GACN,OAAO,GACP,KAAK,GACL,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB;IACpB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,QAAQ,EAAE,aAAa,CAAC;IACxB,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iCAAiC;IACjC,KAAK,EAAE,WAAW,CAAC;IACnB,qCAAqC;IACrC,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,iCAAiC;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,YAAY,EAAE,UAAU,EAAE,CAAC;IAC3B,iEAAiE;IACjE,eAAe,EAAE,aAAa,CAAC;IAC/B,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACnD,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * reference-manager - A local reference management tool using CSL-JSON
+ *
+ * Main library entry point
+ */
+export * from "./core/index.js";
+export * as Utils from "./utils/index.js";
+export * as Config from "./config/index.js";
+export * as Search from "./features/search/index.js";
+export * as Duplicate from "./features/duplicate/index.js";
+export * as Merge from "./features/merge/index.js";
+export { FileWatcher, type FileWatcherOptions } from "./features/file-watcher/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,iBAAiB,CAAC;AAGhC,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAG5C,OAAO,KAAK,MAAM,MAAM,4BAA4B,CAAC;AACrD,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,KAAK,MAAM,2BAA2B,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -0,0 +1,559 @@
+import { C as CslLibrarySchema, c as computeFileHash, a as computeHash, b as backupConfigSchema, d as configSchema, e as defaultConfig, g as getDefaultBackupDirectory, f as getDefaultCurrentDirConfigFilename, h as getDefaultLibraryPath, i as getDefaultUserConfigPath, l as loadConfig, j as logLevelSchema, n as normalizePartialConfig, p as partialConfigSchema, w as watchConfigSchema, k as normalize, s as search, m as sortResults, t as tokenize, o as detectDuplicate } from "./chunks/detector-BF8Mcc72.js";
+import { q, L, R, D, E, x, y, A, B, z, r, u, v } from "./chunks/detector-BF8Mcc72.js";
+import * as fs from "node:fs/promises";
+import { mkdir, readFile, copyFile, stat, unlink, readdir } from "node:fs/promises";
+import * as path from "node:path";
+import { dirname, join } from "node:path";
+import writeFileAtomicLib from "write-file-atomic";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { EventEmitter } from "node:events";
+import chokidar from "chokidar";
+function validateCslJson(data) {
+  const parseResult = CslLibrarySchema.safeParse(data);
+  if (!parseResult.success) {
+    throw new Error(`Invalid CSL-JSON structure: ${parseResult.error.message}`);
+  }
+  return parseResult.data;
+}
+function createLogger(level = "info") {
+  const shouldLogInfo = level === "info" || level === "debug";
+  const shouldLogDebug = level === "debug";
+  function formatMessage(...args) {
+    return `${args.map((arg) => String(arg)).join(" ")}
+`;
+  }
+  return {
+    info(...args) {
+      if (shouldLogInfo) {
+        process.stderr.write(formatMessage(...args));
+      }
+    },
+    debug(...args) {
+      if (shouldLogDebug) {
+        process.stderr.write(formatMessage(...args));
+      }
+    },
+    error(...args) {
+      process.stderr.write(formatMessage(...args));
+    }
+  };
+}
+async function writeFileAtomic(filePath, content) {
+  await ensureDirectoryExists(dirname(filePath));
+  await writeFileAtomicLib(filePath, content, { encoding: "utf-8" });
+}
+async function ensureDirectoryExists(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+const DEFAULT_MAX_GENERATIONS = 50;
+const DEFAULT_MAX_AGE_MS = 365 * 24 * 60 * 60 * 1e3;
+async function resolvePackageName() {
+  try {
+    const currentFile = fileURLToPath(import.meta.url);
+    let currentDir = dirname(currentFile);
+    for (let i = 0; i < 10; i++) {
+      const packageJsonPath = join(currentDir, "package.json");
+      if (existsSync(packageJsonPath)) {
+        const content = await readFile(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(content);
+        return pkg.name;
+      }
+      currentDir = dirname(currentDir);
+    }
+  } catch {
+  }
+  return "reference-manager";
+}
+const packageName = await resolvePackageName();
+function getBackupDirectory(libraryName) {
+  const pkgName = packageName ?? "reference-manager";
+  return join(tmpdir(), pkgName, "backups", libraryName);
+}
+async function createBackup(sourceFile, libraryName) {
+  const backupDir = getBackupDirectory(libraryName);
+  await ensureDirectoryExists(backupDir);
+  const timestamp = Date.now();
+  const backupFileName = `${timestamp}.backup`;
+  const backupPath = join(backupDir, backupFileName);
+  await copyFile(sourceFile, backupPath);
+  return backupPath;
+}
+async function listBackups(libraryName) {
+  const backupDir = getBackupDirectory(libraryName);
+  if (!existsSync(backupDir)) {
+    return [];
+  }
+  const files = await readdir(backupDir);
+  const backupFiles = files.filter((f) => f.endsWith(".backup")).map((f) => join(backupDir, f));
+  const filesWithStats = await Promise.all(
+    backupFiles.map(async (file) => {
+      const stats = await stat(file);
+      return { file, mtime: stats.mtimeMs };
+    })
+  );
+  filesWithStats.sort((a, b) => b.mtime - a.mtime);
+  return filesWithStats.map((f) => f.file);
+}
+async function cleanupOldBackups(libraryName, options) {
+  const maxGenerations = options?.maxGenerations ?? DEFAULT_MAX_GENERATIONS;
+  const maxAgeMs = options?.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const backups = await listBackups(libraryName);
+  const now = Date.now();
+  const backupsToDelete = [];
+  for (let i = 0; i < backups.length; i++) {
+    const backupPath = backups[i];
+    if (!backupPath) continue;
+    const stats = await stat(backupPath);
+    const age = now - stats.mtimeMs;
+    if (i >= maxGenerations || age > maxAgeMs) {
+      backupsToDelete.push(backupPath);
+    }
+  }
+  await Promise.all(backupsToDelete.map((backup) => unlink(backup)));
+}
+const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  cleanupOldBackups,
+  computeFileHash,
+  computeHash,
+  createBackup,
+  createLogger,
+  ensureDirectoryExists,
+  getBackupDirectory,
+  listBackups,
+  writeFileAtomic
+}, Symbol.toStringTag, { value: "Module" }));
+const index$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  backupConfigSchema,
+  configSchema,
+  defaultConfig,
+  getDefaultBackupDirectory,
+  getDefaultCurrentDirConfigFilename,
+  getDefaultLibraryPath,
+  getDefaultUserConfigPath,
+  loadConfig,
+  logLevelSchema,
+  normalizePartialConfig,
+  partialConfigSchema,
+  watchConfigSchema
+}, Symbol.toStringTag, { value: "Module" }));
+const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  normalize,
+  search,
+  sortResults,
+  tokenize
+}, Symbol.toStringTag, { value: "Module" }));
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  detectDuplicate
+}, Symbol.toStringTag, { value: "Module" }));
+function getItemUuid(item) {
+  return item.custom?.uuid || item.id || "unknown";
+}
+function getTimestamp(item) {
+  return item.custom?.timestamp || item.custom?.created_at || "1970-01-01T00:00:00.000Z";
+}
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function resolveFieldConflict(localValue, remoteValue, localTimestamp, remoteTimestamp, options) {
+  if (localTimestamp > remoteTimestamp) {
+    return localValue;
+  }
+  if (remoteTimestamp > localTimestamp) {
+    return remoteValue;
+  }
+  if (options?.prefer === "remote") {
+    return remoteValue;
+  }
+  return localValue;
+}
+function determineResolution(fieldConflicts, localTimestamp, remoteTimestamp, options) {
+  const hasRealConflicts = fieldConflicts.every((fc) => fc.resolved !== void 0);
+  const localIsNewer = fieldConflicts.some(
+    (fc) => fc.local !== fc.remote && localTimestamp > remoteTimestamp
+  );
+  const remoteIsNewer = fieldConflicts.some(
+    (fc) => fc.local !== fc.remote && remoteTimestamp > localTimestamp
+  );
+  if (hasRealConflicts && localIsNewer) return "auto-lww";
+  if (hasRealConflicts && remoteIsNewer) return "auto-lww";
+  if (options?.prefer === "local") return "prefer-local";
+  if (options?.prefer === "remote") return "prefer-remote";
+  return "unresolved";
+}
+function mergeField(key, baseValue, localValue, remoteValue, localTimestamp, remoteTimestamp, options) {
+  const localChanged = !deepEqual(baseValue, localValue);
+  const remoteChanged = !deepEqual(baseValue, remoteValue);
+  if (!localChanged && !remoteChanged) {
+    return { value: baseValue, conflict: null };
+  }
+  if (localChanged && !remoteChanged) {
+    return { value: localValue, conflict: null };
+  }
+  if (!localChanged && remoteChanged) {
+    return { value: remoteValue, conflict: null };
+  }
+  if (deepEqual(localValue, remoteValue)) {
+    return { value: localValue, conflict: null };
+  }
+  const resolved = resolveFieldConflict(
+    localValue,
+    remoteValue,
+    localTimestamp,
+    remoteTimestamp,
+    options
+  );
+  if (key === "custom") {
+    return { value: resolved, conflict: null };
+  }
+  return {
+    value: resolved,
+    conflict: {
+      field: key,
+      base: baseValue,
+      local: localValue,
+      remote: remoteValue,
+      resolved
+    }
+  };
+}
+function mergeItem(base, local, remote, options) {
+  const uuid = getItemUuid(base);
+  const localTimestamp = getTimestamp(local);
+  const remoteTimestamp = getTimestamp(remote);
+  const merged = { ...base };
+  const fieldConflicts = [];
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(base),
+    ...Object.keys(local),
+    ...Object.keys(remote)
+  ]);
+  for (const key of allKeys) {
+    const baseValue = base[key];
+    const localValue = local[key];
+    const remoteValue = remote[key];
+    const { value, conflict } = mergeField(
+      key,
+      baseValue,
+      localValue,
+      remoteValue,
+      localTimestamp,
+      remoteTimestamp,
+      options
+    );
+    merged[key] = value;
+    if (conflict) {
+      fieldConflicts.push(conflict);
+    }
+  }
+  if (fieldConflicts.length > 0) {
+    const resolution = determineResolution(
+      fieldConflicts,
+      localTimestamp,
+      remoteTimestamp,
+      options
+    );
+    return {
+      merged,
+      conflict: {
+        uuid,
+        id: base.id || "unknown",
+        fields: fieldConflicts,
+        localTimestamp,
+        remoteTimestamp,
+        resolution
+      }
+    };
+  }
+  return { merged, conflict: null };
+}
+function buildItemMaps(base, local, remote) {
+  const baseMap = /* @__PURE__ */ new Map();
+  const localMap = /* @__PURE__ */ new Map();
+  const remoteMap = /* @__PURE__ */ new Map();
+  for (const item of base) {
+    baseMap.set(getItemUuid(item), item);
+  }
+  for (const item of local) {
+    localMap.set(getItemUuid(item), item);
+  }
+  for (const item of remote) {
+    remoteMap.set(getItemUuid(item), item);
+  }
+  return { baseMap, localMap, remoteMap };
+}
+function mergeExistingItem(baseItem, localItem, remoteItem, options, merged, conflicts) {
+  const { merged: mergedItem, conflict } = mergeItem(baseItem, localItem, remoteItem, options);
+  merged.push(mergedItem);
+  if (conflict) {
+    conflicts.push(conflict);
+  }
+}
+function handleDualAddition(uuid, localItem, remoteItem, options, merged, conflicts) {
+  if (deepEqual(localItem, remoteItem)) {
+    merged.push(localItem);
+  } else {
+    const syntheticBase = {
+      id: uuid,
+      type: "article",
+      custom: {
+        uuid,
+        created_at: "1970-01-01T00:00:00.000Z",
+        timestamp: "1970-01-01T00:00:00.000Z"
+      }
+    };
+    const { merged: mergedItem, conflict } = mergeItem(
+      syntheticBase,
+      localItem,
+      remoteItem,
+      options
+    );
+    merged.push(mergedItem);
+    if (conflict) {
+      conflicts.push(conflict);
+    }
+  }
+}
+function processItem(uuid, baseMap, localMap, remoteMap, options, result) {
+  const baseItem = baseMap.get(uuid);
+  const localItem = localMap.get(uuid);
+  const remoteItem = remoteMap.get(uuid);
+  if (baseItem && localItem && remoteItem) {
+    mergeExistingItem(baseItem, localItem, remoteItem, options, result.merged, result.conflicts);
+  } else if (!baseItem && localItem && remoteItem) {
+    handleDualAddition(uuid, localItem, remoteItem, options, result.merged, result.conflicts);
+  } else if (!baseItem && localItem && !remoteItem) {
+    result.merged.push(localItem);
+    result.localOnly.push(localItem);
+  } else if (!baseItem && !localItem && remoteItem) {
+    result.merged.push(remoteItem);
+    result.remoteOnly.push(remoteItem);
+  } else if (baseItem && !localItem && remoteItem) {
+    result.deletedInLocal.push(baseItem);
+  } else if (baseItem && localItem && !remoteItem) {
+    result.deletedInRemote.push(baseItem);
+  } else if (baseItem && !localItem && !remoteItem) {
+    result.deletedInLocal.push(baseItem);
+    result.deletedInRemote.push(baseItem);
+  }
+}
+function threeWayMerge(base, local, remote, options) {
+  const { baseMap, localMap, remoteMap } = buildItemMaps(base, local, remote);
+  const result = {
+    merged: [],
+    conflicts: [],
+    localOnly: [],
+    remoteOnly: [],
+    deletedInLocal: [],
+    deletedInRemote: []
+  };
+  const allUuids = /* @__PURE__ */ new Set([...baseMap.keys(), ...localMap.keys(), ...remoteMap.keys()]);
+  for (const uuid of allUuids) {
+    processItem(uuid, baseMap, localMap, remoteMap, options, result);
+  }
+  let status = "success";
+  if (result.conflicts.length > 0) {
+    const hasUnresolved = result.conflicts.some((c) => c.resolution === "unresolved");
+    status = hasUnresolved ? "conflict" : "auto-resolved";
+  }
+  return {
+    status,
+    ...result
+  };
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  threeWayMerge
+}, Symbol.toStringTag, { value: "Module" }));
+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 {
+  index$3 as Config,
+  q as CslItemSchema,
+  CslLibrarySchema,
+  index$1 as Duplicate,
+  FileWatcher,
+  L as Library,
+  index as Merge,
+  R as Reference,
+  index$2 as Search,
+  index$4 as Utils,
+  D as ensureCustomMetadata,
+  E as extractUuidFromCustom,
+  x as generateId,
+  y as generateIdWithCollisionCheck,
+  A as generateUuid,
+  B as isValidUuid,
+  z as normalizeText,
+  r as parseCslJson,
+  u as serializeCslJson,
+  validateCslJson,
+  v as writeCslJson
+};
+//# sourceMappingURL=index.js.map