@rhseung/ps-cli 1.6.0 → 1.7.0

package/dist/chunk-A6STXEAE.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+// src/services/solved-api.ts
+var BASE_URL = "https://solved.ac/api/v3";
+var USER_AGENT = "ps-cli/1.0.0";
+async function fetchWithRetry(url, options = {}, maxRetries = 3) {
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "User-Agent": USER_AGENT,
+          ...options.headers
+        }
+      });
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        const waitTime = retryAfter ? parseInt(retryAfter, 10) * 1e3 : (attempt + 1) * 1e3;
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        continue;
+      }
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxRetries - 1) {
+        await new Promise(
+          (resolve) => setTimeout(resolve, (attempt + 1) * 1e3)
+        );
+      }
+    }
+  }
+  throw lastError || new Error("Request failed after retries");
+}
+async function getProblem(problemId) {
+  const url = `${BASE_URL}/problem/show?problemId=${problemId}`;
+  const response = await fetchWithRetry(url);
+  const data = await response.json();
+  return data;
+}
+async function getUserStats(handle) {
+  const url = `${BASE_URL}/user/show?handle=${handle}`;
+  const response = await fetchWithRetry(url);
+  const data = await response.json();
+  return data;
+}
+
+export {
+  getProblem,
+  getUserStats
+};

package/dist/{chunk-RVD22OUQ.js → chunk-TNGUME4H.js}

@@ -10023,12 +10023,250 @@ function getSolvingDir() {
   }
   return config.get("solvingDir") ?? "solving";
 }
