@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/github-extract-F64RZOEA.js

@@ -0,0 +1,619 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  registerSessionCleanup
+} from "./chunk-AUXVGBO4.js";
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/github-extract.js
+import { existsSync, readFileSync, rmSync, statSync, readdirSync, openSync, readSync, closeSync, realpathSync } from "node:fs";
+import { execFile as execFile2 } from "node:child_process";
+import { extname, join, resolve as resolvePath, sep as pathSep } from "node:path";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/github-api.js
+import { execFile } from "node:child_process";
+var MAX_TREE_ENTRIES = 200, MAX_INLINE_FILE_CHARS = 1e5, ghAvailable = null, ghHintShown = !1;
+async function checkGhAvailable() {
+  return ghAvailable !== null ? ghAvailable : new Promise((resolve) => {
+    execFile("gh", ["--version"], { timeout: 5e3 }, (err) => {
+      ghAvailable = !err, resolve(ghAvailable);
+    });
+  });
+}
+function showGhHint() {
+  ghHintShown || (ghHintShown = !0, console.error("[pi-web-access] Install `gh` CLI for better GitHub repo access including private repos."));
+}
+async function checkRepoSize(owner, repo) {
+  return await checkGhAvailable() ? new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}`, "--jq", ".size"], { timeout: 1e4 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      let kb = parseInt(stdout.trim(), 10);
+      resolve(Number.isNaN(kb) ? null : kb);
+    });
+  }) : null;
+}
+async function getDefaultBranch(owner, repo) {
+  return await checkGhAvailable() ? new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}`, "--jq", ".default_branch"], { timeout: 1e4 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      let branch = stdout.trim();
+      resolve(branch || null);
+    });
+  }) : null;
+}
+async function fetchTreeViaApi(owner, repo, ref) {
+  return await checkGhAvailable() ? new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}/git/trees/${ref}?recursive=1`, "--jq", ".tree[].path"], { timeout: 15e3, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      let paths = stdout.trim().split(`
+`).filter(Boolean);
+      if (paths.length === 0) {
+        resolve(null);
+        return;
+      }
+      let truncated = paths.length > MAX_TREE_ENTRIES, display = paths.slice(0, MAX_TREE_ENTRIES).join(`
+`);
+      resolve(truncated ? display + `
+... (${paths.length} total entries)` : display);
+    });
+  }) : null;
+}
+async function fetchReadmeViaApi(owner, repo, ref) {
+  return await checkGhAvailable() ? new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}/readme?ref=${ref}`, "--jq", ".content"], { timeout: 1e4 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      try {
+        let decoded = Buffer.from(stdout.trim(), "base64").toString("utf-8");
+        resolve(decoded.length > 8192 ? decoded.slice(0, 8192) + `
+
+[README truncated at 8K chars]` : decoded);
+      } catch {
+        resolve(null);
+      }
+    });
+  }) : null;
+}
+async function fetchFileViaApi(owner, repo, path, ref) {
+  return await checkGhAvailable() ? new Promise((resolve) => {
+    execFile("gh", ["api", `repos/${owner}/${repo}/contents/${path}?ref=${ref}`, "--jq", ".content"], { timeout: 1e4, maxBuffer: 2 * 1024 * 1024 }, (err, stdout) => {
+      if (err) {
+        resolve(null);
+        return;
+      }
+      try {
+        resolve(Buffer.from(stdout.trim(), "base64").toString("utf-8"));
+      } catch {
+        resolve(null);
+      }
+    });
+  }) : null;
+}
+async function fetchViaApi(url, owner, repo, info, sizeNote) {
+  let ref = info.ref || await getDefaultBranch(owner, repo);
+  if (!ref)
+    return null;
+  let lines = [];
+  if (sizeNote && (lines.push(sizeNote), lines.push("")), info.type === "blob" && info.path) {
+    let content = await fetchFileViaApi(owner, repo, info.path, ref);
+    return content ? (lines.push(`## ${info.path}`), content.length > MAX_INLINE_FILE_CHARS ? (lines.push(content.slice(0, MAX_INLINE_FILE_CHARS)), lines.push(`
+[File truncated at 100K chars]`)) : lines.push(content), {
+      url,
+      title: `${owner}/${repo} - ${info.path}`,
+      content: lines.join(`
+`),
+      error: null
+    }) : null;
+  }
+  let [tree, readme] = await Promise.all([
+    fetchTreeViaApi(owner, repo, ref),
+    fetchReadmeViaApi(owner, repo, ref)
+  ]);
+  if (!tree && !readme)
+    return null;
+  tree && (lines.push("## Structure"), lines.push(tree), lines.push("")), readme && (lines.push("## README.md"), lines.push(readme), lines.push("")), lines.push("This is an API-only view. Clone the repo or use `read`/`bash` for deeper exploration.");
+  let title = info.path ? `${owner}/${repo} - ${info.path}` : `${owner}/${repo}`;
+  return {
+    url,
+    title,
+    content: lines.join(`
+`),
+    error: null
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/github-extract.js
+var CONFIG_PATH = getWebSearchConfigPath(), BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".svg",
+  ".tiff",
+  ".tif",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".flv",
+  ".wmv",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".flac",
+  ".aac",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".zst",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".o",
+  ".a",
+  ".lib",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".sqlite",
+  ".db",
+  ".sqlite3",
+  ".pyc",
+  ".pyo",
+  ".class",
+  ".jar",
+  ".war",
+  ".iso",
+  ".img",
+  ".dmg"
+]), NOISE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "vendor",
+  ".next",
+  "dist",
+  "build",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".tox",
+  ".mypy_cache",
+  ".pytest_cache",
+  "target",
+  ".gradle",
+  ".idea",
+  ".vscode"
+]), MAX_INLINE_FILE_CHARS2 = 1e5, MAX_TREE_ENTRIES2 = 200, cloneCache = /* @__PURE__ */ new Map(), cachedConfig = null;
+function normalizeEnabled(value, fallback) {
+  return typeof value == "boolean" ? value : fallback;
+}
+function normalizePositiveNumber(value, fallback) {
+  return typeof value != "number" || !Number.isFinite(value) ? fallback : value > 0 ? value : fallback;
+}
+function normalizeClonePath(value, fallback) {
+  if (typeof value != "string")
+    return fallback;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : fallback;
+}
+function loadGitHubConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  let defaults = {
+    enabled: !0,
+    maxRepoSizeMB: 350,
+    cloneTimeoutSeconds: 30,
+    clonePath: "/tmp/pi-github-repos"
+  };
+  if (!existsSync(CONFIG_PATH))
+    return cachedConfig = defaults, cachedConfig;
+  let rawText = readFileSync(CONFIG_PATH, "utf-8"), raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  let gc = raw.githubClone ?? {};
+  return cachedConfig = {
+    enabled: normalizeEnabled(gc.enabled, defaults.enabled),
+    maxRepoSizeMB: normalizePositiveNumber(gc.maxRepoSizeMB, defaults.maxRepoSizeMB),
+    cloneTimeoutSeconds: normalizePositiveNumber(gc.cloneTimeoutSeconds, defaults.cloneTimeoutSeconds),
+    clonePath: normalizeClonePath(gc.clonePath, defaults.clonePath)
+  }, cachedConfig;
+}
+var NON_CODE_SEGMENTS = /* @__PURE__ */ new Set([
+  "issues",
+  "pull",
+  "pulls",
+  "discussions",
+  "releases",
+  "wiki",
+  "actions",
+  "settings",
+  "security",
+  "projects",
+  "graphs",
+  "compare",
+  "commits",
+  "tags",
+  "branches",
+  "stargazers",
+  "watchers",
+  "network",
+  "forks",
+  "milestone",
+  "labels",
+  "packages",
+  "codespaces",
+  "contribute",
+  "community",
+  "sponsors",
+  "invitations",
+  "notifications",
+  "insights"
+]);
+function parseGitHubUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  let host = parsed.hostname.toLowerCase();
+  if (host !== "github.com" && host !== "www.github.com")
+    return null;
+  let segments = parsed.pathname.split("/").filter(Boolean).map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return segment;
+    }
+  });
+  if (segments.length < 2)
+    return null;
+  let owner = segments[0], repo = segments[1].replace(/\.git$/, "");
+  if (NON_CODE_SEGMENTS.has(segments[2]?.toLowerCase()))
+    return null;
+  if (segments.length === 2)
+    return { owner, repo, refIsFullSha: !1, type: "root" };
+  let action = segments[2];
+  if (action !== "blob" && action !== "tree" || segments.length < 4)
+    return null;
+  let ref = segments[3], refIsFullSha = /^[0-9a-f]{40}$/.test(ref), pathParts = segments.slice(4), path = pathParts.length > 0 ? pathParts.join("/") : "";
+  return {
+    owner,
+    repo,
+    ref,
+    refIsFullSha,
+    path,
+    type: action
+  };
+}
+function cacheKey(owner, repo, ref) {
+  return ref ? `${owner}/${repo}@${ref}` : `${owner}/${repo}`;
+}
+function cloneDir(config, owner, repo, ref) {
+  let dirName = ref ? `${repo}@${ref}` : repo;
+  return join(config.clonePath, owner, dirName);
+}
+function execClone(args, localPath, timeoutMs, signal) {
+  return new Promise((resolve) => {
+    let child = execFile2(args[0], args.slice(1), { timeout: timeoutMs }, (err) => {
+      if (err) {
+        try {
+          rmSync(localPath, { recursive: !0, force: !0 });
+        } catch {
+        }
+        resolve(null);
+        return;
+      }
+      resolve(localPath);
+    });
+    if (signal) {
+      let onAbort = () => child.kill();
+      signal.addEventListener("abort", onAbort, { once: !0 }), child.on("exit", () => signal.removeEventListener("abort", onAbort));
+    }
+  });
+}
+async function cloneRepo(owner, repo, ref, config, signal) {
+  let localPath = cloneDir(config, owner, repo, ref);
+  try {
+    rmSync(localPath, { recursive: !0, force: !0 });
+  } catch {
+  }
+  let timeoutMs = config.cloneTimeoutSeconds * 1e3;
+  if (await checkGhAvailable()) {
+    let args2 = ["gh", "repo", "clone", `${owner}/${repo}`, localPath, "--", "--depth", "1", "--single-branch"];
+    return ref && args2.push("--branch", ref), execClone(args2, localPath, timeoutMs, signal);
+  }
+  showGhHint();
+  let gitUrl = `https://github.com/${owner}/${repo}.git`, args = ["git", "clone", "--depth", "1", "--single-branch"];
+  return ref && args.push("--branch", ref), args.push(gitUrl, localPath), execClone(args, localPath, timeoutMs, signal);
+}
+function isBinaryFile(filePath) {
+  let ext = extname(filePath).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext))
+    return !0;
+  let fd;
+  try {
+    fd = openSync(filePath, "r");
+  } catch {
+    return !1;
+  }
+  try {
+    let buf = Buffer.alloc(512), bytesRead = readSync(fd, buf, 0, 512, 0);
+    for (let i = 0; i < bytesRead; i++)
+      if (buf[i] === 0)
+        return !0;
+  } catch {
+    return !1;
+  } finally {
+    closeSync(fd);
+  }
+  return !1;
+}
+function formatFileSize(bytes) {
+  return bytes < 1024 ? `${bytes} B` : bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function resolveWithinRepo(rootPath, relativePath) {
+  let normalizedRoot = resolvePath(rootPath), candidate = resolvePath(normalizedRoot, relativePath);
+  if (candidate !== normalizedRoot) {
+    let rootPrefix = normalizedRoot.endsWith(pathSep) ? normalizedRoot : normalizedRoot + pathSep;
+    if (!candidate.startsWith(rootPrefix))
+      return null;
+  }
+  if (!existsSync(candidate))
+    return candidate;
+  try {
+    let realRoot = realpathSync(normalizedRoot), realCandidate = realpathSync(candidate);
+    if (realCandidate === realRoot)
+      return candidate;
+    let realRootPrefix = realRoot.endsWith(pathSep) ? realRoot : realRoot + pathSep;
+    return realCandidate.startsWith(realRootPrefix) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+function readTextFile(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function buildTree(rootPath) {
+  let entries = [];
+  function walk(dir, relPath) {
+    if (entries.length >= MAX_TREE_ENTRIES2)
+      return;
+    let items;
+    try {
+      items = readdirSync(dir).sort();
+    } catch {
+      return;
+    }
+    for (let item of items) {
+      if (entries.length >= MAX_TREE_ENTRIES2)
+        return;
+      if (item === ".git")
+        continue;
+      let rel = relPath ? `${relPath}/${item}` : item, safePath = resolveWithinRepo(rootPath, rel);
+      if (!safePath) {
+        entries.push(`${rel}  [outside repo skipped]`);
+        continue;
+      }
+      let stat;
+      try {
+        stat = statSync(safePath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (NOISE_DIRS.has(item)) {
+          entries.push(`${rel}/  [skipped]`);
+          continue;
+        }
+        entries.push(`${rel}/`), walk(safePath, rel);
+      } else
+        entries.push(rel);
+    }
+  }
+  return walk(rootPath, ""), entries.length >= MAX_TREE_ENTRIES2 && entries.push(`... (truncated at ${MAX_TREE_ENTRIES2} entries)`), entries.join(`
+`);
+}
+function buildDirListing(rootPath, subPath) {
+  let targetPath = resolveWithinRepo(rootPath, subPath);
+  if (!targetPath)
+    return "(path escapes repository root)";
+  let lines = [], items;
+  try {
+    items = readdirSync(targetPath).sort();
+  } catch {
+    return "(directory not readable)";
+  }
+  for (let item of items) {
+    if (item === ".git")
+      continue;
+    let rel = subPath ? `${subPath}/${item}` : item, safePath = resolveWithinRepo(rootPath, rel);
+    if (!safePath) {
+      lines.push(`  ${item}  (outside repo)`);
+      continue;
+    }
+    try {
+      let stat = statSync(safePath);
+      stat.isDirectory() ? lines.push(`  ${item}/`) : lines.push(`  ${item}  (${formatFileSize(stat.size)})`);
+    } catch {
+      lines.push(`  ${item}  (unreadable)`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function readReadme(localPath) {
+  let candidates = ["README.md", "readme.md", "README", "README.txt", "README.rst"];
+  for (let name of candidates) {
+    let readmePath = join(localPath, name);
+    if (existsSync(readmePath))
+      try {
+        let content = readFileSync(readmePath, "utf-8");
+        return content.length > 8192 ? content.slice(0, 8192) + `
+
+[README truncated at 8K chars]` : content;
+      } catch {
+        continue;
+      }
+  }
+  return null;
+}
+function generateContent(localPath, info) {
+  let lines = [];
+  if (lines.push(`Repository cloned to: ${localPath}`), lines.push(""), info.type === "root") {
+    lines.push("## Structure"), lines.push(buildTree(localPath)), lines.push("");
+    let readme = readReadme(localPath);
+    return readme && (lines.push("## README.md"), lines.push(readme), lines.push("")), lines.push("Use `read` and `bash` tools at the path above to explore further."), lines.join(`
+`);
+  }
+  if (info.type === "tree") {
+    let dirPath = info.path || "", fullDirPath = resolveWithinRepo(localPath, dirPath);
+    return !fullDirPath || !existsSync(fullDirPath) ? (lines.push(`Path \`${dirPath}\` not found in clone. Showing repository root instead.`), lines.push(""), lines.push("## Structure"), lines.push(buildTree(localPath))) : (lines.push(`## ${dirPath || "/"}`), lines.push(buildDirListing(localPath, dirPath))), lines.push(""), lines.push("Use `read` and `bash` tools at the path above to explore further."), lines.join(`
+`);
+  }
+  if (info.type === "blob") {
+    let filePath = info.path || "", fullFilePath = resolveWithinRepo(localPath, filePath);
+    if (!fullFilePath || !existsSync(fullFilePath))
+      return lines.push(`Path \`${filePath}\` not found in clone. Showing repository root instead.`), lines.push(""), lines.push("## Structure"), lines.push(buildTree(localPath)), lines.push(""), lines.push("Use `read` and `bash` tools at the path above to explore further."), lines.join(`
+`);
+    let stat;
+    try {
+      stat = statSync(fullFilePath);
+    } catch (err) {
+      let message = err instanceof Error ? err.message : String(err);
+      return lines.push(`Could not inspect \`${filePath}\`: ${message}`), lines.push(""), lines.push("Use `read` and `bash` tools at the path above to explore further."), lines.join(`
+`);
+    }
+    if (stat.isDirectory())
+      return lines.push(`## ${filePath || "/"}`), lines.push(buildDirListing(localPath, filePath)), lines.push(""), lines.push("Use `read` and `bash` tools at the path above to explore further."), lines.join(`
+`);
+    if (isBinaryFile(fullFilePath)) {
+      let ext = extname(filePath).replace(".", "");
+      return lines.push(`## ${filePath}`), lines.push(`Binary file (${ext}, ${formatFileSize(stat.size)}). Use \`read\` or \`bash\` tools at the path above to inspect.`), lines.join(`
+`);
+    }
+    let content = readTextFile(fullFilePath);
+    return content === null ? (lines.push(`Could not read \`${filePath}\` as UTF-8 text.`), lines.push(""), lines.push("Use `read` and `bash` tools at the path above to explore further."), lines.join(`
+`)) : (lines.push(`## ${filePath}`), content.length > MAX_INLINE_FILE_CHARS2 ? (lines.push(content.slice(0, MAX_INLINE_FILE_CHARS2)), lines.push(""), lines.push(`[File truncated at 100K chars. Full file: ${fullFilePath}]`)) : lines.push(content), lines.push(""), lines.push("Use `read` and `bash` tools at the path above to explore further."), lines.join(`
+`));
+  }
+  return lines.join(`
+`);
+}
+async function awaitCachedClone(cached, url, owner, repo, info, signal) {
+  if (signal?.aborted)
+    return null;
+  let result = await cached.clonePromise;
+  if (signal?.aborted)
+    return null;
+  if (result) {
+    let content = generateContent(result, info), title = info.path ? `${owner}/${repo} - ${info.path}` : `${owner}/${repo}`;
+    return { url, title, content, error: null };
+  }
+  return fetchViaApi(url, owner, repo, info);
+}
+async function extractGitHub(url, signal, forceClone) {
+  let info = parseGitHubUrl(url);
+  if (!info || signal?.aborted)
+    return null;
+  let config = loadGitHubConfig();
+  if (!config.enabled)
+    return null;
+  let { owner, repo } = info, key = cacheKey(owner, repo, info.ref), cached = cloneCache.get(key);
+  if (cached)
+    return awaitCachedClone(cached, url, owner, repo, info, signal);
+  if (info.refIsFullSha)
+    return signal?.aborted ? null : fetchViaApi(url, owner, repo, info, "Note: Commit SHA URLs use the GitHub API instead of cloning.");
+  let activityId = activityMonitor.logStart({ type: "fetch", url: `github.com/${owner}/${repo}` });
+  if (!forceClone) {
+    let sizeKB = await checkRepoSize(owner, repo);
+    if (signal?.aborted)
+      return activityMonitor.logComplete(activityId, 0), null;
+    if (sizeKB !== null) {
+      let sizeMB = sizeKB / 1024;
+      if (sizeMB > config.maxRepoSizeMB) {
+        if (signal?.aborted)
+          return activityMonitor.logComplete(activityId, 0), null;
+        let sizeNote = `Note: Repository is ${Math.round(sizeMB)}MB (threshold: ${config.maxRepoSizeMB}MB). Showing API-fetched content instead of full clone. Ask the user if they'd like to clone the full repo -- if yes, call fetch_content again with the same URL and add forceClone: true to the params.`, apiView = await fetchViaApi(url, owner, repo, info, sizeNote);
+        return apiView ? (activityMonitor.logComplete(activityId, 200), apiView) : (activityMonitor.logError(activityId, "api fallback unavailable for oversized repository"), null);
+      }
+    }
+  }
+  if (signal?.aborted)
+    return activityMonitor.logComplete(activityId, 0), null;
+  let cachedAfterSizeCheck = cloneCache.get(key);
+  if (cachedAfterSizeCheck) {
+    let cachedResult = await awaitCachedClone(cachedAfterSizeCheck, url, owner, repo, info, signal);
+    return signal?.aborted ? activityMonitor.logComplete(activityId, 0) : cachedResult ? activityMonitor.logComplete(activityId, 200) : activityMonitor.logError(activityId, "clone failed"), cachedResult;
+  }
+  let clonePromise = cloneRepo(owner, repo, info.ref, config, signal), localPath = cloneDir(config, owner, repo, info.ref);
+  cloneCache.set(key, { localPath, clonePromise });
+  let result = await clonePromise;
+  if (signal?.aborted)
+    return result || cloneCache.delete(key), activityMonitor.logComplete(activityId, 0), null;
+  if (!result) {
+    if (cloneCache.delete(key), signal?.aborted)
+      return activityMonitor.logComplete(activityId, 0), null;
+    let apiFallback = await fetchViaApi(url, owner, repo, info);
+    return apiFallback ? (activityMonitor.logComplete(activityId, 200), apiFallback) : (activityMonitor.logError(activityId, "clone and API fallback failed"), null);
+  }
+  activityMonitor.logComplete(activityId, 200);
+  let content = generateContent(result, info), title = info.path ? `${owner}/${repo} - ${info.path}` : `${owner}/${repo}`;
+  return { url, title, content, error: null };
+}
+function clearCloneCache() {
+  for (let entry of cloneCache.values())
+    try {
+      rmSync(entry.localPath, { recursive: !0, force: !0 });
+    } catch {
+    }
+  cloneCache.clear(), cachedConfig = null;
+}
+registerSessionCleanup(clearCloneCache);
+export {
+  clearCloneCache,
+  extractGitHub,
+  parseGitHubUrl
+};