ctx7 0.1.4 → 0.2.0

package/dist/index.js

@@ -2,26 +2,25 @@
 
 // src/index.ts
 import { Command } from "commander";
-import pc4 from "picocolors";
+import pc8 from "picocolors";
 import figlet from "figlet";
 
 // src/commands/skill.ts
-import pc3 from "picocolors";
-import { checkbox as checkbox2 } from "@inquirer/prompts";
-import ora from "ora";
+import pc6 from "picocolors";
+import ora2 from "ora";
 import { readdir, rm as rm2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 
 // src/utils/parse-input.ts
-function parseSkillInput(input) {
-  const urlMatch = input.match(
+function parseSkillInput(input2) {
+  const urlMatch = input2.match(
     /(?:https?:\/\/)?github\.com\/([^\/]+)\/([^\/]+)\/tree\/([^\/]+)\/(.+)/
   );
   if (urlMatch) {
-    const [, owner, repo, branch, path] = urlMatch;
-    return { type: "url", owner, repo, branch, path };
+    const [, owner, repo, branch, path2] = urlMatch;
+    return { type: "url", owner, repo, branch, path: path2 };
   }
-  const shortMatch = input.match(/^\/?([^\/]+)\/([^\/]+)$/);
+  const shortMatch = input2.match(/^\/?([^\/]+)\/([^\/]+)$/);
   if (shortMatch) {
     const [, owner, repo] = shortMatch;
     return { type: "repo", owner, repo };
@@ -46,24 +45,24 @@ function parseGitHubUrl(url) {
         if (pathParts2.length > 0 && pathParts2[pathParts2.length - 1].includes(".")) {
           pathParts2.pop();
         }
-        const path2 = pathParts2.join("/");
-        return { owner, repo, branch: branch2, path: path2 };
+        const path3 = pathParts2.join("/");
+        return { owner, repo, branch: branch2, path: path3 };
       }
       const branch = parts[2];
       const pathParts = parts.slice(3);
       if (pathParts.length > 0 && pathParts[pathParts.length - 1].includes(".")) {
         pathParts.pop();
       }
-      const path = pathParts.join("/");
-      return { owner, repo, branch, path };
+      const path2 = pathParts.join("/");
+      return { owner, repo, branch, path: path2 };
     }
     if (urlObj.hostname === "github.com") {
       if (parts.length < 4 || parts[2] !== "tree") return null;
       const owner = parts[0];
       const repo = parts[1];
       const branch = parts[3];
-      const path = parts.slice(4).join("/");
-      return { owner, repo, branch, path };
+      const path2 = parts.slice(4).join("/");
+      return { owner, repo, branch, path: path2 };
     }
     return null;
   } catch {
@@ -166,6 +165,124 @@ async function downloadSkill(project, skillName) {
   }
   return { skill, files };
 }
+async function searchLibraries(query, accessToken) {
+  const params = new URLSearchParams({ query });
+  const headers = {};
+  if (accessToken) {
+    headers["Authorization"] = `Bearer ${accessToken}`;
+  }
+  const response = await fetch(`${baseUrl}/api/v2/libs/search?${params}`, { headers });
+  return await response.json();
+}
+async function getSkillQuota(accessToken) {
+  const response = await fetch(`${baseUrl}/api/v2/skills/quota`, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    return {
+      used: 0,
+      limit: 0,
+      remaining: 0,
+      tier: "free",
+      resetDate: null,
+      error: errorData.message || `HTTP error ${response.status}`
+    };
+  }
+  return await response.json();
+}
+async function getSkillQuestions(libraries, motivation, accessToken) {
+  const headers = { "Content-Type": "application/json" };
+  if (accessToken) {
+    headers["Authorization"] = `Bearer ${accessToken}`;
+  }
+  const response = await fetch(`${baseUrl}/api/v2/skills/questions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ libraries, motivation })
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    return {
+      questions: [],
+      error: errorData.message || `HTTP error ${response.status}`
+    };
+  }
+  return await response.json();
+}
+async function generateSkillStructured(input2, onEvent, accessToken) {
+  const headers = { "Content-Type": "application/json" };
+  if (accessToken) {
+    headers["Authorization"] = `Bearer ${accessToken}`;
+  }
+  const response = await fetch(`${baseUrl}/api/v2/skills/generate`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(input2)
+  });
+  const libraryName = input2.libraries[0]?.name || "skill";
+  return handleGenerateResponse(response, libraryName, onEvent);
+}
+async function handleGenerateResponse(response, libraryName, onEvent) {
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    return {
+      content: "",
+      libraryName,
+      error: errorData.message || `HTTP error ${response.status}`
+    };
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return { content: "", libraryName, error: "No response body" };
+  }
+  const decoder = new TextDecoder();
+  let content = "";
+  let finalLibraryName = libraryName;
+  let error;
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const chunk = decoder.decode(value, { stream: true });
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine) continue;
+      try {
+        const data = JSON.parse(trimmedLine);
+        if (onEvent) {
+          onEvent(data);
+        }
+        if (data.type === "complete") {
+          content = data.content || "";
+          finalLibraryName = data.libraryName || libraryName;
+        } else if (data.type === "error") {
+          error = data.message;
+        }
+      } catch {
+      }
+    }
+  }
+  if (buffer.trim()) {
+    try {
+      const data = JSON.parse(buffer.trim());
+      if (onEvent) {
+        onEvent(data);
+      }
+      if (data.type === "complete") {
+        content = data.content || "";
+        finalLibraryName = data.libraryName || libraryName;
+      } else if (data.type === "error") {
+        error = data.message;
+      }
+    } catch {
+    }
+  }
+  return { content, libraryName: finalLibraryName, error };
+}
 
 // src/utils/logger.ts
 import pc from "picocolors";
@@ -315,7 +432,9 @@ ${pc2.dim(pathList)}`,
       message: `Which clients do you want to install the skill(s) for?
 ${pc2.dim(baseDir)}`,
       choices: ideChoices,
-      required: true
+      required: true,
+      loop: false,
+      theme: { style: { highlight: (text) => pc2.green(text) } }
     });
   } catch {
     return null;
@@ -343,7 +462,9 @@ async function promptForSingleTarget(options) {
     selectedIde = await select({
       message: "Which client?",
       choices: ideChoices,
-      default: DEFAULT_CONFIG.defaultIde
+      default: DEFAULT_CONFIG.defaultIde,
+      loop: false,
+      theme: { style: { highlight: (text) => pc2.green(text) } }
     });
   } catch {
     return null;
@@ -365,7 +486,9 @@ async function promptForSingleTarget(options) {
             value: "global"
           }
         ],
-        default: DEFAULT_CONFIG.defaultScope
+        default: DEFAULT_CONFIG.defaultScope,
+        loop: false,
+        theme: { style: { highlight: (text) => pc2.green(text) } }
       });
     } catch {
       return null;
@@ -398,6 +521,74 @@ function getTargetDirFromSelection(ide, scope) {
   return join(process.cwd(), IDE_PATHS[ide]);
 }
 
+// src/utils/prompts.ts
+import pc3 from "picocolors";
+import { checkbox as checkbox2 } from "@inquirer/prompts";
+import readline from "readline";
+function terminalLink(text, url, color) {
+  const colorFn = color ?? ((s) => s);
+  return `\x1B]8;;${url}\x07${colorFn(text)}\x1B]8;;\x07`;
+}
+function formatInstallCount(count) {
+  if (count === void 0 || count === 0) return "";
+  let display;
+  if (count >= 1e3) {
+    display = `${Math.floor(count / 1e3)}k+`;
+  } else if (count >= 100) {
+    const hundreds = Math.floor(count / 100) * 100;
+    display = `${hundreds}+`;
+  } else if (count >= 10) {
+    const tens = Math.floor(count / 10) * 10;
+    display = `${tens}+`;
+  } else {
+    display = String(count);
+  }
+  return `\x1B[38;5;214m\u2193${display}\x1B[0m`;
+}
+async function checkboxWithHover(config, options) {
+  const choices = config.choices.filter(
+    (c) => typeof c === "object" && c !== null && !("type" in c && c.type === "separator")
+  );
+  const values = choices.map((c) => c.value);
+  const totalItems = values.length;
+  let cursorPosition = 0;
+  const getName = options?.getName ?? ((v) => v.name);
+  const keypressHandler = (_str, key) => {
+    if (key.name === "up" && cursorPosition > 0) {
+      cursorPosition--;
+    } else if (key.name === "down" && cursorPosition < totalItems - 1) {
+      cursorPosition++;
+    }
+  };
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.on("keypress", keypressHandler);
+  const customConfig = {
+    ...config,
+    theme: {
+      ...config.theme,
+      style: {
+        ...config.theme?.style,
+        highlight: (text) => pc3.green(text),
+        renderSelectedChoices: (selected, _allChoices) => {
+          if (selected.length === 0) {
+            return pc3.dim(getName(values[cursorPosition]));
+          }
+          return selected.map((c) => getName(c.value)).join(", ");
+        }
+      }
+    }
+  };
+  try {
+    const selected = await checkbox2(customConfig);
+    if (selected.length === 0) {
+      return [values[cursorPosition]];
+    }
+    return selected;
+  } finally {
+    process.stdin.removeListener("keypress", keypressHandler);
+  }
+}
+
 // src/utils/installer.ts
 import { mkdir, writeFile, rm, symlink, lstat } from "fs/promises";
 import { join as join2 } from "path";
@@ -423,7 +614,670 @@ async function symlinkSkill(skillName, sourcePath, targetDir) {
   await symlink(sourcePath, targetPath);
 }
 
+// src/commands/generate.ts
+import pc5 from "picocolors";
+import ora from "ora";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { input, select as select2 } from "@inquirer/prompts";
+
+// src/utils/auth.ts
+import * as crypto from "crypto";
+import * as http from "http";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".context7");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+function generatePKCE() {
+  const codeVerifier = crypto.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
+  return { codeVerifier, codeChallenge };
+}
+function generateState() {
+  return crypto.randomBytes(16).toString("base64url");
+}
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function saveTokens(tokens) {
+  ensureConfigDir();
+  const data = {
+    ...tokens,
+    expires_at: tokens.expires_at ?? (tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : void 0)
+  };
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function loadTokens() {
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    return data;
+  } catch {
+    return null;
+  }
+}
+function clearTokens() {
+  if (fs.existsSync(CREDENTIALS_FILE)) {
+    fs.unlinkSync(CREDENTIALS_FILE);
+    return true;
+  }
+  return false;
+}
+function isTokenExpired(tokens) {
+  if (!tokens.expires_at) {
+    return false;
+  }
+  return Date.now() > tokens.expires_at - 6e4;
+}
+var CALLBACK_PORT = 52417;
+function createCallbackServer(expectedState) {
+  let resolvePort;
+  let resolveResult;
+  let rejectResult;
+  let serverInstance = null;
+  const portPromise = new Promise((resolve) => {
+    resolvePort = resolve;
+  });
+  const resultPromise = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url || "/", `http://localhost`);
+    if (url.pathname === "/callback") {
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      const errorDescription = url.searchParams.get("error_description");
+      res.writeHead(200, { "Content-Type": "text/html" });
+      if (error) {
+        res.end(errorPage(errorDescription || error));
+        serverInstance?.close();
+        rejectResult(new Error(errorDescription || error));
+        return;
+      }
+      if (!code || !state) {
+        res.end(errorPage("Missing authorization code or state"));
+        serverInstance?.close();
+        rejectResult(new Error("Missing authorization code or state"));
+        return;
+      }
+      if (state !== expectedState) {
+        res.end(errorPage("State mismatch - possible CSRF attack"));
+        serverInstance?.close();
+        rejectResult(new Error("State mismatch"));
+        return;
+      }
+      res.end(successPage());
+      serverInstance?.close();
+      resolveResult({ code, state });
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  serverInstance = server;
+  server.on("error", (err) => {
+    rejectResult(err);
+  });
+  server.listen(CALLBACK_PORT, "127.0.0.1", () => {
+    resolvePort(CALLBACK_PORT);
+  });
+  const timeout = setTimeout(
+    () => {
+      server.close();
+      rejectResult(new Error("Login timed out after 5 minutes"));
+    },
+    5 * 60 * 1e3
+  );
+  return {
+    port: portPromise,
+    result: resultPromise,
+    close: () => {
+      clearTimeout(timeout);
+      server.close();
+    }
+  };
+}
+function successPage() {
+  return `<!DOCTYPE html>
+<html>
+  <head><title>Login Successful</title></head>
+  <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #f9fafb;">
+    <div style="text-align: center; padding: 2rem;">
+      <div style="width: 64px; height: 64px; background: #16a34a; border-radius: 50%; display: flex; align-items: center; justify-content: center; margin: 0 auto 1rem;">
+        <svg width="32" height="32" fill="none" stroke="white" stroke-width="3" viewBox="0 0 24 24">
+          <path d="M5 13l4 4L19 7" stroke-linecap="round" stroke-linejoin="round"/>
+        </svg>
+      </div>
+      <h1 style="color: #16a34a; margin: 0 0 0.5rem;">Login Successful!</h1>
+      <p style="color: #6b7280; margin: 0;">You can close this window and return to the terminal.</p>
+    </div>
+  </body>
+</html>`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function errorPage(message) {
+  const safeMessage = escapeHtml(message);
+  return `<!DOCTYPE html>
+<html>
+  <head><title>Login Failed</title></head>
+  <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #f9fafb;">
+    <div style="text-align: center; padding: 2rem;">
+      <div style="width: 64px; height: 64px; background: #dc2626; border-radius: 50%; display: flex; align-items: center; justify-content: center; margin: 0 auto 1rem;">
+        <svg width="32" height="32" fill="none" stroke="white" stroke-width="3" viewBox="0 0 24 24">
+          <path d="M6 18L18 6M6 6l12 12" stroke-linecap="round" stroke-linejoin="round"/>
+        </svg>
+      </div>
+      <h1 style="color: #dc2626; margin: 0 0 0.5rem;">Login Failed</h1>
+      <p style="color: #6b7280; margin: 0;">${safeMessage}</p>
+      <p style="color: #9ca3af; margin: 1rem 0 0; font-size: 0.875rem;">You can close this window.</p>
+    </div>
+  </body>
+</html>`;
+}
+async function exchangeCodeForTokens(baseUrl3, code, codeVerifier, redirectUri, clientId) {
+  const response = await fetch(`${baseUrl3}/api/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: clientId,
+      code,
+      code_verifier: codeVerifier,
+      redirect_uri: redirectUri
+    }).toString()
+  });
+  if (!response.ok) {
+    const err = await response.json().catch(() => ({}));
+    throw new Error(err.error_description || err.error || "Failed to exchange code for tokens");
+  }
+  return await response.json();
+}
+function buildAuthorizationUrl(baseUrl3, clientId, redirectUri, codeChallenge, state) {
+  const url = new URL(`${baseUrl3}/api/oauth/authorize`);
+  url.searchParams.set("client_id", clientId);
+  url.searchParams.set("redirect_uri", redirectUri);
+  url.searchParams.set("code_challenge", codeChallenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("state", state);
+  url.searchParams.set("scope", "profile email");
+  url.searchParams.set("response_type", "code");
+  return url.toString();
+}
+
+// src/utils/selectOrInput.ts
+import {
+  createPrompt,
+  useState,
+  useKeypress,
+  usePrefix,
+  isEnterKey,
+  isUpKey,
+  isDownKey
+} from "@inquirer/core";
+import pc4 from "picocolors";
+var selectOrInput = createPrompt((config, done) => {
+  const { message, options, recommendedIndex = 0 } = config;
+  const [cursor, setCursor] = useState(recommendedIndex);
+  const [inputValue, setInputValue] = useState("");
+  const prefix = usePrefix({});
+  useKeypress((key, rl) => {
+    if (isUpKey(key)) {
+      setCursor(Math.max(0, cursor - 1));
+      return;
+    }
+    if (isDownKey(key)) {
+      setCursor(Math.min(options.length, cursor + 1));
+      return;
+    }
+    if (isEnterKey(key)) {
+      if (cursor === options.length) {
+        const finalValue = inputValue.trim();
+        done(finalValue || options[recommendedIndex]);
+      } else {
+        done(options[cursor]);
+      }
+      return;
+    }
+    if (cursor === options.length && key.name !== "return") {
+      if (key.name === "w" && key.ctrl || key.name === "backspace") {
+        if (key.name === "w" && key.ctrl) {
+          const words = inputValue.trimEnd().split(/\s+/);
+          if (words.length > 0) {
+            words.pop();
+            setInputValue(
+              words.join(" ") + (inputValue.endsWith(" ") && words.length > 0 ? " " : "")
+            );
+          }
+        } else {
+          setInputValue(inputValue.slice(0, -1));
+        }
+      } else if (key.name === "u" && key.ctrl) {
+        setInputValue("");
+      } else if (key.name === "space") {
+        setInputValue(inputValue + " ");
+      } else if (key.name && key.name.length === 1 && !key.ctrl) {
+        setInputValue(inputValue + key.name);
+      }
+    } else if (rl.line) {
+      rl.line = "";
+    }
+  });
+  let output = `${prefix} ${pc4.bold(message)}
+
+`;
+  options.forEach((opt, idx) => {
+    const isRecommended = idx === recommendedIndex;
+    const isCursor = idx === cursor;
+    const number = pc4.cyan(`${idx + 1}.`);
+    const text = isRecommended ? `${opt} ${pc4.green("\u2713 Recommended")}` : opt;
+    if (isCursor) {
+      output += pc4.cyan(`\u276F ${number} ${text}
+`);
+    } else {
+      output += `  ${number} ${text}
+`;
+    }
+  });
+  const isCustomCursor = cursor === options.length;
+  if (isCustomCursor) {
+    output += pc4.cyan(`\u276F ${pc4.yellow("\u270E")} ${inputValue || pc4.dim("Type your own...")}`);
+  } else {
+    output += `  ${pc4.yellow("\u270E")} ${pc4.dim("Type your own...")}`;
+  }
+  return output;
+});
+var selectOrInput_default = selectOrInput;
+
+// src/commands/generate.ts
+function registerGenerateCommand(skillCommand) {
+  skillCommand.command("generate").alias("gen").alias("g").option("-o, --output <dir>", "Output directory (default: current directory)").option("--all", "Generate for all detected IDEs").option("--global", "Generate in global skills directory").option("--claude", "Claude Code (.claude/skills/)").option("--cursor", "Cursor (.cursor/skills/)").option("--codex", "Codex (.codex/skills/)").option("--opencode", "OpenCode (.opencode/skills/)").option("--amp", "Amp (.agents/skills/)").option("--antigravity", "Antigravity (.agent/skills/)").description("Generate a skill for a library using AI").action(async (options) => {
+    await generateCommand(options);
+  });
+}
+async function generateCommand(options) {
+  log.blank();
+  const tokens = loadTokens();
+  if (!tokens) {
+    log.error("Authentication required. Please run 'ctx7 login' first.");
+    return;
+  }
+  if (isTokenExpired(tokens)) {
+    log.error("Session expired. Please run 'ctx7 login' to refresh.");
+    return;
+  }
+  const accessToken = tokens.access_token;
+  const initSpinner = ora().start();
+  const quota = await getSkillQuota(accessToken);
+  if (quota.error) {
+    initSpinner.fail(pc5.red("Failed to initialize"));
+    return;
+  }
+  if (quota.tier !== "unlimited" && quota.remaining < 1) {
+    initSpinner.fail(pc5.red("Weekly skill generation limit reached"));
+    log.blank();
+    console.log(
+      `  You've used ${pc5.bold(pc5.white(quota.used.toString()))}/${pc5.bold(pc5.white(quota.limit.toString()))} skill generations this week.`
+    );
+    console.log(
+      `  Your quota resets on ${pc5.yellow(new Date(quota.resetDate).toLocaleDateString())}.`
+    );
+    log.blank();
+    if (quota.tier === "free") {
+      console.log(
+        `  ${pc5.yellow("Tip:")} Upgrade to Pro for ${pc5.bold("10")} generations per week.`
+      );
+      console.log(`  Visit ${pc5.green("https://context7.com/dashboard")} to upgrade.`);
+    }
+    return;
+  }
+  initSpinner.stop();
+  initSpinner.clear();
+  console.log(pc5.bold("What should your agent become an expert at?\n"));
+  console.log(
+    pc5.dim("Skills teach agents best practices, design patterns, and domain expertise.\n")
+  );
+  console.log(pc5.yellow("Examples:"));
+  console.log(pc5.dim('  "React component optimization and performance best practices"'));
+  console.log(pc5.dim('  "Responsive web design with Tailwind CSS"'));
+  console.log(pc5.dim('  "Writing effective landing page copy"'));
+  console.log(pc5.dim('  "Deploying Next.js apps to Vercel"'));
+  console.log(pc5.dim('  "OAuth authentication with NextAuth.js"\n'));
+  let motivation;
+  try {
+    motivation = await input({
+      message: "Describe the expertise:"
+    });
+    if (!motivation.trim()) {
+      log.warn("Expertise description is required");
+      return;
+    }
+    motivation = motivation.trim();
+  } catch {
+    log.warn("Generation cancelled");
+    return;
+  }
+  const searchSpinner = ora("Finding relevant libraries...").start();
+  const searchResult = await searchLibraries(motivation, accessToken);
+  if (searchResult.error || !searchResult.results?.length) {
+    searchSpinner.fail(pc5.red("No libraries found"));
+    log.warn(searchResult.message || "Try a different description");
+    return;
+  }
+  searchSpinner.succeed(pc5.green(`Found ${searchResult.results.length} relevant libraries`));
+  log.blank();
+  let selectedLibraries;
+  try {
+    const formatProjectId = (id) => {
+      return id.startsWith("/") ? id.slice(1) : id;
+    };
+    const isGitHubRepo = (id) => {
+      const cleanId = id.startsWith("/") ? id.slice(1) : id;
+      const parts = cleanId.split("/");
+      if (parts.length !== 2) return false;
+      const nonGitHubPrefixes = ["websites", "packages", "npm", "docs", "libraries", "llmstxt"];
+      return !nonGitHubPrefixes.includes(parts[0].toLowerCase());
+    };
+    const libraries = searchResult.results.slice(0, 5);
+    const indexWidth = libraries.length.toString().length;
+    const maxNameLen = Math.max(...libraries.map((lib) => lib.title.length));
+    const libraryChoices = libraries.map((lib, index) => {
+      const projectId = formatProjectId(lib.id);
+      const isGitHub = isGitHubRepo(lib.id);
+      const indexStr = pc5.dim(`${(index + 1).toString().padStart(indexWidth)}.`);
+      const paddedName = lib.title.padEnd(maxNameLen);
+      const libUrl = `https://context7.com${lib.id}`;
+      const libLink = terminalLink(lib.title, libUrl, pc5.white);
+      const repoLink = isGitHub ? terminalLink(projectId, `https://github.com/${projectId}`, pc5.white) : pc5.white(projectId);
+      const starsLine = lib.stars && isGitHub ? [`${pc5.yellow("Stars:")}       ${lib.stars.toLocaleString()}`] : [];
+      const metadataLines = [
+        pc5.dim("\u2500".repeat(50)),
+        "",
+        `${pc5.yellow("Library:")}     ${libLink}`,
+        `${pc5.yellow("Source:")}      ${repoLink}`,
+        `${pc5.yellow("Snippets:")}    ${lib.totalSnippets.toLocaleString()}`,
+        ...starsLine,
+        `${pc5.yellow("Description:")}`,
+        pc5.white(lib.description || "No description")
+      ];
+      return {
+        name: `${indexStr} ${paddedName}  ${pc5.dim(`(${projectId})`)}`,
+        value: lib,
+        description: metadataLines.join("\n")
+      };
+    });
+    selectedLibraries = await checkboxWithHover(
+      {
+        message: "Select libraries:",
+        choices: libraryChoices,
+        pageSize: 10,
+        loop: false
+      },
+      { getName: (lib) => `${lib.title} (${formatProjectId(lib.id)})` }
+    );
+    if (!selectedLibraries || selectedLibraries.length === 0) {
+      log.info("No libraries selected. Try running the command again.");
+      return;
+    }
+  } catch {
+    log.warn("Generation cancelled");
+    return;
+  }
+  log.blank();
+  const questionsSpinner = ora("Preparing questions...").start();
+  const librariesInput = selectedLibraries.map((lib) => ({ id: lib.id, name: lib.title }));
+  const questionsResult = await getSkillQuestions(librariesInput, motivation, accessToken);
+  if (questionsResult.error || !questionsResult.questions?.length) {
+    questionsSpinner.fail(pc5.red("Failed to generate questions"));
+    log.warn(questionsResult.message || "Please try again");
+    return;
+  }
+  questionsSpinner.succeed(pc5.green("Questions prepared"));
+  log.blank();
+  const answers = [];
+  try {
+    for (let i = 0; i < questionsResult.questions.length; i++) {
+      const q = questionsResult.questions[i];
+      const questionNum = i + 1;
+      const totalQuestions = questionsResult.questions.length;
+      const answer = await selectOrInput_default({
+        message: `${pc5.dim(`[${questionNum}/${totalQuestions}]`)} ${q.question}`,
+        options: q.options,
+        recommendedIndex: q.recommendedIndex
+      });
+      answers.push({
+        question: q.question,
+        answer
+      });
+      const linesToClear = 3 + q.options.length;
+      process.stdout.write(`\x1B[${linesToClear}A\x1B[J`);
+      const truncatedAnswer = answer.length > 50 ? answer.slice(0, 47) + "..." : answer;
+      console.log(`${pc5.green("\u2713")} ${pc5.dim(`[${questionNum}/${totalQuestions}]`)} ${q.question}`);
+      console.log(`  ${pc5.cyan(truncatedAnswer)}`);
+      log.blank();
+    }
+  } catch {
+    log.warn("Generation cancelled");
+    return;
+  }
+  let generatedContent = null;
+  let skillName = "";
+  let feedback;
+  const libraryNames = selectedLibraries.map((lib) => lib.title).join(", ");
+  const queryLog = [];
+  let genSpinner = null;
+  const formatQueryLogText = () => {
+    if (queryLog.length === 0) return "";
+    const lines = [];
+    const latestEntry = queryLog[queryLog.length - 1];
+    lines.push(pc5.dim(`(${queryLog.length} ${queryLog.length === 1 ? "query" : "queries"})`));
+    lines.push("");
+    for (const result of latestEntry.results.slice(0, 3)) {
+      const cleanContent = result.content.replace(/Source:\s*https?:\/\/[^\s]+/gi, "").trim();
+      if (cleanContent) {
+        lines.push(`  ${pc5.yellow("\u2022")} ${pc5.white(result.title)}`);
+        const maxLen = 400;
+        const content = cleanContent.length > maxLen ? cleanContent.slice(0, maxLen - 3) + "..." : cleanContent;
+        const words = content.split(" ");
+        let currentLine = "    ";
+        for (const word of words) {
+          if (currentLine.length + word.length > 84) {
+            lines.push(pc5.dim(currentLine));
+            currentLine = "    " + word + " ";
+          } else {
+            currentLine += word + " ";
+          }
+        }
+        if (currentLine.trim()) {
+          lines.push(pc5.dim(currentLine));
+        }
+        lines.push("");
+      }
+    }
+    return "\n" + lines.join("\n");
+  };
+  let isGeneratingContent = false;
+  const handleStreamEvent = (event) => {
+    if (event.type === "progress") {
+      if (genSpinner) {
+        if (event.message.startsWith("Generating skill content...") && !isGeneratingContent) {
+          isGeneratingContent = true;
+          if (queryLog.length > 0) {
+            genSpinner.succeed(pc5.green(`Queried documentation`));
+          } else {
+            genSpinner.succeed(pc5.green(`Ready to generate`));
+          }
+          genSpinner = ora("Generating skill content...").start();
+        } else if (!isGeneratingContent) {
+          genSpinner.text = event.message + formatQueryLogText();
+        }
+      }
+    } else if (event.type === "tool_result") {
+      queryLog.push({
+        query: event.query,
+        libraryId: event.libraryId,
+        results: event.results
+      });
+      if (genSpinner && !isGeneratingContent) {
+        genSpinner.text = genSpinner.text.split("\n")[0] + formatQueryLogText();
+      }
+    }
+  };
+  while (true) {
+    const generateInput = {
+      motivation,
+      libraries: librariesInput,
+      answers,
+      feedback,
+      previousContent: feedback && generatedContent ? generatedContent : void 0
+    };
+    queryLog.length = 0;
+    isGeneratingContent = false;
+    const initialStatus = feedback ? "Regenerating skill with your feedback..." : `Generating skill for "${libraryNames}"...`;
+    genSpinner = ora(initialStatus).start();
+    const result = await generateSkillStructured(generateInput, handleStreamEvent, accessToken);
+    if (result.error) {
+      genSpinner.fail(pc5.red(`Error: ${result.error}`));
+      return;
+    }
+    if (!result.content) {
+      genSpinner.fail(pc5.red("No content generated"));
+      return;
+    }
+    genSpinner.succeed(pc5.green(`Generated skill for "${result.libraryName}"`));
+    generatedContent = result.content;
+    skillName = result.libraryName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const contentLines = generatedContent.split("\n");
+    const previewLineCount = 20;
+    const hasMoreLines = contentLines.length > previewLineCount;
+    const previewContent = contentLines.slice(0, previewLineCount).join("\n");
+    const remainingLines = contentLines.length - previewLineCount;
+    const showPreview = () => {
+      log.blank();
+      console.log(pc5.dim("\u2501".repeat(70)));
+      console.log(pc5.bold(`Generated Skill: `) + pc5.green(pc5.bold(skillName)));
+      console.log(pc5.dim("\u2501".repeat(70)));
+      log.blank();
+      console.log(previewContent);
+      if (hasMoreLines) {
+        log.blank();
+        console.log(pc5.dim(`... ${remainingLines} more lines`));
+      }
+      log.blank();
+      console.log(pc5.dim("\u2501".repeat(70)));
+      log.blank();
+    };
+    const showFullContent = () => {
+      log.blank();
+      console.log(pc5.dim("\u2501".repeat(70)));
+      console.log(pc5.bold(`Generated Skill: `) + pc5.green(pc5.bold(skillName)));
+      console.log(pc5.dim("\u2501".repeat(70)));
+      log.blank();
+      console.log(generatedContent);
+      log.blank();
+      console.log(pc5.dim("\u2501".repeat(70)));
+      log.blank();
+    };
+    showPreview();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    try {
+      let action;
+      while (true) {
+        const choices = [
+          { name: `${pc5.green("\u2713")} Install skill`, value: "install" },
+          ...hasMoreLines ? [{ name: `${pc5.blue("\u2922")} View full skill`, value: "expand" }] : [],
+          { name: `${pc5.yellow("\u270E")} Request changes`, value: "feedback" },
+          { name: `${pc5.red("\u2715")} Cancel`, value: "cancel" }
+        ];
+        action = await select2({
+          message: "What would you like to do?",
+          choices
+        });
+        if (action === "expand") {
+          showFullContent();
+          continue;
+        }
+        break;
+      }
+      if (action === "install") {
+        break;
+      } else if (action === "cancel") {
+        log.warn("Generation cancelled");
+        return;
+      } else if (action === "feedback") {
+        feedback = await input({
+          message: "What changes would you like? (press Enter to skip)"
+        });
+        if (!feedback.trim()) {
+          feedback = void 0;
+        }
+        log.blank();
+      }
+    } catch {
+      log.warn("Generation cancelled");
+      return;
+    }
+  }
+  const targets = await promptForInstallTargets(options);
+  if (!targets) {
+    log.warn("Generation cancelled");
+    return;
+  }
+  const targetDirs = getTargetDirs(targets);
+  const writeSpinner = ora("Writing skill files...").start();
+  let permissionError = false;
+  const failedDirs = /* @__PURE__ */ new Set();
+  for (const targetDir of targetDirs) {
+    let finalDir = targetDir;
+    if (options.output && !targetDir.includes("/.config/") && !targetDir.startsWith(homedir3())) {
+      finalDir = targetDir.replace(process.cwd(), options.output);
+    }
+    const skillDir = join4(finalDir, skillName);
+    const skillPath = join4(skillDir, "SKILL.md");
+    try {
+      await mkdir2(skillDir, { recursive: true });
+      await writeFile2(skillPath, generatedContent, "utf-8");
+    } catch (err) {
+      const error = err;
+      if (error.code === "EACCES" || error.code === "EPERM") {
+        permissionError = true;
+        failedDirs.add(skillDir);
+      } else {
+        log.warn(`Failed to write to ${skillPath}: ${error.message}`);
+      }
+    }
+  }
+  if (permissionError) {
+    writeSpinner.fail(pc5.red("Permission denied"));
+    log.blank();
+    console.log(pc5.yellow("Fix permissions with:"));
+    for (const dir of failedDirs) {
+      const parentDir = join4(dir, "..");
+      console.log(pc5.dim(`  sudo chown -R $(whoami) "${parentDir}"`));
+    }
+    log.blank();
+    return;
+  }
+  writeSpinner.succeed(pc5.green(`Created skill in ${targetDirs.length} location(s)`));
+  log.blank();
+  console.log(pc5.green(pc5.bold("Skill saved successfully")));
+  for (const targetDir of targetDirs) {
+    console.log(pc5.dim(`  ${targetDir}/`) + pc5.green(skillName));
+  }
+  log.blank();
+}
+
 // src/commands/skill.ts
