agdex 0.7.0 → 0.8.1

package/dist/{index-ecjc59t4.js → index-9k6cxm1y.js}

@@ -1,11 +1,78 @@
 import {
-  __require
-} from "./index-dtcewfnz.js";
+  __require,
+  __toESM
+} from "./index-pyanjjwn.js";
 
-// src/lib/agents-md.ts
-import { execSync } from "child_process";
+// src/lib/lockfile.ts
 import fs from "fs";
 import path from "path";
+var LOCKFILE_SCHEMA_VERSION = 1;
+var LOCKFILE_RELATIVE_PATH = path.join(".agdex", "agdex.lock");
+function getLockfilePath(cwd) {
+  return path.join(cwd, LOCKFILE_RELATIVE_PATH);
+}
+function createIndexId(kind, sourceName, targetFile) {
+  return `${kind}:${sourceName}:${normalizeRelativePath(targetFile)}`;
+}
+function normalizeRelativePath(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+function toStoredPath(cwd, filePath) {
+  if (!path.isAbsolute(filePath)) {
+    return normalizeRelativePath(filePath);
+  }
+  const relative = path.relative(cwd, filePath);
+  if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+    return normalizeRelativePath(relative);
+  }
+  return filePath;
+}
+function resolveStoredPath(cwd, storedPath) {
+  return path.isAbsolute(storedPath) ? storedPath : path.join(cwd, storedPath);
+}
+function readIndexLockfile(cwd) {
+  const lockfilePath = getLockfilePath(cwd);
+  if (!fs.existsSync(lockfilePath)) {
+    return { schemaVersion: LOCKFILE_SCHEMA_VERSION, indexes: [] };
+  }
+  const parsed = JSON.parse(fs.readFileSync(lockfilePath, "utf-8"));
+  return {
+    schemaVersion: parsed.schemaVersion || LOCKFILE_SCHEMA_VERSION,
+    indexes: Array.isArray(parsed.indexes) ? parsed.indexes : []
+  };
+}
+function writeIndexLockfile(cwd, lockfile) {
+  const lockfilePath = getLockfilePath(cwd);
+  fs.mkdirSync(path.dirname(lockfilePath), { recursive: true });
+  const normalized = {
+    schemaVersion: LOCKFILE_SCHEMA_VERSION,
+    indexes: [...lockfile.indexes].sort((a, b) => a.id.localeCompare(b.id))
+  };
+  fs.writeFileSync(lockfilePath, `${JSON.stringify(normalized, null, 2)}
+`, "utf-8");
+}
+function upsertIndexLockEntry(cwd, entry) {
+  const lockfile = readIndexLockfile(cwd);
+  const nextEntry = {
+    ...entry,
+    targetFile: normalizeRelativePath(entry.targetFile),
+    cachePath: toStoredPath(cwd, entry.cachePath),
+    updatedAt: new Date().toISOString()
+  };
+  const existingIndex = lockfile.indexes.findIndex((candidate) => candidate.id === nextEntry.id);
+  if (existingIndex === -1) {
+    lockfile.indexes.push(nextEntry);
+  } else {
+    lockfile.indexes[existingIndex] = nextEntry;
+  }
+  writeIndexLockfile(cwd, lockfile);
+  return nextEntry;
+}
+
+// src/lib/agents-md.ts
+import { execSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
 import os from "os";
 var START_MARKER_PREFIX = "<!-- AGENTS-MD-EMBED-START";
 var END_MARKER_PREFIX = "<!-- AGENTS-MD-EMBED-END";
@@ -18,8 +85,8 @@ function getEndMarker(providerName) {
 }
 async function pullDocs(provider, options) {
   if (provider.urlConfig) {
-    const { pullDocsFromUrl } = await import("./url-scraper-5sj8c56t.js");
-    const docsPath2 = options.docsDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "agdex-"));
+    const { pullDocsFromUrl } = await import("./url-scraper-axfs3dz7.js");
+    const docsPath2 = options.docsDir ?? fs2.mkdtempSync(path2.join(os.tmpdir(), "agdex-"));
     return pullDocsFromUrl(provider.urlConfig, docsPath2, { onProgress: options.onProgress });
   }
   const { cwd, version: versionOverride, docsDir } = options;
@@ -36,11 +103,11 @@ async function pullDocs(provider, options) {
   } else {
     version = provider.defaultBranch || "main";
   }
