@ncukondo/slide-generation 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,2994 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command8 } from "commander";
+
+// src/core/parser.ts
+import { z } from "zod";
+import { parse as parseYaml } from "yaml";
+import { readFile } from "fs/promises";
+var referencesConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  style: z.string().default("author-year-pmid")
+});
+var metaSchema = z.object({
+  title: z.string(),
+  author: z.string().optional(),
+  date: z.string().optional(),
+  theme: z.string().default("default"),
+  references: referencesConfigSchema.optional()
+});
+var slideSchema = z.object({
+  template: z.string(),
+  content: z.record(z.unknown()).default({}),
+  class: z.string().optional(),
+  notes: z.string().optional(),
+  raw: z.string().optional()
+});
+var presentationSchema = z.object({
+  meta: metaSchema,
+  slides: z.array(slideSchema).default([])
+});
+var ParseError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "ParseError";
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "ValidationError";
+  }
+};
+var Parser = class {
+  parse(yamlContent) {
+    let rawData;
+    try {
+      rawData = parseYaml(yamlContent);
+    } catch (error) {
+      throw new ParseError("Failed to parse YAML", error);
+    }
+    const result = presentationSchema.safeParse(rawData);
+    if (!result.success) {
+      throw new ValidationError(
+        "Schema validation failed",
+        result.error.format()
+      );
+    }
+    return result.data;
+  }
+  async parseFile(filePath) {
+    let content;
+    try {
+      content = await readFile(filePath, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new ParseError(`File not found: ${filePath}`);
+      }
+      throw new ParseError(`Failed to read file: ${filePath}`, error);
+    }
+    return this.parse(content);
+  }
+};
+
+// src/core/transformer.ts
+var ICON_PLACEHOLDER_PREFIX = "___ICON_PLACEHOLDER_";
+var ICON_PLACEHOLDER_SUFFIX = "___";
+var REFS_CITE_PLACEHOLDER_PREFIX = "___REFS_CITE_PLACEHOLDER_";
+var REFS_CITE_PLACEHOLDER_SUFFIX = "___";
+var REFS_EXPAND_PLACEHOLDER_PREFIX = "___REFS_EXPAND_PLACEHOLDER_";
+var REFS_EXPAND_PLACEHOLDER_SUFFIX = "___";
+var TransformError = class extends Error {
+  constructor(message, slide, details) {
+    super(message);
+    this.slide = slide;
+    this.details = details;
+    this.name = "TransformError";
+  }
+};
+var Transformer = class {
+  constructor(templateEngine, templateLoader, iconResolver, citationFormatter) {
+    this.templateEngine = templateEngine;
+    this.templateLoader = templateLoader;
+    this.iconResolver = iconResolver;
+    this.citationFormatter = citationFormatter;
+  }
+  /**
+   * Transform a single slide using its template
+   */
+  async transform(slide, context) {
+    if (slide.template === "raw") {
+      return slide.raw ?? "";
+    }
+    const template = this.templateLoader.get(slide.template);
+    if (!template) {
+      throw new TransformError(
+        `Template "${slide.template}" not found`,
+        slide
+      );
+    }
+    const validationResult = this.templateLoader.validateContent(
+      slide.template,
+      slide.content
+    );
+    if (!validationResult.valid) {
+      throw new TransformError(
+        `Slide content validation failed: ${validationResult.errors?.join(", ")}`,
+        slide,
+        validationResult.errors
+      );
+    }
+    const pending = {
+      icons: /* @__PURE__ */ new Map(),
+      cites: /* @__PURE__ */ new Map(),
+      expands: /* @__PURE__ */ new Map()
+    };
+    const templateContext = this.buildTemplateContext(slide, context, pending);
+    let output = this.templateEngine.render(template.output, templateContext);
+    output = await this.resolvePlaceholders(output, pending);
+    if (slide.class) {
+      output = `<!-- _class: ${slide.class} -->
+${output}`;
+    }
+    return output.trim();
+  }
+  /**
+   * Transform all slides in a presentation
+   */
+  async transformAll(presentation) {
+    const results = [];
+    const totalSlides = presentation.slides.length;
+    for (let i = 0; i < presentation.slides.length; i++) {
+      const slide = presentation.slides[i];
+      const context = {
+        meta: presentation.meta,
+        slideIndex: i,
+        totalSlides
+      };
+      const transformed = await this.transform(slide, context);
+      results.push(transformed);
+    }
+    return results;
+  }
+  /**
+   * Build the full template context with helpers that collect async operations
+   */
+  buildTemplateContext(slide, context, pending) {
+    let iconCounter = 0;
+    let citeCounter = 0;
+    let expandCounter = 0;
+    const icons = {
+      render: (name, options) => {
+        const id = `${iconCounter++}`;
+        const placeholder = `${ICON_PLACEHOLDER_PREFIX}${id}${ICON_PLACEHOLDER_SUFFIX}`;
+        pending.icons.set(id, { name, options });
+        return placeholder;
+      }
+    };
+    const refs = {
+      cite: (id) => {
+        const counterId = `${citeCounter++}`;
+        const placeholder = `${REFS_CITE_PLACEHOLDER_PREFIX}${counterId}${REFS_CITE_PLACEHOLDER_SUFFIX}`;
+        pending.cites.set(counterId, id);
+        return placeholder;
+      },
+      expand: (text) => {
+        const counterId = `${expandCounter++}`;
+        const placeholder = `${REFS_EXPAND_PLACEHOLDER_PREFIX}${counterId}${REFS_EXPAND_PLACEHOLDER_SUFFIX}`;
+        pending.expands.set(counterId, text);
+        return placeholder;
+      }
+    };
+    return {
+      content: slide.content,
+      meta: {
+        title: context.meta.title,
+        author: context.meta.author,
+        theme: context.meta.theme
+      },
+      slide: {
+        index: context.slideIndex,
+        total: context.totalSlides
+      },
+      icons,
+      refs
+    };
+  }
+  /**
+   * Resolve all placeholders by executing async operations
+   */
+  async resolvePlaceholders(output, pending) {
+    const iconResults = /* @__PURE__ */ new Map();
+    for (const [id, { name, options }] of pending.icons) {
+      const rendered = await this.iconResolver.render(
+        name,
+        options
+      );
+      iconResults.set(id, rendered);
+    }
+    const citeResults = /* @__PURE__ */ new Map();
+    for (const [counterId, id] of pending.cites) {
+      const formatted = await this.citationFormatter.formatInline(id);
+      citeResults.set(counterId, formatted);
+    }
+    const expandResults = /* @__PURE__ */ new Map();
+    for (const [counterId, text] of pending.expands) {
+      const expanded = await this.citationFormatter.expandCitations(text);
+      expandResults.set(counterId, expanded);
+    }
+    let result = output;
+    for (const [id, rendered] of iconResults) {
+      const placeholder = `${ICON_PLACEHOLDER_PREFIX}${id}${ICON_PLACEHOLDER_SUFFIX}`;
+      result = result.replace(placeholder, rendered);
+    }
+    for (const [counterId, formatted] of citeResults) {
+      const placeholder = `${REFS_CITE_PLACEHOLDER_PREFIX}${counterId}${REFS_CITE_PLACEHOLDER_SUFFIX}`;
+      result = result.replace(placeholder, formatted);
+    }
+    for (const [counterId, expanded] of expandResults) {
+      const placeholder = `${REFS_EXPAND_PLACEHOLDER_PREFIX}${counterId}${REFS_EXPAND_PLACEHOLDER_SUFFIX}`;
+      result = result.replace(placeholder, expanded);
+    }
+    return result;
+  }
+};
+
+// src/core/renderer.ts
+var Renderer = class {
+  /**
+   * Render slides and metadata into final Marp markdown
+   */
+  render(slides, meta, options) {
+    const frontMatter = this.renderFrontMatter(meta, options);
+    const slidesContent = this.joinSlides(slides, options?.notes);
+    if (slides.length === 0) {
+      return frontMatter;
+    }
+    return `${frontMatter}
+
+${slidesContent}`;
+  }
+  /**
+   * Render the YAML front matter block
+   */
+  renderFrontMatter(meta, options) {
+    const lines = ["---", "marp: true"];
+    lines.push(`title: ${meta.title}`);
+    if (meta.author) {
+      lines.push(`author: ${meta.author}`);
+    }
+    if (meta.date) {
+      lines.push(`date: ${meta.date}`);
+    }
+    const includeTheme = options?.includeTheme ?? true;
+    if (includeTheme && meta.theme) {
+      lines.push(`theme: ${meta.theme}`);
+    }
+    if (options?.additionalFrontMatter) {
+      for (const [key, value] of Object.entries(options.additionalFrontMatter)) {
+        lines.push(`${key}: ${this.formatFrontMatterValue(value)}`);
+      }
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+  /**
+   * Format a front matter value for YAML
+   */
+  formatFrontMatterValue(value) {
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "string") {
+      if (/[:#[\]{}|>]/.test(value)) {
+        return `"${value.replace(/"/g, '\\"')}"`;
+      }
+      return value;
+    }
+    return String(value);
+  }
+  /**
+   * Join slides with Marp slide separator
+   */
+  joinSlides(slides, notes) {
+    const parts = [];
+    for (let i = 0; i < slides.length; i++) {
+      let slideContent = slides[i];
+      const note = notes?.[i];
+      if (note && note.trim()) {
+        slideContent = `${slideContent}
+
+${this.renderSpeakerNotes(note)}`;
+      }
+      parts.push(slideContent);
+    }
+    return parts.map((slide) => `---
+
+${slide}`).join("\n\n");
+  }
+  /**
+   * Render speaker notes as HTML comment
+   */
+  renderSpeakerNotes(notes) {
+    return `<!--
+${notes}
+-->`;
+  }
+};
+
+// src/core/pipeline.ts
+import { writeFile } from "fs/promises";
+
+// src/templates/engine.ts
+import nunjucks from "nunjucks";
+var TemplateEngine = class {
+  env;
+  constructor() {
+    this.env = new nunjucks.Environment(null, {
+      autoescape: false,
+      // HTML output for Marp
+      throwOnUndefined: false
+    });
+    this.registerFilters();
+    this.registerGlobals();
+  }
+  render(template, context) {
+    return this.env.renderString(template, context);
+  }
+  registerFilters() {
+  }
+  registerGlobals() {
+    const icons = {
+      render: (name, options) => {
+        const size = options?.["size"] ?? "24px";
+        const color = options?.["color"] ?? "currentColor";
+        return `<span class="icon icon-${name}" style="font-size: ${size}; color: ${color};">[${name}]</span>`;
+      }
+    };
+    this.env.addGlobal("icons", icons);
+    const refs = {
+      cite: (id) => {
+        const cleanId = id.replace("@", "");
+        return `(${cleanId})`;
+      },
+      expand: (text) => {
+        return text.replace(/\[@(\w+)\]/g, "($1)");
+      }
+    };
+    this.env.addGlobal("refs", refs);
+  }
+};
+
+// src/templates/loader.ts
+import { z as z3 } from "zod";
+import * as yaml from "yaml";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// src/templates/validators.ts
+import { z as z2 } from "zod";
+function jsonSchemaToZod(schema) {
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    const schemas = schema.oneOf.map((s) => jsonSchemaToZod(s));
+    if (schemas.length === 1) {
+      return schemas[0];
+    }
+    return z2.union(schemas);
+  }
+  const type = schema.type ?? "object";
+  switch (type) {
+    case "string": {
+      if (schema.enum && schema.enum.length > 0) {
+        const enumValues = schema.enum;
+        return z2.enum(enumValues);
+      }
+      let zodSchema = z2.string();
+      if (schema.pattern) {
+        zodSchema = zodSchema.regex(new RegExp(schema.pattern));
+      }
+      return zodSchema;
+    }
+    case "number":
+      return z2.number();
+    case "integer":
+      return z2.number().int();
+    case "boolean":
+      return z2.boolean();
+    case "array": {
+      const itemSchema = schema.items ? jsonSchemaToZod(schema.items) : z2.unknown();
+      let arraySchema = z2.array(itemSchema);
+      if (schema.minItems !== void 0) {
+        arraySchema = arraySchema.min(schema.minItems);
+      }
+      if (schema.maxItems !== void 0) {
+        arraySchema = arraySchema.max(schema.maxItems);
+      }
+      return arraySchema;
+    }
+    case "object": {
+      if (!schema.properties) {
+        return z2.record(z2.unknown());
+      }
+      const shape = {};
+      const required = new Set(schema.required ?? []);
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        const propZod = jsonSchemaToZod(propSchema);
+        shape[key] = required.has(key) ? propZod : propZod.optional();
+      }
+      return z2.object(shape).passthrough();
+    }
+    default:
+      return z2.unknown();
+  }
+}
+function validateWithJsonSchema(schema, content) {
+  const zodSchema = jsonSchemaToZod(schema);
+  const result = zodSchema.safeParse(content);
+  if (result.success) {
+    return { valid: true, errors: [] };
+  }
+  const errors = result.error.errors.map((issue) => {
+    const path3 = issue.path.join(".");
+    return path3 ? `${path3}: ${issue.message}` : issue.message;
+  });
+  return { valid: false, errors };
+}
+
+// src/templates/loader.ts
+var jsonSchemaSchema = z3.record(z3.unknown());
+var templateDefSchema = z3.object({
+  name: z3.string().min(1, "Template name is required"),
+  description: z3.string(),
+  category: z3.string(),
+  schema: jsonSchemaSchema,
+  example: z3.record(z3.unknown()).optional(),
+  output: z3.string().min(1, "Template output is required"),
+  css: z3.string().optional()
+});
+var TemplateLoader = class {
+  templates;
+  constructor() {
+    this.templates = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Load a template from a YAML string
+   */
+  async loadFromString(yamlContent) {
+    const parsed = yaml.parse(yamlContent);
+    const result = templateDefSchema.safeParse(parsed);
+    if (!result.success) {
+      const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(`Invalid template definition: ${errors}`);
+    }
+    this.templates.set(result.data.name, result.data);
+  }
+  /**
+   * Load a template from a file
+   */
+  async loadFromFile(filePath) {
+    const content = await fs.readFile(filePath, "utf-8");
+    await this.loadFromString(content);
+  }
+  /**
+   * Load all templates from a directory (recursively)
+   */
+  async loadBuiltIn(directory) {
+    await this.loadDirectory(directory);
+  }
+  /**
+   * Load custom templates from a directory (can override built-in)
+   */
+  async loadCustom(directory) {
+    await this.loadDirectory(directory);
+  }
+  /**
+   * Internal method to load templates from a directory
+   */
+  async loadDirectory(directory) {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        await this.loadDirectory(fullPath);
+      } else if (entry.isFile() && (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml"))) {
+        await this.loadFromFile(fullPath);
+      }
+    }
+  }
+  /**
+   * Get a template by name
+   */
+  get(name) {
+    return this.templates.get(name);
+  }
+  /**
+   * List all loaded templates
+   */
+  list() {
+    return Array.from(this.templates.values());
+  }
+  /**
+   * List templates filtered by category
+   */
+  listByCategory(category) {
+    return this.list().filter((t) => t.category === category);
+  }
+  /**
+   * Validate content against a template's schema
+   */
+  validateContent(templateName, content) {
+    const template = this.get(templateName);
+    if (!template) {
+      return {
+        valid: false,
+        errors: [`Template "${templateName}" not found`]
+      };
+    }
+    return validateWithJsonSchema(template.schema, content);
+  }
+};
+
+// src/icons/registry.ts
+import * as fs2 from "fs/promises";
+import { parse as parseYaml2 } from "yaml";
+
+// src/icons/schema.ts
+import { z as z4 } from "zod";
+var iconSourceTypeSchema = z4.enum([
+  "web-font",
+  "svg-inline",
+  "svg-sprite",
+  "local-svg"
+]);
+var iconSourceSchema = z4.object({
+  name: z4.string(),
+  type: iconSourceTypeSchema,
+  prefix: z4.string(),
+  url: z4.string().optional(),
+  path: z4.string().optional(),
+  render: z4.string().optional()
+});
+var iconDefaultsSchema = z4.object({
+  size: z4.string().default("24px"),
+  color: z4.string().default("currentColor")
+});
+var iconRegistrySchema = z4.object({
+  sources: z4.array(iconSourceSchema),
+  aliases: z4.record(z4.string()).default({}),
+  colors: z4.record(z4.string()).optional(),
+  defaults: iconDefaultsSchema.default({})
+});
+
+// src/icons/registry.ts
+var IconRegistryLoader = class {
+  registry = null;
+  sourcesByPrefix = /* @__PURE__ */ new Map();
+  aliasMap = /* @__PURE__ */ new Map();
+  colorMap = /* @__PURE__ */ new Map();
+  /**
+   * Load registry from YAML file
+   */
+  async load(configPath) {
+    const content = await fs2.readFile(configPath, "utf-8");
+    const parsed = parseYaml2(content);
+    const validated = iconRegistrySchema.parse(parsed);
+    this.registry = validated;
+    this.buildMaps();
+    return validated;
+  }
+  /**
+   * Resolve an alias to its icon reference
+   * @returns The resolved icon reference or the original name if not an alias
+   */
+  resolveAlias(nameOrAlias) {
+    return this.aliasMap.get(nameOrAlias) ?? nameOrAlias;
+  }
+  /**
+   * Get icon source by prefix
+   */
+  getSource(prefix) {
+    return this.sourcesByPrefix.get(prefix);
+  }
+  /**
+   * Parse an icon reference string (e.g., "mi:home" or "iconify:mdi:account")
+   * @returns Parsed reference or null if invalid format
+   */
+  parseIconReference(reference) {
+    const colonIndex = reference.indexOf(":");
+    if (colonIndex === -1) {
+      return null;
+    }
+    const prefix = reference.substring(0, colonIndex);
+    const name = reference.substring(colonIndex + 1);
+    return { prefix, name };
+  }
+  /**
+   * Get registry defaults
+   */
+  getDefaults() {
+    if (!this.registry) {
+      return { size: "24px", color: "currentColor" };
+    }
+    return this.registry.defaults;
+  }
+  /**
+   * Get color by name from color palette
+   */
+  getColor(name) {
+    return this.colorMap.get(name);
+  }
+  /**
+   * Get all sources
+   */
+  getSources() {
+    return this.registry?.sources ?? [];
+  }
+  /**
+   * Get all aliases
+   */
+  getAliases() {
+    return this.registry?.aliases ?? {};
+  }
+  /**
+   * Check if registry is loaded
+   */
+  isLoaded() {
+    return this.registry !== null;
+  }
+  /**
+   * Build internal lookup maps from registry
+   */
+  buildMaps() {
+    this.sourcesByPrefix.clear();
+    this.aliasMap.clear();
+    this.colorMap.clear();
+    if (!this.registry) {
+      return;
+    }
+    for (const source of this.registry.sources) {
+      this.sourcesByPrefix.set(source.prefix, source);
+    }
+    for (const [alias, target] of Object.entries(this.registry.aliases)) {
+      this.aliasMap.set(alias, target);
+    }
+    if (this.registry.colors) {
+      for (const [name, color] of Object.entries(this.registry.colors)) {
+        this.colorMap.set(name, color);
+      }
+    }
+  }
+};
+
+// src/icons/resolver.ts
+import * as fs3 from "fs/promises";
+import * as path2 from "path";
+import nunjucks2 from "nunjucks";
+var IconResolver = class {
+  constructor(registry) {
+    this.registry = registry;
+    this.nunjucksEnv = new nunjucks2.Environment(null, {
+      autoescape: false
+    });
+  }
+  nunjucksEnv;
+  /**
+   * Render an icon by name or alias
+   */
+  async render(nameOrAlias, options) {
+    const resolved = this.registry.resolveAlias(nameOrAlias);
+    const parsed = this.registry.parseIconReference(resolved);
+    if (!parsed) {
+      throw new Error(
+        `Invalid icon reference format: "${resolved}". Expected format: "prefix:name"`
+      );
+    }
+    const source = this.registry.getSource(parsed.prefix);
+    if (!source) {
+      throw new Error(`Unknown icon source prefix: "${parsed.prefix}"`);
+    }
+    const defaults = this.registry.getDefaults();
+    const mergedOptions = {
+      size: options?.size ?? defaults.size,
+      color: options?.color ?? defaults.color,
+      ...options?.class !== void 0 ? { class: options.class } : {}
+    };
+    switch (source.type) {
+      case "web-font":
+        return this.renderWebFont(source, parsed.name, mergedOptions);
+      case "local-svg":
+        return await this.renderLocalSvg(source, parsed.name, mergedOptions);
+      case "svg-inline":
+        return await this.renderSvgInline(source, parsed.name, mergedOptions);
+      case "svg-sprite":
+        return this.renderSvgSprite(source, parsed.name, mergedOptions);
+      default:
+        throw new Error(`Unsupported icon source type: "${source.type}"`);
+    }
+  }
+  /**
+   * Render a web-font icon
+   */
+  renderWebFont(source, name, options) {
+    const style = this.buildStyle(options);
+    const className = this.buildClassName(name, options);
+    if (source.render) {
+      return this.nunjucksEnv.renderString(source.render, {
+        name,
+        style,
+        class: className,
+        size: options.size,
+        color: options.color
+      });
+    }
+    return `<span class="${className}" style="${style}">${name}</span>`;
+  }
+  /**
+   * Render a local SVG icon
+   */
+  async renderLocalSvg(source, name, options) {
+    if (!source.path) {
+      throw new Error(`Local SVG source "${source.name}" has no path defined`);
+    }
+    const svgPath = path2.join(source.path, `${name}.svg`);
+    try {
+      const svgContent = await fs3.readFile(svgPath, "utf-8");
+      return this.processSvg(svgContent, name, options);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Icon file not found: ${svgPath}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Render an SVG from external URL (placeholder without cache)
+   */
+  async renderSvgInline(source, name, options) {
+    const className = this.buildClassName(name, options);
+    const style = this.buildStyle(options);
+    return `<span class="${className}" style="${style}" data-icon-source="${source.name}" data-icon-name="${name}">[${name}]</span>`;
+  }
+  /**
+   * Render an SVG sprite reference
+   */
+  renderSvgSprite(source, name, options) {
+    const className = this.buildClassName(name, options);
+    const size = options.size ?? "24px";
+    const color = options.color ?? "currentColor";
+    const spriteUrl = source.url ?? "";
+    return `<svg class="${className}" width="${size}" height="${size}" fill="${color}">
+  <use xlink:href="${spriteUrl}#${name}"/>
+</svg>`;
+  }
+  /**
+   * Process SVG content and apply options
+   */
+  processSvg(svgContent, name, options) {
+    const className = this.buildClassName(name, options);
+    const size = options.size ?? "24px";
+    const color = options.color ?? "currentColor";
+    let processed = svgContent.trim();
+    if (processed.includes("class=")) {
+      processed = processed.replace(/class="[^"]*"/, `class="${className}"`);
+    } else {
+      processed = processed.replace("<svg", `<svg class="${className}"`);
+    }
+    if (processed.includes("width=")) {
+      processed = processed.replace(/width="[^"]*"/, `width="${size}"`);
+    } else {
+      processed = processed.replace("<svg", `<svg width="${size}"`);
+    }
+    if (processed.includes("height=")) {
+      processed = processed.replace(/height="[^"]*"/, `height="${size}"`);
+    } else {
+      processed = processed.replace("<svg", `<svg height="${size}"`);
+    }
+    if (color !== "currentColor") {
+      processed = processed.replace(/fill="currentColor"/g, `fill="${color}"`);
+    }
+    return processed;
+  }
+  /**
+   * Build CSS style string
+   */
+  buildStyle(options) {
+    const styles = [];
+    if (options.size) {
+      styles.push(`font-size: ${options.size}`);
+    }
+    if (options.color) {
+      styles.push(`color: ${options.color}`);
+    }
+    return styles.join("; ");
+  }
+  /**
+   * Build class name string
+   */
+  buildClassName(name, options) {
+    const classes = ["icon", `icon-${name}`];
+    if (options.class) {
+      classes.push(options.class);
+    }
+    return classes.join(" ");
+  }
+};
+
+// src/references/manager.ts
+import { exec } from "child_process";
+var ReferenceManagerError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ReferenceManagerError";
+  }
+};
+var ReferenceManager = class {
+  constructor(command = "ref") {
+    this.command = command;
+  }
+  /**
+   * Check if reference-manager CLI is available
+   */
+  async isAvailable() {
+    try {
+      await this.execCommand(`${this.command} --version`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get all references from the library
+   */
+  async getAll() {
+    const result = await this.execCommand(`${this.command} list --format json`);
+    return this.parseJSON(result);
+  }
+  /**
+   * Get a single reference by ID
+   */
+  async getById(id) {
+    const result = await this.execCommand(
+      `${this.command} list --id ${id} --format json`
+    );
+    const items = this.parseJSON(result);
+    return items[0] || null;
+  }
+  /**
+   * Get multiple references by IDs
+   */
+  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 map = /* @__PURE__ */ new Map();
+    for (const item of allItems) {
+      if (idSet.has(item.id)) {
+        map.set(item.id, item);
+      }
+    }
+    return map;
+  }
+  execCommand(cmd) {
+    return new Promise((resolve2, reject) => {
+      exec(cmd, (error, stdout) => {
+        if (error) {
+          reject(
+            new ReferenceManagerError(`Failed to execute: ${cmd}`, error)
+          );
+          return;
+        }
+        resolve2(stdout.toString());
+      });
+    });
+  }
+  parseJSON(data) {
+    try {
+      return JSON.parse(data);
+    } catch (error) {
+      throw new ReferenceManagerError(
+        "Failed to parse reference-manager output as JSON",
+        error
+      );
+    }
+  }
+};
+
+// src/references/extractor.ts
+var SINGLE_CITATION_PATTERN = /@([\w-]+)(?:,\s*([^;\]]+))?/g;
+var CITATION_BRACKET_PATTERN = /\[(@[\w-]+(?:,\s*[^;\]]+)?(?:;\s*@[\w-]+(?:,\s*[^;\]]+)?)*)\]/g;
+var SOURCE_CITATION_PATTERN = /^@([\w-]+)$/;
+var CitationExtractor = class {
+  /**
+   * Extract citations from a text string
+   */
+  extract(text) {
+    const citations = [];
+    let bracketMatch;
+    CITATION_BRACKET_PATTERN.lastIndex = 0;
+    while ((bracketMatch = CITATION_BRACKET_PATTERN.exec(text)) !== null) {
+      const bracketStart = bracketMatch.index;
+      const bracketContent = bracketMatch[1];
+      SINGLE_CITATION_PATTERN.lastIndex = 0;
+      let singleMatch;
+      while ((singleMatch = SINGLE_CITATION_PATTERN.exec(bracketContent)) !== null) {
+        const id = singleMatch[1];
+        const locator = singleMatch[2]?.trim();
+        citations.push({
+          id,
+          locator: locator ?? void 0,
+          position: {
+            start: bracketStart,
+            end: bracketStart + bracketMatch[0].length
+          }
+        });
+      }
+    }
+    return citations;
+  }
+  /**
+   * Extract citations from a slide's content
+   */
+  extractFromSlide(slide) {
+    const allCitations = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    const extractFromValue = (value) => {
+      if (typeof value === "string") {
+        const sourceMatch = SOURCE_CITATION_PATTERN.exec(value);
+        if (sourceMatch && sourceMatch[1]) {
+          const id = sourceMatch[1];
+          if (!seenIds.has(id)) {
+            seenIds.add(id);
+            allCitations.push({
+              id,
+              locator: void 0,
+              position: { start: 0, end: value.length }
+            });
+          }
+          return;
+        }
+        const citations = this.extract(value);
+        for (const citation of citations) {
+          if (!seenIds.has(citation.id)) {
+            seenIds.add(citation.id);
+            allCitations.push(citation);
+          }
+        }
+      } else if (Array.isArray(value)) {
+        for (const item of value) {
+          extractFromValue(item);
+        }
+      } else if (value && typeof value === "object") {
+        for (const v of Object.values(value)) {
+          extractFromValue(v);
+        }
+      }
+    };
+    extractFromValue(slide.content);
+    if (slide.notes) {
+      const notesCitations = this.extract(slide.notes);
+      for (const citation of notesCitations) {
+        if (!seenIds.has(citation.id)) {
+          seenIds.add(citation.id);
+          allCitations.push(citation);
+        }
+      }
+    }
+    return allCitations;
+  }
+  /**
+   * Extract citations from all slides in a presentation
+   */
+  extractFromPresentation(presentation) {
+    const allCitations = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const slide of presentation.slides) {
+      const slideCitations = this.extractFromSlide(slide);
+      for (const citation of slideCitations) {
+        if (!seenIds.has(citation.id)) {
+          seenIds.add(citation.id);
+          allCitations.push(citation);
+        }
+      }
+    }
+    return allCitations;
+  }
+  /**
+   * Get unique citation IDs in order of first appearance
+   */
+  getUniqueIds(citations) {
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueIds = [];
+    for (const citation of citations) {
+      if (!seen.has(citation.id)) {
+        seen.add(citation.id);
+        uniqueIds.push(citation.id);
+      }
+    }
+    return uniqueIds;
+  }
+};
+
+// src/references/formatter.ts
+var DEFAULT_CONFIG = {
+  author: {
+    maxAuthors: 2,
+    etAl: "et al.",
+    etAlJa: "\u307B\u304B",
+    separatorJa: "\u30FB"
+  },
+  inline: {
+    authorSep: ", ",
+    identifierSep: "; ",
+    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 {
+  constructor(manager, config) {
+    this.manager = manager;
+    this.config = {
+      author: { ...DEFAULT_CONFIG.author, ...config?.author },
+      inline: { ...DEFAULT_CONFIG.inline, ...config?.inline }
+    };
+  }
+  config;
+  /**
+   * Format an inline citation
+   * e.g., "(Smith et al., 2024; PMID: 12345678)"
+   */
+  async formatInline(id) {
+    const item = await this.manager.getById(id);
+    if (!item) {
+      return `[${id}]`;
+    }
+    return this.formatInlineItem(item);
+  }
+  /**
+   * Format a full bibliography citation
+   */
+  async formatFull(id) {
+    const item = await this.manager.getById(id);
+    if (!item) {
+      return `[${id}]`;
+    }
+    return this.formatFullItem(item);
+  }
+  /**
+   * Expand all citations in text
+   * e.g., "[@smith2024]" -> "(Smith et al., 2024; PMID: 12345678)"
+   */
+  async expandCitations(text) {
+    const ids = /* @__PURE__ */ new Set();
+    CITATION_BRACKET_PATTERN2.lastIndex = 0;
+    let match;
+    while ((match = CITATION_BRACKET_PATTERN2.exec(text)) !== null) {
+      const content = match[1];
+      SINGLE_CITATION_PATTERN2.lastIndex = 0;
+      let singleMatch;
+      while ((singleMatch = SINGLE_CITATION_PATTERN2.exec(content)) !== null) {
+        ids.add(singleMatch[1]);
+      }
+    }
+    const items = await this.manager.getByIds([...ids]);
+    CITATION_BRACKET_PATTERN2.lastIndex = 0;
+    let result = text;
+    const matches = [];
+    CITATION_BRACKET_PATTERN2.lastIndex = 0;
+    while ((match = CITATION_BRACKET_PATTERN2.exec(text)) !== null) {
+      const content = match[1];
+      const replacements = [];
+      SINGLE_CITATION_PATTERN2.lastIndex = 0;
+      let singleMatch;
+      while ((singleMatch = SINGLE_CITATION_PATTERN2.exec(content)) !== null) {
+        const id = singleMatch[1];
+        const item = items.get(id);
+        if (item) {
+          replacements.push(this.formatInlineItem(item));
+        } else {
+          replacements.push(`[${id}]`);
+        }
+      }
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        replacement: replacements.join(", ")
+      });
+    }
+    for (const m of [...matches].reverse()) {
+      result = result.slice(0, m.start) + m.replacement + result.slice(m.end);
+    }
+    return result;
+  }
+  /**
+   * Generate bibliography entries
+   */
+  async generateBibliography(ids, sort = "citation-order") {
+    if (ids.length === 0) {
+      return [];
+    }
+    const items = await this.manager.getByIds(ids);
+    let sortedItems;
+    if (sort === "citation-order") {
+      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);
+        return authorA.localeCompare(authorB);
+      });
+    } else {
+      sortedItems = [...items.values()].sort((a, b) => {
+        const yearA = this.getYear(a);
+        const yearB = this.getYear(b);
+        return yearA - yearB;
+      });
+    }
+    return sortedItems.map((item) => this.formatFullItem(item));
+  }
+  formatInlineItem(item) {
+    const author = this.formatAuthorInline(item.author);
+    const year = this.getYear(item);
+    const identifier = this.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 { 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 : " & ";
+      return `${firstAuthor.family}${separator}${authors[1].family}`;
+    }
+    const suffix = isJapanese ? 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 || "";
+  }
+  getYear(item) {
+    const dateParts = item.issued?.["date-parts"];
+    if (dateParts && dateParts[0] && dateParts[0][0]) {
+      return dateParts[0][0];
+    }
+    return 0;
+  }
+  getIdentifier(item) {
+    if (item.PMID) {
+      return `PMID: ${item.PMID}`;
+    }
+    if (item.DOI) {
+      return `DOI: ${item.DOI}`;
+    }
+    return null;
+  }
+};
+
+// src/core/pipeline.ts
+var PipelineError = class extends Error {
+  constructor(message, stage, details) {
+    super(message);
+    this.stage = stage;
+    this.details = details;
+    this.name = "PipelineError";
+  }
+};
+var Pipeline = class {
+  constructor(config) {
+    this.config = config;
+    this.parser = new Parser();
+    this.templateEngine = new TemplateEngine();
+    this.templateLoader = new TemplateLoader();
+    this.iconRegistry = new IconRegistryLoader();
+    this.iconResolver = new IconResolver(this.iconRegistry);
+    this.referenceManager = new ReferenceManager(
+      config.references.connection.command
+    );
+    this.citationExtractor = new CitationExtractor();
+    this.citationFormatter = new CitationFormatter(
+      this.referenceManager,
+      {
+        author: {
+          maxAuthors: config.references.format.maxAuthors,
+          etAl: config.references.format.etAl,
+          etAlJa: config.references.format.etAlJa
+        },
+        inline: {
+          authorSep: config.references.format.authorSep,
+          identifierSep: config.references.format.identifierSep
+        }
+      }
+    );
+    this.transformer = new Transformer(
+      this.templateEngine,
+      this.templateLoader,
+      this.iconResolver,
+      this.citationFormatter
+    );
+    this.renderer = new Renderer();
+  }
+  parser;
+  templateEngine;
+  templateLoader;
+  iconRegistry;
+  iconResolver;
+  referenceManager;
+  citationExtractor;
+  citationFormatter;
+  transformer;
+  renderer;
+  warnings = [];
+  /**
+   * Run the full conversion pipeline
+   */
+  async run(inputPath, options) {
+    this.warnings = [];
+    try {
+      const presentation = await this.parseSource(inputPath);
+      const citationIds = this.collectCitations(presentation);
+      await this.resolveReferences(citationIds);
+      const transformedSlides = await this.transformSlides(presentation);
+      const output = this.render(transformedSlides, presentation);
+      if (options?.outputPath) {
+        await writeFile(options.outputPath, output, "utf-8");
+      }
+      return output;
+    } catch (error) {
+      if (error instanceof PipelineError) {
+        throw error;
+      }
+      throw new PipelineError(
+        error instanceof Error ? error.message : "Unknown error",
+        "unknown",
+        error
+      );
+    }
+  }
+  /**
+   * Run the full pipeline with detailed result
+   */
+  async runWithResult(inputPath, options) {
+    this.warnings = [];
+    try {
+      const presentation = await this.parseSource(inputPath);
+      const citationIds = this.collectCitations(presentation);
+      await this.resolveReferences(citationIds);
+      const transformedSlides = await this.transformSlides(presentation);
+      const output = this.render(transformedSlides, presentation);
+      if (options?.outputPath) {
+        await writeFile(options.outputPath, output, "utf-8");
+      }
+      return {
+        output,
+        citations: citationIds,
+        warnings: this.warnings,
+        slideCount: presentation.slides.length
+      };
+    } catch (error) {
+      if (error instanceof PipelineError) {
+        throw error;
+      }
+      throw new PipelineError(
+        error instanceof Error ? error.message : "Unknown error",
+        "unknown",
+        error
+      );
+    }
+  }
+  /**
+   * Initialize the pipeline by loading templates and icon registry
+   */
+  async initialize() {
+    try {
+      await this.templateLoader.loadBuiltIn(this.config.templates.builtin);
+      if (this.config.templates.custom) {
+        await this.templateLoader.loadCustom(this.config.templates.custom);
+      }
+      await this.iconRegistry.load(this.config.icons.registry);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to initialize pipeline: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "initialize",
+        error
+      );
+    }
+  }
+  /**
+   * Get collected warnings
+   */
+  getWarnings() {
+    return [...this.warnings];
+  }
+  // --- Private Stage Methods ---
+  /**
+   * Stage 1: Parse the YAML source file
+   */
+  async parseSource(inputPath) {
+    try {
+      return await this.parser.parseFile(inputPath);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to parse source file: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "parse",
+        error
+      );
+    }
+  }
+  /**
+   * Stage 2: Collect all citation IDs from the presentation
+   */
+  collectCitations(presentation) {
+    const citations = this.citationExtractor.extractFromPresentation(presentation);
+    return this.citationExtractor.getUniqueIds(citations);
+  }
+  /**
+   * Stage 3: Resolve references from the reference manager
+   */
+  async resolveReferences(ids) {
+    if (!this.config.references.enabled || ids.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    try {
+      const items = await this.referenceManager.getByIds(ids);
+      for (const id of ids) {
+        if (!items.has(id)) {
+          this.warnings.push(`Reference not found: ${id}`);
+        }
+      }
+      return items;
+    } catch (error) {
+      this.warnings.push(
+        `Failed to resolve references: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * Stage 4: Transform all slides using templates
+   */
+  async transformSlides(presentation) {
+    try {
+      return await this.transformer.transformAll(presentation);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to transform slides: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "transform",
+        error
+      );
+    }
+  }
+  /**
+   * Stage 5: Render the final Marp markdown
+   */
+  render(slides, presentation) {
+    try {
+      const notes = presentation.slides.map((slide) => slide.notes);
+      const renderOptions = {
+        includeTheme: true,
+        notes
+      };
+      return this.renderer.render(slides, presentation.meta, renderOptions);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to render output: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "render",
+        error
+      );
+    }
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+// src/cli/commands/convert.ts
+import { Command } from "commander";
+import { access as access2 } from "fs/promises";
+import { basename, dirname, join as join4 } from "path";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config/loader.ts
+import { access, readFile as readFile5 } from "fs/promises";
+import { join as join3 } from "path";
+import { parse as parseYaml3 } from "yaml";
+
+// src/config/schema.ts
+import { z as z5 } from "zod";
+var configSchema = z5.object({
+  templates: z5.object({
+    builtin: z5.string().default("./templates"),
+    custom: z5.string().optional()
+  }).default({}),
+  icons: z5.object({
+    registry: z5.string().default("./icons/registry.yaml"),
+    cache: z5.object({
+      enabled: z5.boolean().default(true),
+      directory: z5.string().default(".cache/icons"),
+      ttl: z5.number().default(86400)
+    }).default({})
+  }).default({}),
+  references: z5.object({
+    enabled: z5.boolean().default(true),
+    connection: z5.object({
+      type: z5.literal("cli").default("cli"),
+      command: z5.string().default("ref")
+    }).default({}),
+    format: z5.object({
+      locale: z5.string().default("ja-JP"),
+      authorSep: z5.string().default(", "),
+      identifierSep: z5.string().default("; "),
+      maxAuthors: z5.number().default(2),
+      etAl: z5.string().default("et al."),
+      etAlJa: z5.string().default("\u307B\u304B")
+    }).default({})
+  }).default({}),
+  output: z5.object({
+    theme: z5.string().default("default"),
+    inlineStyles: z5.boolean().default(false)
+  }).default({})
+});
+
+// src/config/loader.ts
+var CONFIG_NAMES = ["config.yaml", "slide-gen.yaml"];
+var ConfigLoader = class {
+  async load(configPath) {
+    const fileConfig = await this.loadFile(configPath);
+    return configSchema.parse(fileConfig);
+  }
+  async findConfig(directory) {
+    for (const name of CONFIG_NAMES) {
+      const path3 = join3(directory, name);
+      try {
+        await access(path3);
+        return path3;
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  async loadFile(configPath) {
+    if (!configPath) return {};
+    try {
+      const content = await readFile5(configPath, "utf-8");
+      return parseYaml3(content) ?? {};
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return {};
+      }
+      throw error;
+    }
+  }
+};
+
+// src/cli/commands/convert.ts
+var ExitCode = {
+  Success: 0,
+  GeneralError: 1,
+  ArgumentError: 2,
+  FileReadError: 3,
+  ValidationError: 4,
+  ConversionError: 5,
+  ReferenceError: 6
+};
+function getDefaultOutputPath(inputPath) {
+  const dir = dirname(inputPath);
+  const base = basename(inputPath, ".yaml");
+  return join4(dir, `${base}.md`);
+}
+function createConvertCommand() {
+  return new Command("convert").description("Convert YAML source to Marp Markdown").argument("<input>", "Input YAML file").option("-o, --output <path>", "Output file path").option("-c, --config <path>", "Config file path").option("-t, --theme <name>", "Theme name").option("--no-references", "Disable reference processing").option("-v, --verbose", "Verbose output").action(async (input, options) => {
+    await executeConvert(input, options);
+  });
+}
+async function executeConvert(inputPath, options) {
+  const spinner = options.verbose ? null : ora();
+  const verbose = options.verbose ?? false;
+  const updateSpinner = (text) => {
+    if (spinner) {
+      spinner.text = text;
+    }
+  };
+  try {
+    spinner?.start(`Reading ${inputPath}...`);
+    try {
+      await access2(inputPath);
+    } catch {
+      spinner?.fail(`File not found: ${inputPath}`);
+      console.error(chalk.red(`Error: Input file not found: ${inputPath}`));
+      process.exitCode = ExitCode.FileReadError;
+      return;
+    }
+    const outputPath = options.output ?? getDefaultOutputPath(inputPath);
+    updateSpinner("Loading configuration...");
+    const configLoader = new ConfigLoader();
+    let configPath = options.config;
+    if (!configPath) {
+      configPath = await configLoader.findConfig(dirname(inputPath));
+    }
+    const config = await configLoader.load(configPath);
+    if (options.references === false) {
+      config.references.enabled = false;
+    }
+    if (options.theme) {
+      config.output.theme = options.theme;
+    }
+    updateSpinner("Initializing pipeline...");
+    const pipeline = new Pipeline(config);
+    try {
+      await pipeline.initialize();
+    } catch (error) {
+      spinner?.fail("Failed to initialize pipeline");
+      if (error instanceof PipelineError) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else {
+        console.error(
+          chalk.red(
+            `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+          )
+        );
+      }
+      process.exitCode = ExitCode.ConversionError;
+      return;
+    }
+    updateSpinner(`Converting ${inputPath}...`);
+    const result = await pipeline.runWithResult(inputPath, { outputPath });
+    spinner?.succeed(`Converted ${inputPath}`);
+    if (verbose) {
+      console.log("");
+      console.log(chalk.green("  \u2713") + ` Parsed ${result.slideCount} slides`);
+      if (result.citations.length > 0) {
+        console.log(
+          chalk.green("  \u2713") + ` Resolved ${result.citations.length} references`
+        );
+      }
+      console.log(chalk.green("  \u2713") + " Generated output");
+    }
+    for (const warning of result.warnings) {
+      console.log(chalk.yellow("  \u26A0") + ` ${warning}`);
+    }
+    console.log("");
+    console.log(`Output: ${chalk.cyan(outputPath)}`);
+  } catch (error) {
+    spinner?.fail("Conversion failed");
+    if (error instanceof PipelineError) {
+      console.error(chalk.red(`
+Error (${error.stage}): ${error.message}`));
+      switch (error.stage) {
+        case "parse":
+          process.exitCode = ExitCode.FileReadError;
+          break;
+        case "transform":
+          process.exitCode = ExitCode.ValidationError;
+          break;
+        case "render":
+          process.exitCode = ExitCode.ConversionError;
+          break;
+        default:
+          process.exitCode = ExitCode.GeneralError;
+      }
+    } else {
+      console.error(
+        chalk.red(
+          `
+Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        )
+      );
+      process.exitCode = ExitCode.GeneralError;
+    }
+  }
+}
+
+// src/cli/commands/validate.ts
+import { Command as Command2 } from "commander";
+import { access as access3, readFile as readFile6 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { parse as parseYaml4 } from "yaml";
+function createValidateCommand() {
+  return new Command2("validate").description("Validate source file without conversion").argument("<input>", "Input YAML file").option("-c, --config <path>", "Config file path").option("--strict", "Treat warnings as errors").option("--format <fmt>", "Output format (text/json)", "text").action(async (input, options) => {
+    await executeValidate(input, options);
+  });
+}
+async function executeValidate(inputPath, options) {
+  const isJsonFormat = options.format === "json";
+  const spinner = isJsonFormat ? null : ora2();
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: [],
+    stats: {
+      yamlSyntax: false,
+      metaValid: false,
+      slideCount: 0,
+      templatesFound: false,
+      iconsResolved: false,
+      referencesCount: 0
+    }
+  };
+  try {
+    spinner?.start(`Validating ${inputPath}...`);
+    try {
+      await access3(inputPath);
+    } catch {
+      spinner?.fail(`File not found: ${inputPath}`);
+      result.errors.push(`File not found: ${inputPath}`);
+      result.valid = false;
+      outputResult(result, options);
+      process.exitCode = ExitCode.FileReadError;
+      return;
+    }
+    const content = await readFile6(inputPath, "utf-8");
+    try {
+      parseYaml4(content);
+      result.stats.yamlSyntax = true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      result.errors.push(`YAML syntax error: ${message}`);
+      result.valid = false;
+      spinner?.fail("YAML syntax invalid");
+      outputResult(result, options);
+      process.exitCode = ExitCode.ValidationError;
+      return;
+    }
+    const parser = new Parser();
+    let presentation;
+    try {
+      presentation = parser.parse(content);
+      result.stats.metaValid = true;
+      result.stats.slideCount = presentation.slides.length;
+    } catch (error) {
+      if (error instanceof ParseError) {
+        result.errors.push(`Parse error: ${error.message}`);
+      } else if (error instanceof ValidationError) {
+        result.errors.push(`Schema validation error: ${error.message}`);
+      } else {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        result.errors.push(`Schema error: ${message}`);
+      }
+      result.valid = false;
+      spinner?.fail("Schema validation failed");
+      outputResult(result, options);
+      process.exitCode = ExitCode.ValidationError;
+      return;
+    }
+    const configLoader = new ConfigLoader();
+    let configPath = options.config;
+    if (!configPath) {
+      configPath = await configLoader.findConfig(dirname2(inputPath));
+    }
+    const config = await configLoader.load(configPath);
+    const templateLoader = new TemplateLoader();
+    try {
+      await templateLoader.loadBuiltIn(config.templates.builtin);
+      if (config.templates.custom) {
+        try {
+          await templateLoader.loadCustom(config.templates.custom);
+        } catch {
+        }
+      }
+    } catch (error) {
+      result.warnings.push(
+        `Could not load templates: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const missingTemplates = [];
+    for (let i = 0; i < presentation.slides.length; i++) {
+      const slide = presentation.slides[i];
+      const template = templateLoader.get(slide.template);
+      if (!template) {
+        missingTemplates.push(`Slide ${i + 1}: Template "${slide.template}" not found`);
+      } else {
+        const validationResult = templateLoader.validateContent(
+          slide.template,
+          slide.content
+        );
+        if (!validationResult.valid) {
+          for (const err of validationResult.errors) {
+            result.errors.push(`Slide ${i + 1} (${slide.template}): ${err}`);
+          }
+        }
+      }
+    }
+    if (missingTemplates.length > 0) {
+      for (const msg of missingTemplates) {
+        result.errors.push(msg);
+      }
+      result.valid = false;
+    } else {
+      result.stats.templatesFound = true;
+    }
+    const iconRegistry = new IconRegistryLoader();
+    try {
+      await iconRegistry.load(config.icons.registry);
+      result.stats.iconsResolved = true;
+    } catch (error) {
+      result.warnings.push(
+        `Could not load icon registry: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const iconPattern = /icon\(['"]([^'"]+)['"]\)/g;
+    for (let i = 0; i < presentation.slides.length; i++) {
+      const slide = presentation.slides[i];
+      const contentStr = JSON.stringify(slide.content);
+      let match;
+      while ((match = iconPattern.exec(contentStr)) !== null) {
+        const iconRef = match[1];
+        const resolved = iconRegistry.resolveAlias(iconRef);
+        const parsed = iconRegistry.parseIconReference(resolved);
+        if (parsed) {
+          const source = iconRegistry.getSource(parsed.prefix);
+          if (!source) {
+            result.warnings.push(
+              `Slide ${i + 1}: Unknown icon source "${parsed.prefix}" in "${iconRef}"`
+            );
+          }
+        } else if (!iconRegistry.resolveAlias(iconRef)) {
+          result.warnings.push(`Slide ${i + 1}: Unknown icon "${iconRef}"`);
+        }
+      }
+    }
+    const citationPattern = /@([a-zA-Z0-9_-]+)/g;
+    const references = /* @__PURE__ */ new Set();
+    for (const slide of presentation.slides) {
+      const contentStr = JSON.stringify(slide.content);
+      let match;
+      while ((match = citationPattern.exec(contentStr)) !== null) {
+        references.add(match[1]);
+      }
+    }
+    result.stats.referencesCount = references.size;
+    if (result.errors.length > 0) {
+      result.valid = false;
+    }
+    if (options.strict && result.warnings.length > 0) {
+      result.valid = false;
+      result.errors.push(...result.warnings);
+      result.warnings = [];
+    }
+    if (result.valid) {
+      spinner?.succeed(`Validated ${inputPath}`);
+    } else {
+      spinner?.fail(`Validation failed for ${inputPath}`);
+    }
+    outputResult(result, options);
+    if (!result.valid) {
+      process.exitCode = ExitCode.ValidationError;
+    }
+  } catch (error) {
+    spinner?.fail("Validation failed");
+    result.errors.push(
+      `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    result.valid = false;
+    outputResult(result, options);
+    process.exitCode = ExitCode.GeneralError;
+  }
+}
+function outputResult(result, options) {
+  if (options.format === "json") {
+    console.log(
+      JSON.stringify(
+        {
+          valid: result.valid,
+          errors: result.errors,
+          warnings: result.warnings,
+          stats: result.stats
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log("");
+  if (result.stats.yamlSyntax) {
+    console.log(chalk2.green("\u2713") + " YAML syntax valid");
+  } else {
+    console.log(chalk2.red("\u2717") + " YAML syntax invalid");
+  }
+  if (result.stats.metaValid) {
+    console.log(chalk2.green("\u2713") + " Meta section valid");
+  }
+  if (result.stats.slideCount > 0) {
+    console.log(chalk2.green("\u2713") + ` ${result.stats.slideCount} slides validated`);
+  }
+  if (result.stats.templatesFound) {
+    console.log(chalk2.green("\u2713") + " All templates found");
+  }
+  if (result.stats.iconsResolved) {
+    console.log(chalk2.green("\u2713") + " All icons resolved");
+  }
+  if (result.stats.referencesCount > 0) {
+    console.log(chalk2.green("\u2713") + ` ${result.stats.referencesCount} references found`);
+  }
+  for (const error of result.errors) {
+    console.log(chalk2.red("\u2717") + ` ${error}`);
+  }
+  for (const warning of result.warnings) {
+    console.log(chalk2.yellow("\u26A0") + ` ${warning}`);
+  }
+  console.log("");
+  if (result.valid) {
+    console.log(chalk2.green("Validation passed!"));
+  } else {
+    const errorCount = result.errors.length;
+    const warningCount = result.warnings.length;
+    let summary = `Validation failed with ${errorCount} error${errorCount !== 1 ? "s" : ""}`;
+    if (warningCount > 0) {
+      summary += ` and ${warningCount} warning${warningCount !== 1 ? "s" : ""}`;
+    }
+    console.log(chalk2.red(summary));
+  }
+}
+
+// src/cli/commands/templates.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import * as yaml2 from "yaml";
+function formatTableList(templates) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const cat = template.category;
+    if (!byCategory.has(cat)) {
+      byCategory.set(cat, []);
+    }
+    byCategory.get(cat).push(template);
+  }
+  const lines = ["Templates:", ""];
+  const sortedCategories = Array.from(byCategory.keys()).sort();
+  for (const category of sortedCategories) {
+    lines.push(`${category}/`);
+    const categoryTemplates = byCategory.get(category);
+    categoryTemplates.sort((a, b) => a.name.localeCompare(b.name));
+    for (const template of categoryTemplates) {
+      const paddedName = template.name.padEnd(16);
+      lines.push(`  ${paddedName}${template.description}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatJsonList(templates) {
+  const output = templates.map((t) => ({
+    name: t.name,
+    description: t.description,
+    category: t.category
+  }));
+  return JSON.stringify(output, null, 2);
+}
+function formatLlmList(templates) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const cat = template.category;
+    if (!byCategory.has(cat)) {
+      byCategory.set(cat, []);
+    }
+    byCategory.get(cat).push(template);
+  }
+  const lines = [];
+  const sortedCategories = Array.from(byCategory.keys()).sort();
+  for (const category of sortedCategories) {
+    lines.push(`[${category}]`);
+    const categoryTemplates = byCategory.get(category);
+    categoryTemplates.sort((a, b) => a.name.localeCompare(b.name));
+    for (const template of categoryTemplates) {
+      lines.push(`${template.name}: ${template.description}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function formatTemplateList(templates, format) {
+  switch (format) {
+    case "json":
+      return formatJsonList(templates);
+    case "llm":
+      return formatLlmList(templates);
+    case "table":
+    default:
+      return formatTableList(templates);
+  }
+}
+function formatSchemaProperty(name, prop, required, indent) {
+  const lines = [];
+  const type = prop["type"] ?? "unknown";
+  const requiredStr = required ? ", required" : "";
+  const description = prop["description"];
+  lines.push(`${indent}${name} (${type}${requiredStr})`);
+  if (description) {
+    lines.push(`${indent}  ${description}`);
+  }
+  if (type === "object" && prop["properties"]) {
+    const nestedRequired = prop["required"] ?? [];
+    const properties = prop["properties"];
+    for (const [propName, propDef] of Object.entries(properties)) {
+      lines.push(
+        ...formatSchemaProperty(propName, propDef, nestedRequired.includes(propName), indent + "  ")
+      );
+    }
+  }
+  if (type === "array" && prop["items"]) {
+    const items = prop["items"];
+    if (items["type"] === "object" && items["properties"]) {
+      const itemRequired = items["required"] ?? [];
+      const itemProps = items["properties"];
+      lines.push(`${indent}  Items:`);
+      for (const [propName, propDef] of Object.entries(itemProps)) {
+        lines.push(
+          ...formatSchemaProperty(propName, propDef, itemRequired.includes(propName), indent + "    ")
+        );
+      }
+    }
+  }
+  return lines;
+}
+function formatTextInfo(template) {
+  const lines = [
+    `Template: ${template.name}`,
+    `Description: ${template.description}`,
+    `Category: ${template.category}`,
+    "",
+    "Schema:"
+  ];
+  const schema = template.schema;
+  if (schema.properties) {
+    const required = schema.required ?? [];
+    for (const [name, prop] of Object.entries(schema.properties)) {
+      lines.push(...formatSchemaProperty(name, prop, required.includes(name), "  "));
+    }
+  }
+  if (template.example) {
+    lines.push("", "Example:");
+    const exampleYaml = yaml2.stringify(template.example, { indent: 2 });
+    lines.push(
+      ...exampleYaml.split("\n").filter((l) => l.trim()).map((l) => `  ${l}`)
+    );
+  }
+  return lines.join("\n");
+}
+function formatJsonInfo(template) {
+  return JSON.stringify(
+    {
+      name: template.name,
+      description: template.description,
+      category: template.category,
+      schema: template.schema,
+      example: template.example
+    },
+    null,
+    2
+  );
+}
+function formatLlmInfo(template) {
+  const lines = [
+    `Template: ${template.name}`,
+    `Description: ${template.description}`,
+    `Category: ${template.category}`,
+    "",
+    "Schema:"
+  ];
+  const schema = template.schema;
+  if (schema.properties) {
+    const required = schema.required ?? [];
+    for (const [name, prop] of Object.entries(schema.properties)) {
+      const type = prop["type"] ?? "unknown";
+      const reqStr = required.includes(name) ? ", required" : "";
+      lines.push(`  ${name} (${type}${reqStr})`);
+      const description = prop["description"];
+      if (description) {
+        lines.push(`    ${description}`);
+      }
+    }
+  }
+  if (template.example) {
+    lines.push("", "Example:");
+    const exampleYaml = yaml2.stringify(
+      { template: template.name, content: template.example },
+      { indent: 2 }
+    );
+    lines.push(
+      ...exampleYaml.split("\n").filter((l) => l.trim()).map((l) => `  ${l}`)
+    );
+  }
+  return lines.join("\n");
+}
+function formatTemplateInfo(template, format) {
+  switch (format) {
+    case "json":
+      return formatJsonInfo(template);
+    case "llm":
+      return formatLlmInfo(template);
+    case "text":
+    default:
+      return formatTextInfo(template);
+  }
+}
+function formatTemplateExample(template) {
+  const slideYaml = yaml2.stringify(
+    [{ template: template.name, content: template.example ?? {} }],
+    { indent: 2 }
+  );
+  return slideYaml;
+}
+async function loadTemplates(configPath) {
+  const configLoader = new ConfigLoader();
+  if (!configPath) {
+    configPath = await configLoader.findConfig(process.cwd());
+  }
+  const config = await configLoader.load(configPath);
+  const templateLoader = new TemplateLoader();
+  try {
+    await templateLoader.loadBuiltIn(config.templates.builtin);
+  } catch {
+  }
+  if (config.templates.custom) {
+    try {
+      await templateLoader.loadCustom(config.templates.custom);
+    } catch {
+    }
+  }
+  return templateLoader;
+}
+function createListCommand() {
+  return new Command3("list").description("List available templates").option("--category <cat>", "Filter by category").option("--format <fmt>", "Output format (table/json/llm)", "table").option("-c, --config <path>", "Config file path").action(async (options) => {
+    try {
+      const templateLoader = await loadTemplates(options.config);
+      let templates = templateLoader.list();
+      if (options.category) {
+        templates = templateLoader.listByCategory(options.category);
+      }
+      if (templates.length === 0) {
+        if (options.format === "json") {
+          console.log("[]");
+        } else {
+          console.log("No templates found.");
+        }
+        return;
+      }
+      const format = options.format ?? "table";
+      const output = formatTemplateList(templates, format);
+      console.log(output);
+    } catch (error) {
+      console.error(
+        chalk3.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+      );
+      process.exitCode = ExitCode.GeneralError;
+    }
+  });
+}
+function createInfoCommand() {
+  return new Command3("info").description("Show template details").argument("<name>", "Template name").option("--format <fmt>", "Output format (text/json/llm)", "text").option("-c, --config <path>", "Config file path").action(async (name, options) => {
+    try {
+      const templateLoader = await loadTemplates(options.config);
+      const template = templateLoader.get(name);
+      if (!template) {
+        console.error(chalk3.red(`Error: Template "${name}" not found`));
+        process.exitCode = ExitCode.GeneralError;
+        return;
+      }
+      const format = options.format ?? "text";
+      const output = formatTemplateInfo(template, format);
+      console.log(output);
+    } catch (error) {
+      console.error(
+        chalk3.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+      );
+      process.exitCode = ExitCode.GeneralError;
+    }
+  });
+}
+function createExampleCommand() {
+  return new Command3("example").description("Output example YAML for a template").argument("<name>", "Template name").option("-c, --config <path>", "Config file path").action(async (name, options) => {
+    try {
+      const templateLoader = await loadTemplates(options.config);
+      const template = templateLoader.get(name);
+      if (!template) {
+        console.error(chalk3.red(`Error: Template "${name}" not found`));
+        process.exitCode = ExitCode.GeneralError;
+        return;
+      }
+      const output = formatTemplateExample(template);
+      console.log(output);
+    } catch (error) {
+      console.error(
+        chalk3.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+      );
+      process.exitCode = ExitCode.GeneralError;
+    }
+  });
+}
+function createTemplatesCommand() {
+  const cmd = new Command3("templates").description("Manage and list templates");
+  cmd.addCommand(createListCommand());
+  cmd.addCommand(createInfoCommand());
+  cmd.addCommand(createExampleCommand());
+  return cmd;
+}
+
+// src/cli/commands/icons.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+function formatTableSourceList(sources) {
+  const lines = ["Icon Sources:", ""];
+  const maxNameLen = Math.max(...sources.map((s) => s.name.length), 4);
+  const maxPrefixLen = Math.max(...sources.map((s) => s.prefix.length), 6);
+  const maxTypeLen = Math.max(...sources.map((s) => s.type.length), 4);
+  const namePad = "Name".padEnd(maxNameLen);
+  const prefixPad = "Prefix".padEnd(maxPrefixLen);
+  const typePad = "Type".padEnd(maxTypeLen);
+  lines.push(`  ${namePad}  ${prefixPad}  ${typePad}`);
+  lines.push(`  ${"\u2500".repeat(maxNameLen)}  ${"\u2500".repeat(maxPrefixLen)}  ${"\u2500".repeat(maxTypeLen)}`);
+  for (const source of sources) {
+    const name = source.name.padEnd(maxNameLen);
+    const prefix = source.prefix.padEnd(maxPrefixLen);
+    const type = source.type.padEnd(maxTypeLen);
+    lines.push(`  ${name}  ${prefix}  ${type}`);
+  }
+  return lines.join("\n");
+}
+function formatJsonSourceList(sources) {
+  const output = sources.map((s) => ({
+    name: s.name,
+    type: s.type,
+    prefix: s.prefix,
+    ...s.url ? { url: s.url } : {},
+    ...s.path ? { path: s.path } : {}
+  }));
+  return JSON.stringify(output, null, 2);
+}
+function formatIconSourceList(sources, format) {
+  switch (format) {
+    case "json":
+      return formatJsonSourceList(sources);
+    case "table":
+    default:
+      return formatTableSourceList(sources);
+  }
+}
+function formatTableAliases(aliases) {
+  const entries = Object.entries(aliases);
+  if (entries.length === 0) {
+    return "No aliases defined.";
+  }
+  const lines = ["Icon Aliases:", ""];
+  const maxAliasLen = Math.max(...entries.map(([a]) => a.length), 5);
+  const maxTargetLen = Math.max(...entries.map(([, t]) => t.length), 6);
+  const aliasPad = "Alias".padEnd(maxAliasLen);
+  const targetPad = "Target".padEnd(maxTargetLen);
+  lines.push(`  ${aliasPad}  ${targetPad}`);
+  lines.push(`  ${"\u2500".repeat(maxAliasLen)}  ${"\u2500".repeat(maxTargetLen)}`);
+  entries.sort((a, b) => a[0].localeCompare(b[0]));
+  for (const [alias, target] of entries) {
+    const aliasStr = alias.padEnd(maxAliasLen);
+    lines.push(`  ${aliasStr}  ${target}`);
+  }
+  return lines.join("\n");
+}
+function formatJsonAliases(aliases) {
+  return JSON.stringify(aliases, null, 2);
+}
+function formatAliasesList(aliases, format) {
+  switch (format) {
+    case "json":
+      return formatJsonAliases(aliases);
+    case "table":
+    default:
+      return formatTableAliases(aliases);
+  }
+}
+function formatTableSearchResults(results) {
+  const lines = [`Search results for "${results.query}"`, ""];
+  const hasResults = results.aliases.length > 0 || results.sources.length > 0;
+  if (!hasResults) {
+    lines.push("No results found.");
+    return lines.join("\n");
+  }
+  if (results.aliases.length > 0) {
+    lines.push("Aliases:");
+    for (const { alias, target } of results.aliases) {
+      lines.push(`  ${alias} \u2192 ${target}`);
+    }
+    lines.push("");
+  }
+  if (results.sources.length > 0) {
+    lines.push("Sources:");
+    for (const source of results.sources) {
+      lines.push(`  ${source.name} (${source.prefix}:) [${source.type}]`);
+    }
+  }
+  return lines.join("\n").trim();
+}
+function formatJsonSearchResults(results) {
+  return JSON.stringify(results, null, 2);
+}
+function formatSearchResults(results, format) {
+  switch (format) {
+    case "json":
+      return formatJsonSearchResults(results);
+    case "table":
+    default:
+      return formatTableSearchResults(results);
+  }
+}
+async function loadRegistry(configPath) {
+  const configLoader = new ConfigLoader();
+  if (!configPath) {
+    configPath = await configLoader.findConfig(process.cwd());
+  }
+  const config = await configLoader.load(configPath);
+  const registry = new IconRegistryLoader();
+  if (config.icons?.registry) {
+    await registry.load(config.icons.registry);
+  }
+  return registry;
+}
+function searchIcons(registry, query) {
+  const lowerQuery = query.toLowerCase();
+  const aliases = Object.entries(registry.getAliases()).filter(
+    ([alias, target]) => alias.toLowerCase().includes(lowerQuery) || target.toLowerCase().includes(lowerQuery)
+  ).map(([alias, target]) => ({ alias, target }));
+  const sources = registry.getSources().filter(
+    (source) => source.name.toLowerCase().includes(lowerQuery) || source.prefix.toLowerCase().includes(lowerQuery)
+  ).map((s) => ({ name: s.name, prefix: s.prefix, type: s.type }));
+  return { query, aliases, sources };
+}
+function createListCommand2() {
+  return new Command4("list").description("List icon sources and aliases").option("--source <name>", "Filter by source name").option("--aliases", "Show only aliases").option("--format <fmt>", "Output format (table/json)", "table").option("-c, --config <path>", "Config file path").action(async (options) => {
+    try {
+      const registry = await loadRegistry(options.config);
+      if (!registry.isLoaded()) {
+        console.log("No icon registry found.");
+        return;
+      }
+      const format = options.format ?? "table";
+      if (options.aliases) {
+        const aliases = registry.getAliases();
+        const output2 = formatAliasesList(aliases, format);
+        console.log(output2);
+        return;
+      }
+      if (options.source) {
+        const sources2 = registry.getSources().filter(
+          (s) => s.name === options.source || s.prefix === options.source
+        );
+        if (sources2.length === 0) {
+          console.error(chalk4.yellow(`No source found matching "${options.source}"`));
+          return;
+        }
+        const output2 = formatIconSourceList(sources2, format);
+        console.log(output2);
+        return;
+      }
+      const sources = registry.getSources();
+      const output = formatIconSourceList(sources, format);
+      console.log(output);
+    } catch (error) {
+      console.error(
+        chalk4.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+      );
+      process.exitCode = ExitCode.GeneralError;
+    }
+  });
+}
+function createSearchCommand() {
+  return new Command4("search").description("Search for icons by name or keyword").argument("<query>", "Search query").option("--format <fmt>", "Output format (table/json)", "table").option("-c, --config <path>", "Config file path").action(async (query, options) => {
+    try {
+      const registry = await loadRegistry(options.config);
+      if (!registry.isLoaded()) {
+        console.log("No icon registry found.");
+        return;
+      }
+      const format = options.format ?? "table";
+      const results = searchIcons(registry, query);
+      const output = formatSearchResults(results, format);
+      console.log(output);
+    } catch (error) {
+      console.error(
+        chalk4.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+      );
+      process.exitCode = ExitCode.GeneralError;
+    }
+  });
+}
+function createPreviewCommand() {
+  return new Command4("preview").description("Preview an icon").argument("<name>", "Icon name or alias").option("--format <fmt>", "Output format (svg/html)", "html").option("--size <size>", "Icon size", "24px").option("--color <color>", "Icon color", "currentColor").option("-c, --config <path>", "Config file path").action(async (name, options) => {
+    try {
+      const registry = await loadRegistry(options.config);
+      if (!registry.isLoaded()) {
+        console.error(chalk4.red("Error: No icon registry found"));
+        process.exitCode = ExitCode.GeneralError;
+        return;
+      }
+      const resolver = new IconResolver(registry);
+      const iconOptions = {};
+      if (options.size) {
+        iconOptions.size = options.size;
+      }
+      if (options.color) {
+        iconOptions.color = options.color;
+      }
+      const rendered = await resolver.render(name, iconOptions);
+      if (options.format === "svg") {
+        console.log(rendered);
+      } else {
+        const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Icon Preview: ${name}</title>
+  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+  <style>
+    body {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      font-family: system-ui, sans-serif;
+      background: #f5f5f5;
+    }
+    .preview {
+      padding: 2rem;
+      background: white;
+      border-radius: 8px;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+      text-align: center;
+    }
+    .icon-container {
+      margin-bottom: 1rem;
+    }
+    .icon-name {
+      color: #666;
+      font-size: 14px;
+    }
+    .material-icons {
+      font-family: 'Material Icons';
+      font-weight: normal;
+      font-style: normal;
+      display: inline-block;
+      line-height: 1;
+      text-transform: none;
+      letter-spacing: normal;
+      word-wrap: normal;
+      white-space: nowrap;
+      direction: ltr;
+      -webkit-font-smoothing: antialiased;
+    }
+  </style>
+</head>
+<body>
+  <div class="preview">
+    <div class="icon-container">
+      ${rendered}
+    </div>
+    <div class="icon-name">${name}</div>
+  </div>
+</body>
+</html>`;
+        console.log(html);
+      }
+    } catch (error) {
+      console.error(
+        chalk4.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+      );
+      process.exitCode = ExitCode.GeneralError;
+    }
+  });
+}
+function createIconsCommand() {
+  const cmd = new Command4("icons").description("Manage and search icons");
+  cmd.addCommand(createListCommand2());
+  cmd.addCommand(createSearchCommand());
+  cmd.addCommand(createPreviewCommand());
+  return cmd;
+}
+
+// src/cli/commands/init.ts
+import { Command as Command5 } from "commander";
+import { mkdir, writeFile as writeFile2, access as access4, readdir as readdir2 } from "fs/promises";
+import { join as join5, resolve } from "path";
+import chalk5 from "chalk";
+import ora3 from "ora";
+function createInitCommand() {
+  return new Command5("init").description("Initialize a new project").argument("[directory]", "Target directory", ".").option("--template <name>", "Initial template").option("--no-examples", "Do not create sample files").action(async (directory, options) => {
+    await executeInit(directory, options);
+  });
+}
+async function executeInit(directory, options) {
+  const spinner = ora3();
+  const targetDir = resolve(directory);
+  const includeExamples = options.examples !== false;
+  try {
+    spinner.start(`Initializing project in ${targetDir}...`);
+    try {
+      await access4(targetDir);
+      const entries = await readdir2(targetDir);
+      if (entries.length > 0) {
+        spinner.info(`Directory ${targetDir} already exists, adding files...`);
+      }
+    } catch {
+    }
+    await mkdir(targetDir, { recursive: true });
+    await mkdir(join5(targetDir, "themes"), { recursive: true });
+    await mkdir(join5(targetDir, "icons", "custom"), { recursive: true });
+    const configContent = generateConfigContent();
+    await writeFileIfNotExists(join5(targetDir, "config.yaml"), configContent);
+    const customCssContent = generateCustomCssContent();
+    await writeFileIfNotExists(join5(targetDir, "themes", "custom.css"), customCssContent);
+    if (includeExamples) {
+      const presentationContent = generatePresentationContent(options.template);
+      await writeFileIfNotExists(join5(targetDir, "presentation.yaml"), presentationContent);
+    }
+    spinner.succeed(`Project initialized in ${targetDir}`);
+    console.log("");
+    console.log(chalk5.green("Created files:"));
+    console.log(`  ${chalk5.cyan("config.yaml")} - Project configuration`);
+    console.log(`  ${chalk5.cyan("themes/custom.css")} - Custom theme styles`);
+    console.log(`  ${chalk5.cyan("icons/custom/")} - Custom icons directory`);
+    if (includeExamples) {
+      console.log(`  ${chalk5.cyan("presentation.yaml")} - Sample presentation`);
+    }
+    console.log("");
+    console.log(chalk5.blue("Next steps:"));
+    console.log(`  1. Edit ${chalk5.yellow("presentation.yaml")} to add your slides`);
+    console.log(`  2. Run ${chalk5.yellow("slide-gen convert presentation.yaml")} to generate markdown`);
+  } catch (error) {
+    spinner.fail("Failed to initialize project");
+    console.error(
+      chalk5.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+    );
+    process.exitCode = ExitCode.GeneralError;
+  }
+}
+async function writeFileIfNotExists(filePath, content) {
+  try {
+    await access4(filePath);
+  } catch {
+    await writeFile2(filePath, content, "utf-8");
+  }
+}
+function generateConfigContent() {
+  return `# slide-gen configuration
+# See https://github.com/example/slide-generation for documentation
+
+templates:
+  # Path to built-in templates (relative to project root)
+  builtin: ./templates
+  # Path to custom templates (optional)
+  # custom: ./my-templates
+
+icons:
+  # Path to icon registry file
+  registry: ./icons/registry.yaml
+  cache:
+    enabled: true
+    directory: .cache/icons
+    ttl: 86400
+
+references:
+  enabled: true
+  connection:
+    type: cli
+    command: ref
+  format:
+    locale: ja-JP
+
+output:
+  theme: default
+  inlineStyles: false
+`;
+}
+function generateCustomCssContent() {
+  return `/* Custom Marp theme styles */
+/* See https://marpit.marp.app/theme-css for documentation */
+
+/*
+section {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: #fff;
+}
+
+h1 {
+  color: #fff;
+  text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+}
+*/
+`;
+}
+function generatePresentationContent(_template) {
+  const baseContent = `# Sample Presentation
+# Generated by slide-gen init
+
+meta:
+  title: My Presentation
+  author: Your Name
+  date: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"
+  theme: default
+
+slides:
+  - template: title
+    content:
+      title: My Presentation
+      subtitle: A sample slide deck
+      author: Your Name
+
+  - template: content
+    content:
+      title: Introduction
+      body: |
+        Welcome to this presentation!
+
+        - Point one
+        - Point two
+        - Point three
+
+  - template: section
+    content:
+      title: Section Title
+      subtitle: Section description
+
+  - template: content
+    content:
+      title: Main Content
+      body: |
+        Here's the main content of your presentation.
+
+        You can use **markdown** formatting in the body text.
+
+  - template: end
+    content:
+      title: Thank You
+      subtitle: Questions?
+`;
+  return baseContent;
+}
+
+// src/cli/commands/watch.ts
+import { Command as Command6 } from "commander";
+import { access as access5 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, join as join6 } from "path";
+import chalk6 from "chalk";
+import { watch as chokidarWatch } from "chokidar";
+var WatchState = class {
+  _isRunning = false;
+  _conversionCount = 0;
+  _lastError = null;
+  get isRunning() {
+    return this._isRunning;
+  }
+  get conversionCount() {
+    return this._conversionCount;
+  }
+  get lastError() {
+    return this._lastError;
+  }
+  start() {
+    this._isRunning = true;
+  }
+  stop() {
+    this._isRunning = false;
+  }
+  incrementConversion() {
+    this._conversionCount++;
+  }
+  setError(error) {
+    this._lastError = error;
+  }
+  clearError() {
+    this._lastError = null;
+  }
+};
+function getDefaultOutputPath2(inputPath) {
+  const dir = dirname3(inputPath);
+  const base = basename2(inputPath, ".yaml");
+  return join6(dir, `${base}.md`);
+}
+function formatTime() {
+  const now = /* @__PURE__ */ new Date();
+  return `[${now.toLocaleTimeString("en-GB")}]`;
+}
+function createWatchCommand() {
+  return new Command6("watch").description("Watch source file and auto-convert on changes").argument("<input>", "Input YAML file to watch").option("-o, --output <path>", "Output file path").option("-c, --config <path>", "Config file path").option("--debounce <ms>", "Debounce delay in milliseconds", "300").option("-v, --verbose", "Verbose output").action(async (input, options) => {
+    await executeWatch(input, options);
+  });
+}
+async function runConversion(inputPath, outputPath, pipeline, verbose) {
+  try {
+    const result = await pipeline.runWithResult(inputPath, { outputPath });
+    console.log(
+      `${formatTime()} ${chalk6.green("\u2713")} Output: ${chalk6.cyan(outputPath)}`
+    );
+    if (verbose) {
+      console.log(`  Parsed ${result.slideCount} slides`);
+      if (result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+          console.log(chalk6.yellow(`  \u26A0 ${warning}`));
+        }
+      }
+    }
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof PipelineError ? `${error.stage}: ${error.message}` : error instanceof Error ? error.message : "Unknown error";
+    console.log(
+      `${formatTime()} ${chalk6.red("\u2717")} Conversion failed: ${message}`
+    );
+    return { success: false, error: message };
+  }
+}
+async function executeWatch(inputPath, options) {
+  const state = new WatchState();
+  const errors = [];
+  const debounceMs = Number(options.debounce) || 300;
+  const verbose = options.verbose ?? false;
+  if (options.signal?.aborted) {
+    try {
+      await access5(inputPath);
+    } catch {
+      errors.push(`File not found: ${inputPath}`);
+      return { success: false, conversionCount: 0, errors };
+    }
+    return { success: true, conversionCount: 0, errors };
+  }
+  try {
+    await access5(inputPath);
+  } catch {
+    console.error(chalk6.red(`Error: File not found: ${inputPath}`));
+    errors.push(`File not found: ${inputPath}`);
+    process.exitCode = ExitCode.FileReadError;
+    return { success: false, conversionCount: 0, errors };
+  }
+  const outputPath = options.output ?? getDefaultOutputPath2(inputPath);
+  const configLoader = new ConfigLoader();
+  let configPath = options.config;
+  if (!configPath) {
+    configPath = await configLoader.findConfig(dirname3(inputPath));
+  }
+  const config = await configLoader.load(configPath);
+  const pipeline = new Pipeline(config);
+  try {
+    await pipeline.initialize();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown initialization error";
+    console.error(chalk6.red(`Error: Failed to initialize pipeline: ${message}`));
+    errors.push(message);
+    process.exitCode = ExitCode.ConversionError;
+    return { success: false, conversionCount: 0, errors };
+  }
+  console.log(`Watching ${chalk6.cyan(inputPath)}...`);
+  console.log(`Output: ${chalk6.cyan(outputPath)}`);
+  console.log("");
+  console.log(`${formatTime()} Initial conversion...`);
+  const initialResult = await runConversion(inputPath, outputPath, pipeline, verbose);
+  if (initialResult.success) {
+    state.incrementConversion();
+  } else if (initialResult.error) {
+    errors.push(initialResult.error);
+  }
+  let debounceTimer = null;
+  let watcher = null;
+  const handleChange = () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(async () => {
+      console.log(`${formatTime()} Changed: ${inputPath}`);
+      console.log(`${formatTime()} Converting...`);
+      const result = await runConversion(inputPath, outputPath, pipeline, verbose);
+      if (result.success) {
+        state.incrementConversion();
+        state.clearError();
+      } else if (result.error) {
+        errors.push(result.error);
+        state.setError(new Error(result.error));
+      }
+    }, debounceMs);
+  };
+  state.start();
+  watcher = chokidarWatch(inputPath, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50
+    }
+  });
+  watcher.on("change", handleChange);
+  const cleanup = () => {
+    state.stop();
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    watcher?.close();
+  };
+  if (options.signal) {
+    options.signal.addEventListener("abort", cleanup);
+  }
+  const signalHandler = () => {
+    console.log("\n" + chalk6.yellow("Watch stopped."));
+    cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", signalHandler);
+  process.on("SIGTERM", signalHandler);
+  await new Promise((resolve2) => {
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => resolve2());
+    }
+  });
+  return {
+    success: errors.length === 0,
+    conversionCount: state.conversionCount,
+    errors
+  };
+}
+
+// src/cli/commands/preview.ts
+import { Command as Command7 } from "commander";
+import { access as access6, unlink } from "fs/promises";
+import { basename as basename3, dirname as dirname4, join as join7 } from "path";
+import { tmpdir } from "os";
+import { spawn, execSync } from "child_process";
+import chalk7 from "chalk";
+import { watch as chokidarWatch2 } from "chokidar";
+async function checkMarpCliAvailable() {
+  try {
+    execSync("npx marp --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getTempOutputPath(inputPath) {
+  const base = basename3(inputPath, ".yaml");
+  return join7(tmpdir(), `slide-gen-preview-${base}-${Date.now()}.md`);
+}
+function buildMarpCommand(markdownPath, options) {
+  const parts = ["npx", "marp", "--preview"];
+  if (options.port) {
+    parts.push("-p", String(options.port));
+  }
+  if (options.watch) {
+    parts.push("--watch");
+  }
+  parts.push(markdownPath);
+  return parts.join(" ");
+}
+function createPreviewCommand2() {
+  return new Command7("preview").description("Preview the generated slides in browser (requires Marp CLI)").argument("<input>", "Input YAML file").option("-p, --port <number>", "Preview server port", "8080").option("-w, --watch", "Watch for changes and auto-reload").option("-c, --config <path>", "Config file path").option("-v, --verbose", "Verbose output").action(async (input, options) => {
+    await executePreview(input, options);
+  });
+}
+async function executePreview(inputPath, options) {
+  const errors = [];
+  const verbose = options.verbose ?? false;
+  const port = Number(options.port) || 8080;
+  if (options.signal?.aborted) {
+    try {
+      await access6(inputPath);
+    } catch {
+      errors.push(`File not found: ${inputPath}`);
+      return { success: false, errors };
+    }
+    return { success: true, errors };
+  }
+  try {
+    await access6(inputPath);
+  } catch {
+    console.error(chalk7.red(`Error: File not found: ${inputPath}`));
+    errors.push(`File not found: ${inputPath}`);
+    process.exitCode = ExitCode.FileReadError;
+    return { success: false, errors };
+  }
+  console.log("Checking for Marp CLI...");
+  const marpAvailable = await checkMarpCliAvailable();
+  if (!marpAvailable) {
+    console.error(
+      chalk7.red(
+        "Error: Marp CLI not found. Install it with: npm install -g @marp-team/marp-cli"
+      )
+    );
+    errors.push("Marp CLI not available");
+    process.exitCode = ExitCode.GeneralError;
+    return { success: false, errors };
+  }
+  console.log(chalk7.green("\u2713") + " Marp CLI found");
+  const configLoader = new ConfigLoader();
+  let configPath = options.config;
+  if (!configPath) {
+    configPath = await configLoader.findConfig(dirname4(inputPath));
+  }
+  const config = await configLoader.load(configPath);
+  console.log("Initializing pipeline...");
+  const pipeline = new Pipeline(config);
+  try {
+    await pipeline.initialize();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown initialization error";
+    console.error(chalk7.red(`Error: Failed to initialize pipeline: ${message}`));
+    errors.push(message);
+    process.exitCode = ExitCode.ConversionError;
+    return { success: false, errors };
+  }
+  const tempMarkdownPath = getTempOutputPath(inputPath);
+  console.log(`Converting ${chalk7.cyan(inputPath)}...`);
+  try {
+    await pipeline.runWithResult(inputPath, { outputPath: tempMarkdownPath });
+    console.log(chalk7.green("\u2713") + " Initial conversion complete");
+  } catch (error) {
+    const message = error instanceof PipelineError ? `${error.stage}: ${error.message}` : error instanceof Error ? error.message : "Unknown error";
+    console.error(chalk7.red(`Error: Conversion failed: ${message}`));
+    errors.push(message);
+    process.exitCode = ExitCode.ConversionError;
+    return { success: false, errors };
+  }
+  console.log(`
+Starting preview server on port ${chalk7.cyan(port)}...`);
+  const marpCommand = buildMarpCommand(tempMarkdownPath, {
+    ...options,
+    port,
+    watch: false
+    // We handle watch ourselves if needed
+  });
+  if (verbose) {
+    console.log(`Running: ${marpCommand}`);
+  }
+  const marpProcess = spawn("npx", ["marp", "--preview", "-p", String(port), tempMarkdownPath], {
+    stdio: "inherit",
+    shell: true
+  });
+  let watcher = null;
+  let debounceTimer = null;
+  if (options.watch) {
+    console.log(`
+Watching ${chalk7.cyan(inputPath)} for changes...`);
+    watcher = chokidarWatch2(inputPath, {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    watcher.on("change", () => {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(async () => {
+        console.log(`
+[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB")}] File changed, reconverting...`);
+        try {
+          await pipeline.runWithResult(inputPath, { outputPath: tempMarkdownPath });
+          console.log(chalk7.green("\u2713") + " Reconversion complete");
+        } catch (error) {
+          const message = error instanceof PipelineError ? `${error.stage}: ${error.message}` : error instanceof Error ? error.message : "Unknown error";
+          console.error(chalk7.red(`\u2717 Reconversion failed: ${message}`));
+        }
+      }, 300);
+    });
+  }
+  const cleanup = async () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    watcher?.close();
+    marpProcess.kill();
+    try {
+      await unlink(tempMarkdownPath);
+    } catch {
+    }
+  };
+  if (options.signal) {
+    options.signal.addEventListener("abort", () => {
+      cleanup();
+    });
+  }
+  const signalHandler = async () => {
+    console.log("\n" + chalk7.yellow("Preview stopped."));
+    await cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", signalHandler);
+  process.on("SIGTERM", signalHandler);
+  await new Promise((resolve2) => {
+    marpProcess.on("exit", () => {
+      cleanup();
+      resolve2();
+    });
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => resolve2());
+    }
+  });
+  return {
+    success: errors.length === 0,
+    errors
+  };
+}
+
+// src/cli/index.ts
+var program = new Command8();
+program.name("slide-gen").description("Generate Marp-compatible Markdown from YAML source files").version(VERSION);
+program.addCommand(createConvertCommand());
+program.addCommand(createValidateCommand());
+program.addCommand(createTemplatesCommand());
+program.addCommand(createIconsCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createWatchCommand());
+program.addCommand(createPreviewCommand2());
+program.parse();
+//# sourceMappingURL=index.js.map