agdex 0.4.0 → 0.4.2

package/dist/index-2hm5b6yq.js

@@ -0,0 +1,2111 @@
+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 defaultVersionToTag = (v) => {
+      if (v.startsWith("v") || /^\d/.test(v)) {
+        return v.startsWith("v") ? v : `v${v}`;
+      }
+      return v;
+    };
+    const tag = provider.versionToTag ? provider.versionToTag(version) : defaultVersionToTag(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/svelte.ts
+import fs8 from "fs";
+import path8 from "path";
+function detectVersion8(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 svelteVersion = dependencies.svelte || devDependencies.svelte;
+    if (svelteVersion) {
+      const cleanVersion = svelteVersion.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    return {
+      version: null,
+      error: "Svelte 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 svelteProvider = {
+  name: "svelte",
+  displayName: "Svelte",
+  repo: "sveltejs/svelte",
+  docsPath: "documentation/docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion8,
+  versionToTag: (version) => {
+    const major = parseInt(version.split(".")[0], 10);
+    if (major >= 5) {
+      return `svelte@${version}`;
+    }
+    return version.startsWith("v") ? version : `v${version}`;
+  },
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Svelte tasks."
+};
+
+// src/lib/providers/tailwind.ts
+import fs9 from "fs";
+import path9 from "path";
+function detectVersion9(cwd) {
+  const packageJsonPath = path9.join(cwd, "package.json");
+  if (!fs9.existsSync(packageJsonPath)) {
+    return {
+      version: null,
+      error: "No package.json found in the current directory"
+    };
+  }
+  try {
+    const packageJson = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const tailwindVersion = dependencies.tailwindcss || devDependencies.tailwindcss;
+    if (tailwindVersion) {
+      const cleanVersion = tailwindVersion.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    return {
+      version: null,
+      error: "Tailwind CSS 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 tailwindProvider = {
+  name: "tailwind",
+  displayName: "Tailwind CSS",
+  repo: "tailwindlabs/tailwindcss.com",
+  docsPath: "src/docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion9,
+  versionToTag: (version) => version.startsWith("v") ? version : `v${version}`,
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Tailwind CSS tasks."
+};
+
+// src/lib/providers/ruff.ts
+import fs10 from "fs";
+import path10 from "path";
+function parseRuffVersion(content) {
+  const patterns = [
+    /ruff\s*=\s*["']([^"']+)["']/,
+    /["']ruff([><=!~]+[\d.]+)["']/,
+    /["']ruff\s*([><=!~]*[\d.]+)["']/
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+      if (versionMatch) {
+        return versionMatch[0];
+      }
+    }
+  }
+  return null;
+}
+function detectVersion10(cwd) {
+  const pyprojectPath = path10.join(cwd, "pyproject.toml");
+  if (fs10.existsSync(pyprojectPath)) {
+    try {
+      const content = fs10.readFileSync(pyprojectPath, "utf-8");
+      if (content.includes("ruff")) {
+        const version = parseRuffVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  const ruffTomlPath = path10.join(cwd, "ruff.toml");
+  if (fs10.existsSync(ruffTomlPath)) {}
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output = execSync3("ruff --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/ruff ([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect ruff version. Use --fw-version to specify."
+  };
+}
+var ruffProvider = {
+  name: "ruff",
+  displayName: "Ruff",
+  repo: "astral-sh/ruff",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion10,
+  versionToTag: (version) => version.replace(/^v/, ""),
+  excludePatterns: [
+    "**/index.md",
+    "**/assets/**",
+    "**/stylesheets/**",
+    "**/javascripts/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Ruff tasks. Ruff is an extremely fast Python linter and formatter."
+};
+
+// src/lib/providers/ty.ts
+import fs11 from "fs";
+import path11 from "path";
+function parseTyVersion(content) {
+  const patterns = [
+    /\bty\s*=\s*["']([^"']+)["']/,
+    /["']ty([><=!~]+[\d.]+)["']/,
+    /["']ty\s*([><=!~]*[\d.]+)["']/
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+      if (versionMatch) {
+        return versionMatch[0];
+      }
+    }
+  }
+  return null;
+}
+function detectVersion11(cwd) {
+  const pyprojectPath = path11.join(cwd, "pyproject.toml");
+  if (fs11.existsSync(pyprojectPath)) {
+    try {
+      const content = fs11.readFileSync(pyprojectPath, "utf-8");
+      if (content.includes("[tool.ty]") || /["']ty[>=<]/.test(content) || /\bty\s*=/.test(content)) {
+        const version = parseTyVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output = execSync3("ty --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/ty ([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect ty version. Use --fw-version to specify."
+  };
+}
+var tyProvider = {
+  name: "ty",
+  displayName: "ty",
+  repo: "astral-sh/ty",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion11,
+  versionToTag: (version) => version.replace(/^v/, ""),
+  excludePatterns: [
+    "**/index.md",
+    "**/assets/**",
+    "**/stylesheets/**",
+    "**/javascripts/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any ty tasks. ty is an extremely fast Python type checker from Astral."
+};
+
+// src/lib/providers/basedpyright.ts
+import fs12 from "fs";
+import path12 from "path";
+function parseBasedpyrightVersion(content) {
+  const patterns = [
+    /basedpyright\s*=\s*["']([^"']+)["']/,
+    /["']basedpyright([><=!~]+[\d.]+)["']/,
+    /["']basedpyright\s*([><=!~]*[\d.]+)["']/
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+      if (versionMatch) {
+        return versionMatch[0];
+      }
+    }
+  }
+  return null;
+}
+function detectVersion12(cwd) {
+  const pyprojectPath = path12.join(cwd, "pyproject.toml");
+  if (fs12.existsSync(pyprojectPath)) {
+    try {
+      const content = fs12.readFileSync(pyprojectPath, "utf-8");
+      if (content.includes("basedpyright")) {
+        const version = parseBasedpyrightVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output = execSync3("basedpyright --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/basedpyright ([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect basedpyright version. Use --fw-version to specify."
+  };
+}
+var basedpyrightProvider = {
+  name: "basedpyright",
+  displayName: "basedpyright",
+  repo: "DetachHead/basedpyright",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion12,
+  versionToTag: (version) => version.startsWith("v") ? version : `v${version}`,
+  excludePatterns: [
+    "**/index.md",
+    "**/assets/**",
+    "**/stylesheets/**",
+    "**/javascripts/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any basedpyright tasks. basedpyright is a fork of pyright with various improvements."
+};
+
+// src/lib/providers/convex.ts
+import fs13 from "fs";
+import path13 from "path";
+function detectVersion13(cwd) {
+  const packageJsonPath = path13.join(cwd, "package.json");
+  if (!fs13.existsSync(packageJsonPath)) {
+    return {
+      version: null,
+      error: "No package.json found in the current directory"
+    };
+  }
+  try {
+    const packageJson = JSON.parse(fs13.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const convexVersion = dependencies.convex || devDependencies.convex;
+    if (convexVersion) {
+      const cleanVersion = convexVersion.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    return {
+      version: null,
+      error: "Convex 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 convexProvider = {
+  name: "convex",
+  displayName: "Convex",
+  repo: "get-convex/convex-backend",
+  docsPath: "npm-packages/docs/docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion13,
+  versionToTag: (version) => `precompiled-${version}`,
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Convex tasks. Convex is a backend platform for web applications."
+};
+
+// src/lib/providers/polars.ts
+import fs14 from "fs";
+import path14 from "path";
+function parsePolarsVersion(content) {
+  const patterns = [
+    /polars\s*=\s*["']([^"']+)["']/,
+    /["']polars([><=!~]+[\d.]+)["']/,
+    /["']polars\s*([><=!~]*[\d.]+)["']/
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+      if (versionMatch) {
+        return versionMatch[0];
+      }
+    }
+  }
+  return null;
+}
+function parseRequirementsVersion(content) {
+  const match = content.match(/polars[><=!~]*([\d]+\.[\d]+\.[\d]+)/);
+  if (match) {
+    return match[1];
+  }
+  return null;
+}
+function detectVersion14(cwd) {
+  const pyprojectPath = path14.join(cwd, "pyproject.toml");
+  if (fs14.existsSync(pyprojectPath)) {
+    try {
+      const content = fs14.readFileSync(pyprojectPath, "utf-8");
+      if (content.includes("polars")) {
+        const version = parsePolarsVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  const requirementsPath = path14.join(cwd, "requirements.txt");
+  if (fs14.existsSync(requirementsPath)) {
+    try {
+      const content = fs14.readFileSync(requirementsPath, "utf-8");
+      if (content.includes("polars")) {
+        const version = parseRequirementsVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output = execSync3("pip show polars", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/Version:\s*([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect polars version. Use --fw-version to specify."
+  };
+}
+var polarsProvider = {
+  name: "polars",
+  displayName: "Polars",
+  repo: "pola-rs/polars",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion14,
+  versionToTag: (version) => `py-${version}`,
+  excludePatterns: [
+    "**/index.md",
+    "**/assets/**",
+    "**/stylesheets/**",
+    "**/javascripts/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Polars tasks. Polars is a blazingly fast DataFrame library."
+};
+
+// src/lib/providers/delta-rs.ts
+import fs15 from "fs";
+import path15 from "path";
+function parseDeltaLakeVersion(content) {
+  const patterns = [
+    /deltalake\s*=\s*["']([^"']+)["']/,
+    /["']deltalake([><=!~]+[\d.]+)["']/,
+    /["']deltalake\s*([><=!~]*[\d.]+)["']/
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+      if (versionMatch) {
+        return versionMatch[0];
+      }
+    }
+  }
+  return null;
+}
+function parseRequirementsVersion2(content) {
+  const match = content.match(/deltalake[><=!~]*([\d]+\.[\d]+\.[\d]+)/);
+  if (match) {
+    return match[1];
+  }
+  return null;
+}
+function detectVersion15(cwd) {
+  const pyprojectPath = path15.join(cwd, "pyproject.toml");
+  if (fs15.existsSync(pyprojectPath)) {
+    try {
+      const content = fs15.readFileSync(pyprojectPath, "utf-8");
+      if (content.includes("deltalake")) {
+        const version = parseDeltaLakeVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  const requirementsPath = path15.join(cwd, "requirements.txt");
+  if (fs15.existsSync(requirementsPath)) {
+    try {
+      const content = fs15.readFileSync(requirementsPath, "utf-8");
+      if (content.includes("deltalake")) {
+        const version = parseRequirementsVersion2(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output = execSync3("pip show deltalake", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/Version:\s*([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect deltalake version. Use --fw-version to specify."
+  };
+}
+var deltaRsProvider = {
+  name: "delta-rs",
+  displayName: "delta-rs",
+  repo: "delta-io/delta-rs",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion15,
+  versionToTag: (version) => `python-v${version}`,
+  excludePatterns: [
+    "**/index.md",
+    "**/assets/**",
+    "**/stylesheets/**",
+    "**/javascripts/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any delta-rs/deltalake tasks. delta-rs is a native Rust implementation of Delta Lake."
+};
+
+// src/lib/providers/obsidian.ts
+import fs16 from "fs";
+import path16 from "path";
+function detectVersion16(cwd) {
+  const packageJsonPath = path16.join(cwd, "package.json");
+  if (!fs16.existsSync(packageJsonPath)) {
+    return {
+      version: null,
+      error: "No package.json found in the current directory"
+    };
+  }
+  try {
+    const packageJson = JSON.parse(fs16.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const obsidianVersion = dependencies.obsidian || devDependencies.obsidian;
+    if (obsidianVersion) {
+      const cleanVersion = obsidianVersion.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    return {
+      version: null,
+      error: "Obsidian 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 obsidianProvider = {
+  name: "obsidian",
+  displayName: "Obsidian",
+  repo: "obsidianmd/obsidian-developer-docs",
+  docsPath: "en",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion16,
+  versionToTag: (version) => version.startsWith("v") ? version : `v${version}`,
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Obsidian plugin development tasks."
+};
+
+// src/lib/providers/obsidian-excalidraw.ts
+import fs17 from "fs";
+import path17 from "path";
+function detectVersion17(cwd) {
+  const manifestPath = path17.join(cwd, "manifest.json");
+  if (fs17.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf-8"));
+      if (manifest.id === "obsidian-excalidraw-plugin" && manifest.version) {
+        return { version: manifest.version };
+      }
+    } catch {}
+  }
+  return {
+    version: null,
+    error: "Could not detect obsidian-excalidraw-plugin version. Use --fw-version to specify."
+  };
+}
+var obsidianExcalidrawProvider = {
+  name: "obsidian-excalidraw",
+  displayName: "Obsidian Excalidraw",
+  repo: "zsviczian/obsidian-excalidraw-plugin",
+  docsPath: "docs",
+  extensions: [".md", ".mdx"],
+  detectVersion: detectVersion17,
+  versionToTag: (version) => version,
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Obsidian Excalidraw plugin tasks."
+};
+
+// src/lib/providers/ffmpeg.ts
+function detectVersion18() {
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output = execSync3("ffmpeg -version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/ffmpeg version (\d+\.\d+(?:\.\d+)?)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect FFmpeg version. Use --fw-version to specify."
+  };
+}
+var ffmpegProvider = {
+  name: "ffmpeg",
+  displayName: "FFmpeg",
+  repo: "FFmpeg/FFmpeg",
+  docsPath: "doc",
+  extensions: [".txt", ".md", ".texi"],
+  detectVersion: detectVersion18,
+  versionToTag: (version) => `n${version}`,
+  excludePatterns: [
+    "**/Makefile",
+    "**/*.mak",
+    "**/*.sh",
+    "**/*.pl",
+    "**/*.py"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any FFmpeg tasks. FFmpeg is a multimedia framework for audio/video processing."
+};
+
+// src/lib/providers/manim.ts
+import fs18 from "fs";
+import path18 from "path";
+function parseManimVersion(content) {
+  const patterns = [
+    /manim\s*=\s*["']([^"']+)["']/,
+    /["']manim([><=!~]+[\d.]+)["']/,
+    /["']manim\s*([><=!~]*[\d.]+)["']/
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
+      if (versionMatch) {
+        return versionMatch[0];
+      }
+    }
+  }
+  return null;
+}
+function parseRequirementsVersion3(content) {
+  const match = content.match(/manim[><=!~]*([\d]+\.[\d]+\.[\d]+)/);
+  if (match) {
+    return match[1];
+  }
+  return null;
+}
+function detectVersion19(cwd) {
+  const pyprojectPath = path18.join(cwd, "pyproject.toml");
+  if (fs18.existsSync(pyprojectPath)) {
+    try {
+      const content = fs18.readFileSync(pyprojectPath, "utf-8");
+      if (content.includes("manim")) {
+        const version = parseManimVersion(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  const requirementsPath = path18.join(cwd, "requirements.txt");
+  if (fs18.existsSync(requirementsPath)) {
+    try {
+      const content = fs18.readFileSync(requirementsPath, "utf-8");
+      if (content.includes("manim")) {
+        const version = parseRequirementsVersion3(content);
+        if (version) {
+          return { version };
+        }
+      }
+    } catch {}
+  }
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output = execSync3("pip show manim", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const versionMatch = output.match(/Version:\s*([\d]+\.[\d]+\.[\d]+)/);
+    if (versionMatch) {
+      return { version: versionMatch[1] };
+    }
+  } catch {}
+  return {
+    version: null,
+    error: "Could not detect manim version. Use --fw-version to specify."
+  };
+}
+var manimProvider = {
+  name: "manim",
+  displayName: "Manim",
+  repo: "ManimCommunity/manim",
+  docsPath: "docs",
+  extensions: [".md", ".rst", ".py"],
+  detectVersion: detectVersion19,
+  versionToTag: (version) => version.startsWith("v") ? version : `v${version}`,
+  excludePatterns: [
+    "**/index.md",
+    "**/conf.py",
+    "**/Makefile",
+    "**/_static/**",
+    "**/_templates/**"
+  ],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Manim tasks. Manim is a Python library for mathematical animations."
+};
+
+// src/lib/providers/generic.ts
+import fs19 from "fs";
+import path19 from "path";
+function createProvider(options) {
+  const {
+    name,
+    displayName,
+    repo,
+    docsPath,
+    extensions = [".mdx", ".md"],
+    packageName,
+    versionToTag = (v) => {
+      if (v.startsWith("v") || /^\d/.test(v)) {
+        return v.startsWith("v") ? v : `v${v}`;
+      }
+      return v;
+    },
+    excludePatterns = ["**/index.mdx", "**/index.md"],
+    instruction
+  } = options;
+  const detectVersion20 = packageName ? (cwd) => {
+    const packageJsonPath = path19.join(cwd, "package.json");
+    if (!fs19.existsSync(packageJsonPath)) {
+      return {
+        version: null,
+        error: "No package.json found in the current directory"
+      };
+    }
+    try {
+      const packageJson = JSON.parse(fs19.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: detectVersion20,
+    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 "svelte":
+      return svelteProvider;
+    case "tailwind":
+      return tailwindProvider;
+    case "ruff":
+      return ruffProvider;
+    case "ty":
+      return tyProvider;
+    case "basedpyright":
+      return basedpyrightProvider;
+    case "convex":
+      return convexProvider;
+    case "polars":
+      return polarsProvider;
+    case "delta-rs":
+      return deltaRsProvider;
+    case "obsidian":
+      return obsidianProvider;
+    case "obsidian-excalidraw":
+      return obsidianExcalidrawProvider;
+    case "ffmpeg":
+      return ffmpegProvider;
+    case "manim":
+      return manimProvider;
+    case "vue":
+    case "astro":
+      return null;
+    default:
+      return null;
+  }
+}
+function listProviders() {
+  return ["nextjs", "react", "pixi", "rattler-build", "tauri", "conda-forge", "bun", "vue", "svelte", "astro", "tailwind", "ruff", "ty", "basedpyright", "convex", "polars", "delta-rs", "obsidian", "obsidian-excalidraw", "ffmpeg", "manim"];
+}
+function isProviderAvailable(preset) {
+  return getProvider(preset) !== null;
+}
+
+// src/lib/skills.ts
+import fs20 from "fs";
+import path20 from "path";
+import os2 from "os";
+var SKILLS_START_MARKER = "<!-- AGENTS-MD-SKILLS-START -->";
+var SKILLS_END_MARKER = "<!-- AGENTS-MD-SKILLS-END -->";
+function parseEnabledPlugins(settingsPath) {
+  if (!fs20.existsSync(settingsPath))
+    return [];
+  try {
+    const content = fs20.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    const enabledPlugins = settings.enabledPlugins || {};
+    const plugins = [];
+    for (const [key, enabled] of Object.entries(enabledPlugins)) {
+      if (!enabled)
+        continue;
+      const match = key.match(/^(.+)@(.+)$/);
+      if (match) {
+        plugins.push({
+          skillName: match[1],
+          pluginRepo: match[2]
+        });
+      }
+    }
+    return plugins;
+  } catch {
+    return [];
+  }
+}
+function findPluginSkillsPath(pluginRepo, skillName) {
+  const cacheDir = path20.join(os2.homedir(), ".claude", "plugins", "cache", pluginRepo, skillName);
+  if (!fs20.existsSync(cacheDir))
+    return null;
+  try {
+    const entries = fs20.readdirSync(cacheDir, { withFileTypes: true });
+    const hashDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith("."));
+    if (hashDirs.length === 0)
+      return null;
+    const hashDir = hashDirs[0].name;
+    const skillsPath = path20.join(cacheDir, hashDir, "skills");
+    if (fs20.existsSync(skillsPath)) {
+      return skillsPath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getEnabledPluginSources(cwd) {
+  const sources = [];
+  const seenPlugins = new Set;
+  const settingsPaths = [
+    path20.join(os2.homedir(), ".claude", "settings.json"),
+    path20.join(cwd, ".claude", "settings.json")
+  ];
+  for (const settingsPath of settingsPaths) {
+    const plugins = parseEnabledPlugins(settingsPath);
+    for (const { skillName, pluginRepo } of plugins) {
+      const key = `${skillName}@${pluginRepo}`;
+      if (seenPlugins.has(key))
+        continue;
+      seenPlugins.add(key);
+      const skillsPath = findPluginSkillsPath(pluginRepo, skillName);
+      if (skillsPath) {
+        sources.push({
+          type: "plugin",
+          path: skillsPath,
+          label: `${skillName}@${pluginRepo}`
+        });
+      }
+    }
+  }
+  return sources;
+}
+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 getFilesRecursively(dir, baseDir) {
+  const files = [];
+  try {
+    const entries = fs20.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "SKILL.md")
+        continue;
+      const fullPath = path20.join(dir, entry.name);
+      const relativePath = path20.relative(baseDir, fullPath);
+      if (entry.isDirectory()) {
+        files.push(...getFilesRecursively(fullPath, baseDir));
+      } else {
+        files.push(relativePath);
+      }
+    }
+  } catch {}
+  return files;
+}
+function getSiblingFiles(skillMdPath) {
+  const dir = path20.dirname(skillMdPath);
+  if (!fs20.existsSync(dir))
+    return [];
+  return getFilesRecursively(dir, dir).sort();
+}
+function discoverPluginSkills(pluginsPath, label) {
+  const skills = [];
+  const pluginsDir = path20.join(pluginsPath, "plugins");
+  if (!fs20.existsSync(pluginsDir)) {
+    return skills;
+  }
+  const plugins = fs20.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const plugin of plugins) {
+    const skillsDir = path20.join(pluginsDir, plugin.name, "skills");
+    if (!fs20.existsSync(skillsDir))
+      continue;
+    const skillDirs = fs20.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const skillDir of skillDirs) {
+      const skillMdPath = path20.join(skillsDir, skillDir.name, "SKILL.md");
+      if (!fs20.existsSync(skillMdPath))
+        continue;
+      try {
+        const content = fs20.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 (!fs20.existsSync(skillsPath)) {
+    return skills;
+  }
+  const skillDirs = fs20.readdirSync(skillsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const skillDir of skillDirs) {
+    const skillMdPath = path20.join(skillsPath, skillDir.name, "SKILL.md");
+    if (!fs20.existsSync(skillMdPath))
+      continue;
+    try {
+      const content = fs20.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") {
+      const isCachePath = source.path.includes("/plugins/cache/");
+      if (isCachePath) {
+        const skills = discoverFlatSkills(source.path, "plugin", source.label);
+        for (const skill of skills) {
+          skill.pluginName = source.label;
+        }
+        allSkills.push(...skills);
+      } else {
+        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,
+    includeEnabledPlugins = true,
+    pluginPaths = []
+  } = options;
+  for (const pluginPath of pluginPaths) {
+    sources.push({
+      type: "plugin",
+      path: pluginPath,
+      label: path20.basename(pluginPath)
+    });
+  }
+  if (includeEnabledPlugins) {
+    const enabledPluginSources = getEnabledPluginSources(cwd);
+    sources.push(...enabledPluginSources);
+  }
+  if (includeUser) {
+    const userSkillsPath = path20.join(os2.homedir(), ".claude", "skills");
+    sources.push({
+      type: "user",
+      path: userSkillsPath,
+      label: "user"
+    });
+  }
+  if (includeProject) {
+    const projectSkillsPath = path20.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 = path20.join(cwd, output);
+  let sizeBefore = 0;
+  let isNewFile = true;
+  let existingContent = "";
+  if (fs20.existsSync(targetPath)) {
+    existingContent = fs20.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);
+  fs20.writeFileSync(targetPath, newContent, "utf-8");
+  const sizeAfter = Buffer.byteLength(newContent, "utf-8");
+  return {
+    success: true,
+    targetFile: output,
+    skillCount: skills.length,
+    sizeBefore,
+    sizeAfter,
+    isNewFile,
+    sourceBreakdown
+  };
+}
+
+// src/lib/config.ts
+import fs21 from "fs";
+import path21 from "path";
+var DEFAULT_CONFIG = {
+  output: "CLAUDE.md"
+};
+function loadConfig(cwd = process.cwd()) {
+  const rcPath = path21.join(cwd, ".agdexrc.json");
+  if (fs21.existsSync(rcPath)) {
+    try {
+      const content = fs21.readFileSync(rcPath, "utf-8");
+      const config = JSON.parse(content);
+      return { ...DEFAULT_CONFIG, ...config };
+    } catch {}
+  }
+  const packageJsonPath = path21.join(cwd, "package.json");
+  if (fs21.existsSync(packageJsonPath)) {
+    try {
+      const content = fs21.readFileSync(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(content);
+      if (packageJson.agdex && typeof packageJson.agdex === "object") {
+        return { ...DEFAULT_CONFIG, ...packageJson.agdex };
+      }
+    } catch {}
+  }
+  return DEFAULT_CONFIG;
+}
+function getDefaultOutput(cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+  return config.output || "AGENTS.md";
+}
+
+export { __toESM, __commonJS, __require, pullDocs, collectDocFiles, buildDocTree, generateIndex, hasExistingIndex, removeDocsIndex, injectIndex, ensureGitignoreEntry, getGlobalCacheDir, getLocalCacheDir, embed, nextjsProvider, reactProvider, pixiProvider, rattlerBuildProvider, tauriProvider, condaForgeProvider, bunProvider, svelteProvider, tailwindProvider, ruffProvider, tyProvider, basedpyrightProvider, convexProvider, polarsProvider, deltaRsProvider, obsidianProvider, obsidianExcalidrawProvider, ffmpegProvider, manimProvider, createProvider, createLocalProvider, getProvider, listProviders, isProviderAvailable, getEnabledPluginSources, parseSkillFrontmatter, discoverPluginSkills, discoverFlatSkills, collectAllSkills, generateSkillsIndex, hasExistingSkillsIndex, removeSkillsIndex, injectSkillsIndex, getDefaultSkillSources, embedSkills, loadConfig, getDefaultOutput };