@night-slayer18/leetcode-cli 1.1.0 → 1.4.0

package/dist/index.js

@@ -1,6 +1,8 @@
+#!/usr/bin/env node
+
 // src/index.ts
 import { Command } from "commander";
-import chalk13 from "chalk";
+import chalk20 from "chalk";
 
 // src/commands/login.ts
 import inquirer from "inquirer";
@@ -9,6 +11,114 @@ import chalk from "chalk";
 
 // src/api/client.ts
 import got from "got";
+import { z as z2 } from "zod";
+
+// src/schemas/api.ts
+import { z } from "zod";
+var TopicTagSchema = z.object({
+  name: z.string(),
+  slug: z.string()
+});
+var CompanyTagSchema = z.object({
+  name: z.string(),
+  slug: z.string()
+});
+var CodeSnippetSchema = z.object({
+  lang: z.string(),
+  langSlug: z.string(),
+  code: z.string()
+});
+var ProblemSchema = z.object({
+  questionId: z.string(),
+  questionFrontendId: z.string(),
+  title: z.string(),
+  titleSlug: z.string(),
+  difficulty: z.enum(["Easy", "Medium", "Hard"]),
+  isPaidOnly: z.boolean(),
+  acRate: z.number().optional().default(0),
+  topicTags: z.array(TopicTagSchema),
+  status: z.enum(["ac", "notac"]).nullable()
+});
+var ProblemDetailSchema = ProblemSchema.extend({
+  content: z.string().nullable(),
+  codeSnippets: z.array(CodeSnippetSchema).nullable(),
+  sampleTestCase: z.string(),
+  exampleTestcases: z.string(),
+  hints: z.array(z.string()),
+  companyTags: z.array(CompanyTagSchema).nullable(),
+  stats: z.string()
+});
+var DailyChallengeSchema = z.object({
+  date: z.string(),
+  link: z.string(),
+  question: ProblemSchema
+});
+var SubmissionSchema = z.object({
+  id: z.string(),
+  statusDisplay: z.string(),
+  lang: z.string(),
+  runtime: z.string(),
+  timestamp: z.string(),
+  memory: z.string()
+});
+var SubmissionDetailsSchema = z.object({
+  code: z.string(),
+  lang: z.object({
+    name: z.string()
+  })
+});
+var TestResultSchema = z.object({
+  status_code: z.number(),
+  status_msg: z.string(),
+  state: z.string(),
+  run_success: z.boolean(),
+  code_answer: z.array(z.string()).optional(),
+  expected_code_answer: z.array(z.string()).optional(),
+  correct_answer: z.boolean().optional(),
+  std_output_list: z.array(z.string()).optional(),
+  compile_error: z.string().optional(),
+  runtime_error: z.string().optional()
+});
+var SubmissionResultSchema = z.object({
+  status_code: z.number(),
+  status_msg: z.string(),
+  state: z.string(),
+  run_success: z.boolean(),
+  total_correct: z.number(),
+  total_testcases: z.number(),
+  status_runtime: z.string(),
+  status_memory: z.string(),
+  runtime_percentile: z.number(),
+  memory_percentile: z.number(),
+  code_output: z.string().optional(),
+  std_output: z.string().optional(),
+  expected_output: z.string().optional(),
+  compile_error: z.string().optional(),
+  runtime_error: z.string().optional(),
+  last_testcase: z.string().optional()
+});
+var UserProfileSchema = z.object({
+  username: z.string(),
+  profile: z.object({
+    realName: z.string(),
+    ranking: z.number()
+  }),
+  submitStatsGlobal: z.object({
+    acSubmissionNum: z.array(z.object({
+      difficulty: z.string(),
+      count: z.number()
+    }))
+  }),
+  userCalendar: z.object({
+    streak: z.number(),
+    totalActiveDays: z.number(),
+    submissionCalendar: z.string().optional()
+  })
+});
+var UserStatusSchema = z.object({
+  isSignedIn: z.boolean(),
+  username: z.string().nullable()
+});
 
 // src/api/queries.ts
 var PROBLEM_LIST_QUERY = `
@@ -93,6 +203,30 @@ var USER_PROFILE_QUERY = `
       userCalendar {
         streak
         totalActiveDays
+        submissionCalendar
+      }
+    }
+  }
+`;
+var SKILL_STATS_QUERY = `
+  query skillStats($username: String!) {
+    matchedUser(username: $username) {
+      tagProblemCounts {
+        fundamental {
+          tagName
+          tagSlug
+          problemsSolved
+        }
+        intermediate {
+          tagName
+          tagSlug
+          problemsSolved
+        }
+        advanced {
+          tagName
+          tagSlug
+          problemsSolved
+        }
       }
     }
   }
