@night-slayer18/leetcode-cli 1.4.0 → 1.6.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk20 from "chalk";
+import chalk22 from "chalk";
 
 // src/commands/login.ts
 import inquirer from "inquirer";
@@ -308,12 +308,12 @@ var LeetCodeClient = class {
       retry: { limit: 2 }
     });
   }
-  setCredentials(credentials) {
-    this.credentials = credentials;
+  setCredentials(credentials2) {
+    this.credentials = credentials2;
     this.client = this.client.extend({
       headers: {
-        "Cookie": `LEETCODE_SESSION=${credentials.session}; csrftoken=${credentials.csrfToken}`,
-        "X-CSRFToken": credentials.csrfToken
+        "Cookie": `LEETCODE_SESSION=${credentials2.session}; csrftoken=${credentials2.csrfToken}`,
+        "X-CSRFToken": credentials2.csrfToken
       }
     });
   }
@@ -445,14 +445,14 @@ var LeetCodeClient = class {
     }).json();
     return this.pollSubmission(response.submission_id.toString(), "submission", SubmissionResultSchema);
   }
-  async pollSubmission(id, _type, schema2) {
+  async pollSubmission(id, _type, schema) {
     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 schema2.parse(result);
+        return schema.parse(result);
       }
       await new Promise((resolve) => setTimeout(resolve, delay));
     }
@@ -461,88 +461,31 @@ var LeetCodeClient = class {
 };
 var leetcodeClient = new LeetCodeClient();
 
-// src/storage/config.ts
+// src/storage/credentials.ts
 import Conf from "conf";
 import { homedir } from "os";
 import { join } from "path";
