@ashdev/codex-plugin-metadata-openlibrary 1.0.0

package/dist/index.js

@@ -0,0 +1,1070 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  buildOpenLibraryUrl: () => buildOpenLibraryUrl,
+  clearCache: () => clearCache,
+  extractOlid: () => extractOlid,
+  getAuthor: () => getAuthor,
+  getCoverUrlById: () => getCoverUrlById,
+  getCoverUrlByIsbn: () => getCoverUrlByIsbn,
+  getCoverUrlByOlid: () => getCoverUrlByOlid,
+  getEditionByIsbn: () => getEditionByIsbn,
+  getWork: () => getWork,
+  getWorkEditions: () => getWorkEditions,
+  isValidIsbn: () => isValidIsbn,
+  normalizeIsbn: () => normalizeIsbn,
+  parseDescription: () => parseDescription,
+  parseLanguage: () => parseLanguage,
+  parseYear: () => parseYear,
+  searchBooks: () => searchBooks
+});
+function getCached(key) {
+  const entry = cache.get(key);
+  if (entry && Date.now() - entry.timestamp < CACHE_TTL_MS) {
+    return entry.data;
+  }
+  if (entry) {
+    cache.delete(key);
+  }
+  return null;
+}
+function setCache(key, data) {
+  cache.set(key, { data, timestamp: Date.now() });
+}
+async function fetchJson(url, description) {
+  const cached = getCached(url);
+  if (cached !== null) {
+    return cached;
+  }
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Codex/1.0 (https://github.com/AshDevFr/codex; codex-plugin)",
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return null;
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    setCache(url, data);
+    return data;
+  } catch (error) {
+    console.error(`[openlibrary] Failed to fetch ${description}:`, error);
+    return null;
+  }
+}
+function normalizeIsbn(isbn) {
+  return isbn.replace(/[-\s]/g, "").toUpperCase();
+}
+function isValidIsbn(isbn) {
+  const normalized = normalizeIsbn(isbn);
+  return normalized.length === 10 || normalized.length === 13;
+}
+async function getEditionByIsbn(isbn) {
+  const normalized = normalizeIsbn(isbn);
+  const url = `${BASE_URL}/isbn/${normalized}.json`;
+  return fetchJson(url, `edition by ISBN ${normalized}`);
+}
+async function getWork(workKey) {
+  const key = workKey.startsWith("/works/") ? workKey : `/works/${workKey}`;
+  const url = `${BASE_URL}${key}.json`;
+  return fetchJson(url, `work ${key}`);
+}
+async function getWorkEditions(workKey, limit = 5) {
+  const key = workKey.startsWith("/works/") ? workKey : `/works/${workKey}`;
+  const url = `${BASE_URL}${key}/editions.json?limit=${limit}`;
+  const response = await fetchJson(url, `editions for ${key}`);
+  return response?.entries || [];
+}
+async function getAuthor(authorKey) {
+  const key = authorKey.startsWith("/authors/") ? authorKey : `/authors/${authorKey}`;
+  const url = `${BASE_URL}${key}.json`;
+  return fetchJson(url, `author ${key}`);
+}
+async function searchBooks(query, options = {}) {
+  const { author, limit = 10 } = options;
+  if (author) {
+    const params2 = new URLSearchParams({
+      title: query,
+      author,
+      fields: SEARCH_FIELDS,
+      limit: String(limit)
+    });
+    const url2 = `${BASE_URL}/search.json?${params2}`;
+    const response = await fetchJson(
+      url2,
+      `search title="${query}" author="${author}"`
+    );
+    if (response?.docs?.length) {
+      return response;
+    }
+  }
+  const params = new URLSearchParams({
+    q: query,
+    fields: SEARCH_FIELDS,
+    limit: String(limit)
+  });
+  if (author) {
+    params.set("author", author);
+  }
+  const url = `${BASE_URL}/search.json?${params}`;
+  return fetchJson(url, `search "${query}"`);
+}
+function getCoverUrlByIsbn(isbn, size) {
+  const normalized = normalizeIsbn(isbn);
+  return `${COVERS_BASE_URL}/b/isbn/${normalized}-${size}.jpg`;
+}
+function getCoverUrlById(coverId, size) {
+  return `${COVERS_BASE_URL}/b/id/${coverId}-${size}.jpg`;
+}
+function getCoverUrlByOlid(olid, size) {
+  const id = olid.replace(/^\/(?:books|works)\//, "");
+  return `${COVERS_BASE_URL}/b/olid/${id}-${size}.jpg`;
+}
+function parseYear(dateStr) {
+  if (!dateStr) return void 0;
+  const match = dateStr.match(/(?:^|[^0-9])(1[89]\d{2}|20\d{2})(?:[^0-9]|$)/);
+  if (match) {
+    return Number.parseInt(match[1], 10);
+  }
+  return void 0;
+}
+function parseDescription(desc) {
+  if (!desc) return void 0;
+  const raw = typeof desc === "string" ? desc : desc.value;
+  return stripHtml(raw);
+}
+function stripHtml(html) {
+  let text = html;
+  text = text.replace(/<\/(p|div|li|tr|h[1-6])>/gi, "\n");
+  text = text.replace(/<br\s*\/?>/gi, "\n");
+  text = text.replace(/<[^>]+>/g, "");
+  text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'").replace(/&nbsp;/g, " ");
+  text = text.replace(/[^\S\n]+/g, " ");
+  text = text.replace(/\n{3,}/g, "\n\n");
+  text = text.split("\n").map((line) => line.trim()).join("\n").trim();
+  return text || void 0;
+}
+function parseLanguage(langRef) {
+  if (!langRef) return void 0;
+  const match = langRef.match(/\/languages\/(\w+)$/);
+  if (!match) return void 0;
+  const code = match[1].toLowerCase();
+  const languageMap = {
+    eng: "en",
+    spa: "es",
+    fre: "fr",
+    fra: "fr",
+    ger: "de",
+    deu: "de",
+    ita: "it",
+    por: "pt",
+    rus: "ru",
+    jpn: "ja",
+    chi: "zh",
+    zho: "zh",
+    kor: "ko",
+    ara: "ar",
+    hin: "hi",
+    pol: "pl",
+    tur: "tr",
+    dut: "nl",
+    nld: "nl",
+    swe: "sv",
+    nor: "no",
+    dan: "da",
+    fin: "fi",
+    cze: "cs",
+    ces: "cs",
+    gre: "el",
+    ell: "el",
+    heb: "he",
+    hun: "hu",
+    rom: "ro",
+    ron: "ro",
+    tha: "th",
+    vie: "vi",
+    ind: "id",
+    mal: "ms",
+    msa: "ms",
+    ukr: "uk",
+    cat: "ca",
+    lat: "la"
+  };
+  return languageMap[code] || code;
+}
+function extractOlid(key) {
+  return key.replace(/^\/(?:works|books|authors)\//, "");
+}
+function buildOpenLibraryUrl(key) {
+  return `${BASE_URL}${key.startsWith("/") ? key : `/${key}`}`;
+}
+function clearCache() {
+  cache.clear();
+}
+var BASE_URL, COVERS_BASE_URL, CACHE_TTL_MS, cache, SEARCH_FIELDS;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    BASE_URL = "https://openlibrary.org";
+    COVERS_BASE_URL = "https://covers.openlibrary.org";
+    CACHE_TTL_MS = 15 * 60 * 1e3;
+    cache = /* @__PURE__ */ new Map();
+    SEARCH_FIELDS = [
+      "key",
+      "title",
+      "subtitle",
+      "author_name",
+      "author_key",
+      "first_publish_year",
+      "publish_year",
+      "publisher",
+      "isbn",
+      "number_of_pages_median",
+      "cover_i",
+      "cover_edition_key",
+      "edition_count",
+      "language",
+      "subject",
+      "ratings_average",
+      "ratings_count"
+    ].join(",");
+  }
+});
+
+// ../sdk-typescript/dist/types/rpc.js
+var JSON_RPC_ERROR_CODES = {
+  /** Invalid JSON was received */
+  PARSE_ERROR: -32700,
+  /** The JSON sent is not a valid Request object */
+  INVALID_REQUEST: -32600,
+  /** The method does not exist / is not available */
+  METHOD_NOT_FOUND: -32601,
+  /** Invalid method parameter(s) */
+  INVALID_PARAMS: -32602,
+  /** Internal JSON-RPC error */
+  INTERNAL_ERROR: -32603
+};
+
+// ../sdk-typescript/dist/errors.js
+var PluginError = class extends Error {
+  data;
+  constructor(message, data) {
+    super(message);
+    this.name = this.constructor.name;
+    this.data = data;
+  }
+  /**
+   * Convert to JSON-RPC error format
+   */
+  toJsonRpcError() {
+    return {
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+};
+
+// ../sdk-typescript/dist/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  name;
+  minLevel;
+  timestamps;
+  constructor(options) {
+    this.name = options.name;
+    this.minLevel = LOG_LEVELS[options.level ?? "info"];
+    this.timestamps = options.timestamps ?? true;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= this.minLevel;
+  }
+  format(level, message, data) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    parts.push(`[${level.toUpperCase()}]`);
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    if (data !== void 0) {
+      if (data instanceof Error) {
+        parts.push(`- ${data.message}`);
+        if (data.stack) {
+          parts.push(`
+${data.stack}`);
+        }
+      } else if (typeof data === "object") {
+        parts.push(`- ${JSON.stringify(data)}`);
+      } else {
+        parts.push(`- ${String(data)}`);
+      }
+    }
+    return parts.join(" ");
+  }
+  log(level, message, data) {
+    if (this.shouldLog(level)) {
+      process.stderr.write(`${this.format(level, message, data)}
+`);
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+};
+function createLogger(options) {
+  return new Logger(options);
+}
+
+// ../sdk-typescript/dist/server.js
+import { createInterface } from "node:readline";
+function validateStringFields(params, fields) {
+  if (params === null || params === void 0) {
+    return { field: "params", message: "params is required" };
+  }
+  if (typeof params !== "object") {
+    return { field: "params", message: "params must be an object" };
+  }
+  const obj = params;
+  for (const field of fields) {
+    const value = obj[field];
+    if (value === void 0 || value === null) {
+      return { field, message: `${field} is required` };
+    }
+    if (typeof value !== "string") {
+      return { field, message: `${field} must be a string` };
+    }
+    if (value.trim() === "") {
+      return { field, message: `${field} cannot be empty` };
+    }
+  }
+  return null;
+}
+function validateSearchParams(params) {
+  return validateStringFields(params, ["query"]);
+}
+function validateGetParams(params) {
+  return validateStringFields(params, ["externalId"]);
+}
+function validateMatchParams(params) {
+  return validateStringFields(params, ["title"]);
+}
+function invalidParamsError(id, error) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+      message: `Invalid params: ${error.message}`,
+      data: { field: error.field }
+    }
+  };
+}
+function createMetadataPlugin(options) {
+  const { manifest: manifest2, provider, onInitialize, logLevel = "info" } = options;
+  const logger2 = createLogger({ name: manifest2.name, level: logLevel });
+  logger2.info(`Starting plugin: ${manifest2.displayName} v${manifest2.version}`);
+  const rl = createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  rl.on("line", (line) => {
+    void handleLine(line, manifest2, provider, onInitialize, logger2);
+  });
+  rl.on("close", () => {
+    logger2.info("stdin closed, shutting down");
+    process.exit(0);
+  });
+  process.on("uncaughtException", (error) => {
+    logger2.error("Uncaught exception", error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger2.error("Unhandled rejection", reason);
+  });
+}
+async function handleLine(line, manifest2, provider, onInitialize, logger2) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return;
+  let id = null;
+  try {
+    const request = JSON.parse(trimmed);
+    id = request.id;
+    logger2.debug(`Received request: ${request.method}`, { id: request.id });
+    const response = await handleRequest(request, manifest2, provider, onInitialize, logger2);
+    if (response !== null) {
+      writeResponse(response);
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      writeResponse({
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
+          message: "Parse error: invalid JSON"
+        }
+      });
+    } else if (error instanceof PluginError) {
+      writeResponse({
+        jsonrpc: "2.0",
+        id,
+        error: error.toJsonRpcError()
+      });
+    } else {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger2.error("Request failed", error);
+      writeResponse({
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+          message
+        }
+      });
+    }
+  }
+}
+async function handleRequest(request, manifest2, provider, onInitialize, logger2) {
+  const { method, params, id } = request;
+  switch (method) {
+    case "initialize":
+      if (onInitialize) {
+        await onInitialize(params);
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: manifest2
+      };
+    case "ping":
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: "pong"
+      };
+    case "shutdown": {
+      logger2.info("Shutdown requested");
+      const response = {
+        jsonrpc: "2.0",
+        id,
+        result: null
+      };
+      process.stdout.write(`${JSON.stringify(response)}
+`, () => {
+        process.exit(0);
+      });
+      return null;
+    }
+    // Series metadata methods (scoped by content type)
+    case "metadata/series/search": {
+      const validationError = validateSearchParams(params);
+      if (validationError) {
+        return invalidParamsError(id, validationError);
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: await provider.search(params)
+      };
+    }
+    case "metadata/series/get": {
+      const validationError = validateGetParams(params);
+      if (validationError) {
+        return invalidParamsError(id, validationError);
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: await provider.get(params)
+      };
+    }
+    case "metadata/series/match": {
+      if (!provider.match) {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+            message: "This plugin does not support match"
+          }
+        };
+      }
+      const validationError = validateMatchParams(params);
+      if (validationError) {
+        return invalidParamsError(id, validationError);
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: await provider.match(params)
+      };
+    }
+    // Future: book metadata methods
+    // case "metadata/book/search":
+    // case "metadata/book/get":
+    // case "metadata/book/match":
+    default:
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+          message: `Method not found: ${method}`
+        }
+      };
+  }
+}
+function writeResponse(response) {
+  process.stdout.write(`${JSON.stringify(response)}
+`);
+}
+
+// src/index.ts
+init_api();
+
+// package.json
+var package_default = {
+  name: "@ashdev/codex-plugin-metadata-openlibrary",
+  version: "1.0.0",
+  description: "Open Library metadata plugin for Codex - fetches book metadata by ISBN or title search",
+  main: "dist/index.js",
+  bin: "dist/index.js",
+  type: "module",
+  files: [
+    "dist",
+    "README.md"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/AshDevFr/codex.git",
+    directory: "plugins/metadata-openlibrary"
+  },
+  scripts: {
+    build: "esbuild src/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.js --sourcemap --banner:js='#!/usr/bin/env node'",
+    dev: "npm run build -- --watch",
+    clean: "rm -rf dist",
+    start: "node dist/index.js",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    prepublishOnly: "npm run lint && npm run build"
+  },
+  keywords: [
+    "codex",
+    "plugin",
+    "openlibrary",
+    "metadata",
+    "books",
+    "isbn"
+  ],
+  author: "Codex",
+  license: "MIT",
+  engines: {
+    node: ">=22.0.0"
+  },
+  dependencies: {
+    "@ashdev/codex-plugin-sdk": "file:../sdk-typescript"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.3.13",
+    "@types/node": "^22.0.0",
+    esbuild: "^0.24.0",
+    typescript: "^5.7.0",
+    vitest: "^3.0.0"
+  }
+};
+
+// src/manifest.ts
+var DEFAULT_MAX_RESULTS = 10;
+var manifest = {
+  name: "metadata-openlibrary",
+  displayName: "Open Library",
+  version: package_default.version,
+  description: "Fetches book metadata from Open Library (openlibrary.org). Supports ISBN lookup and title search for EPUBs, PDFs, and other book formats.",
+  author: "Codex",
+  homepage: "https://openlibrary.org",
+  protocolVersion: "1.0",
+  capabilities: {
+    // Book metadata provider only (not series)
+    metadataProvider: ["book"]
+  },
+  configSchema: {
+    description: "Configuration options for the Open Library plugin",
+    fields: [
+      {
+        key: "maxResults",
+        label: "Maximum Results",
+        description: "Maximum number of results to return for search queries (1-50)",
+        type: "number",
+        required: false,
+        default: DEFAULT_MAX_RESULTS,
+        example: 20
+      }
+    ]
+  }
+};
+
+// src/mapper.ts
+init_api();
+function mapSearchDocToSearchResult(doc) {
+  const year = doc.first_publish_year;
+  const coverUrl = doc.cover_i ? getCoverUrlById(doc.cover_i, "M") : void 0;
+  let relevanceScore = 0.5;
+  if (doc.author_name?.length) relevanceScore += 0.1;
+  if (doc.isbn?.length) relevanceScore += 0.15;
+  if (doc.cover_i) relevanceScore += 0.1;
+  if (doc.first_publish_year) relevanceScore += 0.05;
+  if (doc.subject?.length) relevanceScore += 0.05;
+  if (doc.ratings_count && doc.ratings_count > 0) relevanceScore += 0.05;
+  return {
+    externalId: doc.key,
+    // Work key, e.g., "/works/OL45883W"
+    title: doc.title,
+    alternateTitles: doc.subtitle ? [doc.subtitle] : [],
+    year,
+    coverUrl,
+    relevanceScore: Math.min(1, relevanceScore),
+    preview: {
+      genres: doc.subject?.slice(0, 5) || [],
+      rating: doc.ratings_average ? Math.round(doc.ratings_average * 2) / 2 : void 0,
+      authors: doc.author_name?.slice(0, 3) || [],
+      description: doc.publisher?.length ? `Published by ${doc.publisher[0]}` : void 0
+    }
+  };
+}
+async function resolveAuthors(authorRefs) {
+  if (!authorRefs?.length) return [];
+  const authors = [];
+  for (const ref of authorRefs) {
+    const key = ref.author?.key || ref.key;
+    if (!key) continue;
+    const authorData = await getAuthor(key);
+    if (authorData) {
+      authors.push({
+        name: authorData.name,
+        key,
+        sortName: authorData.personal_name || void 0
+      });
+    }
+  }
+  return authors;
+}
+function mapToBookAuthors(authors) {
+  return authors.map((author) => ({
+    name: author.name,
+    role: "author",
+    sortName: author.sortName
+  }));
+}
+function buildCoverUrls(isbn, coverId) {
+  const covers = [];
+  if (isbn) {
+    covers.push({
+      url: getCoverUrlByIsbn(isbn, "S"),
+      size: "small"
+    });
+    covers.push({
+      url: getCoverUrlByIsbn(isbn, "M"),
+      size: "medium"
+    });
+    covers.push({
+      url: getCoverUrlByIsbn(isbn, "L"),
+      size: "large"
+    });
+  } else if (coverId) {
+    covers.push({
+      url: getCoverUrlById(coverId, "S"),
+      size: "small"
+    });
+    covers.push({
+      url: getCoverUrlById(coverId, "M"),
+      size: "medium"
+    });
+    covers.push({
+      url: getCoverUrlById(coverId, "L"),
+      size: "large"
+    });
+  }
+  return covers;
+}
+function buildExternalLinks(editionKey, workKey) {
+  const links = [
+    {
+      url: buildOpenLibraryUrl(editionKey),
+      label: "Open Library (Edition)",
+      linkType: "provider"
+    }
+  ];
+  if (workKey) {
+    links.push({
+      url: buildOpenLibraryUrl(workKey),
+      label: "Open Library (Work)",
+      linkType: "provider"
+    });
+  }
+  return links;
+}
+function collectIsbns(edition) {
+  const isbns = [];
+  if (edition.isbn_13?.length) {
+    isbns.push(...edition.isbn_13);
+  }
+  if (edition.isbn_10?.length) {
+    isbns.push(...edition.isbn_10);
+  }
+  return [...new Set(isbns)];
+}
+async function mapEditionToBookMetadata(edition, workData) {
+  const authorRefs = edition.authors || workData?.authors;
+  const authors = await resolveAuthors(authorRefs);
+  const isbns = collectIsbns(edition);
+  const primaryIsbn = isbns[0];
+  const coverId = edition.covers?.[0] || workData?.covers?.[0];
+  const description = parseDescription(edition.description) || parseDescription(workData?.description);
+  const subjects = [...edition.subjects || [], ...workData?.subjects || []];
+  const uniqueSubjects = [...new Set(subjects)];
+  const year = parseYear(edition.publish_date);
+  const originalYear = parseYear(workData?.first_publish_date);
+  const language = parseLanguage(edition.languages?.[0]?.key);
+  const externalRatings = [];
+  const workKey = edition.works?.[0]?.key || workData?.key;
+  const externalId = workKey || edition.key;
+  return {
+    externalId,
+    externalUrl: buildOpenLibraryUrl(externalId),
+    // Core fields
+    title: edition.title,
+    subtitle: edition.subtitle || workData?.subtitle,
+    alternateTitles: [],
+    summary: description,
+    bookType: detectBookType(edition),
+    // Book-specific fields
+    pageCount: edition.number_of_pages,
+    year,
+    // ISBN
+    isbn: primaryIsbn,
+    isbns,
+    // Edition info
+    edition: edition.edition_name,
+    originalTitle: workData?.title !== edition.title ? workData?.title : void 0,
+    originalYear,
+    language,
+    // Taxonomy
+    genres: [],
+    // Open Library doesn't have genres, just subjects
+    tags: [],
+    subjects: uniqueSubjects.slice(0, 20),
+    // Limit to 20 subjects
+    // Credits
+    authors: mapToBookAuthors(authors),
+    artists: [],
+    // Open Library doesn't track artists separately
+    publisher: edition.publishers?.[0],
+    // Media
+    coverUrl: primaryIsbn ? getCoverUrlByIsbn(primaryIsbn, "L") : coverId ? getCoverUrlById(coverId, "L") : void 0,
+    covers: buildCoverUrls(primaryIsbn, coverId),
+    // Rating
+    externalRatings,
+    awards: [],
+    // Links
+    externalLinks: buildExternalLinks(edition.key, workKey)
+  };
+}
+function detectBookType(edition) {
+  const format = edition.physical_format?.toLowerCase();
+  if (format) {
+    if (format.includes("comic") || format.includes("graphic novel")) {
+      return "graphic_novel";
+    }
+    if (format.includes("manga")) {
+      return "manga";
+    }
+    if (format.includes("magazine") || format.includes("periodical")) {
+      return "magazine";
+    }
+  }
+  const subjects = (edition.subjects || []).join(" ").toLowerCase();
+  if (subjects.includes("graphic novel") || subjects.includes("comics")) {
+    return "graphic_novel";
+  }
+  if (subjects.includes("manga")) {
+    return "manga";
+  }
+  return "novel";
+}
+async function getFullBookMetadata(editionOrWorkKey, isbn) {
+  if (isbn) {
+    const { getEditionByIsbn: getEditionByIsbn2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+    const edition = await getEditionByIsbn2(isbn);
+    if (edition) {
+      const workKey = edition.works?.[0]?.key;
+      const workData = workKey ? await getWork(workKey) : null;
+      return mapEditionToBookMetadata(edition, workData);
+    }
+  }
+  if (editionOrWorkKey.includes("/works/")) {
+    const workData = await getWork(editionOrWorkKey);
+    if (!workData) return null;
+    const editions = await getWorkEditions(editionOrWorkKey, 5);
+    if (editions.length > 0) {
+      const editionWithIsbn = editions.find((e) => e.isbn_13?.length || e.isbn_10?.length);
+      const edition = editionWithIsbn || editions[0];
+      return mapEditionToBookMetadata(edition, workData);
+    }
+    const authors = await resolveAuthors(workData.authors);
+    const coverId = workData.covers?.[0];
+    return {
+      externalId: workData.key,
+      externalUrl: buildOpenLibraryUrl(workData.key),
+      title: workData.title,
+      subtitle: workData.subtitle,
+      alternateTitles: [],
+      summary: parseDescription(workData.description),
+      isbns: [],
+      genres: [],
+      tags: [],
+      subjects: workData.subjects?.slice(0, 20) || [],
+      authors: mapToBookAuthors(authors),
+      artists: [],
+      coverUrl: coverId ? getCoverUrlById(coverId, "L") : void 0,
+      covers: coverId ? [
+        { url: getCoverUrlById(coverId, "S"), size: "small" },
+        { url: getCoverUrlById(coverId, "M"), size: "medium" },
+        { url: getCoverUrlById(coverId, "L"), size: "large" }
+      ] : [],
+      externalRatings: [],
+      awards: [],
+      externalLinks: [
+        {
+          url: buildOpenLibraryUrl(workData.key),
+          label: "Open Library",
+          linkType: "provider"
+        }
+      ]
+    };
+  }
+  const url = `https://openlibrary.org${editionOrWorkKey}.json`;
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Codex/1.0 (https://github.com/AshDevFr/codex; codex-plugin)",
+        Accept: "application/json"
+      }
+    });
+    if (response.ok) {
+      const edition = await response.json();
+      const workKey = edition.works?.[0]?.key;
+      const workData = workKey ? await getWork(workKey) : null;
+      return mapEditionToBookMetadata(edition, workData);
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/index.ts
+var logger = createLogger({ name: "openlibrary", level: "info" });
+var config = {
+  maxResults: DEFAULT_MAX_RESULTS
+};
+var bookProvider = {
+  /**
+   * Search for books by ISBN or title/author query
+   *
+   * If ISBN is provided, it takes priority for direct lookup.
+   * Otherwise, falls back to title/author search.
+   */
+  async search(params) {
+    const { isbn, query, author, limit } = params;
+    const maxResults = Math.min(limit || config.maxResults, 50);
+    if (isbn && isValidIsbn(isbn)) {
+      const edition = await getEditionByIsbn(isbn);
+      if (edition) {
+        const workKey = edition.works?.[0]?.key;
+        const workData = workKey ? await getWork(workKey) : null;
+        const metadata = await mapEditionToBookMetadata(edition, workData);
+        return {
+          results: [
+            {
+              externalId: metadata.externalId,
+              title: metadata.title || "Unknown",
+              alternateTitles: metadata.subtitle ? [metadata.subtitle] : [],
+              year: metadata.year,
+              coverUrl: metadata.coverUrl,
+              relevanceScore: 1,
+              // Perfect match by ISBN
+              preview: {
+                genres: metadata.subjects.slice(0, 5),
+                authors: metadata.authors.map((a) => a.name)
+              }
+            }
+          ]
+        };
+      }
+      if (!query) {
+        return { results: [] };
+      }
+    }
+    if (!query) {
+      return { results: [] };
+    }
+    const searchResponse = await searchBooks(query, {
+      author,
+      limit: maxResults
+    });
+    if (!searchResponse?.docs?.length) {
+      return { results: [] };
+    }
+    return {
+      results: searchResponse.docs.map(mapSearchDocToSearchResult)
+    };
+  },
+  /**
+   * Get full book metadata by external ID
+   *
+   * The external ID can be:
+   * - A work key: "/works/OL45883W"
+   * - An edition key: "/books/OL7353617M"
+   */
+  async get(params) {
+    const { externalId } = params;
+    const metadata = await getFullBookMetadata(externalId);
+    if (metadata) {
+      return metadata;
+    }
+    return {
+      externalId,
+      externalUrl: `https://openlibrary.org${externalId.startsWith("/") ? externalId : `/${externalId}`}`,
+      alternateTitles: [],
+      isbns: [],
+      genres: [],
+      tags: [],
+      subjects: [],
+      authors: [],
+      artists: [],
+      covers: [],
+      externalRatings: [],
+      awards: [],
+      externalLinks: [
+        {
+          url: `https://openlibrary.org${externalId.startsWith("/") ? externalId : `/${externalId}`}`,
+          label: "Open Library",
+          linkType: "provider"
+        }
+      ]
+    };
+  },
+  /**
+   * Auto-match a book using available identifiers
+   *
+   * Match priority:
+   * 1. ISBN (if provided) - highest confidence
+   * 2. Title + author search - lower confidence
+   */
+  async match(params) {
+    const { title, authors, isbn, year } = params;
+    if (isbn && isValidIsbn(isbn)) {
+      const edition = await getEditionByIsbn(isbn);
+      if (edition) {
+        const workKey = edition.works?.[0]?.key;
+        const workData = workKey ? await getWork(workKey) : null;
+        const metadata = await mapEditionToBookMetadata(edition, workData);
+        return {
+          match: {
+            externalId: metadata.externalId,
+            title: metadata.title || "Unknown",
+            alternateTitles: metadata.subtitle ? [metadata.subtitle] : [],
+            year: metadata.year,
+            coverUrl: metadata.coverUrl,
+            relevanceScore: 1,
+            preview: {
+              genres: metadata.subjects.slice(0, 5),
+              authors: metadata.authors.map((a) => a.name)
+            }
+          },
+          confidence: 0.99,
+          // Very high confidence for ISBN match
+          alternatives: []
+        };
+      }
+    }
+    const searchQuery = authors?.length ? `${title} ${authors[0]}` : title;
+    const searchResponse = await searchBooks(searchQuery, {
+      limit: 5
+    });
+    if (!searchResponse?.docs?.length) {
+      return {
+        match: null,
+        confidence: 0,
+        alternatives: []
+      };
+    }
+    const results = searchResponse.docs.map(mapSearchDocToSearchResult);
+    const bestMatch = results[0];
+    let confidence = bestMatch.relevanceScore || 0.5;
+    const normalizedTitle = title.toLowerCase().trim();
+    const normalizedMatchTitle = bestMatch.title.toLowerCase().trim();
+    if (normalizedTitle === normalizedMatchTitle) {
+      confidence = Math.min(1, confidence + 0.3);
+    } else if (normalizedMatchTitle.includes(normalizedTitle) || normalizedTitle.includes(normalizedMatchTitle)) {
+      confidence = Math.min(1, confidence + 0.15);
+    }
+    if (year && bestMatch.year === year) {
+      confidence = Math.min(1, confidence + 0.1);
+    }
+    confidence = Math.min(confidence, 0.85);
+    return {
+      match: bestMatch,
+      confidence,
+      alternatives: results.slice(1)
+    };
+  }
+};
+createMetadataPlugin({
+  manifest,
+  bookProvider,
+  logLevel: "info",
+  onInitialize(params) {
+    const maxResults = params.config?.maxResults;
+    if (maxResults !== void 0) {
+      config.maxResults = Math.min(Math.max(1, maxResults), 50);
+    }
+    logger.info(`Plugin initialized (maxResults: ${config.maxResults})`);
+  }
+});
+logger.info("Open Library plugin started");
+//# sourceMappingURL=index.js.map