@ncukondo/slide-generation 0.2.5 → 0.4.0

package/dist/index.d.ts

@@ -598,7 +598,7 @@ declare class ReferenceManager {
      */
     getById(id: string): Promise<CSLItem | null>;
     /**
-     * Get multiple references by IDs
+     * Get multiple references by IDs using ref export for better performance
      */
     getByIds(ids: string[]): Promise<Map<string, CSLItem>>;
     private execCommand;
@@ -624,7 +624,13 @@ interface FormatterConfig {
 declare class CitationFormatter {
     private manager;
     private config;
+    private availabilityChecked;
+    private isAvailable;
     constructor(manager: ReferenceManager, config?: FormatterConfig);
+    /**
+     * Check if reference-manager is available (cached)
+     */
+    private checkAvailability;
     /**
      * Format an inline citation
      * e.g., "(Smith et al., 2024; PMID: 12345678)"
@@ -644,13 +650,7 @@ declare class CitationFormatter {
      */
     generateBibliography(ids: string[], sort?: 'author' | 'year' | 'citation-order'): Promise<string[]>;
     private formatInlineItem;
-    private formatFullItem;
     private formatAuthorInline;
-    private formatAuthorsFull;
-    private isJapaneseAuthors;
-    private getFirstAuthorFamily;
-    private getYear;
-    private getIdentifier;
 }
 
 /**
@@ -966,6 +966,7 @@ declare class Pipeline {
     private referenceManager;
     private citationExtractor;
     private citationFormatter;
+    private bibliographyGenerator;
     private transformer;
     private renderer;
     private warnings;
@@ -1006,6 +1007,19 @@ declare class Pipeline {
      * Stage 5: Render the final Marp markdown
      */
     private render;
+    /**
+     * Process bibliography slides with autoGenerate: true
+     * Populates references array from collected citations
+     */
+    private processBibliography;
+    /**
+     * Format authors for template-compatible format
+     */
+    private formatAuthorsForTemplate;
+    /**
+     * Get year from CSL item
+     */
+    private getYear;
 }
 
 /**

package/dist/index.js

@@ -918,20 +918,20 @@ var ReferenceManager = class {
     return items[0] || null;
   }
   /**
-   * Get multiple references by IDs
+   * Get multiple references by IDs using ref export for better performance
    */
   async getByIds(ids) {
     if (ids.length === 0) {
       return /* @__PURE__ */ new Map();
     }
-    const result = await this.execCommand(`${this.command} list --format json`);
-    const allItems = this.parseJSON(result);
-    const idSet = new Set(ids);
+    const idsArg = ids.map((id) => `"${id}"`).join(" ");
+    const result = await this.execCommand(
+      `${this.command} export ${idsArg}`
+    );
+    const items = this.parseJSON(result);
     const map = /* @__PURE__ */ new Map();
-    for (const item of allItems) {
-      if (idSet.has(item.id)) {
-        map.set(item.id, item);
-      }
+    for (const item of items) {
+      map.set(item.id, item);
     }
     return map;
   }
@@ -1075,6 +1075,82 @@ var CitationExtractor = class {
   }
 };
 
+// src/references/utils.ts
+var JAPANESE_PATTERN = /[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]/;
+function isJapaneseAuthors(authors) {
+  if (!authors || authors.length === 0) {
+    return false;
+  }
+  return JAPANESE_PATTERN.test(authors[0].family);
+}
+function getYear(item) {
+  const dateParts = item.issued?.["date-parts"];
+  if (dateParts && dateParts[0] && dateParts[0][0]) {
+    return dateParts[0][0];
+  }
+  return 0;
+}
+function getIdentifier(item) {
+  if (item.PMID) {
+    return `PMID: ${item.PMID}`;
+  }
+  if (item.DOI) {
+    return `DOI: ${item.DOI}`;
+  }
+  return null;
+}
+function getFirstAuthorFamily(item) {
+  return item.author?.[0]?.family || "";
+}
+function formatAuthorsFull(authors, isJapanese) {
+  if (!authors || authors.length === 0) {
+    return "Unknown";
+  }
+  if (isJapanese) {
+    return authors.map((a) => `${a.family}${a.given || ""}`).join(", ");
+  }
+  if (authors.length === 1) {
+    const a = authors[0];
+    const initial = a.given ? `${a.given.charAt(0)}.` : "";
+    return `${a.family}, ${initial}`;
+  }
+  const formatted = authors.map((a, i) => {
+    const initial = a.given ? `${a.given.charAt(0)}.` : "";
+    if (i === authors.length - 1) {
+      return `& ${a.family}, ${initial}`;
+    }
+    return `${a.family}, ${initial}`;
+  });
+  return formatted.join(", ").replace(", &", ", &");
+}
+function formatFullEntry(item) {
+  const parts = [];
+  const japanese = isJapaneseAuthors(item.author);
+  const authors = formatAuthorsFull(item.author, japanese);
+  parts.push(authors);
+  const year = getYear(item);
+  parts.push(`(${year}).`);
+  if (item.title) {
+    parts.push(`${item.title}.`);
+  }
+  if (item["container-title"]) {
+    const journal = japanese ? item["container-title"] : `*${item["container-title"]}*`;
+    let location = "";
+    if (item.volume) {
+      location = item.issue ? `${item.volume}(${item.issue})` : item.volume;
+    }
+    if (item.page) {
+      location = location ? `${location}, ${item.page}` : item.page;
+    }
+    parts.push(location ? `${journal}, ${location}.` : `${journal}.`);
+  }
+  const identifier = getIdentifier(item);
+  if (identifier) {
+    parts.push(identifier);
+  }
+  return parts.join(" ");
+}
+
 // src/references/formatter.ts
 var DEFAULT_CONFIG = {
   author: {
@@ -1089,7 +1165,6 @@ var DEFAULT_CONFIG = {
     multiSep: "), ("
   }
 };
-var JAPANESE_PATTERN = /[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]/;
 var CITATION_BRACKET_PATTERN2 = /\[(@[\w-]+(?:,\s*[^;\]]+)?(?:;\s*@[\w-]+(?:,\s*[^;\]]+)?)*)\]/g;
 var SINGLE_CITATION_PATTERN2 = /@([\w-]+)(?:,\s*([^;\]]+))?/g;
 var CitationFormatter = class {
@@ -1101,6 +1176,18 @@ var CitationFormatter = class {
     };
   }
   config;
