ctx7 0.3.12 → 0.4.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import pc10 from "picocolors";
+import pc12 from "picocolors";
 import figlet from "figlet";
 
 // src/commands/skill.ts
@@ -453,6 +453,9 @@ async function getLibraryContext(libraryId, query, options, accessToken) {
   if (options?.type) {
     params.set("type", options.type);
   }
+  if (options?.researchMode) {
+    params.set("researchMode", "true");
+  }
   const response = await fetch(`${baseUrl}/api/v2/context?${params}`, {
     headers: getAuthHeaders(accessToken)
   });
@@ -482,6 +485,24 @@ async function getLibraryContext(libraryId, query, options, accessToken) {
 
 // src/utils/logger.ts
 import pc from "picocolors";
+var ANSI_PATTERN = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+function visibleLength(text) {
+  return text.replace(ANSI_PATTERN, "").length;
+}
+function padVisible(text, width) {
+  const padding = Math.max(0, width - visibleLength(text));
+  return text + " ".repeat(padding);
+}
+function box(lines, color = pc.green) {
+  const contentWidth = Math.max(...lines.map((line) => visibleLength(line)), 0);
+  const top = color(`\u250C${"\u2500".repeat(contentWidth + 2)}\u2510`);
+  const bottom = color(`\u2514${"\u2500".repeat(contentWidth + 2)}\u2518`);
+  console.log(top);
+  for (const line of lines) {
+    console.log(color("\u2502 ") + padVisible(line, contentWidth) + color(" \u2502"));
+  }
+  console.log(bottom);
+}
 var log = {
   info: (message) => console.log(pc.cyan(message)),
   success: (message) => console.log(pc.green(`\u2714 ${message}`)),
@@ -491,7 +512,8 @@ var log = {
   item: (message) => console.log(pc.green(`  ${message}`)),
   itemAdd: (message) => console.log(`  ${pc.green("+")} ${message}`),
   plain: (message) => console.log(message),
-  blank: () => console.log("")
+  blank: () => console.log(""),
+  box
 };
 
 // src/utils/ide.ts
@@ -844,7 +866,7 @@ async function installSkillFiles(skillName, files, targetDir) {
   const skillDir = resolve(targetDir, skillName);
   for (const file of files) {
     const filePath = resolve(skillDir, file.path);
-    if (!filePath.startsWith(skillDir + "/") && filePath !== skillDir) {
+    if (!filePath.startsWith(skillDir + "/") && !filePath.startsWith(skillDir + "\\") && filePath !== skillDir) {
       throw new Error(`Skill file path "${file.path}" resolves outside the target directory`);
     }
     const fileDir = dirname3(filePath);
@@ -2761,7 +2783,8 @@ Do not use for: refactoring, writing scripts from scratch, debugging business lo
 1. \`resolve-library-id\` with the library name and the user's question. Use the official library name with proper punctuation (e.g., "Next.js" not "nextjs", "Customer.io" not "customerio", "Three.js" not "threejs")
 2. Pick the best match by: exact name match, description relevance, code snippet count, source reputation (High/Medium preferred), and benchmark score (higher is better). Use version-specific IDs when the user mentions a version
 3. \`query-docs\` with the selected library ID and the user's full question (not single words)
-4. Answer using the fetched docs
+4. If you weren't satisfied with the answer, call \`query-docs\` again for the same library with \`researchMode: true\`. This retries with sandboxed agents that git-pull the actual source repos plus a live web search, then synthesizes a fresh answer. More costly than the default
+5. Answer using the fetched docs
 `;
 var FALLBACK_CLI = `Use the \`ctx7\` CLI to fetch current documentation whenever the user asks about a library, framework, SDK, API, CLI tool, or cloud service -- even well-known ones like React, Next.js, Prisma, Express, Tailwind, Django, or Spring Boot. This includes API syntax, configuration, version migration, library-specific debugging, setup instructions, and CLI tool usage. Use even when you think you know the answer -- your training data may not reflect recent changes. Prefer this over web search for library docs.
 
@@ -2772,7 +2795,8 @@ Do not use for: refactoring, writing scripts from scratch, debugging business lo
 1. Resolve library: \`npx ctx7@latest library <name> "<user's question>"\`
 2. Pick the best match by: exact name match, description relevance, code snippet count, source reputation (High/Medium preferred), and benchmark score (higher is better). If results don't look right, try the full name with punctuation (e.g., "next.js" not "nextjs")
 3. Fetch docs: \`npx ctx7@latest docs <libraryId> "<user's question>"\`
-4. Answer using the fetched documentation
+4. If you weren't satisfied with the answer, re-run the same command with \`--research\`. This retries with sandboxed agents that git-pull the actual source repos plus a live web search, then synthesizes a fresh answer. More costly than the default
+5. Answer using the fetched documentation
 
 You MUST call \`library\` first to get a valid ID (format: \`/org/project\`) unless the user provides one directly. Use the user's full question as the query -- specific and detailed queries return better results than vague single words. Do not run more than 3 commands per question. Do not include sensitive information (API keys, passwords, credentials) in queries.
 
@@ -2886,6 +2910,24 @@ function mergeServerEntry(existing, configKey, serverName, entry) {
     alreadyExists
   };
 }
+function removeServerEntry(existing, configKey, serverName) {
+  const section = existing[configKey];
+  if (!section || typeof section !== "object" || Array.isArray(section)) {
+    return { config: existing, removed: false };
+  }
+  const current = section;
+  if (!(serverName in current)) {
+    return { config: existing, removed: false };
+  }
+  const rest = Object.fromEntries(Object.entries(current).filter(([key]) => key !== serverName));
+  const next = { ...existing };
+  if (Object.keys(rest).length === 0) {
+    delete next[configKey];
+  } else {
+    next[configKey] = rest;
+  }
+  return { config: next, removed: true };
+}
 async function resolveMcpPath(candidates) {
   for (const candidate of candidates) {
     try {
@@ -2900,6 +2942,14 @@ async function writeJsonConfig(filePath, config) {
   await mkdir3(dirname4(filePath), { recursive: true });
   await writeFile3(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
+async function readTomlServerExists(filePath, serverName) {
+  try {
+    const raw = await readFile3(filePath, "utf-8");
+    return raw.includes(`[mcp_servers.${serverName}]`);
+  } catch {
+    return false;
+  }
+}
 function buildTomlServerBlock(serverName, entry) {
   const lines = [`[mcp_servers.${serverName}]`];
   const headers = entry.headers;
@@ -2954,6 +3004,39 @@ async function appendTomlServer(filePath, serverName, entry) {
   }
   return { alreadyExists };
 }
+async function removeTomlServer(filePath, serverName) {
+  let existing = "";
+  try {
+    existing = await readFile3(filePath, "utf-8");
+  } catch {
+    return { removed: false };
+  }
+  const sectionHeader = `[mcp_servers.${serverName}]`;
+  const startIdx = existing.indexOf(sectionHeader);
+  if (startIdx === -1) {
+    return { removed: false };
+  }
+  const subPrefix = `[mcp_servers.${serverName}.`;
+  const rest = existing.slice(startIdx + sectionHeader.length);
+  let endOffset = rest.length;
+  const re = /^\[/gm;
+  let match;
+  while ((match = re.exec(rest)) !== null) {
+    const lineEnd = rest.indexOf("\n", match.index);
+    const line = rest.slice(match.index, lineEnd === -1 ? void 0 : lineEnd);
+    if (!line.startsWith(subPrefix)) {
+      endOffset = match.index;
+      break;
+    }
+  }
+  const rawBefore = existing.slice(0, startIdx).replace(/\n+$/, "");
+  const rawAfter = existing.slice(startIdx + sectionHeader.length + endOffset).replace(/^\n+/, "");
+  const content = [rawBefore, rawAfter].filter(Boolean).join("\n\n");
+  await mkdir3(dirname4(filePath), { recursive: true });
+  await writeFile3(filePath, content.length > 0 ? `${content}
+` : "", "utf-8");
+  return { removed: true };
+}
 
 // src/commands/setup.ts
 var CHECKBOX_THEME = {
@@ -3293,9 +3376,344 @@ async function setupCommand(options) {
   }
 }
 
-// src/commands/docs.ts
+// src/commands/remove.ts
 import pc9 from "picocolors";
 import ora5 from "ora";
+import { join as join10 } from "path";
+import { access as access4, readFile as readFile5, rm as rm3, writeFile as writeFile5 } from "fs/promises";
+var CHECKBOX_THEME2 = {
+  style: {
+    highlight: (text) => pc9.green(text),
+    disabledChoice: (text) => ` ${pc9.dim("\u25EF")} ${pc9.dim(text)}`
+  }
+};
+var CONTEXT7_SECTION_MARKER = "<!-- context7 -->";
+var MODE_SKILLS = {
+  mcp: ["context7-mcp"],
+  cli: ["find-docs"]
+};
+var MODE_LABELS = {
+  mcp: "MCP",
+  cli: "CLI + Skills"
+};
+function registerRemoveCommand(program2) {
+  program2.command("remove").alias("uninstall").description("Remove Context7 setup from your AI coding agent").option("--claude", "Remove from Claude Code").option("--cursor", "Remove from Cursor").option("--opencode", "Remove from OpenCode").option("--codex", "Remove from Codex").option("--gemini", "Remove from Gemini CLI").option("--all", "Remove both MCP setup and CLI + Skills setup").option("--mcp", "Remove MCP setup").option("--cli", "Remove CLI + Skills setup").option("-p, --project", "Remove from the current project instead of global config").option("-y, --yes", "Skip confirmation prompts").action(async (options) => {
+    await removeCommand2(options);
+  });
+}
+function getSelectedAgents2(options) {
+  const agents2 = [];
+  if (options.claude) agents2.push("claude");
+  if (options.cursor) agents2.push("cursor");
+  if (options.opencode) agents2.push("opencode");
+  if (options.codex) agents2.push("codex");
+  if (options.gemini) agents2.push("gemini");
+  return agents2;
+}
+async function promptAgents2(detected) {
+  const choices = detected.map((name) => ({
+    name: SETUP_AGENT_NAMES[name],
+    value: name
+  }));
+  if (detected.length > 0) {
+    log.dim(`Detected: ${detected.map((agent) => SETUP_AGENT_NAMES[agent]).join(", ")}`);
+  }
+  try {
+    return await checkboxWithHover(
+      {
+        message: "Which agents do you want to remove Context7 setup from?",
+        choices,
+        loop: false,
+        theme: CHECKBOX_THEME2
+      },
+      { getName: (agent) => SETUP_AGENT_NAMES[agent] }
+    );
+  } catch {
+    return null;
+  }
+}
+async function promptModes(modes) {
+  const choices = modes.map((mode) => ({
+    name: MODE_LABELS[mode],
+    value: mode
+  }));
+  try {
+    return await checkboxWithHover(
+      {
+        message: "Which Context7 setup modes do you want to remove?",
+        choices,
+        loop: false,
+        theme: CHECKBOX_THEME2
+      },
+      { getName: (mode) => MODE_LABELS[mode] }
+    );
+  } catch {
+    return null;
+  }
+}
+async function resolveAgents2(options, scope) {
+  const explicit = getSelectedAgents2(options);
+  if (explicit.length > 0) return explicit;
+  const detected = await detectConfiguredAgents(scope);
+  if (detected.length > 0 && options.yes) return detected;
+  if (detected.length === 0) {
+    log.warn(
+      "No Context7 setup detected. Pass --claude, --cursor, --opencode, --codex, or --gemini."
+    );
+    return [];
+  }
+  log.blank();
+  const selected = await promptAgents2(detected);
+  if (!selected) {
+    log.warn("Remove cancelled");
+    return [];
+  }
+  return selected;
+}
+function resolveFlagModes(options) {
+  if (options.all) return ["mcp", "cli"];
+  const selected = [];
+  if (options.mcp) selected.push("mcp");
+  if (options.cli) selected.push("cli");
+  return selected.length > 0 ? selected : ["mcp", "cli"];
+}
+async function pathExists2(path2) {
+  try {
+    await access4(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasMcpConfig(agentName, scope) {
+  const agent = getAgent(agentName);
+  const candidates = scope === "global" ? agent.mcp.globalPaths : agent.mcp.projectPaths.map((path2) => join10(process.cwd(), path2));
+  const mcpPath = await resolveMcpPath(candidates);
+  if (mcpPath.endsWith(".toml")) {
+    return readTomlServerExists(mcpPath, "context7");
+  }
+  const existing = await readJsonConfig(mcpPath);
+  const section = existing[agent.mcp.configKey];
+  return !!section && typeof section === "object" && !Array.isArray(section) && "context7" in section;
+}
+async function hasRule(agentName, scope) {
+  const agent = getAgent(agentName);
+  const rule = agent.rule;
+  if (rule.kind === "file") {
+    const ruleDir = scope === "global" ? rule.dir("global") : join10(process.cwd(), rule.dir("project"));
+    return pathExists2(join10(ruleDir, rule.filename));
+  }
+  const filePath = scope === "global" ? rule.file("global") : join10(process.cwd(), rule.file("project"));
+  try {
+    const existing = await readFile5(filePath, "utf-8");
+    return existing.includes(CONTEXT7_SECTION_MARKER);
+  } catch {
+    return false;
+  }
+}
+async function hasSkill(agentName, scope, skillName) {
+  const agent = getAgent(agentName);
+  const skillsDir = scope === "global" ? agent.skill.dir("global") : join10(process.cwd(), agent.skill.dir("project"));
+  return pathExists2(join10(skillsDir, skillName));
+}
+async function detectAvailableModes(agents2, scope) {
+  let hasMcpArtifacts = false;
+  let hasCliArtifacts = false;
+  let hasRuleArtifacts = false;
+  for (const agent of agents2) {
+    hasMcpArtifacts = hasMcpArtifacts || await hasMcpConfig(agent, scope) || await hasSkill(agent, scope, MODE_SKILLS.mcp[0]);
+    hasCliArtifacts = hasCliArtifacts || await hasSkill(agent, scope, MODE_SKILLS.cli[0]);
+    hasRuleArtifacts = hasRuleArtifacts || await hasRule(agent, scope);
+  }
+  const modes = [];
+  if (hasMcpArtifacts) modes.push("mcp");
+  if (hasCliArtifacts) modes.push("cli");
+  if (modes.length === 0 && hasRuleArtifacts) {
+    return ["mcp", "cli"];
+  }
+  return modes;
+}
+async function hasAnyContext7Artifacts(agent, scope) {
+  return await hasMcpConfig(agent, scope) || await hasRule(agent, scope) || await hasSkill(agent, scope, MODE_SKILLS.mcp[0]) || await hasSkill(agent, scope, MODE_SKILLS.cli[0]);
+}
+async function detectConfiguredAgents(scope) {
+  const detected = [];
+  for (const agent of ALL_AGENT_NAMES) {
+    if (await hasAnyContext7Artifacts(agent, scope)) {
+      detected.push(agent);
+    }
+  }
+  return detected;
+}
+async function resolveModes(options, agents2, scope) {
+  if (options.all || options.mcp || options.cli) {
+    return resolveFlagModes(options);
+  }
+  const detectedModes = await detectAvailableModes(agents2, scope);
+  if (detectedModes.length <= 1) {
+    return detectedModes.length === 1 ? detectedModes : ["mcp", "cli"];
+  }
+  if (options.yes) {
+    return detectedModes;
+  }
+  log.blank();
+  const selected = await promptModes(detectedModes);
+  if (!selected) {
+    log.warn("Remove cancelled");
+    return [];
+  }
+  return selected;
+}
+async function uninstallMcp(agentName, scope) {
+  const agent = getAgent(agentName);
+  const mcpCandidates = scope === "global" ? agent.mcp.globalPaths : agent.mcp.projectPaths.map((path2) => join10(process.cwd(), path2));
+  const mcpPath = await resolveMcpPath(mcpCandidates);
+  try {
+    if (mcpPath.endsWith(".toml")) {
+      const { removed: removed2 } = await removeTomlServer(mcpPath, "context7");
+      return { status: removed2 ? "removed" : "not found", path: mcpPath };
+    }
+    const existing = await readJsonConfig(mcpPath);
+    const { config, removed } = removeServerEntry(existing, agent.mcp.configKey, "context7");
+    if (removed) {
+      await writeJsonConfig(mcpPath, config);
+    }
+    return { status: removed ? "removed" : "not found", path: mcpPath };
+  } catch (err) {
+    return { status: `failed: ${err instanceof Error ? err.message : String(err)}`, path: mcpPath };
+  }
+}
+async function uninstallRule(agentName, scope) {
+  const agent = getAgent(agentName);
+  const rule = agent.rule;
+  if (rule.kind === "file") {
+    const rulePath = scope === "global" ? rule.dir("global") : join10(process.cwd(), rule.dir("project"));
+    const targetPath = join10(rulePath, rule.filename);
+    try {
+      await rm3(targetPath);
+      return { status: "removed", path: targetPath };
+    } catch (err) {
+      const error = err;
+      if (error.code === "ENOENT") return { status: "not found", path: targetPath };
+      return { status: `failed: ${error.message}`, path: targetPath };
+    }
+  }
+  const filePath = scope === "global" ? rule.file("global") : join10(process.cwd(), rule.file("project"));
+  try {
+    const existing = await readFile5(filePath, "utf-8");
+    if (!existing.includes(CONTEXT7_SECTION_MARKER)) {
+      return { status: "not found", path: filePath };
+    }
+    const escapedMarker = CONTEXT7_SECTION_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const updated = existing.replace(new RegExp(`\\n?${escapedMarker}\\n[\\s\\S]*?${escapedMarker}\\n?`, "m"), "").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "").trimEnd();
+    if (updated.length === 0) {
+      await rm3(filePath);
+    } else {
+      await writeFile5(filePath, `${updated}
+`, "utf-8");
+    }
+    return { status: "removed", path: filePath };
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT") return { status: "not found", path: filePath };
+    return { status: `failed: ${error.message}`, path: filePath };
+  }
+}
+async function uninstallSkills(agentName, scope, skillNames) {
+  const agent = getAgent(agentName);
+  const skillsDir = scope === "global" ? agent.skill.dir("global") : join10(process.cwd(), agent.skill.dir("project"));
+  const results = [];
+  for (const skillName of skillNames) {
+    const skillPath = join10(skillsDir, skillName);
+    try {
+      await rm3(skillPath, { recursive: true });
+      results.push({ name: skillName, status: "removed", path: skillPath });
+    } catch (err) {
+      const error = err;
+      if (error.code === "ENOENT") {
+        results.push({ name: skillName, status: "not found", path: skillPath });
+      } else {
+        results.push({ name: skillName, status: `failed: ${error.message}`, path: skillPath });
+      }
+    }
+  }
+  return results;
+}
+async function uninstallAgent(agentName, scope, modes) {
+  const result = { agent: getAgent(agentName).displayName };
+  const skillNames = Array.from(new Set(modes.flatMap((mode) => [...MODE_SKILLS[mode]])));
+  const shouldRemoveRule = modes.includes("mcp") || modes.includes("cli");
+  if (modes.includes("mcp")) {
+    result.mcp = await uninstallMcp(agentName, scope);
+  }
+  if (shouldRemoveRule) {
+    result.rule = await uninstallRule(agentName, scope);
+  }
+  if (skillNames.length > 0) {
+    result.skills = await uninstallSkills(agentName, scope, skillNames);
+  }
+  return result;
+}
+function iconForStatus(status) {
+  if (status === "removed") return pc9.green("-");
+  if (status === "not found") return pc9.dim("~");
+  return pc9.red("!");
+}
+function printResults(results, modes) {
+  log.blank();
+  const shouldPrintRule = modes.includes("mcp") || modes.includes("cli");
+  let hasVisibleResults = false;
+  for (const result of results) {
+    const visibleSkills = result.skills?.filter((skill) => skill.status !== "not found") ?? [];
+    const showMcp = modes.includes("mcp") && result.mcp && result.mcp.status !== "not found";
+    const showRule = shouldPrintRule && result.rule && result.rule.status !== "not found";
+    if (!showMcp && !showRule && visibleSkills.length === 0) {
+      continue;
+    }
+    hasVisibleResults = true;
+    log.plain(`  ${pc9.bold(result.agent)}`);
+    if (showMcp && result.mcp) {
+      log.plain(`    ${iconForStatus(result.mcp.status)} MCP config ${result.mcp.status}`);
+      log.plain(`      ${pc9.dim(result.mcp.path)}`);
+    }
+    if (showRule && result.rule) {
+      log.plain(`    ${iconForStatus(result.rule.status)} Rule ${result.rule.status}`);
+      log.plain(`      ${pc9.dim(result.rule.path)}`);
+    }
+    for (const skill of visibleSkills) {
+      log.plain(`    ${iconForStatus(skill.status)} Skill ${skill.name} ${skill.status}`);
+      log.plain(`      ${pc9.dim(skill.path)}`);
+    }
+  }
+  if (hasVisibleResults) {
+    log.blank();
+  } else {
+    log.plain(`  ${pc9.dim("No matching Context7 setup was found to remove.")}`);
+    log.blank();
+  }
+}
+async function removeCommand2(options) {
+  trackEvent("command", { name: "remove" });
+  const scope = options.project ? "project" : "global";
+  const agents2 = await resolveAgents2(options, scope);
+  if (agents2.length === 0) return;
+  const modes = await resolveModes(options, agents2, scope);
+  if (modes.length === 0) return;
+  log.blank();
+  const spinner = ora5("Removing Context7 setup...").start();
+  const results = [];
+  for (const agentName of agents2) {
+    spinner.text = `Cleaning up ${getAgent(agentName).displayName}...`;
+    results.push(await uninstallAgent(agentName, scope, modes));
+  }
+  spinner.succeed("Context7 cleanup complete");
+  printResults(results, modes);
+  trackEvent("remove", { agents: agents2, scope, modes });
+}
+
+// src/commands/docs.ts
+import pc10 from "picocolors";
+import ora6 from "ora";
 var isTTY = process.stdout.isTTY;
 function getReputationLabel(score) {
   if (score === void 0 || score < 0) return "Unknown";
@@ -3310,28 +3728,28 @@ function getAccessToken() {
 }
 function formatLibraryResult(lib, index) {
   const lines = [];
-  lines.push(`${pc9.dim(`${index + 1}.`)} ${pc9.bold(`Title: ${lib.title}`)}`);
-  lines.push(`   ${pc9.cyan(`Context7-compatible library ID: ${lib.id}`)}`);
+  lines.push(`${pc10.dim(`${index + 1}.`)} ${pc10.bold(`Title: ${lib.title}`)}`);
+  lines.push(`   ${pc10.cyan(`Context7-compatible library ID: ${lib.id}`)}`);
   if (lib.description) {
-    lines.push(`   ${pc9.dim(`Description: ${lib.description}`)}`);
+    lines.push(`   ${pc10.dim(`Description: ${lib.description}`)}`);
   }
   if (lib.totalSnippets) {
-    lines.push(`   ${pc9.dim(`Code Snippets: ${lib.totalSnippets}`)}`);
+    lines.push(`   ${pc10.dim(`Code Snippets: ${lib.totalSnippets}`)}`);
   }
   if (lib.trustScore !== void 0) {
-    lines.push(`   ${pc9.dim(`Source Reputation: ${getReputationLabel(lib.trustScore)}`)}`);
+    lines.push(`   ${pc10.dim(`Source Reputation: ${getReputationLabel(lib.trustScore)}`)}`);
   }
   if (lib.benchmarkScore !== void 0 && lib.benchmarkScore > 0) {
-    lines.push(`   ${pc9.dim(`Benchmark Score: ${lib.benchmarkScore}`)}`);
+    lines.push(`   ${pc10.dim(`Benchmark Score: ${lib.benchmarkScore}`)}`);
   }
   if (lib.versions && lib.versions.length > 0) {
-    lines.push(`   ${pc9.dim(`Versions: ${lib.versions.join(", ")}`)}`);
+    lines.push(`   ${pc10.dim(`Versions: ${lib.versions.join(", ")}`)}`);
   }
   return lines.join("\n");
 }
 async function resolveCommand(library, query, options) {
   trackEvent("command", { name: "library" });
-  const spinner = isTTY ? ora5(`Searching for "${library}"...`).start() : null;
+  const spinner = isTTY ? ora6(`Searching for "${library}"...`).start() : null;
   const accessToken = getAccessToken();
   let data;
   try {
@@ -3373,8 +3791,8 @@ async function resolveCommand(library, query, options) {
   if (isTTY && results.length > 0) {
     const best = results[0];
     log.plain(
-      `${pc9.bold("Quick command:")}
-  ${pc9.cyan(`ctx7 docs "${best.id}" "<your question>"`)}`
+      `${pc10.bold("Quick command:")}
+  ${pc10.cyan(`ctx7 docs "${best.id}" "<your question>"`)}`
     );
     log.blank();
   }
@@ -3388,12 +3806,19 @@ async function queryCommand(libraryId, query, options) {
     process.exitCode = 1;
     return;
   }
-  const spinner = isTTY ? ora5(`Fetching docs for "${libraryId}"...`).start() : null;
+  const spinner = isTTY ? ora6(
+    options.research ? `Researching "${libraryId}"...` : `Fetching docs for "${libraryId}"...`
+  ).start() : null;
   const accessToken = getAccessToken();
   const outputType = options.json ? "json" : "txt";
   let result;
   try {
-    result = await getLibraryContext(libraryId, query, { type: outputType }, accessToken);
+    result = await getLibraryContext(
+      libraryId,
+      query,
+      { type: outputType, researchMode: options.research },
+      accessToken
+    );
   } catch (err) {
     spinner?.fail(`Error: ${err instanceof Error ? err.message : String(err)}`);
     if (!spinner) log.error(err instanceof Error ? err.message : String(err));
@@ -3410,8 +3835,8 @@ async function queryCommand(libraryId, query, options) {
     if (ctx.redirectUrl) {
       spinner?.warn("Library has been redirected");
       if (!spinner) log.warn("Library has been redirected");
-      log.info(`New ID: ${pc9.cyan(ctx.redirectUrl)}`);
-      log.info(`Run: ${pc9.cyan(`ctx7 docs "${ctx.redirectUrl}" "${query}"`)}`);
+      log.info(`New ID: ${pc10.cyan(ctx.redirectUrl)}`);
+      log.info(`Run: ${pc10.cyan(`ctx7 docs "${ctx.redirectUrl}" "${query}"`)}`);
       process.exitCode = 1;
       return;
     }
@@ -3434,7 +3859,7 @@ async function queryCommand(libraryId, query, options) {
   log.blank();
   if (ctx.codeSnippets) {
     for (const snippet of ctx.codeSnippets) {
-      log.plain(pc9.bold(snippet.codeTitle));
+      log.plain(pc10.bold(snippet.codeTitle));
       if (snippet.codeDescription) log.dim(snippet.codeDescription);
       log.blank();
       for (const code of snippet.codeList) {
@@ -3447,7 +3872,7 @@ async function queryCommand(libraryId, query, options) {
   }
   if (ctx.infoSnippets) {
     for (const snippet of ctx.infoSnippets) {
-      if (snippet.breadcrumb) log.plain(pc9.bold(snippet.breadcrumb));
+      if (snippet.breadcrumb) log.plain(pc10.bold(snippet.breadcrumb));
       log.plain(snippet.content);
       log.blank();
     }
@@ -3457,15 +3882,342 @@ function registerDocsCommands(program2) {
   program2.command("library").argument("<name>", "Library name to search for").argument("[query]", "Question or task for relevance ranking").option("--json", "Output as JSON").description("Resolve a library name to a Context7 library ID").action(async (name, query, options) => {
     await resolveCommand(name, query, options);
   });
-  program2.command("docs").argument("<libraryId>", "Context7 library ID (e.g., /facebook/react)").argument("<query>", "Question or task to get docs for").option("--json", "Output as JSON").description("Query documentation for a library").action(async (libraryId, query, options) => {
-    await queryCommand(libraryId, query, options);
+  program2.command("docs").argument("<libraryId>", "Context7 library ID (e.g., /facebook/react)").argument("<query>", "Question or task to get docs for").option("--json", "Output as JSON").option(
+    "--research",
+    "Retry the query with deep research: spins up sandboxed agents that read the actual source repos (git pull + inspect) and runs a live web search, then synthesizes a fresh answer. Use on retry if you weren't satisfied with the first answer. More costly than the default."
+  ).description("Query documentation for a library").action(
+    async (libraryId, query, options) => {
+      await queryCommand(libraryId, query, options);
+    }
+  );
+}
+
+// src/commands/upgrade.ts
+import { confirm as confirm2 } from "@inquirer/prompts";
+import { spawn as spawn2 } from "child_process";
+import pc11 from "picocolors";
+
+// src/utils/update-check.ts
+import { homedir as homedir6 } from "os";
+import { dirname as dirname6, join as join11 } from "path";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_STATE_FILE = join11(homedir6(), ".context7", "cli-state.json");
+function getStateFilePath(stateFile) {
+  return stateFile ?? UPDATE_STATE_FILE;
+}
+async function readUpdateState(stateFile) {
+  try {
+    const raw = await readFile6(getStateFilePath(stateFile), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function writeUpdateState(state, stateFile) {
+  const path2 = getStateFilePath(stateFile);
+  await mkdir5(dirname6(path2), { recursive: true });
+  await writeFile6(path2, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+function compareVersions(a, b) {
+  const normalize = (version) => version.split("-", 1)[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = normalize(a);
+  const right = normalize(b);
+  const max = Math.max(left.length, right.length);
+  for (let i = 0; i < max; i++) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function detectInstallMethod(env = process.env) {
+  const execPath = env.npm_execpath?.toLowerCase() ?? "";
+  const npmCommand = env.npm_command?.toLowerCase() ?? "";
+  const userAgent = env.npm_config_user_agent?.toLowerCase() ?? "";
+  if (execPath.includes("pnpm") && npmCommand === "dlx") return "pnpm-dlx";
+  if (execPath.includes("pnpm")) return "pnpm-global";
+  if (execPath.includes("bun") && npmCommand === "x") return "bunx";
+  if (execPath.includes("bun")) return "bun-global";
+  if (execPath.includes("npm") && npmCommand === "exec") return "npx";
+  if (execPath.includes("npm")) return "npm-global";
+  if (userAgent.startsWith("pnpm/")) return "pnpm-global";
+  if (userAgent.startsWith("bun/")) return "bun-global";
+  if (userAgent.startsWith("npm/")) return "npm-global";
+  return "unknown";
+}
+function getUpgradePlan(installMethod = detectInstallMethod(), packageName = NAME) {
+  switch (installMethod) {
+    case "pnpm-global":
+      return {
+        installMethod,
+        command: "pnpm",
+        args: ["add", "-g", `${packageName}@latest`],
+        displayCommand: `pnpm add -g ${packageName}@latest`,
+        canRun: true,
+        needsExplicitVersion: false
+      };
+    case "bun-global":
+      return {
+        installMethod,
+        command: "bun",
+        args: ["add", "-g", `${packageName}@latest`],
+        displayCommand: `bun add -g ${packageName}@latest`,
+        canRun: true,
+        needsExplicitVersion: false
+      };
+    case "npx":
+      return {
+        installMethod,
+        command: "npx",
+        args: [`${packageName}@latest`],
+        displayCommand: `npx ${packageName}@latest <command>`,
+        canRun: false,
+        needsExplicitVersion: true
+      };
+    case "pnpm-dlx":
+      return {
+        installMethod,
+        command: "pnpm",
+        args: ["dlx", `${packageName}@latest`],
+        displayCommand: `pnpm dlx ${packageName}@latest <command>`,
+        canRun: false,
+        needsExplicitVersion: true
+      };
+    case "bunx":
+      return {
+        installMethod,
+        command: "bunx",
+        args: [`${packageName}@latest`],
+        displayCommand: `bunx ${packageName}@latest <command>`,
+        canRun: false,
+        needsExplicitVersion: true
+      };
+    case "unknown":
+      return {
+        installMethod,
+        command: "npm",
+        args: ["install", "-g", `${packageName}@latest`],
+        displayCommand: `npm install -g ${packageName}@latest`,
+        canRun: false,
+        needsExplicitVersion: false
+      };
+    case "npm-global":
+    default:
+      return {
+        installMethod: "npm-global",
+        command: "npm",
+        args: ["install", "-g", `${packageName}@latest`],
+        displayCommand: `npm install -g ${packageName}@latest`,
+        canRun: true,
+        needsExplicitVersion: false
+      };
+  }
+}
+async function fetchLatestVersion(packageName = NAME) {
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
+      {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(1500)
+      }
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdates(options = {}) {
+  const now = options.now ?? Date.now();
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+  const stateFile = options.stateFile;
+  const state = await readUpdateState(stateFile);
+  const isStale = options.force || !state.lastCheckedAt || now - state.lastCheckedAt >= cacheTtlMs || !state.latestVersion;
+  let latestVersion = state.latestVersion ?? null;
+  if (isStale) {
+    const fetchedVersion = await fetchLatestVersion();
+    if (fetchedVersion) {
+      latestVersion = fetchedVersion;
+      await writeUpdateState(
+        {
+          ...state,
+          latestVersion: fetchedVersion,
+          lastCheckedAt: now
+        },
+        stateFile
+      );
+    }
+  }
+  if (!latestVersion) return null;
+  const installMethod = detectInstallMethod();
+  return {
+    currentVersion: VERSION,
+    latestVersion,
+    updateAvailable: compareVersions(latestVersion, VERSION) > 0,
+    installMethod,
+    upgradePlan: getUpgradePlan(installMethod)
+  };
+}
+async function shouldShowUpdateNotification(info, options = {}) {
+  if (!info.updateAvailable) return false;
+  const now = options.now ?? Date.now();
+  const cooldownMs = options.cooldownMs ?? DEFAULT_CACHE_TTL_MS;
+  const state = await readUpdateState(options.stateFile);
+  if (state.notifiedVersion === info.latestVersion && state.lastNotifiedAt && now - state.lastNotifiedAt < cooldownMs) {
+    return false;
+  }
+  return true;
+}
+async function markUpdateNotificationShown(latestVersion, options = {}) {
+  const now = options.now ?? Date.now();
+  const state = await readUpdateState(options.stateFile);
+  await writeUpdateState(
+    {
+      ...state,
+      notifiedVersion: latestVersion,
+      lastNotifiedAt: now
+    },
+    options.stateFile
+  );
+}
+function shouldSkipUpdateNotifier(argv = process.argv) {
+  return argv.includes("--json") || argv.includes("-v") || argv.includes("--version");
+}
+
+// src/commands/upgrade.ts
+function registerUpgradeCommand(program2) {
+  program2.command("upgrade").description("Check for a newer ctx7 version and upgrade when possible").option("-y, --yes", "Run the suggested upgrade command without prompting").option("--check", "Only check for updates without running the upgrade command").action(async (options) => {
+    await upgradeCommand(options);
+  });
+}
+function runCommand(command, args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn2(command, args, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2(code));
   });
 }
+async function runUpgradePlan(plan) {
+  return runCommand(plan.command, plan.args);
+}
+function showUpgradeFailureHelp(plan) {
+  log.info(`Try rerunning: ${pc11.cyan(plan.displayCommand)}`);
+  const isGlobalNpmInstall = (plan.installMethod === "npm-global" || plan.installMethod === "unknown") && plan.command === "npm" && plan.args.includes("-g");
+  const isGlobalAltInstall = (plan.installMethod === "pnpm-global" || plan.installMethod === "bun-global") && plan.args.includes("-g");
+  if (isGlobalNpmInstall) {
+    log.dim(
+      "If this failed due to permissions, your global npm directory may require elevated privileges on this machine."
+    );
+  } else if (isGlobalAltInstall) {
+    log.dim(
+      "If this failed due to permissions, your global package manager install location may require additional privileges on this machine."
+    );
+  }
+}
+async function maybeShowUpgradeNotice(options = {}) {
+  const actionName = options.actionName ?? "";
+  const argv = options.argv ?? process.argv;
+  const isInteractive = options.isInteractive ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  if (!isInteractive || shouldSkipUpdateNotifier(argv) || actionName === "upgrade") {
+    return;
+  }
+  const info = await checkForUpdates();
+  if (!info || !info.updateAvailable || !await shouldShowUpdateNotification(info)) {
+    return;
+  }
+  log.blank();
+  if (info.upgradePlan.needsExplicitVersion) {
+    log.box([
+      `${pc11.white(pc11.bold("Update available:"))} ${pc11.green(pc11.bold(`v${info.currentVersion}`))} ${pc11.dim("->")} ${pc11.green(pc11.bold(`v${info.latestVersion}`))}`,
+      `${pc11.white("Use")} ${pc11.yellow(pc11.bold(info.upgradePlan.displayCommand))} ${pc11.white("to run the latest version")}`
+    ]);
+    await markUpdateNotificationShown(info.latestVersion);
+    log.blank();
+    return;
+  }
+  if (!info.upgradePlan.canRun) {
+    log.box([
+      `${pc11.white(pc11.bold("Update available:"))} ${pc11.green(pc11.bold(`v${info.currentVersion}`))} ${pc11.dim("->")} ${pc11.green(pc11.bold(`v${info.latestVersion}`))}`,
+      `${pc11.white("Run")} ${pc11.yellow(pc11.bold("ctx7 upgrade"))} ${pc11.white("for update steps")}`,
+      `${pc11.white("Or run")} ${pc11.yellow(info.upgradePlan.displayCommand)}`
+    ]);
+    await markUpdateNotificationShown(info.latestVersion);
+    log.blank();
+    return;
+  }
+  log.box([
+    `${pc11.white(pc11.bold("Update available:"))} ${pc11.green(pc11.bold(`v${info.currentVersion}`))} ${pc11.dim("->")} ${pc11.green(pc11.bold(`v${info.latestVersion}`))}`,
+    `${pc11.white("Run")} ${pc11.yellow(pc11.bold("ctx7 upgrade"))} ${pc11.white("to update now")}`,
+    `${pc11.white("Or run")} ${pc11.yellow(info.upgradePlan.displayCommand)}`
+  ]);
+  await markUpdateNotificationShown(info.latestVersion);
+  log.blank();
+}
+async function upgradeCommand(options) {
+  trackEvent("command", { name: "upgrade" });
+  const info = await checkForUpdates({ force: true });
+  const plan = info?.upgradePlan ?? getUpgradePlan();
+  if (!info) {
+    log.warn("Couldn't check for updates right now.");
+    log.info(`Try again later or run ${pc11.cyan(plan.displayCommand)} manually.`);
+    return;
+  }
+  if (!info.updateAvailable) {
+    log.success(`ctx7 is up to date (${pc11.bold(`v${VERSION}`)})`);
+    return;
+  }
+  log.blank();
+  log.info(
+    `Update available: ${pc11.bold(`v${info.currentVersion}`)} ${pc11.dim("->")} ${pc11.bold(`v${info.latestVersion}`)}`
+  );
+  if (plan.needsExplicitVersion) {
+    log.info(`You're using an ephemeral runner (${plan.installMethod}).`);
+    log.info(`Use ${pc11.cyan(plan.displayCommand)} to run the latest version immediately.`);
+    log.info(`Or install globally with ${pc11.cyan("npm install -g ctx7@latest")}.`);
+    return;
+  }
+  if (!plan.canRun) {
+    log.info(`Run ${pc11.cyan(plan.displayCommand)} to update your installed version.`);
+    return;
+  }
+  log.info(`Upgrade command: ${pc11.cyan(plan.displayCommand)}`);
+  if (options.check) {
+    return;
+  }
+  let shouldRun = options.yes ?? false;
+  if (!shouldRun && process.stdout.isTTY) {
+    shouldRun = await confirm2({
+      message: `Run ${plan.displayCommand} now?`,
+      default: true
+    });
+  }
+  if (!shouldRun) {
+    log.dim("Upgrade skipped.");
+    return;
+  }
+  log.blank();
+  const exitCode = await runUpgradePlan(plan);
+  if (exitCode === 0) {
+    log.blank();
+    log.success("Upgrade complete.");
+    log.info(`Run ${pc11.cyan("ctx7 --version")} to verify the installed version.`);
+    return;
+  }
+  log.blank();
+  log.error(`Upgrade command exited with code ${exitCode ?? "unknown"}.`);
+  showUpgradeFailureHelp(plan);
+  process.exitCode = 1;
+}
 
 // src/index.ts
 var brand = {
-  primary: pc10.green,
-  dim: pc10.dim
+  primary: pc12.green,
+  dim: pc12.dim
 };
 var program = new Command();
 program.name("ctx7").description("Context7 CLI - Manage AI coding skills and documentation context").version(VERSION).option("--base-url <url>").hook("preAction", (thisCommand) => {
@@ -3474,6 +4226,11 @@ program.name("ctx7").description("Context7 CLI - Manage AI coding skills and doc
     setBaseUrl(opts.baseUrl);
     setAuthBaseUrl(opts.baseUrl);
   }
+}).hook("preAction", async (_thisCommand, actionCommand) => {
+  await maybeShowUpgradeNotice({
+    actionName: actionCommand.name(),
+    argv: process.argv
+  });
 }).addHelpText(
   "after",
   `
@@ -3494,6 +4251,12 @@ Examples:
   ${brand.primary("npx ctx7 skills list --claude")}
   ${brand.primary("npx ctx7 skills remove pdf")}
 
+  ${brand.dim("# Remove Context7 setup")}
+  ${brand.primary("npx ctx7 remove --cursor")}
+  ${brand.primary("npx ctx7 remove --cursor --all")}
+  ${brand.primary("npx ctx7 remove --cursor --cli")}
+  ${brand.primary("npx ctx7 remove --claude --mcp")}
+
   ${brand.dim("# Query library documentation")}
   ${brand.primary('npx ctx7 library react "how to use hooks"')}
   ${brand.primary('npx ctx7 docs /facebook/react "useEffect examples"')}
@@ -3505,7 +4268,9 @@ registerSkillCommands(program);
 registerSkillAliases(program);
 registerAuthCommands(program);
 registerSetupCommand(program);
+registerRemoveCommand(program);
 registerDocsCommands(program);
+registerUpgradeCommand(program);
 program.action(() => {
   console.log("");
   const banner = figlet.textSync("Context7", { font: "ANSI Shadow" });
@@ -3520,5 +4285,5 @@ program.action(() => {
   console.log(`  Visit ${brand.primary("https://context7.com")} to browse skills`);
   console.log("");
 });
-program.parse();
+await program.parseAsync();
 //# sourceMappingURL=index.js.map