@ncukondo/reference-manager 0.7.1 → 0.9.0

package/dist/cli.js

@@ -1,25 +1,127 @@
 import { Command } from "commander";
 import { ZodOptional as ZodOptional$2, z } from "zod";
-import { p as pickDefined, q as sortOrderSchema, r as paginationOptionsSchema, L as Library, F as FileWatcher, u as sortFieldSchema, v as searchSortFieldSchema } from "./chunks/file-watcher-D7oyc-9z.js";
+import { p as pickDefined, q as sortOrderSchema, r as paginationOptionsSchema, L as Library, F as FileWatcher, u as sortFieldSchema, v as searchSortFieldSchema } from "./chunks/file-watcher-DdhXSm1l.js";
 import { promises, existsSync, mkdtempSync, writeFileSync, readFileSync } from "node:fs";
 import * as os from "node:os";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
 import { join, extname } from "node:path";
 import { mkdir, unlink, rename, copyFile, rm, readFile } from "node:fs/promises";
-import { u as updateReference, B as BUILTIN_STYLES, s as startServerWithFileWatcher } from "./chunks/index-_7NEUoS7.js";
+import { u as updateReference, B as BUILTIN_STYLES, s as startServerWithFileWatcher, g as getFulltextAttachmentTypes } from "./chunks/index-DmMZCOno.js";
+import { o as openWithSystemApp, l as loadConfig } from "./chunks/loader-C-bdImuO.js";
 import process$1, { stdin, stdout } from "node:process";
-import { l as loadConfig } from "./chunks/loader-BItrdVWG.js";
 import { spawn } from "node:child_process";
 import { serve } from "@hono/node-server";
 const name = "@ncukondo/reference-manager";
-const version$1 = "0.7.1";
+const version$1 = "0.9.0";
 const description$1 = "A local reference management tool using CSL-JSON as the single source of truth";
 const packageJson = {
   name,
   version: version$1,
   description: description$1
 };
+function formatAddJsonOutput(result, options) {
+  const { full = false, sources = /* @__PURE__ */ new Map(), items: items2 = /* @__PURE__ */ new Map() } = options;
+  const added = result.added.map((item) => {
+    const output = {
+      source: sources.get(item.id) ?? "",
+      id: item.id,
+      uuid: item.uuid,
+      title: item.title
+    };
+    if (item.idChanged && item.originalId) {
+      output.idChanged = true;
+      output.originalId = item.originalId;
+    }
+    if (full) {
+      const cslItem = items2.get(item.id);
+      if (cslItem) {
+        output.item = cslItem;
+      }
+    }
+    return output;
+  });
+  const skipped = result.skipped.map((item) => ({
+    source: item.source,
+    reason: "duplicate",
+    existingId: item.existingId,
+    duplicateType: item.duplicateType
+  }));
+  const failed = result.failed.map((item) => ({
+    source: item.source,
+    reason: item.reason,
+    error: item.error
+  }));
+  return {
+    summary: {
+      total: added.length + skipped.length + failed.length,
+      added: added.length,
+      skipped: skipped.length,
+      failed: failed.length
+    },
+    added,
+    skipped,
+    failed
+  };
+}
+function formatRemoveJsonOutput(result, id2, options) {
+  const { full = false } = options;
+  if (!result.removed || !result.removedItem) {
+    return {
+      success: false,
+      id: id2,
+      error: `Reference not found: ${id2}`
+    };
+  }
+  const uuid2 = result.removedItem.custom?.uuid;
+  const output = {
+    success: true,
+    id: id2,
+    ...uuid2 && { uuid: uuid2 },
+    title: typeof result.removedItem.title === "string" ? result.removedItem.title : ""
+  };
+  if (full) {
+    output.item = result.removedItem;
+  }
+  return output;
+}
+function formatUpdateJsonOutput(result, originalId, options) {
+  const { full = false, before } = options;
+  if (!result.updated || !result.item) {
+    if (result.idCollision) {
+      return {
+        success: false,
+        id: originalId,
+        error: "ID collision: target ID already exists"
+      };
+    }
+    return {
+      success: false,
+      id: originalId,
+      error: `Reference not found: ${originalId}`
+    };
+  }
+  const item = result.item;
+  const uuid2 = item.custom?.uuid;
+  const finalId = result.idChanged && result.newId ? result.newId : item.id ?? originalId;
+  const output = {
+    success: true,
+    id: finalId,
+    ...uuid2 && { uuid: uuid2 },
+    title: typeof item.title === "string" ? item.title : ""
+  };
+  if (result.idChanged && result.newId) {
+    output.idChanged = true;
+    output.previousId = originalId;
+  }
+  if (full) {
+    if (before) {
+      output.before = before;
+    }
+    output.after = item;
+  }
+  return output;
+}
 function getPortfilePath() {
   const tmpDir = os.tmpdir();
   return path.join(tmpDir, "reference-manager", "server.port");
@@ -607,6 +709,54 @@ async function fulltextDetach(library, options) {
     return handleDetachError(error);
   }
 }