+function getArchiveStrategy() {
+  const projectConfig = getProjectConfigSync();
+  if (projectConfig?.archiveStrategy !== void 0) {
+    return projectConfig.archiveStrategy;
+  }
+  return config.get("archiveStrategy") ?? "flat";
+}
+
+// src/utils/tier.ts
+import gradient from "gradient-string";
+var TIER_NAMES = [
+  void 0,
+  "Bronze V",
+  "Bronze IV",
+  "Bronze III",
+  "Bronze II",
+  "Bronze I",
+  "Silver V",
+  "Silver IV",
+  "Silver III",
+  "Silver II",
+  "Silver I",
+  "Gold V",
+  "Gold IV",
+  "Gold III",
+  "Gold II",
+  "Gold I",
+  "Platinum V",
+  "Platinum IV",
+  "Platinum III",
+  "Platinum II",
+  "Platinum I",
+  "Diamond V",
+  "Diamond IV",
+  "Diamond III",
+  "Diamond II",
+  "Diamond I",
+  "Ruby V",
+  "Ruby IV",
+  "Ruby III",
+  "Ruby II",
+  "Ruby I",
+  "Master"
+];
+var TIER_COLORS = [
+  void 0,
+  "#9d4900",
+  "#a54f00",
+  "#ad5600",
+  "#b55d0a",
+  "#c67739",
+  "#38546e",
+  "#3d5a74",
+  "#435f7a",
+  "#496580",
+  "#4e6a86",
+  "#d28500",
+  "#df8f00",
+  "#ec9a00",
+  "#f9a518",
+  "#ffb028",
+  "#00c78b",
+  "#00d497",
+  "#27e2a4",
+  "#3ef0b1",
+  "#51fdbd",
+  "#009ee5",
+  "#00a9f0",
+  "#00b4fc",
+  "#2bbfff",
+  "#41caff",
+  "#e0004c",
+  "#ea0053",
+  "#f5005a",
+  "#ff0062",
+  "#ff3071",
+  "#b300e0"
+];
+var TIER_IMAGE_BASE_URL = "https://d2gd6pc034wcta.cloudfront.net/tier";
+var MASTER_TIER_GRADIENT = [
+  { r: 255, g: 124, b: 168 },
+  { r: 180, g: 145, b: 255 },
+  { r: 124, g: 249, b: 255 }
+];
+var TIER_MIN_RATINGS = [
+  0,
+  // Unrated (tier 0): 0-29
+  30,
+  // Bronze V (tier 1)
+  60,
+  // Bronze IV (tier 2)
+  90,
+  // Bronze III (tier 3)
+  120,
+  // Bronze II (tier 4)
+  150,
+  // Bronze I (tier 5)
+  200,
+  // Silver V (tier 6)
+  300,
+  // Silver IV (tier 7)
+  400,
+  // Silver III (tier 8)
+  500,
+  // Silver II (tier 9)
+  650,
+  // Silver I (tier 10)
+  800,
+  // Gold V (tier 11)
+  950,
+  // Gold IV (tier 12)
+  1100,
+  // Gold III (tier 13)
+  1250,
+  // Gold II (tier 14)
+  1400,
+  // Gold I (tier 15)
+  1600,
+  // Platinum V (tier 16)
+  1750,
+  // Platinum IV (tier 17)
+  1900,
+  // Platinum III (tier 18)
+  2e3,
+  // Platinum II (tier 19)
+  2100,
+  // Platinum I (tier 20)
+  2200,
+  // Diamond V (tier 21)
+  2300,
+  // Diamond IV (tier 22)
+  2400,
+  // Diamond III (tier 23)
+  2500,
+  // Diamond II (tier 24)
+  2600,
+  // Diamond I (tier 25)
+  2700,
+  // Ruby V (tier 26)
+  2800,
+  // Ruby IV (tier 27)
+  2850,
+  // Ruby III (tier 28)
+  2900,
+  // Ruby II (tier 29)
+  2950,
+  // Ruby I (tier 30)
+  3e3
+  // Master (tier 31)
+];
+function getTierMinRating(tier) {
+  if (tier >= 0 && tier < TIER_MIN_RATINGS.length) {
+    return TIER_MIN_RATINGS[tier] ?? 0;
+  }
+  return 0;
+}
+function getNextTierMinRating(tier) {
+  if (tier === 31) {
+    return null;
+  }
+  if (tier >= 0 && tier < TIER_MIN_RATINGS.length - 1) {
+    return TIER_MIN_RATINGS[tier + 1] ?? null;
+  }
+  return null;
+}
+function calculateTierProgress(currentRating, tier) {
+  if (tier === 31) {
+    return 100;
+  }
+  const currentTierMin = getTierMinRating(tier);
+  const nextTierMin = getNextTierMinRating(tier);
+  if (nextTierMin === null) {
+    return 100;
+  }
+  if (currentRating < currentTierMin) {
+    return 0;
+  }
+  if (currentRating >= nextTierMin) {
+    return 100;
+  }
+  const progress = (currentRating - currentTierMin) / (nextTierMin - currentTierMin) * 100;
+  return Math.max(0, Math.min(100, progress));
+}
+function getTierName(level) {
+  if (level === 0) return "Unrated";
+  if (level >= 1 && level < TIER_NAMES.length) {
+    return TIER_NAMES[level] || "Unrated";
+  }
+  return "Unrated";
+}
+function getTierColor(level) {
+  if (level === 0) return "#2d2d2d";
+  if (level === 31) {
+    return gradient([...MASTER_TIER_GRADIENT]);
+  }
+  if (level >= 1 && level < TIER_COLORS.length) {
+    return TIER_COLORS[level] || "#2d2d2d";
+  }
+  return "#2d2d2d";
+}
+function getTierImageUrl(level) {
+  return `${TIER_IMAGE_BASE_URL}/${level}.svg`;
+}
 
 // src/utils/problem-id.ts
 import { join as join2 } from "path";
