@night-slayer18/leetcode-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1358 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk11 from "chalk";
+
+// src/commands/login.ts
+import inquirer from "inquirer";
+import ora from "ora";
+import chalk from "chalk";
+
+// src/api/client.ts
+import got from "got";
+
+// src/api/queries.ts
+var PROBLEM_LIST_QUERY = `
+  query problemsetQuestionList($categorySlug: String, $limit: Int, $skip: Int, $filters: QuestionListFilterInput) {
+    problemsetQuestionList: questionList(
+      categorySlug: $categorySlug
+      limit: $limit
+      skip: $skip
+      filters: $filters
+    ) {
+      total: totalNum
+      questions: data {
+        questionId
+        questionFrontendId
+        title
+        titleSlug
+        difficulty
+        isPaidOnly
+        acRate
+        topicTags {
+          name
+          slug
+        }
+        status
+      }
+    }
+  }
+`;
+var PROBLEM_DETAIL_QUERY = `
+  query questionData($titleSlug: String!) {
+    question(titleSlug: $titleSlug) {
+      questionId
+      questionFrontendId
+      title
+      titleSlug
+      content
+      difficulty
+      isPaidOnly
+      topicTags {
+        name
+        slug
+      }
+      codeSnippets {
+        lang
+        langSlug
+        code
+      }
+      sampleTestCase
+      exampleTestcases
+      hints
+      companyTags {
+        name
+        slug
+      }
+      stats
+      status
+    }
+  }
+`;
+var USER_STATUS_QUERY = `
+  query globalData {
+    userStatus {
+      isSignedIn
+      username
+    }
+  }
+`;
+var USER_PROFILE_QUERY = `
+  query userPublicProfile($username: String!) {
+    matchedUser(username: $username) {
+      username
+      profile {
+        realName
+        ranking
+      }
+      submitStatsGlobal {
+        acSubmissionNum {
+          difficulty
+          count
+        }
+      }
+      userCalendar {
+        streak
+        totalActiveDays
+      }
+    }
+  }
+`;
+var DAILY_CHALLENGE_QUERY = `
+  query questionOfToday {
+    activeDailyCodingChallengeQuestion {
+      date
+      link
+      question {
+        questionId
+        questionFrontendId
+        title
+        titleSlug
+        difficulty
+        isPaidOnly
+        acRate
+        topicTags {
+          name
+          slug
+        }
+        status
+      }
+    }
+  }
+`;
+
+// src/api/client.ts
+var LEETCODE_BASE_URL = "https://leetcode.com";
+var LEETCODE_GRAPHQL_URL = `${LEETCODE_BASE_URL}/graphql`;
+var LeetCodeClient = class {
+  client;
+  credentials = null;
+  constructor() {
+    this.client = got.extend({
+      prefixUrl: LEETCODE_BASE_URL,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+        "Origin": LEETCODE_BASE_URL,
+        "Referer": `${LEETCODE_BASE_URL}/`
+      },
+      timeout: { request: 3e4 },
+      retry: { limit: 2 }
+    });
+  }
+  setCredentials(credentials) {
+    this.credentials = credentials;
+    this.client = this.client.extend({
+      headers: {
+        "Cookie": `LEETCODE_SESSION=${credentials.session}; csrftoken=${credentials.csrfToken}`,
+        "X-CSRFToken": credentials.csrfToken
+      }
+    });
+  }
+  getCredentials() {
+    return this.credentials;
+  }
+  async graphql(query, variables = {}) {
+    const response = await this.client.post("graphql", {
+      json: { query, variables }
+    }).json();
+    if (response.errors?.length) {
+      throw new Error(`GraphQL Error: ${response.errors[0].message}`);
+    }
+    return response.data;
+  }
+  async checkAuth() {
+    const data = await this.graphql(USER_STATUS_QUERY);
+    return data.userStatus;
+  }
+  async getProblems(filters = {}) {
+    const variables = {
+      categorySlug: "",
+      limit: filters.limit ?? 50,
+      skip: filters.skip ?? 0,
+      filters: {}
+    };
+    if (filters.difficulty) {
+      variables.filters.difficulty = filters.difficulty;
+    }
+    if (filters.status) {
+      variables.filters.status = filters.status;
+    }
+    if (filters.tags?.length) {
+      variables.filters.tags = filters.tags;
+    }
+    if (filters.searchKeywords) {
+      variables.filters.searchKeywords = filters.searchKeywords;
+    }
+    const data = await this.graphql(PROBLEM_LIST_QUERY, variables);
+    return {
+      total: data.problemsetQuestionList.total,
+      problems: data.problemsetQuestionList.questions
+    };
+  }
+  async getProblem(titleSlug) {
+    const data = await this.graphql(
+      PROBLEM_DETAIL_QUERY,
+      { titleSlug }
+    );
+    return data.question;
+  }
+  async getProblemById(id) {
+    const { problems } = await this.getProblems({ searchKeywords: id, limit: 10 });
+    const problem = problems.find((p) => p.questionFrontendId === id);
+    if (!problem) {
+      throw new Error(`Problem #${id} not found`);
+    }
+    return this.getProblem(problem.titleSlug);
+  }
+  async getDailyChallenge() {
+    const data = await this.graphql(DAILY_CHALLENGE_QUERY);
+    return data.activeDailyCodingChallengeQuestion;
+  }
+  async getUserProfile(username) {
+    const data = await this.graphql(USER_PROFILE_QUERY, { username });
+    const user = data.matchedUser;
+    return {
+      username: user.username,
+      realName: user.profile.realName,
+      ranking: user.profile.ranking,
+      acSubmissionNum: user.submitStatsGlobal.acSubmissionNum,
+      streak: user.userCalendar.streak,
+      totalActiveDays: user.userCalendar.totalActiveDays
+    };
+  }
+  async testSolution(titleSlug, code, lang, testcases, questionId) {
+    const response = await this.client.post(`problems/${titleSlug}/interpret_solution/`, {
+      json: {
+        data_input: testcases,
+        lang,
+        typed_code: code,
+        question_id: questionId
+      }
+    }).json();
+    return this.pollSubmission(response.interpret_id, "interpret");
+  }
+  async submitSolution(titleSlug, code, lang, questionId) {
+    const response = await this.client.post(`problems/${titleSlug}/submit/`, {
+      json: {
+        lang,
+        typed_code: code,
+        question_id: questionId
+      }
+    }).json();
+    return this.pollSubmission(response.submission_id.toString(), "submission");
+  }
+  async pollSubmission(id, type) {
+    const endpoint = type === "interpret" ? `submissions/detail/${id}/check/` : `submissions/detail/${id}/check/`;
+    const maxAttempts = 30;
+    const delay = 1e3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.client.get(endpoint).json();
+      if (result.state === "SUCCESS" || result.state === "FAILURE") {
+        return result;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    throw new Error("Submission timeout: Result not available after 30 seconds");
+  }
+};
+var leetcodeClient = new LeetCodeClient();
+
+// src/storage/config.ts
+import Conf from "conf";
+import { homedir } from "os";
+import { join } from "path";
+var schema = {
+  credentials: {
+    type: "object",
+    nullable: true,
+    properties: {
+      csrfToken: { type: "string" },
+      session: { type: "string" }
+    }
+  },
+  config: {
+    type: "object",
+    properties: {
+      language: { type: "string", default: "typescript" },
+      editor: { type: "string" },
+      workDir: { type: "string", default: join(homedir(), "leetcode") }
+    },
+    default: {
+      language: "typescript",
+      workDir: join(homedir(), "leetcode")
+    }
+  }
+};
+var configStore = new Conf({
+  projectName: "leetcode-cli",
+  cwd: join(homedir(), ".leetcode"),
+  schema
+});
+var config = {
+  // Credentials
+  getCredentials() {
+    return configStore.get("credentials") ?? null;
+  },
+  setCredentials(credentials) {
+    configStore.set("credentials", credentials);
+  },
+  clearCredentials() {
+    configStore.delete("credentials");
+  },
+  // User Config
+  getConfig() {
+    return configStore.get("config");
+  },
+  setLanguage(language) {
+    configStore.set("config.language", language);
+  },
+  setEditor(editor) {
+    configStore.set("config.editor", editor);
+  },
+  setWorkDir(workDir) {
+    configStore.set("config.workDir", workDir);
+  },
+  // Get specific config values
+  getLanguage() {
+    return configStore.get("config.language");
+  },
+  getEditor() {
+    return configStore.get("config.editor");
+  },
+  getWorkDir() {
+    return configStore.get("config.workDir");
+  },
+  // Clear all config
+  clear() {
+    configStore.clear();
+  },
+  // Get config file path (for debugging)
+  getPath() {
+    return configStore.path;
+  }
+};
+
+// src/commands/login.ts
+async function loginCommand() {
+  console.log();
+  console.log(chalk.cyan("LeetCode CLI Login"));
+  console.log(chalk.gray("\u2500".repeat(40)));
+  console.log();
+  console.log(chalk.yellow("To login, you need to provide your LeetCode session cookies."));
+  console.log(chalk.gray("1. Open https://leetcode.com in your browser"));
+  console.log(chalk.gray("2. Login to your account"));
+  console.log(chalk.gray("3. Open DevTools (F12) \u2192 Application \u2192 Cookies \u2192 leetcode.com"));
+  console.log(chalk.gray("4. Copy the values of LEETCODE_SESSION and csrftoken"));
+  console.log();
+  const answers = await inquirer.prompt([
+    {
+      type: "password",
+      name: "session",
+      message: "LEETCODE_SESSION:",
+      mask: "*",
+      validate: (input) => input.length > 0 || "Session token is required"
+    },
+    {
+      type: "password",
+      name: "csrfToken",
+      message: "csrftoken:",
+      mask: "*",
+      validate: (input) => input.length > 0 || "CSRF token is required"
+    }
+  ]);
+  const credentials = {
+    session: answers.session.trim(),
+    csrfToken: answers.csrfToken.trim()
+  };
+  const spinner = ora("Verifying credentials...").start();
+  try {
+    leetcodeClient.setCredentials(credentials);
+    const { isSignedIn, username } = await leetcodeClient.checkAuth();
+    if (!isSignedIn || !username) {
+      spinner.fail("Invalid credentials");
+      console.log(chalk.red("Please check your session cookies and try again."));
+      return;
+    }
+    config.setCredentials(credentials);
+    spinner.succeed(`Logged in as ${chalk.green(username)}`);
+    console.log();
+    console.log(chalk.gray(`Credentials saved to ${config.getPath()}`));
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    if (error instanceof Error) {
+      console.log(chalk.red(error.message));
+    }
+  }
+}
+async function logoutCommand() {
+  config.clearCredentials();
+  console.log(chalk.green("\u2713 Logged out successfully"));
+}
+async function whoamiCommand() {
+  const credentials = config.getCredentials();
+  if (!credentials) {
+    console.log(chalk.yellow('Not logged in. Run "leetcode login" to authenticate.'));
+    return;
+  }
+  const spinner = ora("Checking session...").start();
+  try {
+    leetcodeClient.setCredentials(credentials);
+    const { isSignedIn, username } = await leetcodeClient.checkAuth();
+    if (!isSignedIn || !username) {
+      spinner.fail("Session expired");
+      console.log(chalk.yellow('Please run "leetcode login" to re-authenticate.'));
+      return;
+    }
+    spinner.succeed(`Logged in as ${chalk.green(username)}`);
+  } catch (error) {
+    spinner.fail("Failed to check session");
+    if (error instanceof Error) {
+      console.log(chalk.red(error.message));
+    }
+  }
+}
+
+// src/commands/list.ts
+import ora2 from "ora";
+import chalk3 from "chalk";
+
+// src/utils/display.ts
+import chalk2 from "chalk";
+import Table from "cli-table3";
+function displayProblemList(problems, total) {
+  const table = new Table({
+    head: [
+      chalk2.cyan("ID"),
+      chalk2.cyan("Title"),
+      chalk2.cyan("Difficulty"),
+      chalk2.cyan("Rate"),
+      chalk2.cyan("Status")
+    ],
+    colWidths: [8, 45, 12, 10, 10],
+    style: { head: [], border: [] }
+  });
+  for (const problem of problems) {
+    table.push([
+      problem.questionFrontendId,
+      problem.title.length > 42 ? problem.title.slice(0, 39) + "..." : problem.title,
+      colorDifficulty(problem.difficulty),
+      `${problem.acRate.toFixed(1)}%`,
+      formatStatus(problem.status)
+    ]);
+  }
+  console.log(table.toString());
+  console.log(chalk2.gray(`
+Showing ${problems.length} of ${total} problems`));
+}
+function displayProblemDetail(problem) {
+  console.log();
+  console.log(chalk2.bold.cyan(`  ${problem.questionFrontendId}. ${problem.title}`));
+  console.log(`  ${colorDifficulty(problem.difficulty)}`);
+  console.log(chalk2.gray(`  https://leetcode.com/problems/${problem.titleSlug}/`));
+  console.log();
+  if (problem.topicTags.length) {
+    const tags = problem.topicTags.map((t) => chalk2.bgBlue.white(` ${t.name} `)).join(" ");
+    console.log(`  ${tags}`);
+    console.log();
+  }
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  console.log();
+  let content = problem.content;
+  content = content.replace(/<sup>(.*?)<\/sup>/gi, "^$1");
+  content = content.replace(/<strong class="example">Example (\d+):<\/strong>/gi, "\xA7EXAMPLE\xA7$1\xA7");
+  content = content.replace(/Input:/gi, "\xA7INPUT\xA7");
+  content = content.replace(/Output:/gi, "\xA7OUTPUT\xA7");
+  content = content.replace(/Explanation:/gi, "\xA7EXPLAIN\xA7");
+  content = content.replace(/<strong>Constraints:<\/strong>/gi, "\xA7CONSTRAINTS\xA7");
+  content = content.replace(/Constraints:/gi, "\xA7CONSTRAINTS\xA7");
+  content = content.replace(/<strong>Follow-up:/gi, "\xA7FOLLOWUP\xA7");
+  content = content.replace(/Follow-up:/gi, "\xA7FOLLOWUP\xA7");
+  content = content.replace(/<li>/gi, "  \u2022 ");
+  content = content.replace(/<\/li>/gi, "\n");
+  content = content.replace(/<\/p>/gi, "\n\n");
+  content = content.replace(/<br\s*\/?>/gi, "\n");
+  content = content.replace(/<[^>]+>/g, "");
+  content = content.replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&le;/g, "\u2264").replace(/&ge;/g, "\u2265").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10)));
+  content = content.replace(/\n{3,}/g, "\n\n").trim();
+  content = content.replace(/§EXAMPLE§(\d+)§/g, (_, num) => chalk2.green.bold(`\u{1F4CC} Example ${num}:`));
+  content = content.replace(/§INPUT§/g, chalk2.yellow("Input:"));
+  content = content.replace(/§OUTPUT§/g, chalk2.yellow("Output:"));
+  content = content.replace(/§EXPLAIN§/g, chalk2.gray("Explanation:"));
+  content = content.replace(/§CONSTRAINTS§/g, chalk2.cyan.bold("\n\u{1F4CB} Constraints:"));
+  content = content.replace(/§FOLLOWUP§/g, chalk2.magenta.bold("\n\u{1F4A1} Follow-up:"));
+  console.log(content);
+  console.log();
+}
+function displayTestResult(result) {
+  console.log();
+  if (result.compile_error) {
+    console.log(chalk2.red.bold("\u274C Compile Error"));
+    console.log(chalk2.red(result.compile_error));
+    return;
+  }
+  if (result.runtime_error) {
+    console.log(chalk2.red.bold("\u274C Runtime Error"));
+    console.log(chalk2.red(result.runtime_error));
+    return;
+  }
+  if (result.correct_answer) {
+    console.log(chalk2.green.bold("\u2713 All test cases passed!"));
+  } else {
+    console.log(chalk2.yellow.bold("\u2717 Some test cases failed"));
+  }
+  console.log();
+  console.log(chalk2.gray("Your Output:"));
+  for (const output of result.code_answer) {
+    console.log(chalk2.white(`  ${output}`));
+  }
+  console.log();
+  console.log(chalk2.gray("Expected Output:"));
+  for (const output of result.expected_code_answer) {
+    console.log(chalk2.white(`  ${output}`));
+  }
+  if (result.std_output_list?.length) {
+    console.log();
+    console.log(chalk2.gray("Stdout:"));
+    for (const output of result.std_output_list) {
+      if (output) console.log(chalk2.gray(`  ${output}`));
+    }
+  }
+}
+function displaySubmissionResult(result) {
+  console.log();
+  if (result.compile_error) {
+    console.log(chalk2.red.bold("\u274C Compile Error"));
+    console.log(chalk2.red(result.compile_error));
+    return;
+  }
+  if (result.runtime_error) {
+    console.log(chalk2.red.bold("\u274C Runtime Error"));
+    console.log(chalk2.red(result.runtime_error));
+    if (result.last_testcase) {
+      console.log(chalk2.gray("Last testcase:"), result.last_testcase);
+    }
+    return;
+  }
+  if (result.status_msg === "Accepted") {
+    console.log(chalk2.green.bold("\u2713 Accepted!"));
+    console.log();
+    console.log(
+      chalk2.gray("Runtime:"),
+      chalk2.white(result.status_runtime),
+      chalk2.gray(`(beats ${result.runtime_percentile?.toFixed(1) ?? "N/A"}%)`)
+    );
+    console.log(
+      chalk2.gray("Memory:"),
+      chalk2.white(result.status_memory),
+      chalk2.gray(`(beats ${result.memory_percentile?.toFixed(1) ?? "N/A"}%)`)
+    );
+  } else {
+    console.log(chalk2.red.bold(`\u274C ${result.status_msg}`));
+    console.log();
+    console.log(chalk2.gray(`Passed ${result.total_correct}/${result.total_testcases} testcases`));
+    if (result.code_output) {
+      console.log(chalk2.gray("Your Output:"), result.code_output);
+    }
+    if (result.expected_output) {
+      console.log(chalk2.gray("Expected:"), result.expected_output);
+    }
+    if (result.last_testcase) {
+      console.log(chalk2.gray("Failed testcase:"), result.last_testcase);
+    }
+  }
+}
+function displayUserStats(username, realName, ranking, acStats, streak, totalActiveDays) {
+  console.log();
+  console.log(chalk2.bold.white(`\u{1F464} ${username}`) + (realName ? chalk2.gray(` (${realName})`) : ""));
+  console.log(chalk2.gray(`Ranking: #${ranking.toLocaleString()}`));
+  console.log();
+  const table = new Table({
+    head: [chalk2.cyan("Difficulty"), chalk2.cyan("Solved")],
+    style: { head: [], border: [] }
+  });
+  for (const stat of acStats) {
+    if (stat.difficulty !== "All") {
+      table.push([
+        colorDifficulty(stat.difficulty),
+        stat.count.toString()
+      ]);
+    }
+  }
+  const total = acStats.find((s) => s.difficulty === "All")?.count ?? 0;
+  table.push([chalk2.white.bold("Total"), chalk2.white.bold(total.toString())]);
+  console.log(table.toString());
+  console.log();
+  console.log(chalk2.gray("\u{1F525} Current streak:"), chalk2.hex("#FFA500")(streak.toString()), chalk2.gray("days"));
+  console.log(chalk2.gray("\u{1F4C5} Total active days:"), chalk2.white(totalActiveDays.toString()));
+}
+function displayDailyChallenge(date, problem) {
+  console.log();
+  console.log(chalk2.bold.yellow("\u{1F3AF} Daily Challenge"), chalk2.gray(`(${date})`));
+  console.log();
+  console.log(chalk2.white(`${problem.questionFrontendId}. ${problem.title}`));
+  console.log(colorDifficulty(problem.difficulty));
+  console.log(chalk2.gray(`https://leetcode.com/problems/${problem.titleSlug}/`));
+  if (problem.topicTags.length) {
+    console.log();
+    const tags = problem.topicTags.map((t) => chalk2.blue(t.name)).join(" ");
+    console.log(chalk2.gray("Tags:"), tags);
+  }
+}
+function colorDifficulty(difficulty) {
+  switch (difficulty.toLowerCase()) {
+    case "easy":
+      return chalk2.green(difficulty);
+    case "medium":
+      return chalk2.yellow(difficulty);
+    case "hard":
+      return chalk2.red(difficulty);
+    default:
+      return difficulty;
+  }
+}
+function formatStatus(status) {
+  switch (status) {
+    case "ac":
+      return chalk2.green("\u2713");
+    case "notac":
+      return chalk2.yellow("\u25CB");
+    default:
+      return chalk2.gray("-");
+  }
+}
+
+// src/commands/list.ts
+async function listCommand(options) {
+  const credentials = config.getCredentials();
+  if (credentials) {
+    leetcodeClient.setCredentials(credentials);
+  }
+  const spinner = ora2("Fetching problems...").start();
+  try {
+    const filters = {};
+    const limit = parseInt(options.limit ?? "20", 10);
+    const page = parseInt(options.page ?? "1", 10);
+    filters.limit = limit;
+    filters.skip = (page - 1) * limit;
+    if (options.difficulty) {
+      const diffMap = {
+        easy: "EASY",
+        e: "EASY",
+        medium: "MEDIUM",
+        m: "MEDIUM",
+        hard: "HARD",
+        h: "HARD"
+      };
+      filters.difficulty = diffMap[options.difficulty.toLowerCase()];
+    }
+    if (options.status) {
+      const statusMap = {
+        todo: "NOT_STARTED",
+        solved: "AC",
+        ac: "AC",
+        attempted: "TRIED",
+        tried: "TRIED"
+      };
+      filters.status = statusMap[options.status.toLowerCase()];
+    }
+    if (options.tag?.length) {
+      filters.tags = options.tag;
+    }
+    if (options.search) {
+      filters.searchKeywords = options.search;
+    }
+    const { total, problems } = await leetcodeClient.getProblems(filters);
+    spinner.stop();
+    if (problems.length === 0) {
+      console.log(chalk3.yellow("No problems found matching your criteria."));
+      return;
+    }
+    displayProblemList(problems, total);
+    if (page * limit < total) {
+      console.log(chalk3.gray(`
+Page ${page} of ${Math.ceil(total / limit)}. Use --page to navigate.`));
+    }
+  } catch (error) {
+    spinner.fail("Failed to fetch problems");
+    if (error instanceof Error) {
+      console.log(chalk3.red(error.message));
+    }
+  }
+}
+
+// src/commands/show.ts
+import ora3 from "ora";
+import chalk4 from "chalk";
+async function showCommand(idOrSlug) {
+  const credentials = config.getCredentials();
+  if (credentials) {
+    leetcodeClient.setCredentials(credentials);
+  }
+  const spinner = ora3("Fetching problem...").start();
+  try {
+    let problem;
+    if (/^\d+$/.test(idOrSlug)) {
+      problem = await leetcodeClient.getProblemById(idOrSlug);
+    } else {
+      problem = await leetcodeClient.getProblem(idOrSlug);
+    }
+    spinner.stop();
+    displayProblemDetail(problem);
+  } catch (error) {
+    spinner.fail("Failed to fetch problem");
+    if (error instanceof Error) {
+      console.log(chalk4.red(error.message));
+    }
+  }
+}
+
+// src/commands/pick.ts
+import { writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+import { spawn } from "child_process";
+import ora4 from "ora";
+import chalk5 from "chalk";
+
+// src/utils/templates.ts
+var LANGUAGE_EXTENSIONS = {
+  typescript: "ts",
+  javascript: "js",
+  python3: "py",
+  java: "java",
+  cpp: "cpp",
+  c: "c",
+  csharp: "cs",
+  go: "go",
+  rust: "rs",
+  kotlin: "kt",
+  swift: "swift"
+};
+var LANG_SLUG_MAP = {
+  typescript: "typescript",
+  javascript: "javascript",
+  python3: "python3",
+  python: "python3",
+  java: "java",
+  "c++": "cpp",
+  cpp: "cpp",
+  c: "c",
+  "c#": "csharp",
+  csharp: "csharp",
+  go: "go",
+  golang: "go",
+  rust: "rust",
+  kotlin: "kotlin",
+  swift: "swift"
+};
+function getCodeTemplate(snippets, preferredLanguage) {
+  const preferred = snippets.find(
+    (s) => LANG_SLUG_MAP[s.langSlug.toLowerCase()] === preferredLanguage
+  );
+  if (preferred) return preferred;
+  return snippets[0] ?? null;
+}
+function generateSolutionFile(problemId, titleSlug, title, difficulty, codeSnippet, language, problemContent) {
+  const commentStyle = getCommentStyle(language);
+  const header = generateHeader(commentStyle, problemId, title, difficulty, titleSlug, problemContent);
+  return `${header}
+
+${codeSnippet}
+`;
+}
+function getCommentStyle(language) {
+  switch (language) {
+    case "python3":
+      return { single: "#", blockStart: '"""', blockEnd: '"""', linePrefix: "" };
+    case "c":
+    case "cpp":
+    case "java":
+    case "typescript":
+    case "javascript":
+    case "go":
+    case "rust":
+    case "kotlin":
+    case "swift":
+    case "csharp":
+    default:
+      return { single: "//", blockStart: "/*", blockEnd: "*/", linePrefix: " * " };
+  }
+}
+function formatProblemContent(html) {
+  let content = html;
+  content = content.replace(/<sup>(.*?)<\/sup>/gi, "^$1");
+  content = content.replace(/<strong class="example">Example (\d+):<\/strong>/gi, "\nExample $1:");
+  content = content.replace(/<li>/gi, "\u2022 ");
+  content = content.replace(/<\/li>/gi, "\n");
+  content = content.replace(/<\/p>/gi, "\n\n");
+  content = content.replace(/<br\s*\/?>/gi, "\n");
+  content = content.replace(/<[^>]+>/g, "");
+  content = content.replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&le;/g, "<=").replace(/&ge;/g, ">=").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code, 10)));
+  content = content.replace(/\n{3,}/g, "\n\n").trim();
+  return content;
+}
+function generateHeader(style, problemId, title, difficulty, titleSlug, problemContent) {
+  const prefix = style.linePrefix;
+  const lines = [
+    style.blockStart,
+    `${prefix}${problemId}. ${title}`,
+    `${prefix}Difficulty: ${difficulty}`,
+    `${prefix}https://leetcode.com/problems/${titleSlug}/`
+  ];
+  if (problemContent) {
+    lines.push(`${prefix}`);
+    lines.push(`${prefix}${"\u2500".repeat(50)}`);
+    lines.push(`${prefix}`);
+    const formattedContent = formatProblemContent(problemContent);
+    const contentLines = formattedContent.split("\n");
+    for (const line of contentLines) {
+      if (line.length > 70) {
+        const words = line.split(" ");
+        let currentLine = "";
+        for (const word of words) {
+          if ((currentLine + " " + word).length > 70) {
+            lines.push(`${prefix}${currentLine.trim()}`);
+            currentLine = word;
+          } else {
+            currentLine += " " + word;
+          }
+        }
+        if (currentLine.trim()) {
+          lines.push(`${prefix}${currentLine.trim()}`);
+        }
+      } else {
+        lines.push(`${prefix}${line}`);
+      }
+    }
+  }
+  lines.push(style.blockEnd);
+  return lines.join("\n");
+}
+function getSolutionFileName(problemId, titleSlug, language) {
+  const ext = LANGUAGE_EXTENSIONS[language];
+  return `${problemId}.${titleSlug}.${ext}`;
+}
+
+// src/commands/pick.ts
+async function pickCommand(idOrSlug, options) {
+  const credentials = config.getCredentials();
+  if (credentials) {
+    leetcodeClient.setCredentials(credentials);
+  }
+  const spinner = ora4("Fetching problem...").start();
+  try {
+    let problem;
+    if (/^\d+$/.test(idOrSlug)) {
+      problem = await leetcodeClient.getProblemById(idOrSlug);
+    } else {
+      problem = await leetcodeClient.getProblem(idOrSlug);
+    }
+    spinner.text = "Generating solution file...";
+    const langInput = options.lang?.toLowerCase() ?? config.getLanguage();
+    const language = LANG_SLUG_MAP[langInput] ?? langInput;
+    const template = getCodeTemplate(problem.codeSnippets, language);
+    if (!template) {
+      spinner.fail(`No code template available for ${language}`);
+      return;
+    }
+    const content = generateSolutionFile(
+      problem.questionFrontendId,
+      problem.titleSlug,
+      problem.title,
+      problem.difficulty,
+      template.code,
+      language,
+      problem.content
+    );
+    const workDir = config.getWorkDir();
+    const difficulty = problem.difficulty;
+    const category = problem.topicTags.length > 0 ? problem.topicTags[0].name.replace(/[^\w\s-]/g, "").trim() : "Uncategorized";
+    const targetDir = join2(workDir, difficulty, category);
+    if (!existsSync(targetDir)) {
+      await mkdir(targetDir, { recursive: true });
+    }
+    const fileName = getSolutionFileName(problem.questionFrontendId, problem.titleSlug, language);
+    const filePath = join2(targetDir, fileName);
+    if (existsSync(filePath)) {
+      spinner.warn(`File already exists: ${fileName}`);
+      console.log(chalk5.gray(`Path: ${filePath}`));
+      if (options.open !== false) {
+        openInEditor(filePath);
+      }
+      return;
+    }
+    await writeFile(filePath, content, "utf-8");
+    spinner.succeed(`Created ${chalk5.green(fileName)}`);
+    console.log(chalk5.gray(`Path: ${filePath}`));
+    console.log();
+    console.log(chalk5.cyan(`${problem.questionFrontendId}. ${problem.title}`));
+    console.log(chalk5.gray(`Difficulty: ${problem.difficulty} | Category: ${category}`));
+    if (options.open !== false) {
+      openInEditor(filePath);
+    }
+  } catch (error) {
+    spinner.fail("Failed to create solution file");
+    if (error instanceof Error) {
+      console.log(chalk5.red(error.message));
+    }
+  }
+}
+function openInEditor(filePath) {
+  const editor = config.getEditor() ?? process.env.EDITOR ?? "code";
+  const workDir = config.getWorkDir();
+  const terminalEditors = ["vim", "nvim", "vi", "nano", "emacs", "micro"];
+  if (terminalEditors.includes(editor)) {
+    console.log();
+    console.log(chalk5.gray(`Open with: ${editor} ${filePath}`));
+    return;
+  }
+  try {
+    if (editor === "code" || editor === "code-insiders" || editor === "cursor") {
+      const child = spawn(editor, ["-r", workDir, "-g", filePath], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+    } else {
+      const child = spawn(editor, [filePath], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+    }
+  } catch {
+  }
+}
+
+// src/commands/test.ts
+import { readFile, readdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { basename, join as join3 } from "path";
+import ora5 from "ora";
+import chalk6 from "chalk";
+async function findSolutionFile(dir, problemId) {
+  if (!existsSync2(dir)) return null;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      const found = await findSolutionFile(fullPath, problemId);
+      if (found) return found;
+    } else if (entry.name.startsWith(`${problemId}.`)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function findFileByName(dir, fileName) {
+  if (!existsSync2(dir)) return null;
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      const found = await findFileByName(fullPath, fileName);
+      if (found) return found;
+    } else if (entry.name === fileName) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function testCommand(fileOrId, options) {
+  const credentials = config.getCredentials();
+  if (!credentials) {
+    console.log(chalk6.yellow("Please login first: leetcode login"));
+    return;
+  }
+  leetcodeClient.setCredentials(credentials);
+  let filePath = fileOrId;
+  if (/^\d+$/.test(fileOrId)) {
+    const workDir = config.getWorkDir();
+    const found = await findSolutionFile(workDir, fileOrId);
+    if (!found) {
+      console.log(chalk6.red(`No solution file found for problem ${fileOrId}`));
+      console.log(chalk6.gray(`Looking in: ${workDir}`));
+      console.log(chalk6.gray('Run "leetcode pick ' + fileOrId + '" first to create a solution file.'));
+      return;
+    }
+    filePath = found;
+    console.log(chalk6.gray(`Found: ${filePath}`));
+  } else if (!fileOrId.includes("/") && !fileOrId.includes("\\") && fileOrId.includes(".")) {
+    const workDir = config.getWorkDir();
+    const found = await findFileByName(workDir, fileOrId);
+    if (!found) {
+      console.log(chalk6.red(`File not found: ${fileOrId}`));
+      console.log(chalk6.gray(`Looking in: ${workDir}`));
+      return;
+    }
+    filePath = found;
+    console.log(chalk6.gray(`Found: ${filePath}`));
+  }
+  if (!existsSync2(filePath)) {
+    console.log(chalk6.red(`File not found: ${filePath}`));
+    return;
+  }
+  const spinner = ora5("Reading solution file...").start();
+  try {
+    const fileName = basename(filePath);
+    const match = fileName.match(/^(\d+)\.([^.]+)\./);
+    if (!match) {
+      spinner.fail("Invalid filename format");
+      console.log(chalk6.gray("Expected format: {id}.{title-slug}.{ext}"));
+      console.log(chalk6.gray("Example: 1.two-sum.ts"));
+      return;
+    }
+    const [, problemId, titleSlug] = match;
+    const ext = fileName.split(".").pop();
+    const langMap = {
+      ts: "typescript",
+      js: "javascript",
+      py: "python3",
+      java: "java",
+      cpp: "cpp",
+      c: "c",
+      cs: "csharp",
+      go: "golang",
+      rs: "rust",
+      kt: "kotlin",
+      swift: "swift"
+    };
+    const lang = langMap[ext];
+    if (!lang) {
+      spinner.fail(`Unsupported file extension: .${ext}`);
+      return;
+    }
+    const code = await readFile(filePath, "utf-8");
+    spinner.text = "Fetching problem details...";
+    const problem = await leetcodeClient.getProblem(titleSlug);
+    const testcases = options.testcase ?? problem.exampleTestcases ?? problem.sampleTestCase;
+    spinner.text = "Running tests...";
+    const result = await leetcodeClient.testSolution(titleSlug, code, lang, testcases, problem.questionId);
+    spinner.stop();
+    displayTestResult(result);
+  } catch (error) {
+    spinner.fail("Test failed");
+    if (error instanceof Error) {
+      console.log(chalk6.red(error.message));
+    }
+  }
+}
+
+// src/commands/submit.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { basename as basename2, join as join4 } from "path";
+import ora6 from "ora";
+import chalk7 from "chalk";
+async function findSolutionFile2(dir, problemId) {
+  if (!existsSync3(dir)) return null;
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      const found = await findSolutionFile2(fullPath, problemId);
+      if (found) return found;
+    } else if (entry.name.startsWith(`${problemId}.`)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function findFileByName2(dir, fileName) {
+  if (!existsSync3(dir)) return null;
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      const found = await findFileByName2(fullPath, fileName);
+      if (found) return found;
+    } else if (entry.name === fileName) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function submitCommand(fileOrId) {
+  const credentials = config.getCredentials();
+  if (!credentials) {
+    console.log(chalk7.yellow("Please login first: leetcode login"));
+    return;
+  }
+  leetcodeClient.setCredentials(credentials);
+  let filePath = fileOrId;
+  if (/^\d+$/.test(fileOrId)) {
+    const workDir = config.getWorkDir();
+    const found = await findSolutionFile2(workDir, fileOrId);
+    if (!found) {
+      console.log(chalk7.red(`No solution file found for problem ${fileOrId}`));
+      console.log(chalk7.gray(`Looking in: ${workDir}`));
+      console.log(chalk7.gray('Run "leetcode pick ' + fileOrId + '" first to create a solution file.'));
+      return;
+    }
+    filePath = found;
+    console.log(chalk7.gray(`Found: ${filePath}`));
+  } else if (!fileOrId.includes("/") && !fileOrId.includes("\\") && fileOrId.includes(".")) {
+    const workDir = config.getWorkDir();
+    const found = await findFileByName2(workDir, fileOrId);
+    if (!found) {
+      console.log(chalk7.red(`File not found: ${fileOrId}`));
+      console.log(chalk7.gray(`Looking in: ${workDir}`));
+      return;
+    }
+    filePath = found;
+    console.log(chalk7.gray(`Found: ${filePath}`));
+  }
+  if (!existsSync3(filePath)) {
+    console.log(chalk7.red(`File not found: ${filePath}`));
+    return;
+  }
+  const spinner = ora6("Reading solution file...").start();
+  try {
+    const fileName = basename2(filePath);
+    const match = fileName.match(/^(\d+)\.([^.]+)\./);
+    if (!match) {
+      spinner.fail("Invalid filename format");
+      console.log(chalk7.gray("Expected format: {id}.{title-slug}.{ext}"));
+      console.log(chalk7.gray("Example: 1.two-sum.ts"));
+      return;
+    }
+    const [, problemId, titleSlug] = match;
+    const ext = fileName.split(".").pop();
+    const langMap = {
+      ts: "typescript",
+      js: "javascript",
+      py: "python3",
+      java: "java",
+      cpp: "cpp",
+      c: "c",
+      cs: "csharp",
+      go: "golang",
+      rs: "rust",
+      kt: "kotlin",
+      swift: "swift"
+    };
+    const lang = langMap[ext];
+    if (!lang) {
+      spinner.fail(`Unsupported file extension: .${ext}`);
+      return;
+    }
+    const code = await readFile2(filePath, "utf-8");
+    spinner.text = "Fetching problem details...";
+    const problem = await leetcodeClient.getProblem(titleSlug);
+    spinner.text = "Submitting solution...";
+    const result = await leetcodeClient.submitSolution(
+      titleSlug,
+      code,
+      lang,
+      problem.questionId
+    );
+    spinner.stop();
+    displaySubmissionResult(result);
+  } catch (error) {
+    spinner.fail("Submission failed");
+    if (error instanceof Error) {
+      console.log(chalk7.red(error.message));
+    }
+  }
+}
+
+// src/commands/stat.ts
+import ora7 from "ora";
+import chalk8 from "chalk";
+async function statCommand(username) {
+  const credentials = config.getCredentials();
+  if (!credentials && !username) {
+    console.log(chalk8.yellow("Please login first or provide a username: leetcode stat [username]"));
+    return;
+  }
+  if (credentials) {
+    leetcodeClient.setCredentials(credentials);
+  }
+  const spinner = ora7("Fetching statistics...").start();
+  try {
+    let targetUsername = username;
+    if (!targetUsername && credentials) {
+      const { isSignedIn, username: currentUser } = await leetcodeClient.checkAuth();
+      if (!isSignedIn || !currentUser) {
+        spinner.fail("Session expired");
+        console.log(chalk8.yellow('Please run "leetcode login" to re-authenticate.'));
+        return;
+      }
+      targetUsername = currentUser;
+    }
+    if (!targetUsername) {
+      spinner.fail("No username available");
+      return;
+    }
+    const profile = await leetcodeClient.getUserProfile(targetUsername);
+    spinner.stop();
+    displayUserStats(
+      profile.username,
+      profile.realName,
+      profile.ranking,
+      profile.acSubmissionNum,
+      profile.streak,
+      profile.totalActiveDays
+    );
+  } catch (error) {
+    spinner.fail("Failed to fetch statistics");
+    if (error instanceof Error) {
+      console.log(chalk8.red(error.message));
+    }
+  }
+}
+
+// src/commands/daily.ts
+import ora8 from "ora";
+import chalk9 from "chalk";
+async function dailyCommand(options) {
+  const credentials = config.getCredentials();
+  if (credentials) {
+    leetcodeClient.setCredentials(credentials);
+  }
+  const spinner = ora8("Fetching daily challenge...").start();
+  try {
+    const daily = await leetcodeClient.getDailyChallenge();
+    spinner.stop();
+    displayDailyChallenge(daily.date, daily.question);
+    console.log();
+    console.log(chalk9.gray("Run the following to start working on this problem:"));
+    console.log(chalk9.cyan(`  leetcode pick ${daily.question.titleSlug}`));
+  } catch (error) {
+    spinner.fail("Failed to fetch daily challenge");
+    if (error instanceof Error) {
+      console.log(chalk9.red(error.message));
+    }
+  }
+}
+
+// src/commands/config.ts
+import inquirer2 from "inquirer";
+import chalk10 from "chalk";
+var SUPPORTED_LANGUAGES = [
+  "typescript",
+  "javascript",
+  "python3",
+  "java",
+  "cpp",
+  "c",
+  "csharp",
+  "go",
+  "rust",
+  "kotlin",
+  "swift"
+];
+async function configCommand(options) {
+  if (!options.lang && !options.editor && !options.workdir) {
+    showCurrentConfig();
+    return;
+  }
+  if (options.lang) {
+    const lang = options.lang.toLowerCase();
+    if (!SUPPORTED_LANGUAGES.includes(lang)) {
+      console.log(chalk10.red(`Unsupported language: ${options.lang}`));
+      console.log(chalk10.gray(`Supported: ${SUPPORTED_LANGUAGES.join(", ")}`));
+      return;
+    }
+    config.setLanguage(lang);
+    console.log(chalk10.green(`\u2713 Default language set to ${lang}`));
+  }
+  if (options.editor) {
+    config.setEditor(options.editor);
+    console.log(chalk10.green(`\u2713 Editor set to ${options.editor}`));
+  }
+  if (options.workdir) {
+    config.setWorkDir(options.workdir);
+    console.log(chalk10.green(`\u2713 Work directory set to ${options.workdir}`));
+  }
+}
+async function configInteractiveCommand() {
+  const currentConfig = config.getConfig();
+  const answers = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "language",
+      message: "Default programming language:",
+      choices: SUPPORTED_LANGUAGES,
+      default: currentConfig.language
+    },
+    {
+      type: "input",
+      name: "editor",
+      message: "Editor command (e.g., code, vim, nvim):",
+      default: currentConfig.editor ?? "code"
+    },
+    {
+      type: "input",
+      name: "workDir",
+      message: "Working directory for solution files:",
+      default: currentConfig.workDir
+    }
+  ]);
+  config.setLanguage(answers.language);
+  config.setEditor(answers.editor);
+  config.setWorkDir(answers.workDir);
+  console.log();
+  console.log(chalk10.green("\u2713 Configuration saved"));
+  showCurrentConfig();
+}
+function showCurrentConfig() {
+  const currentConfig = config.getConfig();
+  const credentials = config.getCredentials();
+  console.log();
+  console.log(chalk10.bold("LeetCode CLI Configuration"));
+  console.log(chalk10.gray("\u2500".repeat(40)));
+  console.log();
+  console.log(chalk10.gray("Config file:"), config.getPath());
+  console.log();
+  console.log(chalk10.gray("Language:    "), chalk10.white(currentConfig.language));
+  console.log(chalk10.gray("Editor:      "), chalk10.white(currentConfig.editor ?? "(not set)"));
+  console.log(chalk10.gray("Work Dir:    "), chalk10.white(currentConfig.workDir));
+  console.log(chalk10.gray("Logged in:   "), credentials ? chalk10.green("Yes") : chalk10.yellow("No"));
+}
+
+// src/index.ts
+var program = new Command();
+program.configureHelp({
+  sortSubcommands: true,
+  subcommandTerm: (cmd) => chalk11.cyan(cmd.name()) + (cmd.alias() ? chalk11.gray(`|${cmd.alias()}`) : ""),
+  subcommandDescription: (cmd) => chalk11.white(cmd.description()),
+  optionTerm: (option) => chalk11.yellow(option.flags),
+  optionDescription: (option) => chalk11.white(option.description)
+});
+program.name("leetcode").usage("[command] [options]").description(chalk11.bold.cyan("\u{1F525} A modern LeetCode CLI built with TypeScript")).version("1.0.0", "-v, --version", "Output the version number").helpOption("-h, --help", "Display help for command").addHelpText("after", `
+${chalk11.yellow("Examples:")}
+  ${chalk11.cyan("$ leetcode login")}             Login to LeetCode
+  ${chalk11.cyan("$ leetcode list -d easy")}      List easy problems
+  ${chalk11.cyan("$ leetcode pick 1")}            Start solving "Two Sum"
+  ${chalk11.cyan("$ leetcode test 1")}            Test your solution
+  ${chalk11.cyan("$ leetcode submit 1")}          Submit your solution
+`);
+program.command("login").description("Login to LeetCode with browser cookies").action(loginCommand);
+program.command("logout").description("Clear stored credentials").action(logoutCommand);
+program.command("whoami").description("Check current login status").action(whoamiCommand);
+program.command("list").alias("l").description("List LeetCode problems").option("-d, --difficulty <level>", "Filter by difficulty (easy/medium/hard)").option("-s, --status <status>", "Filter by status (todo/solved/attempted)").option("-t, --tag <tags...>", "Filter by topic tags").option("-q, --search <keywords>", "Search by keywords").option("-n, --limit <number>", "Number of problems to show", "20").option("-p, --page <number>", "Page number", "1").action(listCommand);
+program.command("show <id>").alias("s").description("Show problem description").action(showCommand);
+program.command("daily").alias("d").description("Show today's daily challenge").action(dailyCommand);
+program.command("pick <id>").alias("p").description("Generate solution file for a problem").option("-l, --lang <language>", "Programming language for the solution").option("--no-open", "Do not open file in editor").action(pickCommand);
+program.command("test <file>").alias("t").description("Test solution against sample test cases").option("-c, --testcase <testcase>", "Custom test case").action(testCommand);
+program.command("submit <file>").alias("x").description("Submit solution to LeetCode").action(submitCommand);
+program.command("stat [username]").description("Show user statistics").action(statCommand);
+program.command("config").description("View or set configuration").option("-l, --lang <language>", "Set default programming language").option("-e, --editor <editor>", "Set editor command").option("-w, --workdir <path>", "Set working directory for solutions").option("-i, --interactive", "Interactive configuration").action(async (options) => {
+  if (options.interactive) {
+    await configInteractiveCommand();
+  } else {
+    await configCommand(options);
+  }
+});
+program.showHelpAfterError("(add --help for additional information)");
+program.parse();
+if (!process.argv.slice(2).length) {
+  console.log();
+  console.log(chalk11.bold.cyan("  \u{1F525} LeetCode CLI"));
+  console.log(chalk11.gray("  A modern command-line interface for LeetCode"));
+  console.log();
+  program.outputHelp();
+}