+function getFulltextPath(item, type2, fulltextDirectory) {
+  const fulltext = item.custom?.fulltext;
+  if (!fulltext) return void 0;
+  const filename = type2 === "pdf" ? fulltext.pdf : fulltext.markdown;
+  if (!filename) return void 0;
+  return join(fulltextDirectory, filename);
+}
+function determineTypeToOpen(item) {
+  const fulltext = item.custom?.fulltext;
+  if (!fulltext) return void 0;
+  if (fulltext.pdf) return "pdf";
+  if (fulltext.markdown) return "markdown";
+  return void 0;
+}
+async function fulltextOpen(library, options) {
+  const { identifier, type: type2, idType = "id", fulltextDirectory } = options;
+  const item = await library.find(identifier, { idType });
+  if (!item) {
+    return { success: false, error: `Reference not found: ${identifier}` };
+  }
+  const typeToOpen = type2 ?? determineTypeToOpen(item);
+  if (!typeToOpen) {
+    return { success: false, error: `No fulltext attached to reference: ${identifier}` };
+  }
+  const filePath = getFulltextPath(item, typeToOpen, fulltextDirectory);
+  if (!filePath) {
+    return { success: false, error: `No ${typeToOpen} attached to reference: ${identifier}` };
+  }
+  if (!existsSync(filePath)) {
+    return {
+      success: false,
+      error: `Fulltext file not found: ${filePath} (metadata exists but file is missing)`
+    };
+  }
+  try {
+    await openWithSystemApp(filePath);
+    return {
+      success: true,
+      openedType: typeToOpen,
+      openedPath: filePath
+    };
+  } catch (_error) {
+    return {
+      success: false,
+      error: `Failed to open file: ${filePath}`
+    };
+  }
+}
 async function executeFulltextAttach(options, context) {
   const operationOptions = {
     identifier: options.identifier,
@@ -640,6 +790,15 @@ async function executeFulltextDetach(options, context) {
   };
   return fulltextDetach(context.library, operationOptions);
 }
+async function executeFulltextOpen(options, context) {
+  const operationOptions = {
+    identifier: options.identifier,
+    type: options.type,
+    idType: options.idType,
+    fulltextDirectory: options.fulltextDirectory
+  };
+  return fulltextOpen(context.library, operationOptions);
+}
 function formatFulltextAttachOutput(result) {
   if (result.requiresConfirmation) {
     return `File already attached: ${result.existingFile}
@@ -686,6 +845,12 @@ function formatFulltextDetachOutput(result) {
   }
   return lines.join("\n");
 }
+function formatFulltextOpenOutput(result) {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+  return `Opened ${result.openedType}: ${result.openedPath}`;
+}
 function getFulltextExitCode(result) {
   return result.success ? 0 : 1;
 }
@@ -20959,19 +21124,19 @@ class OperationsLibrary {
   }
   // High-level operations
   async search(options) {
-    const { searchReferences } = await import("./chunks/index-_7NEUoS7.js").then((n) => n.e);
+    const { searchReferences } = await import("./chunks/index-DmMZCOno.js").then((n) => n.e);
     return searchReferences(this.library, options);
   }
   async list(options) {
-    const { listReferences } = await import("./chunks/index-_7NEUoS7.js").then((n) => n.l);
+    const { listReferences } = await import("./chunks/index-DmMZCOno.js").then((n) => n.l);
     return listReferences(this.library, options ?? {});
   }
   async cite(options) {
-    const { citeReferences } = await import("./chunks/index-_7NEUoS7.js").then((n) => n.d);
+    const { citeReferences } = await import("./chunks/index-DmMZCOno.js").then((n) => n.d);
     return citeReferences(this.library, options);
   }
   async import(inputs, options) {
-    const { addReferences } = await import("./chunks/index-_7NEUoS7.js").then((n) => n.b);
+    const { addReferences } = await import("./chunks/index-DmMZCOno.js").then((n) => n.b);
     return addReferences(inputs, this.library, options ?? {});
   }
 }
@@ -21484,7 +21649,16 @@ async function mcpStart(options) {
   return result;
 }
 async function executeRemove(options, context) {
-  const { identifier, idType = "id" } = options;
+  const { identifier, idType = "id", fulltextDirectory, deleteFulltext = false } = options;
+  if (context.mode === "local" && deleteFulltext && fulltextDirectory) {
+    const { removeReference } = await import("./chunks/index-DmMZCOno.js").then((n) => n.r);
+    return removeReference(context.library, {
+      identifier,
+      idType,
+      fulltextDirectory,
+      deleteFulltext
+    });
+  }
   return context.library.remove(identifier, { idType });
 }
 function formatRemoveOutput(result, identifier) {
@@ -21492,46 +21666,24 @@ function formatRemoveOutput(result, identifier) {
     return `Reference not found: ${identifier}`;
   }
   const item = result.removedItem;
+  let output = "";
   if (item) {
-    return `Removed: [${item.id}] ${item.title || "(no title)"}`;
-  }
-  return `Removed reference: ${identifier}`;
-}
-function getFulltextAttachmentTypes(item) {
-  const types2 = [];
-  const fulltext = item.custom?.fulltext;
-  if (fulltext?.pdf) {
-    types2.push("pdf");
+    output = `Removed: [${item.id}] ${item.title || "(no title)"}`;
+  } else {
+    output = `Removed reference: ${identifier}`;
   }
-  if (fulltext?.markdown) {
-    types2.push("markdown");
+  if (result.deletedFulltextTypes && result.deletedFulltextTypes.length > 0) {
+    const typeLabels = result.deletedFulltextTypes.map((t) => t === "pdf" ? "PDF" : "Markdown");
+    output += `
+Deleted fulltext files: ${typeLabels.join(" and ")}`;
   }
-  return types2;
+  return output;
 }
 function formatFulltextWarning(types2) {
   const typeLabels = types2.map((t) => t === "pdf" ? "PDF" : "Markdown");
   const fileTypes = typeLabels.join(" and ");
   return `Warning: This reference has fulltext files attached (${fileTypes}). Use --force to also delete the fulltext files.`;
 }
-async function deleteFulltextFiles(item, fulltextDirectory) {
-  const fulltext = item.custom?.fulltext;
-  if (!fulltext) {
-    return;
-  }
-  const filesToDelete = [];
-  if (fulltext.pdf) {
-    filesToDelete.push(join(fulltextDirectory, fulltext.pdf));
-  }
-  if (fulltext.markdown) {
-    filesToDelete.push(join(fulltextDirectory, fulltext.markdown));
-  }
-  for (const filePath of filesToDelete) {
-    try {
-      await unlink(filePath);
-    } catch {
-    }
-  }
-}
 const VALID_SEARCH_SORT_FIELDS = /* @__PURE__ */ new Set([
   "created",
   "updated",
@@ -21628,9 +21780,9 @@ async function executeInteractiveSearch(options, context, config2) {
   validateInteractiveOptions(options);
   const { checkTTY } = await import("./chunks/tty-CDBIQraQ.js");
   const { runSearchPrompt } = await import("./chunks/search-prompt-RtHDJFgL.js");
-  const { runActionMenu } = await import("./chunks/action-menu-CTtINmWd.js");
-  const { search } = await import("./chunks/file-watcher-D7oyc-9z.js").then((n) => n.y);
-  const { tokenize } = await import("./chunks/file-watcher-D7oyc-9z.js").then((n) => n.x);
+  const { runActionMenu } = await import("./chunks/action-menu-BN2HHFPR.js");
+  const { search } = await import("./chunks/file-watcher-DdhXSm1l.js").then((n) => n.y);
+  const { tokenize } = await import("./chunks/file-watcher-DdhXSm1l.js").then((n) => n.x);
   checkTTY();
   const allReferences = await context.library.getAll();
   const searchFn = (query) => {
@@ -21740,9 +21892,181 @@ async function serverStatus(portfilePath) {
   }
   return result;
 }
+function parseSetOption(input) {
+  const match = input.match(/^([a-zA-Z][a-zA-Z0-9_.]*)([\+\-]?=)(.*)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid --set syntax: "${input}". Use field=value, field+=value, or field-=value`
+    );
+  }
+  return {
+    field: match[1],
+    operator: match[2],
+    value: match[3]
+  };
+}
+const PROTECTED_FIELDS = /* @__PURE__ */ new Set([
+  "custom.uuid",
+  "custom.created_at",
+  "custom.timestamp",
+  "custom.fulltext"
+]);
+const STRING_FIELDS = /* @__PURE__ */ new Set([
+  "title",
+  "abstract",
+  "type",
+  "DOI",
+  "PMID",
+  "PMCID",
+  "ISBN",
+  "ISSN",
+  "URL",
+  "publisher",
+  "publisher-place",
+  "page",
+  "volume",
+  "issue",
+  "container-title",
+  "note",
+  "id"
+]);
+const ARRAY_FIELDS = /* @__PURE__ */ new Set(["custom.tags", "custom.additional_urls", "keyword"]);
+const NAME_FIELDS = /* @__PURE__ */ new Set(["author", "editor"]);
+const DATE_RAW_FIELDS = /* @__PURE__ */ new Set(["issued.raw", "accessed.raw"]);
+function parseAuthorValue(value) {
+  return value.split(";").map((author) => {
+    const trimmed = author.trim();
+    const parts = trimmed.split(",").map((p) => p.trim());
+    if (parts.length >= 2 && parts[0] && parts[1]) {
+      return { family: parts[0], given: parts[1] };
+    }
+    return { family: trimmed };
+  });
+}
+function applyArrayOperator(operator, value) {
+  if (operator === "+=") return { $add: value };
+  if (operator === "-=") return { $remove: value };
+  return value.split(",").map((v) => v.trim());
+}
+function handleCustomArrayField(result, field, operator, value) {
+  const child = field.split(".")[1];
+  if (!child) return;
+  if (!result.custom) result.custom = {};
+  result.custom[child] = applyArrayOperator(operator, value);
+}
+function applySingleOperation(result, op) {
+  const { field, operator, value } = op;
+  if (PROTECTED_FIELDS.has(field)) {
+    throw new Error(`Cannot set protected field: ${field}`);
+  }
+  if (STRING_FIELDS.has(field)) {
+    result[field] = value === "" ? void 0 : value;
+    return;
+  }
+  if (ARRAY_FIELDS.has(field)) {
+    if (field.startsWith("custom.")) {
+      handleCustomArrayField(result, field, operator, value);
+    } else {
+      result[field] = applyArrayOperator(operator, value);
+    }
+    return;
+  }
+  if (NAME_FIELDS.has(field)) {
+    result[field] = parseAuthorValue(value);
+    return;
+  }
+  if (DATE_RAW_FIELDS.has(field)) {
+    const dateField = field.split(".")[0];
+    if (dateField) result[dateField] = { raw: value };
+    return;
+  }
+  throw new Error(`Unsupported field: ${field}`);
+}
+function applySetOperations(operations) {
+  const result = {};
+  for (const op of operations) {
+    applySingleOperation(result, op);
+  }
+  return result;
+}
+function hasArrayOperations(updates) {
+  for (const value of Object.values(updates)) {
+    if (typeof value !== "object" || value === null) continue;
+    const obj = value;
+    if ("$add" in obj || "$remove" in obj) return true;
+    if (hasArrayOperations(obj)) return true;
+  }
+  return false;
+}
+function resolveArrayOperations(updates, existingItem) {
+  const result = {};
+  for (const [key, value] of Object.entries(updates)) {
+    if (key === "custom" && typeof value === "object" && value !== null) {
+      result.custom = resolveCustomArrayOperations(
+        value,
+        existingItem.custom
+      );
+    } else if (isArrayOperation(value)) {
+      result[key] = resolveTopLevelArrayOperation(
+        value,
+        existingItem[key]
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isArrayOperation(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return "$add" in obj || "$remove" in obj;
+}
+function resolveCustomArrayOperations(customUpdates, existingCustom) {
+  const result = {};
+  for (const [customKey, customValue] of Object.entries(customUpdates)) {
+    if (isArrayOperation(customValue)) {
+      const op = customValue;
+      const existingArray = existingCustom?.[customKey] ?? [];
+      result[customKey] = applyArrayOperation(existingArray, op);
+    } else {
+      result[customKey] = customValue;
+    }
+  }
+  return result;
+}
+function resolveTopLevelArrayOperation(op, existingArray) {
+  return applyArrayOperation(existingArray ?? [], op);
+}
+function applyArrayOperation(existingArray, op) {
+  const newArray = [...existingArray];
+  if ("$add" in op && op.$add && !newArray.includes(op.$add)) {
+    newArray.push(op.$add);
+  }
+  if ("$remove" in op && op.$remove) {
+    const idx = newArray.indexOf(op.$remove);
+    if (idx >= 0) newArray.splice(idx, 1);
+  }
+  return newArray;
+}
 async function executeUpdate(options, context) {
-  const { identifier, updates, idType = "id" } = options;
-  return context.library.update(identifier, updates, { idType });
+  const { identifier, idType = "id" } = options;
+  let { updates } = options;
+  if (hasArrayOperations(updates)) {
+    const existingItem = await context.library.find(identifier, { idType });
+    if (!existingItem) {
+      return { updated: false };
+    }
+    updates = resolveArrayOperations(
+      updates,
+      existingItem
+    );
+  }
+  const result = await context.library.update(identifier, updates, { idType });
+  if (result.updated) {
+    await context.library.save();
+  }
+  return result;
 }
 function formatUpdateOutput(result, identifier) {
   if (!result.updated) {
@@ -22005,7 +22329,7 @@ const OPTION_VALUES = {
   "--log-level": LOG_LEVELS
 };
 const ID_COMPLETION_COMMANDS = /* @__PURE__ */ new Set(["cite", "remove", "update"]);
-const ID_COMPLETION_FULLTEXT_SUBCOMMANDS = /* @__PURE__ */ new Set(["attach", "get", "detach"]);
+const ID_COMPLETION_FULLTEXT_SUBCOMMANDS = /* @__PURE__ */ new Set(["attach", "get", "detach", "open"]);
 function toCompletionItems(values) {
   return values.map((name2) => ({ name: name2 }));
 }
@@ -22357,7 +22681,53 @@ function registerSearchCommand(program) {
     await handleSearchAction(query ?? "", options, program);
   });
 }
+function buildAddOptions(inputs, options, config2, stdinContent) {
+  const addOptions = {
+    inputs,
+    force: options.force ?? false
+  };
+  if (options.format !== void 0) {
+    addOptions.format = options.format;
+  }
+  if (options.verbose !== void 0) {
+    addOptions.verbose = options.verbose;
+  }
+  if (stdinContent?.trim()) {
+    addOptions.stdinContent = stdinContent;
+  }
+  const pubmedConfig = {};
+  if (config2.pubmed.email !== void 0) {
+    pubmedConfig.email = config2.pubmed.email;
+  }
+  if (config2.pubmed.apiKey !== void 0) {
+    pubmedConfig.apiKey = config2.pubmed.apiKey;
+  }
+  if (Object.keys(pubmedConfig).length > 0) {
+    addOptions.pubmedConfig = pubmedConfig;
+  }
+  return addOptions;
+}
+async function outputAddResultJson(result, context, full) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const item of result.added) {
+    sources.set(item.id, "");
+  }
+  const items2 = /* @__PURE__ */ new Map();
+  if (full) {
+    for (const added of result.added) {
+      const item = await context.library.find(added.id, { idType: "id" });
+      if (item) {
+        items2.set(added.id, item);
+      }
+    }
+  }
+  const options = { full, sources, items: items2 };
+  const jsonOutput = formatAddJsonOutput(result, options);
+  process.stdout.write(`${JSON.stringify(jsonOutput)}
+`);
+}
 async function handleAddAction(inputs, options, program) {
+  const outputFormat = options.output ?? "text";
   try {
     const globalOpts = program.opts();
     const config2 = await loadConfigWithOverrides({ ...globalOpts, ...options });
@@ -22366,38 +22736,25 @@ async function handleAddAction(inputs, options, program) {
       stdinContent = await readStdinContent();
     }
     const context = await createExecutionContext(config2, Library.load);
-    const addOptions = {
-      inputs,
-      force: options.force ?? false
-    };
-    if (options.format !== void 0) {
-      addOptions.format = options.format;
-    }
-    if (options.verbose !== void 0) {
-      addOptions.verbose = options.verbose;
-    }
-    if (stdinContent?.trim()) {
-      addOptions.stdinContent = stdinContent;
-    }
-    const pubmedConfig = {};
-    if (config2.pubmed.email !== void 0) {
-      pubmedConfig.email = config2.pubmed.email;
-    }
-    if (config2.pubmed.apiKey !== void 0) {
-      pubmedConfig.apiKey = config2.pubmed.apiKey;
-    }
-    if (Object.keys(pubmedConfig).length > 0) {
-      addOptions.pubmedConfig = pubmedConfig;
-    }
+    const addOptions = buildAddOptions(inputs, options, config2, stdinContent);
     const result = await executeAdd(addOptions, context);
-    const output = formatAddOutput(result, options.verbose ?? false);
-    process.stderr.write(`${output}
+    if (outputFormat === "json") {
+      await outputAddResultJson(result, context, options.full ?? false);
+    } else {
+      const output = formatAddOutput(result, options.verbose ?? false);
+      process.stderr.write(`${output}
 `);
+    }
     process.exit(getExitCode(result));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`Error: ${message}
+    if (outputFormat === "json") {
+      process.stdout.write(`${JSON.stringify({ success: false, error: message })}
 `);
+    } else {
+      process.stderr.write(`Error: ${message}
+`);
+    }
     process.exit(1);
   }
 }
@@ -22406,102 +22763,99 @@ function registerAddCommand(program) {
     "--format <format>",
     "Explicit input format: json|bibtex|ris|pmid|doi|isbn|auto",
     "auto"
-  ).option("--verbose", "Show detailed error information").action(async (inputs, options) => {
+  ).option("--verbose", "Show detailed error information").option("-o, --output <format>", "Output format: json|text", "text").option("--full", "Include full CSL-JSON data in JSON output").action(async (inputs, options) => {
     await handleAddAction(inputs, options, program);
   });
 }
-async function findReferenceToRemove(identifier, useUuid, context) {
-  return context.library.find(identifier, { idType: useUuid ? "uuid" : "id" });
+function outputRemoveNotFoundAndExit(identifier, outputFormat) {
+  if (outputFormat === "json") {
+    const jsonOutput = formatRemoveJsonOutput({ removed: false }, identifier, {});
+    process.stdout.write(`${JSON.stringify(jsonOutput)}
+`);
+  } else {
+    process.stderr.write(`Error: Reference not found: ${identifier}
+`);
+  }
+  process.exit(1);
 }
-async function confirmRemoval(refToRemove, force, fulltextWarning) {
+function outputRemoveResult(result, identifier, outputFormat, full) {
+  if (outputFormat === "json") {
+    const jsonOutput = formatRemoveJsonOutput(result, identifier, { full });
+    process.stdout.write(`${JSON.stringify(jsonOutput)}
+`);
+  } else {
+    const output = formatRemoveOutput(result, identifier);
+    process.stderr.write(`${output}
+`);
+  }
+}
+async function confirmRemoveIfNeeded(item, hasFulltext, force) {
   if (force || !isTTY()) {
     return true;
   }
-  const authors = Array.isArray(refToRemove.author) ? refToRemove.author.map((a) => `${a.family || ""}, ${a.given?.[0] || ""}.`).join("; ") : "(no authors)";
-  let confirmMsg = `Remove reference [${refToRemove.id}]?
-Title: ${refToRemove.title || "(no title)"}
-Authors: ${authors}`;
-  if (fulltextWarning) {
-    confirmMsg += `
+  const authors = Array.isArray(item.author) ? item.author.map((a) => `${a.family || ""}, ${a.given?.[0] || ""}.`).join("; ") : "(no authors)";
+  const fulltextTypes = hasFulltext ? getFulltextAttachmentTypes(item) : [];
+  const warning = hasFulltext ? formatFulltextWarning(fulltextTypes) : "";
+  const warningPart = warning ? `
 
-${fulltextWarning}`;
-  }
-  confirmMsg += "\nContinue?";
-  return await readConfirmation(confirmMsg);
-}
-function handleRemoveError(error) {
+${warning}` : "";
+  const confirmMsg = `Remove reference [${item.id}]?
+Title: ${item.title || "(no title)"}
+Authors: ${authors}${warningPart}
+Continue?`;
+  return readConfirmation(confirmMsg);
+}
+function handleRemoveError(error, identifier, outputFormat) {
   const message = error instanceof Error ? error.message : String(error);
-  if (message.includes("not found")) {
+  if (outputFormat === "json") {
+    process.stdout.write(`${JSON.stringify({ success: false, id: identifier, error: message })}
+`);
+  } else {
     process.stderr.write(`Error: ${message}
 `);
-    process.exit(1);
   }
-  process.stderr.write(`Error: ${message}
-`);
-  process.exit(4);
-}
-function formatTypeLabels(types2) {
-  return types2.map((t) => t === "pdf" ? "PDF" : "Markdown").join(" and ");
-}
-async function handleFulltextDeletion(item, fulltextDirectory, types2, output) {
-  await deleteFulltextFiles(item, fulltextDirectory);
-  const typeLabels = formatTypeLabels(types2);
-  process.stderr.write(`${output}
-`);
-  process.stderr.write(`Deleted fulltext files: ${typeLabels}
-`);
+  process.exit(message.includes("not found") ? 1 : 4);
 }
 async function handleRemoveAction(identifier, options, program) {
+  const outputFormat = options.output ?? "text";
+  const useUuid = options.uuid ?? false;
+  const force = options.force ?? false;
   try {
     const globalOpts = program.opts();
     const config2 = await loadConfigWithOverrides({ ...globalOpts, ...options });
     const context = await createExecutionContext(config2, Library.load);
-    const refToRemove = await findReferenceToRemove(identifier, options.uuid ?? false, context);
+    const refToRemove = await context.library.find(identifier, { idType: useUuid ? "uuid" : "id" });
     if (!refToRemove) {
-      process.stderr.write(`Error: Reference not found: ${identifier}
-`);
-      process.exit(1);
+      outputRemoveNotFoundAndExit(identifier, outputFormat);
     }
     const fulltextTypes = getFulltextAttachmentTypes(refToRemove);
     const hasFulltext = fulltextTypes.length > 0;
-    if (hasFulltext && !isTTY() && !options.force) {
-      const warning = formatFulltextWarning(fulltextTypes);
-      process.stderr.write(`Error: ${warning}
+    const requiresForce = hasFulltext && !isTTY() && !force;
+    if (requiresForce) {
+      process.stderr.write(`Error: ${formatFulltextWarning(fulltextTypes)}
 `);
       process.exit(1);
     }
-    const fulltextWarning = hasFulltext && !options.force ? formatFulltextWarning(fulltextTypes) : void 0;
-    const confirmed = await confirmRemoval(refToRemove, options.force ?? false, fulltextWarning);
+    const confirmed = await confirmRemoveIfNeeded(refToRemove, hasFulltext, force);
     if (!confirmed) {
       process.stderr.write("Cancelled.\n");
       process.exit(2);
     }
     const removeOptions = {
-      identifier
+      identifier,
+      idType: useUuid ? "uuid" : "id",
+      fulltextDirectory: config2.fulltext.directory,
+      deleteFulltext: force && hasFulltext
     };
-    if (options.uuid) {
-      removeOptions.idType = "uuid";
-    }
     const result = await executeRemove(removeOptions, context);
-    const output = formatRemoveOutput(result, identifier);
-    if (!result.removed) {
-      process.stderr.write(`${output}
-`);
-      process.exit(1);
-    }
-    if (hasFulltext && options.force) {
-      await handleFulltextDeletion(refToRemove, config2.fulltext.directory, fulltextTypes, output);
-    } else {
-      process.stderr.write(`${output}
-`);
-    }
-    process.exit(0);
+    outputRemoveResult(result, identifier, outputFormat, options.full ?? false);
+    process.exit(result.removed ? 0 : 1);
   } catch (error) {
-    handleRemoveError(error);
+    handleRemoveError(error, identifier, outputFormat);
   }
 }
 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) => {
+  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").option("-o, --output <format>", "Output format: json|text", "text").option("--full", "Include full CSL-JSON data in JSON output").action(async (identifier, options) => {
     await handleRemoveAction(identifier, options, program);
   });
 }
@@ -22521,39 +22875,70 @@ function handleUpdateError(error) {
 `);
   process.exit(4);
 }
+function parseUpdateInput(setOptions, file) {
+  if (setOptions && setOptions.length > 0 && file) {
+    throw new Error("Cannot use --set with a file argument. Use one or the other.");
+  }
+  if (setOptions && setOptions.length > 0) {
+    const operations = setOptions.map((s) => parseSetOption(s));
+    return applySetOperations(operations);
+  }
+  return readJsonInput(file).then((inputStr) => {
+    const updates = parseJsonInput(inputStr);
+    const updatesSchema = z.record(z.string(), z.unknown());
+    return updatesSchema.parse(updates);
+  });
+}
+function outputUpdateResult(result, identifier, outputFormat, full, beforeItem) {
+  if (outputFormat === "json") {
+    const jsonOptions = {
+      full,
+      ...beforeItem && { before: beforeItem }
+    };
+    const jsonOutput = formatUpdateJsonOutput(result, identifier, jsonOptions);
+    process.stdout.write(`${JSON.stringify(jsonOutput)}
+`);
+  } else {
+    const output = formatUpdateOutput(result, identifier);
+    process.stderr.write(`${output}
+`);
+  }
+}
+function handleUpdateErrorWithFormat(error, identifier, outputFormat) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (outputFormat === "json") {
+    process.stdout.write(`${JSON.stringify({ success: false, id: identifier, error: message })}
+`);
+    process.exit(message.includes("not found") || message.includes("validation") ? 1 : 4);
+  }
+  handleUpdateError(error);
+}
 async function handleUpdateAction(identifier, file, options, program) {
+  const outputFormat = options.output ?? "text";
   try {
     const globalOpts = program.opts();
     const config2 = 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 validatedUpdates = await parseUpdateInput(options.set, file);
     const context = await createExecutionContext(config2, Library.load);
+    const idType = options.uuid ? "uuid" : "id";
+    const beforeItem = options.full ? await context.library.find(identifier, { idType }) : void 0;
     const updateOptions = {
       identifier,
-      updates: validatedUpdates
+      updates: validatedUpdates,
+      ...options.uuid && { idType: "uuid" }
     };
-    if (options.uuid) {
-      updateOptions.idType = "uuid";
-    }
     const result = await executeUpdate(updateOptions, context);
-    const output = formatUpdateOutput(result, identifier);
-    if (result.updated) {
-      process.stderr.write(`${output}
-`);
-      process.exit(0);
-    } else {
-      process.stderr.write(`${output}
-`);
-      process.exit(1);
-    }
+    outputUpdateResult(result, identifier, outputFormat, options.full ?? false, beforeItem);
+    process.exit(result.updated ? 0 : 1);
   } catch (error) {
-    handleUpdateError(error);
+    handleUpdateErrorWithFormat(error, identifier, outputFormat);
   }
 }
+function collectSetOption(value, previous) {
+  return previous.concat([value]);
+}
 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) => {
+  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").option("--set <field=value>", "Set field value (repeatable)", collectSetOption, []).option("-o, --output <format>", "Output format: json|text", "text").option("--full", "Include full CSL-JSON data in JSON output").action(async (identifier, file, options) => {
     await handleUpdateAction(identifier, file, options, program);
   });
 }
@@ -22787,6 +23172,48 @@ async function handleFulltextDetachAction(identifier, options, program) {
     process.exit(4);
   }
 }
+async function handleFulltextOpenAction(identifierArg, options, program) {
+  try {
+    const config2 = await loadConfigWithOverrides(program.opts());
+    let identifier;
+    if (identifierArg) {
+      identifier = identifierArg;
+    } else {
+      if (isTTY()) {
+        process.stderr.write("Error: Identifier is required when running interactively.\n");
+        process.exit(1);
+      }
+      const stdinId = (await readStdinContent()).split("\n")[0]?.trim() ?? "";
+      if (!stdinId) {
+        process.stderr.write("Error: No identifier provided from stdin.\n");
+        process.exit(1);
+      }
+      identifier = stdinId;
+    }
+    const context = await createExecutionContext(config2, Library.load);
+    const openOptions = {
+      identifier,
+      fulltextDirectory: config2.fulltext.directory,
+      ...options.pdf && { type: "pdf" },
+      ...options.markdown && { type: "markdown" },
+      ...options.uuid && { idType: "uuid" }
+    };
+    const result = await executeFulltextOpen(openOptions, context);
+    const output = formatFulltextOpenOutput(result);
+    if (result.success) {
+      process.stderr.write(`${output}
+`);
+    } else {
+      process.stderr.write(`${output}
+`);
+    }
+    process.exit(getFulltextExitCode(result));
+  } catch (error) {
+    process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(4);
+  }
+}
 function registerFulltextCommand(program) {
   const fulltextCmd = program.command("fulltext").description("Manage full-text files attached to references");
   fulltextCmd.command("attach").description("Attach a full-text file to a reference").argument("<identifier>", "Citation key or UUID").argument("[file-path]", "Path to the file to attach").option("--pdf [path]", "Attach as PDF (path optional if provided as argument)").option("--markdown [path]", "Attach as Markdown (path optional if provided as argument)").option("--move", "Move file instead of copy").option("-f, --force", "Overwrite existing attachment").option("--uuid", "Interpret identifier as UUID").action(async (identifier, filePath, options) => {
@@ -22798,6 +23225,9 @@ function registerFulltextCommand(program) {
   fulltextCmd.command("detach").description("Detach full-text file from a reference").argument("<identifier>", "Citation key or UUID").option("--pdf", "Detach PDF only").option("--markdown", "Detach Markdown only").option("--delete", "Also delete the file from disk").option("-f, --force", "Skip confirmation for delete").option("--uuid", "Interpret identifier as UUID").action(async (identifier, options) => {
     await handleFulltextDetachAction(identifier, options, program);
   });
+  fulltextCmd.command("open").description("Open full-text file with system default application").argument("[identifier]", "Citation key or UUID (reads from stdin if not provided)").option("--pdf", "Open PDF file").option("--markdown", "Open Markdown file").option("--uuid", "Interpret identifier as UUID").action(async (identifier, options) => {
+    await handleFulltextOpenAction(identifier, options, program);
+  });
 }
 async function main(argv) {
   const program = createProgram();