agdex 0.2.0 → 0.3.1

package/dist/index-5h59833k.js

@@ -0,0 +1,1270 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/lib/agents-md.ts
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+var START_MARKER_PREFIX = "<!-- AGENTS-MD-EMBED-START";
+var END_MARKER_PREFIX = "<!-- AGENTS-MD-EMBED-END";
+var MARKER_SUFFIX = " -->";
+function getStartMarker(providerName) {
+  return providerName ? `${START_MARKER_PREFIX}:${providerName}${MARKER_SUFFIX}` : `${START_MARKER_PREFIX}${MARKER_SUFFIX}`;
+}
+function getEndMarker(providerName) {
+  return providerName ? `${END_MARKER_PREFIX}:${providerName}${MARKER_SUFFIX}` : `${END_MARKER_PREFIX}${MARKER_SUFFIX}`;
+}
+async function pullDocs(provider, options) {
+  const { cwd, version: versionOverride, docsDir } = options;
+  let version;
+  if (versionOverride) {
+    version = versionOverride;
+  } else if (provider.detectVersion) {
+    const versionResult = provider.detectVersion(cwd);
+    if (!versionResult.version) {
+      return {
+        success: false,
+        error: versionResult.error || `Could not detect ${provider.displayName} version`
+      };
+    }
+    version = versionResult.version;
+  } else {
+    return {
+      success: false,
+      error: `No version provided and ${provider.displayName} does not support auto-detection`
+    };
+  }
+  const docsPath = docsDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "agdex-"));
+  const useTempDir = !docsDir;
+  try {
+    if (fs.existsSync(docsPath)) {
+      fs.rmSync(docsPath, { recursive: true });
+    }
+    const tag = provider.versionToTag ? provider.versionToTag(version) : `v${version}`;
+    await cloneDocsFolder(provider.repo, provider.docsPath, tag, docsPath);
+    return {
+      success: true,
+      docsPath,
+      version
+    };
+  } catch (error) {
+    if (useTempDir && fs.existsSync(docsPath)) {
+      fs.rmSync(docsPath, { recursive: true });
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function cloneDocsFolder(repo, docsFolder, tag, destDir) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agdex-clone-"));
+  try {
+    try {
+      execSync(`git clone --depth 1 --filter=blob:none --sparse --branch ${tag} https://github.com/${repo}.git .`, { cwd: tempDir, stdio: "pipe" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("not found") || message.includes("did not match")) {
+        throw new Error(`Could not find documentation for tag ${tag}. This version may not exist on GitHub yet.`);
+      }
+      throw error;
+    }
+    execSync(`git sparse-checkout set ${docsFolder}`, { cwd: tempDir, stdio: "pipe" });
+    const sourceDocsDir = path.join(tempDir, docsFolder);
+    if (!fs.existsSync(sourceDocsDir)) {
+      throw new Error(`${docsFolder} folder not found in cloned repository`);
+    }
+    if (fs.existsSync(destDir)) {
+      fs.rmSync(destDir, { recursive: true });
+    }
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.cpSync(sourceDocsDir, destDir, { recursive: true });
+  } finally {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true });
+    }
+  }
+}
+function collectDocFiles(dir, options) {
+  const extensions = options?.extensions || [".mdx", ".md"];
+  const excludePatterns = options?.excludePatterns || [];
+  const files = fs.readdirSync(dir, { recursive: true });
+  return files.filter((f) => {
+    const hasValidExtension = extensions.some((ext) => f.endsWith(ext));
+    if (!hasValidExtension)
+      return false;
+    for (const pattern of excludePatterns) {
+      if (pattern.startsWith("**/") && pattern.endsWith("/**")) {
+        const dirName = pattern.slice(3, -3);
+        if (f.includes(`/${dirName}/`) || f.startsWith(`${dirName}/`))
+          return false;
+      } else if (pattern.startsWith("**/")) {
+        const suffix = pattern.slice(3);
+        if (f.endsWith(suffix) || f === suffix)
+          return false;
+      } else if (pattern.startsWith("*")) {
+        const suffix = pattern.slice(1);
+        if (f.endsWith(suffix))
+          return false;
+      } else if (f === pattern || f.endsWith("/" + pattern)) {
+        return false;
+      }
+    }
+    if (f.endsWith("/index.mdx") || f.endsWith("/index.md") || f.startsWith("index.")) {
+      return false;
+    }
+    return true;
+  }).sort().map((f) => ({ relativePath: f }));
+}
+function buildDocTree(files) {
+  const sections = new Map;
+  for (const file of files) {
+    const parts = file.relativePath.split("/");
+    if (parts.length === 1) {
+      if (!sections.has(".")) {
+        sections.set(".", {
+          name: ".",
+          files: [],
+          subsections: []
+        });
+      }
+      sections.get(".").files.push({ relativePath: file.relativePath });
+      continue;
+    }
+    const topLevelDir = parts[0];
+    if (!sections.has(topLevelDir)) {
+      sections.set(topLevelDir, {
+        name: topLevelDir,
+        files: [],
+        subsections: []
+      });
+    }
+    const section = sections.get(topLevelDir);
+    if (parts.length === 2) {
+      section.files.push({ relativePath: file.relativePath });
+    } else {
+      const subsectionDir = parts[1];
+      let subsection = section.subsections.find((s) => s.name === subsectionDir);
+      if (!subsection) {
+        subsection = { name: subsectionDir, files: [], subsections: [] };
+        section.subsections.push(subsection);
+      }
+      if (parts.length === 3) {
+        subsection.files.push({ relativePath: file.relativePath });
+      } else {
+        const subSubDir = parts[2];
+        let subSubsection = subsection.subsections.find((s) => s.name === subSubDir);
+        if (!subSubsection) {
+          subSubsection = { name: subSubDir, files: [], subsections: [] };
+          subsection.subsections.push(subSubsection);
+        }
+        subSubsection.files.push({ relativePath: file.relativePath });
+      }
+    }
+  }
+  const sortedSections = Array.from(sections.values()).sort((a, b) => a.name.localeCompare(b.name));
+  for (const section of sortedSections) {
+    section.files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    section.subsections.sort((a, b) => a.name.localeCompare(b.name));
+    for (const subsection of section.subsections) {
+      subsection.files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+      subsection.subsections.sort((a, b) => a.name.localeCompare(b.name));
+      for (const subSubsection of subsection.subsections) {
+        subSubsection.files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+      }
+    }
+  }
+  return sortedSections;
+}
+function generateIndex(options) {
+  const { docsPath, sections, outputFile, providerName, instruction, description, regenerateCommand } = options;
+  const parts = [];
+  const header = providerName ? `[${providerName} Docs Index]` : "[Docs Index]";
+  parts.push(header);
+  parts.push(`root: ${docsPath}`);
+  if (instruction) {
+    parts.push(instruction);
+  }
+  if (description) {
+    parts.push(description);
+  }
+  const targetFile = outputFile || "AGENTS.md";
+  const cmd = regenerateCommand || `npx agdex --output ${targetFile}`;
+  parts.push(`If docs missing, run: ${cmd}`);
+  const allFiles = collectAllFilesFromSections(sections);
+  const grouped = groupByDirectory(allFiles);
+  for (const [dir, files] of grouped) {
+    parts.push(`${dir}:{${files.join(",")}}`);
+  }
+  return parts.join("|");
+}
+function collectAllFilesFromSections(sections) {
+  const files = [];
+  for (const section of sections) {
+    for (const file of section.files) {
+      files.push(file.relativePath);
+    }
+    files.push(...collectAllFilesFromSections(section.subsections));
+  }
+  return files;
+}
+function groupByDirectory(files) {
+  const grouped = new Map;
+  for (const filePath of files) {
+    const lastSlash = filePath.lastIndexOf("/");
+    const dir = lastSlash === -1 ? "." : filePath.slice(0, lastSlash);
+    const fileName = lastSlash === -1 ? filePath : filePath.slice(lastSlash + 1);
+    const existing = grouped.get(dir);
+    if (existing) {
+      existing.push(fileName);
+    } else {
+      grouped.set(dir, [fileName]);
+    }
+  }
+  return grouped;
+}
+function hasExistingIndex(content, providerName) {
+  if (providerName) {
+    return content.includes(getStartMarker(providerName));
+  }
+  return content.includes(START_MARKER_PREFIX);
+}
+function removeDocsIndex(content, providerName) {
+  if (!hasExistingIndex(content, providerName)) {
+    return content;
+  }
+  let result = content;
+  if (providerName) {
+    const startMarker = getStartMarker(providerName);
+    const endMarker = getEndMarker(providerName);
+    const startIdx = result.indexOf(startMarker);
+    const endIdx = result.indexOf(endMarker) + endMarker.length;
+    if (startIdx !== -1 && endIdx > startIdx) {
+      result = result.slice(0, startIdx) + result.slice(endIdx);
+    }
+  } else {
+    let startIdx;
+    while ((startIdx = result.indexOf(START_MARKER_PREFIX)) !== -1) {
+      const startMarkerEnd = result.indexOf(MARKER_SUFFIX, startIdx) + MARKER_SUFFIX.length;
+      const startMarkerContent = result.slice(startIdx, startMarkerEnd);
+      const providerMatch = startMarkerContent.match(/:([^-\s]+)/);
+      const provider = providerMatch ? providerMatch[1] : undefined;
+      const endMarker = getEndMarker(provider);
+      const endIdx = result.indexOf(endMarker);
+      if (endIdx !== -1) {
+        result = result.slice(0, startIdx) + result.slice(endIdx + endMarker.length);
+      } else {
+        result = result.slice(0, startIdx) + result.slice(startMarkerEnd);
+      }
+    }
+  }
+  result = result.replace(/\n{3,}/g, `
+
+`);
+  result = result.trimEnd();
+  if (result.length > 0) {
+    result += `
+`;
+  }
+  return result;
+}
+function wrapWithMarkers(content, providerName) {
+  const startMarker = getStartMarker(providerName);
+  const endMarker = getEndMarker(providerName);
+  return `${startMarker}
+${content}
+${endMarker}`;
+}
+function injectIndex(existingContent, indexContent, providerName) {
+  const wrappedContent = wrapWithMarkers(indexContent, providerName);
+  if (hasExistingIndex(existingContent, providerName)) {
+    const startMarker = getStartMarker(providerName);
+    const endMarker = getEndMarker(providerName);
+    const startIdx = existingContent.indexOf(startMarker);
+    const endIdx = existingContent.indexOf(endMarker) + endMarker.length;
+    return existingContent.slice(0, startIdx) + wrappedContent + existingContent.slice(endIdx);
+  }
+  const separator = existingContent.endsWith(`
+`) ? `
+` : `
+
+`;
+  return existingContent + separator + wrappedContent + `
+`;
+}
+function ensureGitignoreEntry(cwd, docsDir) {
+  const gitignorePath = path.join(cwd, ".gitignore");
+  const entry = docsDir.endsWith("/") ? docsDir : `${docsDir}/`;
+  const entryRegex = new RegExp(`^\\s*${docsDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:/.*)?$`);
+  let content = "";
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, "utf-8");
+  }
+  const hasEntry = content.split(/\r?\n/).some((line) => entryRegex.test(line));
+  if (hasEntry) {
+    return { path: gitignorePath, updated: false, alreadyPresent: true };
+  }
+  const needsNewline = content.length > 0 && !content.endsWith(`
+`);
+  const header = content.includes("# agdex") ? "" : `# agdex
+`;
+  const newContent = content + (needsNewline ? `
+` : "") + header + `${entry}
+`;
+  fs.writeFileSync(gitignorePath, newContent, "utf-8");
+  return { path: gitignorePath, updated: true, alreadyPresent: false };
+}
+function getGlobalCacheDir() {
+  return path.join(os.homedir(), ".cache", "agdex");
+}
+function getLocalCacheDir(cwd) {
+  return path.join(cwd, ".agdex");
+}
+async function embed(options) {
+  const {
+    cwd,
+    provider,
+    version,
+    output = "AGENTS.md",
+    docsDir: customDocsDir,
+    globalCache = false,
+    description
+  } = options;
+  let docsPath;
+  let docsLinkPath;
+  let docsDir;
+  if (customDocsDir) {
+    docsDir = customDocsDir;
+    docsPath = path.isAbsolute(customDocsDir) ? customDocsDir : path.join(cwd, customDocsDir);
+    docsLinkPath = path.isAbsolute(customDocsDir) ? customDocsDir : `./${customDocsDir}`;
+  } else if (globalCache) {
+    const cacheBase = getGlobalCacheDir();
+    docsDir = path.join(cacheBase, provider.name);
+    docsPath = docsDir;
+    docsLinkPath = docsPath;
+  } else {
+    docsDir = `.agdex/${provider.name}`;
+    docsPath = path.join(cwd, docsDir);
+    docsLinkPath = `./${docsDir}`;
+  }
+  const targetPath = path.join(cwd, output);
+  let sizeBefore = 0;
+  let isNewFile = true;
+  let existingContent = "";
+  if (fs.existsSync(targetPath)) {
+    existingContent = fs.readFileSync(targetPath, "utf-8");
+    sizeBefore = Buffer.byteLength(existingContent, "utf-8");
+    isNewFile = false;
+  }
+  const pullResult = await pullDocs(provider, {
+    cwd,
+    version,
+    docsDir: docsPath
+  });
+  if (!pullResult.success) {
+    return {
+      success: false,
+      error: pullResult.error
+    };
+  }
+  const docFiles = collectDocFiles(docsPath, {
+    extensions: provider.extensions,
+    excludePatterns: provider.excludePatterns
+  });
+  const sections = buildDocTree(docFiles);
+  const globalFlag = globalCache ? " --global" : "";
+  const regenerateCommand = `npx agdex --provider ${provider.name} --output ${output}${globalFlag}`;
+  const indexContent = generateIndex({
+    docsPath: docsLinkPath,
+    sections,
+    outputFile: output,
+    providerName: provider.displayName,
+    instruction: provider.instruction,
+    description,
+    regenerateCommand
+  });
+  const newContent = injectIndex(existingContent, indexContent, provider.name);
+  fs.writeFileSync(targetPath, newContent, "utf-8");
+  const sizeAfter = Buffer.byteLength(newContent, "utf-8");
+  let gitignoreUpdated = false;
+  if (!globalCache && !customDocsDir) {
+    const gitignoreResult = ensureGitignoreEntry(cwd, ".agdex");
+    gitignoreUpdated = gitignoreResult.updated;
+  } else if (!globalCache && customDocsDir && !path.isAbsolute(customDocsDir)) {
+    const gitignoreResult = ensureGitignoreEntry(cwd, customDocsDir);
+    gitignoreUpdated = gitignoreResult.updated;
+  }
+  return {
+    success: true,
+    targetFile: output,
+    docsPath: globalCache ? docsPath : docsDir,
+    version: pullResult.version,
+    sizeBefore,
+    sizeAfter,
+    isNewFile,
+    gitignoreUpdated
+  };
+}
+
+// src/lib/providers/nextjs.ts
+import fs2 from "fs";
+import path2 from "path";
+function detectWorkspace(cwd) {
+  const packageJsonPath = path2.join(cwd, "package.json");
+  const pnpmWorkspacePath = path2.join(cwd, "pnpm-workspace.yaml");
+  if (fs2.existsSync(pnpmWorkspacePath)) {
+    const packages = parsePnpmWorkspace(pnpmWorkspacePath);
+    if (packages.length > 0) {
+      return { isMonorepo: true, type: "pnpm", packages };
+    }
+  }
+  if (fs2.existsSync(packageJsonPath)) {
+    const packages = parsePackageJsonWorkspaces(packageJsonPath);
+    if (packages.length > 0) {
+      return { isMonorepo: true, type: "npm", packages };
+    }
+  }
+  return { isMonorepo: false, type: null, packages: [] };
+}
+function parsePnpmWorkspace(filePath) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    const packages = [];
+    let inPackages = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "packages:") {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        if (trimmed && !trimmed.startsWith("-") && !trimmed.startsWith("#")) {
+          break;
+        }
+        const match = trimmed.match(/^-\s*['"]?([^'"]+)['"]?$/);
+        if (match) {
+          packages.push(match[1]);
+        }
+      }
+    }
+    return packages;
+  } catch {
+    return [];
+  }
+}
+function parsePackageJsonWorkspaces(filePath) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (Array.isArray(pkg.workspaces)) {
+      return pkg.workspaces;
+    }
+    if (pkg.workspaces?.packages && Array.isArray(pkg.workspaces.packages)) {
+      return pkg.workspaces.packages;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function expandWorkspacePatterns(cwd, patterns) {
+  const packagePaths = [];
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!"))
+      continue;
+    if (pattern.includes("*")) {
+      const basePath = path2.join(cwd, pattern.replace("/*", "").replace("/**", ""));
+      if (fs2.existsSync(basePath)) {
+        try {
+          const entries = fs2.readdirSync(basePath);
+          for (const entry of entries) {
+            const fullPath = path2.join(basePath, entry);
+            if (fs2.statSync(fullPath).isDirectory()) {
+              packagePaths.push(fullPath);
+            }
+          }
+        } catch {}
+      }
+    } else {
+      const fullPath = path2.join(cwd, pattern);
+      if (fs2.existsSync(fullPath)) {
+        packagePaths.push(fullPath);
+      }
+    }
+  }
+  return [...new Set(packagePaths)];
+}
+function compareVersions(a, b) {
+  const parseVersion = (v) => {
+    const match = v.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+      return [0, 0, 0];
+    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])];
+  };
+  const [aMajor, aMinor, aPatch] = parseVersion(a);
+  const [bMajor, bMinor, bPatch] = parseVersion(b);
+  if (aMajor !== bMajor)
+    return aMajor - bMajor;
+  if (aMinor !== bMinor)
+    return aMinor - bMinor;
+  return aPatch - bPatch;
+}
+function findNextjsInWorkspace(cwd, patterns) {
+  const packagePaths = expandWorkspacePatterns(cwd, patterns);
+  const versions = [];
+  for (const pkgPath of packagePaths) {
+    const packageJsonPath = path2.join(pkgPath, "package.json");
+    if (!fs2.existsSync(packageJsonPath))
+      continue;
+    try {
+      const content = fs2.readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      const nextVersion = pkg.dependencies?.next || pkg.devDependencies?.next;
+      if (nextVersion) {
+        versions.push(nextVersion.replace(/^[\^~>=<]+/, ""));
+      }
+    } catch {}
+  }
+  if (versions.length === 0)
+    return null;
+  if (versions.length === 1)
+    return versions[0];
+  return versions.reduce((highest, current) => {
+    return compareVersions(current, highest) > 0 ? current : highest;
+  });
+}
+function detectVersion(cwd) {
+  const packageJsonPath = path2.join(cwd, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    return {
+      version: null,
+      error: "No package.json found in the current directory"
+    };
+  }
+  try {
+    const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const nextVersion = dependencies.next || devDependencies.next;
+    if (nextVersion) {
+      const cleanVersion = nextVersion.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    const workspace = detectWorkspace(cwd);
+    if (workspace.isMonorepo && workspace.packages.length > 0) {
+      const highestVersion = findNextjsInWorkspace(cwd, workspace.packages);
+      if (highestVersion) {
+        return { version: highestVersion };
+      }
+      return {
+        version: null,
+        error: `No Next.js found in ${workspace.type} workspace packages.`
+      };
+    }
+    return {
+      version: null,
+      error: "Next.js is not installed in this project."
+    };
+  } catch (err) {
+    return {
+      version: null,
+      error: `Failed to parse package.json: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+var nextjsProvider = {
+  name: "nextjs",
+  displayName: "Next.js",
+  repo: "vercel/next.js",
+  docsPath: "docs",
+  extensions: [".mdx", ".md"],
+  detectVersion,
+  versionToTag: (version) => version.startsWith("v") ? version : `v${version}`,
+  excludePatterns: ["**/index.mdx", "**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Next.js tasks."
+};
+
+// src/lib/providers/react.ts
+import fs3 from "fs";
+import path3 from "path";
+function detectVersion2(cwd) {
+  const packageJsonPath = path3.join(cwd, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    return {
+      version: null,
+      error: "No package.json found in the current directory"
+    };
+  }
+  try {
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const reactVersion = dependencies.react || devDependencies.react;
+    if (reactVersion) {
+      const cleanVersion = reactVersion.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    return {
+      version: null,
+      error: "React is not installed in this project."
+    };
+  } catch (err) {
+    return {
+      version: null,
+      error: `Failed to parse package.json: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+var reactProvider = {
+  name: "react",
+  displayName: "React",
+  repo: "reactjs/react.dev",
+  docsPath: "src/content",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion2,
+  versionToTag: (version) => `v${version}`,
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any React tasks."
+};
+
+// src/lib/providers/pixi.ts
+import fs4 from "fs";
+import path4 from "path";
+function parsePixiVersion(content) {
+  const requiresPixiMatch = content.match(/requires-pixi\s*=\s*["']([^"']+)["']/);
+  if (requiresPixiMatch) {
+    const versionMatch = requiresPixiMatch[1].match(/[\d]+\.[\d]+\.[\d]+/);
+    if (versionMatch) {
+      return versionMatch[0];
+    }
+  }
+  return null;
+}
+function detectVersion3(cwd) {
+  const pixiTomlPath = path4.join(cwd, "pixi.toml");
+  if (fs4.existsSync(pixiTomlPath)) {
+    try {
+      const content = fs4.readFileSync(pixiTomlPath, "utf-8");
+      const version = parsePixiVersion(content);
+      if (version) {
+        return { version };
+      }
+    } catch {}
+  }
+  const pyprojectPath = path4.join(cwd, "pyproject.toml");
+  if (fs4.existsSync(pyprojectPath)) {
+    try {
+      const content = fs4.readFileSync(pyprojectPath, "utf-8");
+      if (content.includes("[tool.pixi")) {
+        const version = parsePixiVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  try {
+    const { execSync: execSync2 } = __require("child_process");
+    const output = execSync2("pixi --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/pixi ([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect pixi version. Use --fw-version to specify."
+  };
+}
+var pixiProvider = {
+  name: "pixi",
+  displayName: "Pixi",
+  repo: "prefix-dev/pixi",
+  docsPath: "docs",
+  extensions: [".md"],
+  detectVersion: detectVersion3,
+  versionToTag: (version) => version.startsWith("v") ? version : `v${version}`,
+  excludePatterns: [
+    "**/index.md",
+    "**/__README.md",
+    "**/partials/**",
+    "**/assets/**",
+    "**/stylesheets/**",
+    "**/javascripts/**",
+    "**/overrides/**",
+    "**/layouts/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any pixi tasks. Pixi is a cross-platform package manager for conda environments."
+};
+
+// src/lib/providers/rattler-build.ts
+import fs5 from "fs";
+import path5 from "path";
+function detectVersion4(cwd) {
+  const pixiTomlPath = path5.join(cwd, "pixi.toml");
+  if (fs5.existsSync(pixiTomlPath)) {
+    try {
+      const content = fs5.readFileSync(pixiTomlPath, "utf-8");
+      const match = content.match(/rattler-build\s*=\s*["']([^"']+)["']/);
+      if (match) {
+        const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+        if (versionMatch) {
+          return { version: versionMatch[0] };
+        }
+      }
+    } catch {}
+  }
+  const pyprojectPath = path5.join(cwd, "pyproject.toml");
+  if (fs5.existsSync(pyprojectPath)) {
+    try {
+      const content = fs5.readFileSync(pyprojectPath, "utf-8");
+      const match = content.match(/rattler-build\s*=\s*["']([^"']+)["']/);
+      if (match) {
+        const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+        if (versionMatch) {
+          return { version: versionMatch[0] };
+        }
+      }
+    } catch {}
+  }
+  try {
+    const { execSync: execSync2 } = __require("child_process");
+    const output = execSync2("rattler-build --version", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const versionMatch = output.match(/rattler-build ([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect rattler-build version. Use --fw-version to specify."
+  };
+}
+var rattlerBuildProvider = {
+  name: "rattler-build",
+  displayName: "rattler-build",
+  repo: "prefix-dev/rattler-build",
+  docsPath: "docs",
+  extensions: [".md"],
+  detectVersion: detectVersion4,
+  versionToTag: (version) => version.startsWith("v") ? version : `v${version}`,
+  excludePatterns: [
+    "**/index.md",
+    "**/assets/**",
+    "**/stylesheets/**",
+    "**/layouts/**",
+    "**/overrides/**",
+    "**/generator/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any rattler-build tasks. rattler-build is a tool for building conda packages from recipe.yaml files."
+};
+
+// src/lib/providers/tauri.ts
+import fs6 from "fs";
+import path6 from "path";
+function detectVersion5(cwd) {
+  const packageJsonPath = path6.join(cwd, "package.json");
+  if (fs6.existsSync(packageJsonPath)) {
+    try {
+      const content = fs6.readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const tauriApi = deps["@tauri-apps/api"];
+      const tauriCli = deps["@tauri-apps/cli"];
+      if (tauriApi || tauriCli) {
+        const version = tauriApi || tauriCli;
+        const versionMatch = version.match(/(\d+)\./);
+        if (versionMatch) {
+          const major = parseInt(versionMatch[1]);
+          return { version: major >= 2 ? "v2" : "v1" };
+        }
+        return { version: "v2" };
+      }
+    } catch {}
+  }
+  const tauriConfPath = path6.join(cwd, "src-tauri", "tauri.conf.json");
+  if (fs6.existsSync(tauriConfPath)) {
+    return { version: "v2" };
+  }
+  const cargoTomlPath = path6.join(cwd, "src-tauri", "Cargo.toml");
+  if (fs6.existsSync(cargoTomlPath)) {
+    try {
+      const content = fs6.readFileSync(cargoTomlPath, "utf-8");
+      const match = content.match(/tauri\s*=\s*.*?"(\d+)\./);
+      if (match) {
+        const major = parseInt(match[1]);
+        return { version: major >= 2 ? "v2" : "v1" };
+      }
+      return { version: "v2" };
+    } catch {}
+  }
+  return {
+    version: null,
+    error: "Could not detect Tauri version. Use --fw-version to specify (v1 or v2)."
+  };
+}
+var tauriProvider = {
+  name: "tauri",
+  displayName: "Tauri",
+  repo: "tauri-apps/tauri-docs",
+  docsPath: "src/content/docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion5,
+  versionToTag: (version) => version,
+  excludePatterns: [
+    "**/index.mdx",
+    "**/index.md",
+    "**/_fragments/**",
+    "**/_it/**",
+    "**/es/**",
+    "**/fr/**",
+    "**/it/**",
+    "**/ja/**",
+    "**/ko/**",
+    "**/zh-cn/**",
+    "**/404.md",
+    "**/rss.mdx"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Tauri tasks. Tauri is a framework for building desktop and mobile apps with web frontends."
+};
+
+// src/lib/providers/conda-forge.ts
+function detectVersion6(_cwd) {
+  return { version: "main" };
+}
+var condaForgeProvider = {
+  name: "conda-forge",
+  displayName: "conda-forge",
+  repo: "conda-forge/conda-forge.github.io",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion6,
+  versionToTag: (version) => version,
+  excludePatterns: [
+    "**/index.md",
+    "**/_sidebar.js",
+    "**/_sidebar.json",
+    "**/_sidebar_diataxis.json"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any conda-forge tasks. conda-forge is a community-led collection of recipes, build infrastructure, and packages for conda."
+};
+
+// src/lib/providers/bun.ts
+import fs7 from "fs";
+import path7 from "path";
+import { execSync as execSync2 } from "child_process";
+function detectVersion7(cwd) {
+  const bunLockPath = path7.join(cwd, "bun.lockb");
+  const hasBunLock = fs7.existsSync(bunLockPath);
+  const bunfigPath = path7.join(cwd, "bunfig.toml");
+  const hasBunfig = fs7.existsSync(bunfigPath);
+  if (!hasBunLock && !hasBunfig) {
+    return {
+      version: null,
+      error: "No bun.lockb or bunfig.toml found in the current directory"
+    };
+  }
+  try {
+    const output = execSync2("bun --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Bun project detected but could not determine version. Please specify with --fw-version."
+  };
+}
+var bunProvider = {
+  name: "bun",
+  displayName: "Bun",
+  repo: "oven-sh/bun",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion7,
+  versionToTag: (version) => `bun-v${version}`,
+  excludePatterns: ["**/README.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Bun tasks."
+};
+
+// src/lib/providers/generic.ts
+import fs8 from "fs";
+import path8 from "path";
+function createProvider(options) {
+  const {
+    name,
+    displayName,
+    repo,
+    docsPath,
+    extensions = [".mdx", ".md"],
+    packageName,
+    versionToTag = (v) => v.startsWith("v") ? v : `v${v}`,
+    excludePatterns = ["**/index.mdx", "**/index.md"],
+    instruction
+  } = options;
+  const detectVersion8 = packageName ? (cwd) => {
+    const packageJsonPath = path8.join(cwd, "package.json");
+    if (!fs8.existsSync(packageJsonPath)) {
+      return {
+        version: null,
+        error: "No package.json found in the current directory"
+      };
+    }
+    try {
+      const packageJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+      const dependencies = packageJson.dependencies || {};
+      const devDependencies = packageJson.devDependencies || {};
+      const version = dependencies[packageName] || devDependencies[packageName];
+      if (version) {
+        const cleanVersion = version.replace(/^[\^~>=<]+/, "");
+        return { version: cleanVersion };
+      }
+      return {
+        version: null,
+        error: `${displayName} (${packageName}) is not installed in this project.`
+      };
+    } catch (err) {
+      return {
+        version: null,
+        error: `Failed to parse package.json: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  } : undefined;
+  return {
+    name,
+    displayName,
+    repo,
+    docsPath,
+    extensions,
+    detectVersion: detectVersion8,
+    versionToTag,
+    excludePatterns,
+    instruction: instruction || `IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any ${displayName} tasks.`
+  };
+}
+function createLocalProvider(options) {
+  return {
+    name: options.name,
+    displayName: options.displayName,
+    repo: "",
+    docsPath: options.localPath,
+    extensions: options.extensions || [".mdx", ".md"],
+    excludePatterns: options.excludePatterns || ["**/index.mdx", "**/index.md"],
+    instruction: options.instruction || `IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any ${options.displayName} tasks.`
+  };
+}
+// src/lib/providers/index.ts
+function getProvider(preset) {
+  switch (preset) {
+    case "nextjs":
+      return nextjsProvider;
+    case "react":
+      return reactProvider;
+    case "pixi":
+      return pixiProvider;
+    case "rattler-build":
+      return rattlerBuildProvider;
+    case "tauri":
+      return tauriProvider;
+    case "conda-forge":
+      return condaForgeProvider;
+    case "bun":
+      return bunProvider;
+    case "vue":
+    case "svelte":
+    case "astro":
+      return null;
+    default:
+      return null;
+  }
+}
+function listProviders() {
+  return ["nextjs", "react", "pixi", "rattler-build", "tauri", "conda-forge", "bun", "vue", "svelte", "astro"];
+}
+function isProviderAvailable(preset) {
+  return getProvider(preset) !== null;
+}
+
+// src/lib/skills.ts
+import fs9 from "fs";
+import path9 from "path";
+import os2 from "os";
+var SKILLS_START_MARKER = "<!-- AGENTS-MD-SKILLS-START -->";
+var SKILLS_END_MARKER = "<!-- AGENTS-MD-SKILLS-END -->";
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match)
+    return null;
+  const frontmatter = match[1];
+  const result = { name: "", description: "" };
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+  if (nameMatch) {
+    result.name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+  }
+  if (descMatch) {
+    result.description = descMatch[1].trim().replace(/^["']|["']$/g, "");
+  }
+  if (!result.name || !result.description) {
+    return null;
+  }
+  return result;
+}
+function getSiblingFiles(skillMdPath) {
+  const dir = path9.dirname(skillMdPath);
+  if (!fs9.existsSync(dir))
+    return [];
+  try {
+    const files = fs9.readdirSync(dir);
+    return files.filter((f) => f !== "SKILL.md" && !f.startsWith(".")).sort();
+  } catch {
+    return [];
+  }
+}
+function discoverPluginSkills(pluginsPath, label) {
+  const skills = [];
+  const pluginsDir = path9.join(pluginsPath, "plugins");
+  if (!fs9.existsSync(pluginsDir)) {
+    return skills;
+  }
+  const plugins = fs9.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const plugin of plugins) {
+    const skillsDir = path9.join(pluginsDir, plugin.name, "skills");
+    if (!fs9.existsSync(skillsDir))
+      continue;
+    const skillDirs = fs9.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const skillDir of skillDirs) {
+      const skillMdPath = path9.join(skillsDir, skillDir.name, "SKILL.md");
+      if (!fs9.existsSync(skillMdPath))
+        continue;
+      try {
+        const content = fs9.readFileSync(skillMdPath, "utf-8");
+        const frontmatter = parseSkillFrontmatter(content);
+        if (!frontmatter)
+          continue;
+        skills.push({
+          name: frontmatter.name,
+          description: frontmatter.description,
+          skillMdPath,
+          siblingFiles: getSiblingFiles(skillMdPath),
+          source: "plugin",
+          pluginName: plugin.name
+        });
+      } catch {}
+    }
+  }
+  return skills;
+}
+function discoverFlatSkills(skillsPath, source, label) {
+  const skills = [];
+  if (!fs9.existsSync(skillsPath)) {
+    return skills;
+  }
+  const skillDirs = fs9.readdirSync(skillsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const skillDir of skillDirs) {
+    const skillMdPath = path9.join(skillsPath, skillDir.name, "SKILL.md");
+    if (!fs9.existsSync(skillMdPath))
+      continue;
+    try {
+      const content = fs9.readFileSync(skillMdPath, "utf-8");
+      const frontmatter = parseSkillFrontmatter(content);
+      if (!frontmatter)
+        continue;
+      skills.push({
+        name: frontmatter.name,
+        description: frontmatter.description,
+        skillMdPath,
+        siblingFiles: getSiblingFiles(skillMdPath),
+        source
+      });
+    } catch {}
+  }
+  return skills;
+}
+function collectAllSkills(sources) {
+  const allSkills = [];
+  for (const source of sources) {
+    if (source.type === "plugin") {
+      allSkills.push(...discoverPluginSkills(source.path, source.label));
+    } else {
+      allSkills.push(...discoverFlatSkills(source.path, source.type, source.label));
+    }
+  }
+  return allSkills;
+}
+function generateSkillsIndex(skills, options = {}) {
+  const parts = ["[Skills Index]"];
+  const pluginSkills = new Map;
+  const userSkills = [];
+  const projectSkills = [];
+  for (const skill of skills) {
+    if (skill.source === "plugin" && skill.pluginName) {
+      const existing = pluginSkills.get(skill.pluginName) || [];
+      existing.push(skill);
+      pluginSkills.set(skill.pluginName, existing);
+    } else if (skill.source === "user") {
+      userSkills.push(skill);
+    } else if (skill.source === "project") {
+      projectSkills.push(skill);
+    }
+  }
+  for (const [pluginName, entries] of pluginSkills) {
+    const skillParts = entries.map((s) => formatSkillEntry(s)).join(";");
+    parts.push(`plugin:${pluginName}:{${skillParts}}`);
+  }
+  if (userSkills.length > 0) {
+    const skillParts = userSkills.map((s) => formatSkillEntry(s)).join(";");
+    parts.push(`user:{${skillParts}}`);
+  }
+  if (projectSkills.length > 0) {
+    const skillParts = projectSkills.map((s) => formatSkillEntry(s)).join(";");
+    parts.push(`project:{${skillParts}}`);
+  }
+  const cmd = options.regenerateCommand || "npx agdex skills embed";
+  parts.push(`Regen: ${cmd}`);
+  return parts.join("|");
+}
+function formatSkillEntry(skill) {
+  const desc = skill.description.replace(/\|/g, "\\|").replace(/;/g, "\\;").replace(/:/g, "\\:").replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/\{/g, "\\{").replace(/\}/g, "\\}");
+  if (skill.siblingFiles.length > 0) {
+    return `${skill.name}:${desc}[${skill.siblingFiles.join(",")}]`;
+  }
+  return `${skill.name}:${desc}`;
+}
+function hasExistingSkillsIndex(content) {
+  return content.includes(SKILLS_START_MARKER);
+}
+function removeSkillsIndex(content) {
+  if (!hasExistingSkillsIndex(content)) {
+    return content;
+  }
+  const startIdx = content.indexOf(SKILLS_START_MARKER);
+  const endIdx = content.indexOf(SKILLS_END_MARKER) + SKILLS_END_MARKER.length;
+  let result = content.slice(0, startIdx) + content.slice(endIdx);
+  result = result.replace(/\n{3,}/g, `
+
+`);
+  result = result.trimEnd();
+  if (result.length > 0) {
+    result += `
+`;
+  }
+  return result;
+}
+function injectSkillsIndex(existingContent, indexContent) {
+  const wrappedContent = `${SKILLS_START_MARKER}
+${indexContent}
+${SKILLS_END_MARKER}`;
+  if (hasExistingSkillsIndex(existingContent)) {
+    const startIdx = existingContent.indexOf(SKILLS_START_MARKER);
+    const endIdx = existingContent.indexOf(SKILLS_END_MARKER) + SKILLS_END_MARKER.length;
+    return existingContent.slice(0, startIdx) + wrappedContent + existingContent.slice(endIdx);
+  }
+  const separator = existingContent.endsWith(`
+`) ? `
+` : `
+
+`;
+  return existingContent + separator + wrappedContent + `
+`;
+}
+function getDefaultSkillSources(cwd, options = {}) {
+  const sources = [];
+  const {
+    includeUser = true,
+    includeProject = true,
+    pluginPaths = []
+  } = options;
+  for (const pluginPath of pluginPaths) {
+    sources.push({
+      type: "plugin",
+      path: pluginPath,
+      label: path9.basename(pluginPath)
+    });
+  }
+  if (includeUser) {
+    const userSkillsPath = path9.join(os2.homedir(), ".claude", "skills");
+    sources.push({
+      type: "user",
+      path: userSkillsPath,
+      label: "user"
+    });
+  }
+  if (includeProject) {
+    const projectSkillsPath = path9.join(cwd, ".claude", "skills");
+    sources.push({
+      type: "project",
+      path: projectSkillsPath,
+      label: "project"
+    });
+  }
+  return sources;
+}
+async function embedSkills(options) {
+  const { cwd, sources, output = "AGENTS.md" } = options;
+  const targetPath = path9.join(cwd, output);
+  let sizeBefore = 0;
+  let isNewFile = true;
+  let existingContent = "";
+  if (fs9.existsSync(targetPath)) {
+    existingContent = fs9.readFileSync(targetPath, "utf-8");
+    sizeBefore = Buffer.byteLength(existingContent, "utf-8");
+    isNewFile = false;
+  }
+  const skills = collectAllSkills(sources);
+  if (skills.length === 0) {
+    return {
+      success: false,
+      error: "No skills found in any of the specified sources"
+    };
+  }
+  const sourceBreakdown = {
+    plugin: 0,
+    user: 0,
+    project: 0
+  };
+  for (const skill of skills) {
+    sourceBreakdown[skill.source]++;
+  }
+  const indexContent = generateSkillsIndex(skills, {
+    regenerateCommand: `npx agdex skills embed`
+  });
+  const newContent = injectSkillsIndex(existingContent, indexContent);
+  fs9.writeFileSync(targetPath, newContent, "utf-8");
+  const sizeAfter = Buffer.byteLength(newContent, "utf-8");
+  return {
+    success: true,
+    targetFile: output,
+    skillCount: skills.length,
+    sizeBefore,
+    sizeAfter,
+    isNewFile,
+    sourceBreakdown
+  };
+}
+
+export { __toESM, __commonJS, __require, pullDocs, collectDocFiles, buildDocTree, generateIndex, hasExistingIndex, removeDocsIndex, injectIndex, ensureGitignoreEntry, getGlobalCacheDir, getLocalCacheDir, embed, nextjsProvider, reactProvider, pixiProvider, rattlerBuildProvider, tauriProvider, condaForgeProvider, bunProvider, createProvider, createLocalProvider, getProvider, listProviders, isProviderAvailable, parseSkillFrontmatter, discoverPluginSkills, discoverFlatSkills, collectAllSkills, generateSkillsIndex, hasExistingSkillsIndex, removeSkillsIndex, injectSkillsIndex, getDefaultSkillSources, embedSkills };