-var schema = {
-  credentials: {
-    type: "object",
-    nullable: true,
-    properties: {
-      csrfToken: { type: "string" },
-      session: { type: "string" }
-    }
-  },
-  config: {
-    type: "object",
-    properties: {
-      language: { type: "string", default: "typescript" },
-      editor: { type: "string" },
-      workDir: { type: "string", default: join(homedir(), "leetcode") },
-      repo: { type: "string" }
-    },
-    default: {
-      language: "typescript",
-      workDir: join(homedir(), "leetcode")
-    }
-  }
-};
-var configStore = new Conf({
-  projectName: "leetcode-cli",
+var credentialsStore = new Conf({
+  configName: "credentials",
   cwd: join(homedir(), ".leetcode"),
-  schema
+  defaults: {}
 });
-var config = {
-  // Credentials
-  getCredentials() {
-    return configStore.get("credentials") ?? null;
-  },
-  setCredentials(credentials) {
-    configStore.set("credentials", credentials);
+var credentials = {
+  get() {
+    const session = credentialsStore.get("session");
+    const csrfToken = credentialsStore.get("csrfToken");
+    if (!session || !csrfToken) return null;
+    return { session, csrfToken };
   },
-  clearCredentials() {
-    configStore.delete("credentials");
+  set(creds) {
+    credentialsStore.set("session", creds.session);
+    credentialsStore.set("csrfToken", creds.csrfToken);
   },
-  // User Config
-  getConfig() {
-    return configStore.get("config");
-  },
-  setLanguage(language) {
-    configStore.set("config.language", language);
-  },
-  setEditor(editor) {
-    configStore.set("config.editor", editor);
-  },
-  setWorkDir(workDir) {
-    configStore.set("config.workDir", workDir);
-  },
-  setRepo(repo) {
-    configStore.set("config.repo", repo);
-  },
-  deleteRepo() {
-    configStore.delete("config.repo");
-  },
-  // Get specific config values
-  getLanguage() {
-    return configStore.get("config.language");
-  },
-  getEditor() {
-    return configStore.get("config.editor");
-  },
-  getWorkDir() {
-    return configStore.get("config.workDir");
-  },
-  getRepo() {
-    return configStore.get("config.repo");
-  },
-  // Clear all config
   clear() {
-    configStore.clear();
+    credentialsStore.clear();
   },
-  // Get config file path (for debugging)
   getPath() {
-    return configStore.path;
+    return credentialsStore.path;
   }
 };
 
@@ -574,23 +517,23 @@ async function loginCommand() {
       validate: (input) => input.length > 0 || "CSRF token is required"
     }
   ]);
-  const credentials = {
+  const creds = {
     session: answers.session.trim(),
     csrfToken: answers.csrfToken.trim()
   };
   const spinner = ora("Verifying credentials...").start();
   try {
-    leetcodeClient.setCredentials(credentials);
+    leetcodeClient.setCredentials(creds);
     const { isSignedIn, username } = await leetcodeClient.checkAuth();
     if (!isSignedIn || !username) {
       spinner.fail("Invalid credentials");
       console.log(chalk.red("Please check your session cookies and try again."));
       return;
     }
-    config.setCredentials(credentials);
+    credentials.set(creds);
     spinner.succeed(`Logged in as ${chalk.green(username)}`);
     console.log();
-    console.log(chalk.gray(`Credentials saved to ${config.getPath()}`));
+    console.log(chalk.gray(`Credentials saved to ${credentials.getPath()}`));
   } catch (error) {
     spinner.fail("Authentication failed");
     if (error instanceof Error) {
@@ -599,18 +542,18 @@ async function loginCommand() {
   }
 }
 async function logoutCommand() {
-  config.clearCredentials();
+  credentials.clear();
   console.log(chalk.green("\u2713 Logged out successfully"));
 }
 async function whoamiCommand() {
-  const credentials = config.getCredentials();
-  if (!credentials) {
+  const creds = credentials.get();
+  if (!creds) {
     console.log(chalk.yellow('Not logged in. Run "leetcode login" to authenticate.'));
     return;
   }
   const spinner = ora("Checking session...").start();
   try {
-    leetcodeClient.setCredentials(credentials);
+    leetcodeClient.setCredentials(creds);
     const { isSignedIn, username } = await leetcodeClient.checkAuth();
     if (!isSignedIn || !username) {
       spinner.fail("Session expired");
@@ -633,13 +576,13 @@ import chalk4 from "chalk";
 // src/utils/auth.ts
 import chalk2 from "chalk";
 async function requireAuth() {
-  const credentials = config.getCredentials();
-  if (!credentials) {
+  const creds = credentials.get();
+  if (!creds) {
     console.log(chalk2.yellow("\u26A0\uFE0F  Please login first: leetcode login"));
     return { authorized: false };
   }
   try {
-    leetcodeClient.setCredentials(credentials);
+    leetcodeClient.setCredentials(creds);
     const { isSignedIn, username } = await leetcodeClient.checkAuth();
     if (!isSignedIn) {
       console.log(chalk2.yellow("\u26A0\uFE0F  Session expired. Please run: leetcode login"));
@@ -990,10 +933,63 @@ async function showCommand(idOrSlug) {
 // src/commands/pick.ts
 import { writeFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import ora4 from "ora";
 import chalk7 from "chalk";
 
+// src/storage/config.ts
+import Conf2 from "conf";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var configStore = new Conf2({
+  configName: "config",
+  cwd: join2(homedir2(), ".leetcode"),
+  defaults: {
+    language: "typescript",
+    workDir: join2(homedir2(), "leetcode")
+  }
+});
+var config = {
+  getConfig() {
+    return {
+      language: configStore.get("language"),
+      editor: configStore.get("editor"),
+      workDir: configStore.get("workDir"),
+      repo: configStore.get("repo")
+    };
+  },
+  setLanguage(language) {
+    configStore.set("language", language);
+  },
+  setEditor(editor) {
+    configStore.set("editor", editor);
+  },
+  setWorkDir(workDir) {
+    configStore.set("workDir", workDir);
+  },
+  setRepo(repo) {
+    configStore.set("repo", repo);
+  },
+  deleteRepo() {
+    configStore.delete("repo");
+  },
+  getLanguage() {
+    return configStore.get("language");
+  },
+  getEditor() {
+    return configStore.get("editor");
+  },
+  getWorkDir() {
+    return configStore.get("workDir");
+  },
+  getRepo() {
+    return configStore.get("repo");
+  },
+  getPath() {
+    return configStore.path;
+  }
+};
+
 // src/utils/templates.ts
 var LANGUAGE_EXTENSIONS = {
   typescript: "ts",
@@ -1187,12 +1183,12 @@ async function pickCommand(idOrSlug, options) {
     const workDir = config.getWorkDir();
     const difficulty = problem.difficulty;
     const category = problem.topicTags.length > 0 ? problem.topicTags[0].name.replace(/[^\w\s-]/g, "").trim() : "Uncategorized";
-    const targetDir = join2(workDir, difficulty, category);
+    const targetDir = join3(workDir, difficulty, category);
     if (!existsSync(targetDir)) {
       await mkdir(targetDir, { recursive: true });
     }
     const fileName = getSolutionFileName(problem.questionFrontendId, problem.titleSlug, language);
-    const filePath = join2(targetDir, fileName);
+    const filePath = join3(targetDir, fileName);
     if (existsSync(filePath)) {
       spinner.warn(`File already exists: ${fileName}`);
       console.log(chalk7.gray(`Path: ${filePath}`));
@@ -1271,19 +1267,23 @@ 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";
+import { join as join4 } 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.name.startsWith(".")) continue;
+    const fullPath = join4(dir, entry.name);
     if (entry.isDirectory()) {
       const found = await findSolutionFile(fullPath, problemId, currentDepth + 1);
       if (found) return found;
     } else if (entry.name.startsWith(`${problemId}.`)) {
-      return fullPath;
+      const ext = entry.name.split(".").pop()?.toLowerCase();
+      if (ext && ext in EXT_TO_LANG_MAP) {
+        return fullPath;
+      }
     }
   }
   return null;
@@ -1293,7 +1293,7 @@ async function findFileByName(dir, fileName, currentDepth = 0) {
   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);
+    const fullPath = join4(dir, entry.name);
     if (entry.isDirectory()) {
       const found = await findFileByName(fullPath, fileName, currentDepth + 1);
       if (found) return found;
@@ -1303,6 +1303,19 @@ async function findFileByName(dir, fileName, currentDepth = 0) {
   }
   return null;
 }
+var EXT_TO_LANG_MAP = {
+  ts: "typescript",
+  js: "javascript",
+  py: "python3",
+  java: "java",
+  cpp: "cpp",
+  c: "c",
+  cs: "csharp",
+  go: "go",
+  rs: "rust",
+  kt: "kotlin",
+  swift: "swift"
+};
 function getLangSlugFromExtension(ext) {
   const langMap = {
     ts: "typescript",
@@ -1398,6 +1411,82 @@ import { existsSync as existsSync4 } from "fs";
 import { basename as basename2 } from "path";
 import ora6 from "ora";
 import chalk9 from "chalk";
+
+// src/storage/timer.ts
+import Conf3 from "conf";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+var timerStore = new Conf3({
+  configName: "timer",
+  cwd: join5(homedir3(), ".leetcode"),
+  defaults: {
+    solveTimes: {},
+    activeTimer: null
+  }
+});
+var timerStorage = {
+  startTimer(problemId, title, difficulty, durationMinutes) {
+    timerStore.set("activeTimer", {
+      problemId,
+      title,
+      difficulty,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMinutes
+    });
+  },
+  getActiveTimer() {
+    return timerStore.get("activeTimer");
+  },
+  stopTimer() {
+    const active = timerStore.get("activeTimer");
+    if (!active) return null;
+    const startedAt = new Date(active.startedAt);
+    const now = /* @__PURE__ */ new Date();
+    const durationSeconds = Math.floor((now.getTime() - startedAt.getTime()) / 1e3);
+    timerStore.set("activeTimer", null);
+    return { durationSeconds };
+  },
+  recordSolveTime(problemId, title, difficulty, durationSeconds, timerMinutes) {
+    const solveTimes = timerStore.get("solveTimes") ?? {};
+    if (!solveTimes[problemId]) {
+      solveTimes[problemId] = [];
+    }
+    solveTimes[problemId].push({
+      problemId,
+      title,
+      difficulty,
+      solvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationSeconds,
+      timerMinutes
+    });
+    timerStore.set("solveTimes", solveTimes);
+  },
+  getSolveTimes(problemId) {
+    const solveTimes = timerStore.get("solveTimes") ?? {};
+    return solveTimes[problemId] ?? [];
+  },
+  getAllSolveTimes() {
+    return timerStore.get("solveTimes") ?? {};
+  },
+  getStats() {
+    const solveTimes = timerStore.get("solveTimes") ?? {};
+    let totalProblems = 0;
+    let totalTime = 0;
+    for (const times of Object.values(solveTimes)) {
+      totalProblems += times.length;
+      for (const t of times) {
+        totalTime += t.durationSeconds;
+      }
+    }
+    return {
+      totalProblems,
+      totalTime,
+      avgTime: totalProblems > 0 ? Math.floor(totalTime / totalProblems) : 0
+    };
+  }
+};
+
+// src/commands/submit.ts
 async function submitCommand(fileOrId) {
   const { authorized } = await requireAuth();
   if (!authorized) return;
@@ -1457,6 +1546,35 @@ async function submitCommand(fileOrId) {
     );
     spinner.stop();
     displaySubmissionResult(result);
+    if (result.status_msg === "Accepted") {
+      const activeTimer = timerStorage.getActiveTimer();
+      if (activeTimer && activeTimer.problemId === problemId) {
+        const timerResult = timerStorage.stopTimer();
+        if (timerResult) {
+          timerStorage.recordSolveTime(
+            problemId,
+            problem.title,
+            problem.difficulty,
+            timerResult.durationSeconds,
+            activeTimer.durationMinutes
+          );
+          const mins = Math.floor(timerResult.durationSeconds / 60);
+          const secs = timerResult.durationSeconds % 60;
+          const timeStr = `${mins}m ${secs}s`;
+          const withinLimit = timerResult.durationSeconds <= activeTimer.durationMinutes * 60;
+          console.log();
+          console.log(chalk9.bold("\u23F1\uFE0F  Timer Result:"));
+          console.log(
+            `   Solved in ${withinLimit ? chalk9.green(timeStr) : chalk9.yellow(timeStr)} (limit: ${activeTimer.durationMinutes}m)`
+          );
+          if (withinLimit) {
+            console.log(chalk9.green("   \u2713 Within time limit!"));
+          } else {
+            console.log(chalk9.yellow("   \u26A0 Exceeded time limit"));
+          }
+        }
+      }
+    }
   } catch (error) {
     spinner.fail("Submission failed");
     if (error instanceof Error) {
@@ -1704,7 +1822,7 @@ async function randomCommand(options) {
 // src/commands/submissions.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 import ora10 from "ora";
 import chalk14 from "chalk";
 async function submissionsCommand(idOrSlug, options) {
@@ -1758,7 +1876,7 @@ async function submissionsCommand(idOrSlug, options) {
       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 = join4(workDir, difficulty, category);
+      const targetDir = join6(workDir, difficulty, category);
       if (!existsSync5(targetDir)) {
         await mkdir2(targetDir, { recursive: true });
       }
@@ -1766,7 +1884,7 @@ async function submissionsCommand(idOrSlug, options) {
       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 = join4(targetDir, fileName);
+      const filePath = join6(targetDir, fileName);
       await writeFile2(filePath, details.code, "utf-8");
       downloadSpinner.succeed(`Downloaded to ${chalk14.green(fileName)}`);
       console.log(chalk14.gray(`Path: ${filePath}`));
@@ -1872,7 +1990,7 @@ async function configInteractiveCommand() {
 }
 function showCurrentConfig() {
   const currentConfig = config.getConfig();
-  const credentials = config.getCredentials();
+  const creds = credentials.get();
   console.log();
   console.log(chalk15.bold("LeetCode CLI Configuration"));
   console.log(chalk15.gray("\u2500".repeat(40)));
@@ -1883,7 +2001,7 @@ function showCurrentConfig() {
   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"));
+  console.log(chalk15.gray("Logged in:   "), creds ? chalk15.green("Yes") : chalk15.yellow("No"));
 }
 
 // src/commands/bookmark.ts
@@ -1892,8 +2010,8 @@ import Table2 from "cli-table3";
 import ora11 from "ora";
 
 // src/storage/bookmarks.ts
-import Conf2 from "conf";
-var bookmarksStore = new Conf2({
+import Conf4 from "conf";
+var bookmarksStore = new Conf4({
   projectName: "leetcode-cli-bookmarks",
   defaults: { bookmarks: [] }
 });
@@ -2046,7 +2164,7 @@ function colorDifficulty2(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 { join as join7 } from "path";
 import { existsSync as existsSync6 } from "fs";
 import chalk17 from "chalk";
 async function notesCommand(problemId, action) {
@@ -2056,8 +2174,8 @@ async function notesCommand(problemId, action) {
     return;
   }
   const noteAction = action === "view" ? "view" : "edit";
-  const notesDir = join5(config.getWorkDir(), ".notes");
-  const notePath = join5(notesDir, `${problemId}.md`);
+  const notesDir = join7(config.getWorkDir(), ".notes");
+  const notePath = join7(notesDir, `${problemId}.md`);
   if (!existsSync6(notesDir)) {
     await mkdir3(notesDir, { recursive: true });
   }
@@ -2376,162 +2494,644 @@ async function syncCommand() {
   }
 }
 
+// src/commands/timer.ts
+import ora14 from "ora";
+import chalk20 from "chalk";
+var DEFAULT_TIMES = {
+  Easy: 20,
+  Medium: 40,
+  Hard: 60
+};
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  } else if (seconds < 3600) {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+  } else {
+    const hours = Math.floor(seconds / 3600);
+    const mins = Math.floor(seconds % 3600 / 60);
+    return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+  }
+}
+async function timerCommand(idOrSlug, options) {
+  if (options.stats) {
+    await showTimerStats(idOrSlug);
+    return;
+  }
+  if (options.stop) {
+    await stopActiveTimer();
+    return;
+  }
+  if (!idOrSlug) {
+    console.log(chalk20.yellow("Please provide a problem ID to start the timer."));
+    console.log(chalk20.gray("Usage: leetcode timer <id>"));
+    console.log(chalk20.gray("       leetcode timer --stats"));
+    console.log(chalk20.gray("       leetcode timer --stop"));
+    return;
+  }
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
+  const activeTimer = timerStorage.getActiveTimer();
+  if (activeTimer) {
+    const startedAt = new Date(activeTimer.startedAt);
+    const elapsed = Math.floor((Date.now() - startedAt.getTime()) / 1e3);
+    console.log(chalk20.yellow("\u26A0\uFE0F  You have an active timer running:"));
+    console.log(chalk20.white(`   Problem: ${activeTimer.title}`));
+    console.log(chalk20.white(`   Elapsed: ${formatDuration(elapsed)}`));
+    console.log();
+    console.log(chalk20.gray("Use `leetcode timer --stop` to stop it first."));
+    return;
+  }
+  const spinner = ora14("Fetching problem...").start();
+  try {
+    let problem;
+    if (/^\d+$/.test(idOrSlug)) {
+      problem = await leetcodeClient.getProblemById(idOrSlug);
+    } else {
+      problem = await leetcodeClient.getProblem(idOrSlug);
+    }
+    if (!problem) {
+      spinner.fail(`Problem "${idOrSlug}" not found`);
+      return;
+    }
+    spinner.stop();
+    const durationMinutes = options.minutes ?? DEFAULT_TIMES[problem.difficulty] ?? 30;
+    timerStorage.startTimer(
+      problem.questionFrontendId,
+      problem.title,
+      problem.difficulty,
+      durationMinutes
+    );
+    console.log();
+    console.log(chalk20.bold.cyan("\u23F1\uFE0F  Interview Mode Started!"));
+    console.log(chalk20.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk20.white(`Problem: ${problem.questionFrontendId}. ${problem.title}`));
+    console.log(chalk20.white(`Difficulty: ${chalk20.bold(problem.difficulty)}`));
+    console.log(chalk20.white(`Time Limit: ${chalk20.bold.yellow(durationMinutes + " minutes")}`));
+    console.log();
+    console.log(chalk20.gray("\u2500".repeat(50)));
+    console.log(chalk20.green("\u2713 Timer is running in background"));
+    console.log(chalk20.gray("  When you submit successfully, your time will be recorded."));
+    console.log(chalk20.gray("  Use `leetcode timer --stop` to cancel."));
+    console.log();
+    await pickCommand(idOrSlug, { open: true });
+  } catch (error) {
+    spinner.fail("Failed to start timer");
+    if (error instanceof Error) {
+      console.log(chalk20.red(error.message));
+    }
+  }
+}
+async function stopActiveTimer() {
+  const result = timerStorage.stopTimer();
+  if (!result) {
+    console.log(chalk20.yellow("No active timer to stop."));
+    return;
+  }
+  console.log(chalk20.green("\u23F1\uFE0F  Timer stopped."));
+  console.log(chalk20.gray(`Elapsed time: ${formatDuration(result.durationSeconds)}`));
+  console.log(chalk20.gray("(Time not recorded since problem was not submitted)"));
+}
+async function showTimerStats(problemId) {
+  if (problemId && /^\d+$/.test(problemId)) {
+    const times = timerStorage.getSolveTimes(problemId);
+    if (times.length === 0) {
+      console.log(chalk20.yellow(`No solve times recorded for problem ${problemId}`));
+      return;
+    }
+    console.log();
+    console.log(chalk20.bold(`\u23F1\uFE0F  Solve Times for Problem ${problemId}`));
+    console.log(chalk20.gray("\u2500".repeat(40)));
+    for (const entry of times) {
+      const date = new Date(entry.solvedAt).toLocaleDateString();
+      const duration = formatDuration(entry.durationSeconds);
+      const limit = entry.timerMinutes;
+      const withinLimit = entry.durationSeconds <= limit * 60;
+      console.log(
+        `  ${date}  ${withinLimit ? chalk20.green(duration) : chalk20.red(duration)}  (limit: ${limit}m)`
+      );
+    }
+  } else {
+    const stats = timerStorage.getStats();
+    const allTimes = timerStorage.getAllSolveTimes();
+    console.log();
+    console.log(chalk20.bold("\u23F1\uFE0F  Timer Statistics"));
+    console.log(chalk20.gray("\u2500".repeat(40)));
+    console.log();
+    console.log(`  Problems timed: ${chalk20.cyan(stats.totalProblems)}`);
+    console.log(`  Total time: ${chalk20.cyan(formatDuration(stats.totalTime))}`);
+    console.log(`  Average time: ${chalk20.cyan(formatDuration(stats.avgTime))}`);
+    console.log();
+    const recentSolves = [];
+    for (const [id, times] of Object.entries(allTimes)) {
+      for (const t of times) {
+        recentSolves.push({
+          problemId: id,
+          title: t.title,
+          duration: t.durationSeconds,
+          date: t.solvedAt
+        });
+      }
+    }
+    if (recentSolves.length > 0) {
+      recentSolves.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+      console.log(chalk20.bold("  Recent Solves:"));
+      for (const solve of recentSolves.slice(0, 5)) {
+        const date = new Date(solve.date).toLocaleDateString();
+        console.log(
+          chalk20.gray(`    ${date}  `) + chalk20.white(`${solve.problemId}. ${solve.title.substring(0, 25)}`) + chalk20.gray("  ") + chalk20.cyan(formatDuration(solve.duration))
+        );
+      }
+    }
+    console.log();
+  }
+}
+
+// src/commands/collab.ts
+import chalk21 from "chalk";
+import ora15 from "ora";
+import { readFile as readFile4 } from "fs/promises";
+
+// src/services/supabase.ts
+import { createClient } from "@supabase/supabase-js";
+var SUPABASE_URL = "https://abagrmwdpvnfyuqizyym.supabase.co";
+var SUPABASE_ANON_KEY = "sb_publishable_indrKu8VJmASdyLp7w8Hog_OyqT17cV";
+var supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+
+// src/storage/collab.ts
+import Conf5 from "conf";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
+var collabStore = new Conf5({
+  configName: "collab",
+  cwd: join8(homedir4(), ".leetcode"),
+  defaults: {
+    session: null
+  }
+});
+var collabStorage = {
+  getSession() {
+    return collabStore.get("session");
+  },
+  setSession(session) {
+    if (session) {
+      collabStore.set("session", session);
+    } else {
+      collabStore.delete("session");
+    }
+  },
+  getPath() {
+    return collabStore.path;
+  }
+};
+
+// src/services/collab.ts
+function generateRoomCode() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  let code = "";
+  for (let i = 0; i < 6; i++) {
+    code += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return code;
+}
+var collabService = {
+  getSession() {
+    return collabStorage.getSession();
+  },
+  async createRoom(problemId, username) {
+    const roomCode = generateRoomCode();
+    const { error } = await supabase.from("collab_rooms").insert({
+      room_code: roomCode,
+      problem_id: problemId,
+      host_username: username,
+      host_code: "",
+      guest_username: null,
+      guest_code: null
+    });
+    if (error) {
+      return { error: error.message };
+    }
+    collabStorage.setSession({
+      roomCode,
+      problemId,
+      isHost: true,
+      username
+    });
+    return { roomCode };
+  },
+  async joinRoom(roomCode, username) {
+    const { data: room, error: fetchError } = await supabase.from("collab_rooms").select("*").eq("room_code", roomCode.toUpperCase()).single();
+    if (fetchError || !room) {
+      return { error: "Room not found" };
+    }
+    const { error: updateError } = await supabase.from("collab_rooms").update({ guest_username: username }).eq("room_code", roomCode.toUpperCase());
+    if (updateError) {
+      return { error: updateError.message };
+    }
+    collabStorage.setSession({
+      roomCode: roomCode.toUpperCase(),
+      problemId: room.problem_id,
+      isHost: false,
+      username
+    });
+    return { problemId: room.problem_id };
+  },
+  async syncCode(code) {
+    const session = collabStorage.getSession();
+    if (!session) {
+      return { success: false, error: "No active session" };
+    }
+    const column = session.isHost ? "host_code" : "guest_code";
+    const { error } = await supabase.from("collab_rooms").update({ [column]: code }).eq("room_code", session.roomCode);
+    if (error) {
+      return { success: false, error: error.message };
+    }
+    return { success: true };
+  },
+  async getPartnerCode() {
+    const session = collabStorage.getSession();
+    if (!session) {
+      return { error: "No active session" };
+    }
+    const { data: room, error } = await supabase.from("collab_rooms").select("*").eq("room_code", session.roomCode).single();
+    if (error || !room) {
+      return { error: "Room not found" };
+    }
+    if (session.isHost) {
+      return {
+        code: room.guest_code || "",
+        username: room.guest_username || "Partner"
+      };
+    } else {
+      return {
+        code: room.host_code || "",
+        username: room.host_username || "Host"
+      };
+    }
+  },
+  async getRoomStatus() {
+    const session = collabStorage.getSession();
+    if (!session) {
+      return { error: "No active session" };
+    }
+    const { data: room, error } = await supabase.from("collab_rooms").select("*").eq("room_code", session.roomCode).single();
+    if (error || !room) {
+      return { error: "Room not found" };
+    }
+    return {
+      host: room.host_username,
+      guest: room.guest_username,
+      hasHostCode: !!room.host_code,
+      hasGuestCode: !!room.guest_code
+    };
+  },
+  async leaveRoom() {
+    const session = collabStorage.getSession();
+    if (session) {
+      if (session.isHost) {
+        await supabase.from("collab_rooms").delete().eq("room_code", session.roomCode);
+      }
+    }
+    collabStorage.setSession(null);
+  }
+};
+
+// src/commands/collab.ts
+async function collabHostCommand(problemId) {
+  const { authorized, username } = await requireAuth();
+  if (!authorized || !username) return;
+  const spinner = ora15("Creating collaboration room...").start();
+  try {
+    const result = await collabService.createRoom(problemId, username);
+    if ("error" in result) {
+      spinner.fail(result.error);
+      return;
+    }
+    spinner.succeed("Room created!");
+    console.log();
+    console.log(chalk21.bold.cyan("\u{1F465} Collaborative Coding Session"));
+    console.log(chalk21.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk21.white(`Room Code: ${chalk21.bold.green(result.roomCode)}`));
+    console.log(chalk21.white(`Problem: ${problemId}`));
+    console.log();
+    console.log(chalk21.gray("Share this code with your partner:"));
+    console.log(chalk21.yellow(`  leetcode collab join ${result.roomCode}`));
+    console.log();
+    console.log(chalk21.gray("\u2500".repeat(50)));
+    console.log(chalk21.gray("After solving, sync and compare:"));
+    console.log(chalk21.gray("  leetcode collab sync     - Upload your solution"));
+    console.log(chalk21.gray("  leetcode collab compare  - See both solutions"));
+    console.log(chalk21.gray("  leetcode collab status   - Check room status"));
+    console.log(chalk21.gray("  leetcode collab leave    - End session"));
+    console.log();
+    await pickCommand(problemId, { open: true });
+  } catch (error) {
+    spinner.fail("Failed to create room");
+    if (error instanceof Error) {
+      console.log(chalk21.red(error.message));
+    }
+  }
+}
+async function collabJoinCommand(roomCode) {
+  const { authorized, username } = await requireAuth();
+  if (!authorized || !username) return;
+  const spinner = ora15(`Joining room ${roomCode}...`).start();
+  try {
+    const result = await collabService.joinRoom(roomCode.toUpperCase(), username);
+    if ("error" in result) {
+      spinner.fail(result.error);
+      return;
+    }
+    spinner.succeed("Joined room!");
+    console.log();
+    console.log(chalk21.bold.cyan("\u{1F465} Collaborative Coding Session"));
+    console.log(chalk21.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk21.white(`Room Code: ${chalk21.bold.green(roomCode.toUpperCase())}`));
+    console.log(chalk21.white(`Problem: ${result.problemId}`));
+    console.log();
+    console.log(chalk21.gray("\u2500".repeat(50)));
+    console.log(chalk21.gray("After solving, sync and compare:"));
+    console.log(chalk21.gray("  leetcode collab sync     - Upload your solution"));
+    console.log(chalk21.gray("  leetcode collab compare  - See both solutions"));
+    console.log(chalk21.gray("  leetcode collab status   - Check room status"));
+    console.log(chalk21.gray("  leetcode collab leave    - End session"));
+    console.log();
+    await pickCommand(result.problemId, { open: true });
+  } catch (error) {
+    spinner.fail("Failed to join room");
+    if (error instanceof Error) {
+      console.log(chalk21.red(error.message));
+    }
+  }
+}
+async function collabSyncCommand() {
+  const session = collabService.getSession();
+  if (!session) {
+    console.log(chalk21.yellow("No active collaboration session."));
+    console.log(chalk21.gray("Use `leetcode collab host <id>` or `leetcode collab join <code>` first."));
+    return;
+  }
+  const spinner = ora15("Syncing your code...").start();
+  const workDir = config.getWorkDir();
+  const filePath = await findSolutionFile(workDir, session.problemId);
+  if (!filePath) {
+    spinner.fail(`No solution file found for problem ${session.problemId}`);
+    return;
+  }
+  const code = await readFile4(filePath, "utf-8");
+  const result = await collabService.syncCode(code);
+  if (result.success) {
+    spinner.succeed("Code synced successfully!");
+    console.log(chalk21.gray(`Uploaded ${code.split("\n").length} lines from ${filePath}`));
+  } else {
+    spinner.fail(result.error || "Sync failed");
+  }
+}
+async function collabCompareCommand() {
+  const session = collabService.getSession();
+  if (!session) {
+    console.log(chalk21.yellow("No active collaboration session."));
+    console.log(chalk21.gray("Use `leetcode collab host <id>` or `leetcode collab join <code>` first."));
+    return;
+  }
+  const spinner = ora15("Fetching solutions...").start();
+  const workDir = config.getWorkDir();
+  const filePath = await findSolutionFile(workDir, session.problemId);
+  if (!filePath) {
+    spinner.fail(`No solution file found for problem ${session.problemId}`);
+    return;
+  }
+  const myCode = await readFile4(filePath, "utf-8");
+  const partnerResult = await collabService.getPartnerCode();
+  if ("error" in partnerResult) {
+    spinner.fail(partnerResult.error);
+    return;
+  }
+  spinner.stop();
+  if (!partnerResult.code) {
+    console.log(chalk21.yellow("Partner has not synced their code yet."));
+    console.log(chalk21.gray("Ask them to run `leetcode collab sync`."));
+    return;
+  }
+  console.log();
+  console.log(chalk21.bold.cyan("\u{1F4CA} Solution Comparison"));
+  console.log(chalk21.gray("\u2500".repeat(60)));
+  console.log();
+  console.log(chalk21.bold.green(`\u25B8 Your Solution (${session.username})`));
+  console.log(chalk21.gray("\u2500".repeat(60)));
+  const myLines = myCode.split("\n");
+  for (let i = 0; i < myLines.length; i++) {
+    const lineNum = String(i + 1).padStart(3, " ");
+    console.log(`${chalk21.gray(lineNum)} ${myLines[i]}`);
+  }
+  console.log();
+  console.log(chalk21.bold.blue(`\u25B8 ${partnerResult.username}'s Solution`));
+  console.log(chalk21.gray("\u2500".repeat(60)));
+  const partnerLines = partnerResult.code.split("\n");
+  for (let i = 0; i < partnerLines.length; i++) {
+    const lineNum = String(i + 1).padStart(3, " ");
+    console.log(`${chalk21.gray(lineNum)} ${partnerLines[i]}`);
+  }
+  console.log();
+  console.log(chalk21.gray("\u2500".repeat(60)));
+  console.log(chalk21.gray(`Your code: ${myLines.length} lines | Partner: ${partnerLines.length} lines`));
+  console.log();
+}
+async function collabLeaveCommand() {
+  const session = collabService.getSession();
+  if (!session) {
+    console.log(chalk21.yellow("No active collaboration session."));
+    return;
+  }
+  await collabService.leaveRoom();
+  console.log(chalk21.green("\u2713 Left the collaboration session."));
+}
+async function collabStatusCommand() {
+  const session = collabService.getSession();
+  if (!session) {
+    console.log(chalk21.yellow("No active collaboration session."));
+    console.log(chalk21.gray("Use `leetcode collab host <id>` or `leetcode collab join <code>` to start."));
+    return;
+  }
+  const status = await collabService.getRoomStatus();
+  if ("error" in status) {
+    console.log(chalk21.red(status.error));
+    return;
+  }
+  console.log();
+  console.log(chalk21.bold.cyan("\u{1F465} Collaboration Status"));
+  console.log(chalk21.gray("\u2500".repeat(40)));
+  console.log(`  Room: ${chalk21.green(session.roomCode)}`);
+  console.log(`  Problem: ${session.problemId}`);
+  console.log(`  Role: ${session.isHost ? "Host" : "Guest"}`);
+  console.log();
+  console.log(chalk21.bold("  Participants:"));
+  console.log(`    Host: ${status.host} ${status.hasHostCode ? chalk21.green("\u2713 synced") : chalk21.gray("pending")}`);
+  console.log(`    Guest: ${status.guest || chalk21.gray("(waiting...)")} ${status.hasGuestCode ? chalk21.green("\u2713 synced") : chalk21.gray("pending")}`);
+  console.log();
+}
+
 // src/index.ts
 var program = new Command();
 program.configureHelp({
   sortSubcommands: true,
-  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)
+  subcommandTerm: (cmd) => chalk22.cyan(cmd.name()) + (cmd.alias() ? chalk22.gray(`|${cmd.alias()}`) : ""),
+  subcommandDescription: (cmd) => chalk22.white(cmd.description()),
+  optionTerm: (option) => chalk22.yellow(option.flags),
+  optionDescription: (option) => chalk22.white(option.description)
 });
-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.name("leetcode").usage("[command] [options]").description(chalk22.bold.cyan("\u{1F525} A modern LeetCode CLI built with TypeScript")).version("1.6.0", "-v, --version", "Output the version number").helpOption("-h, --help", "Display help for command").addHelpText("after", `
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode login")}             Login to LeetCode
+  ${chalk22.cyan("$ leetcode list -d easy")}      List easy problems
+  ${chalk22.cyan("$ leetcode random -d medium")}   Get random medium problem
+  ${chalk22.cyan("$ leetcode pick 1")}            Start solving "Two Sum"
+  ${chalk22.cyan("$ leetcode test 1")}            Test your solution
+  ${chalk22.cyan("$ leetcode submit 1")}          Submit your solution
 `);
 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
+${chalk22.yellow("How to login:")}
+  1. Open ${chalk22.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")}
+  4. Copy values of ${chalk22.green("LEETCODE_SESSION")} and ${chalk22.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").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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode list")}                    List first 20 problems
+  ${chalk22.cyan("$ leetcode list -d easy")}            List easy problems only
+  ${chalk22.cyan("$ leetcode list -s solved")}          List your solved problems
+  ${chalk22.cyan("$ leetcode list -t array -t string")} Filter by multiple tags
+  ${chalk22.cyan('$ leetcode list -q "two sum"')}       Search by keywords
+  ${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode show 1")}                  Show by problem ID
+  ${chalk22.cyan("$ leetcode show two-sum")}            Show by problem slug
+  ${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode daily")}                   Show today's challenge
+  ${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode random")}                  Get any random problem
+  ${chalk22.cyan("$ leetcode random -d medium")}        Random medium problem
+  ${chalk22.cyan("$ leetcode random -t array")}         Random array problem
+  ${chalk22.cyan("$ leetcode random --pick")}           Random + create file
+  ${chalk22.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/")}
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode pick 1")}                  Pick by problem ID
+  ${chalk22.cyan("$ leetcode pick two-sum")}            Pick by problem slug
+  ${chalk22.cyan("$ leetcode pick 1 -l python3")}       Pick with specific language
+  ${chalk22.cyan("$ leetcode pick 1 --no-open")}        Create file without opening
+  ${chalk22.cyan("$ leetcode p 412")}                   Short alias
+
+${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode pick-batch 1 2 3")}        Pick problems 1, 2, and 3
+  ${chalk22.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.")}
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode test 1")}                  Test by problem ID
+  ${chalk22.cyan("$ leetcode test two-sum")}            Test by problem slug
+  ${chalk22.cyan("$ leetcode test ./path/to/file.py")} Test by file path
+  ${chalk22.cyan('$ leetcode test 1 -c "[1,2]\\n3"')}   Test with custom case
+  ${chalk22.cyan("$ leetcode t 412")}                   Short alias
+
+${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode submit 1")}                Submit by problem ID
+  ${chalk22.cyan("$ leetcode submit two-sum")}          Submit by problem slug
+  ${chalk22.cyan("$ leetcode submit ./path/to/file.py")} Submit by file path
+  ${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode submissions 1")}           View submissions for problem
+  ${chalk22.cyan("$ leetcode submissions 1 -n 5")}      Show last 5 submissions
+  ${chalk22.cyan("$ leetcode submissions 1 --last")}    Show last accepted submission
+  ${chalk22.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
+${chalk22.yellow("Options Explained:")}
+  ${chalk22.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,
+  ${chalk22.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.
+  ${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode stat")}                    Show basic stats (solved count, rank)
+  ${chalk22.cyan("$ leetcode stat lee215")}             Show another user's stats
+  ${chalk22.cyan("$ leetcode stat -c")}                 Weekly activity table
+  ${chalk22.cyan("$ leetcode stat -s")}                 Topic-wise breakdown
+  ${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.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
+${chalk22.yellow("Actions:")}
+  ${chalk22.cyan("add <id>")}      Bookmark a problem
+  ${chalk22.cyan("remove <id>")}   Remove a bookmark
+  ${chalk22.cyan("list")}          List all bookmarks
+  ${chalk22.cyan("clear")}         Clear all bookmarks
+
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode bookmark add 1")}          Bookmark problem 1
+  ${chalk22.cyan("$ leetcode bookmark remove 1")}       Remove bookmark
+  ${chalk22.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
+${chalk22.yellow("Actions:")}
+  ${chalk22.cyan("edit")}   Open notes in editor (default)
+  ${chalk22.cyan("view")}   Display notes in terminal
+
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode note 1")}                  Edit notes for problem 1
+  ${chalk22.cyan("$ leetcode note 1 edit")}             Edit notes (explicit)
+  ${chalk22.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
+${chalk22.yellow("Examples:")}
+  ${chalk22.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")}
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode config")}                  View current config
+  ${chalk22.cyan("$ leetcode config -l python3")}       Set language to Python
+  ${chalk22.cyan('$ leetcode config -e "code"')}        Set editor to VS Code
+  ${chalk22.cyan("$ leetcode config -w ~/leetcode")}    Set solutions folder
+  ${chalk22.cyan("$ leetcode config -r https://...")}   Set git repository
+  ${chalk22.cyan("$ leetcode config -i")}               Interactive setup
+
+${chalk22.gray("Supported languages: typescript, javascript, python3, java, cpp, c, csharp, go, rust, kotlin, swift")}
 `).action(async (options) => {
   if (options.interactive) {
     await configInteractiveCommand();
@@ -2539,12 +3139,45 @@ ${chalk20.gray("Supported languages: typescript, javascript, python3, java, cpp,
     await configCommand(options);
   }
 });
+program.command("timer [id]").description("Start interview mode with timer").option("-m, --minutes <minutes>", "Custom time limit in minutes").option("--stats", "Show solve time statistics").option("--stop", "Stop active timer").addHelpText("after", `
+${chalk22.yellow("How it works:")}
+  Start a problem with a countdown timer to simulate interview conditions.
+  Default time limits: Easy (20 min), Medium (40 min), Hard (60 min).
+  Your solve times are recorded when you submit successfully.
+
+${chalk22.yellow("Examples:")}
+  ${chalk22.cyan("$ leetcode timer 1")}                  Start problem 1 with default time
+  ${chalk22.cyan("$ leetcode timer 1 -m 30")}            Start with 30 minute limit
+  ${chalk22.cyan("$ leetcode timer --stats")}            Show your solve time statistics
+  ${chalk22.cyan("$ leetcode timer --stop")}             Stop active timer
+`).action((id, options) => timerCommand(id, options));
+var collabCmd = program.command("collab").description("Collaborative coding with a partner").addHelpText("after", `
+${chalk22.yellow("Subcommands:")}
+  ${chalk22.cyan("host <id>")}      Create a room and get a code to share
+  ${chalk22.cyan("join <code>")}    Join a room with the shared code
+  ${chalk22.cyan("sync")}           Upload your solution to the room
+  ${chalk22.cyan("compare")}        View both solutions side by side
+  ${chalk22.cyan("status")}         Check room and sync status
+  ${chalk22.cyan("leave")}          End the collaboration session
+
+${chalk22.yellow("Examples:")}
+  ${chalk22.gray("$ leetcode collab host 1")}       Start a session for Two Sum
+  ${chalk22.gray("$ leetcode collab join ABC123")} Join your partner's session
+  ${chalk22.gray("$ leetcode collab sync")}        Upload your code after solving
+  ${chalk22.gray("$ leetcode collab compare")}     Compare solutions
+`);
+collabCmd.command("host <problemId>").description("Host a collaboration session").action(collabHostCommand);
+collabCmd.command("join <roomCode>").description("Join a collaboration session").action(collabJoinCommand);
+collabCmd.command("sync").description("Sync your code with partner").action(collabSyncCommand);
+collabCmd.command("compare").description("Compare your solution with partner").action(collabCompareCommand);
+collabCmd.command("leave").description("Leave the collaboration session").action(collabLeaveCommand);
+collabCmd.command("status").description("Show collaboration status").action(collabStatusCommand);
 program.showHelpAfterError("(add --help for additional information)");
 program.parse();
 if (!process.argv.slice(2).length) {
   console.log();
-  console.log(chalk20.bold.cyan("  \u{1F525} LeetCode CLI"));
-  console.log(chalk20.gray("  A modern command-line interface for LeetCode"));
+  console.log(chalk22.bold.cyan("  \u{1F525} LeetCode CLI"));
+  console.log(chalk22.gray("  A modern command-line interface for LeetCode"));
   console.log();
   program.outputHelp();
 }