+  availabilityChecked = false;
+  isAvailable = false;
+  /**
+   * Check if reference-manager is available (cached)
+   */
+  async checkAvailability() {
+    if (!this.availabilityChecked) {
+      this.isAvailable = await this.manager.isAvailable();
+      this.availabilityChecked = true;
+    }
+    return this.isAvailable;
+  }
   /**
    * Format an inline citation
    * e.g., "(Smith et al., 2024; PMID: 12345678)"
@@ -1120,13 +1207,16 @@ var CitationFormatter = class {
     if (!item) {
       return `[${id}]`;
     }
-    return this.formatFullItem(item);
+    return formatFullEntry(item);
   }
   /**
    * Expand all citations in text
    * e.g., "[@smith2024]" -> "(Smith et al., 2024; PMID: 12345678)"
    */
   async expandCitations(text) {
+    if (!await this.checkAvailability()) {
+      return text;
+    }
     const ids = /* @__PURE__ */ new Set();
     CITATION_BRACKET_PATTERN2.lastIndex = 0;
     let match;
@@ -1181,117 +1271,102 @@ var CitationFormatter = class {
       sortedItems = ids.map((id) => items.get(id)).filter((item) => item !== void 0);
     } else if (sort === "author") {
       sortedItems = [...items.values()].sort((a, b) => {
-        const authorA = this.getFirstAuthorFamily(a);
-        const authorB = this.getFirstAuthorFamily(b);
+        const authorA = getFirstAuthorFamily(a);
+        const authorB = getFirstAuthorFamily(b);
         return authorA.localeCompare(authorB);
       });
     } else {
       sortedItems = [...items.values()].sort((a, b) => {
-        const yearA = this.getYear(a);
-        const yearB = this.getYear(b);
+        const yearA = getYear(a);
+        const yearB = getYear(b);
         return yearA - yearB;
       });
     }
-    return sortedItems.map((item) => this.formatFullItem(item));
+    return sortedItems.map((item) => formatFullEntry(item));
   }
   formatInlineItem(item) {
     const author = this.formatAuthorInline(item.author);
-    const year = this.getYear(item);
-    const identifier = this.getIdentifier(item);
+    const year = getYear(item);
+    const identifier = getIdentifier(item);
     if (identifier) {
       return `(${author}, ${year}; ${identifier})`;
     }
     return `(${author}, ${year})`;
   }