-  const docsPath = docsDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "agdex-"));
+  const docsPath = docsDir ?? fs2.mkdtempSync(path2.join(os.tmpdir(), "agdex-"));
   const useTempDir = !docsDir;
   try {
-    if (fs.existsSync(docsPath)) {
-      fs.rmSync(docsPath, { recursive: true });
+    if (fs2.existsSync(docsPath)) {
+      fs2.rmSync(docsPath, { recursive: true });
     }
     const defaultVersionToTag = (v) => {
       if (v.startsWith("v") || /^\d/.test(v)) {
@@ -56,8 +123,8 @@ async function pullDocs(provider, options) {
       version
     };
   } catch (error) {
-    if (useTempDir && fs.existsSync(docsPath)) {
-      fs.rmSync(docsPath, { recursive: true });
+    if (useTempDir && fs2.existsSync(docsPath)) {
+      fs2.rmSync(docsPath, { recursive: true });
     }
     return {
       success: false,
@@ -66,7 +133,7 @@ async function pullDocs(provider, options) {
   }
 }
 async function cloneDocsFolder(repo, docsFolder, tag, destDir) {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agdex-clone-"));
+  const tempDir = fs2.mkdtempSync(path2.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" });
@@ -78,25 +145,25 @@ async function cloneDocsFolder(repo, docsFolder, tag, destDir) {
       throw error;
     }
     execSync(`git sparse-checkout set ${docsFolder}`, { cwd: tempDir, stdio: "pipe" });
-    const sourceDocsDir = path.join(tempDir, docsFolder);
-    if (!fs.existsSync(sourceDocsDir)) {
+    const sourceDocsDir = path2.join(tempDir, docsFolder);
+    if (!fs2.existsSync(sourceDocsDir)) {
       throw new Error(`${docsFolder} folder not found in cloned repository`);
     }
-    if (fs.existsSync(destDir)) {
-      fs.rmSync(destDir, { recursive: true });
+    if (fs2.existsSync(destDir)) {
+      fs2.rmSync(destDir, { recursive: true });
     }
-    fs.mkdirSync(destDir, { recursive: true });
-    fs.cpSync(sourceDocsDir, destDir, { recursive: true });
+    fs2.mkdirSync(destDir, { recursive: true });
+    fs2.cpSync(sourceDocsDir, destDir, { recursive: true });
   } finally {
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true });
+    if (fs2.existsSync(tempDir)) {
+      fs2.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 });
+  const files = fs2.readdirSync(dir, { recursive: true });
   return files.filter((f) => {
     const hasValidExtension = extensions.some((ext) => f.endsWith(ext));
     if (!hasValidExtension)
@@ -310,12 +377,12 @@ function injectIndex(existingContent, indexContent, providerName) {
 `;
 }
 function ensureGitignoreEntry(cwd, docsDir) {
-  const gitignorePath = path.join(cwd, ".gitignore");
+  const gitignorePath = path2.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");
+  if (fs2.existsSync(gitignorePath)) {
+    content = fs2.readFileSync(gitignorePath, "utf-8");
   }
   const hasEntry = content.split(/\r?\n/).some((line) => entryRegex.test(line));
   if (hasEntry) {
@@ -328,23 +395,24 @@ function ensureGitignoreEntry(cwd, docsDir) {
   const newContent = content + (needsNewline ? `
 ` : "") + header + `${entry}
 `;
-  fs.writeFileSync(gitignorePath, newContent, "utf-8");
+  fs2.writeFileSync(gitignorePath, newContent, "utf-8");
   return { path: gitignorePath, updated: true, alreadyPresent: false };
 }
 function getGlobalCacheDir() {
-  return path.join(os.homedir(), ".cache", "agdex");
+  return path2.join(os.homedir(), ".cache", "agdex");
 }
 function getLocalCacheDir(cwd) {
-  return path.join(cwd, ".agdex");
+  return path2.join(cwd, ".agdex");
 }
 async function embed(options) {
   const {
     cwd,
     provider,
     version,
-    output = "AGENTS.md",
+    versionMode,
+    output = "CLAUDE.local.md",
     docsDir: customDocsDir,
-    globalCache = true,
+    globalCache = false,
     description
   } = options;
   let docsPath;
@@ -352,28 +420,28 @@ async function embed(options) {
   let docsDir;
   if (customDocsDir) {
     docsDir = customDocsDir;
-    docsPath = path.isAbsolute(customDocsDir) ? customDocsDir : path.join(cwd, customDocsDir);
-    docsLinkPath = path.isAbsolute(customDocsDir) ? customDocsDir : `./${customDocsDir}`;
+    docsPath = path2.isAbsolute(customDocsDir) ? customDocsDir : path2.join(cwd, customDocsDir);
+    docsLinkPath = path2.isAbsolute(customDocsDir) ? customDocsDir : `./${customDocsDir}`;
   } else if (globalCache) {
     const cacheBase = getGlobalCacheDir();
-    docsDir = path.join(cacheBase, provider.name);
+    docsDir = path2.join(cacheBase, provider.name);
     docsPath = docsDir;
     docsLinkPath = docsPath;
   } else {
     docsDir = `.agdex/${provider.name}`;
-    docsPath = path.join(cwd, docsDir);
+    docsPath = path2.join(cwd, docsDir);
     docsLinkPath = `./${docsDir}`;
   }
-  const targetPath = path.join(cwd, output);
+  const targetPath = path2.join(cwd, output);
   let sizeBefore = 0;
   let isNewFile = true;
   let existingContent = "";
-  if (fs.existsSync(targetPath)) {
-    existingContent = fs.readFileSync(targetPath, "utf-8");
+  if (fs2.existsSync(targetPath)) {
+    existingContent = fs2.readFileSync(targetPath, "utf-8");
     sizeBefore = Buffer.byteLength(existingContent, "utf-8");
     isNewFile = false;
   }
-  const cacheHit = fs.existsSync(docsPath) && fs.readdirSync(docsPath).length > 0;
+  const cacheHit = fs2.existsSync(docsPath) && fs2.readdirSync(docsPath).length > 0;
   let pullResult;
   if (cacheHit) {
     let resolvedVersion = version;
@@ -404,8 +472,8 @@ async function embed(options) {
     excludePatterns: provider.excludePatterns
   });
   const sections = buildDocTree(docFiles);
-  const localFlag = !globalCache ? " --local" : "";
-  const regenerateCommand = `npx agdex --provider ${provider.name} --output ${output}${localFlag}`;
+  const cacheFlag = globalCache ? " --global" : "";
+  const regenerateCommand = `npx agdex --provider ${provider.name} --output ${output}${cacheFlag}`;
   const indexContent = generateIndex({
     docsPath: docsLinkPath,
     sections,
@@ -416,16 +484,34 @@ async function embed(options) {
     regenerateCommand
   });
   const newContent = injectIndex(existingContent, indexContent, provider.name);
-  fs.writeFileSync(targetPath, newContent, "utf-8");
+  fs2.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)) {
+  } else if (!globalCache && customDocsDir && !path2.isAbsolute(customDocsDir)) {
     const gitignoreResult = ensureGitignoreEntry(cwd, customDocsDir);
     gitignoreUpdated = gitignoreResult.updated;
   }
+  upsertIndexLockEntry(cwd, {
+    id: createIndexId("docs", provider.name, output),
+    kind: "docs",
+    source: {
+      type: provider.urlConfig ? "url-docs" : provider.name === "custom" ? "github-docs" : "builtin-provider",
+      name: provider.name,
+      displayName: provider.displayName,
+      repo: provider.repo || undefined,
+      docsPath: provider.docsPath || undefined,
+      url: provider.urlConfig?.baseUrl,
+      version: pullResult.version,
+      versionMode: versionMode || (version ? "pinned" : pullResult.version ? "auto" : "unknown")
+    },
+    targetFile: output,
+    marker: provider.name,
+    cachePath: docsPath,
+    command: regenerateCommand
+  });
   return {
     success: true,
     targetFile: output,
@@ -440,18 +526,18 @@ async function embed(options) {
 }
 
 // src/lib/providers/nextjs.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 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 packageJsonPath = path3.join(cwd, "package.json");
+  const pnpmWorkspacePath = path3.join(cwd, "pnpm-workspace.yaml");
+  if (fs3.existsSync(pnpmWorkspacePath)) {
     const packages = parsePnpmWorkspace(pnpmWorkspacePath);
     if (packages.length > 0) {
       return { isMonorepo: true, type: "pnpm", packages };
     }
   }
-  if (fs2.existsSync(packageJsonPath)) {
+  if (fs3.existsSync(packageJsonPath)) {
     const packages = parsePackageJsonWorkspaces(packageJsonPath);
     if (packages.length > 0) {
       return { isMonorepo: true, type: "npm", packages };
@@ -461,7 +547,7 @@ function detectWorkspace(cwd) {
 }
 function parsePnpmWorkspace(filePath) {
   try {
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const content = fs3.readFileSync(filePath, "utf-8");
     const lines = content.split(`
 `);
     const packages = [];
@@ -489,7 +575,7 @@ function parsePnpmWorkspace(filePath) {
 }
 function parsePackageJsonWorkspaces(filePath) {
   try {
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const content = fs3.readFileSync(filePath, "utf-8");
     const pkg = JSON.parse(content);
     if (Array.isArray(pkg.workspaces)) {
       return pkg.workspaces;
@@ -508,21 +594,21 @@ function expandWorkspacePatterns(cwd, patterns) {
     if (pattern.startsWith("!"))
       continue;
     if (pattern.includes("*")) {
-      const basePath = path2.join(cwd, pattern.replace("/*", "").replace("/**", ""));
-      if (fs2.existsSync(basePath)) {
+      const basePath = path3.join(cwd, pattern.replace("/*", "").replace("/**", ""));
+      if (fs3.existsSync(basePath)) {
         try {
-          const entries = fs2.readdirSync(basePath);
+          const entries = fs3.readdirSync(basePath);
           for (const entry of entries) {
-            const fullPath = path2.join(basePath, entry);
-            if (fs2.statSync(fullPath).isDirectory()) {
+            const fullPath = path3.join(basePath, entry);
+            if (fs3.statSync(fullPath).isDirectory()) {
               packagePaths.push(fullPath);
             }
           }
         } catch {}
       }
     } else {
-      const fullPath = path2.join(cwd, pattern);
-      if (fs2.existsSync(fullPath)) {
+      const fullPath = path3.join(cwd, pattern);
+      if (fs3.existsSync(fullPath)) {
         packagePaths.push(fullPath);
       }
     }
@@ -548,11 +634,11 @@ 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))
+    const packageJsonPath = path3.join(pkgPath, "package.json");
+    if (!fs3.existsSync(packageJsonPath))
       continue;
     try {
-      const content = fs2.readFileSync(packageJsonPath, "utf-8");
+      const content = fs3.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const nextVersion = pkg.dependencies?.next || pkg.devDependencies?.next;
       if (nextVersion) {
@@ -569,15 +655,15 @@ function findNextjsInWorkspace(cwd, patterns) {
   });
 }
 function detectVersion(cwd) {
-  const packageJsonPath = path2.join(cwd, "package.json");
-  if (!fs2.existsSync(packageJsonPath)) {
+  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(fs2.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const nextVersion = dependencies.next || devDependencies.next;
@@ -621,18 +707,18 @@ var nextjsProvider = {
 };
 
 // src/lib/providers/react.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function detectVersion2(cwd) {
-  const packageJsonPath = path3.join(cwd, "package.json");
-  if (!fs3.existsSync(packageJsonPath)) {
+  const packageJsonPath = path4.join(cwd, "package.json");
+  if (!fs4.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 packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const reactVersion = dependencies.react || devDependencies.react;
@@ -664,8 +750,8 @@ var reactProvider = {
 };
 
 // src/lib/providers/pixi.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 function parsePixiVersion(content) {
   const requiresPixiMatch = content.match(/requires-pixi\s*=\s*["']([^"']+)["']/);
   if (requiresPixiMatch) {
@@ -677,20 +763,20 @@ function parsePixiVersion(content) {
   return null;
 }
 function detectVersion3(cwd) {
-  const pixiTomlPath = path4.join(cwd, "pixi.toml");
-  if (fs4.existsSync(pixiTomlPath)) {
+  const pixiTomlPath = path5.join(cwd, "pixi.toml");
+  if (fs5.existsSync(pixiTomlPath)) {
     try {
-      const content = fs4.readFileSync(pixiTomlPath, "utf-8");
+      const content = fs5.readFileSync(pixiTomlPath, "utf-8");
       const version = parsePixiVersion(content);
       if (version) {
         return { version };
       }
     } catch {}
   }
-  const pyprojectPath = path4.join(cwd, "pyproject.toml");
-  if (fs4.existsSync(pyprojectPath)) {
+  const pyprojectPath = path5.join(cwd, "pyproject.toml");
+  if (fs5.existsSync(pyprojectPath)) {
     try {
-      const content = fs4.readFileSync(pyprojectPath, "utf-8");
+      const content = fs5.readFileSync(pyprojectPath, "utf-8");
       if (content.includes("[tool.pixi")) {
         const version = parsePixiVersion(content);
         if (version) {
@@ -734,13 +820,13 @@ var pixiProvider = {
 };
 
 // src/lib/providers/rattler-build.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 function detectVersion4(cwd) {
-  const pixiTomlPath = path5.join(cwd, "pixi.toml");
-  if (fs5.existsSync(pixiTomlPath)) {
+  const pixiTomlPath = path6.join(cwd, "pixi.toml");
+  if (fs6.existsSync(pixiTomlPath)) {
     try {
-      const content = fs5.readFileSync(pixiTomlPath, "utf-8");
+      const content = fs6.readFileSync(pixiTomlPath, "utf-8");
       const match = content.match(/rattler-build\s*=\s*["']([^"']+)["']/);
       if (match) {
         const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
@@ -750,10 +836,10 @@ function detectVersion4(cwd) {
       }
     } catch {}
   }
-  const pyprojectPath = path5.join(cwd, "pyproject.toml");
-  if (fs5.existsSync(pyprojectPath)) {
+  const pyprojectPath = path6.join(cwd, "pyproject.toml");
+  if (fs6.existsSync(pyprojectPath)) {
     try {
-      const content = fs5.readFileSync(pyprojectPath, "utf-8");
+      const content = fs6.readFileSync(pyprojectPath, "utf-8");
       const match = content.match(/rattler-build\s*=\s*["']([^"']+)["']/);
       if (match) {
         const versionMatch = match[1].match(/[\d]+\.[\d]+\.[\d]+/);
@@ -799,13 +885,13 @@ var rattlerBuildProvider = {
 };
 
 // src/lib/providers/tauri.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 function detectVersion5(cwd) {
-  const packageJsonPath = path6.join(cwd, "package.json");
-  if (fs6.existsSync(packageJsonPath)) {
+  const packageJsonPath = path7.join(cwd, "package.json");
+  if (fs7.existsSync(packageJsonPath)) {
     try {
-      const content = fs6.readFileSync(packageJsonPath, "utf-8");
+      const content = fs7.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       const tauriApi = deps["@tauri-apps/api"];
@@ -821,14 +907,14 @@ function detectVersion5(cwd) {
       }
     } catch {}
   }
-  const tauriConfPath = path6.join(cwd, "src-tauri", "tauri.conf.json");
-  if (fs6.existsSync(tauriConfPath)) {
+  const tauriConfPath = path7.join(cwd, "src-tauri", "tauri.conf.json");
+  if (fs7.existsSync(tauriConfPath)) {
     return { version: "v2" };
   }
-  const cargoTomlPath = path6.join(cwd, "src-tauri", "Cargo.toml");
-  if (fs6.existsSync(cargoTomlPath)) {
+  const cargoTomlPath = path7.join(cwd, "src-tauri", "Cargo.toml");
+  if (fs7.existsSync(cargoTomlPath)) {
     try {
-      const content = fs6.readFileSync(cargoTomlPath, "utf-8");
+      const content = fs7.readFileSync(cargoTomlPath, "utf-8");
       const match = content.match(/tauri\s*=\s*.*?"(\d+)\./);
       if (match) {
         const major = parseInt(match[1]);
@@ -889,14 +975,14 @@ var condaForgeProvider = {
 };
 
 // src/lib/providers/bun.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 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);
+  const bunLockPath = path8.join(cwd, "bun.lockb");
+  const hasBunLock = fs8.existsSync(bunLockPath);
+  const bunfigPath = path8.join(cwd, "bunfig.toml");
+  const hasBunfig = fs8.existsSync(bunfigPath);
   if (!hasBunLock && !hasBunfig) {
     return {
       version: null,
@@ -928,18 +1014,18 @@ var bunProvider = {
 };
 
 // src/lib/providers/svelte.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 function detectVersion8(cwd) {
-  const packageJsonPath = path8.join(cwd, "package.json");
-  if (!fs8.existsSync(packageJsonPath)) {
+  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(fs8.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const svelteVersion = dependencies.svelte || devDependencies.svelte;
@@ -977,18 +1063,18 @@ var svelteProvider = {
 };
 
 // src/lib/providers/tailwind.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 function detectVersion9(cwd) {
-  const packageJsonPath = path9.join(cwd, "package.json");
-  if (!fs9.existsSync(packageJsonPath)) {
+  const packageJsonPath = path10.join(cwd, "package.json");
+  if (!fs10.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 packageJson = JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const tailwindVersion = dependencies.tailwindcss || devDependencies.tailwindcss;
@@ -1020,8 +1106,8 @@ var tailwindProvider = {
 };
 
 // src/lib/providers/ruff.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 function parseRuffVersion(content) {
   const patterns = [
     /ruff\s*=\s*["']([^"']+)["']/,
@@ -1040,10 +1126,10 @@ function parseRuffVersion(content) {
   return null;
 }
 function detectVersion10(cwd) {
-  const pyprojectPath = path10.join(cwd, "pyproject.toml");
-  if (fs10.existsSync(pyprojectPath)) {
+  const pyprojectPath = path11.join(cwd, "pyproject.toml");
+  if (fs11.existsSync(pyprojectPath)) {
     try {
-      const content = fs10.readFileSync(pyprojectPath, "utf-8");
+      const content = fs11.readFileSync(pyprojectPath, "utf-8");
       if (content.includes("ruff")) {
         const version = parseRuffVersion(content);
         if (version) {
@@ -1052,8 +1138,8 @@ function detectVersion10(cwd) {
       }
     } catch {}
   }
-  const ruffTomlPath = path10.join(cwd, "ruff.toml");
-  if (fs10.existsSync(ruffTomlPath)) {}
+  const ruffTomlPath = path11.join(cwd, "ruff.toml");
+  if (fs11.existsSync(ruffTomlPath)) {}
   try {
     const { execSync: execSync3 } = __require("child_process");
     const output = execSync3("ruff --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
@@ -1085,8 +1171,8 @@ var ruffProvider = {
 };
 
 // src/lib/providers/ty.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 function parseTyVersion(content) {
   const patterns = [
     /\bty\s*=\s*["']([^"']+)["']/,
@@ -1105,10 +1191,10 @@ function parseTyVersion(content) {
   return null;
 }
 function detectVersion11(cwd) {
-  const pyprojectPath = path11.join(cwd, "pyproject.toml");
-  if (fs11.existsSync(pyprojectPath)) {
+  const pyprojectPath = path12.join(cwd, "pyproject.toml");
+  if (fs12.existsSync(pyprojectPath)) {
     try {
-      const content = fs11.readFileSync(pyprojectPath, "utf-8");
+      const content = fs12.readFileSync(pyprojectPath, "utf-8");
       if (content.includes("[tool.ty]") || /["']ty[>=<]/.test(content) || /\bty\s*=/.test(content)) {
         const version = parseTyVersion(content);
         if (version) {
@@ -1148,8 +1234,8 @@ var tyProvider = {
 };
 
 // src/lib/providers/basedpyright.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 function parseBasedpyrightVersion(content) {
   const patterns = [
     /basedpyright\s*=\s*["']([^"']+)["']/,
@@ -1168,10 +1254,10 @@ function parseBasedpyrightVersion(content) {
   return null;
 }
 function detectVersion12(cwd) {
-  const pyprojectPath = path12.join(cwd, "pyproject.toml");
-  if (fs12.existsSync(pyprojectPath)) {
+  const pyprojectPath = path13.join(cwd, "pyproject.toml");
+  if (fs13.existsSync(pyprojectPath)) {
     try {
-      const content = fs12.readFileSync(pyprojectPath, "utf-8");
+      const content = fs13.readFileSync(pyprojectPath, "utf-8");
       if (content.includes("basedpyright")) {
         const version = parseBasedpyrightVersion(content);
         if (version) {
@@ -1211,18 +1297,18 @@ var basedpyrightProvider = {
 };
 
 // src/lib/providers/convex.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 function detectVersion13(cwd) {
-  const packageJsonPath = path13.join(cwd, "package.json");
-  if (!fs13.existsSync(packageJsonPath)) {
+  const packageJsonPath = path14.join(cwd, "package.json");
+  if (!fs14.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 packageJson = JSON.parse(fs14.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const convexVersion = dependencies.convex || devDependencies.convex;
@@ -1254,8 +1340,8 @@ var convexProvider = {
 };
 
 // src/lib/providers/polars.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path15 from "path";
 function parsePolarsVersion(content) {
   const patterns = [
     /polars\s*=\s*["']([^"']+)["']/,
@@ -1281,10 +1367,10 @@ function parseRequirementsVersion(content) {
   return null;
 }
 function detectVersion14(cwd) {
-  const pyprojectPath = path14.join(cwd, "pyproject.toml");
-  if (fs14.existsSync(pyprojectPath)) {
+  const pyprojectPath = path15.join(cwd, "pyproject.toml");
+  if (fs15.existsSync(pyprojectPath)) {
     try {
-      const content = fs14.readFileSync(pyprojectPath, "utf-8");
+      const content = fs15.readFileSync(pyprojectPath, "utf-8");
       if (content.includes("polars")) {
         const version = parsePolarsVersion(content);
         if (version) {
@@ -1293,10 +1379,10 @@ function detectVersion14(cwd) {
       }
     } catch {}
   }
-  const requirementsPath = path14.join(cwd, "requirements.txt");
-  if (fs14.existsSync(requirementsPath)) {
+  const requirementsPath = path15.join(cwd, "requirements.txt");
+  if (fs15.existsSync(requirementsPath)) {
     try {
-      const content = fs14.readFileSync(requirementsPath, "utf-8");
+      const content = fs15.readFileSync(requirementsPath, "utf-8");
       if (content.includes("polars")) {
         const version = parseRequirementsVersion(content);
         if (version) {
@@ -1336,8 +1422,8 @@ var polarsProvider = {
 };
 
 // src/lib/providers/delta-rs.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs16 from "fs";
+import path16 from "path";
 function parseDeltaLakeVersion(content) {
   const patterns = [
     /deltalake\s*=\s*["']([^"']+)["']/,
@@ -1363,10 +1449,10 @@ function parseRequirementsVersion2(content) {
   return null;
 }
 function detectVersion15(cwd) {
-  const pyprojectPath = path15.join(cwd, "pyproject.toml");
-  if (fs15.existsSync(pyprojectPath)) {
+  const pyprojectPath = path16.join(cwd, "pyproject.toml");
+  if (fs16.existsSync(pyprojectPath)) {
     try {
-      const content = fs15.readFileSync(pyprojectPath, "utf-8");
+      const content = fs16.readFileSync(pyprojectPath, "utf-8");
       if (content.includes("deltalake")) {
         const version = parseDeltaLakeVersion(content);
         if (version) {
@@ -1375,10 +1461,10 @@ function detectVersion15(cwd) {
       }
     } catch {}
   }
-  const requirementsPath = path15.join(cwd, "requirements.txt");
-  if (fs15.existsSync(requirementsPath)) {
+  const requirementsPath = path16.join(cwd, "requirements.txt");
+  if (fs16.existsSync(requirementsPath)) {
     try {
-      const content = fs15.readFileSync(requirementsPath, "utf-8");
+      const content = fs16.readFileSync(requirementsPath, "utf-8");
       if (content.includes("deltalake")) {
         const version = parseRequirementsVersion2(content);
         if (version) {
@@ -1418,18 +1504,18 @@ var deltaRsProvider = {
 };
 
 // src/lib/providers/obsidian.ts
-import fs16 from "fs";
-import path16 from "path";
+import fs17 from "fs";
+import path17 from "path";
 function detectVersion16(cwd) {
-  const packageJsonPath = path16.join(cwd, "package.json");
-  if (!fs16.existsSync(packageJsonPath)) {
+  const packageJsonPath = path17.join(cwd, "package.json");
+  if (!fs17.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 packageJson = JSON.parse(fs17.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const obsidianVersion = dependencies.obsidian || devDependencies.obsidian;
@@ -1461,13 +1547,13 @@ var obsidianProvider = {
 };
 
 // src/lib/providers/obsidian-excalidraw.ts
-import fs17 from "fs";
-import path17 from "path";
+import fs18 from "fs";
+import path18 from "path";
 function detectVersion17(cwd) {
-  const manifestPath = path17.join(cwd, "manifest.json");
-  if (fs17.existsSync(manifestPath)) {
+  const manifestPath = path18.join(cwd, "manifest.json");
+  if (fs18.existsSync(manifestPath)) {
     try {
-      const manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf-8"));
+      const manifest = JSON.parse(fs18.readFileSync(manifestPath, "utf-8"));
       if (manifest.id === "obsidian-excalidraw-plugin" && manifest.version) {
         return { version: manifest.version };
       }
@@ -1524,8 +1610,8 @@ var ffmpegProvider = {
 };
 
 // src/lib/providers/manim.ts
-import fs18 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path19 from "path";
 function parseManimVersion(content) {
   const patterns = [
     /manim\s*=\s*["']([^"']+)["']/,
@@ -1551,10 +1637,10 @@ function parseRequirementsVersion3(content) {
   return null;
 }
 function detectVersion19(cwd) {
-  const pyprojectPath = path18.join(cwd, "pyproject.toml");
-  if (fs18.existsSync(pyprojectPath)) {
+  const pyprojectPath = path19.join(cwd, "pyproject.toml");
+  if (fs19.existsSync(pyprojectPath)) {
     try {
-      const content = fs18.readFileSync(pyprojectPath, "utf-8");
+      const content = fs19.readFileSync(pyprojectPath, "utf-8");
       if (content.includes("manim")) {
         const version = parseManimVersion(content);
         if (version) {
@@ -1563,10 +1649,10 @@ function detectVersion19(cwd) {
       }
     } catch {}
   }
-  const requirementsPath = path18.join(cwd, "requirements.txt");
-  if (fs18.existsSync(requirementsPath)) {
+  const requirementsPath = path19.join(cwd, "requirements.txt");
+  if (fs19.existsSync(requirementsPath)) {
     try {
-      const content = fs18.readFileSync(requirementsPath, "utf-8");
+      const content = fs19.readFileSync(requirementsPath, "utf-8");
       if (content.includes("manim")) {
         const version = parseRequirementsVersion3(content);
         if (version) {
@@ -1670,8 +1756,8 @@ var tensorrtProvider = {
 };
 
 // src/lib/providers/generic.ts
-import fs19 from "fs";
-import path19 from "path";
+import fs20 from "fs";
+import path20 from "path";
 function createProvider(options) {
   const {
     name,
@@ -1691,15 +1777,15 @@ function createProvider(options) {
     instruction
   } = options;
   const detectVersion20 = packageName ? (cwd) => {
-    const packageJsonPath = path19.join(cwd, "package.json");
-    if (!fs19.existsSync(packageJsonPath)) {
+    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(fs19.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs20.readFileSync(packageJsonPath, "utf-8"));
       const dependencies = packageJson.dependencies || {};
       const devDependencies = packageJson.devDependencies || {};
       const version = dependencies[packageName] || devDependencies[packageName];
@@ -1742,19 +1828,31 @@ function createLocalProvider(options) {
     instruction: options.instruction || `IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any ${options.displayName} tasks.`
   };
 }
+function createUrlProvider(options) {
+  return {
+    name: options.name,
+    displayName: options.displayName,
+    repo: "",
+    docsPath: "",
+    extensions: options.extensions || [".md"],
+    excludePatterns: options.excludePatterns || [],
+    instruction: options.instruction || `IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any ${options.displayName} tasks.`,
+    urlConfig: options.urlConfig
+  };
+}
 // src/lib/providers/sveltekit.ts
-import fs20 from "fs";
-import path20 from "path";
+import fs21 from "fs";
+import path21 from "path";
 function detectVersion20(cwd) {
-  const packageJsonPath = path20.join(cwd, "package.json");
-  if (!fs20.existsSync(packageJsonPath)) {
+  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(fs20.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(fs21.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const kitVersion = dependencies["@sveltejs/kit"] || devDependencies["@sveltejs/kit"];
@@ -1785,18 +1883,18 @@ var sveltekitProvider = {
   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";
+import fs22 from "fs";
+import path22 from "path";
 function detectVersion21(cwd) {
-  const packageJsonPath = path21.join(cwd, "package.json");
-  if (!fs21.existsSync(packageJsonPath)) {
+  const packageJsonPath = path22.join(cwd, "package.json");
+  if (!fs22.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 packageJson = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     const version = dependencies["shadcn-svelte"] || devDependencies["shadcn-svelte"];
@@ -1905,8 +2003,8 @@ function isProviderAvailable(preset) {
 }
 
 // src/lib/skills.ts
-import fs22 from "fs";
-import path22 from "path";
+import fs23 from "fs";
+import path23 from "path";
 import os2 from "os";
 var SKILLS_START_MARKER = "<!-- AGENTS-MD-SKILLS-START -->";
 var SKILLS_END_MARKER = "<!-- AGENTS-MD-SKILLS-END -->";
@@ -1921,10 +2019,10 @@ async function fetchSkillsShSearch(query, limit = 20) {
   return data.skills;
 }
 function parseEnabledPlugins(settingsPath) {
-  if (!fs22.existsSync(settingsPath))
+  if (!fs23.existsSync(settingsPath))
     return [];
   try {
-    const content = fs22.readFileSync(settingsPath, "utf-8");
+    const content = fs23.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(content);
     const enabledPlugins = settings.enabledPlugins || {};
     const plugins = [];
@@ -1945,17 +2043,17 @@ function parseEnabledPlugins(settingsPath) {
   }
 }
 function findPluginSkillsPath(pluginRepo, skillName) {
-  const cacheDir = path22.join(os2.homedir(), ".claude", "plugins", "cache", pluginRepo, skillName);
-  if (!fs22.existsSync(cacheDir))
+  const cacheDir = path23.join(os2.homedir(), ".claude", "plugins", "cache", pluginRepo, skillName);
+  if (!fs23.existsSync(cacheDir))
     return null;
   try {
-    const entries = fs22.readdirSync(cacheDir, { withFileTypes: true });
+    const entries = fs23.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 = path22.join(cacheDir, hashDir, "skills");
-    if (fs22.existsSync(skillsPath)) {
+    const skillsPath = path23.join(cacheDir, hashDir, "skills");
+    if (fs23.existsSync(skillsPath)) {
       return skillsPath;
     }
     return null;
@@ -1967,8 +2065,8 @@ function getEnabledPluginSources(cwd) {
   const sources = [];
   const seenPlugins = new Set;
   const settingsPaths = [
-    path22.join(os2.homedir(), ".claude", "settings.json"),
-    path22.join(cwd, ".claude", "settings.json")
+    path23.join(os2.homedir(), ".claude", "settings.json"),
+    path23.join(cwd, ".claude", "settings.json")
   ];
   for (const settingsPath of settingsPaths) {
     const plugins = parseEnabledPlugins(settingsPath);
@@ -2011,12 +2109,12 @@ function parseSkillFrontmatter(content) {
 function getFilesRecursively(dir, baseDir) {
   const files = [];
   try {
-    const entries = fs22.readdirSync(dir, { withFileTypes: true });
+    const entries = fs23.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "SKILL.md")
         continue;
-      const fullPath = path22.join(dir, entry.name);
-      const relativePath = path22.relative(baseDir, fullPath);
+      const fullPath = path23.join(dir, entry.name);
+      const relativePath = path23.relative(baseDir, fullPath);
       if (entry.isDirectory()) {
         files.push(...getFilesRecursively(fullPath, baseDir));
       } else {
@@ -2027,29 +2125,29 @@ function getFilesRecursively(dir, baseDir) {
   return files;
 }
 function getSiblingFiles(skillMdPath) {
-  const dir = path22.dirname(skillMdPath);
-  if (!fs22.existsSync(dir))
+  const dir = path23.dirname(skillMdPath);
+  if (!fs23.existsSync(dir))
     return [];
   return getFilesRecursively(dir, dir).sort();
 }
 function discoverPluginSkills(pluginsPath, label) {
   const skills = [];
-  const pluginsDir = path22.join(pluginsPath, "plugins");
-  if (!fs22.existsSync(pluginsDir)) {
+  const pluginsDir = path23.join(pluginsPath, "plugins");
+  if (!fs23.existsSync(pluginsDir)) {
     return skills;
   }
-  const plugins = fs22.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  const plugins = fs23.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const plugin of plugins) {
-    const skillsDir = path22.join(pluginsDir, plugin.name, "skills");
-    if (!fs22.existsSync(skillsDir))
+    const skillsDir = path23.join(pluginsDir, plugin.name, "skills");
+    if (!fs23.existsSync(skillsDir))
       continue;
-    const skillDirs = fs22.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    const skillDirs = fs23.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const skillDir of skillDirs) {
-      const skillMdPath = path22.join(skillsDir, skillDir.name, "SKILL.md");
-      if (!fs22.existsSync(skillMdPath))
+      const skillMdPath = path23.join(skillsDir, skillDir.name, "SKILL.md");
+      if (!fs23.existsSync(skillMdPath))
         continue;
       try {
-        const content = fs22.readFileSync(skillMdPath, "utf-8");
+        const content = fs23.readFileSync(skillMdPath, "utf-8");
         const frontmatter = parseSkillFrontmatter(content);
         if (!frontmatter)
           continue;
@@ -2068,16 +2166,16 @@ function discoverPluginSkills(pluginsPath, label) {
 }
 function discoverFlatSkills(skillsPath, source, label) {
   const skills = [];
-  if (!fs22.existsSync(skillsPath)) {
+  if (!fs23.existsSync(skillsPath)) {
     return skills;
   }
-  const skillDirs = fs22.readdirSync(skillsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+  const skillDirs = fs23.readdirSync(skillsPath, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const skillDir of skillDirs) {
-    const skillMdPath = path22.join(skillsPath, skillDir.name, "SKILL.md");
-    if (!fs22.existsSync(skillMdPath))
+    const skillMdPath = path23.join(skillsPath, skillDir.name, "SKILL.md");
+    if (!fs23.existsSync(skillMdPath))
       continue;
     try {
-      const content = fs22.readFileSync(skillMdPath, "utf-8");
+      const content = fs23.readFileSync(skillMdPath, "utf-8");
       const frontmatter = parseSkillFrontmatter(content);
       if (!frontmatter)
         continue;
@@ -2102,10 +2200,10 @@ function discoverSkillsShRepo(repoDir, repoName) {
     "skills/.curated",
     "skills/.experimental"
   ];
-  const rootSkillMd = path22.join(repoDir, "SKILL.md");
-  if (fs22.existsSync(rootSkillMd)) {
+  const rootSkillMd = path23.join(repoDir, "SKILL.md");
+  if (fs23.existsSync(rootSkillMd)) {
     try {
-      const content = fs22.readFileSync(rootSkillMd, "utf-8");
+      const content = fs23.readFileSync(rootSkillMd, "utf-8");
       const frontmatter = parseSkillFrontmatter(content);
       if (frontmatter) {
         seen.add(frontmatter.name);
@@ -2121,8 +2219,8 @@ function discoverSkillsShRepo(repoDir, repoName) {
     } catch {}
   }
   for (const dir of searchDirs) {
-    const fullDir = path22.join(repoDir, dir);
-    if (!fs22.existsSync(fullDir))
+    const fullDir = path23.join(repoDir, dir);
+    if (!fs23.existsSync(fullDir))
       continue;
     const discovered = discoverFlatSkills(fullDir, "skills-sh", repoName);
     for (const skill of discovered) {
@@ -2252,7 +2350,7 @@ function getDefaultSkillSources(cwd, options = {}) {
     sources.push({
       type: "plugin",
       path: pluginPath,
-      label: path22.basename(pluginPath)
+      label: path23.basename(pluginPath)
     });
   }
   if (includeEnabledPlugins) {
@@ -2260,7 +2358,7 @@ function getDefaultSkillSources(cwd, options = {}) {
     sources.push(...enabledPluginSources);
   }
   if (includeUser) {
-    const userSkillsPath = path22.join(os2.homedir(), ".claude", "skills");
+    const userSkillsPath = path23.join(os2.homedir(), ".claude", "skills");
     sources.push({
       type: "user",
       path: userSkillsPath,
@@ -2268,7 +2366,7 @@ function getDefaultSkillSources(cwd, options = {}) {
     });
   }
   if (includeProject) {
-    const projectSkillsPath = path22.join(cwd, ".claude", "skills");
+    const projectSkillsPath = path23.join(cwd, ".claude", "skills");
     sources.push({
       type: "project",
       path: projectSkillsPath,
@@ -2279,12 +2377,12 @@ function getDefaultSkillSources(cwd, options = {}) {
 }
 async function embedSkills(options) {
   const { cwd, sources, output = "AGENTS.md" } = options;
-  const targetPath = path22.join(cwd, output);
+  const targetPath = path23.join(cwd, output);
   let sizeBefore = 0;
   let isNewFile = true;
   let existingContent = "";
-  if (fs22.existsSync(targetPath)) {
-    existingContent = fs22.readFileSync(targetPath, "utf-8");
+  if (fs23.existsSync(targetPath)) {
+    existingContent = fs23.readFileSync(targetPath, "utf-8");
     sizeBefore = Buffer.byteLength(existingContent, "utf-8");
     isNewFile = false;
   }
@@ -2308,7 +2406,7 @@ async function embedSkills(options) {
     regenerateCommand: `npx agdex skills embed`
   });
   const newContent = injectSkillsIndex(existingContent, indexContent);
-  fs22.writeFileSync(targetPath, newContent, "utf-8");
+  fs23.writeFileSync(targetPath, newContent, "utf-8");
   const sizeAfter = Buffer.byteLength(newContent, "utf-8");
   return {
     success: true,
@@ -2322,24 +2420,24 @@ async function embedSkills(options) {
 }
 
 // src/lib/config.ts
-import fs23 from "fs";
-import path23 from "path";
+import fs24 from "fs";
+import path24 from "path";
 var DEFAULT_CONFIG = {
   output: "CLAUDE.local.md"
 };
 function loadConfig(cwd = process.cwd()) {
-  const rcPath = path23.join(cwd, ".agdexrc.json");
-  if (fs23.existsSync(rcPath)) {
+  const rcPath = path24.join(cwd, ".agdexrc.json");
+  if (fs24.existsSync(rcPath)) {
     try {
-      const content = fs23.readFileSync(rcPath, "utf-8");
+      const content = fs24.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)) {
+  const packageJsonPath = path24.join(cwd, "package.json");
+  if (fs24.existsSync(packageJsonPath)) {
     try {
-      const content = fs23.readFileSync(packageJsonPath, "utf-8");
+      const content = fs24.readFileSync(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(content);
       if (packageJson.agdex && typeof packageJson.agdex === "object") {
         return { ...DEFAULT_CONFIG, ...packageJson.agdex };
@@ -2353,4 +2451,120 @@ function getDefaultOutput(cwd = process.cwd()) {
   return config.output || "CLAUDE.local.md";
 }
 
-export { 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, tensorrtProvider, createProvider, createLocalProvider, getProvider, listProviders, isProviderAvailable, fetchSkillsShSearch, getEnabledPluginSources, parseSkillFrontmatter, discoverPluginSkills, discoverFlatSkills, discoverSkillsShRepo, collectAllSkills, generateSkillsIndex, hasExistingSkillsIndex, removeSkillsIndex, injectSkillsIndex, getDefaultSkillSources, embedSkills, loadConfig, getDefaultOutput };
+// src/lib/index-maintenance.ts
+import fs25 from "fs";
+import path25 from "path";
+var DOCS_MARKER_REGEX = /<!-- AGENTS-MD-EMBED-START:(\S+?) -->/g;
+var SKILLS_START_MARKER2 = "<!-- AGENTS-MD-SKILLS-START -->";
+function getDefaultStatusTargets(cwd) {
+  const targets = [
+    getDefaultOutput(cwd),
+    "AGENTS.md",
+    "AGENTS.local.md",
+    "CLAUDE.md",
+    "CLAUDE.local.md"
+  ];
+  return [...new Set(targets)];
+}
+function readEmbeddedMarkers(cwd, targetFile) {
+  const targetPath = path25.join(cwd, targetFile);
+  if (!fs25.existsSync(targetPath))
+    return [];
+  const content = fs25.readFileSync(targetPath, "utf-8");
+  const markers = [];
+  let match;
+  while ((match = DOCS_MARKER_REGEX.exec(content)) !== null) {
+    markers.push({ kind: "docs", marker: match[1], targetFile });
+  }
+  if (content.includes(SKILLS_START_MARKER2)) {
+    markers.push({ kind: "skills", marker: "skills", targetFile });
+  }
+  return markers;
+}
+function createStatusReport(options) {
+  const { cwd } = options;
+  const lockfile = readIndexLockfile(cwd);
+  const scannedFiles = options.targetFile ? [options.targetFile] : getScannedFiles(cwd, lockfile);
+  const markers = scannedFiles.flatMap((targetFile) => readEmbeddedMarkers(cwd, targetFile));
+  const indexes = [];
+  const seenMarkers = new Set;
+  for (const entry of lockfile.indexes) {
+    if (options.targetFile && entry.targetFile !== options.targetFile)
+      continue;
+    const markerKey = getMarkerKey(entry.kind, entry.marker, entry.targetFile);
+    const marker = markers.find((candidate) => candidate.kind === entry.kind && candidate.marker === entry.marker && candidate.targetFile === entry.targetFile);
+    if (marker)
+      seenMarkers.add(markerKey);
+    indexes.push(analyzeLockfileEntry(cwd, entry, Boolean(marker)));
+  }
+  for (const marker of markers) {
+    const markerKey = getMarkerKey(marker.kind, marker.marker, marker.targetFile);
+    if (seenMarkers.has(markerKey))
+      continue;
+    indexes.push({
+      id: `untracked:${marker.kind}:${marker.marker}:${marker.targetFile}`,
+      kind: marker.kind,
+      health: "untracked-marker",
+      targetFile: marker.targetFile,
+      marker: marker.marker,
+      suggestedAction: "Run `agdex migrate` or rerun the embed command to create a lockfile entry."
+    });
+  }
+  return {
+    cwd,
+    lockfilePath: path25.join(cwd, ".agdex", "agdex.lock"),
+    scannedFiles,
+    indexes: indexes.sort((a, b) => a.id.localeCompare(b.id))
+  };
+}
+function getScannedFiles(cwd, lockfile) {
+  const targets = [
+    ...lockfile.indexes.map((entry) => entry.targetFile),
+    ...getDefaultStatusTargets(cwd)
+  ];
+  return [...new Set(targets)].filter((target) => fs25.existsSync(path25.join(cwd, target)));
+}
+function analyzeLockfileEntry(cwd, entry, hasMarker) {
+  const targetExists = fs25.existsSync(path25.join(cwd, entry.targetFile));
+  const cachePath = resolveStoredPath(cwd, entry.cachePath);
+  const cacheExists = fs25.existsSync(cachePath);
+  let health = "ok";
+  let suggestedAction = "No action needed.";
+  if (!targetExists) {
+    health = "missing-target";
+    suggestedAction = "Rerun the original embed command or remove this stale lockfile entry.";
+  } else if (!hasMarker) {
+    health = "missing-marker";
+    suggestedAction = "Run `agdex refresh --repair` or rerun the original embed command.";
+  } else if (!cacheExists) {
+    health = "missing-cache";
+    suggestedAction = "Run `agdex refresh` to rebuild the documentation cache.";
+  } else if (entry.kind === "docs" && !hasReadableCache(cachePath)) {
+    health = "stale-lockfile-entry";
+    suggestedAction = "Run `agdex refresh --force` or remove this stale lockfile entry.";
+  }
+  return {
+    id: entry.id,
+    kind: entry.kind,
+    health,
+    targetFile: entry.targetFile,
+    marker: entry.marker,
+    cachePath: entry.cachePath,
+    source: entry.source,
+    command: entry.command,
+    suggestedAction,
+    lockfileEntry: entry
+  };
+}
+function hasReadableCache(cachePath) {
+  try {
+    return fs25.readdirSync(cachePath).length > 0;
+  } catch {
+    return false;
+  }
+}
+function getMarkerKey(kind, marker, targetFile) {
+  return `${kind}:${marker}:${targetFile}`;
+}
+
+export { getLockfilePath, createIndexId, readIndexLockfile, writeIndexLockfile, upsertIndexLockEntry, 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, tensorrtProvider, createProvider, createLocalProvider, createUrlProvider, getProvider, listProviders, isProviderAvailable, fetchSkillsShSearch, getEnabledPluginSources, parseSkillFrontmatter, discoverPluginSkills, discoverFlatSkills, discoverSkillsShRepo, collectAllSkills, generateSkillsIndex, hasExistingSkillsIndex, removeSkillsIndex, injectSkillsIndex, getDefaultSkillSources, embedSkills, loadConfig, getDefaultOutput, getDefaultStatusTargets, readEmbeddedMarkers, createStatusReport };