@night-slayer18/leetcode-cli 1.5.0 → 2.0.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk21 from "chalk";
+import chalk26 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);
-  },
-  clearCredentials() {
-    configStore.delete("credentials");
-  },
-  // User Config
-  getConfig() {
-    return configStore.get("config");
-  },
-  setLanguage(language) {
-    configStore.set("config.language", language);
+var credentials = {
+  get() {
+    const session = credentialsStore.get("session");
+    const csrfToken = credentialsStore.get("csrfToken");
+    if (!session || !csrfToken) return null;
+    return { session, csrfToken };
   },
-  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");
+  set(creds) {
+    credentialsStore.set("session", creds.session);
+    credentialsStore.set("csrfToken", creds.csrfToken);
   },
-  // 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");
@@ -628,18 +571,18 @@ async function whoamiCommand() {
 
 // src/commands/list.ts
 import ora2 from "ora";
-import chalk4 from "chalk";
+import chalk5 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"));
@@ -653,16 +596,227 @@ async function requireAuth() {
 }
 
 // src/utils/display.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import Table from "cli-table3";
+
+// src/utils/visualize.ts
+import chalk3 from "chalk";
+var TAG_VISUALIZATION = {
+  "Linked List": "linkedlist",
+  "Doubly-Linked List": "linkedlist",
+  "Tree": "tree",
+  "Binary Tree": "tree",
+  "Binary Search Tree": "tree",
+  "Trie": "tree",
+  "Segment Tree": "tree",
+  "Binary Indexed Tree": "tree",
+  "Graph": "graph",
+  "Matrix": "matrix",
+  "Array": "array",
+  "Hash Table": "array",
+  "Stack": "array",
+  "Queue": "array",
+  "Monotonic Stack": "array",
+  "Monotonic Queue": "array",
+  "Heap (Priority Queue)": "array",
+  "String": "string"
+};
+function detectVisualizationType(tags) {
+  for (const tag of tags) {
+    const vizType = TAG_VISUALIZATION[tag.name];
+    if (vizType) return vizType;
+  }
+  return null;
+}
+function parseValue(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function isMatrix(value) {
+  return Array.isArray(value) && value.length > 0 && Array.isArray(value[0]);
+}
+function visualizeArray(arr, expected) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return String(arr);
+  }
+  const maxLen = Math.max(...arr.map((v) => String(v).length), 1);
+  const cellWidth = Math.max(maxLen, 3);
+  const indices = arr.map((_, i) => `[${i}]`.padStart(cellWidth).padEnd(cellWidth)).join(" ");
+  const values = arr.map((v, i) => {
+    const valStr = String(v).padStart(cellWidth).padEnd(cellWidth);
+    if (expected && Array.isArray(expected) && expected[i] !== v) {
+      return chalk3.red.bold(valStr);
+    }
+    return valStr;
+  }).join(" ");
+  return `${chalk3.gray(indices)}
+${values}`;
+}
+function visualizeLinkedList(arr, expected) {
+  if (!Array.isArray(arr)) {
+    return String(arr);
+  }
+  if (arr.length === 0) {
+    return chalk3.gray("(empty)");
+  }
+  const parts = arr.map((v, i) => {
+    const valStr = String(v);
+    if (expected && Array.isArray(expected)) {
+      if (i >= expected.length || expected[i] !== v) {
+        return chalk3.red.bold(valStr);
+      }
+    }
+    return valStr;
+  });
+  return parts.join(chalk3.gray(" \u2192 "));
+}
+function visualizeTree(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return chalk3.gray("(empty tree)");
+  }
+  const lines = [];
+  const height = Math.floor(Math.log2(arr.length)) + 1;
+  const maxWidth = Math.pow(2, height) * 3;
+  function renderLevel(level, startIdx, endIdx, indent) {
+    if (startIdx > arr.length - 1) return;
+    const levelNodes = [];
+    const levelBranches = [];
+    const spacing = Math.floor(maxWidth / Math.pow(2, level + 1));
+    for (let i = startIdx; i <= endIdx && i < arr.length; i++) {
+      const val = arr[i];
+      const nodeStr = val === null ? " " : String(val);
+      levelNodes.push(nodeStr.padStart(spacing).padEnd(spacing));
+      const leftChild = 2 * i + 1;
+      const rightChild = 2 * i + 2;
+      const hasLeft = leftChild < arr.length && arr[leftChild] !== null;
+      const hasRight = rightChild < arr.length && arr[rightChild] !== null;
+      if (hasLeft || hasRight) {
+        let branch = "";
+        if (hasLeft) branch += "/";
+        else branch += " ";
+        branch += " ";
+        if (hasRight) branch += "\\";
+        else branch += " ";
+        levelBranches.push(branch.padStart(spacing).padEnd(spacing));
+      }
+    }
+    if (levelNodes.length > 0) {
+      lines.push(levelNodes.join(""));
+      if (levelBranches.length > 0 && level < height - 1) {
+        lines.push(levelBranches.join(""));
+      }
+    }
+  }
+  for (let level = 0; level < height; level++) {
+    const startIdx = Math.pow(2, level) - 1;
+    const endIdx = Math.pow(2, level + 1) - 2;
+    renderLevel(level, startIdx, endIdx, 0);
+  }
+  return lines.join("\n");
+}
+function visualizeMatrix(matrix, expected) {
+  if (!isMatrix(matrix) || matrix.length === 0) {
+    return String(matrix);
+  }
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+  const cellWidth = 3;
+  const lines = [];
+  const colHeaders = "    " + matrix[0].map((_, i) => String(i).padStart(cellWidth).padEnd(cellWidth)).join(" ");
+  lines.push(chalk3.gray(colHeaders));
+  lines.push("    \u250C" + Array(cols).fill("\u2500\u2500\u2500").join("\u252C") + "\u2510");
+  for (let r = 0; r < rows; r++) {
+    const rowContent = matrix[r].map((v, c) => {
+      const valStr = String(v).padStart(2);
+      if (expected && isMatrix(expected) && expected[r] && expected[r][c] !== v) {
+        return chalk3.red.bold(valStr);
+      }
+      return valStr;
+    }).join(" \u2502 ");
+    lines.push(chalk3.gray(`  ${r} `) + `\u2502 ${rowContent} \u2502`);
+    if (r < rows - 1) {
+      lines.push("    \u251C" + Array(cols).fill("\u2500\u2500\u2500").join("\u253C") + "\u2524");
+    } else {
+      lines.push("    \u2514" + Array(cols).fill("\u2500\u2500\u2500").join("\u2534") + "\u2518");
+    }
+  }
+  return lines.join("\n");
+}
+function visualizeGraph(adjList) {
+  if (!isMatrix(adjList)) {
+    return String(adjList);
+  }
+  const lines = adjList.map((neighbors, node) => {
+    const neighborStr = Array.isArray(neighbors) ? neighbors.join(", ") : String(neighbors);
+    return `  ${chalk3.cyan(String(node))} \u2192 [${neighborStr}]`;
+  });
+  return lines.join("\n");
+}
+function visualizeTestOutput(output, expected, tags) {
+  const outputVal = parseValue(output);
+  const expectedVal = parseValue(expected);
+  const matches = output === expected;
+  const vizType = detectVisualizationType(tags);
+  let outputVis;
+  let expectedVis;
+  if (isMatrix(outputVal)) {
+    const expectedMatrix = isMatrix(expectedVal) ? expectedVal : void 0;
+    outputVis = visualizeMatrix(outputVal, expectedMatrix);
+    expectedVis = isMatrix(expectedVal) ? visualizeMatrix(expectedVal) : String(expected);
+    return { outputVis, expectedVis, matches };
+  }
+  if (vizType === null) {
+    return {
+      outputVis: String(output),
+      expectedVis: String(expected),
+      matches,
+      unsupported: true
+    };
+  }
+  switch (vizType) {
+    case "linkedlist":
+      outputVis = visualizeLinkedList(outputVal, expectedVal);
+      expectedVis = visualizeLinkedList(expectedVal);
+      break;
+    case "tree":
+      outputVis = visualizeTree(outputVal);
+      expectedVis = visualizeTree(expectedVal);
+      break;
+    case "graph":
+      outputVis = visualizeGraph(outputVal);
+      expectedVis = visualizeGraph(expectedVal);
+      break;
+    case "matrix":
+      const expMatrix = isMatrix(expectedVal) ? expectedVal : void 0;
+      outputVis = visualizeMatrix(outputVal, expMatrix);
+      expectedVis = isMatrix(expectedVal) ? visualizeMatrix(expectedVal) : String(expected);
+      break;
+    case "array":
+    case "string":
+      if (Array.isArray(outputVal)) {
+        outputVis = visualizeArray(outputVal, expectedVal);
+        expectedVis = Array.isArray(expectedVal) ? visualizeArray(expectedVal) : String(expected);
+      } else {
+        outputVis = matches ? String(output) : chalk3.red.bold(String(output));
+        expectedVis = String(expected);
+      }
+      break;
+  }
+  return { outputVis, expectedVis, matches };
+}
+
+// src/utils/display.ts
 function displayProblemList(problems, total) {
   const table = new Table({
     head: [
-      chalk3.cyan("ID"),
-      chalk3.cyan("Title"),
-      chalk3.cyan("Difficulty"),
-      chalk3.cyan("Rate"),
-      chalk3.cyan("Status")
+      chalk4.cyan("ID"),
+      chalk4.cyan("Title"),
+      chalk4.cyan("Difficulty"),
+      chalk4.cyan("Rate"),
+      chalk4.cyan("Status")
     ],
     colWidths: [8, 45, 12, 10, 10],
     style: { head: [], border: [] }
@@ -681,34 +835,34 @@ function displayProblemList(problems, total) {
     ]);
   }
   console.log(table.toString());
-  console.log(chalk3.gray(`
+  console.log(chalk4.gray(`
 Showing ${problems.length} of ${total} problems`));
 }
 function displayProblemDetail(problem) {
   console.log();
   const titlePrefix = problem.isPaidOnly ? "\u{1F512} " : "";
-  console.log(chalk3.bold.cyan(`  ${problem.questionFrontendId}. ${titlePrefix}${problem.title}`));
+  console.log(chalk4.bold.cyan(`  ${problem.questionFrontendId}. ${titlePrefix}${problem.title}`));
   console.log(`  ${colorDifficulty(problem.difficulty)}`);
-  console.log(chalk3.gray(`  https://leetcode.com/problems/${problem.titleSlug}/`));
+  console.log(chalk4.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(chalk4.yellow("  \u26A0\uFE0F  Premium Problem"));
+    console.log(chalk4.gray("     This problem requires a LeetCode Premium subscription."));
+    console.log(chalk4.gray(`     Visit the URL above to view on LeetCode.`));
     console.log();
   }
   if (problem.topicTags.length) {
-    const tags = problem.topicTags.map((t) => chalk3.bgBlue.white(` ${t.name} `)).join(" ");
+    const tags = problem.topicTags.map((t) => chalk4.bgBlue.white(` ${t.name} `)).join(" ");
     console.log(`  ${tags}`);
     console.log();
   }
-  console.log(chalk3.gray("\u2500".repeat(60)));
+  console.log(chalk4.gray("\u2500".repeat(60)));
   console.log();
   let content = problem.content;
   if (!content) {
-    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(chalk4.yellow("  \u{1F512} Premium Content"));
+    console.log(chalk4.gray("  Problem description is not available directly."));
+    console.log(chalk4.gray("  Please visit the URL above to view on LeetCode."));
     console.log();
     return;
   }
@@ -728,100 +882,128 @@ 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) => 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:"));
+  content = content.replace(/§EXAMPLE§(\d+)§/g, (_, num) => chalk4.green.bold(`\u{1F4CC} Example ${num}:`));
+  content = content.replace(/§INPUT§/g, chalk4.yellow("Input:"));
+  content = content.replace(/§OUTPUT§/g, chalk4.yellow("Output:"));
+  content = content.replace(/§EXPLAIN§/g, chalk4.gray("Explanation:"));
+  content = content.replace(/§CONSTRAINTS§/g, chalk4.cyan.bold("\n\u{1F4CB} Constraints:"));
+  content = content.replace(/§FOLLOWUP§/g, chalk4.magenta.bold("\n\u{1F4A1} Follow-up:"));
   console.log(content);
   console.log();
 }
-function displayTestResult(result) {
+function displayTestResult(result, topicTags) {
   console.log();
   if (result.compile_error) {
-    console.log(chalk3.red.bold("\u274C Compile Error"));
-    console.log(chalk3.red(result.compile_error));
+    console.log(chalk4.red.bold("\u274C Compile Error"));
+    console.log(chalk4.red(result.compile_error));
     return;
   }
   if (result.runtime_error) {
-    console.log(chalk3.red.bold("\u274C Runtime Error"));
-    console.log(chalk3.red(result.runtime_error));
+    console.log(chalk4.red.bold("\u274C Runtime Error"));
+    console.log(chalk4.red(result.runtime_error));
     return;
   }
   if (result.correct_answer) {
-    console.log(chalk3.green.bold("\u2713 All test cases passed!"));
+    console.log(chalk4.green.bold("\u2713 All test cases passed!"));
   } else {
-    console.log(chalk3.yellow.bold("\u2717 Some test cases failed"));
-  }
-  console.log();
-  console.log(chalk3.gray("Your Output:"));
-  for (const output of result.code_answer ?? []) {
-    console.log(chalk3.white(`  ${output}`));
+    console.log(chalk4.yellow.bold("\u2717 Some test cases failed"));
   }
-  console.log();
-  console.log(chalk3.gray("Expected Output:"));
-  for (const output of result.expected_code_answer ?? []) {
-    console.log(chalk3.white(`  ${output}`));
+  const outputs = result.code_answer ?? [];
+  const expected = result.expected_code_answer ?? [];
+  if (topicTags && outputs.length > 0) {
+    console.log();
+    console.log(chalk4.gray.bold("\u2500".repeat(50)));
+    const validCases = outputs.map((out, i) => ({ out, exp: expected[i] ?? "" })).filter(({ out, exp }) => out !== "" || exp !== "");
+    for (let i = 0; i < validCases.length; i++) {
+      const { out, exp } = validCases[i];
+      const { outputVis, expectedVis, matches, unsupported } = visualizeTestOutput(out, exp, topicTags);
+      console.log();
+      console.log(chalk4.gray(`Test Case ${i + 1}:`));
+      if (unsupported) {
+        console.log(chalk4.yellow("  \u26A0 No visualization available for this problem type"));
+        console.log(chalk4.gray(`  Tags: ${topicTags.map((t) => t.name).join(", ")}`));
+      }
+      console.log();
+      console.log(chalk4.cyan("  Your Output:"));
+      outputVis.split("\n").forEach((line) => console.log(`    ${line}`));
+      console.log();
+      console.log(chalk4.cyan("  Expected:"));
+      expectedVis.split("\n").forEach((line) => console.log(`    ${line}`));
+      console.log();
+      console.log(matches ? chalk4.green("  \u2713 Match") : chalk4.red("  \u2717 Mismatch"));
+    }
+    console.log(chalk4.gray.bold("\u2500".repeat(50)));
+  } else {
+    console.log();
+    console.log(chalk4.gray("Your Output:"));
+    for (const output of outputs) {
+      console.log(chalk4.white(`  ${output}`));
+    }
+    console.log();
+    console.log(chalk4.gray("Expected Output:"));
+    for (const output of expected) {
+      console.log(chalk4.white(`  ${output}`));
+    }
   }
-  if (result.std_output_list?.length) {
+  const stdoutEntries = (result.std_output_list ?? []).filter((s) => s);
+  if (stdoutEntries.length > 0) {
     console.log();
-    console.log(chalk3.gray("Stdout:"));
-    for (const output of result.std_output_list) {
-      if (output) console.log(chalk3.gray(`  ${output}`));
+    console.log(chalk4.gray("Stdout:"));
+    for (const output of stdoutEntries) {
+      console.log(chalk4.gray(`  ${output}`));
     }
   }
 }
 function displaySubmissionResult(result) {
   console.log();
   if (result.compile_error) {
-    console.log(chalk3.red.bold("\u274C Compile Error"));
-    console.log(chalk3.red(result.compile_error));
+    console.log(chalk4.red.bold("\u274C Compile Error"));
+    console.log(chalk4.red(result.compile_error));
     return;
   }
   if (result.runtime_error) {
-    console.log(chalk3.red.bold("\u274C Runtime Error"));
-    console.log(chalk3.red(result.runtime_error));
+    console.log(chalk4.red.bold("\u274C Runtime Error"));
+    console.log(chalk4.red(result.runtime_error));
     if (result.last_testcase) {
-      console.log(chalk3.gray("Last testcase:"), result.last_testcase);
+      console.log(chalk4.gray("Last testcase:"), result.last_testcase);
     }
     return;
   }
   if (result.status_msg === "Accepted") {
-    console.log(chalk3.green.bold("\u2713 Accepted!"));
+    console.log(chalk4.green.bold("\u2713 Accepted!"));
     console.log();
     console.log(
-      chalk3.gray("Runtime:"),
-      chalk3.white(result.status_runtime),
-      chalk3.gray(`(beats ${result.runtime_percentile?.toFixed(1) ?? "N/A"}%)`)
+      chalk4.gray("Runtime:"),
+      chalk4.white(result.status_runtime),
+      chalk4.gray(`(beats ${result.runtime_percentile?.toFixed(1) ?? "N/A"}%)`)
     );
     console.log(
-      chalk3.gray("Memory:"),
-      chalk3.white(result.status_memory),
-      chalk3.gray(`(beats ${result.memory_percentile?.toFixed(1) ?? "N/A"}%)`)
+      chalk4.gray("Memory:"),
+      chalk4.white(result.status_memory),
+      chalk4.gray(`(beats ${result.memory_percentile?.toFixed(1) ?? "N/A"}%)`)
     );
   } else {
-    console.log(chalk3.red.bold(`\u274C ${result.status_msg}`));
+    console.log(chalk4.red.bold(`\u274C ${result.status_msg}`));
     console.log();
-    console.log(chalk3.gray(`Passed ${result.total_correct}/${result.total_testcases} testcases`));
+    console.log(chalk4.gray(`Passed ${result.total_correct}/${result.total_testcases} testcases`));
     if (result.code_output) {
-      console.log(chalk3.gray("Your Output:"), result.code_output);
+      console.log(chalk4.gray("Your Output:"), result.code_output);
     }
     if (result.expected_output) {
-      console.log(chalk3.gray("Expected:"), result.expected_output);
+      console.log(chalk4.gray("Expected:"), result.expected_output);
     }
     if (result.last_testcase) {
-      console.log(chalk3.gray("Failed testcase:"), result.last_testcase);
+      console.log(chalk4.gray("Failed testcase:"), result.last_testcase);
     }
   }
 }
 function displayUserStats(username, realName, ranking, acStats, streak, totalActiveDays) {
   console.log();
-  console.log(chalk3.bold.white(`\u{1F464} ${username}`) + (realName ? chalk3.gray(` (${realName})`) : ""));
-  console.log(chalk3.gray(`Ranking: #${ranking.toLocaleString()}`));
+  console.log(chalk4.bold.white(`\u{1F464} ${username}`) + (realName ? chalk4.gray(` (${realName})`) : ""));
+  console.log(chalk4.gray(`Ranking: #${ranking.toLocaleString()}`));
   console.log();
   const table = new Table({
-    head: [chalk3.cyan("Difficulty"), chalk3.cyan("Solved")],
+    head: [chalk4.cyan("Difficulty"), chalk4.cyan("Solved")],
     style: { head: [], border: [] }
   });
   for (const stat of acStats) {
@@ -833,33 +1015,33 @@ function displayUserStats(username, realName, ranking, acStats, streak, totalAct
     }
   }
   const total = acStats.find((s) => s.difficulty === "All")?.count ?? 0;
-  table.push([chalk3.white.bold("Total"), chalk3.white.bold(total.toString())]);
+  table.push([chalk4.white.bold("Total"), chalk4.white.bold(total.toString())]);
   console.log(table.toString());
   console.log();
-  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()));
+  console.log(chalk4.gray("\u{1F525} Current streak:"), chalk4.hex("#FFA500")(streak.toString()), chalk4.gray("days"));
+  console.log(chalk4.gray("\u{1F4C5} Total active days:"), chalk4.white(totalActiveDays.toString()));
 }
 function displayDailyChallenge(date, problem) {
   console.log();
-  console.log(chalk3.bold.yellow("\u{1F3AF} Daily Challenge"), chalk3.gray(`(${date})`));
+  console.log(chalk4.bold.yellow("\u{1F3AF} Daily Challenge"), chalk4.gray(`(${date})`));
   console.log();
-  console.log(chalk3.white(`${problem.questionFrontendId}. ${problem.title}`));
+  console.log(chalk4.white(`${problem.questionFrontendId}. ${problem.title}`));
   console.log(colorDifficulty(problem.difficulty));
-  console.log(chalk3.gray(`https://leetcode.com/problems/${problem.titleSlug}/`));
+  console.log(chalk4.gray(`https://leetcode.com/problems/${problem.titleSlug}/`));
   if (problem.topicTags.length) {
     console.log();
-    const tags = problem.topicTags.map((t) => chalk3.blue(t.name)).join(" ");
-    console.log(chalk3.gray("Tags:"), tags);
+    const tags = problem.topicTags.map((t) => chalk4.blue(t.name)).join(" ");
+    console.log(chalk4.gray("Tags:"), tags);
   }
 }
 function colorDifficulty(difficulty) {
   switch (difficulty.toLowerCase()) {
     case "easy":
-      return chalk3.green(difficulty);
+      return chalk4.green(difficulty);
     case "medium":
-      return chalk3.yellow(difficulty);
+      return chalk4.yellow(difficulty);
     case "hard":
-      return chalk3.red(difficulty);
+      return chalk4.red(difficulty);
     default:
       return difficulty;
   }
@@ -867,22 +1049,22 @@ function colorDifficulty(difficulty) {
 function formatStatus(status) {
   switch (status) {
     case "ac":
-      return chalk3.green("\u2713");
+      return chalk4.green("\u2713");
     case "notac":
-      return chalk3.yellow("\u25CB");
+      return chalk4.yellow("\u25CB");
     default:
-      return chalk3.gray("-");
+      return chalk4.gray("-");
   }
 }
 function displaySubmissionsList(submissions) {
   const table = new Table({
     head: [
-      chalk3.cyan("ID"),
-      chalk3.cyan("Status"),
-      chalk3.cyan("Lang"),
-      chalk3.cyan("Runtime"),
-      chalk3.cyan("Memory"),
-      chalk3.cyan("Date")
+      chalk4.cyan("ID"),
+      chalk4.cyan("Status"),
+      chalk4.cyan("Lang"),
+      chalk4.cyan("Runtime"),
+      chalk4.cyan("Memory"),
+      chalk4.cyan("Date")
     ],
     colWidths: [12, 18, 15, 12, 12, 25],
     style: { head: [], border: [] }
@@ -892,7 +1074,7 @@ function displaySubmissionsList(submissions) {
     const cleanTime = new Date(parseInt(s.timestamp) * 1e3).toLocaleString();
     table.push([
       s.id,
-      isAC ? chalk3.green(s.statusDisplay) : chalk3.red(s.statusDisplay),
+      isAC ? chalk4.green(s.statusDisplay) : chalk4.red(s.statusDisplay),
       s.lang,
       s.runtime,
       s.memory,
@@ -943,25 +1125,25 @@ async function listCommand(options) {
     const { total, problems } = await leetcodeClient.getProblems(filters);
     spinner.stop();
     if (problems.length === 0) {
-      console.log(chalk4.yellow("No problems found matching your criteria."));
+      console.log(chalk5.yellow("No problems found matching your criteria."));
       return;
     }
     displayProblemList(problems, total);
     if (page * limit < total) {
-      console.log(chalk4.gray(`
+      console.log(chalk5.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(chalk4.red(error.message));
+      console.log(chalk5.red(error.message));
     }
   }
 }
 
 // src/commands/show.ts
 import ora3 from "ora";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 async function showCommand(idOrSlug) {
   const { authorized } = await requireAuth();
   if (!authorized) return;
@@ -982,17 +1164,229 @@ async function showCommand(idOrSlug) {
   } catch (error) {
     spinner.fail("Failed to fetch problem");
     if (error instanceof Error) {
-      console.log(chalk5.red(error.message));
+      console.log(chalk6.red(error.message));
     }
   }
 }
 
 // src/commands/pick.ts
 import { writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
 import ora4 from "ora";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
+
+// src/storage/config.ts
+import { join as join3 } from "path";
+
+// src/storage/workspaces.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var LEETCODE_DIR = join2(homedir2(), ".leetcode");
+var WORKSPACES_FILE = join2(LEETCODE_DIR, "workspaces.json");
+var WORKSPACES_DIR = join2(LEETCODE_DIR, "workspaces");
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function loadRegistry() {
+  if (existsSync(WORKSPACES_FILE)) {
+    return JSON.parse(readFileSync(WORKSPACES_FILE, "utf-8"));
+  }
+  return { active: "default", workspaces: [] };
+}
+function saveRegistry(registry) {
+  ensureDir(LEETCODE_DIR);
+  writeFileSync(WORKSPACES_FILE, JSON.stringify(registry, null, 2));
+}
+var workspaceStorage = {
+  /**
+   * Initialize workspaces on first run - migrate existing config to "default" workspace
+   */
+  ensureInitialized() {
+    const registry = loadRegistry();
+    if (registry.workspaces.length === 0) {
+      this.create("default", {
+        workDir: join2(homedir2(), "leetcode"),
+        lang: "typescript"
+      });
+      registry.workspaces = ["default"];
+      registry.active = "default";
+      saveRegistry(registry);
+    }
+  },
+  /**
+   * Get the currently active workspace name
+   */
+  getActive() {
+    this.ensureInitialized();
+    return loadRegistry().active;
+  },
+  /**
+   * Set the active workspace
+   */
+  setActive(name) {
+    const registry = loadRegistry();
+    if (!registry.workspaces.includes(name)) {
+      return false;
+    }
+    registry.active = name;
+    saveRegistry(registry);
+    return true;
+  },
+  /**
+   * List all workspace names
+   */
+  list() {
+    this.ensureInitialized();
+    return loadRegistry().workspaces;
+  },
+  /**
+   * Check if a workspace exists
+   */
+  exists(name) {
+    this.ensureInitialized();
+    return loadRegistry().workspaces.includes(name);
+  },
+  /**
+   * Create a new workspace
+   */
+  create(name, config2) {
+    const registry = loadRegistry();
+    if (registry.workspaces.includes(name)) {
+      return false;
+    }
+    const wsDir = join2(WORKSPACES_DIR, name);
+    ensureDir(wsDir);
+    ensureDir(join2(wsDir, "snapshots"));
+    const configPath = join2(wsDir, "config.json");
+    writeFileSync(configPath, JSON.stringify(config2, null, 2));
+    writeFileSync(join2(wsDir, "timer.json"), JSON.stringify({ solveTimes: {}, activeTimer: null }, null, 2));
+    writeFileSync(join2(wsDir, "collab.json"), JSON.stringify({ session: null }, null, 2));
+    registry.workspaces.push(name);
+    saveRegistry(registry);
+    return true;
+  },
+  /**
+   * Delete a workspace
+   */
+  delete(name) {
+    if (name === "default") {
+      return false;
+    }
+    const registry = loadRegistry();
+    if (!registry.workspaces.includes(name)) {
+      return false;
+    }
+    registry.workspaces = registry.workspaces.filter((w) => w !== name);
+    if (registry.active === name) {
+      registry.active = "default";
+    }
+    saveRegistry(registry);
+    return true;
+  },
+  /**
+   * Get the directory path for a workspace
+   */
+  getWorkspaceDir(name) {
+    const wsName = name ?? this.getActive();
+    return join2(WORKSPACES_DIR, wsName);
+  },
+  /**
+   * Get config for a workspace
+   */
+  getConfig(name) {
+    const wsName = name ?? this.getActive();
+    const configPath = join2(WORKSPACES_DIR, wsName, "config.json");
+    if (existsSync(configPath)) {
+      return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    return {
+      workDir: join2(homedir2(), "leetcode"),
+      lang: "typescript"
+    };
+  },
+  /**
+   * Update config for a workspace
+   */
+  setConfig(config2, name) {
+    const wsName = name ?? this.getActive();
+    const wsDir = join2(WORKSPACES_DIR, wsName);
+    ensureDir(wsDir);
+    const currentConfig = this.getConfig(wsName);
+    const newConfig = { ...currentConfig, ...config2 };
+    writeFileSync(join2(wsDir, "config.json"), JSON.stringify(newConfig, null, 2));
+  },
+  /**
+   * Get snapshots directory for active workspace
+   */
+  getSnapshotsDir() {
+    return join2(this.getWorkspaceDir(), "snapshots");
+  },
+  /**
+   * Get timer file path for active workspace
+   */
+  getTimerPath() {
+    return join2(this.getWorkspaceDir(), "timer.json");
+  },
+  /**
+   * Get collab file path for active workspace
+   */
+  getCollabPath() {
+    return join2(this.getWorkspaceDir(), "collab.json");
+  }
+};
+
+// src/storage/config.ts
+var config = {
+  getConfig() {
+    const wsConfig = workspaceStorage.getConfig();
+    return {
+      language: wsConfig.lang,
+      editor: wsConfig.editor,
+      workDir: wsConfig.workDir,
+      repo: wsConfig.syncRepo
+    };
+  },
+  setLanguage(language) {
+    workspaceStorage.setConfig({ lang: language });
+  },
+  setEditor(editor) {
+    workspaceStorage.setConfig({ editor });
+  },
+  setWorkDir(workDir) {
+    workspaceStorage.setConfig({ workDir });
+  },
+  setRepo(repo) {
+    workspaceStorage.setConfig({ syncRepo: repo });
+  },
+  deleteRepo() {
+    const wsConfig = workspaceStorage.getConfig();
+    delete wsConfig.syncRepo;
+    workspaceStorage.setConfig(wsConfig);
+  },
+  getLanguage() {
+    return workspaceStorage.getConfig().lang;
+  },
+  getEditor() {
+    return workspaceStorage.getConfig().editor;
+  },
+  getWorkDir() {
+    return workspaceStorage.getConfig().workDir;
+  },
+  getRepo() {
+    return workspaceStorage.getConfig().syncRepo;
+  },
+  getPath() {
+    return join3(workspaceStorage.getWorkspaceDir(), "config.json");
+  },
+  // New workspace-aware methods
+  getActiveWorkspace() {
+    return workspaceStorage.getActive();
+  }
+};
 
 // src/utils/templates.ts
 var LANGUAGE_EXTENSIONS = {
@@ -1116,7 +1510,7 @@ function getSolutionFileName(problemId, titleSlug, language) {
 // src/utils/editor.ts
 import { spawn } from "child_process";
 import open from "open";
-import chalk6 from "chalk";
+import chalk7 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) {
@@ -1124,7 +1518,7 @@ async function openInEditor(filePath, workDir) {
   const workspace = workDir ?? config.getWorkDir();
   if (TERMINAL_EDITORS.includes(editor)) {
     console.log();
-    console.log(chalk6.gray(`Open with: ${editor} ${filePath}`));
+    console.log(chalk7.gray(`Open with: ${editor} ${filePath}`));
     return;
   }
   try {
@@ -1164,13 +1558,13 @@ async function pickCommand(idOrSlug, options) {
     const template = getCodeTemplate(snippets, language);
     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..."));
+      spinner.warn(chalk8.yellow("Premium Problem (No code snippets available)"));
+      console.log(chalk8.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}`);
-      console.log(chalk7.gray(`Available languages: ${snippets.map((s) => s.langSlug).join(", ")}`));
+      console.log(chalk8.gray(`Available languages: ${snippets.map((s) => s.langSlug).join(", ")}`));
       return false;
     } else {
       code = template.code;
@@ -1187,26 +1581,26 @@ 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);
-    if (!existsSync(targetDir)) {
+    const targetDir = join4(workDir, difficulty, category);
+    if (!existsSync2(targetDir)) {
       await mkdir(targetDir, { recursive: true });
     }
     const fileName = getSolutionFileName(problem.questionFrontendId, problem.titleSlug, language);
-    const filePath = join2(targetDir, fileName);
-    if (existsSync(filePath)) {
+    const filePath = join4(targetDir, fileName);
+    if (existsSync2(filePath)) {
       spinner.warn(`File already exists: ${fileName}`);
-      console.log(chalk7.gray(`Path: ${filePath}`));
+      console.log(chalk8.gray(`Path: ${filePath}`));
       if (options.open !== false) {
         await openInEditor(filePath);
       }
       return true;
     }
     await writeFile(filePath, content, "utf-8");
-    spinner.succeed(`Created ${chalk7.green(fileName)}`);
-    console.log(chalk7.gray(`Path: ${filePath}`));
+    spinner.succeed(`Created ${chalk8.green(fileName)}`);
+    console.log(chalk8.gray(`Path: ${filePath}`));
     console.log();
-    console.log(chalk7.cyan(`${problem.questionFrontendId}. ${problem.title}`));
-    console.log(chalk7.gray(`Difficulty: ${problem.difficulty} | Category: ${category}`));
+    console.log(chalk8.cyan(`${problem.questionFrontendId}. ${problem.title}`));
+    console.log(chalk8.gray(`Difficulty: ${problem.difficulty} | Category: ${category}`));
     if (options.open !== false) {
       await openInEditor(filePath);
     }
@@ -1215,17 +1609,17 @@ async function pickCommand(idOrSlug, options) {
     spinner.fail("Failed to fetch problem");
     if (error instanceof Error) {
       if (error.message.includes("expected object, received null")) {
-        console.log(chalk7.red(`Problem "${idOrSlug}" not found`));
+        console.log(chalk8.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"));
+            console.log(chalk8.red("API Response Validation Failed"));
           } else {
-            console.log(chalk7.red(error.message));
+            console.log(chalk8.red(error.message));
           }
         } catch {
-          console.log(chalk7.red(error.message));
+          console.log(chalk8.red(error.message));
         }
       }
     }
@@ -1234,12 +1628,12 @@ async function pickCommand(idOrSlug, options) {
 }
 async function batchPickCommand(ids, options) {
   if (ids.length === 0) {
-    console.log(chalk7.yellow("Please provide at least one problem ID"));
+    console.log(chalk8.yellow("Please provide at least one problem ID"));
     return;
   }
   const { authorized } = await requireAuth();
   if (!authorized) return;
-  console.log(chalk7.cyan(`\u{1F4E6} Picking ${ids.length} problem${ids.length !== 1 ? "s" : ""}...`));
+  console.log(chalk8.cyan(`\u{1F4E6} Picking ${ids.length} problem${ids.length !== 1 ? "s" : ""}...`));
   console.log();
   console.log();
   let succeeded = 0;
@@ -1253,33 +1647,33 @@ async function batchPickCommand(ids, options) {
     }
     console.log();
   }
-  console.log(chalk7.gray("\u2500".repeat(50)));
+  console.log(chalk8.gray("\u2500".repeat(50)));
   console.log(
-    chalk7.bold(
-      `Done! ${chalk7.green(`${succeeded} succeeded`)}${failed > 0 ? `, ${chalk7.red(`${failed} failed`)}` : ""}`
+    chalk8.bold(
+      `Done! ${chalk8.green(`${succeeded} succeeded`)}${failed > 0 ? `, ${chalk8.red(`${failed} failed`)}` : ""}`
     )
   );
 }
 
 // src/commands/test.ts
 import { readFile } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { basename } from "path";
 import ora5 from "ora";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/utils/fileUtils.ts
 import { readdir } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
 var MAX_SEARCH_DEPTH = 5;
 async function findSolutionFile(dir, problemId, currentDepth = 0) {
-  if (!existsSync2(dir)) return null;
+  if (!existsSync3(dir)) return null;
   if (currentDepth >= MAX_SEARCH_DEPTH) return null;
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const fullPath = join3(dir, entry.name);
+    const fullPath = join5(dir, entry.name);
     if (entry.isDirectory()) {
       const found = await findSolutionFile(fullPath, problemId, currentDepth + 1);
       if (found) return found;
@@ -1293,11 +1687,11 @@ async function findSolutionFile(dir, problemId, currentDepth = 0) {
   return null;
 }
 async function findFileByName(dir, fileName, currentDepth = 0) {
-  if (!existsSync2(dir)) return null;
+  if (!existsSync3(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);
+    const fullPath = join5(dir, entry.name);
     if (entry.isDirectory()) {
       const found = await findFileByName(fullPath, fileName, currentDepth + 1);
       if (found) return found;
@@ -1354,26 +1748,26 @@ async function testCommand(fileOrId, options) {
     const workDir = config.getWorkDir();
     const found = await findSolutionFile(workDir, fileOrId);
     if (!found) {
-      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.`));
+      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(chalk8.gray(`Found: ${filePath}`));
+    console.log(chalk9.gray(`Found: ${filePath}`));
   } else if (isFileName(fileOrId)) {
     const workDir = config.getWorkDir();
     const found = await findFileByName(workDir, fileOrId);
     if (!found) {
-      console.log(chalk8.red(`File not found: ${fileOrId}`));
-      console.log(chalk8.gray(`Looking in: ${workDir}`));
+      console.log(chalk9.red(`File not found: ${fileOrId}`));
+      console.log(chalk9.gray(`Looking in: ${workDir}`));
       return;
     }
     filePath = found;
-    console.log(chalk8.gray(`Found: ${filePath}`));
+    console.log(chalk9.gray(`Found: ${filePath}`));
   }
-  if (!existsSync3(filePath)) {
-    console.log(chalk8.red(`File not found: ${filePath}`));
+  if (!existsSync4(filePath)) {
+    console.log(chalk9.red(`File not found: ${filePath}`));
     return;
   }
   const spinner = ora5({ text: "Reading solution file...", spinner: "dots" }).start();
@@ -1382,8 +1776,8 @@ async function testCommand(fileOrId, options) {
     const match = fileName.match(/^(\d+)\.([^.]+)\./);
     if (!match) {
       spinner.fail("Invalid filename format");
-      console.log(chalk8.gray("Expected format: {id}.{title-slug}.{ext}"));
-      console.log(chalk8.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;
@@ -1400,62 +1794,75 @@ async function testCommand(fileOrId, options) {
     spinner.text = "Running tests...";
     const result = await leetcodeClient.testSolution(titleSlug, code, lang, testcases, problem.questionId);
     spinner.stop();
-    displayTestResult(result);
+    displayTestResult(result, options.visualize ? problem.topicTags : void 0);
   } catch (error) {
     spinner.fail("Test failed");
     if (error instanceof Error) {
-      console.log(chalk8.red(error.message));
+      console.log(chalk9.red(error.message));
     }
   }
 }
 
 // src/commands/submit.ts
 import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { basename as basename2 } from "path";
 import ora6 from "ora";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 
 // src/storage/timer.ts
-import Conf2 from "conf";
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
-var timerStore = new Conf2({
-  projectName: "leetcode-cli-timer",
-  cwd: join4(homedir2(), ".leetcode"),
-  defaults: {
-    solveTimes: {},
-    activeTimer: null
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+function getTimerPath() {
+  return workspaceStorage.getTimerPath();
+}
+function loadTimer() {
+  const path = getTimerPath();
+  if (existsSync5(path)) {
+    return JSON.parse(readFileSync2(path, "utf-8"));
   }
-});
+  return { solveTimes: {}, activeTimer: null };
+}
+function saveTimer(data) {
+  const timerPath = getTimerPath();
+  const dir = dirname(timerPath);
+  if (!existsSync5(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(timerPath, JSON.stringify(data, null, 2));
+}
 var timerStorage = {
   startTimer(problemId, title, difficulty, durationMinutes) {
-    timerStore.set("activeTimer", {
+    const data = loadTimer();
+    data.activeTimer = {
       problemId,
       title,
       difficulty,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       durationMinutes
-    });
+    };
+    saveTimer(data);
   },
   getActiveTimer() {
-    return timerStore.get("activeTimer");
+    return loadTimer().activeTimer;
   },
   stopTimer() {
-    const active = timerStore.get("activeTimer");
+    const data = loadTimer();
+    const active = data.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);
+    data.activeTimer = null;
+    saveTimer(data);
     return { durationSeconds };
   },
   recordSolveTime(problemId, title, difficulty, durationSeconds, timerMinutes) {
-    const solveTimes = timerStore.get("solveTimes") ?? {};
-    if (!solveTimes[problemId]) {
-      solveTimes[problemId] = [];
+    const data = loadTimer();
+    if (!data.solveTimes[problemId]) {
+      data.solveTimes[problemId] = [];
     }
-    solveTimes[problemId].push({
+    data.solveTimes[problemId].push({
       problemId,
       title,
       difficulty,
@@ -1463,17 +1870,17 @@ var timerStorage = {
       durationSeconds,
       timerMinutes
     });
-    timerStore.set("solveTimes", solveTimes);
+    saveTimer(data);
   },
   getSolveTimes(problemId) {
-    const solveTimes = timerStore.get("solveTimes") ?? {};
-    return solveTimes[problemId] ?? [];
+    const data = loadTimer();
+    return data.solveTimes[problemId] ?? [];
   },
   getAllSolveTimes() {
-    return timerStore.get("solveTimes") ?? {};
+    return loadTimer().solveTimes ?? {};
   },
   getStats() {
-    const solveTimes = timerStore.get("solveTimes") ?? {};
+    const solveTimes = loadTimer().solveTimes ?? {};
     let totalProblems = 0;
     let totalTime = 0;
     for (const times of Object.values(solveTimes)) {
@@ -1499,26 +1906,26 @@ async function submitCommand(fileOrId) {
     const workDir = config.getWorkDir();
     const found = await findSolutionFile(workDir, fileOrId);
     if (!found) {
-      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.`));
+      console.log(chalk10.red(`No solution file found for problem ${fileOrId}`));
+      console.log(chalk10.gray(`Looking in: ${workDir}`));
+      console.log(chalk10.gray(`Run "leetcode pick ${fileOrId}" first to create a solution file.`));
       return;
     }
     filePath = found;
-    console.log(chalk9.gray(`Found: ${filePath}`));
+    console.log(chalk10.gray(`Found: ${filePath}`));
   } else if (isFileName(fileOrId)) {
     const workDir = config.getWorkDir();
     const found = await findFileByName(workDir, fileOrId);
     if (!found) {
-      console.log(chalk9.red(`File not found: ${fileOrId}`));
-      console.log(chalk9.gray(`Looking in: ${workDir}`));
+      console.log(chalk10.red(`File not found: ${fileOrId}`));
+      console.log(chalk10.gray(`Looking in: ${workDir}`));
       return;
     }
     filePath = found;
-    console.log(chalk9.gray(`Found: ${filePath}`));
+    console.log(chalk10.gray(`Found: ${filePath}`));
   }
-  if (!existsSync4(filePath)) {
-    console.log(chalk9.red(`File not found: ${filePath}`));
+  if (!existsSync6(filePath)) {
+    console.log(chalk10.red(`File not found: ${filePath}`));
     return;
   }
   const spinner = ora6({ text: "Reading solution file...", spinner: "dots" }).start();
@@ -1527,8 +1934,8 @@ async function submitCommand(fileOrId) {
     const match = fileName.match(/^(\d+)\.([^.]+)\./);
     if (!match) {
       spinner.fail("Invalid filename format");
-      console.log(chalk9.gray("Expected format: {id}.{title-slug}.{ext}"));
-      console.log(chalk9.gray("Example: 1.two-sum.ts"));
+      console.log(chalk10.gray("Expected format: {id}.{title-slug}.{ext}"));
+      console.log(chalk10.gray("Example: 1.two-sum.ts"));
       return;
     }
     const [, problemId, titleSlug] = match;
@@ -1567,14 +1974,14 @@ async function submitCommand(fileOrId) {
           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(chalk10.bold("\u23F1\uFE0F  Timer Result:"));
           console.log(
-            `   Solved in ${withinLimit ? chalk9.green(timeStr) : chalk9.yellow(timeStr)} (limit: ${activeTimer.durationMinutes}m)`
+            `   Solved in ${withinLimit ? chalk10.green(timeStr) : chalk10.yellow(timeStr)} (limit: ${activeTimer.durationMinutes}m)`
           );
           if (withinLimit) {
-            console.log(chalk9.green("   \u2713 Within time limit!"));
+            console.log(chalk10.green("   \u2713 Within time limit!"));
           } else {
-            console.log(chalk9.yellow("   \u26A0 Exceeded time limit"));
+            console.log(chalk10.yellow("   \u26A0 Exceeded time limit"));
           }
         }
       }
@@ -1582,17 +1989,17 @@ async function submitCommand(fileOrId) {
   } catch (error) {
     spinner.fail("Submission failed");
     if (error instanceof Error) {
-      console.log(chalk9.red(error.message));
+      console.log(chalk10.red(error.message));
     }
   }
 }
 
 // src/commands/stat.ts
 import ora7 from "ora";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 
 // src/utils/stats-display.ts
-import chalk10 from "chalk";
+import chalk11 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);
@@ -1625,25 +2032,25 @@ function renderHeatmap(calendarJson) {
   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(chalk11.bold("\u{1F4C5} Activity (Last 12 Weeks)"));
+  console.log(chalk11.gray("How many problems you submitted and days you practiced."));
+  console.log(chalk11.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 bar = week.count > 0 ? chalk11.green("\u2588".repeat(Math.min(week.count, 10))).padEnd(10) : chalk11.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(`  ${chalk11.white(weekLabel)} ${bar} ${chalk11.cyan(countStr)} ${chalk11.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(chalk11.gray("\u2500".repeat(50)));
+  console.log(`  ${chalk11.bold.white("Total:")} ${chalk11.cyan.bold(totalSubmissions + " submissions")}, ${chalk11.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)));
+  console.log(chalk11.bold("\u{1F3AF} Skill Breakdown"));
+  console.log(chalk11.gray("\u2500".repeat(45)));
   const renderSection = (title, stats, color) => {
     if (stats.length === 0) return;
     console.log();
@@ -1652,12 +2059,12 @@ function renderSkillStats(fundamental, intermediate, advanced) {
     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)}`);
+      console.log(`    ${chalk11.white(name)} ${bar} ${chalk11.white(stat.problemsSolved)}`);
     }
   };
-  renderSection("Fundamental", fundamental, chalk10.green);
-  renderSection("Intermediate", intermediate, chalk10.yellow);
-  renderSection("Advanced", advanced, chalk10.red);
+  renderSection("Fundamental", fundamental, chalk11.green);
+  renderSection("Intermediate", intermediate, chalk11.yellow);
+  renderSection("Advanced", advanced, chalk11.red);
   console.log();
 }
 function renderTrendChart(calendarJson) {
@@ -1678,15 +2085,15 @@ function renderTrendChart(calendarJson) {
   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(chalk11.bold("\u{1F4C8} Submission Trend (Last 7 Days)"));
+  console.log(chalk11.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 ");
+        line += chalk11.green(" \u2588\u2588 ");
       } else {
         line += "    ";
       }
@@ -1695,10 +2102,10 @@ function renderTrendChart(calendarJson) {
   }
   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("")}`));
+  console.log(chalk11.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(chalk11.white(`  Total: ${total} submissions this week`));
   console.log();
 }
 
@@ -1730,14 +2137,14 @@ async function statCommand(username, options = {}) {
       if (profile.submissionCalendar) {
         renderHeatmap(profile.submissionCalendar);
       } else {
-        console.log(chalk11.yellow("Calendar data not available."));
+        console.log(chalk12.yellow("Calendar data not available."));
       }
     }
     if (options.trend) {
       if (profile.submissionCalendar) {
         renderTrendChart(profile.submissionCalendar);
       } else {
-        console.log(chalk11.yellow("Calendar data not available."));
+        console.log(chalk12.yellow("Calendar data not available."));
       }
     }
     if (options.skills) {
@@ -1749,14 +2156,14 @@ async function statCommand(username, options = {}) {
   } catch (error) {
     spinner.fail("Failed to fetch statistics");
     if (error instanceof Error) {
-      console.log(chalk11.red(error.message));
+      console.log(chalk12.red(error.message));
     }
   }
 }
 
 // src/commands/daily.ts
 import ora8 from "ora";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 async function dailyCommand() {
   const { authorized } = await requireAuth();
   if (!authorized) return;
@@ -1766,19 +2173,19 @@ async function dailyCommand() {
     spinner.stop();
     displayDailyChallenge(daily.date, daily.question);
     console.log();
-    console.log(chalk12.gray("Run the following to start working on this problem:"));
-    console.log(chalk12.cyan(`  leetcode pick ${daily.question.titleSlug}`));
+    console.log(chalk13.gray("Run the following to start working on this problem:"));
+    console.log(chalk13.cyan(`  leetcode pick ${daily.question.titleSlug}`));
   } catch (error) {
     spinner.fail("Failed to fetch daily challenge");
     if (error instanceof Error) {
-      console.log(chalk12.red(error.message));
+      console.log(chalk13.red(error.message));
     }
   }
 }
 
 // src/commands/random.ts
 import ora9 from "ora";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 async function randomCommand(options) {
   const { authorized } = await requireAuth();
   if (!authorized) return;
@@ -1812,23 +2219,23 @@ async function randomCommand(options) {
       await pickCommand(titleSlug, { open: options.open ?? true });
     } else {
       await showCommand(titleSlug);
-      console.log(chalk13.gray("Run following to start solving:"));
-      console.log(chalk13.cyan(`  leetcode pick ${titleSlug}`));
+      console.log(chalk14.gray("Run following to start solving:"));
+      console.log(chalk14.cyan(`  leetcode pick ${titleSlug}`));
     }
   } catch (error) {
     spinner.fail("Failed to fetch random problem");
     if (error instanceof Error) {
-      console.log(chalk13.red(error.message));
+      console.log(chalk14.red(error.message));
     }
   }
 }
 
 // src/commands/submissions.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join6 } from "path";
 import ora10 from "ora";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 async function submissionsCommand(idOrSlug, options) {
   const { authorized } = await requireAuth();
   if (!authorized) return;
@@ -1850,16 +2257,16 @@ async function submissionsCommand(idOrSlug, options) {
     const submissions = await leetcodeClient.getSubmissionList(slug, limit);
     spinner.stop();
     if (submissions.length === 0) {
-      console.log(chalk14.yellow("No submissions found."));
+      console.log(chalk15.yellow("No submissions found."));
       return;
     }
     if (options.last) {
       const lastAC = submissions.find((s) => s.statusDisplay === "Accepted");
       if (lastAC) {
-        console.log(chalk14.bold("Last Accepted Submission:"));
+        console.log(chalk15.bold("Last Accepted Submission:"));
         displaySubmissionsList([lastAC]);
       } else {
-        console.log(chalk14.yellow("No accepted submissions found in recent history."));
+        console.log(chalk15.yellow("No accepted submissions found in recent history."));
       }
     } else {
       displaySubmissionsList(submissions);
@@ -1880,30 +2287,30 @@ 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 = join5(workDir, difficulty, category);
-      if (!existsSync5(targetDir)) {
+      const targetDir = join6(workDir, difficulty, category);
+      if (!existsSync7(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 = join6(targetDir, fileName);
       await writeFile2(filePath, details.code, "utf-8");
-      downloadSpinner.succeed(`Downloaded to ${chalk14.green(fileName)}`);
-      console.log(chalk14.gray(`Path: ${filePath}`));
+      downloadSpinner.succeed(`Downloaded to ${chalk15.green(fileName)}`);
+      console.log(chalk15.gray(`Path: ${filePath}`));
     }
   } catch (error) {
     spinner.fail("Failed to fetch submissions");
     if (error instanceof Error) {
-      console.log(chalk14.red(error.message));
+      console.log(chalk15.red(error.message));
     }
   }
 }
 
 // src/commands/config.ts
 import inquirer2 from "inquirer";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 var SUPPORTED_LANGUAGES = [
   "typescript",
   "javascript",
@@ -1925,34 +2332,38 @@ async function configCommand(options) {
   if (options.lang) {
     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(", ")}`));
+      console.log(chalk16.red(`Unsupported language: ${options.lang}`));
+      console.log(chalk16.gray(`Supported: ${SUPPORTED_LANGUAGES.join(", ")}`));
       return;
     }
     const lang = langInput;
     config.setLanguage(lang);
-    console.log(chalk15.green(`\u2713 Default language set to ${lang}`));
+    console.log(chalk16.green(`\u2713 Default language set to ${lang}`));
   }
   if (options.editor) {
     config.setEditor(options.editor);
-    console.log(chalk15.green(`\u2713 Editor set to ${options.editor}`));
+    console.log(chalk16.green(`\u2713 Editor set to ${options.editor}`));
   }
   if (options.workdir) {
     config.setWorkDir(options.workdir);
-    console.log(chalk15.green(`\u2713 Work directory set to ${options.workdir}`));
+    console.log(chalk16.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"));
+      console.log(chalk16.green("\u2713 Repository URL cleared"));
     } else {
       config.setRepo(options.repo);
-      console.log(chalk15.green(`\u2713 Repository URL set to ${options.repo}`));
+      console.log(chalk16.green(`\u2713 Repository URL set to ${options.repo}`));
     }
   }
 }
 async function configInteractiveCommand() {
   const currentConfig = config.getConfig();
+  const workspace = config.getActiveWorkspace();
+  console.log();
+  console.log(chalk16.bold.cyan(`\u{1F4C1} Configuring workspace: ${workspace}`));
+  console.log(chalk16.gray("\u2500".repeat(40)));
   const answers = await inquirer2.prompt([
     {
       type: "list",
@@ -1989,33 +2400,34 @@ async function configInteractiveCommand() {
     config.deleteRepo();
   }
   console.log();
-  console.log(chalk15.green("\u2713 Configuration saved"));
+  console.log(chalk16.green("\u2713 Configuration saved"));
   showCurrentConfig();
 }
 function showCurrentConfig() {
   const currentConfig = config.getConfig();
-  const credentials = config.getCredentials();
+  const creds = credentials.get();
+  const workspace = config.getActiveWorkspace();
   console.log();
-  console.log(chalk15.bold("LeetCode CLI Configuration"));
-  console.log(chalk15.gray("\u2500".repeat(40)));
+  console.log(chalk16.bold.cyan(`\u{1F4C1} Workspace: ${workspace}`));
+  console.log(chalk16.gray("\u2500".repeat(40)));
   console.log();
-  console.log(chalk15.gray("Config file:"), config.getPath());
+  console.log(chalk16.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"));
+  console.log(chalk16.gray("Language:    "), chalk16.white(currentConfig.language));
+  console.log(chalk16.gray("Editor:      "), chalk16.white(currentConfig.editor ?? "(not set)"));
+  console.log(chalk16.gray("Work Dir:    "), chalk16.white(currentConfig.workDir));
+  console.log(chalk16.gray("Repo URL:    "), chalk16.white(currentConfig.repo ?? "(not set)"));
+  console.log(chalk16.gray("Logged in:   "), creds ? chalk16.green("Yes") : chalk16.yellow("No"));
 }
 
 // src/commands/bookmark.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 import Table2 from "cli-table3";
 import ora11 from "ora";
 
 // src/storage/bookmarks.ts
-import Conf3 from "conf";
-var bookmarksStore = new Conf3({
+import Conf2 from "conf";
+var bookmarksStore = new Conf2({
   projectName: "leetcode-cli-bookmarks",
   defaults: { bookmarks: [] }
 });
@@ -2054,36 +2466,36 @@ var bookmarks = {
 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"));
+    console.log(chalk17.red(`Invalid action: ${action}`));
+    console.log(chalk17.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"));
+        console.log(chalk17.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"));
+        console.log(chalk17.red(`Invalid problem ID: ${id}`));
+        console.log(chalk17.gray("Problem ID must be a positive integer"));
         return;
       }
       if (bookmarks.add(id)) {
-        console.log(chalk16.green(`\u2713 Bookmarked problem ${id}`));
+        console.log(chalk17.green(`\u2713 Bookmarked problem ${id}`));
       } else {
-        console.log(chalk16.yellow(`Problem ${id} is already bookmarked`));
+        console.log(chalk17.yellow(`Problem ${id} is already bookmarked`));
       }
       break;
     case "remove":
       if (!id) {
-        console.log(chalk16.red("Please provide a problem ID to remove"));
+        console.log(chalk17.red("Please provide a problem ID to remove"));
         return;
       }
       if (bookmarks.remove(id)) {
-        console.log(chalk16.green(`\u2713 Removed bookmark for problem ${id}`));
+        console.log(chalk17.green(`\u2713 Removed bookmark for problem ${id}`));
       } else {
-        console.log(chalk16.yellow(`Problem ${id} is not bookmarked`));
+        console.log(chalk17.yellow(`Problem ${id} is not bookmarked`));
       }
       break;
     case "list":
@@ -2092,10 +2504,10 @@ async function bookmarkCommand(action, id) {
     case "clear":
       const count = bookmarks.count();
       if (count === 0) {
-        console.log(chalk16.yellow("No bookmarks to clear"));
+        console.log(chalk17.yellow("No bookmarks to clear"));
       } else {
         bookmarks.clear();
-        console.log(chalk16.green(`\u2713 Cleared ${count} bookmark${count !== 1 ? "s" : ""}`));
+        console.log(chalk17.green(`\u2713 Cleared ${count} bookmark${count !== 1 ? "s" : ""}`));
       }
       break;
   }
@@ -2103,12 +2515,12 @@ async function bookmarkCommand(action, id) {
 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'));
+    console.log(chalk17.yellow("\u{1F4CC} No bookmarked problems"));
+    console.log(chalk17.gray('Use "leetcode bookmark add <id>" to bookmark a problem'));
     return;
   }
   console.log();
-  console.log(chalk16.bold.cyan(`\u{1F4CC} Bookmarked Problems (${bookmarkList.length})`));
+  console.log(chalk17.bold.cyan(`\u{1F4CC} Bookmarked Problems (${bookmarkList.length})`));
   console.log();
   const { authorized } = await requireAuth();
   if (authorized) {
@@ -2116,10 +2528,10 @@ async function listBookmarks() {
     try {
       const table = new Table2({
         head: [
-          chalk16.cyan("ID"),
-          chalk16.cyan("Title"),
-          chalk16.cyan("Difficulty"),
-          chalk16.cyan("Status")
+          chalk17.cyan("ID"),
+          chalk17.cyan("Title"),
+          chalk17.cyan("Difficulty"),
+          chalk17.cyan("Status")
         ],
         colWidths: [8, 45, 12, 10],
         style: { head: [], border: [] }
@@ -2132,35 +2544,35 @@ async function listBookmarks() {
               problem.questionFrontendId,
               problem.title.length > 42 ? problem.title.slice(0, 39) + "..." : problem.title,
               colorDifficulty2(problem.difficulty),
-              problem.status === "ac" ? chalk16.green("\u2713") : chalk16.gray("-")
+              problem.status === "ac" ? chalk17.green("\u2713") : chalk17.gray("-")
             ]);
           } else {
-            table.push([id, chalk16.gray("(not found)"), "-", "-"]);
+            table.push([id, chalk17.gray("(not found)"), "-", "-"]);
           }
         } catch {
-          table.push([id, chalk16.gray("(error fetching)"), "-", "-"]);
+          table.push([id, chalk17.gray("(error fetching)"), "-", "-"]);
         }
       }
       spinner.stop();
       console.log(table.toString());
     } catch {
       spinner.stop();
-      console.log(chalk16.gray("IDs: ") + bookmarkList.join(", "));
+      console.log(chalk17.gray("IDs: ") + bookmarkList.join(", "));
     }
   } else {
-    console.log(chalk16.gray("IDs: ") + bookmarkList.join(", "));
+    console.log(chalk17.gray("IDs: ") + bookmarkList.join(", "));
     console.log();
-    console.log(chalk16.gray("Login to see problem details"));
+    console.log(chalk17.gray("Login to see problem details"));
   }
 }
 function colorDifficulty2(difficulty) {
   switch (difficulty.toLowerCase()) {
     case "easy":
-      return chalk16.green(difficulty);
+      return chalk17.green(difficulty);
     case "medium":
-      return chalk16.yellow(difficulty);
+      return chalk17.yellow(difficulty);
     case "hard":
-      return chalk16.red(difficulty);
+      return chalk17.red(difficulty);
     default:
       return difficulty;
   }
@@ -2168,19 +2580,19 @@ function colorDifficulty2(difficulty) {
 
 // src/commands/notes.ts
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join6 } from "path";
-import { existsSync as existsSync6 } from "fs";
-import chalk17 from "chalk";
+import { join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import chalk18 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"));
+    console.log(chalk18.red(`Invalid problem ID: ${problemId}`));
+    console.log(chalk18.gray("Problem ID must be a positive integer"));
     return;
   }
   const noteAction = action === "view" ? "view" : "edit";
-  const notesDir = join6(config.getWorkDir(), ".notes");
-  const notePath = join6(notesDir, `${problemId}.md`);
-  if (!existsSync6(notesDir)) {
+  const notesDir = join7(config.getWorkDir(), ".notes");
+  const notePath = join7(notesDir, `${problemId}.md`);
+  if (!existsSync8(notesDir)) {
     await mkdir3(notesDir, { recursive: true });
   }
   if (noteAction === "view") {
@@ -2190,32 +2602,32 @@ async function notesCommand(problemId, action) {
   }
 }
 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`));
+  if (!existsSync8(notePath)) {
+    console.log(chalk18.yellow(`No notes found for problem ${problemId}`));
+    console.log(chalk18.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(chalk18.bold.cyan(`\u{1F4DD} Notes for Problem ${problemId}`));
+    console.log(chalk18.gray("\u2500".repeat(50)));
     console.log();
     console.log(content);
   } catch (error) {
-    console.log(chalk17.red("Failed to read notes"));
+    console.log(chalk18.red("Failed to read notes"));
     if (error instanceof Error) {
-      console.log(chalk17.gray(error.message));
+      console.log(chalk18.gray(error.message));
     }
   }
 }
 async function editNote(notePath, problemId) {
-  if (!existsSync6(notePath)) {
+  if (!existsSync8(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(chalk18.green(`\u2713 Created notes file for problem ${problemId}`));
   }
-  console.log(chalk17.gray(`Opening: ${notePath}`));
+  console.log(chalk18.gray(`Opening: ${notePath}`));
   await openInEditor(notePath);
 }
 async function generateNoteTemplate(problemId) {
@@ -2272,7 +2684,7 @@ async function generateNoteTemplate(problemId) {
 }
 
 // src/commands/today.ts
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 import ora12 from "ora";
 async function todayCommand() {
   const { authorized, username } = await requireAuth();
@@ -2287,48 +2699,48 @@ async function todayCommand() {
     ]);
     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(chalk19.bold.cyan(`\u{1F4CA} Today's Summary`), chalk19.gray(`- ${username}`));
+    console.log(chalk19.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(chalk19.yellow(`\u{1F525} Current Streak: ${profile.streak} day${profile.streak !== 1 ? "s" : ""}`));
+    console.log(chalk19.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(chalk19.white("\u{1F4C8} Problems Solved:"));
+    console.log(`   ${chalk19.green("Easy")}: ${easy?.count ?? 0}  |  ${chalk19.yellow("Medium")}: ${medium?.count ?? 0}  |  ${chalk19.red("Hard")}: ${hard?.count ?? 0}`);
+    console.log(`   ${chalk19.bold("Total")}: ${total?.count ?? 0}`);
     console.log();
-    console.log(chalk18.bold.yellow("\u{1F3AF} Today's Challenge:"));
+    console.log(chalk19.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!"));
+      console.log(chalk19.green("   \u2713 Completed!"));
     } else if (status === "notac") {
-      console.log(chalk18.yellow("   \u25CB Attempted"));
+      console.log(chalk19.yellow("   \u25CB Attempted"));
     } else {
-      console.log(chalk18.gray("   - Not started"));
+      console.log(chalk19.gray("   - Not started"));
     }
     console.log();
-    console.log(chalk18.gray(`   leetcode pick ${daily.question.questionFrontendId} # Start working on it`));
+    console.log(chalk19.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));
+      console.log(chalk19.red(error.message));
     }
   }
 }
 function colorDifficulty3(difficulty) {
   switch (difficulty.toLowerCase()) {
     case "easy":
-      return chalk18.green(difficulty);
+      return chalk19.green(difficulty);
     case "medium":
-      return chalk18.yellow(difficulty);
+      return chalk19.yellow(difficulty);
     case "hard":
-      return chalk18.red(difficulty);
+      return chalk19.red(difficulty);
     default:
       return difficulty;
   }
@@ -2336,8 +2748,8 @@ function colorDifficulty3(difficulty) {
 
 // src/commands/sync.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import chalk19 from "chalk";
+import { existsSync as existsSync9 } from "fs";
+import chalk20 from "chalk";
 import inquirer3 from "inquirer";
 import ora13 from "ora";
 function isGitInstalled() {
@@ -2382,7 +2794,7 @@ async function setupGitRepo(workDir) {
     }
   ]);
   if (!init) {
-    console.log(chalk19.yellow("Skipping basic git initialization."));
+    console.log(chalk20.yellow("Skipping basic git initialization."));
     return false;
   }
   const spinner = ora13("Initializing git repository...").start();
@@ -2421,12 +2833,12 @@ async function setupRemote(workDir) {
           return repoUrl;
         } catch (error) {
           spinner.fail("Failed to create GitHub repository");
-          console.log(chalk19.red(error));
+          console.log(chalk20.red(error));
         }
       }
     }
     if (!repoUrl) {
-      console.log(chalk19.yellow("\nPlease create a new repository on your Git provider and copy the URL."));
+      console.log(chalk20.yellow("\nPlease create a new repository on your Git provider and copy the URL."));
       const { url } = await inquirer3.prompt([
         {
           type: "input",
@@ -2445,21 +2857,21 @@ async function setupRemote(workDir) {
   if (!currentRemote && repoUrl) {
     try {
       execSync(`git remote add origin ${repoUrl}`, { cwd: workDir });
-      console.log(chalk19.green("\u2713 Added remote origin"));
+      console.log(chalk20.green("\u2713 Added remote origin"));
     } catch (e) {
-      console.log(chalk19.red("Failed to add remote origin"));
+      console.log(chalk20.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}`));
+  if (!existsSync9(workDir)) {
+    console.log(chalk20.red(`Work directory does not exist: ${workDir}`));
     return;
   }
   if (!isGitInstalled()) {
-    console.log(chalk19.red("Git is not installed. Please install Git to use command."));
+    console.log(chalk20.red("Git is not installed. Please install Git to use command."));
     return;
   }
   if (!isMapRepo(workDir)) {
@@ -2493,14 +2905,14 @@ async function syncCommand() {
   } catch (error) {
     spinner.fail("Sync failed");
     if (error.message) {
-      console.log(chalk19.red(error.message));
+      console.log(chalk20.red(error.message));
     }
   }
 }
 
 // src/commands/timer.ts
 import ora14 from "ora";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 var DEFAULT_TIMES = {
   Easy: 20,
   Medium: 40,
@@ -2529,10 +2941,10 @@ async function timerCommand(idOrSlug, options) {
     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"));
+    console.log(chalk21.yellow("Please provide a problem ID to start the timer."));
+    console.log(chalk21.gray("Usage: leetcode timer <id>"));
+    console.log(chalk21.gray("       leetcode timer --stats"));
+    console.log(chalk21.gray("       leetcode timer --stop"));
     return;
   }
   const { authorized } = await requireAuth();
@@ -2541,11 +2953,11 @@ async function timerCommand(idOrSlug, options) {
   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(chalk21.yellow("\u26A0\uFE0F  You have an active timer running:"));
+    console.log(chalk21.white(`   Problem: ${activeTimer.title}`));
+    console.log(chalk21.white(`   Elapsed: ${formatDuration(elapsed)}`));
     console.log();
-    console.log(chalk20.gray("Use `leetcode timer --stop` to stop it first."));
+    console.log(chalk21.gray("Use `leetcode timer --stop` to stop it first."));
     return;
   }
   const spinner = ora14("Fetching problem...").start();
@@ -2569,65 +2981,65 @@ async function timerCommand(idOrSlug, options) {
       durationMinutes
     );
     console.log();
-    console.log(chalk20.bold.cyan("\u23F1\uFE0F  Interview Mode Started!"));
-    console.log(chalk20.gray("\u2500".repeat(50)));
+    console.log(chalk21.bold.cyan("\u23F1\uFE0F  Interview Mode Started!"));
+    console.log(chalk21.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(chalk21.white(`Problem: ${problem.questionFrontendId}. ${problem.title}`));
+    console.log(chalk21.white(`Difficulty: ${chalk21.bold(problem.difficulty)}`));
+    console.log(chalk21.white(`Time Limit: ${chalk21.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(chalk21.gray("\u2500".repeat(50)));
+    console.log(chalk21.green("\u2713 Timer is running in background"));
+    console.log(chalk21.gray("  When you submit successfully, your time will be recorded."));
+    console.log(chalk21.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));
+      console.log(chalk21.red(error.message));
     }
   }
 }
 async function stopActiveTimer() {
   const result = timerStorage.stopTimer();
   if (!result) {
-    console.log(chalk20.yellow("No active timer to stop."));
+    console.log(chalk21.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)"));
+  console.log(chalk21.green("\u23F1\uFE0F  Timer stopped."));
+  console.log(chalk21.gray(`Elapsed time: ${formatDuration(result.durationSeconds)}`));
+  console.log(chalk21.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}`));
+      console.log(chalk21.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)));
+    console.log(chalk21.bold(`\u23F1\uFE0F  Solve Times for Problem ${problemId}`));
+    console.log(chalk21.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)`
+        `  ${date}  ${withinLimit ? chalk21.green(duration) : chalk21.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(chalk21.bold("\u23F1\uFE0F  Timer Statistics"));
+    console.log(chalk21.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(`  Problems timed: ${chalk21.cyan(stats.totalProblems)}`);
+    console.log(`  Total time: ${chalk21.cyan(formatDuration(stats.totalTime))}`);
+    console.log(`  Average time: ${chalk21.cyan(formatDuration(stats.avgTime))}`);
     console.log();
     const recentSolves = [];
     for (const [id, times] of Object.entries(allTimes)) {
@@ -2642,11 +3054,11 @@ async function showTimerStats(problemId) {
     }
     if (recentSolves.length > 0) {
       recentSolves.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
-      console.log(chalk20.bold("  Recent Solves:"));
+      console.log(chalk21.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))
+          chalk21.gray(`    ${date}  `) + chalk21.white(`${solve.problemId}. ${solve.title.substring(0, 25)}`) + chalk21.gray("  ") + chalk21.cyan(formatDuration(solve.duration))
         );
       }
     }
@@ -2654,162 +3066,1048 @@ async function showTimerStats(problemId) {
   }
 }
 
+// src/commands/collab.ts
+import chalk22 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 { existsSync as existsSync10, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+function getCollabPath() {
+  return workspaceStorage.getCollabPath();
+}
+function loadCollab() {
+  const path = getCollabPath();
+  if (existsSync10(path)) {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  }
+  return { session: null };
+}
+function saveCollab(data) {
+  const collabPath = getCollabPath();
+  const dir = dirname2(collabPath);
+  if (!existsSync10(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  writeFileSync4(collabPath, JSON.stringify(data, null, 2));
+}
+var collabStorage = {
+  getSession() {
+    return loadCollab().session;
+  },
+  setSession(session) {
+    saveCollab({ session });
+  },
+  getPath() {
+    return getCollabPath();
+  }
+};
+
+// 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(chalk22.bold.cyan("\u{1F465} Collaborative Coding Session"));
+    console.log(chalk22.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk22.white(`Room Code: ${chalk22.bold.green(result.roomCode)}`));
+    console.log(chalk22.white(`Problem: ${problemId}`));
+    console.log();
+    console.log(chalk22.gray("Share this code with your partner:"));
+    console.log(chalk22.yellow(`  leetcode collab join ${result.roomCode}`));
+    console.log();
+    console.log(chalk22.gray("\u2500".repeat(50)));
+    console.log(chalk22.gray("After solving, sync and compare:"));
+    console.log(chalk22.gray("  leetcode collab sync     - Upload your solution"));
+    console.log(chalk22.gray("  leetcode collab compare  - See both solutions"));
+    console.log(chalk22.gray("  leetcode collab status   - Check room status"));
+    console.log(chalk22.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(chalk22.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(chalk22.bold.cyan("\u{1F465} Collaborative Coding Session"));
+    console.log(chalk22.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk22.white(`Room Code: ${chalk22.bold.green(roomCode.toUpperCase())}`));
+    console.log(chalk22.white(`Problem: ${result.problemId}`));
+    console.log();
+    console.log(chalk22.gray("\u2500".repeat(50)));
+    console.log(chalk22.gray("After solving, sync and compare:"));
+    console.log(chalk22.gray("  leetcode collab sync     - Upload your solution"));
+    console.log(chalk22.gray("  leetcode collab compare  - See both solutions"));
+    console.log(chalk22.gray("  leetcode collab status   - Check room status"));
+    console.log(chalk22.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(chalk22.red(error.message));
+    }
+  }
+}
+async function collabSyncCommand() {
+  const session = collabService.getSession();
+  if (!session) {
+    console.log(chalk22.yellow("No active collaboration session."));
+    console.log(chalk22.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(chalk22.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(chalk22.yellow("No active collaboration session."));
+    console.log(chalk22.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(chalk22.yellow("Partner has not synced their code yet."));
+    console.log(chalk22.gray("Ask them to run `leetcode collab sync`."));
+    return;
+  }
+  console.log();
+  console.log(chalk22.bold.cyan("\u{1F4CA} Solution Comparison"));
+  console.log(chalk22.gray("\u2500".repeat(60)));
+  console.log();
+  console.log(chalk22.bold.green(`\u25B8 Your Solution (${session.username})`));
+  console.log(chalk22.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(`${chalk22.gray(lineNum)} ${myLines[i]}`);
+  }
+  console.log();
+  console.log(chalk22.bold.blue(`\u25B8 ${partnerResult.username}'s Solution`));
+  console.log(chalk22.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(`${chalk22.gray(lineNum)} ${partnerLines[i]}`);
+  }
+  console.log();
+  console.log(chalk22.gray("\u2500".repeat(60)));
+  console.log(chalk22.gray(`Your code: ${myLines.length} lines | Partner: ${partnerLines.length} lines`));
+  console.log();
+}
+async function collabLeaveCommand() {
+  const session = collabService.getSession();
+  if (!session) {
+    console.log(chalk22.yellow("No active collaboration session."));
+    return;
+  }
+  await collabService.leaveRoom();
+  console.log(chalk22.green("\u2713 Left the collaboration session."));
+}
+async function collabStatusCommand() {
+  const session = collabService.getSession();
+  if (!session) {
+    console.log(chalk22.yellow("No active collaboration session."));
+    console.log(chalk22.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(chalk22.red(status.error));
+    return;
+  }
+  console.log();
+  console.log(chalk22.bold.cyan("\u{1F465} Collaboration Status"));
+  console.log(chalk22.gray("\u2500".repeat(40)));
+  console.log(`  Room: ${chalk22.green(session.roomCode)}`);
+  console.log(`  Problem: ${session.problemId}`);
+  console.log(`  Role: ${session.isHost ? "Host" : "Guest"}`);
+  console.log();
+  console.log(chalk22.bold("  Participants:"));
+  console.log(`    Host: ${status.host} ${status.hasHostCode ? chalk22.green("\u2713 synced") : chalk22.gray("pending")}`);
+  console.log(`    Guest: ${status.guest || chalk22.gray("(waiting...)")} ${status.hasGuestCode ? chalk22.green("\u2713 synced") : chalk22.gray("pending")}`);
+  console.log();
+}
+
+// src/commands/snapshot.ts
+import chalk23 from "chalk";
+
+// src/storage/snapshots.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync5, unlinkSync } from "fs";
+import { join as join8 } from "path";
+function getSnapshotsDir() {
+  return workspaceStorage.getSnapshotsDir();
+}
+function getSnapshotDir(problemId) {
+  return join8(getSnapshotsDir(), problemId);
+}
+function getMetaPath(problemId) {
+  return join8(getSnapshotDir(problemId), "meta.json");
+}
+function getFilesDir(problemId) {
+  return join8(getSnapshotDir(problemId), "files");
+}
+function ensureSnapshotDir(problemId) {
+  const dir = getFilesDir(problemId);
+  if (!existsSync11(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+}
+function loadMeta(problemId) {
+  const metaPath = getMetaPath(problemId);
+  if (existsSync11(metaPath)) {
+    return JSON.parse(readFileSync4(metaPath, "utf-8"));
+  }
+  return {
+    problemId,
+    problemTitle: "",
+    snapshots: []
+  };
+}
+function saveMeta(problemId, meta) {
+  ensureSnapshotDir(problemId);
+  writeFileSync5(getMetaPath(problemId), JSON.stringify(meta, null, 2));
+}
+var snapshotStorage = {
+  /**
+   * Save a snapshot of the solution
+   */
+  save(problemId, problemTitle, code, language, name) {
+    ensureSnapshotDir(problemId);
+    const meta = loadMeta(problemId);
+    if (problemTitle) {
+      meta.problemTitle = problemTitle;
+    }
+    const nextId = meta.snapshots.length > 0 ? Math.max(...meta.snapshots.map((s) => s.id)) + 1 : 1;
+    const snapshotName = name || `snapshot-${nextId}`;
+    const existing = meta.snapshots.find((s) => s.name === snapshotName);
+    if (existing) {
+      return { error: `Snapshot with name "${snapshotName}" already exists (ID: ${existing.id})` };
+    }
+    const ext = LANGUAGE_EXTENSIONS[language] || language;
+    const fileName = `${nextId}_${snapshotName}.${ext}`;
+    const filePath = join8(getFilesDir(problemId), fileName);
+    writeFileSync5(filePath, code, "utf-8");
+    const snapshot = {
+      id: nextId,
+      name: snapshotName,
+      fileName,
+      language,
+      lines: code.split("\n").length,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    meta.snapshots.push(snapshot);
+    saveMeta(problemId, meta);
+    return snapshot;
+  },
+  /**
+   * Get all snapshots for a problem
+   */
+  list(problemId) {
+    const meta = loadMeta(problemId);
+    return meta.snapshots;
+  },
+  /**
+   * Get snapshot metadata
+   */
+  getMeta(problemId) {
+    return loadMeta(problemId);
+  },
+  /**
+   * Get a specific snapshot by ID or name
+   */
+  get(problemId, idOrName) {
+    const meta = loadMeta(problemId);
+    const byId = meta.snapshots.find((s) => s.id === parseInt(idOrName, 10));
+    if (byId) return byId;
+    const byName = meta.snapshots.find((s) => s.name === idOrName);
+    return byName || null;
+  },
+  /**
+   * Get snapshot code content
+   */
+  getCode(problemId, snapshot) {
+    const filePath = join8(getFilesDir(problemId), snapshot.fileName);
+    if (!existsSync11(filePath)) {
+      throw new Error(`Snapshot file not found: ${snapshot.fileName}`);
+    }
+    return readFileSync4(filePath, "utf-8");
+  },
+  /**
+   * Delete a snapshot
+   */
+  delete(problemId, idOrName) {
+    const meta = loadMeta(problemId);
+    const snapshot = this.get(problemId, idOrName);
+    if (!snapshot) {
+      return false;
+    }
+    const filePath = join8(getFilesDir(problemId), snapshot.fileName);
+    if (existsSync11(filePath)) {
+      unlinkSync(filePath);
+    }
+    meta.snapshots = meta.snapshots.filter((s) => s.id !== snapshot.id);
+    saveMeta(problemId, meta);
+    return true;
+  },
+  /**
+   * Check if snapshots exist for a problem
+   */
+  hasSnapshots(problemId) {
+    return this.list(problemId).length > 0;
+  }
+};
+
+// src/commands/snapshot.ts
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { extname, basename as basename3 } from "path";
+import { diffLines } from "diff";
+function formatTimeAgo(dateStr) {
+  const date = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  return `${diffDays}d ago`;
+}
+async function snapshotSaveCommand(problemId, name) {
+  const workDir = config.getWorkDir();
+  try {
+    const filePath = await findSolutionFile(workDir, problemId);
+    if (!filePath) {
+      console.log(chalk23.red(`No solution file found for problem ${problemId}`));
+      console.log(chalk23.gray("Run `leetcode pick " + problemId + "` first to create a solution file."));
+      return;
+    }
+    const code = await readFile5(filePath, "utf-8");
+    const ext = extname(filePath).slice(1);
+    const lang = getLangSlugFromExtension(ext) || ext;
+    const fileName = basename3(filePath);
+    const titleMatch = fileName.match(/^\d+\.(.+)\.\w+$/);
+    const title = titleMatch ? titleMatch[1] : "";
+    const result = snapshotStorage.save(problemId, title, code, lang, name);
+    if ("error" in result) {
+      console.log(chalk23.red("\u2717 " + result.error));
+      return;
+    }
+    const snapshot = result;
+    console.log(chalk23.green("\u2713 Snapshot saved!"));
+    console.log();
+    console.log(`  ID:     ${chalk23.cyan(snapshot.id)}`);
+    console.log(`  Name:   ${chalk23.white(snapshot.name)}`);
+    console.log(`  Lines:  ${chalk23.gray(snapshot.lines)}`);
+    console.log(`  File:   ${chalk23.gray(filePath)}`);
+  } catch (error) {
+    console.log(chalk23.red("Failed to save snapshot"));
+    if (error instanceof Error) {
+      console.log(chalk23.gray(error.message));
+    }
+  }
+}
+async function snapshotListCommand(problemId) {
+  const snapshots = snapshotStorage.list(problemId);
+  if (snapshots.length === 0) {
+    console.log(chalk23.yellow(`No snapshots found for problem ${problemId}`));
+    console.log(chalk23.gray("Use `leetcode snapshot save " + problemId + "` to create one."));
+    return;
+  }
+  const meta = snapshotStorage.getMeta(problemId);
+  console.log();
+  console.log(chalk23.bold(`\u{1F4F8} Snapshots for Problem ${problemId}`));
+  if (meta.problemTitle) {
+    console.log(chalk23.gray(`   ${meta.problemTitle}`));
+  }
+  console.log(chalk23.gray("\u2500".repeat(50)));
+  console.log();
+  for (const snap of snapshots) {
+    const timeAgo = formatTimeAgo(snap.createdAt);
+    console.log(
+      `  ${chalk23.cyan(snap.id.toString().padStart(2))}. ${chalk23.white(snap.name.padEnd(25))} ${chalk23.gray(snap.lines + " lines")} ${chalk23.gray("\xB7")} ${chalk23.gray(timeAgo)}`
+    );
+  }
+  console.log();
+  console.log(chalk23.gray("Commands:"));
+  console.log(chalk23.gray(`  restore: leetcode snapshot restore ${problemId} <id|name>`));
+  console.log(chalk23.gray(`  diff:    leetcode snapshot diff ${problemId} <id1> <id2>`));
+  console.log(chalk23.gray(`  delete:  leetcode snapshot delete ${problemId} <id|name>`));
+}
+async function snapshotRestoreCommand(problemId, idOrName) {
+  const workDir = config.getWorkDir();
+  try {
+    const snapshot = snapshotStorage.get(problemId, idOrName);
+    if (!snapshot) {
+      console.log(chalk23.red(`Snapshot "${idOrName}" not found for problem ${problemId}`));
+      console.log(chalk23.gray("Run `leetcode snapshot list " + problemId + "` to see available snapshots."));
+      return;
+    }
+    const filePath = await findSolutionFile(workDir, problemId);
+    if (!filePath) {
+      console.log(chalk23.red(`No solution file found for problem ${problemId}`));
+      return;
+    }
+    const currentCode = await readFile5(filePath, "utf-8");
+    const backupName = `backup-before-restore-${Date.now()}`;
+    const ext = extname(filePath).slice(1);
+    const lang = getLangSlugFromExtension(ext) || ext;
+    snapshotStorage.save(problemId, "", currentCode, lang, backupName);
+    const snapshotCode = snapshotStorage.getCode(problemId, snapshot);
+    await writeFile4(filePath, snapshotCode, "utf-8");
+    console.log(chalk23.green("\u2713 Snapshot restored!"));
+    console.log();
+    console.log(`  Restored: ${chalk23.cyan(snapshot.name)} (${snapshot.lines} lines)`);
+    console.log(`  File:     ${chalk23.gray(filePath)}`);
+    console.log(`  Backup:   ${chalk23.gray(backupName)}`);
+  } catch (error) {
+    console.log(chalk23.red("Failed to restore snapshot"));
+    if (error instanceof Error) {
+      console.log(chalk23.gray(error.message));
+    }
+  }
+}
+async function snapshotDiffCommand(problemId, idOrName1, idOrName2) {
+  try {
+    const snap1 = snapshotStorage.get(problemId, idOrName1);
+    const snap2 = snapshotStorage.get(problemId, idOrName2);
+    if (!snap1) {
+      console.log(chalk23.red(`Snapshot "${idOrName1}" not found`));
+      return;
+    }
+    if (!snap2) {
+      console.log(chalk23.red(`Snapshot "${idOrName2}" not found`));
+      return;
+    }
+    const code1 = snapshotStorage.getCode(problemId, snap1);
+    const code2 = snapshotStorage.getCode(problemId, snap2);
+    console.log();
+    console.log(chalk23.bold(`\u{1F4CA} Diff: ${snap1.name} \u2192 ${snap2.name}`));
+    console.log(chalk23.gray("\u2500".repeat(50)));
+    console.log();
+    const diff = diffLines(code1, code2);
+    let added = 0;
+    let removed = 0;
+    for (const part of diff) {
+      const lines = part.value.split("\n").filter((l) => l !== "");
+      if (part.added) {
+        added += lines.length;
+        for (const line of lines) {
+          console.log(chalk23.green("+ " + line));
+        }
+      } else if (part.removed) {
+        removed += lines.length;
+        for (const line of lines) {
+          console.log(chalk23.red("- " + line));
+        }
+      } else {
+        if (lines.length <= 4) {
+          for (const line of lines) {
+            console.log(chalk23.gray("  " + line));
+          }
+        } else {
+          console.log(chalk23.gray("  " + lines[0]));
+          console.log(chalk23.gray("  " + lines[1]));
+          console.log(chalk23.gray(`  ... (${lines.length - 4} more lines)`));
+          console.log(chalk23.gray("  " + lines[lines.length - 2]));
+          console.log(chalk23.gray("  " + lines[lines.length - 1]));
+        }
+      }
+    }
+    console.log();
+    console.log(chalk23.gray("\u2500".repeat(50)));
+    console.log(
+      `${chalk23.green("+" + added + " added")} ${chalk23.gray("\xB7")} ${chalk23.red("-" + removed + " removed")} ${chalk23.gray("\xB7")} ${chalk23.gray(snap1.lines + " \u2192 " + snap2.lines + " lines")}`
+    );
+  } catch (error) {
+    console.log(chalk23.red("Failed to diff snapshots"));
+    if (error instanceof Error) {
+      console.log(chalk23.gray(error.message));
+    }
+  }
+}
+async function snapshotDeleteCommand(problemId, idOrName) {
+  const snapshot = snapshotStorage.get(problemId, idOrName);
+  if (!snapshot) {
+    console.log(chalk23.red(`Snapshot "${idOrName}" not found for problem ${problemId}`));
+    return;
+  }
+  const deleted = snapshotStorage.delete(problemId, idOrName);
+  if (deleted) {
+    console.log(chalk23.green(`\u2713 Deleted snapshot: ${snapshot.name}`));
+  } else {
+    console.log(chalk23.red("Failed to delete snapshot"));
+  }
+}
+
+// src/commands/diff.ts
+import ora16 from "ora";
+import chalk24 from "chalk";
+import { readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import { diffLines as diffLines2 } from "diff";
+function showCodeBlock(code, label) {
+  const lines = code.split("\n");
+  const lineCount = lines.length;
+  console.log();
+  console.log(chalk24.bold.cyan(`=== ${label} (${lineCount} lines) ===`));
+  console.log(chalk24.gray("\u2500".repeat(60)));
+  lines.forEach((line, i) => {
+    const lineNum = (i + 1).toString().padStart(3);
+    console.log(chalk24.gray(lineNum + " \u2502 ") + line);
+  });
+}
+function showUnifiedDiff(sourceCode, targetCode, sourceLabel, targetLabel) {
+  const sourceLines = sourceCode.split("\n").length;
+  const targetLines = targetCode.split("\n").length;
+  console.log();
+  console.log(chalk24.bold(`\u{1F4CA} Unified Diff: ${sourceLabel} \u2192 ${targetLabel}`));
+  console.log(chalk24.gray("\u2500".repeat(60)));
+  console.log();
+  const diff = diffLines2(sourceCode, targetCode);
+  let added = 0;
+  let removed = 0;
+  for (const part of diff) {
+    const lines = part.value.split("\n").filter((l) => l !== "");
+    if (part.added) {
+      added += lines.length;
+      for (const line of lines) {
+        console.log(chalk24.green("+ " + line));
+      }
+    } else if (part.removed) {
+      removed += lines.length;
+      for (const line of lines) {
+        console.log(chalk24.red("- " + line));
+      }
+    } else {
+      if (lines.length <= 6) {
+        for (const line of lines) {
+          console.log(chalk24.gray("  " + line));
+        }
+      } else {
+        console.log(chalk24.gray("  " + lines[0]));
+        console.log(chalk24.gray("  " + lines[1]));
+        console.log(chalk24.dim(`  ... (${lines.length - 4} unchanged lines)`));
+        console.log(chalk24.gray("  " + lines[lines.length - 2]));
+        console.log(chalk24.gray("  " + lines[lines.length - 1]));
+      }
+    }
+  }
+  console.log();
+  console.log(chalk24.gray("\u2500".repeat(60)));
+  console.log(
+    `${chalk24.green("+" + added + " added")} ${chalk24.gray("\xB7")} ${chalk24.red("-" + removed + " removed")} ${chalk24.gray("\xB7")} ${chalk24.gray(sourceLines + " \u2192 " + targetLines + " lines")}`
+  );
+}
+function showComparison(sourceCode, targetCode, sourceLabel, targetLabel, unified) {
+  if (unified) {
+    showUnifiedDiff(sourceCode, targetCode, sourceLabel, targetLabel);
+  } else {
+    showCodeBlock(sourceCode, sourceLabel);
+    showCodeBlock(targetCode, targetLabel);
+    const diff = diffLines2(sourceCode, targetCode);
+    let added = 0;
+    let removed = 0;
+    for (const part of diff) {
+      const lines = part.value.split("\n").filter((l) => l !== "");
+      if (part.added) added += lines.length;
+      else if (part.removed) removed += lines.length;
+    }
+    console.log();
+    console.log(chalk24.gray("\u2500".repeat(60)));
+    console.log(
+      `${chalk24.bold("Summary:")} ${chalk24.green("+" + added + " added")} ${chalk24.gray("\xB7")} ${chalk24.red("-" + removed + " removed")}`
+    );
+    console.log(chalk24.gray("Tip: Use --unified for line-by-line diff"));
+  }
+}
+async function diffCommand(problemId, options) {
+  const { authorized } = await requireAuth();
+  if (!authorized) return;
+  const workDir = config.getWorkDir();
+  const spinner = ora16("Finding solution file...").start();
+  try {
+    const filePath = await findSolutionFile(workDir, problemId);
+    if (!filePath) {
+      spinner.fail(`No solution file found for problem ${problemId}`);
+      console.log(chalk24.gray("Run `leetcode pick " + problemId + "` first to create a solution file."));
+      return;
+    }
+    const currentCode = await readFile6(filePath, "utf-8");
+    spinner.text = "Fetching comparison target...";
+    if (options.file) {
+      spinner.stop();
+      if (!existsSync12(options.file)) {
+        console.log(chalk24.red(`File not found: ${options.file}`));
+        return;
+      }
+      const otherCode = await readFile6(options.file, "utf-8");
+      showComparison(currentCode, otherCode, "Your Solution", options.file, options.unified ?? false);
+      return;
+    }
+    const problem = await leetcodeClient.getProblemById(problemId);
+    if (!problem) {
+      spinner.fail(`Problem ${problemId} not found`);
+      return;
+    }
+    if (options.submission) {
+      const submissionId = parseInt(options.submission, 10);
+      const submission = await leetcodeClient.getSubmissionDetails(submissionId);
+      spinner.stop();
+      showComparison(currentCode, submission.code, "Your Solution", `Submission #${submissionId}`, options.unified ?? false);
+      return;
+    }
+    const submissions = await leetcodeClient.getSubmissionList(problem.titleSlug, 50);
+    const accepted = submissions.find((s) => s.statusDisplay === "Accepted");
+    if (!accepted) {
+      spinner.fail("No accepted submissions found for this problem");
+      console.log(chalk24.gray("Tip: Use --file to compare with a local file instead"));
+      return;
+    }
+    const acceptedDetails = await leetcodeClient.getSubmissionDetails(parseInt(accepted.id, 10));
+    spinner.stop();
+    showComparison(currentCode, acceptedDetails.code, "Your Solution", "Last Accepted", options.unified ?? false);
+  } catch (error) {
+    spinner.fail("Failed to diff");
+    if (error instanceof Error) {
+      console.log(chalk24.red(error.message));
+    }
+  }
+}
+
+// src/commands/workspace.ts
+import chalk25 from "chalk";
+import inquirer4 from "inquirer";
+import { homedir as homedir3 } from "os";
+import { join as join9 } from "path";
+async function workspaceCurrentCommand() {
+  const active = workspaceStorage.getActive();
+  const config2 = workspaceStorage.getConfig(active);
+  console.log();
+  console.log(chalk25.bold.cyan(`\u{1F4C1} Active Workspace: ${active}`));
+  console.log(chalk25.gray("\u2500".repeat(40)));
+  console.log(`  workDir:  ${chalk25.white(config2.workDir)}`);
+  console.log(`  lang:     ${chalk25.white(config2.lang)}`);
+  if (config2.editor) console.log(`  editor:   ${chalk25.white(config2.editor)}`);
+  if (config2.syncRepo) console.log(`  syncRepo: ${chalk25.white(config2.syncRepo)}`);
+  console.log();
+}
+async function workspaceListCommand() {
+  const workspaces = workspaceStorage.list();
+  const active = workspaceStorage.getActive();
+  console.log();
+  console.log(chalk25.bold("Workspaces:"));
+  console.log();
+  for (const ws of workspaces) {
+    const config2 = workspaceStorage.getConfig(ws);
+    const marker = ws === active ? chalk25.green("\u25B8 ") : "  ";
+    const name = ws === active ? chalk25.green.bold(ws) : ws;
+    console.log(`${marker}${name}`);
+    console.log(`    ${chalk25.gray(config2.workDir)}`);
+  }
+  console.log();
+}
+async function workspaceCreateCommand(name, options) {
+  if (workspaceStorage.exists(name)) {
+    console.log(chalk25.red(`Workspace "${name}" already exists`));
+    return;
+  }
+  const workDir = options.workdir ?? join9(homedir3(), "leetcode", name);
+  const config2 = {
+    workDir,
+    lang: "typescript"
+  };
+  const success = workspaceStorage.create(name, config2);
+  if (success) {
+    console.log(chalk25.green(`\u2713 Created workspace "${name}"`));
+    console.log(`  workDir: ${chalk25.gray(workDir)}`);
+    console.log();
+    console.log(chalk25.gray(`Switch to it: leetcode workspace use ${name}`));
+  } else {
+    console.log(chalk25.red("Failed to create workspace"));
+  }
+}
+async function workspaceUseCommand(name) {
+  if (!workspaceStorage.exists(name)) {
+    console.log(chalk25.red(`Workspace "${name}" not found`));
+    console.log(chalk25.gray("Use `leetcode workspace list` to see available workspaces"));
+    return;
+  }
+  const success = workspaceStorage.setActive(name);
+  if (success) {
+    const config2 = workspaceStorage.getConfig(name);
+    console.log(chalk25.green(`\u2713 Switched to workspace "${name}"`));
+    console.log(`  workDir: ${chalk25.gray(config2.workDir)}`);
+  } else {
+    console.log(chalk25.red("Failed to switch workspace"));
+  }
+}
+async function workspaceDeleteCommand(name) {
+  if (name === "default") {
+    console.log(chalk25.red("Cannot delete the default workspace"));
+    return;
+  }
+  if (!workspaceStorage.exists(name)) {
+    console.log(chalk25.red(`Workspace "${name}" not found`));
+    return;
+  }
+  const { confirmed } = await inquirer4.prompt([{
+    type: "confirm",
+    name: "confirmed",
+    message: `Delete workspace "${name}"? (files in workDir will NOT be deleted)`,
+    default: false
+  }]);
+  if (!confirmed) {
+    console.log(chalk25.gray("Cancelled"));
+    return;
+  }
+  const success = workspaceStorage.delete(name);
+  if (success) {
+    console.log(chalk25.green(`\u2713 Deleted workspace "${name}"`));
+  } else {
+    console.log(chalk25.red("Failed to delete workspace"));
+  }
+}
+
 // src/index.ts
 var program = new Command();
 program.configureHelp({
   sortSubcommands: true,
-  subcommandTerm: (cmd) => chalk21.cyan(cmd.name()) + (cmd.alias() ? chalk21.gray(`|${cmd.alias()}`) : ""),
-  subcommandDescription: (cmd) => chalk21.white(cmd.description()),
-  optionTerm: (option) => chalk21.yellow(option.flags),
-  optionDescription: (option) => chalk21.white(option.description)
+  subcommandTerm: (cmd) => {
+    const name = cmd.name();
+    const alias = cmd.alias();
+    const term = alias ? `${name}|${alias}` : name;
+    return chalk26.cyan(term.padEnd(16));
+  },
+  subcommandDescription: (cmd) => chalk26.white(cmd.description()),
+  optionTerm: (option) => chalk26.yellow(option.flags),
+  optionDescription: (option) => chalk26.white(option.description)
 });
-program.name("leetcode").usage("[command] [options]").description(chalk21.bold.cyan("\u{1F525} A modern LeetCode CLI built with TypeScript")).version("1.5.0", "-v, --version", "Output the version number").helpOption("-h, --help", "Display help for command").addHelpText("after", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode login")}             Login to LeetCode
-  ${chalk21.cyan("$ leetcode list -d easy")}      List easy problems
-  ${chalk21.cyan("$ leetcode random -d medium")}   Get random medium problem
-  ${chalk21.cyan("$ leetcode pick 1")}            Start solving "Two Sum"
-  ${chalk21.cyan("$ leetcode test 1")}            Test your solution
-  ${chalk21.cyan("$ leetcode submit 1")}          Submit your solution
+program.name("leetcode").usage("[command] [options]").description(chalk26.bold.cyan("\u{1F525} A modern LeetCode CLI built with TypeScript")).version("2.0.0", "-v, --version", "Output the version number").helpOption("-h, --help", "Display help for command").addHelpText("after", `
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode login")}             Login to LeetCode
+  ${chalk26.cyan("$ leetcode list -d easy")}      List easy problems
+  ${chalk26.cyan("$ leetcode random -d medium")}   Get random medium problem
+  ${chalk26.cyan("$ leetcode pick 1")}            Start solving "Two Sum"
+  ${chalk26.cyan("$ leetcode test 1")}            Test your solution
+  ${chalk26.cyan("$ leetcode submit 1")}          Submit your solution
 `);
 program.command("login").description("Login to LeetCode with browser cookies").addHelpText("after", `
-${chalk21.yellow("How to login:")}
-  1. Open ${chalk21.cyan("https://leetcode.com")} in your browser
+${chalk26.yellow("How to login:")}
+  1. Open ${chalk26.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 ${chalk21.green("LEETCODE_SESSION")} and ${chalk21.green("csrftoken")}
+  4. Copy values of ${chalk26.green("LEETCODE_SESSION")} and ${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode list")}                    List first 20 problems
-  ${chalk21.cyan("$ leetcode list -d easy")}            List easy problems only
-  ${chalk21.cyan("$ leetcode list -s solved")}          List your solved problems
-  ${chalk21.cyan("$ leetcode list -t array -t string")} Filter by multiple tags
-  ${chalk21.cyan('$ leetcode list -q "two sum"')}       Search by keywords
-  ${chalk21.cyan("$ leetcode list -n 50 -p 2")}         Show 50 problems, page 2
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode list")}                    List first 20 problems
+  ${chalk26.cyan("$ leetcode list -d easy")}            List easy problems only
+  ${chalk26.cyan("$ leetcode list -s solved")}          List your solved problems
+  ${chalk26.cyan("$ leetcode list -t array -t string")} Filter by multiple tags
+  ${chalk26.cyan('$ leetcode list -q "two sum"')}       Search by keywords
+  ${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode show 1")}                  Show by problem ID
-  ${chalk21.cyan("$ leetcode show two-sum")}            Show by problem slug
-  ${chalk21.cyan("$ leetcode s 412")}                   Short alias
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode show 1")}                  Show by problem ID
+  ${chalk26.cyan("$ leetcode show two-sum")}            Show by problem slug
+  ${chalk26.cyan("$ leetcode s 412")}                   Short alias
 `).action(showCommand);
 program.command("daily").alias("d").description("Show today's daily challenge").addHelpText("after", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode daily")}                   Show today's challenge
-  ${chalk21.cyan("$ leetcode d")}                       Short alias
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode daily")}                   Show today's challenge
+  ${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode random")}                  Get any random problem
-  ${chalk21.cyan("$ leetcode random -d medium")}        Random medium problem
-  ${chalk21.cyan("$ leetcode random -t array")}         Random array problem
-  ${chalk21.cyan("$ leetcode random --pick")}           Random + create file
-  ${chalk21.cyan("$ leetcode r -d easy --pick")}        Random easy + file
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode random")}                  Get any random problem
+  ${chalk26.cyan("$ leetcode random -d medium")}        Random medium problem
+  ${chalk26.cyan("$ leetcode random -t array")}         Random array problem
+  ${chalk26.cyan("$ leetcode random --pick")}           Random + create file
+  ${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode pick 1")}                  Pick by problem ID
-  ${chalk21.cyan("$ leetcode pick two-sum")}            Pick by problem slug
-  ${chalk21.cyan("$ leetcode pick 1 -l python3")}       Pick with specific language
-  ${chalk21.cyan("$ leetcode pick 1 --no-open")}        Create file without opening
-  ${chalk21.cyan("$ leetcode p 412")}                   Short alias
-
-${chalk21.gray("Files are organized by: workDir/Difficulty/Category/")}
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode pick 1")}                  Pick by problem ID
+  ${chalk26.cyan("$ leetcode pick two-sum")}            Pick by problem slug
+  ${chalk26.cyan("$ leetcode pick 1 -l python3")}       Pick with specific language
+  ${chalk26.cyan("$ leetcode pick 1 --no-open")}        Create file without opening
+  ${chalk26.cyan("$ leetcode p 412")}                   Short alias
+
+${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode pick-batch 1 2 3")}        Pick problems 1, 2, and 3
-  ${chalk21.cyan("$ leetcode pick-batch 1 2 3 -l py")}  Pick with Python
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode pick-batch 1 2 3")}        Pick problems 1, 2, and 3
+  ${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode test 1")}                  Test by problem ID
-  ${chalk21.cyan("$ leetcode test two-sum")}            Test by problem slug
-  ${chalk21.cyan("$ leetcode test ./path/to/file.py")} Test by file path
-  ${chalk21.cyan('$ leetcode test 1 -c "[1,2]\\n3"')}   Test with custom case
-  ${chalk21.cyan("$ leetcode t 412")}                   Short alias
-
-${chalk21.gray("Testcases use \\n to separate multiple inputs.")}
+program.command("test <file>").alias("t").description("Test solution against sample test cases").option("-c, --testcase <testcase>", "Custom test case").option("-V, --visualize", "Visual output for data structures (arrays, trees, etc.)").addHelpText("after", `
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode test 1")}                  Test by problem ID
+  ${chalk26.cyan("$ leetcode test two-sum")}            Test by problem slug
+  ${chalk26.cyan("$ leetcode test ./path/to/file.py")} Test by file path
+  ${chalk26.cyan('$ leetcode test 1 -c "[1,2]\\n3"')}   Test with custom case
+  ${chalk26.cyan("$ leetcode test 1 --visualize")}     Visual mode for debugging
+  ${chalk26.cyan("$ leetcode t 412")}                   Short alias
+
+${chalk26.gray("Testcases use \\n to separate multiple inputs.")}
 `).action(testCommand);
 program.command("submit <file>").alias("x").description("Submit solution to LeetCode").addHelpText("after", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode submit 1")}                Submit by problem ID
-  ${chalk21.cyan("$ leetcode submit two-sum")}          Submit by problem slug
-  ${chalk21.cyan("$ leetcode submit ./path/to/file.py")} Submit by file path
-  ${chalk21.cyan("$ leetcode x 412")}                   Short alias
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode submit 1")}                Submit by problem ID
+  ${chalk26.cyan("$ leetcode submit two-sum")}          Submit by problem slug
+  ${chalk26.cyan("$ leetcode submit ./path/to/file.py")} Submit by file path
+  ${chalk26.cyan("$ leetcode x 412")}                   Short alias
 `).action(submitCommand);
+program.command("diff <id>").description("Compare solution with past submissions").option("-s, --submission <id>", "Compare with specific submission ID").option("-f, --file <path>", "Compare with a local file").option("-u, --unified", "Show unified diff (line-by-line changes)").addHelpText("after", `
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode diff 1")}                  Compare with last accepted
+  ${chalk26.cyan("$ leetcode diff 1 -u")}               Show unified diff
+  ${chalk26.cyan("$ leetcode diff 1 -s 12345")}         Compare with specific submission
+  ${chalk26.cyan("$ leetcode diff 1 -f other.py")}      Compare with local file
+`).action(diffCommand);
 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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode submissions 1")}           View submissions for problem
-  ${chalk21.cyan("$ leetcode submissions 1 -n 5")}      Show last 5 submissions
-  ${chalk21.cyan("$ leetcode submissions 1 --last")}    Show last accepted submission
-  ${chalk21.cyan("$ leetcode submissions 1 --download")} Download last accepted code
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode submissions 1")}           View submissions for problem
+  ${chalk26.cyan("$ leetcode submissions 1 -n 5")}      Show last 5 submissions
+  ${chalk26.cyan("$ leetcode submissions 1 --last")}    Show last accepted submission
+  ${chalk26.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", `
-${chalk21.yellow("Options Explained:")}
-  ${chalk21.cyan("-c, --calendar")}  Shows a table of your weekly submissions and active days
+${chalk26.yellow("Options Explained:")}
+  ${chalk26.cyan("-c, --calendar")}  Shows a table of your weekly submissions and active days
                     for the past 12 weeks. Useful for tracking consistency.
   
-  ${chalk21.cyan("-s, --skills")}    Shows how many problems you solved per topic tag,
+  ${chalk26.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.
   
-  ${chalk21.cyan("-t, --trend")}     Shows a bar chart of daily submissions for the past week.
+  ${chalk26.cyan("-t, --trend")}     Shows a bar chart of daily submissions for the past week.
                     Visualizes your recent coding activity day by day.
 
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode stat")}                    Show basic stats (solved count, rank)
-  ${chalk21.cyan("$ leetcode stat lee215")}             Show another user's stats
-  ${chalk21.cyan("$ leetcode stat -c")}                 Weekly activity table
-  ${chalk21.cyan("$ leetcode stat -s")}                 Topic-wise breakdown
-  ${chalk21.cyan("$ leetcode stat -t")}                 7-day trend chart
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode stat")}                    Show basic stats (solved count, rank)
+  ${chalk26.cyan("$ leetcode stat lee215")}             Show another user's stats
+  ${chalk26.cyan("$ leetcode stat -c")}                 Weekly activity table
+  ${chalk26.cyan("$ leetcode stat -s")}                 Topic-wise breakdown
+  ${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode today")}                   Show streak, solved, and daily challenge
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode today")}                   Show streak, solved, and daily challenge
 `).action(todayCommand);
 program.command("bookmark <action> [id]").description("Manage problem bookmarks").addHelpText("after", `
-${chalk21.yellow("Actions:")}
-  ${chalk21.cyan("add <id>")}      Bookmark a problem
-  ${chalk21.cyan("remove <id>")}   Remove a bookmark
-  ${chalk21.cyan("list")}          List all bookmarks
-  ${chalk21.cyan("clear")}         Clear all bookmarks
-
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode bookmark add 1")}          Bookmark problem 1
-  ${chalk21.cyan("$ leetcode bookmark remove 1")}       Remove bookmark
-  ${chalk21.cyan("$ leetcode bookmark list")}           List all bookmarks
+${chalk26.yellow("Actions:")}
+  ${chalk26.cyan("add <id>")}      Bookmark a problem
+  ${chalk26.cyan("remove <id>")}   Remove a bookmark
+  ${chalk26.cyan("list")}          List all bookmarks
+  ${chalk26.cyan("clear")}         Clear all bookmarks
+
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode bookmark add 1")}          Bookmark problem 1
+  ${chalk26.cyan("$ leetcode bookmark remove 1")}       Remove bookmark
+  ${chalk26.cyan("$ leetcode bookmark list")}           List all bookmarks
 `).action(bookmarkCommand);
 program.command("note <id> [action]").description("View or edit notes for a problem").addHelpText("after", `
-${chalk21.yellow("Actions:")}
-  ${chalk21.cyan("edit")}   Open notes in editor (default)
-  ${chalk21.cyan("view")}   Display notes in terminal
-
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode note 1")}                  Edit notes for problem 1
-  ${chalk21.cyan("$ leetcode note 1 edit")}             Edit notes (explicit)
-  ${chalk21.cyan("$ leetcode note 1 view")}             View notes in terminal
+${chalk26.yellow("Actions:")}
+  ${chalk26.cyan("edit")}   Open notes in editor (default)
+  ${chalk26.cyan("view")}   Display notes in terminal
+
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode note 1")}                  Edit notes for problem 1
+  ${chalk26.cyan("$ leetcode note 1 edit")}             Edit notes (explicit)
+  ${chalk26.cyan("$ leetcode note 1 view")}             View notes in terminal
 `).action(notesCommand);
 program.command("sync").description("Sync solutions to Git repository").addHelpText("after", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode sync")}                    Sync all solutions to remote
+${chalk26.yellow("Examples:")}
+  ${chalk26.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", `
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode config")}                  View current config
-  ${chalk21.cyan("$ leetcode config -l python3")}       Set language to Python
-  ${chalk21.cyan('$ leetcode config -e "code"')}        Set editor to VS Code
-  ${chalk21.cyan("$ leetcode config -w ~/leetcode")}    Set solutions folder
-  ${chalk21.cyan("$ leetcode config -r https://...")}   Set git repository
-  ${chalk21.cyan("$ leetcode config -i")}               Interactive setup
-
-${chalk21.gray("Supported languages: typescript, javascript, python3, java, cpp, c, csharp, go, rust, kotlin, swift")}
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode config")}                  View current config
+  ${chalk26.cyan("$ leetcode config -l python3")}       Set language to Python
+  ${chalk26.cyan('$ leetcode config -e "code"')}        Set editor to VS Code
+  ${chalk26.cyan("$ leetcode config -w ~/leetcode")}    Set solutions folder
+  ${chalk26.cyan("$ leetcode config -r https://...")}   Set git repository
+  ${chalk26.cyan("$ leetcode config -i")}               Interactive setup
+
+${chalk26.gray("Supported languages: typescript, javascript, python3, java, cpp, c, csharp, go, rust, kotlin, swift")}
 `).action(async (options) => {
   if (options.interactive) {
     await configInteractiveCommand();
@@ -2818,23 +4116,69 @@ ${chalk21.gray("Supported languages: typescript, javascript, python3, java, cpp,
   }
 });
 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", `
-${chalk21.yellow("How it works:")}
+${chalk26.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.
 
-${chalk21.yellow("Examples:")}
-  ${chalk21.cyan("$ leetcode timer 1")}                  Start problem 1 with default time
-  ${chalk21.cyan("$ leetcode timer 1 -m 30")}            Start with 30 minute limit
-  ${chalk21.cyan("$ leetcode timer --stats")}            Show your solve time statistics
-  ${chalk21.cyan("$ leetcode timer --stop")}             Stop active timer
+${chalk26.yellow("Examples:")}
+  ${chalk26.cyan("$ leetcode timer 1")}                  Start problem 1 with default time
+  ${chalk26.cyan("$ leetcode timer 1 -m 30")}            Start with 30 minute limit
+  ${chalk26.cyan("$ leetcode timer --stats")}            Show your solve time statistics
+  ${chalk26.cyan("$ leetcode timer --stop")}             Stop active timer
 `).action((id, options) => timerCommand(id, options));
+var workspaceCmd = program.command("workspace").description("Manage workspaces for different contexts");
+workspaceCmd.command("current").description("Show current workspace").action(workspaceCurrentCommand);
+workspaceCmd.command("list").description("List all workspaces").action(workspaceListCommand);
+workspaceCmd.command("create <name>").description("Create a new workspace").option("-w, --workdir <path>", "Set working directory for this workspace").action(workspaceCreateCommand);
+workspaceCmd.command("use <name>").description("Switch to a workspace").action(workspaceUseCommand);
+workspaceCmd.command("delete <name>").description("Delete a workspace").action(workspaceDeleteCommand);
+var collabCmd = program.command("collab").description("Collaborative coding with a partner").addHelpText("after", `
+${chalk26.yellow("Subcommands:")}
+  ${chalk26.cyan("host <id>")}      Create a room and get a code to share
+  ${chalk26.cyan("join <code>")}    Join a room with the shared code
+  ${chalk26.cyan("sync")}           Upload your solution to the room
+  ${chalk26.cyan("compare")}        View both solutions side by side
+  ${chalk26.cyan("status")}         Check room and sync status
+  ${chalk26.cyan("leave")}          End the collaboration session
+
+${chalk26.yellow("Examples:")}
+  ${chalk26.gray("$ leetcode collab host 1")}       Start a session for Two Sum
+  ${chalk26.gray("$ leetcode collab join ABC123")} Join your partner's session
+  ${chalk26.gray("$ leetcode collab sync")}        Upload your code after solving
+  ${chalk26.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);
+var snapshotCmd = program.command("snapshot").description("Save and restore solution versions").addHelpText("after", `
+${chalk26.yellow("Subcommands:")}
+  ${chalk26.cyan("save <id> [name]")}           Save current solution as a snapshot
+  ${chalk26.cyan("list <id>")}                  List all snapshots for a problem
+  ${chalk26.cyan("restore <id> <snapshot>")}   Restore a snapshot
+  ${chalk26.cyan("diff <id> <s1> <s2>")}        Compare two snapshots
+  ${chalk26.cyan("delete <id> <snapshot>")}    Delete a snapshot
+
+${chalk26.yellow("Examples:")}
+  ${chalk26.gray('$ leetcode snapshot save 1 "brute-force"')}     Save current solution
+  ${chalk26.gray("$ leetcode snapshot list 1")}                   List snapshots
+  ${chalk26.gray("$ leetcode snapshot restore 1 2")}              Restore snapshot #2
+  ${chalk26.gray("$ leetcode snapshot diff 1 1 2")}               Compare snapshots
+`);
+snapshotCmd.command("save <id> [name]").description("Save current solution as a snapshot").action(snapshotSaveCommand);
+snapshotCmd.command("list <id>").description("List all snapshots for a problem").action(snapshotListCommand);
+snapshotCmd.command("restore <id> <snapshot>").description("Restore a snapshot").action(snapshotRestoreCommand);
+snapshotCmd.command("diff <id> <snap1> <snap2>").description("Compare two snapshots").action(snapshotDiffCommand);
+snapshotCmd.command("delete <id> <snapshot>").description("Delete a snapshot").action(snapshotDeleteCommand);
 program.showHelpAfterError("(add --help for additional information)");
 program.parse();
 if (!process.argv.slice(2).length) {
   console.log();
-  console.log(chalk21.bold.cyan("  \u{1F525} LeetCode CLI"));
-  console.log(chalk21.gray("  A modern command-line interface for LeetCode"));
+  console.log(chalk26.bold.cyan("  \u{1F525} LeetCode CLI"));
+  console.log(chalk26.gray("  A modern command-line interface for LeetCode"));
   console.log();
   program.outputHelp();
 }