@@ -197,7 +331,8 @@ var LeetCodeClient = class {
   }
   async checkAuth() {
     const data = await this.graphql(USER_STATUS_QUERY);
-    return data.userStatus;
+    const validated = UserStatusSchema.parse(data.userStatus);
+    return validated;
   }
   async getProblems(filters = {}) {
     const variables = {
@@ -219,9 +354,10 @@ var LeetCodeClient = class {
       variables.filters.searchKeywords = filters.searchKeywords;
     }
     const data = await this.graphql(PROBLEM_LIST_QUERY, variables);
+    const validatedProblems = z2.array(ProblemSchema).parse(data.problemsetQuestionList.questions);
     return {
       total: data.problemsetQuestionList.total,
-      problems: data.problemsetQuestionList.questions
+      problems: validatedProblems
     };
   }
   async getProblem(titleSlug) {
@@ -229,7 +365,8 @@ var LeetCodeClient = class {
       PROBLEM_DETAIL_QUERY,
       { titleSlug }
     );
-    return data.question;
+    const validated = ProblemDetailSchema.parse(data.question);
+    return validated;
   }
   async getProblemById(id) {
     const { problems } = await this.getProblems({ searchKeywords: id, limit: 10 });
@@ -241,7 +378,8 @@ var LeetCodeClient = class {
   }
   async getDailyChallenge() {
     const data = await this.graphql(DAILY_CHALLENGE_QUERY);
-    return data.activeDailyCodingChallengeQuestion;
+    const validated = DailyChallengeSchema.parse(data.activeDailyCodingChallengeQuestion);
+    return validated;
   }
   async getRandomProblem(filters = {}) {
     const variables = {
@@ -255,27 +393,36 @@ var LeetCodeClient = class {
       variables.filters.tags = filters.tags;
     }
     const data = await this.graphql(RANDOM_PROBLEM_QUERY, variables);
-    return data.randomQuestion.titleSlug;
+    const validated = z2.object({ titleSlug: z2.string() }).parse(data.randomQuestion);
+    return validated.titleSlug;
   }
   async getUserProfile(username) {
     const data = await this.graphql(USER_PROFILE_QUERY, { username });
     const user = data.matchedUser;
+    const validated = UserProfileSchema.parse(user);
     return {
-      username: user.username,
-      realName: user.profile.realName,
-      ranking: user.profile.ranking,
-      acSubmissionNum: user.submitStatsGlobal.acSubmissionNum,
-      streak: user.userCalendar.streak,
-      totalActiveDays: user.userCalendar.totalActiveDays
+      username: validated.username,
+      realName: validated.profile.realName,
+      ranking: validated.profile.ranking,
+      acSubmissionNum: validated.submitStatsGlobal.acSubmissionNum,
+      streak: validated.userCalendar.streak,
+      totalActiveDays: validated.userCalendar.totalActiveDays,
+      submissionCalendar: user.userCalendar.submissionCalendar
     };
   }
+  async getSkillStats(username) {
+    const data = await this.graphql(SKILL_STATS_QUERY, { username });
+    return data.matchedUser.tagProblemCounts;
+  }
   async getSubmissionList(slug, limit = 20, offset = 0) {
     const data = await this.graphql(SUBMISSION_LIST_QUERY, { questionSlug: slug, limit, offset });
-    return data.questionSubmissionList.submissions;
+    const validated = z2.array(SubmissionSchema).parse(data.questionSubmissionList.submissions);
+    return validated;
   }
   async getSubmissionDetails(submissionId) {
     const data = await this.graphql(SUBMISSION_DETAILS_QUERY, { submissionId });
-    return data.submissionDetails;
+    const validated = SubmissionDetailsSchema.parse(data.submissionDetails);
+    return validated;
   }
   async testSolution(titleSlug, code, lang, testcases, questionId) {
     const response = await this.client.post(`problems/${titleSlug}/interpret_solution/`, {
@@ -286,7 +433,7 @@ var LeetCodeClient = class {
         question_id: questionId
       }
     }).json();
-    return this.pollSubmission(response.interpret_id, "interpret");
+    return this.pollSubmission(response.interpret_id, "interpret", TestResultSchema);
   }
   async submitSolution(titleSlug, code, lang, questionId) {
     const response = await this.client.post(`problems/${titleSlug}/submit/`, {
@@ -296,16 +443,16 @@ var LeetCodeClient = class {
         question_id: questionId
       }
     }).json();
-    return this.pollSubmission(response.submission_id.toString(), "submission");
+    return this.pollSubmission(response.submission_id.toString(), "submission", SubmissionResultSchema);
   }
-  async pollSubmission(id, type) {
-    const endpoint = type === "interpret" ? `submissions/detail/${id}/check/` : `submissions/detail/${id}/check/`;
+  async pollSubmission(id, _type, schema2) {
+    const endpoint = `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;
+        return schema2.parse(result);
       }
       await new Promise((resolve) => setTimeout(resolve, delay));
     }
@@ -332,7 +479,8 @@ var schema = {
     properties: {
       language: { type: "string", default: "typescript" },
       editor: { type: "string" },
-      workDir: { type: "string", default: join(homedir(), "leetcode") }
+      workDir: { type: "string", default: join(homedir(), "leetcode") },
+      repo: { type: "string" }
     },
     default: {
       language: "typescript",
@@ -369,6 +517,12 @@ var config = {
   setWorkDir(workDir) {
     configStore.set("config.workDir", workDir);
   },
+  setRepo(repo) {
+    configStore.set("config.repo", repo);
+  },
+  deleteRepo() {
+    configStore.delete("config.repo");
+  },
   // Get specific config values
   getLanguage() {
     return configStore.get("config.language");
@@ -379,6 +533,9 @@ var config = {
   getWorkDir() {
     return configStore.get("config.workDir");
   },
+  getRepo() {
+    return configStore.get("config.repo");
+  },
   // Clear all config
   clear() {
     configStore.clear();
@@ -471,19 +628,41 @@ async function whoamiCommand() {
 
 // src/commands/list.ts
 import ora2 from "ora";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 
-// src/utils/display.ts
+// src/utils/auth.ts
 import chalk2 from "chalk";
+async function requireAuth() {
+  const credentials = config.getCredentials();
+  if (!credentials) {
+    console.log(chalk2.yellow("\u26A0\uFE0F  Please login first: leetcode login"));
+    return { authorized: false };
+  }
+  try {
+    leetcodeClient.setCredentials(credentials);
+    const { isSignedIn, username } = await leetcodeClient.checkAuth();
+    if (!isSignedIn) {
+      console.log(chalk2.yellow("\u26A0\uFE0F  Session expired. Please run: leetcode login"));
+      return { authorized: false };
+    }
+    return { authorized: true, username: username ?? void 0 };
+  } catch {
+    console.log(chalk2.yellow("\u26A0\uFE0F  Session validation failed. Please run: leetcode login"));
+    return { authorized: false };
+  }
+}
+
+// src/utils/display.ts
+import chalk3 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")
+      chalk3.cyan("ID"),
+      chalk3.cyan("Title"),
+      chalk3.cyan("Difficulty"),
+      chalk3.cyan("Rate"),
+      chalk3.cyan("Status")
     ],
     colWidths: [8, 45, 12, 10, 10],
     style: { head: [], border: [] }
@@ -502,27 +681,34 @@ function displayProblemList(problems, total) {
     ]);
   }
   console.log(table.toString());
-  console.log(chalk2.gray(`
+  console.log(chalk3.gray(`
 Showing ${problems.length} of ${total} problems`));
 }
 function displayProblemDetail(problem) {
   console.log();
   const titlePrefix = problem.isPaidOnly ? "\u{1F512} " : "";
-  console.log(chalk2.bold.cyan(`  ${problem.questionFrontendId}. ${titlePrefix}${problem.title}`));
+  console.log(chalk3.bold.cyan(`  ${problem.questionFrontendId}. ${titlePrefix}${problem.title}`));
   console.log(`  ${colorDifficulty(problem.difficulty)}`);
-  console.log(chalk2.gray(`  https://leetcode.com/problems/${problem.titleSlug}/`));
+  console.log(chalk3.gray(`  https://leetcode.com/problems/${problem.titleSlug}/`));
   console.log();
+  if (problem.isPaidOnly) {
+    console.log(chalk3.yellow("  \u26A0\uFE0F  Premium Problem"));
+    console.log(chalk3.gray("     This problem requires a LeetCode Premium subscription."));
+    console.log(chalk3.gray(`     Visit the URL above to view on LeetCode.`));
+    console.log();
+  }
   if (problem.topicTags.length) {
-    const tags = problem.topicTags.map((t) => chalk2.bgBlue.white(` ${t.name} `)).join(" ");
+    const tags = problem.topicTags.map((t) => chalk3.bgBlue.white(` ${t.name} `)).join(" ");
     console.log(`  ${tags}`);
     console.log();
   }
-  console.log(chalk2.gray("\u2500".repeat(60)));
+  console.log(chalk3.gray("\u2500".repeat(60)));
   console.log();
   let content = problem.content;
   if (!content) {
-    console.log(chalk2.yellow("\u{1F512} Premium Problem"));
-    console.log(chalk2.gray("Content is not available directly. Please visit the URL below."));
+    console.log(chalk3.yellow("  \u{1F512} Premium Content"));
+    console.log(chalk3.gray("  Problem description is not available directly."));
+    console.log(chalk3.gray("  Please visit the URL above to view on LeetCode."));
     console.log();
     return;
   }
@@ -542,100 +728,100 @@ function displayProblemDetail(problem) {
   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:"));
+  content = content.replace(/§EXAMPLE§(\d+)§/g, (_, num) => chalk3.green.bold(`\u{1F4CC} Example ${num}:`));
+  content = content.replace(/§INPUT§/g, chalk3.yellow("Input:"));
+  content = content.replace(/§OUTPUT§/g, chalk3.yellow("Output:"));
+  content = content.replace(/§EXPLAIN§/g, chalk3.gray("Explanation:"));
+  content = content.replace(/§CONSTRAINTS§/g, chalk3.cyan.bold("\n\u{1F4CB} Constraints:"));
+  content = content.replace(/§FOLLOWUP§/g, chalk3.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));
+    console.log(chalk3.red.bold("\u274C Compile Error"));
+    console.log(chalk3.red(result.compile_error));
     return;
   }
   if (result.runtime_error) {
-    console.log(chalk2.red.bold("\u274C Runtime Error"));
-    console.log(chalk2.red(result.runtime_error));
+    console.log(chalk3.red.bold("\u274C Runtime Error"));
+    console.log(chalk3.red(result.runtime_error));
     return;
   }
   if (result.correct_answer) {
-    console.log(chalk2.green.bold("\u2713 All test cases passed!"));
+    console.log(chalk3.green.bold("\u2713 All test cases passed!"));
   } else {
-    console.log(chalk2.yellow.bold("\u2717 Some test cases failed"));
+    console.log(chalk3.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(chalk3.gray("Your Output:"));
+  for (const output of result.code_answer ?? []) {
+    console.log(chalk3.white(`  ${output}`));
   }
   console.log();
-  console.log(chalk2.gray("Expected Output:"));
-  for (const output of result.expected_code_answer) {
-    console.log(chalk2.white(`  ${output}`));
+  console.log(chalk3.gray("Expected Output:"));
+  for (const output of result.expected_code_answer ?? []) {
+    console.log(chalk3.white(`  ${output}`));
   }
   if (result.std_output_list?.length) {
     console.log();
-    console.log(chalk2.gray("Stdout:"));
+    console.log(chalk3.gray("Stdout:"));
     for (const output of result.std_output_list) {
-      if (output) console.log(chalk2.gray(`  ${output}`));
+      if (output) console.log(chalk3.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));
+    console.log(chalk3.red.bold("\u274C Compile Error"));
+    console.log(chalk3.red(result.compile_error));
     return;
   }
   if (result.runtime_error) {
-    console.log(chalk2.red.bold("\u274C Runtime Error"));
-    console.log(chalk2.red(result.runtime_error));
+    console.log(chalk3.red.bold("\u274C Runtime Error"));
+    console.log(chalk3.red(result.runtime_error));
     if (result.last_testcase) {
-      console.log(chalk2.gray("Last testcase:"), result.last_testcase);
+      console.log(chalk3.gray("Last testcase:"), result.last_testcase);
     }
     return;
   }
   if (result.status_msg === "Accepted") {
-    console.log(chalk2.green.bold("\u2713 Accepted!"));
+    console.log(chalk3.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"}%)`)
+      chalk3.gray("Runtime:"),
+      chalk3.white(result.status_runtime),
+      chalk3.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"}%)`)
+      chalk3.gray("Memory:"),
+      chalk3.white(result.status_memory),
+      chalk3.gray(`(beats ${result.memory_percentile?.toFixed(1) ?? "N/A"}%)`)
     );
   } else {
-    console.log(chalk2.red.bold(`\u274C ${result.status_msg}`));
+    console.log(chalk3.red.bold(`\u274C ${result.status_msg}`));
     console.log();
-    console.log(chalk2.gray(`Passed ${result.total_correct}/${result.total_testcases} testcases`));
+    console.log(chalk3.gray(`Passed ${result.total_correct}/${result.total_testcases} testcases`));
     if (result.code_output) {
-      console.log(chalk2.gray("Your Output:"), result.code_output);
+      console.log(chalk3.gray("Your Output:"), result.code_output);
     }
     if (result.expected_output) {
-      console.log(chalk2.gray("Expected:"), result.expected_output);
+      console.log(chalk3.gray("Expected:"), result.expected_output);
     }
     if (result.last_testcase) {
-      console.log(chalk2.gray("Failed testcase:"), result.last_testcase);
+      console.log(chalk3.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(chalk3.bold.white(`\u{1F464} ${username}`) + (realName ? chalk3.gray(` (${realName})`) : ""));
+  console.log(chalk3.gray(`Ranking: #${ranking.toLocaleString()}`));
   console.log();
   const table = new Table({
-    head: [chalk2.cyan("Difficulty"), chalk2.cyan("Solved")],
+    head: [chalk3.cyan("Difficulty"), chalk3.cyan("Solved")],
     style: { head: [], border: [] }
   });
   for (const stat of acStats) {
@@ -647,33 +833,33 @@ function displayUserStats(username, realName, ranking, acStats, streak, totalAct
     }
   }
   const total = acStats.find((s) => s.difficulty === "All")?.count ?? 0;
-  table.push([chalk2.white.bold("Total"), chalk2.white.bold(total.toString())]);
+  table.push([chalk3.white.bold("Total"), chalk3.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()));
+  console.log(chalk3.gray("\u{1F525} Current streak:"), chalk3.hex("#FFA500")(streak.toString()), chalk3.gray("days"));
+  console.log(chalk3.gray("\u{1F4C5} Total active days:"), chalk3.white(totalActiveDays.toString()));
 }
 function displayDailyChallenge(date, problem) {
   console.log();
-  console.log(chalk2.bold.yellow("\u{1F3AF} Daily Challenge"), chalk2.gray(`(${date})`));
+  console.log(chalk3.bold.yellow("\u{1F3AF} Daily Challenge"), chalk3.gray(`(${date})`));
   console.log();
-  console.log(chalk2.white(`${problem.questionFrontendId}. ${problem.title}`));
+  console.log(chalk3.white(`${problem.questionFrontendId}. ${problem.title}`));
   console.log(colorDifficulty(problem.difficulty));
-  console.log(chalk2.gray(`https://leetcode.com/problems/${problem.titleSlug}/`));
+  console.log(chalk3.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);
+    const tags = problem.topicTags.map((t) => chalk3.blue(t.name)).join(" ");
+    console.log(chalk3.gray("Tags:"), tags);
   }
 }
 function colorDifficulty(difficulty) {
   switch (difficulty.toLowerCase()) {
     case "easy":
-      return chalk2.green(difficulty);
+      return chalk3.green(difficulty);
     case "medium":
-      return chalk2.yellow(difficulty);
+      return chalk3.yellow(difficulty);
     case "hard":
-      return chalk2.red(difficulty);
+      return chalk3.red(difficulty);
     default:
       return difficulty;
   }
@@ -681,22 +867,22 @@ function colorDifficulty(difficulty) {
 function formatStatus(status) {
   switch (status) {
     case "ac":
-      return chalk2.green("\u2713");
+      return chalk3.green("\u2713");
     case "notac":
-      return chalk2.yellow("\u25CB");
+      return chalk3.yellow("\u25CB");
     default:
-      return chalk2.gray("-");
+      return chalk3.gray("-");
   }
 }
 function displaySubmissionsList(submissions) {
   const table = new Table({
     head: [
-      chalk2.cyan("ID"),
-      chalk2.cyan("Status"),
-      chalk2.cyan("Lang"),
-      chalk2.cyan("Runtime"),
-      chalk2.cyan("Memory"),
-      chalk2.cyan("Date")
+      chalk3.cyan("ID"),
+      chalk3.cyan("Status"),
+      chalk3.cyan("Lang"),
+      chalk3.cyan("Runtime"),
+      chalk3.cyan("Memory"),
+      chalk3.cyan("Date")
     ],
     colWidths: [12, 18, 15, 12, 12, 25],
     style: { head: [], border: [] }
@@ -706,7 +892,7 @@ function displaySubmissionsList(submissions) {
     const cleanTime = new Date(parseInt(s.timestamp) * 1e3).toLocaleString();
     table.push([
       s.id,
-      isAC ? chalk2.green(s.statusDisplay) : chalk2.red(s.statusDisplay),
+      isAC ? chalk3.green(s.statusDisplay) : chalk3.red(s.statusDisplay),
       s.lang,
       s.runtime,
       s.memory,
@@ -718,10 +904,8 @@ function displaySubmissionsList(submissions) {
 
 // src/commands/list.ts
 async function listCommand(options) {
-  const credentials = config.getCredentials();
-  if (credentials) {
-    leetcodeClient.setCredentials(credentials);
-  }
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
   const spinner = ora2("Fetching problems...").start();
   try {
     const filters = {};
@@ -759,30 +943,28 @@ async function listCommand(options) {
     const { total, problems } = await leetcodeClient.getProblems(filters);
     spinner.stop();
     if (problems.length === 0) {
-      console.log(chalk3.yellow("No problems found matching your criteria."));
+      console.log(chalk4.yellow("No problems found matching your criteria."));
       return;
     }
     displayProblemList(problems, total);
     if (page * limit < total) {
-      console.log(chalk3.gray(`
+      console.log(chalk4.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));
+      console.log(chalk4.red(error.message));
     }
   }
 }
 
 // src/commands/show.ts
 import ora3 from "ora";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 async function showCommand(idOrSlug) {
-  const credentials = config.getCredentials();
-  if (credentials) {
-    leetcodeClient.setCredentials(credentials);
-  }
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
   const spinner = ora3("Fetching problem...").start();
   try {
     let problem;
@@ -800,7 +982,7 @@ async function showCommand(idOrSlug) {
   } catch (error) {
     spinner.fail("Failed to fetch problem");
     if (error instanceof Error) {
-      console.log(chalk4.red(error.message));
+      console.log(chalk5.red(error.message));
     }
   }
 }
@@ -809,9 +991,8 @@ async function showCommand(idOrSlug) {
 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";
+import chalk7 from "chalk";
 
 // src/utils/templates.ts
 var LANGUAGE_EXTENSIONS = {
@@ -932,13 +1113,39 @@ function getSolutionFileName(problemId, titleSlug, language) {
   return `${problemId}.${titleSlug}.${ext}`;
 }
 
+// src/utils/editor.ts
+import { spawn } from "child_process";
+import open from "open";
+import chalk6 from "chalk";
+var TERMINAL_EDITORS = ["vim", "nvim", "vi", "nano", "emacs", "micro", "helix"];
+var VSCODE_EDITORS = ["code", "code-insiders", "cursor", "codium", "vscodium"];
+async function openInEditor(filePath, workDir) {
+  const editor = config.getEditor() ?? process.env.EDITOR ?? "code";
+  const workspace = workDir ?? config.getWorkDir();
+  if (TERMINAL_EDITORS.includes(editor)) {
+    console.log();
+    console.log(chalk6.gray(`Open with: ${editor} ${filePath}`));
+    return;
+  }
+  try {
+    if (VSCODE_EDITORS.includes(editor)) {
+      const child = spawn(editor, ["-r", workspace, "-g", filePath], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      return;
+    }
+    await open(filePath, { app: { name: editor } });
+  } catch {
+  }
+}
+
 // src/commands/pick.ts
 async function pickCommand(idOrSlug, options) {
-  const credentials = config.getCredentials();
-  if (credentials) {
-    leetcodeClient.setCredentials(credentials);
-  }
-  const spinner = ora4("Fetching problem...").start();
+  const { authorized } = await requireAuth();
+  if (!authorized) return false;
+  const spinner = ora4({ text: "Fetching problem details...", spinner: "dots" }).start();
   try {
     let problem;
     if (/^\d+$/.test(idOrSlug)) {
@@ -948,22 +1155,26 @@ async function pickCommand(idOrSlug, options) {
     }
     if (!problem) {
       spinner.fail(`Problem "${idOrSlug}" not found`);
-      return;
+      return false;
     }
     spinner.text = "Generating solution file...";
     const langInput = options.lang?.toLowerCase() ?? config.getLanguage();
     const language = LANG_SLUG_MAP[langInput] ?? langInput;
     const snippets = problem.codeSnippets ?? [];
     const template = getCodeTemplate(snippets, language);
-    if (!template && snippets.length === 0) {
-      spinner.warn(chalk5.yellow("Premium Problem (No code snippets available)"));
-      console.log(chalk5.gray("Generating plain file with problem info..."));
+    let code;
+    if (snippets.length === 0) {
+      spinner.warn(chalk7.yellow("Premium Problem (No code snippets available)"));
+      console.log(chalk7.gray("Generating placeholder file with problem info..."));
+      code = `// \u{1F512} Premium Problem - ${problem.title}
+// Solution stub not available - visit LeetCode to view`;
     } else if (!template) {
       spinner.fail(`No code template available for ${language}`);
-      return;
+      console.log(chalk7.gray(`Available languages: ${snippets.map((s) => s.langSlug).join(", ")}`));
+      return false;
+    } else {
+      code = template.code;
     }
-    const code = template?.code ?? `// \u{1F512} Premium Problem - ${problem.title}
-// Solution stub not available`;
     const content = generateSolutionFile(
       problem.questionFrontendId,
       problem.titleSlug,
@@ -971,7 +1182,7 @@ async function pickCommand(idOrSlug, options) {
       problem.difficulty,
       code,
       language,
-      problem.content
+      problem.content ?? void 0
     );
     const workDir = config.getWorkDir();
     const difficulty = problem.difficulty;
@@ -984,68 +1195,92 @@ async function pickCommand(idOrSlug, options) {
     const filePath = join2(targetDir, fileName);
     if (existsSync(filePath)) {
       spinner.warn(`File already exists: ${fileName}`);
-      console.log(chalk5.gray(`Path: ${filePath}`));
+      console.log(chalk7.gray(`Path: ${filePath}`));
       if (options.open !== false) {
-        openInEditor(filePath);
+        await openInEditor(filePath);
       }
-      return;
+      return true;
     }
     await writeFile(filePath, content, "utf-8");
-    spinner.succeed(`Created ${chalk5.green(fileName)}`);
-    console.log(chalk5.gray(`Path: ${filePath}`));
+    spinner.succeed(`Created ${chalk7.green(fileName)}`);
+    console.log(chalk7.gray(`Path: ${filePath}`));
     console.log();
-    console.log(chalk5.cyan(`${problem.questionFrontendId}. ${problem.title}`));
-    console.log(chalk5.gray(`Difficulty: ${problem.difficulty} | Category: ${category}`));
+    console.log(chalk7.cyan(`${problem.questionFrontendId}. ${problem.title}`));
+    console.log(chalk7.gray(`Difficulty: ${problem.difficulty} | Category: ${category}`));
     if (options.open !== false) {
-      openInEditor(filePath);
+      await openInEditor(filePath);
     }
+    return true;
   } catch (error) {
-    spinner.fail("Failed to create solution file");
+    spinner.fail("Failed to fetch problem");
     if (error instanceof Error) {
-      console.log(chalk5.red(error.message));
+      if (error.message.includes("expected object, received null")) {
+        console.log(chalk7.red(`Problem "${idOrSlug}" not found`));
+      } else {
+        try {
+          const zodError = JSON.parse(error.message);
+          if (Array.isArray(zodError)) {
+            console.log(chalk7.red("API Response Validation Failed"));
+          } else {
+            console.log(chalk7.red(error.message));
+          }
+        } catch {
+          console.log(chalk7.red(error.message));
+        }
+      }
     }
+    return false;
   }
 }
-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}`));
+async function batchPickCommand(ids, options) {
+  if (ids.length === 0) {
+    console.log(chalk7.yellow("Please provide at least one problem ID"));
     return;
   }
-  try {
-    if (editor === "code" || editor === "code-insiders" || editor === "cursor") {
-      const child = spawn(editor, ["-r", workDir, "-g", filePath], {
-        detached: true,
-        stdio: "ignore"
-      });
-      child.unref();
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
+  console.log(chalk7.cyan(`\u{1F4E6} Picking ${ids.length} problem${ids.length !== 1 ? "s" : ""}...`));
+  console.log();
+  console.log();
+  let succeeded = 0;
+  let failed = 0;
+  for (const id of ids) {
+    const success = await pickCommand(id, { ...options, open: false });
+    if (success) {
+      succeeded++;
     } else {
-      const child = spawn(editor, [filePath], {
-        detached: true,
-        stdio: "ignore"
-      });
-      child.unref();
+      failed++;
     }
-  } catch {
+    console.log();
   }
+  console.log(chalk7.gray("\u2500".repeat(50)));
+  console.log(
+    chalk7.bold(
+      `Done! ${chalk7.green(`${succeeded} succeeded`)}${failed > 0 ? `, ${chalk7.red(`${failed} failed`)}` : ""}`
+    )
+  );
 }
 
 // src/commands/test.ts
-import { readFile, readdir } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { basename, join as join3 } from "path";
+import { readFile } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { basename } from "path";
 import ora5 from "ora";
-import chalk6 from "chalk";
-async function findSolutionFile(dir, problemId) {
+import chalk8 from "chalk";
+
+// src/utils/fileUtils.ts
+import { readdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+var MAX_SEARCH_DEPTH = 5;
+async function findSolutionFile(dir, problemId, currentDepth = 0) {
   if (!existsSync2(dir)) return null;
+  if (currentDepth >= MAX_SEARCH_DEPTH) 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);
+      const found = await findSolutionFile(fullPath, problemId, currentDepth + 1);
       if (found) return found;
     } else if (entry.name.startsWith(`${problemId}.`)) {
       return fullPath;
@@ -1053,13 +1288,14 @@ async function findSolutionFile(dir, problemId) {
   }
   return null;
 }
-async function findFileByName(dir, fileName) {
+async function findFileByName(dir, fileName, currentDepth = 0) {
   if (!existsSync2(dir)) return null;
+  if (currentDepth >= MAX_SEARCH_DEPTH) 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);
+      const found = await findFileByName(fullPath, fileName, currentDepth + 1);
       if (found) return found;
     } else if (entry.name === fileName) {
       return fullPath;
@@ -1067,66 +1303,75 @@ async function findFileByName(dir, fileName) {
   }
   return null;
 }
+function getLangSlugFromExtension(ext) {
+  const langMap = {
+    ts: "typescript",
+    js: "javascript",
+    py: "python3",
+    java: "java",
+    cpp: "cpp",
+    c: "c",
+    cs: "csharp",
+    go: "golang",
+    rs: "rust",
+    kt: "kotlin",
+    swift: "swift"
+  };
+  return langMap[ext.toLowerCase()] ?? null;
+}
+
+// src/utils/validation.ts
+function isProblemId(input) {
+  return /^\d+$/.test(input);
+}
+function isFileName(input) {
+  return !input.includes("/") && !input.includes("\\") && input.includes(".");
+}
+
+// src/commands/test.ts
 async function testCommand(fileOrId, options) {
-  const credentials = config.getCredentials();
-  if (!credentials) {
-    console.log(chalk6.yellow("Please login first: leetcode login"));
-    return;
-  }
-  leetcodeClient.setCredentials(credentials);
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
   let filePath = fileOrId;
-  if (/^\d+$/.test(fileOrId)) {
+  if (isProblemId(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.'));
+      console.log(chalk8.red(`No solution file found for problem ${fileOrId}`));
+      console.log(chalk8.gray(`Looking in: ${workDir}`));
+      console.log(chalk8.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(".")) {
+    console.log(chalk8.gray(`Found: ${filePath}`));
+  } else if (isFileName(fileOrId)) {
     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}`));
+      console.log(chalk8.red(`File not found: ${fileOrId}`));
+      console.log(chalk8.gray(`Looking in: ${workDir}`));
       return;
     }
     filePath = found;
-    console.log(chalk6.gray(`Found: ${filePath}`));
+    console.log(chalk8.gray(`Found: ${filePath}`));
   }
-  if (!existsSync2(filePath)) {
-    console.log(chalk6.red(`File not found: ${filePath}`));
+  if (!existsSync3(filePath)) {
+    console.log(chalk8.red(`File not found: ${filePath}`));
     return;
   }
-  const spinner = ora5("Reading solution file...").start();
+  const spinner = ora5({ text: "Reading solution file...", spinner: "dots" }).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"));
+      console.log(chalk8.gray("Expected format: {id}.{title-slug}.{ext}"));
+      console.log(chalk8.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];
+    const lang = getLangSlugFromExtension(ext);
     if (!lang) {
       spinner.fail(`Unsupported file extension: .${ext}`);
       return;
@@ -1142,105 +1387,60 @@ async function testCommand(fileOrId, options) {
   } catch (error) {
     spinner.fail("Test failed");
     if (error instanceof Error) {
-      console.log(chalk6.red(error.message));
+      console.log(chalk8.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 { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { basename as basename2 } 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;
-}
+import chalk9 from "chalk";
 async function submitCommand(fileOrId) {
-  const credentials = config.getCredentials();
-  if (!credentials) {
-    console.log(chalk7.yellow("Please login first: leetcode login"));
-    return;
-  }
-  leetcodeClient.setCredentials(credentials);
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
   let filePath = fileOrId;
-  if (/^\d+$/.test(fileOrId)) {
+  if (isProblemId(fileOrId)) {
     const workDir = config.getWorkDir();
-    const found = await findSolutionFile2(workDir, fileOrId);
+    const found = await findSolutionFile(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.'));
+      console.log(chalk9.red(`No solution file found for problem ${fileOrId}`));
+      console.log(chalk9.gray(`Looking in: ${workDir}`));
+      console.log(chalk9.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(".")) {
+    console.log(chalk9.gray(`Found: ${filePath}`));
+  } else if (isFileName(fileOrId)) {
     const workDir = config.getWorkDir();
-    const found = await findFileByName2(workDir, fileOrId);
+    const found = await findFileByName(workDir, fileOrId);
     if (!found) {
-      console.log(chalk7.red(`File not found: ${fileOrId}`));
-      console.log(chalk7.gray(`Looking in: ${workDir}`));
+      console.log(chalk9.red(`File not found: ${fileOrId}`));
+      console.log(chalk9.gray(`Looking in: ${workDir}`));
       return;
     }
     filePath = found;
-    console.log(chalk7.gray(`Found: ${filePath}`));
+    console.log(chalk9.gray(`Found: ${filePath}`));
   }
-  if (!existsSync3(filePath)) {
-    console.log(chalk7.red(`File not found: ${filePath}`));
+  if (!existsSync4(filePath)) {
+    console.log(chalk9.red(`File not found: ${filePath}`));
     return;
   }
-  const spinner = ora6("Reading solution file...").start();
+  const spinner = ora6({ text: "Reading solution file...", spinner: "dots" }).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"));
+      console.log(chalk9.gray("Expected format: {id}.{title-slug}.{ext}"));
+      console.log(chalk9.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];
+    const lang = getLangSlugFromExtension(ext);
     if (!lang) {
       spinner.fail(`Unsupported file extension: .${ext}`);
       return;
@@ -1260,89 +1460,206 @@ async function submitCommand(fileOrId) {
   } catch (error) {
     spinner.fail("Submission failed");
     if (error instanceof Error) {
-      console.log(chalk7.red(error.message));
+      console.log(chalk9.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;
+import chalk11 from "chalk";
+
+// src/utils/stats-display.ts
+import chalk10 from "chalk";
+var MONTH_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function renderHeatmap(calendarJson) {
+  const data = JSON.parse(calendarJson);
+  const now = /* @__PURE__ */ new Date();
+  const weeks = [];
+  for (let w = 11; w >= 0; w--) {
+    const weekStart = new Date(now);
+    weekStart.setDate(weekStart.getDate() - w * 7 - weekStart.getDay());
+    let weekCount = 0;
+    let activeDays = 0;
+    for (let d = 0; d < 7; d++) {
+      const day = new Date(weekStart);
+      day.setDate(day.getDate() + d);
+      if (day > now) break;
+      const midnight = new Date(Date.UTC(day.getFullYear(), day.getMonth(), day.getDate()));
+      const timestamp = Math.floor(midnight.getTime() / 1e3).toString();
+      const count = data[timestamp] || 0;
+      weekCount += count;
+      if (count > 0) activeDays++;
+    }
+    const weekEnd = new Date(weekStart);
+    weekEnd.setDate(weekEnd.getDate() + 6);
+    weeks.push({
+      start: `${MONTH_NAMES[weekStart.getMonth()]} ${weekStart.getDate()}`,
+      end: `${MONTH_NAMES[weekEnd.getMonth()]} ${weekEnd.getDate()}`,
+      count: weekCount,
+      days: activeDays
+    });
   }
-  if (credentials) {
-    leetcodeClient.setCredentials(credentials);
+  const totalSubmissions = weeks.reduce((sum, w) => sum + w.count, 0);
+  const totalActiveDays = weeks.reduce((sum, w) => sum + w.days, 0);
+  console.log();
+  console.log(chalk10.bold("\u{1F4C5} Activity (Last 12 Weeks)"));
+  console.log(chalk10.gray("How many problems you submitted and days you practiced."));
+  console.log(chalk10.gray("\u2500".repeat(50)));
+  console.log();
+  for (const week of weeks) {
+    const weekLabel = `${week.start} - ${week.end}`.padEnd(18);
+    const bar = week.count > 0 ? chalk10.green("\u2588".repeat(Math.min(week.count, 10))).padEnd(10) : chalk10.gray("\xB7").padEnd(10);
+    const countStr = week.count > 0 ? `${week.count} subs`.padEnd(10) : "".padEnd(10);
+    const daysStr = week.days > 0 ? `${week.days}d active` : "";
+    console.log(`  ${chalk10.white(weekLabel)} ${bar} ${chalk10.cyan(countStr)} ${chalk10.yellow(daysStr)}`);
+  }
+  console.log(chalk10.gray("\u2500".repeat(50)));
+  console.log(`  ${chalk10.bold.white("Total:")} ${chalk10.cyan.bold(totalSubmissions + " submissions")}, ${chalk10.yellow.bold(totalActiveDays + " days active")}`);
+  console.log();
+}
+function renderSkillStats(fundamental, intermediate, advanced) {
+  console.log();
+  console.log(chalk10.bold("\u{1F3AF} Skill Breakdown"));
+  console.log(chalk10.gray("\u2500".repeat(45)));
+  const renderSection = (title, stats, color) => {
+    if (stats.length === 0) return;
+    console.log();
+    console.log(color.bold(`  ${title}`));
+    const sorted = [...stats].sort((a, b) => b.problemsSolved - a.problemsSolved);
+    for (const stat of sorted.slice(0, 8)) {
+      const name = stat.tagName.padEnd(22);
+      const bar = color("\u2588".repeat(Math.min(stat.problemsSolved, 15)));
+      console.log(`    ${chalk10.white(name)} ${bar} ${chalk10.white(stat.problemsSolved)}`);
+    }
+  };
+  renderSection("Fundamental", fundamental, chalk10.green);
+  renderSection("Intermediate", intermediate, chalk10.yellow);
+  renderSection("Advanced", advanced, chalk10.red);
+  console.log();
+}
+function renderTrendChart(calendarJson) {
+  const data = JSON.parse(calendarJson);
+  const now = /* @__PURE__ */ new Date();
+  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const days = [];
+  for (let d = 6; d >= 0; d--) {
+    const day = new Date(now);
+    day.setDate(day.getDate() - d);
+    const midnight = new Date(Date.UTC(day.getFullYear(), day.getMonth(), day.getDate()));
+    const timestamp = Math.floor(midnight.getTime() / 1e3).toString();
+    days.push({
+      label: dayNames[day.getDay()],
+      count: data[timestamp] || 0
+    });
   }
-  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;
+  const maxVal = Math.max(...days.map((d) => d.count), 1);
+  const chartHeight = 6;
+  console.log();
+  console.log(chalk10.bold("\u{1F4C8} Submission Trend (Last 7 Days)"));
+  console.log(chalk10.gray("\u2500".repeat(35)));
+  console.log();
+  for (let row = chartHeight; row >= 1; row--) {
+    let line = `  ${row === chartHeight ? maxVal.toString().padStart(2) : "  "} \u2502`;
+    for (const day of days) {
+      const barHeight = Math.round(day.count / maxVal * chartHeight);
+      if (barHeight >= row) {
+        line += chalk10.green(" \u2588\u2588 ");
+      } else {
+        line += "    ";
       }
-      targetUsername = currentUser;
     }
+    console.log(line);
+  }
+  console.log(`   0 \u2514${"\u2500\u2500\u2500\u2500".repeat(7)}`);
+  console.log(`       ${days.map((d) => d.label.padEnd(4)).join("")}`);
+  console.log(chalk10.gray(`       ${days.map((d) => d.count.toString().padEnd(4)).join("")}`));
+  const total = days.reduce((a, b) => a + b.count, 0);
+  console.log();
+  console.log(chalk10.white(`  Total: ${total} submissions this week`));
+  console.log();
+}
+
+// src/commands/stat.ts
+async function statCommand(username, options = {}) {
+  const { authorized, username: currentUser } = await requireAuth();
+  if (!authorized) return;
+  const spinner = ora7("Fetching statistics...").start();
+  try {
+    const targetUsername = username || currentUser;
     if (!targetUsername) {
-      spinner.fail("No username available");
+      spinner.fail("No username found");
       return;
     }
     const profile = await leetcodeClient.getUserProfile(targetUsername);
     spinner.stop();
-    displayUserStats(
-      profile.username,
-      profile.realName,
-      profile.ranking,
-      profile.acSubmissionNum,
-      profile.streak,
-      profile.totalActiveDays
-    );
+    if (!options.calendar && !options.skills && !options.trend) {
+      displayUserStats(
+        profile.username,
+        profile.realName,
+        profile.ranking,
+        profile.acSubmissionNum,
+        profile.streak,
+        profile.totalActiveDays
+      );
+      return;
+    }
+    if (options.calendar) {
+      if (profile.submissionCalendar) {
+        renderHeatmap(profile.submissionCalendar);
+      } else {
+        console.log(chalk11.yellow("Calendar data not available."));
+      }
+    }
+    if (options.trend) {
+      if (profile.submissionCalendar) {
+        renderTrendChart(profile.submissionCalendar);
+      } else {
+        console.log(chalk11.yellow("Calendar data not available."));
+      }
+    }
+    if (options.skills) {
+      spinner.start("Fetching skill stats...");
+      const skills = await leetcodeClient.getSkillStats(targetUsername);
+      spinner.stop();
+      renderSkillStats(skills.fundamental, skills.intermediate, skills.advanced);
+    }
   } catch (error) {
     spinner.fail("Failed to fetch statistics");
     if (error instanceof Error) {
-      console.log(chalk8.red(error.message));
+      console.log(chalk11.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);
-  }
+import chalk12 from "chalk";
+async function dailyCommand() {
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
   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}`));
+    console.log(chalk12.gray("Run the following to start working on this problem:"));
+    console.log(chalk12.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));
+      console.log(chalk12.red(error.message));
     }
   }
 }
 
 // src/commands/random.ts
 import ora9 from "ora";
-import chalk10 from "chalk";
+import chalk13 from "chalk";
 async function randomCommand(options) {
-  const credentials = config.getCredentials();
-  if (credentials) {
-    leetcodeClient.setCredentials(credentials);
-  }
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
   const spinner = ora9("Fetching random problem...").start();
   try {
     const filters = {};
@@ -1373,30 +1690,26 @@ async function randomCommand(options) {
       await pickCommand(titleSlug, { open: options.open ?? true });
     } else {
       await showCommand(titleSlug);
-      console.log(chalk10.gray("Run following to start solving:"));
-      console.log(chalk10.cyan(`  leetcode pick ${titleSlug}`));
+      console.log(chalk13.gray("Run following to start solving:"));
+      console.log(chalk13.cyan(`  leetcode pick ${titleSlug}`));
     }
   } catch (error) {
     spinner.fail("Failed to fetch random problem");
     if (error instanceof Error) {
-      console.log(chalk10.red(error.message));
+      console.log(chalk13.red(error.message));
     }
   }
 }
 
 // src/commands/submissions.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
 import ora10 from "ora";
-import chalk11 from "chalk";
+import chalk14 from "chalk";
 async function submissionsCommand(idOrSlug, options) {
-  const credentials = config.getCredentials();
-  if (!credentials) {
-    console.log(chalk11.red("Please login first to view submissions."));
-    return;
-  }
-  leetcodeClient.setCredentials(credentials);
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
   const spinner = ora10("Fetching problem info...").start();
   try {
     let problem;
@@ -1415,16 +1728,16 @@ async function submissionsCommand(idOrSlug, options) {
     const submissions = await leetcodeClient.getSubmissionList(slug, limit);
     spinner.stop();
     if (submissions.length === 0) {
-      console.log(chalk11.yellow("No submissions found."));
+      console.log(chalk14.yellow("No submissions found."));
       return;
     }
     if (options.last) {
       const lastAC = submissions.find((s) => s.statusDisplay === "Accepted");
       if (lastAC) {
-        console.log(chalk11.bold("Last Accepted Submission:"));
+        console.log(chalk14.bold("Last Accepted Submission:"));
         displaySubmissionsList([lastAC]);
       } else {
-        console.log(chalk11.yellow("No accepted submissions found in recent history."));
+        console.log(chalk14.yellow("No accepted submissions found in recent history."));
       }
     } else {
       displaySubmissionsList(submissions);
@@ -1436,34 +1749,39 @@ async function submissionsCommand(idOrSlug, options) {
         downloadSpinner.fail("No accepted submission found to download.");
         return;
       }
-      const details = await leetcodeClient.getSubmissionDetails(parseInt(lastAC.id, 10));
+      const submissionId = parseInt(lastAC.id, 10);
+      if (isNaN(submissionId)) {
+        downloadSpinner.fail("Invalid submission ID format");
+        return;
+      }
+      const details = await leetcodeClient.getSubmissionDetails(submissionId);
       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 = join5(workDir, difficulty, category);
-      if (!existsSync4(targetDir)) {
+      const targetDir = join4(workDir, difficulty, category);
+      if (!existsSync5(targetDir)) {
         await mkdir2(targetDir, { recursive: true });
       }
       const langSlug = details.lang.name;
       const supportedLang = LANG_SLUG_MAP[langSlug] ?? "txt";
       const ext = LANGUAGE_EXTENSIONS[supportedLang] ?? langSlug;
       const fileName = `${problem.questionFrontendId}.${problem.titleSlug}.submission-${lastAC.id}.${ext}`;
-      const filePath = join5(targetDir, fileName);
+      const filePath = join4(targetDir, fileName);
       await writeFile2(filePath, details.code, "utf-8");
-      downloadSpinner.succeed(`Downloaded to ${chalk11.green(fileName)}`);
-      console.log(chalk11.gray(`Path: ${filePath}`));
+      downloadSpinner.succeed(`Downloaded to ${chalk14.green(fileName)}`);
+      console.log(chalk14.gray(`Path: ${filePath}`));
     }
   } catch (error) {
     spinner.fail("Failed to fetch submissions");
     if (error instanceof Error) {
-      console.log(chalk11.red(error.message));
+      console.log(chalk14.red(error.message));
     }
   }
 }
 
 // src/commands/config.ts
 import inquirer2 from "inquirer";
-import chalk12 from "chalk";
+import chalk15 from "chalk";
 var SUPPORTED_LANGUAGES = [
   "typescript",
   "javascript",
@@ -1483,22 +1801,32 @@ async function configCommand(options) {
     return;
   }
   if (options.lang) {
-    const lang = options.lang.toLowerCase();
-    if (!SUPPORTED_LANGUAGES.includes(lang)) {
-      console.log(chalk12.red(`Unsupported language: ${options.lang}`));
-      console.log(chalk12.gray(`Supported: ${SUPPORTED_LANGUAGES.join(", ")}`));
+    const langInput = options.lang.toLowerCase();
+    if (!SUPPORTED_LANGUAGES.includes(langInput)) {
+      console.log(chalk15.red(`Unsupported language: ${options.lang}`));
+      console.log(chalk15.gray(`Supported: ${SUPPORTED_LANGUAGES.join(", ")}`));
       return;
     }
+    const lang = langInput;
     config.setLanguage(lang);
-    console.log(chalk12.green(`\u2713 Default language set to ${lang}`));
+    console.log(chalk15.green(`\u2713 Default language set to ${lang}`));
   }
   if (options.editor) {
     config.setEditor(options.editor);
-    console.log(chalk12.green(`\u2713 Editor set to ${options.editor}`));
+    console.log(chalk15.green(`\u2713 Editor set to ${options.editor}`));
   }
   if (options.workdir) {
     config.setWorkDir(options.workdir);
-    console.log(chalk12.green(`\u2713 Work directory set to ${options.workdir}`));
+    console.log(chalk15.green(`\u2713 Work directory set to ${options.workdir}`));
+  }
+  if (options.repo !== void 0) {
+    if (options.repo.trim() === "") {
+      config.deleteRepo();
+      console.log(chalk15.green("\u2713 Repository URL cleared"));
+    } else {
+      config.setRepo(options.repo);
+      console.log(chalk15.green(`\u2713 Repository URL set to ${options.repo}`));
+    }
   }
 }
 async function configInteractiveCommand() {
@@ -1522,61 +1850,689 @@ async function configInteractiveCommand() {
       name: "workDir",
       message: "Working directory for solution files:",
       default: currentConfig.workDir
+    },
+    {
+      type: "input",
+      name: "repo",
+      message: "Git repository URL (optional):",
+      default: currentConfig.repo
     }
   ]);
   config.setLanguage(answers.language);
   config.setEditor(answers.editor);
   config.setWorkDir(answers.workDir);
+  if (answers.repo) {
+    config.setRepo(answers.repo);
+  } else {
+    config.deleteRepo();
+  }
   console.log();
-  console.log(chalk12.green("\u2713 Configuration saved"));
+  console.log(chalk15.green("\u2713 Configuration saved"));
   showCurrentConfig();
 }
 function showCurrentConfig() {
   const currentConfig = config.getConfig();
   const credentials = config.getCredentials();
   console.log();
-  console.log(chalk12.bold("LeetCode CLI Configuration"));
-  console.log(chalk12.gray("\u2500".repeat(40)));
+  console.log(chalk15.bold("LeetCode CLI Configuration"));
+  console.log(chalk15.gray("\u2500".repeat(40)));
+  console.log();
+  console.log(chalk15.gray("Config file:"), config.getPath());
+  console.log();
+  console.log(chalk15.gray("Language:    "), chalk15.white(currentConfig.language));
+  console.log(chalk15.gray("Editor:      "), chalk15.white(currentConfig.editor ?? "(not set)"));
+  console.log(chalk15.gray("Work Dir:    "), chalk15.white(currentConfig.workDir));
+  console.log(chalk15.gray("Repo URL:    "), chalk15.white(currentConfig.repo ?? "(not set)"));
+  console.log(chalk15.gray("Logged in:   "), credentials ? chalk15.green("Yes") : chalk15.yellow("No"));
+}
+
+// src/commands/bookmark.ts
+import chalk16 from "chalk";
+import Table2 from "cli-table3";
+import ora11 from "ora";
+
+// src/storage/bookmarks.ts
+import Conf2 from "conf";
+var bookmarksStore = new Conf2({
+  projectName: "leetcode-cli-bookmarks",
+  defaults: { bookmarks: [] }
+});
+var bookmarks = {
+  add(problemId) {
+    const current = bookmarksStore.get("bookmarks");
+    if (current.includes(problemId)) {
+      return false;
+    }
+    bookmarksStore.set("bookmarks", [...current, problemId]);
+    return true;
+  },
+  remove(problemId) {
+    const current = bookmarksStore.get("bookmarks");
+    if (!current.includes(problemId)) {
+      return false;
+    }
+    bookmarksStore.set("bookmarks", current.filter((id) => id !== problemId));
+    return true;
+  },
+  list() {
+    return bookmarksStore.get("bookmarks");
+  },
+  has(problemId) {
+    return bookmarksStore.get("bookmarks").includes(problemId);
+  },
+  count() {
+    return bookmarksStore.get("bookmarks").length;
+  },
+  clear() {
+    bookmarksStore.set("bookmarks", []);
+  }
+};
+
+// src/commands/bookmark.ts
+async function bookmarkCommand(action, id) {
+  const validActions = ["add", "remove", "list", "clear"];
+  if (!validActions.includes(action)) {
+    console.log(chalk16.red(`Invalid action: ${action}`));
+    console.log(chalk16.gray("Valid actions: add, remove, list, clear"));
+    return;
+  }
+  switch (action) {
+    case "add":
+      if (!id) {
+        console.log(chalk16.red("Please provide a problem ID to bookmark"));
+        return;
+      }
+      if (!isProblemId(id)) {
+        console.log(chalk16.red(`Invalid problem ID: ${id}`));
+        console.log(chalk16.gray("Problem ID must be a positive integer"));
+        return;
+      }
+      if (bookmarks.add(id)) {
+        console.log(chalk16.green(`\u2713 Bookmarked problem ${id}`));
+      } else {
+        console.log(chalk16.yellow(`Problem ${id} is already bookmarked`));
+      }
+      break;
+    case "remove":
+      if (!id) {
+        console.log(chalk16.red("Please provide a problem ID to remove"));
+        return;
+      }
+      if (bookmarks.remove(id)) {
+        console.log(chalk16.green(`\u2713 Removed bookmark for problem ${id}`));
+      } else {
+        console.log(chalk16.yellow(`Problem ${id} is not bookmarked`));
+      }
+      break;
+    case "list":
+      await listBookmarks();
+      break;
+    case "clear":
+      const count = bookmarks.count();
+      if (count === 0) {
+        console.log(chalk16.yellow("No bookmarks to clear"));
+      } else {
+        bookmarks.clear();
+        console.log(chalk16.green(`\u2713 Cleared ${count} bookmark${count !== 1 ? "s" : ""}`));
+      }
+      break;
+  }
+}
+async function listBookmarks() {
+  const bookmarkList = bookmarks.list();
+  if (bookmarkList.length === 0) {
+    console.log(chalk16.yellow("\u{1F4CC} No bookmarked problems"));
+    console.log(chalk16.gray('Use "leetcode bookmark add <id>" to bookmark a problem'));
+    return;
+  }
   console.log();
-  console.log(chalk12.gray("Config file:"), config.getPath());
+  console.log(chalk16.bold.cyan(`\u{1F4CC} Bookmarked Problems (${bookmarkList.length})`));
   console.log();
-  console.log(chalk12.gray("Language:    "), chalk12.white(currentConfig.language));
-  console.log(chalk12.gray("Editor:      "), chalk12.white(currentConfig.editor ?? "(not set)"));
-  console.log(chalk12.gray("Work Dir:    "), chalk12.white(currentConfig.workDir));
-  console.log(chalk12.gray("Logged in:   "), credentials ? chalk12.green("Yes") : chalk12.yellow("No"));
+  const { authorized } = await requireAuth();
+  if (authorized) {
+    const spinner = ora11({ text: "Fetching problem details...", spinner: "dots" }).start();
+    try {
+      const table = new Table2({
+        head: [
+          chalk16.cyan("ID"),
+          chalk16.cyan("Title"),
+          chalk16.cyan("Difficulty"),
+          chalk16.cyan("Status")
+        ],
+        colWidths: [8, 45, 12, 10],
+        style: { head: [], border: [] }
+      });
+      for (const id of bookmarkList) {
+        try {
+          const problem = await leetcodeClient.getProblemById(id);
+          if (problem) {
+            table.push([
+              problem.questionFrontendId,
+              problem.title.length > 42 ? problem.title.slice(0, 39) + "..." : problem.title,
+              colorDifficulty2(problem.difficulty),
+              problem.status === "ac" ? chalk16.green("\u2713") : chalk16.gray("-")
+            ]);
+          } else {
+            table.push([id, chalk16.gray("(not found)"), "-", "-"]);
+          }
+        } catch {
+          table.push([id, chalk16.gray("(error fetching)"), "-", "-"]);
+        }
+      }
+      spinner.stop();
+      console.log(table.toString());
+    } catch {
+      spinner.stop();
+      console.log(chalk16.gray("IDs: ") + bookmarkList.join(", "));
+    }
+  } else {
+    console.log(chalk16.gray("IDs: ") + bookmarkList.join(", "));
+    console.log();
+    console.log(chalk16.gray("Login to see problem details"));
+  }
+}
+function colorDifficulty2(difficulty) {
+  switch (difficulty.toLowerCase()) {
+    case "easy":
+      return chalk16.green(difficulty);
+    case "medium":
+      return chalk16.yellow(difficulty);
+    case "hard":
+      return chalk16.red(difficulty);
+    default:
+      return difficulty;
+  }
+}
+
+// src/commands/notes.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join5 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import chalk17 from "chalk";
+async function notesCommand(problemId, action) {
+  if (!isProblemId(problemId)) {
+    console.log(chalk17.red(`Invalid problem ID: ${problemId}`));
+    console.log(chalk17.gray("Problem ID must be a positive integer"));
+    return;
+  }
+  const noteAction = action === "view" ? "view" : "edit";
+  const notesDir = join5(config.getWorkDir(), ".notes");
+  const notePath = join5(notesDir, `${problemId}.md`);
+  if (!existsSync6(notesDir)) {
+    await mkdir3(notesDir, { recursive: true });
+  }
+  if (noteAction === "view") {
+    await viewNote(notePath, problemId);
+  } else {
+    await editNote(notePath, problemId);
+  }
+}
+async function viewNote(notePath, problemId) {
+  if (!existsSync6(notePath)) {
+    console.log(chalk17.yellow(`No notes found for problem ${problemId}`));
+    console.log(chalk17.gray(`Use "leetcode note ${problemId} edit" to create notes`));
+    return;
+  }
+  try {
+    const content = await readFile3(notePath, "utf-8");
+    console.log();
+    console.log(chalk17.bold.cyan(`\u{1F4DD} Notes for Problem ${problemId}`));
+    console.log(chalk17.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(content);
+  } catch (error) {
+    console.log(chalk17.red("Failed to read notes"));
+    if (error instanceof Error) {
+      console.log(chalk17.gray(error.message));
+    }
+  }
+}
+async function editNote(notePath, problemId) {
+  if (!existsSync6(notePath)) {
+    const template = await generateNoteTemplate(problemId);
+    await writeFile3(notePath, template, "utf-8");
+    console.log(chalk17.green(`\u2713 Created notes file for problem ${problemId}`));
+  }
+  console.log(chalk17.gray(`Opening: ${notePath}`));
+  await openInEditor(notePath);
+}
+async function generateNoteTemplate(problemId) {
+  let header = `# Problem ${problemId} Notes
+
+`;
+  const { authorized } = await requireAuth();
+  if (authorized) {
+    try {
+      const problem = await leetcodeClient.getProblemById(problemId);
+      if (problem) {
+        header = `# ${problemId}. ${problem.title}
+
+`;
+        header += `**Difficulty:** ${problem.difficulty}
+`;
+        header += `**URL:** https://leetcode.com/problems/${problem.titleSlug}/
+`;
+        if (problem.topicTags.length > 0) {
+          header += `**Topics:** ${problem.topicTags.map((t) => t.name).join(", ")}
+`;
+        }
+        header += "\n---\n\n";
+      }
+    } catch {
+    }
+  }
+  return `${header}## Approach
+
+<!-- Describe your approach to solving this problem -->
+
+
+## Key Insights
+
+<!-- What patterns or techniques did you use? -->
+
+
+## Complexity
+
+- **Time:** O(?)
+- **Space:** O(?)
+
+
+## Code Notes
+
+<!-- Any notes about the implementation -->
+
+
+## Mistakes / Learnings
+
+<!-- What did you learn from this problem? -->
+
+`;
+}
+
+// src/commands/today.ts
+import chalk18 from "chalk";
+import ora12 from "ora";
+async function todayCommand() {
+  const { authorized, username } = await requireAuth();
+  if (!authorized || !username) {
+    return;
+  }
+  const spinner = ora12({ text: "Fetching your progress...", spinner: "dots" }).start();
+  try {
+    const [profile, daily] = await Promise.all([
+      leetcodeClient.getUserProfile(username),
+      leetcodeClient.getDailyChallenge()
+    ]);
+    spinner.stop();
+    console.log();
+    console.log(chalk18.bold.cyan(`\u{1F4CA} Today's Summary`), chalk18.gray(`- ${username}`));
+    console.log(chalk18.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk18.yellow(`\u{1F525} Current Streak: ${profile.streak} day${profile.streak !== 1 ? "s" : ""}`));
+    console.log(chalk18.gray(`   Total Active Days: ${profile.totalActiveDays}`));
+    console.log();
+    const total = profile.acSubmissionNum.find((s) => s.difficulty === "All");
+    const easy = profile.acSubmissionNum.find((s) => s.difficulty === "Easy");
+    const medium = profile.acSubmissionNum.find((s) => s.difficulty === "Medium");
+    const hard = profile.acSubmissionNum.find((s) => s.difficulty === "Hard");
+    console.log(chalk18.white("\u{1F4C8} Problems Solved:"));
+    console.log(`   ${chalk18.green("Easy")}: ${easy?.count ?? 0}  |  ${chalk18.yellow("Medium")}: ${medium?.count ?? 0}  |  ${chalk18.red("Hard")}: ${hard?.count ?? 0}`);
+    console.log(`   ${chalk18.bold("Total")}: ${total?.count ?? 0}`);
+    console.log();
+    console.log(chalk18.bold.yellow("\u{1F3AF} Today's Challenge:"));
+    console.log(`   ${daily.question.questionFrontendId}. ${daily.question.title}`);
+    console.log(`   ${colorDifficulty3(daily.question.difficulty)}`);
+    const status = daily.question.status;
+    if (status === "ac") {
+      console.log(chalk18.green("   \u2713 Completed!"));
+    } else if (status === "notac") {
+      console.log(chalk18.yellow("   \u25CB Attempted"));
+    } else {
+      console.log(chalk18.gray("   - Not started"));
+    }
+    console.log();
+    console.log(chalk18.gray(`   leetcode pick ${daily.question.questionFrontendId} # Start working on it`));
+  } catch (error) {
+    spinner.fail("Failed to fetch progress");
+    if (error instanceof Error) {
+      console.log(chalk18.red(error.message));
+    }
+  }
+}
+function colorDifficulty3(difficulty) {
+  switch (difficulty.toLowerCase()) {
+    case "easy":
+      return chalk18.green(difficulty);
+    case "medium":
+      return chalk18.yellow(difficulty);
+    case "hard":
+      return chalk18.red(difficulty);
+    default:
+      return difficulty;
+  }
+}
+
+// src/commands/sync.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import chalk19 from "chalk";
+import inquirer3 from "inquirer";
+import ora13 from "ora";
+function isGitInstalled() {
+  try {
+    execSync("git --version", { stdio: "ignore" });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function isMapRepo(workDir) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd: workDir, stdio: "ignore" });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function isGhInstalled() {
+  try {
+    execSync("gh --version", { stdio: "ignore" });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function getRemoteUrl(workDir) {
+  try {
+    const url = execSync("git config --get remote.origin.url", { cwd: workDir, encoding: "utf-8" });
+    return url.trim();
+  } catch (error) {
+    return null;
+  }
+}
+async function setupGitRepo(workDir) {
+  const { init } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "init",
+      message: "Work directory is not a git repository. Initialize?",
+      default: true
+    }
+  ]);
+  if (!init) {
+    console.log(chalk19.yellow("Skipping basic git initialization."));
+    return false;
+  }
+  const spinner = ora13("Initializing git repository...").start();
+  try {
+    execSync("git init", { cwd: workDir });
+    spinner.succeed("Initialized git repository");
+    return true;
+  } catch (error) {
+    spinner.fail("Failed to initialize git repository");
+    throw error;
+  }
+}
+async function setupRemote(workDir) {
+  const spinner = ora13();
+  let repoUrl = config.getRepo();
+  if (!repoUrl) {
+    if (isGhInstalled()) {
+      const { createGh } = await inquirer3.prompt([
+        {
+          type: "confirm",
+          name: "createGh",
+          message: "Create a new private GitHub repository?",
+          default: true
+        }
+      ]);
+      if (createGh) {
+        spinner.start("Creating GitHub repository...");
+        try {
+          const repoName = workDir.split("/").pop() || "leetcode-solutions";
+          execSync(`gh repo create ${repoName} --private --source=. --remote=origin`, { cwd: workDir });
+          spinner.succeed("Created and linked GitHub repository");
+          repoUrl = getRemoteUrl(workDir) || "";
+          if (repoUrl) {
+            config.setRepo(repoUrl);
+          }
+          return repoUrl;
+        } catch (error) {
+          spinner.fail("Failed to create GitHub repository");
+          console.log(chalk19.red(error));
+        }
+      }
+    }
+    if (!repoUrl) {
+      console.log(chalk19.yellow("\nPlease create a new repository on your Git provider and copy the URL."));
+      const { url } = await inquirer3.prompt([
+        {
+          type: "input",
+          name: "url",
+          message: "Enter remote repository URL:",
+          validate: (input) => input.length > 0 ? true : "URL cannot be empty"
+        }
+      ]);
+      repoUrl = url;
+    }
+  }
+  if (repoUrl) {
+    config.setRepo(repoUrl);
+  }
+  const currentRemote = getRemoteUrl(workDir);
+  if (!currentRemote && repoUrl) {
+    try {
+      execSync(`git remote add origin ${repoUrl}`, { cwd: workDir });
+      console.log(chalk19.green("\u2713 Added remote origin"));
+    } catch (e) {
+      console.log(chalk19.red("Failed to add remote origin"));
+    }
+  }
+  return repoUrl || "";
+}
+async function syncCommand() {
+  const workDir = config.getWorkDir();
+  if (!existsSync7(workDir)) {
+    console.log(chalk19.red(`Work directory does not exist: ${workDir}`));
+    return;
+  }
+  if (!isGitInstalled()) {
+    console.log(chalk19.red("Git is not installed. Please install Git to use command."));
+    return;
+  }
+  if (!isMapRepo(workDir)) {
+    const initialized = await setupGitRepo(workDir);
+    if (!initialized) return;
+  }
+  await setupRemote(workDir);
+  const spinner = ora13("Syncing solutions...").start();
+  try {
+    const status = execSync("git status --porcelain", { cwd: workDir, encoding: "utf-8" });
+    if (!status) {
+      spinner.info("No changes to sync");
+      return;
+    }
+    execSync("git add .", { cwd: workDir });
+    const lines = status.trim().split("\n");
+    const count = lines.length;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
+    const message = `Sync: ${count} solutions - ${timestamp}`;
+    execSync(`git commit -m "${message}"`, { cwd: workDir });
+    try {
+      execSync("git push -u origin main", { cwd: workDir, stdio: "ignore" });
+    } catch {
+      try {
+        execSync("git push -u origin master", { cwd: workDir, stdio: "ignore" });
+      } catch (e) {
+        throw new Error("Failed to push to remote. Please check your git credentials and branch status.");
+      }
+    }
+    spinner.succeed("Successfully synced solutions to remote");
+  } catch (error) {
+    spinner.fail("Sync failed");
+    if (error.message) {
+      console.log(chalk19.red(error.message));
+    }
+  }
 }
 
 // src/index.ts
 var program = new Command();
 program.configureHelp({
   sortSubcommands: true,
-  subcommandTerm: (cmd) => chalk13.cyan(cmd.name()) + (cmd.alias() ? chalk13.gray(`|${cmd.alias()}`) : ""),
-  subcommandDescription: (cmd) => chalk13.white(cmd.description()),
-  optionTerm: (option) => chalk13.yellow(option.flags),
-  optionDescription: (option) => chalk13.white(option.description)
+  subcommandTerm: (cmd) => chalk20.cyan(cmd.name()) + (cmd.alias() ? chalk20.gray(`|${cmd.alias()}`) : ""),
+  subcommandDescription: (cmd) => chalk20.white(cmd.description()),
+  optionTerm: (option) => chalk20.yellow(option.flags),
+  optionDescription: (option) => chalk20.white(option.description)
 });
-program.name("leetcode").usage("[command] [options]").description(chalk13.bold.cyan("\u{1F525} A modern LeetCode CLI built with TypeScript")).version("1.1.0", "-v, --version", "Output the version number").helpOption("-h, --help", "Display help for command").addHelpText("after", `
-${chalk13.yellow("Examples:")}
-  ${chalk13.cyan("$ leetcode login")}             Login to LeetCode
-  ${chalk13.cyan("$ leetcode list -d easy")}      List easy problems
-  ${chalk13.cyan("$ leetcode random -d medium")}   Get random medium problem
-  ${chalk13.cyan("$ leetcode pick 1")}            Start solving "Two Sum"
-  ${chalk13.cyan("$ leetcode test 1")}            Test your solution
-  ${chalk13.cyan("$ leetcode submit 1")}          Submit your solution
+program.name("leetcode").usage("[command] [options]").description(chalk20.bold.cyan("\u{1F525} A modern LeetCode CLI built with TypeScript")).version("1.4.0", "-v, --version", "Output the version number").helpOption("-h, --help", "Display help for command").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode login")}             Login to LeetCode
+  ${chalk20.cyan("$ leetcode list -d easy")}      List easy problems
+  ${chalk20.cyan("$ leetcode random -d medium")}   Get random medium problem
+  ${chalk20.cyan("$ leetcode pick 1")}            Start solving "Two Sum"
+  ${chalk20.cyan("$ leetcode test 1")}            Test your solution
+  ${chalk20.cyan("$ leetcode submit 1")}          Submit your solution
 `);
-program.command("login").description("Login to LeetCode with browser cookies").action(loginCommand);
+program.command("login").description("Login to LeetCode with browser cookies").addHelpText("after", `
+${chalk20.yellow("How to login:")}
+  1. Open ${chalk20.cyan("https://leetcode.com")} in your browser
+  2. Login to your account
+  3. Open Developer Tools (F12) \u2192 Application \u2192 Cookies
+  4. Copy values of ${chalk20.green("LEETCODE_SESSION")} and ${chalk20.green("csrftoken")}
+  5. Paste when prompted by this command
+`).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("random").alias("r").description("Get a random problem").option("-d, --difficulty <level>", "Filter by difficulty (easy/medium/hard)").option("-t, --tag <tag>", "Filter by topic tag").option("--pick", "Auto-generate solution file").option("--no-open", "Do not open file in editor").action(randomCommand);
-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("submissions <id>").description("View past submissions").option("-n, --limit <number>", "Number of submissions to show", "20").option("--last", "Show details of the last accepted submission").option("--download", "Download the last accepted submission code").action(submissionsCommand);
-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) => {
+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").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode list")}                    List first 20 problems
+  ${chalk20.cyan("$ leetcode list -d easy")}            List easy problems only
+  ${chalk20.cyan("$ leetcode list -s solved")}          List your solved problems
+  ${chalk20.cyan("$ leetcode list -t array -t string")} Filter by multiple tags
+  ${chalk20.cyan('$ leetcode list -q "two sum"')}       Search by keywords
+  ${chalk20.cyan("$ leetcode list -n 50 -p 2")}         Show 50 problems, page 2
+`).action(listCommand);
+program.command("show <id>").alias("s").description("Show problem description").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode show 1")}                  Show by problem ID
+  ${chalk20.cyan("$ leetcode show two-sum")}            Show by problem slug
+  ${chalk20.cyan("$ leetcode s 412")}                   Short alias
+`).action(showCommand);
+program.command("daily").alias("d").description("Show today's daily challenge").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode daily")}                   Show today's challenge
+  ${chalk20.cyan("$ leetcode d")}                       Short alias
+`).action(dailyCommand);
+program.command("random").alias("r").description("Get a random problem").option("-d, --difficulty <level>", "Filter by difficulty (easy/medium/hard)").option("-t, --tag <tag>", "Filter by topic tag").option("--pick", "Auto-generate solution file").option("--no-open", "Do not open file in editor").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode random")}                  Get any random problem
+  ${chalk20.cyan("$ leetcode random -d medium")}        Random medium problem
+  ${chalk20.cyan("$ leetcode random -t array")}         Random array problem
+  ${chalk20.cyan("$ leetcode random --pick")}           Random + create file
+  ${chalk20.cyan("$ leetcode r -d easy --pick")}        Random easy + file
+`).action(randomCommand);
+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").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode pick 1")}                  Pick by problem ID
+  ${chalk20.cyan("$ leetcode pick two-sum")}            Pick by problem slug
+  ${chalk20.cyan("$ leetcode pick 1 -l python3")}       Pick with specific language
+  ${chalk20.cyan("$ leetcode pick 1 --no-open")}        Create file without opening
+  ${chalk20.cyan("$ leetcode p 412")}                   Short alias
+
+${chalk20.gray("Files are organized by: workDir/Difficulty/Category/")}
+`).action(async (id, options) => {
+  await pickCommand(id, options);
+});
+program.command("pick-batch <ids...>").description("Generate solution files for multiple problems").option("-l, --lang <language>", "Programming language for the solutions").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode pick-batch 1 2 3")}        Pick problems 1, 2, and 3
+  ${chalk20.cyan("$ leetcode pick-batch 1 2 3 -l py")}  Pick with Python
+`).action(batchPickCommand);
+program.command("test <file>").alias("t").description("Test solution against sample test cases").option("-c, --testcase <testcase>", "Custom test case").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode test 1")}                  Test by problem ID
+  ${chalk20.cyan("$ leetcode test two-sum")}            Test by problem slug
+  ${chalk20.cyan("$ leetcode test ./path/to/file.py")} Test by file path
+  ${chalk20.cyan('$ leetcode test 1 -c "[1,2]\\n3"')}   Test with custom case
+  ${chalk20.cyan("$ leetcode t 412")}                   Short alias
+
+${chalk20.gray("Testcases use \\n to separate multiple inputs.")}
+`).action(testCommand);
+program.command("submit <file>").alias("x").description("Submit solution to LeetCode").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode submit 1")}                Submit by problem ID
+  ${chalk20.cyan("$ leetcode submit two-sum")}          Submit by problem slug
+  ${chalk20.cyan("$ leetcode submit ./path/to/file.py")} Submit by file path
+  ${chalk20.cyan("$ leetcode x 412")}                   Short alias
+`).action(submitCommand);
+program.command("submissions <id>").description("View past submissions").option("-n, --limit <number>", "Number of submissions to show", "20").option("--last", "Show details of the last accepted submission").option("--download", "Download the last accepted submission code").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode submissions 1")}           View submissions for problem
+  ${chalk20.cyan("$ leetcode submissions 1 -n 5")}      Show last 5 submissions
+  ${chalk20.cyan("$ leetcode submissions 1 --last")}    Show last accepted submission
+  ${chalk20.cyan("$ leetcode submissions 1 --download")} Download last accepted code
+`).action(submissionsCommand);
+program.command("stat [username]").description("Show user statistics and analytics").option("-c, --calendar", "Weekly activity summary (submissions & active days for last 12 weeks)").option("-s, --skills", "Skill breakdown (problems solved grouped by topic tags)").option("-t, --trend", "Daily trend chart (bar graph of submissions for last 7 days)").addHelpText("after", `
+${chalk20.yellow("Options Explained:")}
+  ${chalk20.cyan("-c, --calendar")}  Shows a table of your weekly submissions and active days
+                    for the past 12 weeks. Useful for tracking consistency.
+  
+  ${chalk20.cyan("-s, --skills")}    Shows how many problems you solved per topic tag,
+                    grouped by difficulty (Fundamental/Intermediate/Advanced).
+                    Helps identify your strong and weak areas.
+  
+  ${chalk20.cyan("-t, --trend")}     Shows a bar chart of daily submissions for the past week.
+                    Visualizes your recent coding activity day by day.
+
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode stat")}                    Show basic stats (solved count, rank)
+  ${chalk20.cyan("$ leetcode stat lee215")}             Show another user's stats
+  ${chalk20.cyan("$ leetcode stat -c")}                 Weekly activity table
+  ${chalk20.cyan("$ leetcode stat -s")}                 Topic-wise breakdown
+  ${chalk20.cyan("$ leetcode stat -t")}                 7-day trend chart
+`).action((username, options) => statCommand(username, options));
+program.command("today").description("Show today's progress summary").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode today")}                   Show streak, solved, and daily challenge
+`).action(todayCommand);
+program.command("bookmark <action> [id]").description("Manage problem bookmarks").addHelpText("after", `
+${chalk20.yellow("Actions:")}
+  ${chalk20.cyan("add <id>")}      Bookmark a problem
+  ${chalk20.cyan("remove <id>")}   Remove a bookmark
+  ${chalk20.cyan("list")}          List all bookmarks
+  ${chalk20.cyan("clear")}         Clear all bookmarks
+
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode bookmark add 1")}          Bookmark problem 1
+  ${chalk20.cyan("$ leetcode bookmark remove 1")}       Remove bookmark
+  ${chalk20.cyan("$ leetcode bookmark list")}           List all bookmarks
+`).action(bookmarkCommand);
+program.command("note <id> [action]").description("View or edit notes for a problem").addHelpText("after", `
+${chalk20.yellow("Actions:")}
+  ${chalk20.cyan("edit")}   Open notes in editor (default)
+  ${chalk20.cyan("view")}   Display notes in terminal
+
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode note 1")}                  Edit notes for problem 1
+  ${chalk20.cyan("$ leetcode note 1 edit")}             Edit notes (explicit)
+  ${chalk20.cyan("$ leetcode note 1 view")}             View notes in terminal
+`).action(notesCommand);
+program.command("sync").description("Sync solutions to Git repository").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode sync")}                    Sync all solutions to remote
+`).action(syncCommand);
+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("-r, --repo <url>", "Set Git repository URL").option("-i, --interactive", "Interactive configuration").addHelpText("after", `
+${chalk20.yellow("Examples:")}
+  ${chalk20.cyan("$ leetcode config")}                  View current config
+  ${chalk20.cyan("$ leetcode config -l python3")}       Set language to Python
+  ${chalk20.cyan('$ leetcode config -e "code"')}        Set editor to VS Code
+  ${chalk20.cyan("$ leetcode config -w ~/leetcode")}    Set solutions folder
+  ${chalk20.cyan("$ leetcode config -r https://...")}   Set git repository
+  ${chalk20.cyan("$ leetcode config -i")}               Interactive setup
+
+${chalk20.gray("Supported languages: typescript, javascript, python3, java, cpp, c, csharp, go, rust, kotlin, swift")}
+`).action(async (options) => {
   if (options.interactive) {
     await configInteractiveCommand();
   } else {
@@ -1587,8 +2543,8 @@ program.showHelpAfterError("(add --help for additional information)");
 program.parse();
 if (!process.argv.slice(2).length) {
   console.log();
-  console.log(chalk13.bold.cyan("  \u{1F525} LeetCode CLI"));
-  console.log(chalk13.gray("  A modern command-line interface for LeetCode"));
+  console.log(chalk20.bold.cyan("  \u{1F525} LeetCode CLI"));
+  console.log(chalk20.gray("  A modern command-line interface for LeetCode"));
   console.log();
   program.outputHelp();
 }