specra 0.1.0

package/dist/chunk-DR4EPLMT.mjs

@@ -0,0 +1,1013 @@
+// src/lib/category.ts
+import fs from "fs";
+import path from "path";
+var DOCS_DIR = path.join(process.cwd(), "docs");
+function getCategoryConfig(folderPath) {
+  try {
+    const categoryPath = path.join(folderPath, "_category_.json");
+    if (!fs.existsSync(categoryPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(categoryPath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Error reading category config from ${folderPath}:`, error);
+    return null;
+  }
+}
+function getAllCategoryConfigs(version) {
+  const configs = /* @__PURE__ */ new Map();
+  const versionDir = path.join(DOCS_DIR, version);
+  if (!fs.existsSync(versionDir)) {
+    return configs;
+  }
+  function scanDirectory(dir, relativePath = "") {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const fullPath = path.join(dir, entry.name);
+        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        const config = getCategoryConfig(fullPath);
+        if (config) {
+          configs.set(relPath, config);
+        }
+        scanDirectory(fullPath, relPath);
+      }
+    }
+  }
+  scanDirectory(versionDir);
+  return configs;
+}
+
+// src/lib/sidebar-utils.ts
+function sortSidebarItems(items) {
+  return [...items].sort((a, b) => {
+    const posA = a.sidebar_position ?? a.meta?.sidebar_position ?? a.meta?.order ?? 999;
+    const posB = b.sidebar_position ?? b.meta?.sidebar_position ?? b.meta?.order ?? 999;
+    return posA - posB;
+  });
+}
+function sortSidebarGroups(groups) {
+  return Object.entries(groups).sort(([, a], [, b]) => {
+    const posA = a.position ?? 999;
+    const posB = b.position ?? 999;
+    return posA - posB;
+  });
+}
+function buildSidebarStructure(docs) {
+  const rootGroups = {};
+  const standalone = [];
+  const categoryMetadata = /* @__PURE__ */ new Map();
+  docs.forEach((doc) => {
+    const pathParts = doc.filePath.split("/");
+    const folderPath = pathParts.length > 1 ? pathParts.slice(0, -1).join("/") : "";
+    if (folderPath && doc.categoryLabel) {
+      categoryMetadata.set(folderPath, {
+        label: doc.categoryLabel,
+        position: doc.categoryPosition,
+        icon: doc.categoryIcon,
+        collapsible: doc.categoryCollapsible,
+        collapsed: doc.categoryCollapsed
+      });
+    }
+  });
+  docs.forEach((doc) => {
+    const pathParts = doc.filePath.split("/");
+    const isIndexFile = doc.filePath.endsWith("/index") || doc.filePath === "index" || pathParts.length > 1 && doc.slug === pathParts.slice(0, -1).join("/");
+    const customGroup = doc.meta.sidebar || doc.meta.group;
+    if (customGroup) {
+      const groupName = customGroup.charAt(0).toUpperCase() + customGroup.slice(1);
+      if (!rootGroups[groupName]) {
+        rootGroups[groupName] = {
+          label: groupName,
+          path: customGroup,
+          items: [],
+          position: 999,
+          collapsible: doc.categoryCollapsible ?? true,
+          defaultCollapsed: doc.categoryCollapsed ?? false,
+          children: {}
+        };
+      }
+      if (isIndexFile) {
+        rootGroups[groupName].position = doc.categoryPosition ?? doc.meta.sidebar_position ?? 999;
+        rootGroups[groupName].icon = doc.categoryIcon;
+      } else {
+        rootGroups[groupName].items.push(doc);
+      }
+      return;
+    }
+    if (pathParts.length > 1) {
+      const folderParts = pathParts.slice(0, -1);
+      let currentLevel = rootGroups;
+      let currentPath = "";
+      for (let i = 0; i < folderParts.length; i++) {
+        const folder = folderParts[i];
+        currentPath = currentPath ? `${currentPath}/${folder}` : folder;
+        const folderLabel = folder.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+        const metadata = categoryMetadata.get(currentPath);
+        if (!currentLevel[folder]) {
+          currentLevel[folder] = {
+            label: metadata?.label ?? folderLabel,
+            path: currentPath,
+            icon: metadata?.icon,
+            items: [],
+            position: metadata?.position ?? 999,
+            collapsible: metadata?.collapsible ?? true,
+            defaultCollapsed: metadata?.collapsed ?? false,
+            children: {}
+          };
+        }
+        if (i === folderParts.length - 1) {
+          if (isIndexFile) {
+            currentLevel[folder].position = doc.categoryPosition ?? doc.meta.sidebar_position ?? currentLevel[folder].position;
+            if (doc.categoryLabel) {
+              currentLevel[folder].label = doc.categoryLabel;
+            }
+            if (doc.categoryIcon) {
+              currentLevel[folder].icon = doc.categoryIcon;
+            }
+            if (doc.categoryCollapsible !== void 0) {
+              currentLevel[folder].collapsible = doc.categoryCollapsible;
+            }
+            if (doc.categoryCollapsed !== void 0) {
+              currentLevel[folder].defaultCollapsed = doc.categoryCollapsed;
+            }
+          } else {
+            currentLevel[folder].items.push(doc);
+          }
+        }
+        currentLevel = currentLevel[folder].children;
+      }
+    } else {
+      if (!isIndexFile) {
+        standalone.push(doc);
+      }
+    }
+  });
+  return { rootGroups, standalone };
+}
+
+// src/lib/mdx.ts
+import fs2 from "fs";
+import path2 from "path";
+import matter from "gray-matter";
+var DOCS_DIR2 = path2.join(process.cwd(), "docs");
+function calculateReadingTime(content) {
+  const words = content.trim().split(/\s+/).length;
+  const minutes = Math.ceil(words / 200);
+  return { minutes, words };
+}
+function getVersions() {
+  try {
+    const versions = fs2.readdirSync(DOCS_DIR2);
+    return versions.filter((v) => fs2.statSync(path2.join(DOCS_DIR2, v)).isDirectory());
+  } catch (error) {
+    return ["v1.0.0"];
+  }
+}
+function findMdxFiles(dir, baseDir = dir) {
+  const files = [];
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...findMdxFiles(fullPath, baseDir));
+      } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
+        const relativePath = path2.relative(baseDir, fullPath).replace(/\\/g, "/");
+        files.push(relativePath);
+      }
+    }
+  } catch (error) {
+    console.error(`Error reading directory ${dir}:`, error);
+  }
+  return files;
+}
+function readDocFromFile(filePath, originalSlug) {
+  try {
+    if (!fs2.existsSync(filePath)) {
+      return null;
+    }
+    const fileContents = fs2.readFileSync(filePath, "utf8");
+    const { data, content } = matter(fileContents);
+    const { minutes, words } = calculateReadingTime(content);
+    let finalSlug = originalSlug;
+    if (data.slug) {
+      const customSlug = data.slug.replace(/^\//, "");
+      const parts = originalSlug.split("/");
+      if (parts.length > 1) {
+        parts[parts.length - 1] = customSlug;
+        finalSlug = parts.join("/");
+      } else {
+        finalSlug = customSlug;
+      }
+    }
+    return {
+      slug: finalSlug,
+      filePath: originalSlug,
+      // Keep original file path for sidebar
+      title: data.title || originalSlug,
+      meta: {
+        ...data,
+        content,
+        reading_time: minutes,
+        word_count: words
+      },
+      content
+    };
+  } catch (error) {
+    console.error(`Error reading file ${filePath}:`, error);
+    return null;
+  }
+}
+async function getDocBySlug(slug, version = "v1.0.0") {
+  try {
+    let filePath = path2.join(DOCS_DIR2, version, `${slug}.mdx`);
+    let doc = readDocFromFile(filePath, slug);
+    if (doc) return doc;
+    filePath = path2.join(DOCS_DIR2, version, slug, "index.mdx");
+    doc = readDocFromFile(filePath, slug);
+    if (doc) return doc;
+    const versionDir = path2.join(DOCS_DIR2, version);
+    if (!fs2.existsSync(versionDir)) {
+      return null;
+    }
+    const mdxFiles = findMdxFiles(versionDir);
+    for (const file of mdxFiles) {
+      const fileSlug = file.replace(/\.mdx$/, "");
+      const testPath = path2.join(versionDir, file.endsWith("index.mdx") ? file : `${fileSlug}.mdx`);
+      const testDoc = readDocFromFile(testPath, fileSlug);
+      if (testDoc && testDoc.slug === slug) {
+        return testDoc;
+      }
+    }
+    return null;
+  } catch (error) {
+    console.error(`Error reading doc ${slug}:`, error);
+    return null;
+  }
+}
+async function getAllDocs(version = "v1.0.0") {
+  try {
+    const versionDir = path2.join(DOCS_DIR2, version);
+    if (!fs2.existsSync(versionDir)) {
+      return [];
+    }
+    const mdxFiles = findMdxFiles(versionDir);
+    const categoryConfigs = getAllCategoryConfigs(version);
+    const docs = await Promise.all(
+      mdxFiles.map(async (file) => {
+        const originalFilePath = file.replace(/\.mdx$/, "");
+        let slug = originalFilePath;
+        if (file.endsWith("/index.mdx") || file === "index.mdx") {
+          slug = path2.dirname(file).replace(/\\/g, "/");
+          if (slug === ".") slug = "";
+        }
+        const doc = await getDocBySlug(slug, version);
+        if (doc) {
+          doc.filePath = originalFilePath;
+          const folderPath = path2.dirname(originalFilePath).replace(/\\/g, "/");
+          if (folderPath !== ".") {
+            const categoryConfig = categoryConfigs.get(folderPath);
+            if (categoryConfig) {
+              doc.categoryLabel = categoryConfig.label;
+              doc.categoryPosition = categoryConfig.position ?? categoryConfig.sidebar_position;
+              doc.categoryCollapsible = categoryConfig.collapsible;
+              doc.categoryCollapsed = categoryConfig.collapsed;
+              doc.categoryIcon = categoryConfig.icon;
+              doc.categoryTabGroup = categoryConfig.tab_group;
+            }
+          }
+        }
+        return doc;
+      })
+    );
+    const isDevelopment3 = process.env.NODE_ENV === "development";
+    const uniqueDocs = /* @__PURE__ */ new Map();
+    docs.filter((doc) => doc !== null).filter((doc) => isDevelopment3 || !doc.meta.draft).forEach((doc) => {
+      uniqueDocs.set(doc.slug, doc);
+    });
+    return Array.from(uniqueDocs.values()).sort((a, b) => {
+      const orderA = a.meta.sidebar_position ?? a.meta.order ?? 999;
+      const orderB = b.meta.sidebar_position ?? b.meta.order ?? 999;
+      return orderA - orderB;
+    });
+  } catch (error) {
+    console.error(`Error getting all docs for version ${version}:`, error);
+    return [];
+  }
+}
+function flattenSidebarOrder(rootGroups, standalone) {
+  const flatDocs = [];
+  const flattenGroup = (group) => {
+    const sortedChildren = sortSidebarGroups(group.children);
+    const sortedItems = sortSidebarItems(group.items);
+    const merged = [
+      ...sortedChildren.map(([, childGroup]) => ({
+        type: "group",
+        group: childGroup,
+        position: childGroup.position
+      })),
+      ...sortedItems.map((doc) => ({
+        type: "item",
+        doc,
+        position: doc.meta.sidebar_position ?? doc.meta.order ?? 999
+      }))
+    ];
+    merged.sort((a, b) => a.position - b.position);
+    merged.forEach((item) => {
+      if (item.type === "group") {
+        flattenGroup(item.group);
+      } else {
+        flatDocs.push(item.doc);
+      }
+    });
+  };
+  sortSidebarItems(standalone).forEach((doc) => {
+    flatDocs.push(doc);
+  });
+  const sortedRootGroups = sortSidebarGroups(rootGroups);
+  sortedRootGroups.forEach(([, group]) => {
+    flattenGroup(group);
+  });
+  return flatDocs;
+}
+function getAdjacentDocs(currentSlug, allDocs) {
+  const { rootGroups, standalone } = buildSidebarStructure(allDocs);
+  const orderedDocs = flattenSidebarOrder(rootGroups, standalone);
+  const currentIndex = orderedDocs.findIndex((doc) => doc.slug === currentSlug);
+  if (currentIndex === -1) {
+    return {};
+  }
+  const currentDoc = orderedDocs[currentIndex];
+  const currentTabGroup = currentDoc.meta?.tab_group || currentDoc.categoryTabGroup;
+  const filteredDocs = orderedDocs.filter((doc) => {
+    const docTabGroup = doc.meta?.tab_group || doc.categoryTabGroup;
+    if (currentTabGroup) {
+      return docTabGroup === currentTabGroup;
+    }
+    return !docTabGroup;
+  });
+  const filteredIndex = filteredDocs.findIndex((doc) => doc.slug === currentSlug);
+  if (filteredIndex === -1) {
+    return {};
+  }
+  return {
+    previous: filteredIndex > 0 ? filteredDocs[filteredIndex - 1] : void 0,
+    next: filteredIndex < filteredDocs.length - 1 ? filteredDocs[filteredIndex + 1] : void 0
+  };
+}
+function extractTableOfContents(content) {
+  const headingRegex = /^(#{2,3})\s+(.+)$/gm;
+  const toc = [];
+  let match;
+  while ((match = headingRegex.exec(content)) !== null) {
+    const level = match[1].length;
+    const text = match[2];
+    const id = text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-|-$/g, "");
+    toc.push({ id, title: text, level });
+  }
+  return toc;
+}
+function isCategoryPage(slug, allDocs) {
+  return allDocs.some((doc) => {
+    const parts = doc.slug.split("/");
+    const docParent = parts.slice(0, -1).join("/");
+    return docParent === slug && doc.slug !== slug;
+  });
+}
+
+// src/lib/dev-utils.ts
+var isDevelopment = process.env.NODE_ENV === "development";
+var PerfTimer = class {
+  constructor(label) {
+    this.label = label;
+    this.startTime = isDevelopment ? performance.now() : 0;
+  }
+  end() {
+    if (!isDevelopment) return;
+    const duration = performance.now() - this.startTime;
+    const color = duration > 1e3 ? "\x1B[31m" : duration > 500 ? "\x1B[33m" : "\x1B[32m";
+    const reset = "\x1B[0m";
+    console.log(`${color}\u23F1\uFE0F  ${this.label}: ${duration.toFixed(2)}ms${reset}`);
+  }
+};
+function logFsOperation(operation, path3, details) {
+  if (!isDevelopment) return;
+  console.log(`\u{1F4C1} [FS] ${operation}: ${path3}`, details || "");
+}
+function logCacheOperation(operation, key) {
+  if (!isDevelopment) return;
+  const emoji = operation === "hit" ? "\u2705" : operation === "miss" ? "\u274C" : "\u{1F504}";
+  console.log(`${emoji} [Cache] ${operation}: ${key}`);
+}
+function logMemoryUsage(label) {
+  if (!isDevelopment) return;
+  const used = process.memoryUsage();
+  const prefix = label ? `[${label}] ` : "";
+  console.log(`\u{1F4BE} ${prefix}Memory Usage:`, {
+    rss: `${Math.round(used.rss / 1024 / 1024)}MB`,
+    heapTotal: `${Math.round(used.heapTotal / 1024 / 1024)}MB`,
+    heapUsed: `${Math.round(used.heapUsed / 1024 / 1024)}MB`
+  });
+}
+function debugLog(label, data) {
+  if (!isDevelopment) return;
+  console.log(`
+\u{1F50D} ${label}:`);
+  console.dir(data, { depth: null, colors: true });
+  console.log("");
+}
+
+// src/lib/mdx-cache.ts
+import { watch } from "fs";
+import { join } from "path";
+var isDevelopment2 = process.env.NODE_ENV === "development";
+var versionsCache = {
+  data: null,
+  timestamp: 0
+};
+var allDocsCache = /* @__PURE__ */ new Map();
+var docBySlugCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = isDevelopment2 ? 5e3 : 6e4;
+var watchersInitialized = false;
+function initializeWatchers() {
+  if (!isDevelopment2 || watchersInitialized) return;
+  watchersInitialized = true;
+  const docsPath = join(process.cwd(), "docs");
+  try {
+    watch(docsPath, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      if (filename.endsWith(".mdx") || filename.endsWith(".json")) {
+        const parts = filename.split(/[/\\]/);
+        const version = parts[0];
+        allDocsCache.delete(version);
+        const cacheKeysToDelete = [];
+        docBySlugCache.forEach((_, key) => {
+          if (key.startsWith(`${version}:`)) {
+            cacheKeysToDelete.push(key);
+          }
+        });
+        cacheKeysToDelete.forEach((key) => docBySlugCache.delete(key));
+        if (eventType === "rename") {
+          versionsCache.data = null;
+        }
+        console.log(`[MDX Cache] Invalidated cache for: ${filename}`);
+      }
+    });
+    console.log("[MDX Cache] File watchers initialized");
+  } catch (error) {
+    console.error("[MDX Cache] Failed to initialize watchers:", error);
+  }
+}
+function isCacheValid(timestamp) {
+  return Date.now() - timestamp < CACHE_TTL;
+}
+function getCachedVersions() {
+  initializeWatchers();
+  if (versionsCache.data && isCacheValid(versionsCache.timestamp)) {
+    logCacheOperation("hit", "versions");
+    return versionsCache.data;
+  }
+  logCacheOperation("miss", "versions");
+  const timer = new PerfTimer("getVersions");
+  const versions = getVersions();
+  timer.end();
+  versionsCache.data = versions;
+  versionsCache.timestamp = Date.now();
+  return versions;
+}
+async function getCachedAllDocs(version = "v1.0.0") {
+  initializeWatchers();
+  const cached = allDocsCache.get(version);
+  if (cached && isCacheValid(cached.timestamp)) {
+    logCacheOperation("hit", `getAllDocs:${version}`);
+    return cached.data;
+  }
+  logCacheOperation("miss", `getAllDocs:${version}`);
+  const timer = new PerfTimer(`getAllDocs(${version})`);
+  const docs = await getAllDocs(version);
+  timer.end();
+  allDocsCache.set(version, {
+    data: docs,
+    timestamp: Date.now()
+  });
+  return docs;
+}
+async function getCachedDocBySlug(slug, version = "v1.0.0") {
+  initializeWatchers();
+  const cacheKey = `${version}:${slug}`;
+  const cached = docBySlugCache.get(cacheKey);
+  if (cached && isCacheValid(cached.timestamp)) {
+    logCacheOperation("hit", `getDocBySlug:${cacheKey}`);
+    return cached.data;
+  }
+  logCacheOperation("miss", `getDocBySlug:${cacheKey}`);
+  const timer = new PerfTimer(`getDocBySlug(${slug})`);
+  const doc = await getDocBySlug(slug, version);
+  timer.end();
+  docBySlugCache.set(cacheKey, {
+    data: doc,
+    timestamp: Date.now()
+  });
+  return doc;
+}
+function clearAllCaches() {
+  versionsCache.data = null;
+  allDocsCache.clear();
+  docBySlugCache.clear();
+  console.log("[MDX Cache] All caches cleared");
+}
+function getCacheStats() {
+  return {
+    versions: {
+      cached: versionsCache.data !== null,
+      age: versionsCache.timestamp ? Date.now() - versionsCache.timestamp : 0
+    },
+    allDocs: {
+      entries: allDocsCache.size,
+      versions: Array.from(allDocsCache.keys())
+    },
+    docBySlug: {
+      entries: docBySlugCache.size
+    }
+  };
+}
+
+// src/lib/parsers/specra-parser.ts
+var SpecraParser = class {
+  validate(input) {
+    return typeof input === "object" && input !== null && "endpoints" in input && Array.isArray(input.endpoints);
+  }
+  parse(input) {
+    if (!this.validate(input)) {
+      throw new Error("Invalid Specra API spec format");
+    }
+    return input;
+  }
+};
+
+// src/lib/parsers/openapi-parser.ts
+var OpenApiParser = class {
+  validate(input) {
+    return typeof input === "object" && input !== null && ("openapi" in input || "swagger" in input) && "paths" in input;
+  }
+  parse(input) {
+    if (!this.validate(input)) {
+      throw new Error("Invalid OpenAPI spec format");
+    }
+    const baseUrl = this.extractBaseUrl(input);
+    const endpoints = [];
+    for (const [path3, pathItem] of Object.entries(input.paths || {})) {
+      const methods = ["get", "post", "put", "patch", "delete"];
+      for (const method of methods) {
+        const operation = pathItem[method];
+        if (!operation) continue;
+        const endpoint = this.parseOperation(path3, method.toUpperCase(), operation, input);
+        endpoints.push(endpoint);
+      }
+    }
+    return {
+      version: input.info?.version,
+      title: input.info?.title,
+      description: input.info?.description,
+      baseUrl,
+      auth: this.extractAuth(input),
+      endpoints
+    };
+  }
+  extractBaseUrl(spec) {
+    if (spec.servers && spec.servers.length > 0) {
+      return spec.servers[0].url;
+    }
+    if (spec.host) {
+      const scheme = spec.schemes?.[0] || "https";
+      const basePath = spec.basePath || "";
+      return `${scheme}://${spec.host}${basePath}`;
+    }
+    return "";
+  }
+  extractAuth(spec) {
+    const securitySchemes = spec.components?.securitySchemes || spec.securityDefinitions;
+    if (!securitySchemes) return void 0;
+    const firstScheme = Object.values(securitySchemes)[0];
+    if (!firstScheme) return void 0;
+    if (firstScheme.type === "http" && firstScheme.scheme === "bearer") {
+      return {
+        type: "bearer",
+        description: firstScheme.description,
+        tokenPrefix: "Bearer"
+      };
+    }
+    if (firstScheme.type === "apiKey") {
+      return {
+        type: "apiKey",
+        description: firstScheme.description,
+        headerName: firstScheme.name || "X-API-Key"
+      };
+    }
+    if (firstScheme.type === "http" && firstScheme.scheme === "basic") {
+      return {
+        type: "basic",
+        description: firstScheme.description
+      };
+    }
+    return void 0;
+  }
+  parseOperation(path3, method, operation, spec) {
+    const endpoint = {
+      title: operation.summary || operation.operationId || `${method} ${path3}`,
+      method,
+      path: this.convertPathParams(path3),
+      description: operation.description
+    };
+    const params = this.parseParameters(operation.parameters || [], spec);
+    if (params.path.length > 0) endpoint.pathParams = params.path;
+    if (params.query.length > 0) endpoint.queryParams = params.query;
+    if (params.header.length > 0) {
+      endpoint.headers = params.header.map((p) => ({
+        name: p.name,
+        value: p.example || "",
+        description: p.description
+      }));
+    }
+    if (operation.requestBody) {
+      endpoint.body = this.parseRequestBody(operation.requestBody, spec);
+    }
+    const responses = this.parseResponses(operation.responses || {}, spec);
+    if (responses.success) endpoint.successResponse = responses.success;
+    if (responses.errors.length > 0) endpoint.errorResponses = responses.errors;
+    return endpoint;
+  }
+  convertPathParams(path3) {
+    return path3.replace(/\{([^}]+)\}/g, ":$1");
+  }
+  parseParameters(parameters, spec) {
+    const result = { path: [], query: [], header: [] };
+    for (const param of parameters) {
+      const resolved = param.$ref ? this.resolveRef(param.$ref, spec) : param;
+      const apiParam = {
+        name: resolved.name,
+        type: resolved.schema?.type || resolved.type || "string",
+        required: resolved.required,
+        description: resolved.description,
+        example: resolved.example || resolved.schema?.example
+      };
+      if (resolved.in === "path") result.path.push(apiParam);
+      else if (resolved.in === "query") result.query.push(apiParam);
+      else if (resolved.in === "header") result.header.push(apiParam);
+    }
+    return result;
+  }
+  parseRequestBody(requestBody, spec) {
+    const content = requestBody.content?.["application/json"];
+    if (!content) return void 0;
+    return {
+      description: requestBody.description,
+      example: content.example || this.generateExample(content.schema, spec),
+      schema: content.schema
+    };
+  }
+  parseResponses(responses, spec) {
+    const result = { errors: [] };
+    for (const [statusCode, response] of Object.entries(responses)) {
+      const status = parseInt(statusCode);
+      if (isNaN(status)) continue;
+      const resolved = response.$ref ? this.resolveRef(response.$ref, spec) : response;
+      const content = resolved.content?.["application/json"];
+      const apiResponse = {
+        status,
+        description: resolved.description,
+        example: content?.example || this.generateExample(content?.schema, spec),
+        schema: content?.schema
+      };
+      if (status >= 200 && status < 300) {
+        result.success = apiResponse;
+      } else {
+        result.errors.push(apiResponse);
+      }
+    }
+    return result;
+  }
+  generateExample(schema, spec) {
+    if (!schema) return void 0;
+    if (schema.$ref) schema = this.resolveRef(schema.$ref, spec);
+    if (schema.example) return schema.example;
+    if (schema.type === "object" && schema.properties) {
+      const example = {};
+      for (const [key, prop] of Object.entries(schema.properties)) {
+        example[key] = this.generateExample(prop, spec);
+      }
+      return example;
+    }
+    if (schema.type === "array" && schema.items) {
+      return [this.generateExample(schema.items, spec)];
+    }
+    const defaults = {
+      string: "string",
+      number: 0,
+      integer: 0,
+      boolean: false,
+      object: {},
+      array: []
+    };
+    return defaults[schema.type] || null;
+  }
+  resolveRef(ref, spec) {
+    const path3 = ref.replace(/^#\//, "").split("/");
+    let current = spec;
+    for (const segment of path3) {
+      current = current[segment];
+      if (!current) return {};
+    }
+    return current;
+  }
+};
+
+// src/lib/parsers/postman-parser.ts
+var PostmanParser = class {
+  validate(input) {
+    return typeof input === "object" && input !== null && "info" in input && input.info?.schema?.includes("v2");
+  }
+  parse(input) {
+    if (!this.validate(input)) {
+      throw new Error("Invalid Postman Collection format (requires v2.0 or v2.1)");
+    }
+    const baseUrl = this.extractBaseUrl(input);
+    const endpoints = [];
+    this.parseItems(input.item || [], endpoints, baseUrl, input);
+    return {
+      version: input.info?.version,
+      title: input.info?.name,
+      description: input.info?.description,
+      baseUrl,
+      auth: this.extractAuth(input.auth),
+      globalHeaders: this.extractGlobalHeaders(input),
+      endpoints
+    };
+  }
+  extractBaseUrl(collection) {
+    const baseUrlVar = collection.variable?.find(
+      (v) => v.key === "baseUrl" || v.key === "base_url" || v.key === "url"
+    );
+    if (baseUrlVar) return baseUrlVar.value;
+    if (collection.item && collection.item.length > 0) {
+      const firstRequest = this.findFirstRequest(collection.item);
+      if (firstRequest?.request?.url) {
+        const url = this.parseUrl(firstRequest.request.url);
+        if (url.host) {
+          return `${url.protocol}://${url.host.join(".")}`;
+        }
+      }
+    }
+    return "";
+  }
+  findFirstRequest(items) {
+    for (const item of items) {
+      if (item.request) return item;
+      if (item.item) {
+        const found = this.findFirstRequest(item.item);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  extractAuth(auth) {
+    if (!auth) return void 0;
+    if (auth.type === "bearer") {
+      return {
+        type: "bearer",
+        tokenPrefix: "Bearer"
+      };
+    }
+    if (auth.type === "apikey") {
+      const keyData = auth.apikey?.find((a) => a.key === "key");
+      const keyName = keyData?.value || "X-API-Key";
+      return {
+        type: "apiKey",
+        headerName: keyName
+      };
+    }
+    if (auth.type === "basic") {
+      return {
+        type: "basic"
+      };
+    }
+    return void 0;
+  }
+  extractGlobalHeaders(collection) {
+    return [];
+  }
+  parseItems(items, endpoints, baseUrl, collection) {
+    for (const item of items) {
+      if (item.item && Array.isArray(item.item)) {
+        this.parseItems(item.item, endpoints, baseUrl, collection);
+      } else if (item.request) {
+        const endpoint = this.parseRequest(item, baseUrl, collection);
+        endpoints.push(endpoint);
+      }
+    }
+  }
+  parseRequest(item, baseUrl, collection) {
+    const request = item.request;
+    const url = this.parseUrl(request.url);
+    const endpoint = {
+      title: item.name,
+      method: request.method.toUpperCase(),
+      path: this.buildPath(url, baseUrl),
+      description: item.request.description || item.description
+    };
+    const params = this.parseUrlParams(url);
+    if (params.path.length > 0) endpoint.pathParams = params.path;
+    if (params.query.length > 0) endpoint.queryParams = params.query;
+    if (request.header && request.header.length > 0) {
+      endpoint.headers = request.header.filter((h) => !h.disabled).map((h) => ({
+        name: h.key,
+        value: h.value || "",
+        description: h.description
+      }));
+    }
+    if (request.body) {
+      endpoint.body = this.parseBody(request.body);
+    }
+    const responses = this.parseResponses(item.response || []);
+    if (responses.success) endpoint.successResponse = responses.success;
+    if (responses.errors.length > 0) endpoint.errorResponses = responses.errors;
+    return endpoint;
+  }
+  parseUrl(url) {
+    if (typeof url === "string") {
+      const urlObj = new URL(url);
+      return {
+        protocol: urlObj.protocol.replace(":", ""),
+        host: urlObj.hostname.split("."),
+        path: urlObj.pathname.split("/").filter(Boolean),
+        query: [],
+        variable: []
+      };
+    }
+    return {
+      protocol: url.protocol || "https",
+      host: url.host || [],
+      path: url.path || [],
+      query: url.query || [],
+      variable: url.variable || []
+    };
+  }
+  buildPath(url, baseUrl) {
+    let path3 = "/";
+    if (url.path && url.path.length > 0) {
+      path3 += url.path.join("/");
+    }
+    path3 = path3.replace(/\{\{([^}]+)\}\}/g, ":$1");
+    return path3;
+  }
+  parseUrlParams(url) {
+    const result = { path: [], query: [] };
+    if (url.variable && url.variable.length > 0) {
+      for (const v of url.variable) {
+        result.path.push({
+          name: v.key,
+          type: v.type || "string",
+          description: v.description,
+          example: v.value
+        });
+      }
+    }
+    if (url.path && url.path.length > 0) {
+      for (const segment of url.path) {
+        if (segment.startsWith(":")) {
+          const paramName = segment.slice(1);
+          if (!result.path.find((p) => p.name === paramName)) {
+            result.path.push({
+              name: paramName,
+              type: "string"
+            });
+          }
+        }
+      }
+    }
+    if (url.query && url.query.length > 0) {
+      for (const q of url.query) {
+        if (q.disabled) continue;
+        result.query.push({
+          name: q.key,
+          type: "string",
+          description: q.description,
+          example: q.value
+        });
+      }
+    }
+    return result;
+  }
+  parseBody(body) {
+    if (!body) return void 0;
+    let example;
+    let description = body.description;
+    if (body.mode === "raw") {
+      try {
+        example = JSON.parse(body.raw);
+      } catch {
+        example = body.raw;
+      }
+    } else if (body.mode === "formdata" || body.mode === "urlencoded") {
+      example = {};
+      for (const item of body[body.mode] || []) {
+        if (!item.disabled) {
+          example[item.key] = item.value;
+        }
+      }
+    }
+    return {
+      description,
+      example
+    };
+  }
+  parseResponses(responses) {
+    const result = { errors: [] };
+    for (const response of responses) {
+      let example;
+      try {
+        example = JSON.parse(response.body);
+      } catch {
+        example = response.body;
+      }
+      const apiResponse = {
+        status: response.code || 200,
+        description: response.name,
+        example
+      };
+      if (apiResponse.status >= 200 && apiResponse.status < 300) {
+        if (!result.success) result.success = apiResponse;
+      } else {
+        result.errors.push(apiResponse);
+      }
+    }
+    return result;
+  }
+};
+
+// src/lib/parsers/index.ts
+var parsers = /* @__PURE__ */ new Map([
+  ["specra", new SpecraParser()],
+  ["openapi", new OpenApiParser()],
+  ["postman", new PostmanParser()]
+]);
+function detectParserType(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("Invalid API spec: input must be an object");
+  }
+  if (input.info?.schema?.includes("v2")) {
+    return "postman";
+  }
+  if (input.openapi || input.swagger) {
+    return "openapi";
+  }
+  if (input.endpoints && Array.isArray(input.endpoints)) {
+    return "specra";
+  }
+  throw new Error(
+    "Unable to auto-detect API spec format. Supported formats: Specra, OpenAPI 3.x, Postman Collection v2.x"
+  );
+}
+function parseApiSpec(input, parserType = "auto") {
+  const actualType = parserType === "auto" ? detectParserType(input) : parserType;
+  const parser = parsers.get(actualType);
+  if (!parser) {
+    throw new Error(`Unknown parser type: ${actualType}`);
+  }
+  if (!parser.validate(input)) {
+    throw new Error(`Input does not match ${actualType} format`);
+  }
+  return parser.parse(input);
+}
+
+export {
+  getCategoryConfig,
+  getAllCategoryConfigs,
+  sortSidebarItems,
+  sortSidebarGroups,
+  buildSidebarStructure,
+  getVersions,
+  getDocBySlug,
+  getAllDocs,
+  getAdjacentDocs,
+  extractTableOfContents,
+  isCategoryPage,
+  PerfTimer,
+  logFsOperation,
+  logCacheOperation,
+  logMemoryUsage,
+  debugLog,
+  getCachedVersions,
+  getCachedAllDocs,
+  getCachedDocBySlug,
+  clearAllCaches,
+  getCacheStats,
+  SpecraParser,
+  OpenApiParser,
+  PostmanParser,
+  detectParserType,
+  parseApiSpec
+};
+//# sourceMappingURL=chunk-DR4EPLMT.mjs.map