@ncukondo/reference-manager 0.1.0

package/dist/cli.js

@@ -0,0 +1,981 @@
+import { Command } from "commander";
+import { z } from "zod";
+import { o as detectDuplicate, R as Reference, t as tokenize, s as search$1, m as sortResults, l as loadConfig, L as Library } from "./chunks/detector-BF8Mcc72.js";
+import { promises, readFileSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { stdin, stdout } from "node:process";
+import { spawn } from "node:child_process";
+function getPortfilePath() {
+  const tmpDir = os.tmpdir();
+  return path.join(tmpDir, "reference-manager", "server.port");
+}
+async function writePortfile(portfilePath, port, pid, library, started_at) {
+  const dir = path.dirname(portfilePath);
+  await promises.mkdir(dir, { recursive: true });
+  const data = { port, pid, library };
+  if (started_at !== void 0) {
+    data.started_at = started_at;
+  }
+  const content = JSON.stringify(data, null, 2);
+  await promises.writeFile(portfilePath, content, "utf-8");
+}
+async function readPortfile(portfilePath) {
+  try {
+    const content = await promises.readFile(portfilePath, "utf-8");
+    const data = JSON.parse(content);
+    if (typeof data.port !== "number" || typeof data.pid !== "number") {
+      return null;
+    }
+    const result = {
+      port: data.port,
+      pid: data.pid
+    };
+    if (typeof data.library === "string") {
+      result.library = data.library;
+    }
+    if (typeof data.started_at === "string") {
+      result.started_at = data.started_at;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function portfileExists(portfilePath) {
+  try {
+    await promises.access(portfilePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removePortfile(portfilePath) {
+  try {
+    await promises.unlink(portfilePath);
+  } catch {
+  }
+}
+function isProcessRunning(pid) {
+  if (pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function 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;
+}
+function resolveIdCollision(baseId, existing) {
+  const existingIds = new Set(existing.map((item) => item.id));
+  if (!existingIds.has(baseId)) {
+    return { id: baseId, changed: false };
+  }
+  let index = 0;
+  let newId;
+  do {
+    const suffix = generateSuffix(index);
+    newId = `${baseId}${suffix}`;
+    index++;
+  } while (existingIds.has(newId));
+  return { id: newId, changed: true };
+}
+async function add(existing, newItem, options) {
+  if (!options.force) {
+    const duplicateResult = detectDuplicate(newItem, existing);
+    if (duplicateResult.matches.length > 0) {
+      return {
+        added: false,
+        item: newItem,
+        idChanged: false,
+        duplicate: duplicateResult.matches[0]
+      };
+    }
+  }
+  const originalId = newItem.id;
+  const { id, changed } = resolveIdCollision(originalId, existing);
+  const finalItem = {
+    ...newItem,
+    id
+  };
+  return {
+    added: true,
+    item: finalItem,
+    idChanged: changed,
+    originalId: changed ? originalId : void 0
+  };
+}
+function mapEntryType(cslType) {
+  const typeMap = {
+    article: "article",
+    "article-journal": "article",
+    "article-magazine": "article",
+    "article-newspaper": "article",
+    book: "book",
+    chapter: "inbook",
+    "paper-conference": "inproceedings",
+    thesis: "phdthesis",
+    report: "techreport",
+    webpage: "misc"
+  };
+  return typeMap[cslType] || "misc";
+}
+function formatBibtexAuthor(author) {
+  if (author.literal) {
+    return author.literal;
+  }
+  const family = author.family || "";
+  const given = author.given || "";
+  return given ? `${family}, ${given}` : family;
+}
+function formatBibtexAuthors(authors) {
+  return authors.map(formatBibtexAuthor).join(" and ");
+}
+function formatField(name, value) {
+  return `  ${name} = {${value}},`;
+}
+function addBasicFields(lines, item) {
+  if (item.title) {
+    lines.push(formatField("title", item.title));
+  }
+  if (item.author && item.author.length > 0) {
+    lines.push(formatField("author", formatBibtexAuthors(item.author)));
+  }
+  const year = item.issued?.["date-parts"]?.[0]?.[0];
+  if (year) {
+    lines.push(formatField("year", String(year)));
+  }
+}
+function addPublicationDetails(lines, item, entryType) {
+  if (item["container-title"]) {
+    if (entryType === "article") {
+      lines.push(formatField("journal", item["container-title"]));
+    } else if (entryType === "inbook" || entryType === "inproceedings") {
+      lines.push(formatField("booktitle", item["container-title"]));
+    }
+  }
+  if (item.volume) {
+    lines.push(formatField("volume", item.volume));
+  }
+  if (item.issue) {
+    lines.push(formatField("number", item.issue));
+  }
+  if (item.page) {
+    lines.push(formatField("pages", item.page));
+  }
+  if (item.publisher) {
+    lines.push(formatField("publisher", item.publisher));
+  }
+}
+function addIdentifierFields(lines, item) {
+  if (item.DOI) {
+    lines.push(formatField("doi", item.DOI));
+  }
+  if (item.URL) {
+    lines.push(formatField("url", item.URL));
+  }
+  if (item.PMID) {
+    lines.push(formatField("note", `PMID: ${item.PMID}`));
+  } else if (item.PMCID) {
+    lines.push(formatField("note", `PMCID: ${item.PMCID}`));
+  }
+}
+function formatSingleBibtexEntry(ref) {
+  const item = ref.getItem();
+  const entryType = mapEntryType(item.type);
+  const lines = [];
+  lines.push(`@${entryType}{${item.id},`);
+  addBasicFields(lines, item);
+  addPublicationDetails(lines, item, entryType);
+  addIdentifierFields(lines, item);
+  lines.push("}");
+  return lines.join("\n");
+}
+function formatBibtex(references) {
+  if (references.length === 0) {
+    return "";
+  }
+  return references.map(formatSingleBibtexEntry).join("\n\n");
+}
+function formatJson(references) {
+  const items = references.map((ref) => ref.getItem());
+  return JSON.stringify(items);
+}
+function formatAuthor(author) {
+  const family = author.family || "";
+  const givenInitial = author.given ? `${author.given.charAt(0)}.` : "";
+  return givenInitial ? `${family}, ${givenInitial}` : family;
+}
+function formatAuthors(authors) {
+  return authors.map(formatAuthor).join("; ");
+}
+function formatSingleReference(ref) {
+  const item = ref.getItem();
+  const lines = [];
+  const header = item.title ? `[${item.id}] ${item.title}` : `[${item.id}]`;
+  lines.push(header);
+  if (item.author && item.author.length > 0) {
+    lines.push(`  Authors: ${formatAuthors(item.author)}`);
+  }
+  const year = item.issued?.["date-parts"]?.[0]?.[0];
+  lines.push(`  Year: ${year || "(no year)"}`);
+  lines.push(`  Type: ${item.type}`);
+  if (item.DOI) {
+    lines.push(`  DOI: ${item.DOI}`);
+  }
+  if (item.PMID) {
+    lines.push(`  PMID: ${item.PMID}`);
+  }
+  if (item.PMCID) {
+    lines.push(`  PMCID: ${item.PMCID}`);
+  }
+  if (item.URL) {
+    lines.push(`  URL: ${item.URL}`);
+  }
+  lines.push(`  UUID: ${ref.getUuid()}`);
+  return lines.join("\n");
+}
+function formatPretty(references) {
+  if (references.length === 0) {
+    return "";
+  }
+  return references.map(formatSingleReference).join("\n\n");
+}
+async function list(items, options) {
+  const outputOptions = [options.json, options.idsOnly, options.uuid, options.bibtex].filter(
+    Boolean
+  );
+  if (outputOptions.length > 1) {
+    throw new Error(
+      "Multiple output formats specified. Only one of --json, --ids-only, --uuid, --bibtex can be used."
+    );
+  }
+  const references = items.map((item) => new Reference(item));
+  if (options.json) {
+    process.stdout.write(formatJson(references));
+  } else if (options.idsOnly) {
+    for (const item of items) {
+      process.stdout.write(`${item.id}
+`);
+    }
+  } else if (options.uuid) {
+    for (const item of items) {
+      if (item.custom) {
+        process.stdout.write(`${item.custom.uuid}
+`);
+      }
+    }
+  } else if (options.bibtex) {
+    process.stdout.write(formatBibtex(references));
+  } else {
+    process.stdout.write(formatPretty(references));
+  }
+}
+async function search(items, query, options) {
+  const outputOptions = [options.json, options.idsOnly, options.uuid, options.bibtex].filter(
+    Boolean
+  );
+  if (outputOptions.length > 1) {
+    throw new Error(
+      "Multiple output formats specified. Only one of --json, --ids-only, --uuid, --bibtex can be used."
+    );
+  }
+  const searchQuery = tokenize(query);
+  const results = search$1(items, searchQuery.tokens);
+  const sorted = sortResults(results);
+  const matchedItems = sorted.map((result) => result.reference);
+  const references = matchedItems.map((item) => new Reference(item));
+  if (options.json) {
+    process.stdout.write(formatJson(references));
+  } else if (options.idsOnly) {
+    for (const item of matchedItems) {
+      process.stdout.write(`${item.id}
+`);
+    }
+  } else if (options.uuid) {
+    for (const item of matchedItems) {
+      if (item.custom) {
+        process.stdout.write(`${item.custom.uuid}
+`);
+      }
+    }
+  } else if (options.bibtex) {
+    process.stdout.write(formatBibtex(references));
+  } else {
+    process.stdout.write(formatPretty(references));
+  }
+}
+async function serverStart(options) {
+  const existingStatus = await serverStatus(options.portfilePath);
+  if (existingStatus !== null) {
+    throw new Error("Server is already running");
+  }
+  const port = options.port ?? 3e3;
+  const pid = process.pid;
+  const started_at = (/* @__PURE__ */ new Date()).toISOString();
+  await writePortfile(options.portfilePath, port, pid, options.library, started_at);
+}
+async function serverStop(portfilePath) {
+  const status = await serverStatus(portfilePath);
+  if (status === null) {
+    throw new Error("Server is not running");
+  }
+  await removePortfile(portfilePath);
+  process.stdout.write("Server stopped successfully\n");
+}
+async function serverStatus(portfilePath) {
+  const portfileData = await readPortfile(portfilePath);
+  if (portfileData === null) {
+    return null;
+  }
+  if (!isProcessRunning(portfileData.pid)) {
+    await removePortfile(portfilePath);
+    return null;
+  }
+  const result = {
+    port: portfileData.port,
+    pid: portfileData.pid,
+    library: portfileData.library ?? ""
+  };
+  if (portfileData.started_at !== void 0) {
+    result.started_at = portfileData.started_at;
+  }
+  return result;
+}
+async function update(items, identifier, updates, options) {
+  let foundIndex = -1;
+  if (options.byUuid) {
+    foundIndex = items.findIndex((item) => item.custom?.uuid === identifier);
+  } else {
+    foundIndex = items.findIndex((item) => item.id === identifier);
+  }
+  if (foundIndex === -1) {
+    return {
+      updated: false,
+      items
+    };
+  }
+  const existingItem = items[foundIndex];
+  if (!existingItem) {
+    return {
+      updated: false,
+      items
+    };
+  }
+  const updatedItem = {
+    ...existingItem,
+    ...updates,
+    // Ensure required fields
+    id: updates.id ?? existingItem.id,
+    type: updates.type ?? existingItem.type,
+    // Preserve UUID and created_at
+    custom: {
+      ...existingItem.custom || {},
+      ...updates.custom || {},
+      uuid: existingItem.custom?.uuid || "",
+      created_at: existingItem.custom?.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+      // Update timestamp
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  const updatedItems = [...items.slice(0, foundIndex), updatedItem, ...items.slice(foundIndex + 1)];
+  return {
+    updated: true,
+    item: updatedItem,
+    items: updatedItems
+  };
+}
+async function readJsonInput(file) {
+  if (file) {
+    try {
+      return readFileSync(file, "utf-8");
+    } catch (error) {
+      throw new Error(
+        `I/O error: Cannot read file ${file}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function parseJsonInput(input) {
+  if (!input || input.trim() === "") {
+    throw new Error("Parse error: Empty input");
+  }
+  try {
+    return JSON.parse(input);
+  } catch (error) {
+    throw new Error(
+      `Parse error: Invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function loadConfigWithOverrides(options) {
+  const config = await loadConfig();
+  const overrides = {};
+  if (options.library) {
+    overrides.library = options.library;
+  }
+  if (options.quiet) {
+    overrides.logLevel = "silent";
+  } else if (options.verbose) {
+    overrides.logLevel = "debug";
+  } else if (options.logLevel) {
+    overrides.logLevel = options.logLevel;
+  }
+  if (options.backup !== void 0 || options.backupDir) {
+    overrides.backup = {
+      ...config.backup,
+      ...options.backup !== void 0 && { enabled: options.backup },
+      ...options.backupDir && { directory: options.backupDir }
+    };
+  }
+  return { ...config, ...overrides };
+}
+function isTTY() {
+  return Boolean(stdin.isTTY && stdout.isTTY);
+}
+async function readConfirmation(prompt) {
+  if (!isTTY()) {
+    return true;
+  }
+  stdout.write(`${prompt} (y/N): `);
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+    const input2 = Buffer.concat(chunks).toString("utf-8");
+    if (input2.includes("\n")) {
+      break;
+    }
+  }
+  const input = Buffer.concat(chunks).toString("utf-8").trim().toLowerCase();
+  return input === "y" || input === "yes";
+}
+class ServerClient {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Get all references from the server.
+   * @returns Array of CSL items
+   */
+  async getAll() {
+    const url = `${this.baseUrl}/api/references`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    return await response.json();
+  }
+  /**
+   * Find reference by UUID.
+   * @param uuid - Reference UUID
+   * @returns CSL item or null if not found
+   */
+  async findByUuid(uuid) {
+    const url = `${this.baseUrl}/api/references/${uuid}`;
+    const response = await fetch(url);
+    if (response.status === 404) {
+      return null;
+    }
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    return await response.json();
+  }
+  /**
+   * Add new reference to the library.
+   * @param item - CSL item to add
+   * @returns Created CSL item with UUID
+   */
+  async add(item) {
+    const url = `${this.baseUrl}/api/references`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(item)
+    });
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    return await response.json();
+  }
+  /**
+   * Update existing reference.
+   * @param uuid - Reference UUID
+   * @param item - Updated CSL item
+   * @returns Updated CSL item
+   */
+  async update(uuid, item) {
+    const url = `${this.baseUrl}/api/references/${uuid}`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(item)
+    });
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+    return await response.json();
+  }
+  /**
+   * Remove reference by UUID.
+   * @param uuid - Reference UUID
+   */
+  async remove(uuid) {
+    const url = `${this.baseUrl}/api/references/${uuid}`;
+    const response = await fetch(url, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      throw new Error(await response.text());
+    }
+  }
+}
+async function getServerConnection(libraryPath, config) {
+  const portfilePath = getPortfilePath();
+  const portfileData = await readPortfile(portfilePath);
+  if (!portfileData) {
+    if (config.server.autoStart) {
+      await startServerDaemon(libraryPath);
+      await waitForPortfile(5e3);
+      return await getServerConnection(libraryPath, config);
+    }
+    return null;
+  }
+  if (!isProcessRunning(portfileData.pid)) {
+    await removePortfile(portfilePath);
+    return null;
+  }
+  if (!portfileData.library || portfileData.library !== libraryPath) {
+    return null;
+  }
+  return {
+    baseUrl: `http://localhost:${portfileData.port}`,
+    pid: portfileData.pid
+  };
+}
+async function startServerDaemon(libraryPath, _config) {
+  const binaryPath = process.argv[1] || process.execPath;
+  const child = spawn(
+    process.execPath,
+    [binaryPath, "server", "start", "--daemon", "--library", libraryPath],
+    {
+      detached: true,
+      stdio: "ignore"
+    }
+  );
+  child.unref();
+}
+async function waitForPortfile(timeoutMs) {
+  const portfilePath = getPortfilePath();
+  const startTime = Date.now();
+  const checkInterval = 50;
+  while (Date.now() - startTime < timeoutMs) {
+    if (await portfileExists(portfilePath)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, checkInterval));
+  }
+  throw new Error(`Server failed to start: portfile not created within ${timeoutMs}ms`);
+}
+const version = "0.1.0";
+const description = "A local reference management tool using CSL-JSON as the single source of truth";
+const packageJson = {
+  version,
+  description
+};
+function createProgram() {
+  const program = new Command();
+  program.name("reference-manager").version(packageJson.version).description(packageJson.description);
+  program.option("--library <path>", "Override library file path").option("--log-level <level>", "Override log level (silent|info|debug)").option("--config <path>", "Use specific config file").option("--quiet", "Suppress all non-error output").option("--verbose", "Enable verbose output").option("--no-backup", "Disable backup creation").option("--backup-dir <path>", "Override backup directory");
+  registerListCommand(program);
+  registerSearchCommand(program);
+  registerAddCommand(program);
+  registerRemoveCommand(program);
+  registerUpdateCommand(program);
+  registerServerCommand(program);
+  return program;
+}
+function registerListCommand(program) {
+  program.command("list").description("List all references in the library").option("--json", "Output in JSON format").option("--ids-only", "Output only citation keys").option("--uuid", "Output only UUIDs").option("--bibtex", "Output in BibTeX format").action(async (options) => {
+    try {
+      const globalOpts = program.opts();
+      const config = await loadConfigWithOverrides({ ...globalOpts, ...options });
+      const server = await getServerConnection(config.library, config);
+      let items;
+      if (server) {
+        const client = new ServerClient(server.baseUrl);
+        items = await client.getAll();
+      } else {
+        const library = await Library.load(config.library);
+        items = library.getAll().map((ref) => ref.getItem());
+      }
+      await list(items, {
+        json: options.json,
+        idsOnly: options.idsOnly,
+        uuid: options.uuid,
+        bibtex: options.bibtex
+      });
+      process.exit(0);
+    } catch (error) {
+      process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+      process.exit(4);
+    }
+  });
+}
+function registerSearchCommand(program) {
+  program.command("search").description("Search references").argument("<query>", "Search query").option("--json", "Output in JSON format").option("--ids-only", "Output only citation keys").option("--uuid", "Output only UUIDs").option("--bibtex", "Output in BibTeX format").action(async (query, options) => {
+    try {
+      const globalOpts = program.opts();
+      const config = await loadConfigWithOverrides({ ...globalOpts, ...options });
+      const server = await getServerConnection(config.library, config);
+      let items;
+      if (server) {
+        const client = new ServerClient(server.baseUrl);
+        items = await client.getAll();
+      } else {
+        const library = await Library.load(config.library);
+        items = library.getAll().map((ref) => ref.getItem());
+      }
+      await search(items, query, {
+        json: options.json,
+        idsOnly: options.idsOnly,
+        uuid: options.uuid,
+        bibtex: options.bibtex
+      });
+      process.exit(0);
+    } catch (error) {
+      process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+      process.exit(4);
+    }
+  });
+}
+async function addViaServer(items, server, force) {
+  const client = new ServerClient(server.baseUrl);
+  for (const item of items) {
+    try {
+      await client.add(item);
+      process.stderr.write(`Added reference: [${item.id}]
+`);
+    } catch (error) {
+      if (!force && error instanceof Error && error.message.includes("Duplicate")) {
+        process.stderr.write(`Error: ${error.message}
+`);
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+}
+async function addViaLibrary(items, libraryPath, force) {
+  const library = await Library.load(libraryPath);
+  const existingItems = library.getAll().map((ref) => ref.getItem());
+  for (const item of items) {
+    const result = await add(existingItems, item, { force });
+    if (result.added) {
+      library.add(result.item);
+      process.stderr.write(`Added reference: [${result.item.id}]
+`);
+      existingItems.push(result.item);
+    } else if (result.duplicate) {
+      throw new Error(
+        `Duplicate detected: ${result.duplicate.type} match with existing reference [${result.duplicate.existing.id}]`
+      );
+    }
+  }
+  await library.save();
+}
+function handleAddError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("Parse error")) {
+    process.stderr.write(`Error: ${message}
+`);
+    process.exit(3);
+  }
+  if (message.includes("Duplicate")) {
+    process.stderr.write(`Error: ${message}
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(4);
+}
+async function handleAddAction(file, options, program) {
+  try {
+    const globalOpts = program.opts();
+    const config = await loadConfigWithOverrides({ ...globalOpts, ...options });
+    const inputStr = await readJsonInput(file);
+    const input = parseJsonInput(inputStr);
+    const items = Array.isArray(input) ? input : [input];
+    const server = await getServerConnection(config.library, config);
+    if (server) {
+      await addViaServer(items, server, options.force ?? false);
+    } else {
+      await addViaLibrary(items, config.library, options.force ?? false);
+    }
+    process.exit(0);
+  } catch (error) {
+    handleAddError(error);
+  }
+}
+function registerAddCommand(program) {
+  program.command("add").description("Add new reference(s) to the library").argument("[file]", "JSON file to add (or use stdin)").option("-f, --force", "Skip duplicate detection").action(async (file, options) => {
+    await handleAddAction(file, options, program);
+  });
+}
+async function findReferenceToRemove(identifier, byUuid, server, libraryPath) {
+  if (server) {
+    const client = new ServerClient(server.baseUrl);
+    const items = await client.getAll();
+    return byUuid ? items.find((item) => item.custom?.uuid === identifier) : items.find((item) => item.id === identifier);
+  }
+  const library = await Library.load(libraryPath);
+  const ref = byUuid ? library.findByUuid(identifier) : library.findById(identifier);
+  return ref?.getItem();
+}
+async function confirmRemoval(refToRemove, force) {
+  if (force || !isTTY()) {
+    return true;
+  }
+  const authors = Array.isArray(refToRemove.author) ? refToRemove.author.map((a) => `${a.family || ""}, ${a.given?.[0] || ""}.`).join("; ") : "(no authors)";
+  const confirmMsg = `Remove reference [${refToRemove.id}]?
+Title: ${refToRemove.title || "(no title)"}
+Authors: ${authors}
+Continue?`;
+  return await readConfirmation(confirmMsg);
+}
+async function removeReference(identifier, refToRemove, byUuid, server, libraryPath) {
+  if (server) {
+    const client = new ServerClient(server.baseUrl);
+    if (!refToRemove.custom?.uuid) {
+      throw new Error("Reference missing UUID");
+    }
+    await client.remove(refToRemove.custom.uuid);
+    return;
+  }
+  const library = await Library.load(libraryPath);
+  const removed = byUuid ? library.removeByUuid(identifier) : library.removeById(identifier);
+  if (!removed) {
+    throw new Error("Reference not found");
+  }
+  await library.save();
+}
+function handleRemoveError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("not found")) {
+    process.stderr.write(`Error: ${message}
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(4);
+}
+async function handleRemoveAction(identifier, options, program) {
+  try {
+    const globalOpts = program.opts();
+    const config = await loadConfigWithOverrides({ ...globalOpts, ...options });
+    const server = await getServerConnection(config.library, config);
+    const refToRemove = await findReferenceToRemove(
+      identifier,
+      options.uuid ?? false,
+      server,
+      config.library
+    );
+    if (!refToRemove) {
+      process.stderr.write(`Error: Reference not found: ${identifier}
+`);
+      process.exit(1);
+    }
+    const confirmed = await confirmRemoval(refToRemove, options.force ?? false);
+    if (!confirmed) {
+      process.stderr.write("Cancelled.\n");
+      process.exit(2);
+    }
+    await removeReference(identifier, refToRemove, options.uuid ?? false, server, config.library);
+    process.stderr.write(`Removed reference: [${refToRemove.id}]
+`);
+    process.exit(0);
+  } catch (error) {
+    handleRemoveError(error);
+  }
+}
+function registerRemoveCommand(program) {
+  program.command("remove").description("Remove a reference from the library").argument("<identifier>", "Citation key or UUID").option("--uuid", "Interpret identifier as UUID").option("-f, --force", "Skip confirmation prompt").action(async (identifier, options) => {
+    await handleRemoveAction(identifier, options, program);
+  });
+}
+async function updateViaServer(identifier, updates, byUuid, server) {
+  const client = new ServerClient(server.baseUrl);
+  const items = await client.getAll();
+  const refToUpdate = byUuid ? items.find((item) => item.custom?.uuid === identifier) : items.find((item) => item.id === identifier);
+  if (!refToUpdate || !refToUpdate.custom?.uuid) {
+    process.stderr.write(`Error: Reference not found: ${identifier}
+`);
+    process.exit(1);
+  }
+  const updatedItem = { ...refToUpdate, ...updates };
+  await client.update(refToUpdate.custom.uuid, updatedItem);
+}
+async function updateViaLibrary(identifier, updates, byUuid, libraryPath) {
+  const library = await Library.load(libraryPath);
+  const items = library.getAll().map((ref) => ref.getItem());
+  const result = await update(items, identifier, updates, { byUuid });
+  if (!result.updated || !result.item) {
+    throw new Error("Reference not found");
+  }
+  if (result.item.custom?.uuid) {
+    library.removeByUuid(result.item.custom.uuid);
+    library.add(result.item);
+  }
+  await library.save();
+}
+function handleUpdateError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("Parse error")) {
+    process.stderr.write(`Error: ${message}
+`);
+    process.exit(3);
+  }
+  if (message.includes("not found") || message.includes("validation")) {
+    process.stderr.write(`Error: ${message}
+`);
+    process.exit(1);
+  }
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(4);
+}
+async function handleUpdateAction(identifier, file, options, program) {
+  try {
+    const globalOpts = program.opts();
+    const config = await loadConfigWithOverrides({ ...globalOpts, ...options });
+    const inputStr = await readJsonInput(file);
+    const updates = parseJsonInput(inputStr);
+    const updatesSchema = z.record(z.string(), z.unknown());
+    const validatedUpdates = updatesSchema.parse(updates);
+    const server = await getServerConnection(config.library, config);
+    if (server) {
+      await updateViaServer(identifier, validatedUpdates, options.uuid ?? false, server);
+    } else {
+      await updateViaLibrary(
+        identifier,
+        validatedUpdates,
+        options.uuid ?? false,
+        config.library
+      );
+    }
+    process.stderr.write(`Updated reference: [${identifier}]
+`);
+    process.exit(0);
+  } catch (error) {
+    handleUpdateError(error);
+  }
+}
+function registerUpdateCommand(program) {
+  program.command("update").description("Update fields of an existing reference").argument("<identifier>", "Citation key or UUID").argument("[file]", "JSON file with updates (or use stdin)").option("--uuid", "Interpret identifier as UUID").action(async (identifier, file, options) => {
+    await handleUpdateAction(identifier, file, options, program);
+  });
+}
+function registerServerCommand(program) {
+  const serverCmd = program.command("server").description("Manage HTTP server for library access");
+  serverCmd.command("start").description("Start HTTP server").option("--port <port>", "Specify port number").option("-d, --daemon", "Run in background").action(async (options) => {
+    try {
+      const globalOpts = program.opts();
+      const config = await loadConfigWithOverrides({ ...globalOpts, ...options });
+      const portfilePath = getPortfilePath();
+      const startOptions = {
+        library: config.library,
+        portfilePath,
+        daemon: options.daemon,
+        ...options.port && { port: Number.parseInt(options.port, 10) }
+      };
+      await serverStart(startOptions);
+      process.exit(0);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("already running") || message.includes("conflict")) {
+        process.stderr.write(`Error: ${message}
+`);
+        process.exit(1);
+      }
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(4);
+    }
+  });
+  serverCmd.command("stop").description("Stop running server").action(async () => {
+    try {
+      const portfilePath = getPortfilePath();
+      await serverStop(portfilePath);
+      process.stderr.write("Server stopped.\n");
+      process.exit(0);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("not running")) {
+        process.stderr.write(`Error: ${message}
+`);
+        process.exit(1);
+      }
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(4);
+    }
+  });
+  serverCmd.command("status").description("Check server status").action(async () => {
+    try {
+      const portfilePath = getPortfilePath();
+      const status = await serverStatus(portfilePath);
+      if (status) {
+        process.stdout.write(
+          `Server is running
+Port: ${status.port}
+PID: ${status.pid}
+Library: ${status.library}
+`
+        );
+        process.exit(0);
+      } else {
+        process.stdout.write("Server not running\n");
+        process.exit(1);
+      }
+    } catch (error) {
+      process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+      process.exit(4);
+    }
+  });
+}
+async function main(argv) {
+  const program = createProgram();
+  process.on("SIGINT", () => {
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    process.exit(0);
+  });
+  await program.parseAsync(argv);
+}
+export {
+  createProgram,
+  main
+};
+//# sourceMappingURL=cli.js.map