+import { homedir as homedir4 } from "os";
 function logInstallSummary(targets, targetDirs, skillNames) {
   log.blank();
   let dirIndex = 0;
@@ -440,6 +1294,7 @@ function logInstallSummary(targets, targetDirs, skillNames) {
 }
 function registerSkillCommands(program2) {
   const skill = program2.command("skills").alias("skill").description("Manage AI coding skills");
+  registerGenerateCommand(skill);
   skill.command("install").alias("i").alias("add").argument("<repository>", "GitHub repository (/owner/repo)").argument("[skill]", "Specific skill name to install").option("--all", "Install all skills without prompting").option("--global", "Install globally instead of current directory").option("--claude", "Claude Code (.claude/skills/)").option("--cursor", "Cursor (.cursor/skills/)").option("--codex", "Codex (.codex/skills/)").option("--opencode", "OpenCode (.opencode/skills/)").option("--amp", "Amp (.agents/skills/)").option("--antigravity", "Antigravity (.agent/skills/)").description("Install skills from a repository").action(async (project, skillName, options) => {
     await installCommand(project, skillName, options);
   });
@@ -464,10 +1319,10 @@ function registerSkillAliases(program2) {
     await searchCommand(keywords.join(" "));
   });
 }
-async function installCommand(input, skillName, options) {
-  const parsed = parseSkillInput(input);
+async function installCommand(input2, skillName, options) {
+  const parsed = parseSkillInput(input2);
   if (!parsed) {
-    log.error(`Invalid input format: ${input}`);
+    log.error(`Invalid input format: ${input2}`);
     log.info(`Expected: /owner/repo or full GitHub URL`);
     log.info(`Example: ctx7 skills install /anthropics/skills pdf`);
     log.blank();
@@ -475,17 +1330,17 @@ async function installCommand(input, skillName, options) {
   }
   const repo = `/${parsed.owner}/${parsed.repo}`;
   log.blank();
-  const spinner = ora(`Fetching skills from ${repo}...`).start();
+  const spinner = ora2(`Fetching skills from ${repo}...`).start();
   let selectedSkills;
   if (skillName) {
     spinner.text = `Fetching skill: ${skillName}...`;
     const skillData = await getSkill(repo, skillName);
     if (skillData.error || !skillData.name) {
       if (skillData.error === "prompt_injection_detected") {
-        spinner.fail(pc3.red(`Prompt injection detected in skill: ${skillName}`));
+        spinner.fail(pc6.red(`Prompt injection detected in skill: ${skillName}`));
         log.warn("This skill contains potentially malicious content and cannot be installed.");
       } else {
-        spinner.fail(pc3.red(`Skill not found: ${skillName}`));
+        spinner.fail(pc6.red(`Skill not found: ${skillName}`));
       }
       return;
     }
@@ -501,11 +1356,11 @@ async function installCommand(input, skillName, options) {
   } else {
     const data = await listProjectSkills(repo);
     if (data.error) {
-      spinner.fail(pc3.red(`Error: ${data.message || data.error}`));
+      spinner.fail(pc6.red(`Error: ${data.message || data.error}`));
       return;
     }
     if (!data.skills || data.skills.length === 0) {
-      spinner.warn(pc3.yellow(`No skills found in ${repo}`));
+      spinner.warn(pc6.yellow(`No skills found in ${repo}`));
       return;
     }
     const skillsWithRepo = data.skills.map((s) => ({ ...s, project: repo }));
@@ -520,26 +1375,36 @@ async function installCommand(input, skillName, options) {
     if (options.all || data.skills.length === 1) {
       selectedSkills = skillsWithRepo;
     } else {
-      const maxNameLen = Math.min(25, Math.max(...data.skills.map((s) => s.name.length)));
-      const choices = skillsWithRepo.map((s) => {
+      const indexWidth = data.skills.length.toString().length;
+      const maxNameLen = Math.max(...data.skills.map((s) => s.name.length));
+      const choices = skillsWithRepo.map((s, index) => {
+        const indexStr = pc6.dim(`${(index + 1).toString().padStart(indexWidth)}.`);
         const paddedName = s.name.padEnd(maxNameLen);
-        const desc = s.description?.trim() ? s.description.slice(0, 60) + (s.description.length > 60 ? "..." : "") : "";
+        const installs = formatInstallCount(s.installCount);
+        const skillUrl = `https://context7.com/skills${s.project}/${s.name}`;
+        const skillLink = terminalLink(s.name, skillUrl, pc6.white);
+        const repoLink = terminalLink(s.project, `https://github.com${s.project}`, pc6.white);
+        const metadataLines = [
+          pc6.dim("\u2500".repeat(50)),
+          "",
+          `${pc6.yellow("Skill:")}       ${skillLink}`,
+          `${pc6.yellow("Repo:")}        ${repoLink}`,
+          `${pc6.yellow("Description:")}`,
+          pc6.white(s.description || "No description")
+        ];
         return {
-          name: desc ? `${paddedName} ${pc3.dim(desc)}` : s.name,
-          value: s
+          name: installs ? `${indexStr} ${paddedName} ${installs}` : `${indexStr} ${paddedName}`,
+          value: s,
+          description: metadataLines.join("\n")
         };
       });
       log.blank();
       try {
-        selectedSkills = await checkbox2({
+        selectedSkills = await checkboxWithHover({
           message: "Select skills:",
           choices,
           pageSize: 15,
-          theme: {
-            style: {
-              renderSelectedChoices: (selected) => selected.map((c) => c.value.name).join(", ")
-            }
-          }
+          loop: false
         });
       } catch {
         log.warn("Installation cancelled");
@@ -557,7 +1422,7 @@ async function installCommand(input, skillName, options) {
     return;
   }
   const targetDirs = getTargetDirs(targets);
-  const installSpinner = ora("Installing skills...").start();
+  const installSpinner = ora2("Installing skills...").start();
   let permissionError = false;
   const failedDirs = /* @__PURE__ */ new Set();
   const installedSkills = [];
@@ -581,7 +1446,7 @@ async function installCommand(input, skillName, options) {
         }
         throw dirErr;
       }
-      const primarySkillDir = join3(primaryDir, skill.name);
+      const primarySkillDir = join5(primaryDir, skill.name);
       for (const targetDir of symlinkDirs) {
         try {
           await symlinkSkill(skill.name, primarySkillDir, targetDir);
@@ -609,7 +1474,7 @@ async function installCommand(input, skillName, options) {
     log.blank();
     log.warn("Fix permissions with:");
     for (const dir of failedDirs) {
-      const parentDir = join3(dir, "..");
+      const parentDir = join5(dir, "..");
       log.dim(`  sudo chown -R $(whoami) "${parentDir}"`);
     }
     log.blank();
@@ -622,45 +1487,57 @@ async function installCommand(input, skillName, options) {
 }
 async function searchCommand(query) {
   log.blank();
-  const spinner = ora(`Searching for "${query}"...`).start();
+  const spinner = ora2(`Searching for "${query}"...`).start();
   let data;
   try {
     data = await searchSkills(query);
   } catch (err) {
-    spinner.fail(pc3.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+    spinner.fail(pc6.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
     return;
   }
   if (data.error) {
-    spinner.fail(pc3.red(`Error: ${data.message || data.error}`));
+    spinner.fail(pc6.red(`Error: ${data.message || data.error}`));
     return;
   }
   if (!data.results || data.results.length === 0) {
-    spinner.warn(pc3.yellow(`No skills found matching "${query}"`));
+    spinner.warn(pc6.yellow(`No skills found matching "${query}"`));
     return;
   }
   spinner.succeed(`Found ${data.results.length} skill(s)`);
-  const maxNameLen = Math.min(25, Math.max(...data.results.map((s) => s.name.length)));
-  const choices = data.results.map((s) => {
+  const indexWidth = data.results.length.toString().length;
+  const maxNameLen = Math.max(...data.results.map((s) => s.name.length));
+  const choices = data.results.map((s, index) => {
+    const indexStr = pc6.dim(`${(index + 1).toString().padStart(indexWidth)}.`);
     const paddedName = s.name.padEnd(maxNameLen);
-    const repoName = pc3.dim(`(${s.project})`);
-    const desc = s.description?.trim() ? s.description.slice(0, 50) + (s.description.length > 50 ? "..." : "") : "";
+    const installs = formatInstallCount(s.installCount);
+    const skillLink = terminalLink(
+      s.name,
+      `https://context7.com/skills${s.project}/${s.name}`,
+      pc6.white
+    );
+    const repoLink = terminalLink(s.project, `https://github.com${s.project}`, pc6.white);
+    const metadataLines = [
+      pc6.dim("\u2500".repeat(50)),
+      "",
+      `${pc6.yellow("Skill:")}       ${skillLink}`,
+      `${pc6.yellow("Repo:")}        ${repoLink}`,
+      `${pc6.yellow("Description:")}`,
+      pc6.white(s.description || "No description")
+    ];
     return {
-      name: desc ? `${paddedName} ${repoName} ${pc3.dim(desc)}` : `${paddedName} ${repoName}`,
-      value: s
+      name: installs ? `${indexStr} ${paddedName} ${installs}` : `${indexStr} ${paddedName}`,
+      value: s,
+      description: metadataLines.join("\n")
     };
   });
   log.blank();
   let selectedSkills;
   try {
-    selectedSkills = await checkbox2({
+    selectedSkills = await checkboxWithHover({
       message: "Select skills to install:",
       choices,
       pageSize: 15,
-      theme: {
-        style: {
-          renderSelectedChoices: (selected) => selected.map((c) => c.value.name).join(", ")
-        }
-      }
+      loop: false
     });
   } catch {
     log.warn("Installation cancelled");
@@ -677,7 +1554,7 @@ async function searchCommand(query) {
     return;
   }
   const targetDirs = getTargetDirs(targets);
-  const installSpinner = ora("Installing skills...").start();
+  const installSpinner = ora2("Installing skills...").start();
   let permissionError = false;
   const failedDirs = /* @__PURE__ */ new Set();
   const installedSkills = [];
@@ -701,7 +1578,7 @@ async function searchCommand(query) {
         }
         throw dirErr;
       }
-      const primarySkillDir = join3(primaryDir, skill.name);
+      const primarySkillDir = join5(primaryDir, skill.name);
       for (const targetDir of symlinkDirs) {
         try {
           await symlinkSkill(skill.name, primarySkillDir, targetDir);
@@ -729,7 +1606,7 @@ async function searchCommand(query) {
     log.blank();
     log.warn("Fix permissions with:");
     for (const dir of failedDirs) {
-      const parentDir = join3(dir, "..");
+      const parentDir = join5(dir, "..");
       log.dim(`  sudo chown -R $(whoami) "${parentDir}"`);
     }
     log.blank();
@@ -741,28 +1618,35 @@ async function searchCommand(query) {
   logInstallSummary(targets, targetDirs, installedNames);
 }
 async function listCommand(options) {
-  const target = await promptForSingleTarget(options);
-  if (!target) {
-    log.warn("Cancelled");
+  const scope = options.global ? "global" : "project";
+  const pathMap = scope === "global" ? IDE_GLOBAL_PATHS : IDE_PATHS;
+  const baseDir = scope === "global" ? homedir4() : process.cwd();
+  const idesToCheck = hasExplicitIdeOption(options) ? getSelectedIdes(options) : Object.keys(IDE_NAMES);
+  const results = [];
+  for (const ide of idesToCheck) {
+    const skillsDir = join5(baseDir, pathMap[ide]);
+    try {
+      const entries = await readdir(skillsDir, { withFileTypes: true });
+      const skillFolders = entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
+      if (skillFolders.length > 0) {
+        results.push({ ide, skills: skillFolders });
+      }
+    } catch {
+    }
+  }
+  if (results.length === 0) {
+    log.warn("No skills installed");
     return;
   }
-  const skillsDir = getTargetDirFromSelection(target.ide, target.scope);
-  try {
-    const entries = await readdir(skillsDir, { withFileTypes: true });
-    const skillFolders = entries.filter((e) => e.isDirectory() || e.isSymbolicLink());
-    if (skillFolders.length === 0) {
-      log.warn(`No skills installed in ${skillsDir}`);
-      return;
-    }
-    log.info(`
-\u25C6 Installed skills (${skillsDir}):`);
-    for (const folder of skillFolders) {
-      log.item(folder.name);
+  log.blank();
+  for (const { ide, skills } of results) {
+    const ideName = IDE_NAMES[ide];
+    const path2 = pathMap[ide];
+    log.plain(`${pc6.bold(ideName)} ${pc6.dim(path2)}`);
+    for (const skill of skills) {
+      log.plain(`  ${pc6.green(skill)}`);
     }
-    log.success(`${skillFolders.length} skill(s) installed
-`);
-  } catch {
-    log.warn(`No skills directory found at ${skillsDir}`);
+    log.blank();
   }
 }
 async function removeCommand(name, options) {
@@ -772,7 +1656,7 @@ async function removeCommand(name, options) {
     return;
   }
   const skillsDir = getTargetDirFromSelection(target.ide, target.scope);
-  const skillPath = join3(skillsDir, name);
+  const skillPath = join5(skillsDir, name);
   try {
     await rm2(skillPath, { recursive: true });
     log.success(`Removed skill: ${name}`);
@@ -787,25 +1671,25 @@ async function removeCommand(name, options) {
     }
   }
 }
-async function infoCommand(input) {
-  const parsed = parseSkillInput(input);
+async function infoCommand(input2) {
+  const parsed = parseSkillInput(input2);
   if (!parsed) {
     log.blank();
-    log.error(`Invalid input format: ${input}`);
+    log.error(`Invalid input format: ${input2}`);
     log.info(`Expected: /owner/repo or full GitHub URL`);
     log.blank();
     return;
   }
   const repo = `/${parsed.owner}/${parsed.repo}`;
   log.blank();
-  const spinner = ora(`Fetching skills from ${repo}...`).start();
+  const spinner = ora2(`Fetching skills from ${repo}...`).start();
   const data = await listProjectSkills(repo);
   if (data.error) {
-    spinner.fail(pc3.red(`Error: ${data.message || data.error}`));
+    spinner.fail(pc6.red(`Error: ${data.message || data.error}`));
     return;
   }
   if (!data.skills || data.skills.length === 0) {
-    spinner.warn(pc3.yellow(`No skills found in ${repo}`));
+    spinner.warn(pc6.yellow(`No skills found in ${repo}`));
     return;
   }
   spinner.succeed(`Found ${data.skills.length} skill(s)`);
@@ -817,32 +1701,165 @@ async function infoCommand(input) {
     log.blank();
   }
   log.plain(
-    `${pc3.bold("Quick commands:")}
-  Install all: ${pc3.cyan(`ctx7 skills install ${repo} --all`)}
-  Install one: ${pc3.cyan(`ctx7 skills install ${repo} ${data.skills[0]?.name}`)}
+    `${pc6.bold("Quick commands:")}
+  Install all: ${pc6.cyan(`ctx7 skills install ${repo} --all`)}
+  Install one: ${pc6.cyan(`ctx7 skills install ${repo} ${data.skills[0]?.name}`)}
 `
   );
 }
 
+// src/commands/auth.ts
+import pc7 from "picocolors";
+import ora3 from "ora";
+import open from "open";
+var CLI_CLIENT_ID = "2veBSofhicRBguUT";
+var baseUrl2 = "https://context7.com";
+function setAuthBaseUrl(url) {
+  baseUrl2 = url;
+}
+function registerAuthCommands(program2) {
+  program2.command("login").description("Log in to Context7").option("--no-browser", "Don't open browser automatically").action(async (options) => {
+    await loginCommand(options);
+  });
+  program2.command("logout").description("Log out of Context7").action(() => {
+    logoutCommand();
+  });
+  program2.command("whoami").description("Show current login status").action(async () => {
+    await whoamiCommand();
+  });
+}
+async function loginCommand(options) {
+  const existingTokens = loadTokens();
+  if (existingTokens) {
+    const expired = isTokenExpired(existingTokens);
+    if (!expired || existingTokens.refresh_token) {
+      console.log(pc7.yellow("You are already logged in."));
+      console.log(
+        pc7.dim("Run 'ctx7 logout' first if you want to log in with a different account.")
+      );
+      return;
+    }
+    clearTokens();
+  }
+  const spinner = ora3("Preparing login...").start();
+  try {
+    const { codeVerifier, codeChallenge } = generatePKCE();
+    const state = generateState();
+    const callbackServer = createCallbackServer(state);
+    const port = await callbackServer.port;
+    const redirectUri = `http://localhost:${port}/callback`;
+    const authUrl = buildAuthorizationUrl(
+      baseUrl2,
+      CLI_CLIENT_ID,
+      redirectUri,
+      codeChallenge,
+      state
+    );
+    spinner.stop();
+    console.log("");
+    console.log(pc7.bold("Opening browser to log in..."));
+    console.log("");
+    if (options.browser) {
+      await open(authUrl);
+      console.log(pc7.dim("If the browser didn't open, visit this URL:"));
+    } else {
+      console.log(pc7.dim("Open this URL in your browser:"));
+    }
+    console.log(pc7.cyan(authUrl));
+    console.log("");
+    const waitingSpinner = ora3("Waiting for login...").start();
+    try {
+      const { code } = await callbackServer.result;
+      waitingSpinner.text = "Exchanging code for tokens...";
+      const tokens = await exchangeCodeForTokens(
+        baseUrl2,
+        code,
+        codeVerifier,
+        redirectUri,
+        CLI_CLIENT_ID
+      );
+      saveTokens(tokens);
+      callbackServer.close();
+      waitingSpinner.succeed(pc7.green("Login successful!"));
+      console.log("");
+      console.log(pc7.dim("You can now use authenticated Context7 features."));
+    } catch (error) {
+      callbackServer.close();
+      waitingSpinner.fail(pc7.red("Login failed"));
+      if (error instanceof Error) {
+        console.error(pc7.red(error.message));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(pc7.red("Login failed"));
+    if (error instanceof Error) {
+      console.error(pc7.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+function logoutCommand() {
+  if (clearTokens()) {
+    console.log(pc7.green("Logged out successfully."));
+  } else {
+    console.log(pc7.yellow("You are not logged in."));
+  }
+}
+async function whoamiCommand() {
+  const tokens = loadTokens();
+  if (!tokens) {
+    console.log(pc7.yellow("Not logged in."));
+    console.log(pc7.dim("Run 'ctx7 login' to authenticate."));
+    return;
+  }
+  console.log(pc7.green("Logged in"));
+  try {
+    const userInfo = await fetchUserInfo(tokens.access_token);
+    if (userInfo.name) {
+      console.log(`${pc7.dim("Name:".padEnd(9))}${userInfo.name}`);
+    }
+    if (userInfo.email) {
+      console.log(`${pc7.dim("Email:".padEnd(9))}${userInfo.email}`);
+    }
+  } catch {
+    if (isTokenExpired(tokens) && !tokens.refresh_token) {
+      console.log(pc7.dim("(Session may be expired - run 'ctx7 login' to refresh)"));
+    }
+  }
+}
+async function fetchUserInfo(accessToken) {
+  const response = await fetch("https://clerk.context7.com/oauth/userinfo", {
+    headers: {
+      Authorization: `Bearer ${accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch user info");
+  }
+  return await response.json();
+}
+
 // src/constants.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync(join4(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync2(join6(__dirname, "../package.json"), "utf-8"));
 var VERSION = pkg.version;
 var NAME = pkg.name;
 
 // src/index.ts
 var brand = {
-  primary: pc4.green,
-  dim: pc4.dim
+  primary: pc8.green,
+  dim: pc8.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) => {
   const opts = thisCommand.opts();
   if (opts.baseUrl) {
     setBaseUrl(opts.baseUrl);
+    setAuthBaseUrl(opts.baseUrl);
   }
 }).addHelpText(
   "after",
@@ -869,6 +1886,7 @@ Visit ${brand.primary("https://context7.com")} to browse skills
 );
 registerSkillCommands(program);
 registerSkillAliases(program);
+registerAuthCommands(program);
 program.action(() => {
   console.log("");
   const banner = figlet.textSync("Context7", { font: "ANSI Shadow" });