agdex 0.4.1 → 0.5.0

package/dist/{index-9gy9s47s.js → index-974mhezm.js}

@@ -58,7 +58,13 @@ async function pullDocs(provider, options) {
     if (fs.existsSync(docsPath)) {
       fs.rmSync(docsPath, { recursive: true });
     }
-    const tag = provider.versionToTag ? provider.versionToTag(version) : `v${version}`;
+    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,
@@ -247,6 +253,15 @@ function hasExistingIndex(content, providerName) {
   }
   return content.includes(START_MARKER_PREFIX);
 }
+function getEmbeddedProviders(content) {
+  const providers = [];
+  const regex = /<!-- AGENTS-MD-EMBED-START:(\S+?) -->/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    providers.push(match[1]);
+  }
+  return providers;
+}
 function removeDocsIndex(content, providerName) {
   if (!hasExistingIndex(content, providerName)) {
     return content;
@@ -345,7 +360,7 @@ async function embed(options) {
     version,
     output = "AGENTS.md",
     docsDir: customDocsDir,
-    globalCache = false,
+    globalCache = true,
     description
   } = options;
   let docsPath;
@@ -374,24 +389,39 @@ async function embed(options) {
     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 cacheHit = fs.existsSync(docsPath) && fs.readdirSync(docsPath).length > 0;
+  let pullResult;
+  if (cacheHit) {
+    let resolvedVersion = version;
+    if (!resolvedVersion && provider.detectVersion) {
+      const detected = provider.detectVersion(cwd);
+      resolvedVersion = detected.version || undefined;
+    }
+    pullResult = {
+      success: true,
+      docsPath,
+      version: resolvedVersion
     };
+  } else {
+    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 localFlag = !globalCache ? " --local" : "";
+  const regenerateCommand = `npx agdex --provider ${provider.name} --output ${output}${localFlag}`;
   const indexContent = generateIndex({
     docsPath: docsLinkPath,
     sections,
@@ -420,7 +450,8 @@ async function embed(options) {
     sizeBefore,
     sizeAfter,
     isNewFile,
-    gitignoreUpdated
+    gitignoreUpdated,
+    cacheHit
   };
 }
 
@@ -911,9 +942,688 @@ var bunProvider = {
   instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any Bun tasks."
 };
 
-// src/lib/providers/generic.ts
+// 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,
@@ -922,20 +1632,25 @@ function createProvider(options) {
     docsPath,
     extensions = [".mdx", ".md"],
     packageName,
-    versionToTag = (v) => v.startsWith("v") ? v : `v${v}`,
+    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 detectVersion8 = packageName ? (cwd) => {
-    const packageJsonPath = path8.join(cwd, "package.json");
-    if (!fs8.existsSync(packageJsonPath)) {
+  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(fs8.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs19.readFileSync(packageJsonPath, "utf-8"));
       const dependencies = packageJson.dependencies || {};
       const devDependencies = packageJson.devDependencies || {};
       const version = dependencies[packageName] || devDependencies[packageName];
@@ -960,7 +1675,7 @@ function createProvider(options) {
     repo,
     docsPath,
     extensions,
-    detectVersion: detectVersion8,
+    detectVersion: detectVersion20,
     versionToTag,
     excludePatterns,
     instruction: instruction || `IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any ${displayName} tasks.`
@@ -977,6 +1692,90 @@ function createLocalProvider(options) {
     instruction: options.instruction || `IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any ${options.displayName} tasks.`
   };
 }
+// src/lib/providers/sveltekit.ts
+import fs20 from "fs";
+import path20 from "path";
+function detectVersion20(cwd) {
+  const packageJsonPath = path20.join(cwd, "package.json");
+  if (!fs20.existsSync(packageJsonPath)) {
+    return {
+      version: null,
+      error: "No package.json found in the current directory"
+    };
+  }
+  try {
+    const packageJson = JSON.parse(fs20.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const kitVersion = dependencies["@sveltejs/kit"] || devDependencies["@sveltejs/kit"];
+    if (kitVersion) {
+      const cleanVersion = kitVersion.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    return {
+      version: null,
+      error: "@sveltejs/kit 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 sveltekitProvider = {
+  name: "sveltekit",
+  displayName: "SvelteKit",
+  repo: "sveltejs/kit",
+  docsPath: "documentation/docs",
+  extensions: [".md"],
+  detectVersion: detectVersion20,
+  versionToTag: (version) => `@sveltejs/kit@${version}`,
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any SvelteKit tasks."
+};
+// src/lib/providers/shadcn-svelte.ts
+import fs21 from "fs";
+import path21 from "path";
+function detectVersion21(cwd) {
+  const packageJsonPath = path21.join(cwd, "package.json");
+  if (!fs21.existsSync(packageJsonPath)) {
+    return {
+      version: null,
+      error: "No package.json found in the current directory"
+    };
+  }
+  try {
+    const packageJson = JSON.parse(fs21.readFileSync(packageJsonPath, "utf-8"));
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    const version = dependencies["shadcn-svelte"] || devDependencies["shadcn-svelte"];
+    if (version) {
+      const cleanVersion = version.replace(/^[\^~>=<]+/, "");
+      return { version: cleanVersion };
+    }
+    return {
+      version: null,
+      error: "shadcn-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 shadcnSvelteProvider = {
+  name: "shadcn-svelte",
+  displayName: "shadcn-svelte",
+  repo: "huntabyte/shadcn-svelte",
+  docsPath: "docs/content",
+  extensions: [".md"],
+  detectVersion: detectVersion21,
+  versionToTag: (version) => `shadcn-svelte@${version}`,
+  excludePatterns: ["**/index.md"],
+  instruction: "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any shadcn-svelte tasks."
+};
 // src/lib/providers/index.ts
 function getProvider(preset) {
   switch (preset) {
@@ -994,8 +1793,35 @@ function getProvider(preset) {
       return condaForgeProvider;
     case "bun":
       return bunProvider;
-    case "vue":
     case "svelte":
+      return svelteProvider;
+    case "sveltekit":
+      return sveltekitProvider;
+    case "shadcn-svelte":
+      return shadcnSvelteProvider;
+    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:
@@ -1003,23 +1829,23 @@ function getProvider(preset) {
   }
 }
 function listProviders() {
-  return ["nextjs", "react", "pixi", "rattler-build", "tauri", "conda-forge", "bun", "vue", "svelte", "astro"];
+  return ["nextjs", "react", "pixi", "rattler-build", "tauri", "conda-forge", "bun", "vue", "svelte", "sveltekit", "shadcn-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 fs9 from "fs";
-import path9 from "path";
+import fs22 from "fs";
+import path22 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 (!fs9.existsSync(settingsPath))
+  if (!fs22.existsSync(settingsPath))
     return [];
   try {
-    const content = fs9.readFileSync(settingsPath, "utf-8");
+    const content = fs22.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(content);
     const enabledPlugins = settings.enabledPlugins || {};
     const plugins = [];
@@ -1040,17 +1866,17 @@ function parseEnabledPlugins(settingsPath) {
   }
 }
 function findPluginSkillsPath(pluginRepo, skillName) {
-  const cacheDir = path9.join(os2.homedir(), ".claude", "plugins", "cache", pluginRepo, skillName);
-  if (!fs9.existsSync(cacheDir))
+  const cacheDir = path22.join(os2.homedir(), ".claude", "plugins", "cache", pluginRepo, skillName);
+  if (!fs22.existsSync(cacheDir))
     return null;
   try {
-    const entries = fs9.readdirSync(cacheDir, { withFileTypes: true });
+    const entries = fs22.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 = path9.join(cacheDir, hashDir, "skills");
-    if (fs9.existsSync(skillsPath)) {
+    const skillsPath = path22.join(cacheDir, hashDir, "skills");
+    if (fs22.existsSync(skillsPath)) {
       return skillsPath;
     }
     return null;
@@ -1062,8 +1888,8 @@ function getEnabledPluginSources(cwd) {
   const sources = [];
   const seenPlugins = new Set;
   const settingsPaths = [
-    path9.join(os2.homedir(), ".claude", "settings.json"),
-    path9.join(cwd, ".claude", "settings.json")
+    path22.join(os2.homedir(), ".claude", "settings.json"),
+    path22.join(cwd, ".claude", "settings.json")
   ];
   for (const settingsPath of settingsPaths) {
     const plugins = parseEnabledPlugins(settingsPath);
@@ -1106,12 +1932,12 @@ function parseSkillFrontmatter(content) {
 function getFilesRecursively(dir, baseDir) {
   const files = [];
   try {
-    const entries = fs9.readdirSync(dir, { withFileTypes: true });
+    const entries = fs22.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "SKILL.md")
         continue;
-      const fullPath = path9.join(dir, entry.name);
-      const relativePath = path9.relative(baseDir, fullPath);
+      const fullPath = path22.join(dir, entry.name);
+      const relativePath = path22.relative(baseDir, fullPath);
       if (entry.isDirectory()) {
         files.push(...getFilesRecursively(fullPath, baseDir));
       } else {
@@ -1122,29 +1948,29 @@ function getFilesRecursively(dir, baseDir) {
   return files;
 }
 function getSiblingFiles(skillMdPath) {
-  const dir = path9.dirname(skillMdPath);
-  if (!fs9.existsSync(dir))
+  const dir = path22.dirname(skillMdPath);
+  if (!fs22.existsSync(dir))
     return [];
   return getFilesRecursively(dir, dir).sort();
 }
 function discoverPluginSkills(pluginsPath, label) {
   const skills = [];
-  const pluginsDir = path9.join(pluginsPath, "plugins");
-  if (!fs9.existsSync(pluginsDir)) {
+  const pluginsDir = path22.join(pluginsPath, "plugins");
+  if (!fs22.existsSync(pluginsDir)) {
     return skills;
   }
-  const plugins = fs9.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  const plugins = fs22.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))
+    const skillsDir = path22.join(pluginsDir, plugin.name, "skills");
+    if (!fs22.existsSync(skillsDir))
       continue;
-    const skillDirs = fs9.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    const skillDirs = fs22.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))
+      const skillMdPath = path22.join(skillsDir, skillDir.name, "SKILL.md");
+      if (!fs22.existsSync(skillMdPath))
         continue;
       try {
-        const content = fs9.readFileSync(skillMdPath, "utf-8");
+        const content = fs22.readFileSync(skillMdPath, "utf-8");
         const frontmatter = parseSkillFrontmatter(content);
         if (!frontmatter)
           continue;
@@ -1163,16 +1989,16 @@ function discoverPluginSkills(pluginsPath, label) {
 }
 function discoverFlatSkills(skillsPath, source, label) {
   const skills = [];
-  if (!fs9.existsSync(skillsPath)) {
+  if (!fs22.existsSync(skillsPath)) {
     return skills;
   }
-  const skillDirs = fs9.readdirSync(skillsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+  const skillDirs = fs22.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))
+    const skillMdPath = path22.join(skillsPath, skillDir.name, "SKILL.md");
+    if (!fs22.existsSync(skillMdPath))
       continue;
     try {
-      const content = fs9.readFileSync(skillMdPath, "utf-8");
+      const content = fs22.readFileSync(skillMdPath, "utf-8");
       const frontmatter = parseSkillFrontmatter(content);
       if (!frontmatter)
         continue;
@@ -1295,7 +2121,7 @@ function getDefaultSkillSources(cwd, options = {}) {
     sources.push({
       type: "plugin",
       path: pluginPath,
-      label: path9.basename(pluginPath)
+      label: path22.basename(pluginPath)
     });
   }
   if (includeEnabledPlugins) {
@@ -1303,7 +2129,7 @@ function getDefaultSkillSources(cwd, options = {}) {
     sources.push(...enabledPluginSources);
   }
   if (includeUser) {
-    const userSkillsPath = path9.join(os2.homedir(), ".claude", "skills");
+    const userSkillsPath = path22.join(os2.homedir(), ".claude", "skills");
     sources.push({
       type: "user",
       path: userSkillsPath,
@@ -1311,7 +2137,7 @@ function getDefaultSkillSources(cwd, options = {}) {
     });
   }
   if (includeProject) {
-    const projectSkillsPath = path9.join(cwd, ".claude", "skills");
+    const projectSkillsPath = path22.join(cwd, ".claude", "skills");
     sources.push({
       type: "project",
       path: projectSkillsPath,
@@ -1322,12 +2148,12 @@ function getDefaultSkillSources(cwd, options = {}) {
 }
 async function embedSkills(options) {
   const { cwd, sources, output = "AGENTS.md" } = options;
-  const targetPath = path9.join(cwd, output);
+  const targetPath = path22.join(cwd, output);
   let sizeBefore = 0;
   let isNewFile = true;
   let existingContent = "";
-  if (fs9.existsSync(targetPath)) {
-    existingContent = fs9.readFileSync(targetPath, "utf-8");
+  if (fs22.existsSync(targetPath)) {
+    existingContent = fs22.readFileSync(targetPath, "utf-8");
     sizeBefore = Buffer.byteLength(existingContent, "utf-8");
     isNewFile = false;
   }
@@ -1350,7 +2176,7 @@ async function embedSkills(options) {
     regenerateCommand: `npx agdex skills embed`
   });
   const newContent = injectSkillsIndex(existingContent, indexContent);
-  fs9.writeFileSync(targetPath, newContent, "utf-8");
+  fs22.writeFileSync(targetPath, newContent, "utf-8");
   const sizeAfter = Buffer.byteLength(newContent, "utf-8");
   return {
     success: true,
@@ -1363,4 +2189,36 @@ async function embedSkills(options) {
   };
 }
 
-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, getEnabledPluginSources, parseSkillFrontmatter, discoverPluginSkills, discoverFlatSkills, collectAllSkills, generateSkillsIndex, hasExistingSkillsIndex, removeSkillsIndex, injectSkillsIndex, getDefaultSkillSources, embedSkills };
+// src/lib/config.ts
+import fs23 from "fs";
+import path23 from "path";
+var DEFAULT_CONFIG = {
+  output: "CLAUDE.md"
+};
+function loadConfig(cwd = process.cwd()) {
+  const rcPath = path23.join(cwd, ".agdexrc.json");
+  if (fs23.existsSync(rcPath)) {
+    try {
+      const content = fs23.readFileSync(rcPath, "utf-8");
+      const config = JSON.parse(content);
+      return { ...DEFAULT_CONFIG, ...config };
+    } catch {}
+  }
+  const packageJsonPath = path23.join(cwd, "package.json");
+  if (fs23.existsSync(packageJsonPath)) {
+    try {
+      const content = fs23.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, getEmbeddedProviders, 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 };