@rhseung/ps-cli 1.5.0 → 1.7.0

package/dist/{chunk-HDNNR5OY.js → chunk-ASMT3CRD.js}

@@ -495,207 +495,6 @@ var chalk = createChalk();
 var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
-// 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`;
-}
-
 export {
-  source_default,
-  getNextTierMinRating,
-  calculateTierProgress,
-  getTierName,
-  getTierColor,
-  getTierImageUrl
+  source_default
 };

package/dist/{chunk-7SVCS23X.js → chunk-TNGUME4H.js}

@@ -9924,8 +9924,10 @@ var config = new Conf({
     autoOpenEditor: false,
     // 기본값: 자동 열기 비활성화
     solvedAcHandle: void 0,
-    problemDir: "problems"
+    problemDir: "problems",
     // 기본값: problems 디렉토리
+    solvingDir: "solving"
+    // 기본값: solving 디렉토리
   }
 });
 var projectConfigCache = null;
@@ -10014,44 +10016,339 @@ function getProblemDir() {
   }
   return config.get("problemDir") ?? "problems";
 }
+function getSolvingDir() {
+  const projectConfig = getProjectConfigSync();
+  if (projectConfig?.solvingDir !== void 0) {
+    return projectConfig.solvingDir;
+  }
+  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, "/");
-  if (problemDir === "." || problemDir === "") {
+  const dirsToCheck = [problemDir, solvingDir].filter(
+    (dir) => dir && dir !== "." && dir !== ""
+  );
+  if (dirsToCheck.length === 0) {
     const segments = normalizedPath.split("/").filter(Boolean);
     const lastSegment = segments[segments.length - 1];
     if (lastSegment) {
-      const problemId2 = parseInt(lastSegment, 10);
-      if (!isNaN(problemId2) && problemId2 > 0 && lastSegment === problemId2.toString()) {
-        return problemId2;
+      const problemId = parseInt(lastSegment, 10);
+      if (!isNaN(problemId) && problemId > 0 && lastSegment === problemId.toString()) {
+        return problemId;
       }
     }
     return null;
   }
-  const dirPattern = `/${problemDir}/`;
-  const dirIndex = normalizedPath.indexOf(dirPattern);
-  if (dirIndex === -1) {
-    return null;
-  }
-  const afterDir = normalizedPath.substring(dirIndex + dirPattern.length);
-  if (!afterDir) {
-    return null;
-  }
-  const firstSegment = afterDir.split("/")[0];
-  if (!firstSegment) {
-    return null;
-  }
-  const problemId = parseInt(firstSegment, 10);
-  if (isNaN(problemId) || problemId <= 0) {
-    return null;
-  }
-  if (firstSegment !== problemId.toString()) {
-    return null;
+  for (const dir of dirsToCheck) {
+    const dirPattern = `/${dir}/`;
+    const dirIndex = normalizedPath.indexOf(dirPattern);
+    if (dirIndex === -1) {
+      continue;
+    }
+    const afterDir = normalizedPath.substring(dirIndex + dirPattern.length);
+    if (!afterDir) {
+      continue;
+    }
+    const segments = afterDir.split("/").filter(Boolean);
+    if (segments.length === 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 (!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;
 }
 function getProblemId(args, cwd = process.cwd()) {
   if (args.length > 0 && args[0]) {
@@ -10062,19 +10359,45 @@ 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(), _) {
+  const solvingDir = getSolvingDir();
+  const projectRoot = findProjectRoot(cwd);
+  const baseDir = projectRoot || cwd;
+  if (solvingDir === "." || solvingDir === "") {
+    return join2(baseDir, problemId.toString());
+  }
+  return join2(baseDir, solvingDir, problemId.toString());
+}
 
 // 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());
@@ -10085,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,
@@ -10249,14 +10589,23 @@ var CommandBuilder = class {
 
 export {
   Command,
+  findProjectRoot,
   getDefaultLanguage,
   getEditor,
   getAutoOpenEditor,
   getSolvedAcHandle,
   getProblemDir,
+  getSolvingDir,
+  getArchiveStrategy,
+  getNextTierMinRating,
+  calculateTierProgress,
+  getTierName,
+  getTierColor,
+  getTierImageUrl,
   detectProblemIdFromPath,
   getProblemId,
   getProblemDirPath,
+  getSolvingDirPath,
   resolveProblemContext,
   resolveLanguage,
   findSolutionFile,