-  formatFullItem(item) {
-    const parts = [];
-    const isJapanese = this.isJapaneseAuthors(item.author);
-    const authors = this.formatAuthorsFull(item.author, isJapanese);
-    parts.push(authors);
-    const year = this.getYear(item);
-    parts.push(`(${year}).`);
-    if (item.title) {
-      parts.push(`${item.title}.`);
-    }
-    if (item["container-title"]) {
-      const journal = isJapanese ? item["container-title"] : `*${item["container-title"]}*`;
-      let location = "";
-      if (item.volume) {
-        location = item.issue ? `${item.volume}(${item.issue})` : item.volume;
-      }
-      if (item.page) {
-        location = location ? `${location}, ${item.page}` : item.page;
-      }
-      parts.push(location ? `${journal}, ${location}.` : `${journal}.`);
-    }
-    const identifier = this.getIdentifier(item);
-    if (identifier) {
-      parts.push(identifier);
-    }
-    return parts.join(" ");
-  }
   formatAuthorInline(authors) {
     if (!authors || authors.length === 0) {
       return "Unknown";
     }
-    const isJapanese = this.isJapaneseAuthors(authors);
+    const japanese = isJapaneseAuthors(authors);
     const { etAl, etAlJa, separatorJa } = this.config.author;
     const firstAuthor = authors[0];
     if (authors.length === 1) {
       return firstAuthor.family;
     }
     if (authors.length === 2) {
-      const separator = isJapanese ? separatorJa : " & ";
+      const separator = japanese ? separatorJa : " & ";
       return `${firstAuthor.family}${separator}${authors[1].family}`;
     }
-    const suffix = isJapanese ? etAlJa : ` ${etAl}`;
+    const suffix = japanese ? etAlJa : ` ${etAl}`;
     return `${firstAuthor.family}${suffix}`;
   }