+function sanitizeFileName(name) {
+  return name.replace(/[<>:"/\\|?*]/g, "").replace(/\s+/g, "-").toLowerCase().trim();
+}
+function getTierDirName(level) {
+  const tierName = getTierName(level);
+  if (tierName === "Unrated") {
+    return "unrated";
+  }
+  return sanitizeFileName(tierName);
+}
+function getArchiveSubPath(problemId, strategy = "flat", problem) {
+  switch (strategy) {
+    case "flat":
+      return "";
+    case "by-range": {
+      const range = Math.floor(problemId / 1e3) * 1e3;
+      return String(range).padStart(5, "0");
+    }
+    case "by-tier": {
+      if (!problem) {
+        return "";
+      }
+      return getTierDirName(problem.level);
+    }
+    case "by-tag": {
+      if (!problem || !problem.tags || problem.tags.length === 0) {
+        return "";
+      }
+      return sanitizeFileName(problem.tags[0]);
+    }
+    default:
+      return "";
+  }
+}
 function detectProblemIdFromPath(cwd = process.cwd()) {
   const problemDir = getProblemDir();
   const solvingDir = getSolvingDir();
+  const archiveStrategy = getArchiveStrategy();
   const normalizedPath = cwd.replace(/\\/g, "/");
   const dirsToCheck = [problemDir, solvingDir].filter(
     (dir) => dir && dir !== "." && dir !== ""
@@ -10054,18 +10292,61 @@ function detectProblemIdFromPath(cwd = process.cwd()) {
     if (!afterDir) {
       continue;
     }
-    const firstSegment = afterDir.split("/")[0];
-    if (!firstSegment) {
+    const segments = afterDir.split("/").filter(Boolean);
+    if (segments.length === 0) {
       continue;
     }
-    const problemId = parseInt(firstSegment, 10);
-    if (isNaN(problemId) || problemId <= 0) {
-      continue;
+    let problemId = null;
+    if (archiveStrategy === "flat") {
+      const firstSegment = segments[0];
+      if (firstSegment) {
+        const id = parseInt(firstSegment, 10);
+        if (!isNaN(id) && id > 0 && firstSegment === id.toString() && segments.length === 1) {
+          problemId = id;
+        }
+      }
+    } else if (archiveStrategy === "by-range") {
+      if (segments.length === 2) {
+        const secondSegment = segments[1];
+        if (secondSegment) {
+          const id = parseInt(secondSegment, 10);
+          if (!isNaN(id) && id > 0 && secondSegment === id.toString()) {
+            problemId = id;
+          }
+        }
+      }
+    } else if (archiveStrategy === "by-tier" || archiveStrategy === "by-tag") {
+      if (segments.length === 2) {
+        const secondSegment = segments[1];
+        if (secondSegment) {
+          const id = parseInt(secondSegment, 10);
+          if (!isNaN(id) && id > 0 && secondSegment === id.toString()) {
+            problemId = id;
+          }
+        }
+      }
     }
-    if (firstSegment !== problemId.toString()) {
-      continue;
+    if (!problemId) {
+      const lastSegment = segments[segments.length - 1];
+      if (lastSegment) {
+        const id = parseInt(lastSegment, 10);
+        if (!isNaN(id) && id > 0 && lastSegment === id.toString() && segments.length === 1) {
+          problemId = id;
+        }
+      }
+      if (!problemId && segments.length === 2) {
+        const secondSegment = segments[1];
+        if (secondSegment) {
+          const id = parseInt(secondSegment, 10);
+          if (!isNaN(id) && id > 0 && secondSegment === id.toString()) {
+            problemId = id;
+          }
+        }
+      }
+    }
+    if (problemId) {
+      return problemId;
     }
-    return problemId;
   }
   return null;
 }
@@ -10078,16 +10359,24 @@ function getProblemId(args, cwd = process.cwd()) {
   }
   return detectProblemIdFromPath(cwd);
 }
-function getProblemDirPath(problemId, cwd = process.cwd()) {
+function getProblemDirPath(problemId, cwd = process.cwd(), problem) {
   const problemDir = getProblemDir();
+  const archiveStrategy = getArchiveStrategy();
   const projectRoot = findProjectRoot(cwd);
   const baseDir = projectRoot || cwd;
+  const subPath = getArchiveSubPath(problemId, archiveStrategy, problem);
   if (problemDir === "." || problemDir === "") {
+    if (subPath) {
+      return join2(baseDir, subPath, problemId.toString());
+    }
     return join2(baseDir, problemId.toString());
   }
+  if (subPath) {
+    return join2(baseDir, problemDir, subPath, problemId.toString());
+  }
   return join2(baseDir, problemDir, problemId.toString());
 }
-function getSolvingDirPath(problemId, cwd = process.cwd()) {
+function getSolvingDirPath(problemId, cwd = process.cwd(), _) {
   const solvingDir = getSolvingDir();
   const projectRoot = findProjectRoot(cwd);
   const baseDir = projectRoot || cwd;
@@ -10098,8 +10387,17 @@ function getSolvingDirPath(problemId, cwd = process.cwd()) {
 }
 
 // src/utils/execution-context.ts
+import { access } from "fs/promises";
 import { readdir } from "fs/promises";
 import { join as join3 } from "path";
+async function directoryExists(dirPath) {
+  try {
+    await access(dirPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function resolveProblemContext(args, options = {}) {
   const { requireId = false } = options;
   const currentPathProblemId = detectProblemIdFromPath(process.cwd());
@@ -10110,7 +10408,24 @@ async function resolveProblemContext(args, options = {}) {
     );
   }
   const isCurrentDir = problemId === null || problemId !== null && currentPathProblemId === problemId;
-  const problemDir = problemId && !isCurrentDir ? getProblemDirPath(problemId) : process.cwd();
+  let problemDir;
+  if (problemId && !isCurrentDir) {
+    const solvingDirPath = getSolvingDirPath(problemId);
+    const problemDirPath = getProblemDirPath(problemId);
+    const solvingDirExists = await directoryExists(solvingDirPath);
+    if (solvingDirExists) {
+      problemDir = solvingDirPath;
+    } else {
+      const problemDirExists = await directoryExists(problemDirPath);
+      if (problemDirExists) {
+        problemDir = problemDirPath;
+      } else {
+        problemDir = solvingDirPath;
+      }
+    }
+  } else {
+    problemDir = process.cwd();
+  }
   return {
     problemId,
     problemDir,
@@ -10281,6 +10596,12 @@ export {
   getSolvedAcHandle,
   getProblemDir,
   getSolvingDir,
+  getArchiveStrategy,
+  getNextTierMinRating,
+  calculateTierProgress,
+  getTierName,
+  getTierColor,
+  getTierImageUrl,
   detectProblemIdFromPath,
   getProblemId,
   getProblemDirPath,

package/dist/commands/config.js

@@ -3,12 +3,13 @@ import {
   Command,
   CommandBuilder,
   CommandDef,
+  getArchiveStrategy,
   getAutoOpenEditor,
   getDefaultLanguage,
   getEditor,
   getProblemDir,
   getSolvedAcHandle
-} from "../chunk-RVD22OUQ.js";
+} from "../chunk-TNGUME4H.js";
 import {
   __decorateClass,
   getSupportedLanguages,
@@ -104,6 +105,18 @@ function useConfig({
           case "problem-dir":
             updatedConfig.problemDir = value;
             break;
+          case "archive-strategy": {
+            const validStrategies = ["flat", "by-range", "by-tier", "by-tag"];
+            if (!validStrategies.includes(value)) {
+              console.error(
+                `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC544\uCE74\uC774\uBE59 \uC804\uB7B5\uC785\uB2C8\uB2E4: ${value}
+\uC9C0\uC6D0 \uC804\uB7B5: ${validStrategies.join(", ")}`
+              );
+              process.exit(1);
+            }
+            updatedConfig.archiveStrategy = value;
+            break;
+          }
           default:
             console.error(`\uC54C \uC218 \uC5C6\uB294 \uC124\uC815 \uD0A4: ${configKey}`);
             process.exit(1);
@@ -147,6 +160,7 @@ function getConfigHelp() {
     auto-open-editor       fetch \uD6C4 \uC790\uB3D9\uC73C\uB85C \uC5D0\uB514\uD130 \uC5F4\uAE30 (true/false)
     solved-ac-handle       Solved.ac \uD578\uB4E4 (stats \uBA85\uB839\uC5B4\uC6A9)
     problem-dir            \uBB38\uC81C \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C (\uAE30\uBCF8\uAC12: problems, "." \uB610\uB294 ""\uB294 \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8)
+    archive-strategy       \uC544\uCE74\uC774\uBE59 \uC804\uB7B5 (flat, by-range, by-tier, by-tag)
 
   \uC635\uC158:
     --help, -h             \uB3C4\uC6C0\uB9D0 \uD45C\uC2DC
@@ -166,7 +180,8 @@ var CONFIG_KEYS = [
   { label: "editor", value: "editor" },
   { label: "auto-open-editor", value: "auto-open-editor" },
   { label: "solved-ac-handle", value: "solved-ac-handle" },
-  { label: "problem-dir", value: "problem-dir" }
+  { label: "problem-dir", value: "problem-dir" },
+  { label: "archive-strategy", value: "archive-strategy" }
 ];
 function ConfigView({
   configKey,
@@ -199,6 +214,7 @@ function ConfigView({
     const autoOpen = config?.autoOpenEditor ?? getAutoOpenEditor();
     const handle = config?.solvedAcHandle ?? getSolvedAcHandle();
     const problemDir = config?.problemDir ?? getProblemDir();
+    const archiveStrategy = config?.archiveStrategy ?? getArchiveStrategy();
     return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
       /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u2699\uFE0F \uD604\uC7AC \uC124\uC815 (.ps-cli.json)" }) }),
       /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
@@ -226,6 +242,11 @@ function ConfigView({
           /* @__PURE__ */ jsx(Text, { color: "gray", children: "problem-dir:" }),
           /* @__PURE__ */ jsx(Text, { children: " " }),
           /* @__PURE__ */ jsx(Text, { bold: true, children: problemDir })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "archive-strategy:" }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsx(Text, { bold: true, children: archiveStrategy })
         ] })
       ] })
     ] });
@@ -248,6 +269,9 @@ function ConfigView({
       case "problem-dir":
         configValue = config?.problemDir ?? getProblemDir();
         break;
+      case "archive-strategy":
+        configValue = config?.archiveStrategy ?? getArchiveStrategy();
+        break;
       default:
         console.error(`\uC54C \uC218 \uC5C6\uB294 \uC124\uC815 \uD0A4: ${configKey}`);
         process.exit(1);
@@ -418,6 +442,8 @@ var ConfigCommand = class extends Command {
           return "Solved.ac \uD578\uB4E4 \uC785\uB825";
         case "problem-dir":
           return "\uBB38\uC81C \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C \uC785\uB825";
+        case "archive-strategy":
+          return "\uC544\uCE74\uC774\uBE59 \uC804\uB7B5 \uC785\uB825 (flat, by-range, by-tier, by-tag)";
         default:
           return "\uAC12 \uC785\uB825";
       }
@@ -434,6 +460,8 @@ var ConfigCommand = class extends Command {
           return "Solved.ac \uC0AC\uC6A9\uC790 \uD578\uB4E4";
         case "problem-dir":
           return '\uBB38\uC81C \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C (\uAE30\uBCF8\uAC12: "problems", \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8: ".")';
+        case "archive-strategy":
+          return "\uC544\uCE74\uC774\uBE59 \uC804\uB7B5: flat (\uD3C9\uBA74), by-range (1000\uBC88\uB300 \uBB36\uAE30), by-tier (\uD2F0\uC5B4\uBCC4), by-tag (\uD0DC\uADF8\uBCC4)";
         default:
           return "";
       }
@@ -448,6 +476,8 @@ var ConfigCommand = class extends Command {
           return ["true", "false"];
         case "problem-dir":
           return ["problems", ".", ""];
+        case "archive-strategy":
+          return ["flat", "by-range", "by-tier", "by-tag"];
         default:
           return [];
       }

package/dist/commands/fetch.js

@@ -3,11 +3,8 @@ import {
   scrapeProblem
 } from "../chunk-AG6KWWHS.js";
 import {
-  getProblem,
-  getTierColor,
-  getTierImageUrl,
-  getTierName
-} from "../chunk-NH36IFWR.js";
+  getProblem
+} from "../chunk-A6STXEAE.js";
 import {
   Command,
   CommandBuilder,
@@ -15,8 +12,11 @@ import {
   getAutoOpenEditor,
   getEditor,
   getProblemId,
-  getSolvingDirPath
-} from "../chunk-RVD22OUQ.js";
+  getSolvingDirPath,
+  getTierColor,
+  getTierImageUrl,
+  getTierName
+} from "../chunk-TNGUME4H.js";
 import {
   __decorateClass,
   getLanguageConfig,
@@ -84,7 +84,7 @@ function getProjectRoot() {
   return join(__dirname, "../..");
 }
 async function generateProblemFiles(problem, language = "python") {
-  const problemDir = getSolvingDirPath(problem.id);
+  const problemDir = getSolvingDirPath(problem.id, process.cwd(), problem);
   await mkdir(problemDir, { recursive: true });
   const langConfig = getLanguageConfig(language);
   const projectRoot = getProjectRoot();
@@ -186,6 +186,7 @@ ${tags}
     id: problem.id,
     title: problem.title,
     level: problem.level,
+    tags: problem.tags,
     timeLimit: problem.timeLimit,
     timeLimitMs: parseTimeLimitToMs(problem.timeLimit),
     memoryLimit: problem.memoryLimit