@oxog/npm-llms 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3589 @@
+'use strict';
+
+var crypto = require('crypto');
+var path = require('path');
+var os = require('os');
+var promises = require('fs/promises');
+var fs = require('fs');
+var zlib = require('zlib');
+
+// src/errors.ts
+var NpmLlmsError = class extends Error {
+  /**
+   * Create a new NpmLlmsError
+   * @param message - Error message
+   * @param code - Error code
+   * @param details - Additional error details
+   */
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "NpmLlmsError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Convert error to JSON
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details
+    };
+  }
+};
+var PackageNotFoundError = class extends NpmLlmsError {
+  constructor(packageName) {
+    super(`Package "${packageName}" not found on npm`, "PACKAGE_NOT_FOUND", { packageName });
+    this.name = "PackageNotFoundError";
+  }
+};
+var VersionNotFoundError = class extends NpmLlmsError {
+  constructor(packageName, version) {
+    super(`Version "${version}" not found for package "${packageName}"`, "VERSION_NOT_FOUND", {
+      packageName,
+      version
+    });
+    this.name = "VersionNotFoundError";
+  }
+};
+var DownloadError = class extends NpmLlmsError {
+  constructor(message, url) {
+    super(message, "DOWNLOAD_FAILED", { url });
+    this.name = "DownloadError";
+  }
+};
+var ParseError = class extends NpmLlmsError {
+  constructor(message, file, position) {
+    super(message, "PARSE_ERROR", { file, position });
+    this.name = "ParseError";
+  }
+};
+var AIError = class extends NpmLlmsError {
+  constructor(message, provider) {
+    super(message, "AI_ERROR", { provider });
+    this.name = "AIError";
+  }
+};
+var PluginError = class extends NpmLlmsError {
+  constructor(message, pluginName) {
+    super(message, "PLUGIN_ERROR", { pluginName });
+    this.name = "PluginError";
+  }
+};
+var CacheError = class extends NpmLlmsError {
+  constructor(message) {
+    super(message, "CACHE_ERROR");
+    this.name = "CacheError";
+  }
+};
+var ConfigError = class extends NpmLlmsError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+};
+var TarError = class extends NpmLlmsError {
+  constructor(message, offset) {
+    super(message, "TAR_ERROR", { offset });
+    this.name = "TarError";
+  }
+};
+var TimeoutError = class extends NpmLlmsError {
+  constructor(message, timeout) {
+    super(message, "TIMEOUT_ERROR", { timeout });
+    this.name = "TimeoutError";
+  }
+};
+var ValidationError = class extends NpmLlmsError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR", { field });
+    this.name = "ValidationError";
+  }
+};
+function isNpmLlmsError(error) {
+  return error instanceof NpmLlmsError;
+}
+function getErrorCode(error) {
+  if (isNpmLlmsError(error)) {
+    return error.code;
+  }
+  return "UNKNOWN_ERROR";
+}
+function wrapError(error, code = "UNKNOWN_ERROR") {
+  if (isNpmLlmsError(error)) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new NpmLlmsError(message, code, {
+    originalError: error instanceof Error ? error.name : typeof error
+  });
+}
+
+// src/kernel.ts
+function createKernel() {
+  const plugins = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const handlerToPlugin = /* @__PURE__ */ new Map();
+  function handlePluginError(error, pluginName) {
+    const plugin = pluginName ? plugins.get(pluginName) : void 0;
+    if (plugin?.onError) {
+      try {
+        plugin.onError(error);
+      } catch {
+      }
+    }
+  }
+  function use(plugin) {
+    if (!plugin.name) {
+      throw new PluginError("Plugin must have a name");
+    }
+    if (plugins.has(plugin.name)) {
+      throw new PluginError(`Plugin "${plugin.name}" is already registered`, plugin.name);
+    }
+    if (plugin.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (!plugins.has(dep)) {
+          throw new PluginError(
+            `Plugin "${plugin.name}" depends on "${dep}" which is not registered`,
+            plugin.name
+          );
+        }
+      }
+    }
+    try {
+      plugin.install(kernel);
+      plugins.set(plugin.name, plugin);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      throw new PluginError(
+        `Failed to install plugin "${plugin.name}": ${err.message}`,
+        plugin.name
+      );
+    }
+    return kernel;
+  }
+  function unregister(name) {
+    const plugin = plugins.get(name);
+    if (!plugin) {
+      return false;
+    }
+    for (const [, p] of plugins) {
+      if (p.dependencies?.includes(name)) {
+        throw new PluginError(
+          `Cannot unregister "${name}": plugin "${p.name}" depends on it`,
+          name
+        );
+      }
+    }
+    for (const [event, handlers] of eventHandlers) {
+      const toRemove = [];
+      for (const entry of handlers) {
+        if (entry.pluginName === name) {
+          toRemove.push(entry);
+          handlerToPlugin.delete(entry.handler);
+        }
+      }
+      for (const entry of toRemove) {
+        handlers.delete(entry);
+      }
+      if (handlers.size === 0) {
+        eventHandlers.delete(event);
+      }
+    }
+    try {
+      plugin.onDestroy?.();
+    } catch {
+    }
+    plugins.delete(name);
+    return true;
+  }
+  function on(event, handler) {
+    if (!eventHandlers.has(event)) {
+      eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    const pluginName = getCurrentPluginContext() ?? "unknown";
+    const entry = { handler, pluginName };
+    eventHandlers.get(event).add(entry);
+    handlerToPlugin.set(handler, pluginName);
+  }
+  function off(event, handler) {
+    const handlers = eventHandlers.get(event);
+    if (!handlers) return;
+    for (const entry of handlers) {
+      if (entry.handler === handler) {
+        handlers.delete(entry);
+        handlerToPlugin.delete(handler);
+        break;
+      }
+    }
+    if (handlers.size === 0) {
+      eventHandlers.delete(event);
+    }
+  }
+  async function emit(event, context, ...args) {
+    const handlers = eventHandlers.get(event);
+    if (!handlers || handlers.size === 0) return;
+    for (const entry of handlers) {
+      try {
+        await entry.handler(context, ...args);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        handlePluginError(err, entry.pluginName);
+      }
+    }
+  }
+  function listPlugins() {
+    return Array.from(plugins.values()).map((p) => ({
+      name: p.name,
+      version: p.version,
+      category: p.category,
+      dependencies: p.dependencies ?? []
+    }));
+  }
+  function getPlugin(name) {
+    return plugins.get(name);
+  }
+  function hasPlugin(name) {
+    return plugins.has(name);
+  }
+  async function destroy() {
+    const pluginNames = Array.from(plugins.keys()).reverse();
+    for (const name of pluginNames) {
+      const plugin = plugins.get(name);
+      if (plugin?.onDestroy) {
+        try {
+          await plugin.onDestroy();
+        } catch {
+        }
+      }
+    }
+    plugins.clear();
+    eventHandlers.clear();
+    handlerToPlugin.clear();
+  }
+  let currentPluginContext = null;
+  function getCurrentPluginContext() {
+    return currentPluginContext;
+  }
+  const originalUse = use;
+  function wrappedUse(plugin) {
+    currentPluginContext = plugin.name;
+    try {
+      originalUse(plugin);
+      return kernel;
+    } finally {
+      currentPluginContext = null;
+    }
+  }
+  const kernel = {
+    use: wrappedUse,
+    unregister,
+    on,
+    off,
+    emit,
+    listPlugins,
+    getPlugin,
+    hasPlugin,
+    destroy
+  };
+  return kernel;
+}
+function definePlugin(definition) {
+  return definition;
+}
+function composePlugins(name, plugins) {
+  return {
+    name,
+    version: "1.0.0",
+    category: "utility",
+    dependencies: plugins.flatMap((p) => p.dependencies ?? []),
+    install(kernel) {
+      for (const plugin of plugins) {
+        kernel.use(plugin);
+      }
+    },
+    async onDestroy() {
+    }
+  };
+}
+async function exists(path) {
+  try {
+    await promises.access(path, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  try {
+    await promises.mkdir(dirPath, { recursive: true });
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function readJsonFile(filePath) {
+  const content = await promises.readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function writeTextFile(filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await promises.writeFile(filePath, content, "utf-8");
+}
+async function writeJsonFile(filePath, data, pretty = true) {
+  const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  await writeTextFile(filePath, content);
+}
+async function deleteFile(filePath) {
+  try {
+    await promises.unlink(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function deleteDir(dirPath) {
+  try {
+    await promises.rm(dirPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function listFiles(dirPath, recursive = false) {
+  const files = [];
+  async function scanDir(currentPath, prefix = "") {
+    const entries = await promises.readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isFile()) {
+        files.push(relativePath);
+      } else if (entry.isDirectory() && recursive) {
+        await scanDir(path.join(currentPath, entry.name), relativePath);
+      }
+    }
+  }
+  try {
+    await scanDir(dirPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  return files;
+}
+async function getDirSize(dirPath) {
+  let totalSize = 0;
+  async function scanDir(currentPath) {
+    try {
+      const entries = await promises.readdir(currentPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        if (entry.isFile()) {
+          const stats = await promises.stat(fullPath);
+          totalSize += stats.size;
+        } else if (entry.isDirectory()) {
+          await scanDir(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  await scanDir(dirPath);
+  return totalSize;
+}
+
+// src/core/cache.ts
+var DEFAULT_CACHE_DIR = ".npm-llms-cache";
+var DEFAULT_TTL = 7 * 24 * 60 * 60 * 1e3;
+var CACHE_VERSION = 1;
+var FileCache = class {
+  dir;
+  defaultTtl;
+  /**
+   * Create a new FileCache
+   * @param dir - Cache directory path
+   * @param defaultTtl - Default TTL in milliseconds
+   */
+  constructor(dir, defaultTtl = DEFAULT_TTL) {
+    this.dir = dir ?? path.join(os.tmpdir(), DEFAULT_CACHE_DIR);
+    this.defaultTtl = defaultTtl;
+  }
+  /**
+   * Generate a cache key hash
+   * @param input - Input string
+   * @returns Hashed key
+   */
+  getKey(input) {
+    return crypto.createHash("sha256").update(input).digest("hex").slice(0, 16);
+  }
+  /**
+   * Get file path for a cache key
+   * @param key - Cache key
+   * @returns File path
+   */
+  getPath(key) {
+    const hash = this.getKey(key);
+    return path.join(this.dir, hash.slice(0, 2), `${hash}.json`);
+  }
+  /**
+   * Get cached data
+   * @param key - Cache key
+   * @returns Cached data or null if not found/expired
+   */
+  async get(key) {
+    const path = this.getPath(key);
+    try {
+      if (!await exists(path)) {
+        return null;
+      }
+      const entry = await readJsonFile(path);
+      if (entry.version !== CACHE_VERSION) {
+        await this.delete(key);
+        return null;
+      }
+      const age = Date.now() - entry.timestamp;
+      if (age > entry.ttl) {
+        await this.delete(key);
+        return null;
+      }
+      return entry.data;
+    } catch {
+      await this.delete(key).catch(() => {
+      });
+      return null;
+    }
+  }
+  /**
+   * Set cached data
+   * @param key - Cache key
+   * @param data - Data to cache
+   * @param ttl - Optional TTL override
+   */
+  async set(key, data, ttl) {
+    const path = this.getPath(key);
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      ttl: ttl ?? this.defaultTtl,
+      key,
+      version: CACHE_VERSION
+    };
+    try {
+      await writeJsonFile(path, entry, false);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CacheError(`Failed to write cache: ${message}`);
+    }
+  }
+  /**
+   * Delete a cached entry
+   * @param key - Cache key
+   * @returns True if deleted, false if not found
+   */
+  async delete(key) {
+    const path = this.getPath(key);
+    return deleteFile(path);
+  }
+  /**
+   * Check if a key is cached and not expired
+   * @param key - Cache key
+   * @returns True if cached and valid
+   */
+  async has(key) {
+    const data = await this.get(key);
+    return data !== null;
+  }
+  /**
+   * Clear all cached data
+   */
+  async clear() {
+    try {
+      await deleteDir(this.dir);
+      await ensureDir(this.dir);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CacheError(`Failed to clear cache: ${message}`);
+    }
+  }
+  /**
+   * Remove expired entries
+   * @returns Number of entries removed
+   */
+  async prune() {
+    let removed = 0;
+    try {
+      const files = await listFiles(this.dir, true);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const path$1 = path.join(this.dir, file);
+        try {
+          const entry = await readJsonFile(path$1);
+          const expired = entry.version !== CACHE_VERSION || Date.now() - entry.timestamp > entry.ttl;
+          if (expired) {
+            await deleteFile(path$1);
+            removed++;
+          }
+        } catch {
+          await deleteFile(path$1);
+          removed++;
+        }
+      }
+    } catch {
+    }
+    return removed;
+  }
+  /**
+   * Get cache statistics
+   * @returns Cache stats
+   */
+  async getStats() {
+    try {
+      if (!await exists(this.dir)) {
+        return { entries: 0, size: 0, dir: this.dir };
+      }
+      const files = await listFiles(this.dir, true);
+      const jsonFiles = files.filter((f) => f.endsWith(".json"));
+      const size = await getDirSize(this.dir);
+      return {
+        entries: jsonFiles.length,
+        size,
+        dir: this.dir
+      };
+    } catch {
+      return { entries: 0, size: 0, dir: this.dir };
+    }
+  }
+  /**
+   * Get cache directory path
+   */
+  getDir() {
+    return this.dir;
+  }
+  /**
+   * Get default TTL
+   */
+  getDefaultTtl() {
+    return this.defaultTtl;
+  }
+};
+function createCache(options) {
+  if (options?.enabled === false) {
+    return null;
+  }
+  const dir = options?.dir ?? path.join(process.cwd(), DEFAULT_CACHE_DIR);
+  const ttl = options?.ttl ?? DEFAULT_TTL;
+  return new FileCache(dir, ttl);
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function buildPackageCacheKey(name, version, type = "result") {
+  return `pkg:${name}@${version}:${type}`;
+}
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var DEFAULT_TIMEOUT = 3e4;
+function createTimeoutController(timeout) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  return {
+    controller,
+    cleanup: () => clearTimeout(timeoutId)
+  };
+}
+async function fetchJson(url, options = {}) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const { controller, cleanup } = createTimeoutController(timeout);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        ...options.headers
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new DownloadError(`HTTP ${response.status}: ${response.statusText}`, url);
+    }
+    const data = await response.json();
+    return {
+      data,
+      status: response.status,
+      headers: response.headers
+    };
+  } catch (error) {
+    if (error instanceof DownloadError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${timeout}ms`, timeout);
+      }
+      throw new DownloadError(error.message, url);
+    }
+    throw new DownloadError("Unknown fetch error", url);
+  } finally {
+    cleanup();
+  }
+}
+async function fetchBinary(url, options = {}) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const { controller, cleanup } = createTimeoutController(timeout);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/octet-stream",
+        ...options.headers
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new DownloadError(`HTTP ${response.status}: ${response.statusText}`, url);
+    }
+    const data = await response.arrayBuffer();
+    return {
+      data,
+      status: response.status,
+      headers: response.headers
+    };
+  } catch (error) {
+    if (error instanceof DownloadError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${timeout}ms`, timeout);
+      }
+      throw new DownloadError(error.message, url);
+    }
+    throw new DownloadError("Unknown fetch error", url);
+  } finally {
+    cleanup();
+  }
+}
+async function fetchGzipped(url, options = {}) {
+  const { data: gzipped } = await fetchBinary(url, options);
+  try {
+    return zlib.gunzipSync(Buffer.from(gzipped));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown decompression error";
+    throw new DownloadError(`Failed to decompress gzip: ${message}`, url);
+  }
+}
+function encodePackageName(name) {
+  if (name.startsWith("@")) {
+    const slashIndex = name.indexOf("/");
+    if (slashIndex === -1) {
+      return encodeURIComponent(name);
+    }
+    const scope = name.slice(0, slashIndex);
+    const pkg = name.slice(slashIndex + 1);
+    return `${scope}%2F${encodeURIComponent(pkg)}`;
+  }
+  return encodeURIComponent(name);
+}
+function buildPackageUrl(name, version, registry = DEFAULT_REGISTRY) {
+  const encodedName = encodePackageName(name);
+  const base = `${registry}/${encodedName}`;
+  return version ? `${base}/${version}` : base;
+}
+
+// src/utils/tar.ts
+var BLOCK_SIZE = 512;
+var TAR_TYPES = {
+  FILE: "0",
+  FILE_ALT: "",
+  GNU_LONGNAME: "L"};
+var decoder = new TextDecoder("utf-8");
+function isZeroBlock(buffer, offset) {
+  const end = Math.min(offset + BLOCK_SIZE, buffer.length);
+  for (let i = offset; i < end; i++) {
+    if (buffer[i] !== 0) return false;
+  }
+  return true;
+}
+function parseOctal(buffer, offset, length) {
+  const bytes = buffer.slice(offset, offset + length);
+  const str = decoder.decode(bytes).replace(/\0/g, "").trim();
+  if (!str) return 0;
+  return parseInt(str, 8) || 0;
+}
+function parseString(buffer, offset, length) {
+  const bytes = buffer.slice(offset, offset + length);
+  const str = decoder.decode(bytes);
+  const nullIndex = str.indexOf("\0");
+  return nullIndex >= 0 ? str.slice(0, nullIndex) : str;
+}
+function calculateChecksum(buffer, offset) {
+  let sum = 0;
+  for (let i = 0; i < BLOCK_SIZE; i++) {
+    if (i >= 148 && i < 156) {
+      sum += 32;
+    } else {
+      sum += buffer[offset + i] ?? 0;
+    }
+  }
+  return sum;
+}
+function parseTarHeader(buffer, offset) {
+  if (isZeroBlock(buffer, offset)) {
+    return null;
+  }
+  if (offset + BLOCK_SIZE > buffer.length) {
+    throw new TarError("Unexpected end of tar archive", offset);
+  }
+  const name = parseString(buffer, offset, 100);
+  const mode = parseOctal(buffer, offset + 100, 8);
+  const uid = parseOctal(buffer, offset + 108, 8);
+  const gid = parseOctal(buffer, offset + 116, 8);
+  const size = parseOctal(buffer, offset + 124, 12);
+  const mtime = parseOctal(buffer, offset + 136, 12);
+  const checksum = parseOctal(buffer, offset + 148, 8);
+  const type = parseString(buffer, offset + 156, 1);
+  const linkname = parseString(buffer, offset + 157, 100);
+  const calculatedChecksum = calculateChecksum(buffer, offset);
+  if (checksum !== 0 && checksum !== calculatedChecksum) {
+    throw new TarError(`Invalid tar header checksum: expected ${checksum}, got ${calculatedChecksum}`, offset);
+  }
+  const magic = parseString(buffer, offset + 257, 6);
+  let fullName = name;
+  if (magic === "ustar" || magic === "ustar ") {
+    const prefix = parseString(buffer, offset + 345, 155);
+    if (prefix) {
+      fullName = `${prefix}/${name}`;
+    }
+  }
+  return {
+    name: fullName,
+    mode,
+    uid,
+    gid,
+    size,
+    mtime,
+    checksum,
+    type,
+    linkname
+  };
+}
+function sanitizePath(path) {
+  let normalized = path.replace(/\\/g, "/");
+  if (normalized.startsWith("/")) {
+    normalized = normalized.slice(1);
+  }
+  const parts = normalized.split("/");
+  const safeParts = [];
+  for (const part of parts) {
+    if (part === "..") {
+      throw new TarError(`Path traversal detected: ${path}`);
+    }
+    if (part && part !== ".") {
+      safeParts.push(part);
+    }
+  }
+  return safeParts.join("/");
+}
+function removePackagePrefix(path) {
+  const prefixes = ["package/", "package\\"];
+  for (const prefix of prefixes) {
+    if (path.startsWith(prefix)) {
+      return path.slice(prefix.length);
+    }
+  }
+  return path;
+}
+function getEntryType(_type) {
+  return "file";
+}
+function shouldExtract(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".d.ts") || lower.endsWith(".d.mts") || lower.endsWith(".d.cts")) {
+    return true;
+  }
+  if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs") || lower.endsWith(".jsx")) {
+    return true;
+  }
+  if (lower.endsWith(".md") || lower.endsWith(".txt") || lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml")) {
+    return true;
+  }
+  const filename = path.split("/").pop() ?? "";
+  if (filename === "package.json" || filename === "README.md" || filename === "CHANGELOG.md" || filename === "LICENSE" || filename === "LICENSE.md") {
+    return true;
+  }
+  return false;
+}
+function* extractTarSync(buffer) {
+  const data = buffer instanceof Buffer ? new Uint8Array(buffer) : new Uint8Array(buffer);
+  let offset = 0;
+  let gnuLongName = null;
+  while (offset < data.length) {
+    const header = parseTarHeader(data, offset);
+    if (!header) {
+      break;
+    }
+    offset += BLOCK_SIZE;
+    if (header.type === TAR_TYPES.GNU_LONGNAME) {
+      const contentBytes = data.slice(offset, offset + header.size);
+      gnuLongName = decoder.decode(contentBytes).replace(/\0/g, "");
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    const entryName = gnuLongName ?? header.name;
+    gnuLongName = null;
+    if (header.type !== TAR_TYPES.FILE && header.type !== TAR_TYPES.FILE_ALT) {
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    let path;
+    try {
+      path = sanitizePath(entryName);
+      path = removePackagePrefix(path);
+    } catch {
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    if (!shouldExtract(path)) {
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    const content = data.slice(offset, offset + header.size);
+    const textContent = decoder.decode(content);
+    yield {
+      path,
+      content: textContent,
+      size: header.size,
+      type: getEntryType(header.type)
+    };
+    offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+  }
+}
+function extractTarToMap(buffer) {
+  const files = /* @__PURE__ */ new Map();
+  for (const entry of extractTarSync(buffer)) {
+    if (entry.type === "file") {
+      files.set(entry.path, entry.content);
+    }
+  }
+  return files;
+}
+
+// src/core/fetcher.ts
+function validatePackageName(name) {
+  if (!name || typeof name !== "string") {
+    throw new ValidationError("Package name is required", "name");
+  }
+  const validPattern = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+  if (!validPattern.test(name)) {
+    throw new ValidationError(
+      `Invalid package name: "${name}". Package names must be lowercase and may contain letters, numbers, hyphens, dots, and underscores.`,
+      "name"
+    );
+  }
+  if (name.length > 214) {
+    throw new ValidationError("Package name cannot exceed 214 characters", "name");
+  }
+}
+function parsePackageSpec(spec) {
+  if (!spec || typeof spec !== "string") {
+    throw new ValidationError("Package specifier is required", "spec");
+  }
+  const trimmed = spec.trim();
+  if (trimmed.startsWith("@")) {
+    const firstSlash = trimmed.indexOf("/");
+    if (firstSlash === -1) {
+      throw new ValidationError(`Invalid scoped package: "${spec}"`, "spec");
+    }
+    const afterScope = trimmed.slice(firstSlash + 1);
+    const versionSep = afterScope.lastIndexOf("@");
+    if (versionSep > 0) {
+      const name = trimmed.slice(0, firstSlash + 1 + versionSep);
+      const version = afterScope.slice(versionSep + 1);
+      return { name, version: version || void 0 };
+    }
+    return { name: trimmed };
+  }
+  const atIndex = trimmed.lastIndexOf("@");
+  if (atIndex > 0) {
+    const name = trimmed.slice(0, atIndex);
+    const version = trimmed.slice(atIndex + 1);
+    return { name, version: version || void 0 };
+  }
+  return { name: trimmed };
+}
+function resolveVersion(packageName, versions, distTags, requested) {
+  if (!requested) {
+    const latest = distTags["latest"];
+    if (latest && versions.includes(latest)) {
+      return latest;
+    }
+    return versions.sort(compareVersions).pop();
+  }
+  if (distTags[requested]) {
+    return distTags[requested];
+  }
+  if (versions.includes(requested)) {
+    return requested;
+  }
+  const matching = versions.filter((v) => v.startsWith(requested));
+  if (matching.length > 0) {
+    return matching.sort(compareVersions).pop();
+  }
+  throw new VersionNotFoundError(packageName, requested);
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] || 0;
+    const nb = pb[i] || 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
+async function fetchPackageMetadata(name, version, options = {}) {
+  validatePackageName(name);
+  const registry = options.registry ?? DEFAULT_REGISTRY;
+  const httpOptions = { timeout: options.timeout };
+  if (version && !["latest", "next", "beta", "alpha"].includes(version)) {
+    try {
+      const url2 = buildPackageUrl(name, version, registry);
+      const { data } = await fetchJson(url2, httpOptions);
+      return extractMetadata(data);
+    } catch (error) {
+      if (!(error instanceof DownloadError) || !error.message.includes("404")) {
+        throw error;
+      }
+    }
+  }
+  const url = buildPackageUrl(name, void 0, registry);
+  try {
+    const { data } = await fetchJson(url, httpOptions);
+    const versions = Object.keys(data.versions ?? {});
+    if (versions.length === 0) {
+      throw new PackageNotFoundError(name);
+    }
+    const resolvedVersion = resolveVersion(
+      name,
+      versions,
+      data["dist-tags"] ?? {},
+      version
+    );
+    const versionData = data.versions[resolvedVersion];
+    if (!versionData) {
+      throw new VersionNotFoundError(name, resolvedVersion);
+    }
+    return extractMetadata(versionData);
+  } catch (error) {
+    if (error instanceof DownloadError && error.message.includes("404")) {
+      throw new PackageNotFoundError(name);
+    }
+    throw error;
+  }
+}
+function extractMetadata(data) {
+  if (!data.dist?.tarball) {
+    throw new DownloadError("Package metadata missing tarball URL");
+  }
+  let repository;
+  if (data.repository) {
+    if (typeof data.repository === "string") {
+      repository = { type: "git", url: data.repository };
+    } else {
+      repository = data.repository;
+    }
+  }
+  return {
+    name: data.name,
+    version: data.version,
+    description: data.description,
+    tarball: data.dist.tarball,
+    types: data.types ?? data.typings,
+    main: data.main,
+    exports: data.exports,
+    repository,
+    keywords: data.keywords,
+    author: data.author,
+    license: data.license,
+    homepage: data.homepage
+  };
+}
+async function downloadPackageFiles(tarballUrl, options = {}) {
+  const buffer = await fetchGzipped(tarballUrl, options);
+  return extractTarToMap(buffer);
+}
+async function fetchPackage(spec, options = {}) {
+  const { name, version } = parsePackageSpec(spec);
+  const metadata = await fetchPackageMetadata(name, version, options);
+  const files = await downloadPackageFiles(metadata.tarball, {
+    timeout: options.timeout
+  });
+  return {
+    ...metadata,
+    files
+  };
+}
+
+// src/plugins/core/types-resolver.ts
+function hasDtsFiles(files) {
+  for (const path of files.keys()) {
+    if (path.endsWith(".d.ts")) {
+      return true;
+    }
+  }
+  return false;
+}
+function getTypesPackageName(packageName) {
+  if (packageName.startsWith("@")) {
+    const withoutAt = packageName.slice(1);
+    return `@types/${withoutAt.replace("/", "__")}`;
+  }
+  return `@types/${packageName}`;
+}
+function isTypesPackage(packageName) {
+  return packageName.startsWith("@types/");
+}
+var typesResolverPlugin = {
+  name: "types-resolver",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("package:fetched", async (context) => {
+      const { files, name } = context.package;
+      if (isTypesPackage(name)) {
+        return;
+      }
+      if (hasDtsFiles(files)) {
+        return;
+      }
+      const typesPackageName = getTypesPackageName(name);
+      try {
+        const typesPackage = await fetchPackage(typesPackageName);
+        let mergedCount = 0;
+        for (const [path, content] of typesPackage.files) {
+          if (path.endsWith(".d.ts")) {
+            const newPath = `__types__/${path}`;
+            files.set(newPath, content);
+            mergedCount++;
+          }
+        }
+        if (typesPackage.types && !context.package.types) {
+          context.package.types = `__types__/${typesPackage.types}`;
+        }
+        if (mergedCount > 0) {
+          console.error(
+            `[types-resolver] Merged ${mergedCount} .d.ts files from ${typesPackageName}`
+          );
+        }
+      } catch (error) {
+      }
+    });
+  }
+};
+
+// src/parsers/jsdoc.ts
+var TAG_PATTERNS = {
+  /** @param {type} name - description */
+  param: /@param\s+(?:\{([^}]*)\})?\s*(\[?\w+(?:\.\w+)*\]?)\s*(?:-\s*)?(.*)$/gm,
+  /** @returns {type} description */
+  returns: /@returns?\s+(?:\{([^}]*)\})?\s*(.*)/g,
+  /** @example ... */
+  example: /@example\s*([\s\S]*?)(?=@\w|$)/g,
+  /** @deprecated reason */
+  deprecated: /@deprecated\s*(.*)/g,
+  /** @since version */
+  since: /@since\s*(.*)/g,
+  /** @see reference */
+  see: /@see\s*(.*)/g,
+  /** @throws {type} description */
+  throws: /@throws?\s+(?:\{([^}]*)\})?\s*(.*)/g,
+  /** @template T - description */
+  typeParam: /@template\s+(\w+)\s*(?:-\s*)?(.*)/g};
+function cleanJSDocComment(comment) {
+  return comment.replace(/^\/\*\*\s*/, "").replace(/\s*\*\/$/, "").replace(/^\s*\*\s?/gm, "").trim();
+}
+function extractDescription(content) {
+  const tagMatch = content.match(/@\w+/);
+  if (!tagMatch) {
+    return content.trim() || void 0;
+  }
+  const description = content.slice(0, tagMatch.index).trim();
+  return description || void 0;
+}
+function parseParams(content) {
+  const params = [];
+  const pattern = new RegExp(TAG_PATTERNS.param.source, "gm");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, type, rawName, description] = match;
+    if (!rawName) continue;
+    const name = rawName;
+    const isOptional = name.startsWith("[") && name.endsWith("]");
+    const cleanName = isOptional ? name.slice(1, -1) : name;
+    params.push({
+      name: cleanName,
+      type: type?.trim(),
+      description: description?.trim() || void 0,
+      optional: isOptional
+    });
+  }
+  return params;
+}
+function parseReturns(content) {
+  const pattern = new RegExp(TAG_PATTERNS.returns.source, "g");
+  const match = pattern.exec(content);
+  if (!match) return void 0;
+  const [, type, description] = match;
+  return {
+    type: type?.trim(),
+    description: description?.trim() || void 0
+  };
+}
+function parseExamples(content) {
+  const examples = [];
+  const pattern = new RegExp(TAG_PATTERNS.example.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const example = match[1]?.trim();
+    if (example) {
+      examples.push(example);
+    }
+  }
+  return examples;
+}
+function parseDeprecated(content) {
+  const pattern = new RegExp(TAG_PATTERNS.deprecated.source, "g");
+  const match = pattern.exec(content);
+  return match ? match[1]?.trim() || "true" : void 0;
+}
+function parseSince(content) {
+  const pattern = new RegExp(TAG_PATTERNS.since.source, "g");
+  const match = pattern.exec(content);
+  return match ? match[1]?.trim() : void 0;
+}
+function parseSee(content) {
+  const refs = [];
+  const pattern = new RegExp(TAG_PATTERNS.see.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const ref = match[1]?.trim();
+    if (ref) {
+      refs.push(ref);
+    }
+  }
+  return refs;
+}
+function parseThrows(content) {
+  const throws = [];
+  const pattern = new RegExp(TAG_PATTERNS.throws.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, type, description] = match;
+    throws.push({
+      type: type?.trim(),
+      description: description?.trim() || void 0
+    });
+  }
+  return throws;
+}
+function parseTypeParams(content) {
+  const params = [];
+  const pattern = new RegExp(TAG_PATTERNS.typeParam.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, name, description] = match;
+    if (!name) continue;
+    params.push({
+      name: name.trim(),
+      description: description?.trim() || void 0
+    });
+  }
+  return params;
+}
+function parseJSDoc(comment) {
+  const content = cleanJSDocComment(comment);
+  return {
+    description: extractDescription(content),
+    params: parseParams(content).map((p) => ({
+      name: p.name,
+      type: p.type,
+      description: p.description,
+      optional: p.optional,
+      defaultValue: p.defaultValue
+    })),
+    returns: parseReturns(content),
+    examples: parseExamples(content),
+    deprecated: parseDeprecated(content),
+    since: parseSince(content),
+    see: parseSee(content),
+    throws: parseThrows(content),
+    typeParams: parseTypeParams(content)
+  };
+}
+function extractJSDocComments(source) {
+  const comments = [];
+  const pattern = /\/\*\*[\s\S]*?\*\//g;
+  let match;
+  while ((match = pattern.exec(source)) !== null) {
+    comments.push({
+      comment: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return comments;
+}
+function findPrecedingJSDoc(source, position, comments) {
+  const allComments = comments ?? extractJSDocComments(source);
+  for (let i = allComments.length - 1; i >= 0; i--) {
+    const comment = allComments[i];
+    if (!comment || comment.end > position) continue;
+    const between = source.slice(comment.end, position);
+    if (/^\s*$/.test(between)) {
+      return parseJSDoc(comment.comment);
+    }
+    if (comment.end < position - 500) break;
+  }
+  return void 0;
+}
+
+// src/parsers/dts.ts
+var PATTERNS = {
+  /** Export function declaration */
+  exportFunction: /export\s+(?:declare\s+)?function\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)\s*:\s*([^;{]+)/g,
+  /** Export const declaration */
+  exportConst: /export\s+(?:declare\s+)?const\s+(\w+)\s*:\s*([^;=]+)/g,
+  /** Export class declaration */
+  exportClass: /export\s+(?:declare\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^\s{]+))?(?:\s+implements\s+([^{]+))?\s*\{/g,
+  /** Export interface declaration */
+  exportInterface: /export\s+(?:declare\s+)?interface\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^{]+))?\s*\{/g,
+  /** Export type declaration */
+  exportType: /export\s+(?:declare\s+)?type\s+(\w+)(?:\s*<([^>]*)>)?\s*=\s*([^;]+)/g,
+  /** Export enum declaration */
+  exportEnum: /export\s+(?:declare\s+)?(?:const\s+)?enum\s+(\w+)\s*\{/g,
+  /** Import statement */
+  importStatement: /import\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*from\s*['"]([^'"]+)['"]/g,
+  /** Declare module (module augmentation) */
+  declareModule: /declare\s+module\s+['"]([^'"]+)['"]\s*\{/g};
+function parseParameters(paramStr) {
+  if (!paramStr.trim()) return [];
+  const params = [];
+  const parts = splitParameters(paramStr);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      const colonIndex = findTypeColonIndex(trimmed);
+      if (colonIndex > 0) {
+        params.push({
+          name: "options",
+          type: trimmed.slice(colonIndex + 1).trim(),
+          optional: trimmed.includes("?")
+        });
+      }
+      continue;
+    }
+    const match = trimmed.match(/^(\w+)(\?)?\s*:\s*(.+?)(?:\s*=\s*(.+))?$/);
+    if (match) {
+      const [, name, optional, type, defaultValue] = match;
+      if (name && type) {
+        params.push({
+          name,
+          type: type.trim(),
+          optional: !!optional,
+          defaultValue: defaultValue?.trim()
+        });
+      }
+    } else {
+      const nameMatch = trimmed.match(/^(\w+)(\?)?$/);
+      if (nameMatch && nameMatch[1]) {
+        params.push({
+          name: nameMatch[1],
+          type: "unknown",
+          optional: !!nameMatch[2]
+        });
+      }
+    }
+  }
+  return params;
+}
+function splitParameters(paramStr) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (let i = 0; i < paramStr.length; i++) {
+    const char = paramStr[i];
+    if (char === "<" || char === "{" || char === "[" || char === "(") {
+      depth++;
+      current += char;
+    } else if (char === ">" || char === "}" || char === "]" || char === ")") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function findTypeColonIndex(str) {
+  let depth = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" || char === "[" || char === "<" || char === "(") {
+      depth++;
+    } else if (char === "}" || char === "]" || char === ">" || char === ")") {
+      depth--;
+    } else if (char === ":" && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function extractBody(source, startIndex) {
+  let depth = 0;
+  let i = startIndex;
+  while (i < source.length) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") {
+      depth--;
+      if (depth === 0) break;
+    }
+    i++;
+  }
+  return source.slice(startIndex + 1, i);
+}
+function parseClassMembers(body, comments, bodyOffset) {
+  const methods = [];
+  const properties = [];
+  const methodPattern = /(?:(?:public|private|protected|static|readonly)\s+)*(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)\s*:\s*([^;{]+)/g;
+  let match;
+  while ((match = methodPattern.exec(body)) !== null) {
+    const [fullMatch, name, generics, params, returnType] = match;
+    if (!name || !returnType) continue;
+    const jsdoc = findPrecedingJSDoc(body, match.index, comments.map((c) => ({
+      ...c,
+      start: c.start - bodyOffset,
+      end: c.end - bodyOffset
+    })));
+    methods.push({
+      kind: "function",
+      name,
+      signature: `${name}${generics || ""}(${params || ""}): ${returnType.trim()}`,
+      description: jsdoc?.description,
+      params: mergeParamDocs(parseParameters(params || ""), jsdoc?.params),
+      returns: {
+        type: returnType.trim(),
+        description: jsdoc?.returns?.description
+      },
+      examples: jsdoc?.examples
+    });
+  }
+  const propPattern = /(?:(?:public|private|protected|static|readonly)\s+)*(\w+)(\?)?\s*:\s*([^;]+)/g;
+  while ((match = propPattern.exec(body)) !== null) {
+    const [, name, optional, type] = match;
+    if (!name || !type) continue;
+    if (type.includes("=>") || type.includes("(")) continue;
+    properties.push({
+      kind: "constant",
+      name,
+      signature: `${name}${optional || ""}: ${type.trim()}`,
+      description: findPrecedingJSDoc(body, match.index)?.description
+    });
+  }
+  return { methods, properties };
+}
+function mergeParamDocs(sigParams, jsdocParams) {
+  if (!jsdocParams || jsdocParams.length === 0) return sigParams;
+  return sigParams.map((param) => {
+    const jsdocParam = jsdocParams.find((p) => p.name === param.name);
+    if (jsdocParam) {
+      return {
+        ...param,
+        description: jsdocParam.description || param.description,
+        type: param.type || jsdocParam.type,
+        optional: param.optional || jsdocParam.optional,
+        defaultValue: param.defaultValue || jsdocParam.defaultValue
+      };
+    }
+    return param;
+  });
+}
+function parseEnumMembers(body) {
+  const members = [];
+  const pattern = /(\w+)\s*(?:=\s*([^,}]+))?/g;
+  let match;
+  while ((match = pattern.exec(body)) !== null) {
+    const [, name, value] = match;
+    if (!name) continue;
+    let parsedValue;
+    if (value !== void 0) {
+      const trimmed = value.trim();
+      const num = Number(trimmed);
+      if (!isNaN(num)) {
+        parsedValue = num;
+      } else {
+        parsedValue = trimmed.replace(/^['"]|['"]$/g, "");
+      }
+    }
+    members.push({ name, value: parsedValue });
+  }
+  return members;
+}
+function parseDts(content, filePath) {
+  const exports$1 = [];
+  const imports = [];
+  let moduleName;
+  const comments = extractJSDocComments(content);
+  const moduleMatch = PATTERNS.declareModule.exec(content);
+  if (moduleMatch) {
+    moduleName = moduleMatch[1];
+  }
+  let match;
+  PATTERNS.exportFunction.lastIndex = 0;
+  while ((match = PATTERNS.exportFunction.exec(content)) !== null) {
+    const [fullMatch, name, generics, params, returnType] = match;
+    if (!name || !returnType) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "function",
+      name,
+      signature: `function ${name}${generics || ""}(${params || ""}): ${returnType.trim()}`,
+      description: jsdoc?.description,
+      params: mergeParamDocs(parseParameters(params || ""), jsdoc?.params),
+      returns: {
+        type: returnType.trim(),
+        description: jsdoc?.returns?.description
+      },
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      since: jsdoc?.since,
+      see: jsdoc?.see,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportConst.lastIndex = 0;
+  while ((match = PATTERNS.exportConst.exec(content)) !== null) {
+    const [, name, type] = match;
+    if (!name || !type) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "constant",
+      name,
+      signature: `const ${name}: ${type.trim()}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportClass.lastIndex = 0;
+  while ((match = PATTERNS.exportClass.exec(content)) !== null) {
+    const [, name, generics, extendsClause, implementsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const bodyStart = match.index + match[0].length - 1;
+    const body = extractBody(content, bodyStart);
+    const { methods, properties } = parseClassMembers(body, comments, bodyStart);
+    exports$1.push({
+      kind: "class",
+      name,
+      signature: `class ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? [extendsClause.trim()] : void 0,
+      implements: implementsClause ? implementsClause.split(",").map((s) => s.trim()) : void 0,
+      methods,
+      properties,
+      typeParams: generics ? generics.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportInterface.lastIndex = 0;
+  while ((match = PATTERNS.exportInterface.exec(content)) !== null) {
+    const [, name, generics, extendsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const bodyStart = match.index + match[0].length - 1;
+    const body = extractBody(content, bodyStart);
+    const { methods, properties } = parseClassMembers(body, comments, bodyStart);
+    exports$1.push({
+      kind: "interface",
+      name,
+      signature: `interface ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? extendsClause.split(",").map((s) => s.trim()) : void 0,
+      methods,
+      properties,
+      typeParams: generics ? generics.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportType.lastIndex = 0;
+  while ((match = PATTERNS.exportType.exec(content)) !== null) {
+    const [, name, generics, definition] = match;
+    if (!name || !definition) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "type",
+      name,
+      signature: `type ${name}${generics ? `<${generics}>` : ""} = ${definition.trim()}`,
+      description: jsdoc?.description,
+      typeParams: generics ? generics.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportEnum.lastIndex = 0;
+  while ((match = PATTERNS.exportEnum.exec(content)) !== null) {
+    const [, name] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const bodyStart = match.index + match[0].length - 1;
+    const body = extractBody(content, bodyStart);
+    const members = parseEnumMembers(body);
+    exports$1.push({
+      kind: "enum",
+      name,
+      signature: `enum ${name}`,
+      description: jsdoc?.description,
+      members,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.importStatement.lastIndex = 0;
+  while ((match = PATTERNS.importStatement.exec(content)) !== null) {
+    if (match[1]) {
+      imports.push(match[1]);
+    }
+  }
+  PATTERNS.declareModule.lastIndex = 0;
+  while ((match = PATTERNS.declareModule.exec(content)) !== null) {
+    const moduleBodyStart = match.index + match[0].length - 1;
+    const moduleBody = extractBody(content, moduleBodyStart);
+    const moduleExports = parseModuleAugmentation(moduleBody, comments, moduleBodyStart, filePath);
+    for (const entry of moduleExports) {
+      exports$1.push(entry);
+    }
+  }
+  return { exports: exports$1, imports, moduleName };
+}
+function parseModuleAugmentation(body, _comments, _bodyOffset, filePath) {
+  const entries = [];
+  const moduleComments = extractJSDocComments(body);
+  const interfacePattern = /interface\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^{]+))?\s*\{/g;
+  let match;
+  while ((match = interfacePattern.exec(body)) !== null) {
+    const [, interfaceName, generics, extendsClause] = match;
+    if (!interfaceName) continue;
+    const ifaceBodyStart = match.index + match[0].length - 1;
+    const ifaceBody = extractBody(body, ifaceBodyStart);
+    if (interfaceName === "LoDashStatic" || interfaceName.endsWith("Static")) {
+      const methods = parseInterfaceMethodsAsExports(
+        ifaceBody,
+        moduleComments,
+        ifaceBodyStart,
+        filePath
+      );
+      for (const method of methods) {
+        entries.push(method);
+      }
+    }
+  }
+  return entries;
+}
+function parseInterfaceMethodsAsExports(body, _comments, _bodyOffset, filePath) {
+  const methods = [];
+  const bodyComments = extractJSDocComments(body);
+  const methodPattern = /(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)\s*:\s*([^;]+);/g;
+  let match;
+  while ((match = methodPattern.exec(body)) !== null) {
+    const [fullMatch, name, generics, params, returnType] = match;
+    if (!name || !returnType) continue;
+    if (["constructor", "toString", "valueOf", "toJSON"].includes(name)) continue;
+    const jsdoc = findPrecedingJSDoc(body, match.index, bodyComments);
+    methods.push({
+      kind: "function",
+      name,
+      signature: `function ${name}${generics || ""}(${params || ""}): ${returnType.trim()}`,
+      description: jsdoc?.description,
+      params: mergeParamDocs(parseParameters(params || ""), jsdoc?.params),
+      returns: {
+        type: returnType.trim(),
+        description: jsdoc?.returns?.description
+      },
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      since: jsdoc?.since,
+      see: jsdoc?.see,
+      sourceFile: filePath
+    });
+  }
+  return methods;
+}
+function sortExports(exports$1) {
+  const kindOrder = {
+    function: 1,
+    class: 2,
+    interface: 3,
+    type: 4,
+    enum: 5,
+    constant: 6
+  };
+  return [...exports$1].sort((a, b) => {
+    const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
+    if (kindDiff !== 0) return kindDiff;
+    return a.name.localeCompare(b.name);
+  });
+}
+function findMainDtsFile(files, typesField) {
+  if (typesField) {
+    const normalized = typesField.replace(/^\.\//, "");
+    if (files.has(normalized)) return normalized;
+  }
+  const priorities = [
+    "index.d.ts",
+    "dist/index.d.ts",
+    "lib/index.d.ts",
+    "types/index.d.ts",
+    "src/index.d.ts",
+    // @types packages merged via types-resolver plugin
+    "__types__/index.d.ts",
+    "__types__/dist/index.d.ts",
+    "__types__/lib/index.d.ts",
+    "__types__/types/index.d.ts"
+  ];
+  for (const path of priorities) {
+    if (files.has(path)) return path;
+  }
+  for (const path of files.keys()) {
+    if (path.endsWith(".d.ts") && !path.startsWith("__types__/")) {
+      return path;
+    }
+  }
+  for (const path of files.keys()) {
+    if (path.endsWith(".d.ts") && path.startsWith("__types__/")) {
+      return path;
+    }
+  }
+  return void 0;
+}
+
+// src/plugins/core/dts-parser.ts
+var dtsParserPlugin = {
+  name: "dts-parser",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("parse:start", async (context) => {
+      const { files } = context.package;
+      const mainDts = findMainDtsFile(files, context.package.types);
+      if (!mainDts) {
+        return;
+      }
+      const dtsFiles = Array.from(files.entries()).filter(([path]) => path.endsWith(".d.ts")).sort(([a], [b]) => {
+        if (a === mainDts) return -1;
+        if (b === mainDts) return 1;
+        if (a.includes("index.d.ts")) return -1;
+        if (b.includes("index.d.ts")) return 1;
+        return a.localeCompare(b);
+      });
+      const seenNames = /* @__PURE__ */ new Set();
+      for (const [path, content] of dtsFiles) {
+        try {
+          const result = parseDts(content, path);
+          for (const entry of result.exports) {
+            if (!seenNames.has(entry.name)) {
+              seenNames.add(entry.name);
+              context.api.push(entry);
+            }
+          }
+        } catch (error) {
+          context.errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      context.api = sortExports(context.api);
+    });
+  }
+};
+
+// src/parsers/typescript.ts
+var PATTERNS2 = {
+  /** Export function */
+  exportFunction: /export\s+(?:async\s+)?function\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^{]+))?\s*\{/g,
+  /** Export arrow function */
+  exportArrow: /export\s+const\s+(\w+)\s*(?::\s*([^=]+))?\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*([^=]+))?\s*=>/g,
+  /** Export class */
+  exportClass: /export\s+(?:abstract\s+)?class\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^\s{]+))?(?:\s+implements\s+([^{]+))?\s*\{/g,
+  /** Export interface */
+  exportInterface: /export\s+interface\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^{]+))?\s*\{/g,
+  /** Export type */
+  exportType: /export\s+type\s+(\w+)(?:\s*<([^>]*)>)?\s*=\s*([^;]+)/g,
+  /** Export const/let */
+  exportConst: /export\s+(?:const|let)\s+(\w+)(?:\s*:\s*([^=]+))?\s*=/g,
+  /** Export enum */
+  exportEnum: /export\s+(?:const\s+)?enum\s+(\w+)\s*\{/g};
+function parseSourceParams(paramStr) {
+  if (!paramStr.trim()) return [];
+  const params = [];
+  const parts = splitParams(paramStr);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      const colonIndex = findBalancedColon(trimmed);
+      if (colonIndex > 0) {
+        params.push({
+          name: "options",
+          type: trimmed.slice(colonIndex + 1).trim(),
+          optional: trimmed.includes("?")
+        });
+      } else {
+        params.push({
+          name: "options",
+          type: "object"
+        });
+      }
+      continue;
+    }
+    const match = trimmed.match(/^(\w+)(\?)?\s*(?::\s*(.+?))?(?:\s*=\s*(.+))?$/);
+    if (match && match[1]) {
+      const [, name, optional, type, defaultValue] = match;
+      params.push({
+        name,
+        type: type?.trim() || inferTypeFromDefault(defaultValue),
+        optional: !!optional || !!defaultValue,
+        defaultValue: defaultValue?.trim()
+      });
+    }
+  }
+  return params;
+}
+function splitParams(str) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (const char of str) {
+    if (char === "<" || char === "{" || char === "[" || char === "(") {
+      depth++;
+      current += char;
+    } else if (char === ">" || char === "}" || char === "]" || char === ")") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function findBalancedColon(str) {
+  let depth = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" || char === "[" || char === "<" || char === "(") {
+      depth++;
+    } else if (char === "}" || char === "]" || char === ">" || char === ")") {
+      depth--;
+    } else if (char === ":" && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function inferTypeFromDefault(defaultValue) {
+  if (!defaultValue) return "unknown";
+  const trimmed = defaultValue.trim();
+  if (trimmed === "true" || trimmed === "false") return "boolean";
+  if (trimmed.startsWith("'") || trimmed.startsWith('"') || trimmed.startsWith("`")) {
+    return "string";
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return "number";
+  if (trimmed === "null") return "null";
+  if (trimmed === "undefined") return "undefined";
+  if (trimmed.startsWith("[")) return "unknown[]";
+  if (trimmed.startsWith("{")) return "object";
+  if (trimmed.startsWith("()") || trimmed.includes("=>")) return "Function";
+  return "unknown";
+}
+function parseTypeScript(content, filePath) {
+  const exports$1 = [];
+  let hasTypes = false;
+  hasTypes = /:\s*\w+/.test(content) || content.includes("interface ") || content.includes("type ");
+  const comments = extractJSDocComments(content);
+  let match;
+  PATTERNS2.exportFunction.lastIndex = 0;
+  while ((match = PATTERNS2.exportFunction.exec(content)) !== null) {
+    const [, name, generics, params, returnType] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const paramStr = params || "";
+    exports$1.push({
+      kind: "function",
+      name,
+      signature: `function ${name}${generics || ""}(${paramStr})${returnType ? `: ${returnType.trim()}` : ""}`,
+      description: jsdoc?.description,
+      params: mergeParams(parseSourceParams(paramStr), jsdoc?.params),
+      returns: returnType ? { type: returnType.trim(), description: jsdoc?.returns?.description } : void 0,
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportArrow.lastIndex = 0;
+  while ((match = PATTERNS2.exportArrow.exec(content)) !== null) {
+    const [fullMatch, name, typeAnnotation, returnType] = match;
+    if (!name || !fullMatch) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const paramsStart = fullMatch.indexOf("(");
+    const paramsEnd = fullMatch.indexOf(")", paramsStart);
+    const params = fullMatch.slice(paramsStart + 1, paramsEnd);
+    exports$1.push({
+      kind: "function",
+      name,
+      signature: typeAnnotation ? `const ${name}: ${typeAnnotation.trim()}` : `const ${name} = (${params})${returnType ? ` => ${returnType.trim()}` : ""}`,
+      description: jsdoc?.description,
+      params: mergeParams(parseSourceParams(params), jsdoc?.params),
+      returns: returnType ? { type: returnType.trim(), description: jsdoc?.returns?.description } : void 0,
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportClass.lastIndex = 0;
+  while ((match = PATTERNS2.exportClass.exec(content)) !== null) {
+    const [, name, generics, extendsClause, implementsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "class",
+      name,
+      signature: `class ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? [extendsClause.trim()] : void 0,
+      implements: implementsClause ? implementsClause.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportInterface.lastIndex = 0;
+  while ((match = PATTERNS2.exportInterface.exec(content)) !== null) {
+    const [, name, generics, extendsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "interface",
+      name,
+      signature: `interface ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? extendsClause.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportType.lastIndex = 0;
+  while ((match = PATTERNS2.exportType.exec(content)) !== null) {
+    const [, name, generics, definition] = match;
+    if (!name || !definition) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "type",
+      name,
+      signature: `type ${name}${generics ? `<${generics}>` : ""} = ${definition.trim()}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportConst.lastIndex = 0;
+  while ((match = PATTERNS2.exportConst.exec(content)) !== null) {
+    const [, name, type] = match;
+    if (!name) continue;
+    if (content.slice(match.index, match.index + 200).includes("=>")) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "constant",
+      name,
+      signature: `const ${name}${type ? `: ${type.trim()}` : ""}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportEnum.lastIndex = 0;
+  while ((match = PATTERNS2.exportEnum.exec(content)) !== null) {
+    const [, name] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "enum",
+      name,
+      signature: `enum ${name}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  return { exports: exports$1, hasTypes };
+}
+function mergeParams(sourceParams, jsdocParams) {
+  if (!jsdocParams || jsdocParams.length === 0) return sourceParams;
+  return sourceParams.map((param) => {
+    const jsdocParam = jsdocParams.find((p) => p.name === param.name);
+    if (jsdocParam) {
+      return {
+        ...param,
+        description: jsdocParam.description || param.description,
+        type: param.type !== "unknown" ? param.type : jsdocParam.type
+      };
+    }
+    return param;
+  });
+}
+function findTypeScriptFiles(files, mainField) {
+  const tsFiles = [];
+  const priorities = [];
+  if (mainField) {
+    const base = mainField.replace(/^\.\//, "").replace(/\.[jt]sx?$/, "");
+    priorities.push(
+      `${base}.ts`,
+      `${base}.tsx`,
+      `src/${base}.ts`,
+      `src/${base}.tsx`
+    );
+  }
+  priorities.push(
+    "src/index.ts",
+    "src/index.tsx",
+    "index.ts",
+    "index.tsx",
+    "lib/index.ts",
+    "src/main.ts"
+  );
+  for (const path of priorities) {
+    if (files.has(path) && !tsFiles.includes(path)) {
+      tsFiles.push(path);
+    }
+  }
+  for (const path of files.keys()) {
+    if ((path.endsWith(".ts") || path.endsWith(".tsx")) && !path.endsWith(".d.ts")) {
+      if (!tsFiles.includes(path)) {
+        tsFiles.push(path);
+      }
+    }
+  }
+  return tsFiles;
+}
+
+// src/plugins/core/ts-source-parser.ts
+var tsSourceParserPlugin = {
+  name: "ts-source-parser",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("parse:start", async (context) => {
+      if (context.api.length > 0) {
+        return;
+      }
+      const { files } = context.package;
+      const tsFiles = findTypeScriptFiles(files, context.package.main);
+      if (tsFiles.length === 0) {
+        return;
+      }
+      const seenNames = /* @__PURE__ */ new Set();
+      for (const path of tsFiles) {
+        const content = files.get(path);
+        if (!content) continue;
+        try {
+          const result = parseTypeScript(content, path);
+          for (const entry of result.exports) {
+            if (!seenNames.has(entry.name)) {
+              seenNames.add(entry.name);
+              context.api.push(entry);
+            }
+          }
+        } catch (error) {
+          context.errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      context.api = sortExports(context.api);
+    });
+  }
+};
+
+// src/parsers/readme.ts
+var SECTION_PATTERNS = {
+  installation: /^#+\s*(installation|install|setup|getting started)/i,
+  quickStart: /^#+\s*(quick\s*start|usage|getting\s*started|basic\s*usage)/i,
+  api: /^#+\s*(api|api\s*reference|reference|methods|functions)/i,
+  examples: /^#+\s*(examples?|code\s*examples?)/i};
+var BADGE_PATTERN = /\[!\[([^\]]*)\]\(([^)]+)\)\]\([^)]+\)|\!\[([^\]]*)\]\(([^)]+)\)/g;
+var CODE_BLOCK_PATTERN = /```(\w+)?\s*\n([\s\S]*?)```/g;
+function parseReadme(content) {
+  const sections = extractSections(content);
+  const badges = extractBadges(content);
+  const { title, description } = extractTitleAndDescription(content, sections);
+  const installation = findSection(sections, SECTION_PATTERNS.installation);
+  const quickStart = findSection(sections, SECTION_PATTERNS.quickStart);
+  const api = findSection(sections, SECTION_PATTERNS.api);
+  const examples = findExampleSections(sections);
+  return {
+    title,
+    description,
+    badges,
+    installation: installation?.content,
+    quickStart: quickStart?.content || findQuickStartFromCode(content),
+    examples,
+    api: api?.content,
+    sections
+  };
+}
+function extractSections(content) {
+  const sections = [];
+  const lines = content.split("\n");
+  let currentSection = null;
+  let currentContent = [];
+  let charIndex = 0;
+  function finishSection() {
+    if (currentSection) {
+      currentSection.content = currentContent.join("\n").trim();
+      currentSection.endIndex = charIndex;
+      sections.push(currentSection);
+      currentContent = [];
+    }
+  }
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch && headingMatch[1] && headingMatch[2]) {
+      finishSection();
+      const level = headingMatch[1].length;
+      const title = headingMatch[2].trim();
+      currentSection = {
+        title,
+        content: "",
+        level,
+        startIndex: charIndex,
+        endIndex: 0
+      };
+      currentContent = [];
+    } else if (currentSection) {
+      currentContent.push(line);
+    }
+    charIndex += line.length + 1;
+  }
+  finishSection();
+  return sections;
+}
+function findSection(sections, pattern) {
+  return sections.find((s) => pattern.test(`# ${s.title}`));
+}
+function findExampleSections(sections) {
+  const examples = [];
+  for (const section of sections) {
+    if (SECTION_PATTERNS.examples.test(`# ${section.title}`)) {
+      const codeBlocks = extractCodeBlocks(section.content);
+      examples.push(...codeBlocks);
+    }
+  }
+  return examples;
+}
+function extractCodeBlocks(content) {
+  const blocks = [];
+  const pattern = new RegExp(CODE_BLOCK_PATTERN.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, language, code] = match;
+    if (code && code.trim()) {
+      blocks.push(language ? `\`\`\`${language}
+${code.trim()}
+\`\`\`` : code.trim());
+    }
+  }
+  return blocks;
+}
+function extractBadges(content) {
+  const badges = [];
+  const pattern = new RegExp(BADGE_PATTERN.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const altText = match[1] || match[3] || "";
+    if (altText) {
+      badges.push(altText);
+    }
+  }
+  return badges;
+}
+function extractTitleAndDescription(content, sections) {
+  let title;
+  let description;
+  const firstHeading = sections[0];
+  if (firstHeading?.level === 1) {
+    title = firstHeading.title;
+  } else {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("!") || trimmed.startsWith("[!")) continue;
+      if (trimmed.startsWith("#")) {
+        title = trimmed.replace(/^#+\s*/, "");
+        break;
+      }
+    }
+  }
+  const afterTitle = content.split("\n").slice(1);
+  let foundContent = false;
+  for (const line of afterTitle) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("!") || trimmed.startsWith("[!")) continue;
+    if (trimmed.startsWith("#")) break;
+    if (!trimmed && !foundContent) continue;
+    if (!trimmed && foundContent) break;
+    if (trimmed) {
+      foundContent = true;
+      if (!description) {
+        description = trimmed;
+      } else {
+        description += " " + trimmed;
+      }
+    }
+  }
+  if (description) {
+    description = description.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").trim();
+  }
+  return { title, description };
+}
+function findQuickStartFromCode(content) {
+  const installMatch = content.match(/installation|install|setup/i);
+  const startIndex = installMatch?.index ?? 0;
+  const searchArea = content.slice(startIndex, startIndex + 2e3);
+  const codeBlocks = extractCodeBlocks(searchArea);
+  for (const block of codeBlocks) {
+    if (block.startsWith("```javascript") || block.startsWith("```typescript") || block.startsWith("```js") || block.startsWith("```ts") || block.startsWith("```jsx") || block.startsWith("```tsx")) {
+      return block;
+    }
+  }
+  return codeBlocks[0];
+}
+
+// src/plugins/core/readme-parser.ts
+var readmeParserPlugin = {
+  name: "readme-parser",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("parse:start", async (context) => {
+      const { files } = context.package;
+      let readmeContent;
+      const readmePatterns = [
+        "README.md",
+        "readme.md",
+        "Readme.md",
+        "README.MD",
+        "README",
+        "readme"
+      ];
+      for (const pattern of readmePatterns) {
+        if (files.has(pattern)) {
+          readmeContent = files.get(pattern);
+          break;
+        }
+      }
+      if (!readmeContent) {
+        for (const [path, content] of files) {
+          if (path.toLowerCase().includes("readme")) {
+            readmeContent = content;
+            break;
+          }
+        }
+      }
+      if (!readmeContent) {
+        return;
+      }
+      try {
+        context.readme = parseReadme(readmeContent);
+        if (!context.package.description && context.readme.description) {
+          context.package.description = context.readme.description;
+        }
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/core/tokens.ts
+var CHARS_PER_TOKEN = {
+  /** English prose: ~4 chars per token */
+  prose: 4,
+  /** Code blocks: ~3 chars per token (more special tokens) */
+  code: 3};
+var PRIORITY_ORDER = {
+  functions: 100,
+  examples: 90,
+  classes: 80,
+  interfaces: 70,
+  types: 60,
+  readme: 50
+};
+function countTokens(text) {
+  if (!text) return 0;
+  let tokens = 0;
+  const codeBlockRegex = /```[\s\S]*?```/g;
+  const parts = [];
+  let lastIndex = 0;
+  let match;
+  while ((match = codeBlockRegex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push({
+        text: text.slice(lastIndex, match.index),
+        isCode: false
+      });
+    }
+    parts.push({
+      text: match[0],
+      isCode: true
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    parts.push({
+      text: text.slice(lastIndex),
+      isCode: false
+    });
+  }
+  for (const part of parts) {
+    const charsPerToken = part.isCode ? CHARS_PER_TOKEN.code : CHARS_PER_TOKEN.prose;
+    tokens += Math.ceil(part.text.length / charsPerToken);
+  }
+  return tokens;
+}
+function parseSections(text) {
+  const sections = [];
+  const lines = text.split("\n");
+  let currentSection = null;
+  let currentContent = [];
+  function finishSection() {
+    if (currentSection) {
+      currentSection.content = currentContent.join("\n").trim();
+      currentSection.tokens = countTokens(currentSection.content);
+      sections.push(currentSection);
+      currentContent = [];
+    }
+  }
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch && headingMatch[2]) {
+      finishSection();
+      const title = headingMatch[2].trim();
+      const priority = inferPriority(title);
+      currentSection = {
+        id: title.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+        title,
+        content: "",
+        priority,
+        tokens: 0
+      };
+      currentContent = [line];
+    } else if (currentSection) {
+      currentContent.push(line);
+    } else {
+      if (line.trim()) {
+        if (!currentSection) {
+          currentSection = {
+            id: "intro",
+            title: "Introduction",
+            content: "",
+            priority: "readme",
+            tokens: 0
+          };
+        }
+        currentContent.push(line);
+      }
+    }
+  }
+  finishSection();
+  return sections;
+}
+function inferPriority(title) {
+  const lower = title.toLowerCase();
+  if (lower.includes("function") || lower.includes("method") || lower.includes("api")) {
+    return "functions";
+  }
+  if (lower.includes("example") || lower.includes("usage") || lower.includes("quick start")) {
+    return "examples";
+  }
+  if (lower.includes("class")) {
+    return "classes";
+  }
+  if (lower.includes("interface")) {
+    return "interfaces";
+  }
+  if (lower.includes("type")) {
+    return "types";
+  }
+  return "readme";
+}
+function prioritizeSections(sections, priorities = ["functions", "examples"]) {
+  const customOrder = { ...PRIORITY_ORDER };
+  priorities.forEach((p, i) => {
+    customOrder[p] = 1e3 - i;
+  });
+  return [...sections].sort((a, b) => {
+    return (customOrder[b.priority] ?? 0) - (customOrder[a.priority] ?? 0);
+  });
+}
+function truncateToTokenLimit(text, limit, priorities = ["functions", "examples"]) {
+  const currentTokens = countTokens(text);
+  if (currentTokens <= limit) {
+    return {
+      text,
+      truncated: false,
+      tokenCount: currentTokens,
+      includedSections: [],
+      removedSections: []
+    };
+  }
+  const sections = parseSections(text);
+  const prioritized = prioritizeSections(sections, priorities);
+  const included = [];
+  const removed = [];
+  let usedTokens = 0;
+  for (const section of prioritized) {
+    if (usedTokens + section.tokens <= limit) {
+      included.push(section);
+      usedTokens += section.tokens;
+    } else {
+      const remaining = limit - usedTokens;
+      if (remaining > 50 && section.tokens > 0) {
+        const truncated = truncateSectionContent(section, remaining);
+        if (truncated) {
+          included.push(truncated);
+          usedTokens += truncated.tokens;
+        }
+      }
+      removed.push(section);
+    }
+  }
+  const sectionOrder = sections.map((s) => s.id);
+  included.sort((a, b) => sectionOrder.indexOf(a.id) - sectionOrder.indexOf(b.id));
+  const output = included.map((s) => s.content).join("\n\n");
+  return {
+    text: output.trim(),
+    truncated: true,
+    tokenCount: countTokens(output),
+    includedSections: included.map((s) => s.title),
+    removedSections: removed.map((s) => s.title)
+  };
+}
+function truncateSectionContent(section, maxTokens) {
+  const lines = section.content.split("\n");
+  const truncatedLines = [];
+  let tokens = 0;
+  for (const line of lines) {
+    const lineTokens = countTokens(line);
+    if (tokens + lineTokens <= maxTokens) {
+      truncatedLines.push(line);
+      tokens += lineTokens;
+    } else {
+      break;
+    }
+  }
+  if (truncatedLines.length === 0) {
+    return null;
+  }
+  truncatedLines.push("\n...(truncated)");
+  return {
+    ...section,
+    content: truncatedLines.join("\n"),
+    tokens: countTokens(truncatedLines.join("\n"))
+  };
+}
+function formatTokenCount(tokens) {
+  if (tokens < 1e3) {
+    return `${tokens} tokens`;
+  }
+  return `${(tokens / 1e3).toFixed(1)}k tokens`;
+}
+
+// src/outputs/llms.ts
+var DEFAULT_LLMS_TOKEN_LIMIT = Infinity;
+function generateLlmsTxt(context, options = {}) {
+  const {
+    tokenLimit = DEFAULT_LLMS_TOKEN_LIMIT,
+    includeInstall = true,
+    includeQuickStart = true,
+    maxFunctions = Infinity,
+    maxClasses = Infinity
+  } = options;
+  const { package: pkg, api, readme } = context;
+  const sections = [];
+  sections.push(`# ${pkg.name}`);
+  if (pkg.description) {
+    sections.push(`
+> ${pkg.description}`);
+  }
+  sections.push("");
+  if (includeInstall) {
+    sections.push("## Install\n");
+    sections.push("```bash");
+    sections.push(`npm install ${pkg.name}`);
+    sections.push("```\n");
+  }
+  if (includeQuickStart && readme?.quickStart) {
+    sections.push("## Quick Start\n");
+    sections.push(readme.quickStart);
+    sections.push("");
+  }
+  sections.push("## API\n");
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const constants = api.filter((e) => e.kind === "constant");
+  if (functions.length > 0) {
+    sections.push("### Functions\n");
+    const limit = Math.min(functions.length, maxFunctions);
+    for (let i = 0; i < limit; i++) {
+      sections.push(formatFunctionBrief(functions[i]));
+    }
+    if (functions.length > maxFunctions && maxFunctions < Infinity) {
+      sections.push(`
+...and ${functions.length - maxFunctions} more functions.`);
+    }
+    sections.push("");
+  }
+  if (classes.length > 0) {
+    sections.push("### Classes\n");
+    const limit = Math.min(classes.length, maxClasses);
+    for (let i = 0; i < limit; i++) {
+      sections.push(formatClassBrief(classes[i]));
+    }
+    if (classes.length > maxClasses && maxClasses < Infinity) {
+      sections.push(`
+...and ${classes.length - maxClasses} more classes.`);
+    }
+    sections.push("");
+  }
+  if (interfaces.length > 0 || types.length > 0) {
+    sections.push("### Types\n");
+    const allTypes = [...interfaces, ...types];
+    for (const t of allTypes) {
+      const desc = t.description ? ` - ${truncate(t.description, 80)}` : "";
+      sections.push(`- \`${t.name}\`${desc}`);
+    }
+    sections.push("");
+  }
+  if (constants.length > 0) {
+    sections.push("### Constants\n");
+    for (const c of constants) {
+      const desc = c.description ? ` - ${truncate(c.description, 80)}` : "";
+      sections.push(`- \`${c.name}\`${desc}`);
+    }
+    sections.push("");
+  }
+  let output = sections.join("\n");
+  const currentTokens = countTokens(output);
+  if (currentTokens > tokenLimit) {
+    const result = truncateToTokenLimit(output, tokenLimit, ["functions", "examples"]);
+    output = result.text;
+    context.truncated = result.truncated;
+  }
+  context.tokenCount = countTokens(output);
+  return output;
+}
+function formatFunctionBrief(fn) {
+  const params = fn.params?.map((p) => `${p.name}${p.optional ? "?" : ""}`).join(", ") || "";
+  const returnType = fn.returns?.type ? `: ${simplifyType(fn.returns.type)}` : "";
+  const desc = fn.description ? ` - ${truncate(fn.description, 60)}` : "";
+  return `- \`${fn.name}(${params})${returnType}\`${desc}`;
+}
+function formatClassBrief(cls) {
+  const lines = [];
+  const desc = cls.description ? ` - ${truncate(cls.description, 60)}` : "";
+  lines.push(`- \`${cls.name}\`${desc}`);
+  if (cls.methods && cls.methods.length > 0) {
+    const keyMethods = cls.methods.slice(0, 3);
+    for (const method of keyMethods) {
+      lines.push(`  - \`${method.name}()\``);
+    }
+    if (cls.methods.length > 3) {
+      lines.push(`  - ...${cls.methods.length - 3} more methods`);
+    }
+  }
+  return lines.join("\n");
+}
+function simplifyType(type) {
+  if (type.length > 30) {
+    const genericStart = type.indexOf("<");
+    if (genericStart > 0) {
+      return type.slice(0, genericStart) + "<...>";
+    }
+  }
+  return type;
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+
+// src/plugins/core/llms-output.ts
+var llmsOutputPlugin = {
+  name: "llms-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("llms")) {
+        return;
+      }
+      try {
+        const tokenLimit = context.options.llmsTokenLimit ?? DEFAULT_LLMS_TOKEN_LIMIT;
+        const output = generateLlmsTxt(context, {
+          tokenLimit,
+          includeInstall: true,
+          includeQuickStart: true
+        });
+        context.outputs.set("llms", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/outputs/llms-full.ts
+function generateLlmsFullTxt(context, options = {}) {
+  const {
+    includeExamples = true,
+    includeParamDescriptions = true,
+    includeSourceLocations = false,
+    includeDeprecations = true
+  } = options;
+  const { package: pkg, api, readme } = context;
+  const sections = [];
+  sections.push(`# ${pkg.name} v${pkg.version}`);
+  if (pkg.description) {
+    sections.push(`
+> ${pkg.description}`);
+  }
+  sections.push("");
+  sections.push("## Package Info\n");
+  sections.push(`- **Version:** ${pkg.version}`);
+  if (pkg.license) {
+    sections.push(`- **License:** ${pkg.license}`);
+  }
+  if (pkg.homepage) {
+    sections.push(`- **Homepage:** ${pkg.homepage}`);
+  }
+  if (pkg.repository) {
+    sections.push(`- **Repository:** ${pkg.repository.url}`);
+  }
+  sections.push("");
+  sections.push("## Installation\n");
+  sections.push("```bash");
+  sections.push(`# npm`);
+  sections.push(`npm install ${pkg.name}`);
+  sections.push("");
+  sections.push(`# yarn`);
+  sections.push(`yarn add ${pkg.name}`);
+  sections.push("");
+  sections.push(`# pnpm`);
+  sections.push(`pnpm add ${pkg.name}`);
+  sections.push("```\n");
+  if (readme?.quickStart) {
+    sections.push("## Quick Start\n");
+    sections.push(readme.quickStart);
+    sections.push("");
+  }
+  sections.push("## API Reference\n");
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const constants = api.filter((e) => e.kind === "constant");
+  const enums = api.filter((e) => e.kind === "enum");
+  if (functions.length > 0) {
+    sections.push("### Functions\n");
+    for (const fn of functions) {
+      sections.push(formatFunction(fn, { includeExamples, includeParamDescriptions, includeDeprecations, includeSourceLocations }));
+      sections.push("");
+    }
+  }
+  if (classes.length > 0) {
+    sections.push("### Classes\n");
+    for (const cls of classes) {
+      sections.push(formatClass(cls, { includeExamples, includeDeprecations}));
+      sections.push("");
+    }
+  }
+  if (interfaces.length > 0) {
+    sections.push("### Interfaces\n");
+    for (const iface of interfaces) {
+      sections.push(formatInterface(iface, { includeDeprecations}));
+      sections.push("");
+    }
+  }
+  if (types.length > 0) {
+    sections.push("### Types\n");
+    for (const type of types) {
+      sections.push(formatType(type, { includeDeprecations }));
+      sections.push("");
+    }
+  }
+  if (enums.length > 0) {
+    sections.push("### Enums\n");
+    for (const enumEntry of enums) {
+      sections.push(formatEnum(enumEntry));
+      sections.push("");
+    }
+  }
+  if (constants.length > 0) {
+    sections.push("### Constants\n");
+    for (const constant of constants) {
+      sections.push(formatConstant(constant));
+      sections.push("");
+    }
+  }
+  const output = sections.join("\n");
+  context.tokenCount = countTokens(output);
+  return output;
+}
+function formatFunction(fn, options) {
+  const lines = [];
+  lines.push(`#### \`${fn.name}\``);
+  if (options.includeDeprecations && fn.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated:** ${typeof fn.deprecated === "string" ? fn.deprecated : "This function is deprecated."}`);
+  }
+  if (fn.description) {
+    lines.push(`
+${fn.description}`);
+  }
+  lines.push("\n**Signature:**");
+  lines.push("```typescript");
+  lines.push(fn.signature);
+  lines.push("```");
+  if (fn.params && fn.params.length > 0 && options.includeParamDescriptions) {
+    lines.push("\n**Parameters:**\n");
+    for (const param of fn.params) {
+      const optional = param.optional ? " (optional)" : "";
+      const defaultVal = param.defaultValue ? ` = \`${param.defaultValue}\`` : "";
+      lines.push(`- \`${param.name}: ${param.type || "unknown"}\`${optional}${defaultVal}`);
+      if (param.description) {
+        lines.push(`  - ${param.description}`);
+      }
+    }
+  }
+  if (fn.returns) {
+    lines.push("\n**Returns:**");
+    lines.push(`- \`${fn.returns.type}\`${fn.returns.description ? ` - ${fn.returns.description}` : ""}`);
+  }
+  if (options.includeExamples && fn.examples && fn.examples.length > 0) {
+    lines.push("\n**Examples:**");
+    for (const example of fn.examples) {
+      if (example.includes("```")) {
+        lines.push(example);
+      } else {
+        lines.push("```typescript");
+        lines.push(example);
+        lines.push("```");
+      }
+    }
+  }
+  if (options.includeSourceLocations && fn.sourceFile) {
+    lines.push(`
+*Source: ${fn.sourceFile}${fn.line ? `:${fn.line}` : ""}*`);
+  }
+  return lines.join("\n");
+}
+function formatClass(cls, options) {
+  const lines = [];
+  lines.push(`#### \`${cls.name}\``);
+  if (options.includeDeprecations && cls.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated:** ${typeof cls.deprecated === "string" ? cls.deprecated : "This class is deprecated."}`);
+  }
+  if (cls.description) {
+    lines.push(`
+${cls.description}`);
+  }
+  lines.push("\n**Signature:**");
+  lines.push("```typescript");
+  let sig = cls.signature;
+  if (cls.extends && cls.extends.length > 0) {
+    sig += ` extends ${cls.extends.join(", ")}`;
+  }
+  if (cls.implements && cls.implements.length > 0) {
+    sig += ` implements ${cls.implements.join(", ")}`;
+  }
+  lines.push(sig);
+  lines.push("```");
+  if (cls.properties && cls.properties.length > 0) {
+    lines.push("\n**Properties:**\n");
+    for (const prop of cls.properties) {
+      lines.push(`- \`${prop.name}\`: \`${prop.signature.split(":").slice(1).join(":").trim() || "unknown"}\``);
+      if (prop.description) {
+        lines.push(`  - ${prop.description}`);
+      }
+    }
+  }
+  if (cls.methods && cls.methods.length > 0) {
+    lines.push("\n**Methods:**\n");
+    for (const method of cls.methods) {
+      const params = method.params?.map((p) => `${p.name}: ${p.type || "unknown"}`).join(", ") || "";
+      const returnType = method.returns?.type || "void";
+      lines.push(`- \`${method.name}(${params}): ${returnType}\``);
+      if (method.description) {
+        lines.push(`  - ${method.description}`);
+      }
+    }
+  }
+  if (options.includeExamples && cls.examples && cls.examples.length > 0) {
+    lines.push("\n**Examples:**");
+    for (const example of cls.examples) {
+      if (example.includes("```")) {
+        lines.push(example);
+      } else {
+        lines.push("```typescript");
+        lines.push(example);
+        lines.push("```");
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatInterface(iface, options) {
+  const lines = [];
+  lines.push(`#### \`${iface.name}\``);
+  if (options.includeDeprecations && iface.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated**`);
+  }
+  if (iface.description) {
+    lines.push(`
+${iface.description}`);
+  }
+  lines.push("\n```typescript");
+  let sig = iface.signature;
+  if (iface.extends && iface.extends.length > 0) {
+    sig += ` extends ${iface.extends.join(", ")}`;
+  }
+  lines.push(sig + " {");
+  if (iface.properties && iface.properties.length > 0) {
+    for (const prop of iface.properties) {
+      lines.push(`  ${prop.signature};`);
+    }
+  }
+  if (iface.methods && iface.methods.length > 0) {
+    for (const method of iface.methods) {
+      lines.push(`  ${method.signature};`);
+    }
+  }
+  lines.push("}");
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatType(type, options) {
+  const lines = [];
+  lines.push(`#### \`${type.name}\``);
+  if (options.includeDeprecations && type.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated**`);
+  }
+  if (type.description) {
+    lines.push(`
+${type.description}`);
+  }
+  lines.push("\n```typescript");
+  lines.push(type.signature);
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatEnum(enumEntry) {
+  const lines = [];
+  lines.push(`#### \`${enumEntry.name}\``);
+  if (enumEntry.description) {
+    lines.push(`
+${enumEntry.description}`);
+  }
+  lines.push("\n```typescript");
+  lines.push(`enum ${enumEntry.name} {`);
+  if (enumEntry.members) {
+    for (const member of enumEntry.members) {
+      if (member.value !== void 0) {
+        lines.push(`  ${member.name} = ${JSON.stringify(member.value)},`);
+      } else {
+        lines.push(`  ${member.name},`);
+      }
+    }
+  }
+  lines.push("}");
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatConstant(constant) {
+  const lines = [];
+  lines.push(`#### \`${constant.name}\``);
+  if (constant.description) {
+    lines.push(`
+${constant.description}`);
+  }
+  lines.push("\n```typescript");
+  lines.push(constant.signature);
+  lines.push("```");
+  return lines.join("\n");
+}
+
+// src/plugins/core/llms-full-output.ts
+var llmsFullOutputPlugin = {
+  name: "llms-full-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("llms-full")) {
+        return;
+      }
+      try {
+        const output = generateLlmsFullTxt(context, {
+          includeExamples: true,
+          includeParamDescriptions: true,
+          includeDeprecations: true
+        });
+        context.outputs.set("llms-full", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/outputs/markdown.ts
+function generateMarkdown(context, options = {}) {
+  const {
+    includeToc = true,
+    includeParamTables = true,
+    includeBadges = true,
+    repositoryUrl
+  } = options;
+  const { package: pkg, api, readme } = context;
+  const sections = [];
+  sections.push(`# ${pkg.name}`);
+  sections.push("");
+  if (includeBadges) {
+    const badges = [];
+    badges.push(`![npm version](https://img.shields.io/npm/v/${encodeURIComponent(pkg.name)})`);
+    if (pkg.license) {
+      badges.push(`![license](https://img.shields.io/npm/l/${encodeURIComponent(pkg.name)})`);
+    }
+    if (badges.length > 0) {
+      sections.push(badges.join(" "));
+      sections.push("");
+    }
+  }
+  if (pkg.description) {
+    sections.push(`> ${pkg.description}`);
+    sections.push("");
+  }
+  if (includeToc) {
+    sections.push("## Table of Contents\n");
+    sections.push("- [Installation](#installation)");
+    if (readme?.quickStart) {
+      sections.push("- [Quick Start](#quick-start)");
+    }
+    sections.push("- [API Reference](#api-reference)");
+    const functions2 = api.filter((e) => e.kind === "function");
+    const classes2 = api.filter((e) => e.kind === "class");
+    const interfaces2 = api.filter((e) => e.kind === "interface");
+    const types2 = api.filter((e) => e.kind === "type");
+    if (functions2.length > 0) {
+      sections.push("  - [Functions](#functions)");
+    }
+    if (classes2.length > 0) {
+      sections.push("  - [Classes](#classes)");
+    }
+    if (interfaces2.length > 0) {
+      sections.push("  - [Interfaces](#interfaces)");
+    }
+    if (types2.length > 0) {
+      sections.push("  - [Types](#types)");
+    }
+    sections.push("");
+  }
+  sections.push("## Installation\n");
+  sections.push("```bash");
+  sections.push(`npm install ${pkg.name}`);
+  sections.push("```\n");
+  sections.push("Or with yarn:\n");
+  sections.push("```bash");
+  sections.push(`yarn add ${pkg.name}`);
+  sections.push("```\n");
+  if (readme?.quickStart) {
+    sections.push("## Quick Start\n");
+    sections.push(readme.quickStart);
+    sections.push("");
+  }
+  sections.push("## API Reference\n");
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const enums = api.filter((e) => e.kind === "enum");
+  const constants = api.filter((e) => e.kind === "constant");
+  if (functions.length > 0) {
+    sections.push("### Functions\n");
+    for (const fn of functions) {
+      sections.push(formatFunctionMd(fn, { includeParamTables, repositoryUrl }));
+      sections.push("");
+      sections.push("---\n");
+    }
+  }
+  if (classes.length > 0) {
+    sections.push("### Classes\n");
+    for (const cls of classes) {
+      sections.push(formatClassMd(cls));
+      sections.push("");
+      sections.push("---\n");
+    }
+  }
+  if (interfaces.length > 0) {
+    sections.push("### Interfaces\n");
+    for (const iface of interfaces) {
+      sections.push(formatInterfaceMd(iface));
+      sections.push("");
+      sections.push("---\n");
+    }
+  }
+  if (types.length > 0) {
+    sections.push("### Types\n");
+    for (const type of types) {
+      sections.push(formatTypeMd(type));
+      sections.push("");
+    }
+  }
+  if (enums.length > 0) {
+    sections.push("### Enums\n");
+    for (const enumEntry of enums) {
+      sections.push(formatEnumMd(enumEntry));
+      sections.push("");
+    }
+  }
+  if (constants.length > 0) {
+    sections.push("### Constants\n");
+    for (const constant of constants) {
+      sections.push(formatConstantMd(constant));
+    }
+    sections.push("");
+  }
+  const output = sections.join("\n");
+  context.tokenCount = countTokens(output);
+  return output;
+}
+function formatFunctionMd(fn, options) {
+  const lines = [];
+  const anchor = fn.name.toLowerCase();
+  lines.push(`<a name="${anchor}"></a>`);
+  lines.push(`#### \`${fn.name}()\``);
+  if (fn.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated:** ${typeof fn.deprecated === "string" ? fn.deprecated : "This function is deprecated."}
+`);
+  }
+  if (fn.description) {
+    lines.push(`
+${fn.description}
+`);
+  }
+  lines.push("**Signature:**\n");
+  lines.push("```typescript");
+  lines.push(fn.signature);
+  lines.push("```\n");
+  if (fn.params && fn.params.length > 0 && options.includeParamTables) {
+    lines.push("**Parameters:**\n");
+    lines.push("| Name | Type | Required | Description |");
+    lines.push("|------|------|----------|-------------|");
+    for (const param of fn.params) {
+      const required = param.optional ? "No" : "Yes";
+      const desc = param.description || "-";
+      const defaultVal = param.defaultValue ? ` (default: \`${param.defaultValue}\`)` : "";
+      lines.push(`| \`${param.name}\` | \`${param.type || "unknown"}\` | ${required} | ${desc}${defaultVal} |`);
+    }
+    lines.push("");
+  }
+  if (fn.returns) {
+    lines.push("**Returns:**\n");
+    lines.push(`\`${fn.returns.type}\`${fn.returns.description ? ` - ${fn.returns.description}` : ""}
+`);
+  }
+  if (fn.examples && fn.examples.length > 0) {
+    lines.push("**Example:**\n");
+    for (const example of fn.examples) {
+      if (example.includes("```")) {
+        lines.push(example);
+      } else {
+        lines.push("```typescript");
+        lines.push(example);
+        lines.push("```");
+      }
+    }
+    lines.push("");
+  }
+  if (options.repositoryUrl && fn.sourceFile) {
+    const sourceUrl = `${options.repositoryUrl}/blob/main/${fn.sourceFile}${fn.line ? `#L${fn.line}` : ""}`;
+    lines.push(`[View source](${sourceUrl})
+`);
+  }
+  return lines.join("\n");
+}
+function formatClassMd(cls, options) {
+  const lines = [];
+  const anchor = cls.name.toLowerCase();
+  lines.push(`<a name="${anchor}"></a>`);
+  lines.push(`#### \`${cls.name}\``);
+  if (cls.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated**
+`);
+  }
+  if (cls.description) {
+    lines.push(`
+${cls.description}
+`);
+  }
+  if (cls.extends && cls.extends.length > 0) {
+    lines.push(`**Extends:** ${cls.extends.map((e) => `\`${e}\``).join(", ")}
+`);
+  }
+  if (cls.implements && cls.implements.length > 0) {
+    lines.push(`**Implements:** ${cls.implements.map((e) => `\`${e}\``).join(", ")}
+`);
+  }
+  const constructor = cls.methods?.find((m) => m.name === "constructor");
+  if (constructor) {
+    lines.push("**Constructor:**\n");
+    lines.push("```typescript");
+    lines.push(`new ${cls.name}(${constructor.params?.map((p) => `${p.name}: ${p.type}`).join(", ") || ""})`);
+    lines.push("```\n");
+  }
+  if (cls.properties && cls.properties.length > 0) {
+    lines.push("**Properties:**\n");
+    lines.push("| Name | Type | Description |");
+    lines.push("|------|------|-------------|");
+    for (const prop of cls.properties) {
+      const type = prop.signature.split(":").slice(1).join(":").trim() || "unknown";
+      lines.push(`| \`${prop.name}\` | \`${type}\` | ${prop.description || "-"} |`);
+    }
+    lines.push("");
+  }
+  const methods = cls.methods?.filter((m) => m.name !== "constructor") || [];
+  if (methods.length > 0) {
+    lines.push("**Methods:**\n");
+    lines.push("| Method | Returns | Description |");
+    lines.push("|--------|---------|-------------|");
+    for (const method of methods) {
+      const params = method.params?.map((p) => `${p.name}`).join(", ") || "";
+      const returnType = method.returns?.type || "void";
+      lines.push(`| \`${method.name}(${params})\` | \`${returnType}\` | ${method.description || "-"} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatInterfaceMd(iface) {
+  const lines = [];
+  lines.push(`#### \`${iface.name}\``);
+  if (iface.description) {
+    lines.push(`
+${iface.description}
+`);
+  }
+  if (iface.extends && iface.extends.length > 0) {
+    lines.push(`**Extends:** ${iface.extends.map((e) => `\`${e}\``).join(", ")}
+`);
+  }
+  if (iface.properties && iface.properties.length > 0) {
+    lines.push("| Property | Type | Description |");
+    lines.push("|----------|------|-------------|");
+    for (const prop of iface.properties) {
+      const type = prop.signature.split(":").slice(1).join(":").trim() || "unknown";
+      lines.push(`| \`${prop.name}\` | \`${type}\` | ${prop.description || "-"} |`);
+    }
+    lines.push("");
+  }
+  lines.push("<details>");
+  lines.push("<summary>Full Definition</summary>\n");
+  lines.push("```typescript");
+  lines.push(`interface ${iface.name} {`);
+  if (iface.properties) {
+    for (const prop of iface.properties) {
+      lines.push(`  ${prop.signature};`);
+    }
+  }
+  if (iface.methods) {
+    for (const method of iface.methods) {
+      lines.push(`  ${method.signature};`);
+    }
+  }
+  lines.push("}");
+  lines.push("```");
+  lines.push("</details>");
+  return lines.join("\n");
+}
+function formatTypeMd(type) {
+  const lines = [];
+  lines.push(`#### \`${type.name}\``);
+  if (type.description) {
+    lines.push(`
+${type.description}
+`);
+  }
+  lines.push("```typescript");
+  lines.push(type.signature);
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatEnumMd(enumEntry) {
+  const lines = [];
+  lines.push(`#### \`${enumEntry.name}\``);
+  if (enumEntry.description) {
+    lines.push(`
+${enumEntry.description}
+`);
+  }
+  if (enumEntry.members && enumEntry.members.length > 0) {
+    lines.push("| Member | Value |");
+    lines.push("|--------|-------|");
+    for (const member of enumEntry.members) {
+      const value = member.value !== void 0 ? `\`${JSON.stringify(member.value)}\`` : "-";
+      lines.push(`| \`${member.name}\` | ${value} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatConstantMd(constant) {
+  const lines = [];
+  lines.push(`- **\`${constant.name}\`**: \`${constant.signature.split(":").slice(1).join(":").trim() || "unknown"}\``);
+  if (constant.description) {
+    lines.push(`  - ${constant.description}`);
+  }
+  return lines.join("\n");
+}
+
+// src/plugins/core/markdown-output.ts
+var markdownOutputPlugin = {
+  name: "markdown-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("markdown")) {
+        return;
+      }
+      try {
+        const repositoryUrl = context.package.repository?.url?.replace(/^git\+/, "").replace(/\.git$/, "");
+        const output = generateMarkdown(context, {
+          includeToc: true,
+          includeParamTables: true,
+          includeBadges: true,
+          repositoryUrl
+        });
+        context.outputs.set("markdown", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/outputs/json.ts
+function generateJson(context, options = {}) {
+  const { pretty = true, includeEmpty = false, includeSourceLocations = true } = options;
+  const output = generateJsonObject(context, { includeEmpty, includeSourceLocations });
+  return pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+}
+function generateJsonObject(context, options = {}) {
+  const { includeEmpty = false, includeSourceLocations = true } = options;
+  const { package: pkg, api } = context;
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const enums = api.filter((e) => e.kind === "enum");
+  const constants = api.filter((e) => e.kind === "constant");
+  const documented = api.filter((e) => e.description).length;
+  const withExamples = api.filter((e) => e.examples && e.examples.length > 0).length;
+  const output = {
+    $schema: "https://npm-llms.oxog.dev/schema/v1.json",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    package: {
+      name: pkg.name,
+      version: pkg.version,
+      description: pkg.description,
+      license: pkg.license,
+      homepage: pkg.homepage,
+      repository: pkg.repository?.url,
+      keywords: pkg.keywords
+    },
+    api: {
+      functions: functions.map((fn) => transformFunction(fn, includeSourceLocations)),
+      classes: classes.map((cls) => transformClass(cls, includeSourceLocations)),
+      interfaces: interfaces.map(transformInterface),
+      types: types.map(transformType),
+      enums: enums.map(transformEnum),
+      constants: constants.map(transformConstant)
+    },
+    stats: {
+      totalExports: api.length,
+      functions: functions.length,
+      classes: classes.length,
+      interfaces: interfaces.length,
+      types: types.length,
+      enums: enums.length,
+      constants: constants.length,
+      documented,
+      withExamples
+    }
+  };
+  if (!includeEmpty) {
+    const apiObj = output.api;
+    for (const [key, value] of Object.entries(apiObj)) {
+      if (Array.isArray(value) && value.length === 0) {
+        delete apiObj[key];
+      }
+    }
+  }
+  return output;
+}
+function transformFunction(entry, includeSource) {
+  const result = {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    params: (entry.params || []).map((p) => ({
+      name: p.name,
+      type: p.type || "unknown",
+      optional: p.optional ?? false,
+      defaultValue: p.defaultValue,
+      description: p.description
+    })),
+    returns: entry.returns ? {
+      type: entry.returns.type,
+      description: entry.returns.description
+    } : void 0,
+    examples: entry.examples || [],
+    deprecated: entry.deprecated,
+    since: entry.since,
+    see: entry.see
+  };
+  if (includeSource) {
+    result.sourceFile = entry.sourceFile;
+    result.line = entry.line;
+  }
+  return result;
+}
+function transformClass(entry, includeSource) {
+  const result = {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    extends: entry.extends,
+    implements: entry.implements,
+    typeParams: entry.typeParams,
+    properties: (entry.properties || []).map((p) => ({
+      name: p.name,
+      type: p.signature.split(":").slice(1).join(":").trim() || "unknown",
+      description: p.description
+    })),
+    methods: (entry.methods || []).map((m) => transformFunction(m, includeSource)),
+    deprecated: entry.deprecated
+  };
+  if (includeSource) {
+    result.sourceFile = entry.sourceFile;
+  }
+  return result;
+}
+function transformInterface(entry) {
+  return {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    extends: entry.extends,
+    typeParams: entry.typeParams,
+    properties: (entry.properties || []).map((p) => ({
+      name: p.name,
+      type: p.signature.split(":").slice(1).join(":").trim() || "unknown",
+      optional: p.signature.includes("?:"),
+      description: p.description
+    })),
+    methods: (entry.methods || []).map((m) => ({
+      name: m.name,
+      signature: m.signature,
+      description: m.description
+    })),
+    deprecated: entry.deprecated
+  };
+}
+function transformType(entry) {
+  return {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    typeParams: entry.typeParams,
+    deprecated: entry.deprecated
+  };
+}
+function transformEnum(entry) {
+  return {
+    name: entry.name,
+    description: entry.description,
+    members: entry.members || []
+  };
+}
+function transformConstant(entry) {
+  return {
+    name: entry.name,
+    type: entry.signature.split(":").slice(1).join(":").trim() || "unknown",
+    description: entry.description
+  };
+}
+
+// src/plugins/core/json-output.ts
+var jsonOutputPlugin = {
+  name: "json-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("json")) {
+        return;
+      }
+      try {
+        const output = generateJson(context, {
+          pretty: true,
+          includeEmpty: false,
+          includeSourceLocations: true
+        });
+        context.outputs.set("json", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/plugins/core/index.ts
+var coreParserPlugins = [
+  typesResolverPlugin,
+  dtsParserPlugin,
+  tsSourceParserPlugin,
+  readmeParserPlugin
+];
+var coreOutputPlugins = [
+  llmsOutputPlugin,
+  llmsFullOutputPlugin,
+  markdownOutputPlugin,
+  jsonOutputPlugin
+];
+var corePlugins = [
+  ...coreParserPlugins,
+  ...coreOutputPlugins
+];
+
+// src/core/extractor.ts
+var DEFAULT_FORMATS = ["llms", "llms-full", "markdown", "json"];
+function createExtractor(options = {}) {
+  const kernel = createKernel();
+  const cache = createCache(options.cache);
+  for (const plugin of corePlugins) {
+    kernel.use(plugin);
+  }
+  if (options.plugins) {
+    for (const plugin of options.plugins) {
+      kernel.use(plugin);
+    }
+  }
+  async function extract2(packageSpec, extractOptions = {}) {
+    const startTime = Date.now();
+    const { name, version } = parsePackageSpec(packageSpec);
+    const cacheKey = buildPackageCacheKey(name, version ?? "latest", "result");
+    let fromCache = false;
+    if (cache && !extractOptions.ignoreCache) {
+      const cached = await cache.get(cacheKey);
+      if (cached) {
+        return {
+          ...cached,
+          fromCache: true
+        };
+      }
+    }
+    const pkg = await fetchPackage(packageSpec, {
+      registry: options.registry,
+      timeout: options.ai?.timeout
+    });
+    const context = createContext(pkg, extractOptions);
+    await kernel.emit("package:fetched", context);
+    await kernel.emit("parse:start", context);
+    await kernel.emit("parse:complete", context);
+    if (extractOptions.enrichWithAI && options.ai) {
+      await kernel.emit("enrich:start", context);
+      await kernel.emit("enrich:complete", context);
+    }
+    await kernel.emit("output:start", context);
+    await kernel.emit("output:complete", context);
+    const result = {
+      package: {
+        name: pkg.name,
+        version: pkg.version,
+        description: pkg.description,
+        tarball: pkg.tarball,
+        types: pkg.types,
+        main: pkg.main,
+        exports: pkg.exports,
+        repository: pkg.repository,
+        keywords: pkg.keywords,
+        author: pkg.author,
+        license: pkg.license,
+        homepage: pkg.homepage
+      },
+      api: context.api,
+      outputs: Object.fromEntries(context.outputs),
+      tokenCount: context.tokenCount,
+      truncated: context.truncated,
+      duration: Date.now() - startTime,
+      fromCache
+    };
+    if (cache && !extractOptions.ignoreCache) {
+      await cache.set(cacheKey, result);
+    }
+    return result;
+  }
+  async function fetchOnly(packageSpec) {
+    return fetchPackage(packageSpec, {
+      registry: options.registry
+    });
+  }
+  function use(plugin) {
+    kernel.use(plugin);
+    return extractor;
+  }
+  function unregister(name) {
+    return kernel.unregister(name);
+  }
+  function listPlugins() {
+    return kernel.listPlugins();
+  }
+  async function clearCache() {
+    if (cache) {
+      await cache.clear();
+    }
+  }
+  async function getCacheStats() {
+    if (cache) {
+      return cache.getStats();
+    }
+    return { entries: 0, size: 0, dir: "" };
+  }
+  const extractor = {
+    extract: extract2,
+    fetch: fetchOnly,
+    use,
+    unregister,
+    listPlugins,
+    clearCache,
+    getCacheStats
+  };
+  return extractor;
+}
+function createContext(pkg, options) {
+  return {
+    package: pkg,
+    api: [],
+    readme: void 0,
+    changelog: void 0,
+    options: {
+      formats: options.formats ?? DEFAULT_FORMATS,
+      enrichWithAI: options.enrichWithAI ?? false,
+      aiTasks: options.aiTasks ?? ["descriptions", "examples", "summary"],
+      llmsTokenLimit: options.llmsTokenLimit ?? 2e3,
+      prioritize: options.prioritize ?? ["functions", "examples"],
+      ignoreCache: options.ignoreCache ?? false
+    },
+    outputs: /* @__PURE__ */ new Map(),
+    tokenCount: 0,
+    truncated: false,
+    startTime: Date.now(),
+    fromCache: false,
+    errors: []
+  };
+}
+async function extract(packageSpec, options) {
+  const extractor = createExtractor();
+  return extractor.extract(packageSpec, options);
+}
+
+exports.AIError = AIError;
+exports.CacheError = CacheError;
+exports.ConfigError = ConfigError;
+exports.DownloadError = DownloadError;
+exports.FileCache = FileCache;
+exports.NpmLlmsError = NpmLlmsError;
+exports.PackageNotFoundError = PackageNotFoundError;
+exports.ParseError = ParseError;
+exports.PluginError = PluginError;
+exports.TarError = TarError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+exports.VersionNotFoundError = VersionNotFoundError;
+exports.composePlugins = composePlugins;
+exports.countTokens = countTokens;
+exports.createCache = createCache;
+exports.createExtractor = createExtractor;
+exports.createKernel = createKernel;
+exports.definePlugin = definePlugin;
+exports.extract = extract;
+exports.fetchPackage = fetchPackage;
+exports.fetchPackageMetadata = fetchPackageMetadata;
+exports.formatBytes = formatBytes;
+exports.formatTokenCount = formatTokenCount;
+exports.getErrorCode = getErrorCode;
+exports.isNpmLlmsError = isNpmLlmsError;
+exports.parsePackageSpec = parsePackageSpec;
+exports.truncateToTokenLimit = truncateToTokenLimit;
+exports.validatePackageName = validatePackageName;
+exports.wrapError = wrapError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map