-  formatAuthorsFull(authors, isJapanese) {
-    if (!authors || authors.length === 0) {
-      return "Unknown";
-    }
-    if (isJapanese) {
-      return authors.map((a) => `${a.family}${a.given || ""}`).join(", ");
-    }
-    if (authors.length === 1) {
-      const a = authors[0];
-      const initial = a.given ? `${a.given.charAt(0)}.` : "";
-      return `${a.family}, ${initial}`;
-    }
-    const formatted = authors.map((a, i) => {
-      const initial = a.given ? `${a.given.charAt(0)}.` : "";
-      if (i === authors.length - 1) {
-        return `& ${a.family}, ${initial}`;
-      }
-      return `${a.family}, ${initial}`;
-    });
-    return formatted.join(", ").replace(", &", ", &");
-  }
-  isJapaneseAuthors(authors) {
-    if (!authors || authors.length === 0) {
-      return false;
-    }
-    return JAPANESE_PATTERN.test(authors[0].family);
-  }
-  getFirstAuthorFamily(item) {
-    return item.author?.[0]?.family || "";
+};
+
+// src/references/bibliography.ts
+var BibliographyGenerator = class {
+  constructor(manager) {
+    this.manager = manager;
   }
-  getYear(item) {
-    const dateParts = item.issued?.["date-parts"];
-    if (dateParts && dateParts[0] && dateParts[0][0]) {
-      return dateParts[0][0];
+  /**
+   * Generate bibliography entries from citation IDs
+   */
+  async generate(citationIds, options = {}) {
+    const { sort = "citation-order" } = options;
+    if (citationIds.length === 0) {
+      return { entries: [], items: [], missing: [] };
+    }
+    const uniqueIds = [...new Set(citationIds)];
+    const itemsMap = await this.manager.getByIds(uniqueIds);
+    const missing = [];
+    const foundItems = [];
+    for (const id of uniqueIds) {
+      const item = itemsMap.get(id);
+      if (item) {
+        foundItems.push(item);
+      } else {
+        missing.push(id);
+      }
     }
-    return 0;
+    const sortedItems = this.sortItems(foundItems, sort);
+    const entries = sortedItems.map((item) => formatFullEntry(item));
+    return {
+      entries,
+      items: sortedItems,
+      missing
+    };
   }
-  getIdentifier(item) {
-    if (item.PMID) {
-      return `PMID: ${item.PMID}`;
-    }
-    if (item.DOI) {
-      return `DOI: ${item.DOI}`;
+  /**
+   * Sort items according to the specified order
+   */
+  sortItems(items, sort) {
+    switch (sort) {
+      case "citation-order":
+        return items;
+      case "author":
+        return [...items].sort((a, b) => {
+          const authorA = getFirstAuthorFamily(a);
+          const authorB = getFirstAuthorFamily(b);
+          return authorA.localeCompare(authorB);
+        });
+      case "year":
+        return [...items].sort((a, b) => {
+          const yearA = getYear(a);
+          const yearB = getYear(b);
+          return yearA - yearB;
+        });
+      default:
+        return items;
     }
-    return null;
   }
 };
 
@@ -1330,6 +1405,7 @@ var Pipeline = class {
         }
       }
     );
+    this.bibliographyGenerator = new BibliographyGenerator(this.referenceManager);
     this.transformer = new Transformer(
       this.templateEngine,
       this.templateLoader,
@@ -1346,6 +1422,7 @@ var Pipeline = class {
   referenceManager;
   citationExtractor;
   citationFormatter;
+  bibliographyGenerator;
   transformer;
   renderer;
   warnings = [];
@@ -1355,9 +1432,10 @@ var Pipeline = class {
   async run(inputPath, options) {
     this.warnings = [];
     try {
-      const presentation = await this.parseSource(inputPath);
+      let presentation = await this.parseSource(inputPath);
       const citationIds = this.collectCitations(presentation);
       await this.resolveReferences(citationIds);
+      presentation = await this.processBibliography(presentation, citationIds);
       const transformedSlides = await this.transformSlides(presentation);
       const output = this.render(transformedSlides, presentation);
       if (options?.outputPath) {
@@ -1381,9 +1459,10 @@ var Pipeline = class {
   async runWithResult(inputPath, options) {
     this.warnings = [];
     try {
-      const presentation = await this.parseSource(inputPath);
+      let presentation = await this.parseSource(inputPath);
       const citationIds = this.collectCitations(presentation);
       await this.resolveReferences(citationIds);
+      presentation = await this.processBibliography(presentation, citationIds);
       const transformedSlides = await this.transformSlides(presentation);
       const output = this.render(transformedSlides, presentation);
       if (options?.outputPath) {
@@ -1459,6 +1538,13 @@ var Pipeline = class {
     if (!this.config.references.enabled || ids.length === 0) {
       return /* @__PURE__ */ new Map();
     }
+    const isAvailable = await this.referenceManager.isAvailable();
+    if (!isAvailable) {
+      this.warnings.push(
+        "reference-manager CLI is not available. Install it to enable citation features: npm install -g @ncukondo/reference-manager"
+      );
+      return /* @__PURE__ */ new Map();
+    }
     try {
       const items = await this.referenceManager.getByIds(ids);
       for (const id of ids) {
@@ -1507,10 +1593,97 @@ var Pipeline = class {
       );
     }
   }
+  /**
+   * Process bibliography slides with autoGenerate: true
+   * Populates references array from collected citations
+   */
+  async processBibliography(presentation, citationIds) {
+    if (!this.config.references.enabled || citationIds.length === 0) {
+      return presentation;
+    }
+    const hasBibliographyAutoGenerate = presentation.slides.some(
+      (slide) => slide.template === "bibliography" && slide.content?.["autoGenerate"] === true
+    );
+    if (!hasBibliographyAutoGenerate) {
+      return presentation;
+    }
+    const isAvailable = await this.referenceManager.isAvailable();
+    if (!isAvailable) {
+      return presentation;
+    }
+    try {
+      const updatedSlides = await Promise.all(
+        presentation.slides.map(async (slide) => {
+          if (slide.template === "bibliography" && slide.content?.["autoGenerate"] === true) {
+            const sort = slide.content["sort"] || "citation-order";
+            const result = await this.bibliographyGenerator.generate(
+              citationIds,
+              { sort }
+            );
+            for (const id of result.missing) {
+              this.warnings.push(`Bibliography: reference not found: ${id}`);
+            }
+            const references = result.items.map((item) => ({
+              id: item.id,
+              authors: this.formatAuthorsForTemplate(item.author),
+              title: item.title || "",
+              year: this.getYear(item),
+              journal: item["container-title"],
+              volume: item.volume,
+              pages: item.page,
+              doi: item.DOI,
+              url: item.URL
+            }));
+            return {
+              ...slide,
+              content: {
+                ...slide.content,
+                references,
+                _autoGenerated: true,
+                _generatedEntries: result.entries
+              }
+            };
+          }
+          return slide;
+        })
+      );
+      return {
+        ...presentation,
+        slides: updatedSlides
+      };
+    } catch (error) {
+      this.warnings.push(
+        `Failed to auto-generate bibliography: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return presentation;
+    }
+  }
+  /**
+   * Format authors for template-compatible format
+   */
+  formatAuthorsForTemplate(authors) {
+    if (!authors || authors.length === 0) {
+      return void 0;
+    }
+    return authors.map((a) => {
+      const initial = a.given ? `${a.given.charAt(0)}.` : "";
+      return initial ? `${a.family}, ${initial}` : a.family;
+    });
+  }
+  /**
+   * Get year from CSL item
+   */
+  getYear(item) {
+    const dateParts = item.issued?.["date-parts"];
+    if (dateParts && dateParts[0] && dateParts[0][0]) {
+      return dateParts[0][0];
+    }
+    return void 0;
+  }
 };
 
 // src/index.ts
-var VERSION = "0.2.5";
+var VERSION = "0.4.0";
 export {
   ParseError,
   Parser,