ctx7 0.3.13 → 0.4.1

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,8 +453,9 @@ async function getLibraryContext(libraryId, query, options, accessToken) {
   if (options?.type) {
     params.set("type", options.type);
   }
+  const headers = getAuthHeaders(accessToken);
   const response = await fetch(`${baseUrl}/api/v2/context?${params}`, {
-    headers: getAuthHeaders(accessToken)
+    headers
   });
   if (!response.ok) {
     const errorData = await response.json().catch(() => ({}));
@@ -482,6 +483,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 +510,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
@@ -2886,6 +2906,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 +2938,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 +3000,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 +3372,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 +3724,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 +3787,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,8 +3802,8 @@ async function queryCommand(libraryId, query, options) {
     process.exitCode = 1;
     return;
   }
-  const spinner = isTTY ? ora5(`Fetching docs for "${libraryId}"...`).start() : null;
   const accessToken = getAccessToken();
+  const spinner = isTTY ? ora6(`Fetching docs for "${libraryId}"...`).start() : null;
   const outputType = options.json ? "json" : "txt";
   let result;
   try {
@@ -3410,8 +3824,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 +3848,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 +3861,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();
     }
@@ -3462,10 +3876,332 @@ function registerDocsCommands(program2) {
   });
 }
 
+// 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 +4210,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 +4235,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 +4252,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 +4269,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