@rhseung/ps-cli 1.7.2 → 1.7.4

package/README.md

@@ -24,99 +24,313 @@ ps test
 
 # 4. 제출
 ps submit
+
+# 5. 커밋 및 아카이빙
+ps archive
 ```
 
 ## 명령어
 
 ### `init` - 프로젝트 초기화
 
-프로젝트를 초기화하고 설정을 구성합니다.
+프로젝트를 대화형으로 초기화하고 설정을 구성합니다.
+
+**사용법:**
 
 ```bash
 ps init
 ```
 
+**설명:**
+
+- 단계별로 설정을 물어봅니다
+- 아카이브 디렉토리, solving 디렉토리, 아카이빙 전략, 기본 언어, 에디터 등을 설정할 수 있습니다
+
+---
+
 ### `fetch` - 문제 가져오기
 
 백준 문제를 가져와서 로컬에 파일을 생성합니다.
 
+**사용법:**
+
+```bash
+ps fetch <문제번호> [옵션]
+```
+
+**옵션:**
+
+- `--language`, `-l`: 언어 선택 (python, javascript, typescript, cpp)
+  - 기본값: python 또는 설정 파일의 `default-language`
+
+**예제:**
+
 ```bash
 ps fetch 1000
 ps fetch 1000 --language python
+ps fetch 1000 -l cpp
 ```
 
+**설명:**
+
+- Solved.ac API와 BOJ 크롤링을 통해 문제 정보 수집
+- 문제 설명, 입출력 형식, 예제 입출력 파일 자동 생성
+- 선택한 언어의 솔루션 템플릿 파일 생성
+- README.md에 문제 정보, 통계, 태그 등 포함
+
+---
+
 ### `test` - 로컬 테스트
 
 예제 입출력으로 테스트를 실행합니다.
 
+**사용법:**
+
 ```bash
-ps test
-ps test 1000
-ps test --watch  # 파일 변경 시 자동 재테스트
+ps test [문제번호] [옵션]
+```
+
+**옵션:**
+
+- `--language`, `-l`: 언어 선택 (지정 시 자동 감지 무시)
+  - 지원 언어: python, javascript, typescript, cpp
+- `--watch`, `-w`: watch 모드 (파일 변경 시 자동 재테스트)
+  - solution._, input_.txt, output\*.txt 파일 변경 감지
+
+**예제:**
+
+```bash
+ps test                    # 현재 디렉토리에서 테스트
+ps test 1000               # 1000번 문제 테스트
+ps test --watch            # watch 모드로 테스트
+ps test 1000 --watch       # 1000번 문제를 watch 모드로 테스트
+ps test --language python  # Python으로 테스트
 ```
 
+**설명:**
+
+- 현재 디렉토리 또는 지정한 문제 번호의 테스트 실행
+- solution.\* 파일을 자동으로 찾아 언어 감지
+- input*.txt와 output*.txt 파일을 기반으로 테스트
+- 문제의 시간 제한을 자동으로 적용
+
+---
+
 ### `run` - 코드 실행
 
 테스트 없이 코드를 실행합니다.
 
+**사용법:**
+
+```bash
+ps run [문제번호] [옵션]
+```
+
+**옵션:**
+
+- `--language`, `-l`: 언어 선택 (지정 시 자동 감지 무시)
+  - 지원 언어: python, javascript, typescript, cpp
+- `--input`, `-i`: 입력 파일 지정
+  - 기본값: input.txt 또는 input1.txt
+
+**예제:**
+
 ```bash
-ps run
-ps run 1000
+ps run                    # 현재 디렉토리에서 실행
+ps run 1000               # 1000번 문제 실행
+ps run --language python  # Python으로 실행
+ps run --input input2.txt # 특정 입력 파일 사용
 ```
 
+**설명:**
+
+- 현재 디렉토리 또는 지정한 문제 번호의 코드 실행
+- solution.\* 파일을 자동으로 찾아 언어 감지
+- input.txt 또는 input1.txt를 표준 입력으로 사용
+- 테스트 케이스 검증 없이 단순 실행
+
+---
+
 ### `submit` - 제출
 
 백준 제출 페이지를 열고 소스 코드를 클립보드에 복사합니다.
 
+**사용법:**
+
 ```bash
-ps submit
-ps submit 1000
+ps submit [문제번호] [옵션]
+```
+
+**옵션:**
+
+- `--language`, `-l`: 언어 선택 (지정 시 자동 감지 무시)
+  - 지원 언어: python, javascript, typescript, cpp
+
+**예제:**
+
+```bash
+ps submit                    # 현재 디렉토리에서 제출
+ps submit 1000                # 1000번 문제 제출
+ps submit --language python   # Python으로 제출
 ```
 
-### `solve` - 아카이빙
+**설명:**
+
+- 문제 번호를 인자로 전달하거나 문제 디렉토리에서 실행하면 자동으로 문제 번호를 추론
+- solution.\* 파일을 자동으로 찾아 언어 감지
+- 소스 코드를 클립보드에 자동 복사
+- 제출 페이지를 브라우저로 자동 열기
+
+---
+
+### `archive` - 아카이빙
+
+solving 디렉토리의 문제를 archive 디렉토리로 이동하고 Git 커밋을 생성합니다.
+
+**사용법:**
 
-solving 디렉토리의 문제를 problem 디렉토리로 이동하고 Git 커밋을 생성합니다.
+```bash
+ps archive [문제번호]
+```
+
+**예제:**
 
 ```bash
-ps solve 1000
+ps archive 1000              # 1000번 문제 아카이빙
+ps archive                   # 현재 디렉토리에서 문제 번호 자동 감지
 ```
 
+**설명:**
+
+- solving 디렉토리에서 문제를 찾아 archive 디렉토리로 이동
+- Git add 및 commit 실행
+- 커밋 메시지: "solve: {문제번호} - {문제이름}"
+
+---
+
 ### `open` - 문제 페이지 열기
 
 백준 문제 페이지를 브라우저로 엽니다.
 
+**사용법:**
+
 ```bash
-ps open 1000
+ps open [문제번호]
 ```
 
+**예제:**
+
+```bash
+ps open 1000                 # 1000번 문제 열기
+ps open                      # 문제 디렉토리에서 실행 시 자동 추론
+```
+
+**설명:**
+
+- 문제 번호를 인자로 전달하거나 문제 디렉토리에서 실행하면 자동으로 문제 번호를 추론
+
+---
+
 ### `search` - 문제 검색
 
-solved.ac에서 문제를 검색합니다.
+solved.ac에서 문제를 검색하거나 백준 문제집의 문제 목록을 표시합니다.
+
+**사용법:**
+
+```bash
+ps search <쿼리> [옵션]
+ps search --workbook <문제집ID>
+```
+
+**옵션:**
+
+- `--workbook`: 문제집 ID를 지정하여 해당 문제집의 문제 목록을 표시
+
+**예제:**
 
 ```bash
-ps search "*g1...g5"
-ps search --workbook 12345
+ps search "*g1...g5"           # Gold 1-5 문제 검색
+ps search "tier:g1...g5"       # Gold 1-5 문제 검색 (tier: 문법)
+ps search "#dp"                 # DP 태그 문제 검색
+ps search "tag:dp"              # DP 태그 문제 검색 (tag: 문법)
+ps search "*g1...g5 #dp"        # Gold 1-5 티어의 DP 태그 문제 검색
+ps search --workbook 25052      # 문제집 25052의 문제 목록 표시
 ```
 
+**설명:**
+
+- solved.ac 검색어 문법을 지원합니다
+- 문제 목록에서 선택하면 자동으로 브라우저에서 문제 페이지를 엽니다
+- 페이지네이션을 통해 여러 페이지의 결과를 탐색할 수 있습니다
+- `--workbook` 옵션으로 백준 문제집의 문제 목록을 볼 수 있습니다
+
+---
+
 ### `stats` - 통계 조회
 
-Solved.ac 사용자 통계를 조회합니다.
+Solved.ac에서 사용자 통계를 조회합니다.
+
+**사용법:**
+
+```bash
+ps stats [핸들] [옵션]
+```
+
+**옵션:**
+
+- `--handle`, `-h`: Solved.ac 핸들
+  - 설정에 저장된 값 사용 가능
+  - 인자로 전달하거나 플래그로 지정 가능
+
+**예제:**
 
 ```bash
-ps stats
-ps stats myhandle
+ps stats myhandle              # myhandle의 통계 조회
+ps stats --handle myhandle     # 플래그로 핸들 지정
+ps stats                       # 설정에 저장된 핸들 사용
 ```
 
+**설명:**
+
+- 티어, 레이팅, 해결한 문제 수 등 표시
+- 그라데이션으로 시각적으로 표시
+- 핸들 우선순위: 인자 > 플래그 > 설정 파일
+
+---
+
 ### `config` - 설정 관리
 
-프로젝트 설정을 관리합니다.
+프로젝트 설정 파일(.ps-cli.json)을 관리합니다.
+
+**사용법:**
 
 ```bash
-ps config list
-ps config set default-language python
-ps config get archive-strategy
+ps config <명령어> [키] [값]
 ```
 
+**명령어:**
+
+- `get [키]`: 설정 값 조회 (키 없으면 대화형 선택)
+- `set [키] [값]`: 설정 값 설정 (키/값 없으면 대화형 선택)
+- `list`: 모든 설정 조회
+- `clear`: .ps-cli.json 파일 삭제
+
+**예제:**
+
+```bash
+ps config get                         # 대화형으로 키 선택 후 값 조회
+ps config get default-language         # default-language 값 조회
+ps config set                         # 대화형으로 키 선택 후 값 설정
+ps config set editor cursor            # editor를 cursor로 설정
+ps config list                         # 모든 설정 조회
+ps config clear                        # .ps-cli.json 파일 삭제
+```
+
+**설명:**
+
+- 설정은 현재 프로젝트의 .ps-cli.json 파일에 저장됩니다
+- 대화형 모드로 키와 값을 선택할 수 있습니다
+
 ## 설정
 
 프로젝트 루트의 `.ps-cli.json` 파일에 저장됩니다.
@@ -127,7 +341,7 @@ ps config get archive-strategy
 - `editor`: 에디터 명령어 (code, cursor, vim 등)
 - `auto-open-editor`: fetch 후 자동으로 에디터 열기 (true/false)
 - `solved-ac-handle`: Solved.ac 핸들
-- `problem-dir`: 아카이브된 문제 디렉토리 (기본값: problems)
+- `archive-dir`: 아카이브된 문제 디렉토리 (기본값: problems)
 - `solving-dir`: 푸는 중인 문제 디렉토리 (기본값: solving)
 - `archive-strategy`: 아카이빙 전략
 
@@ -173,7 +387,54 @@ ps config get archive-strategy
 3. **작성**: `solving/1000/`에서 코드 작성
 4. **테스트**: `ps test`로 로컬 테스트
 5. **제출**: `ps submit`으로 제출
-6. **아카이빙**: `ps solve`로 problem 디렉토리로 이동
+6. **아카이빙**: `ps archive`로 archive 디렉토리로 이동
+
+## 개발
+
+로컬에서 개발하거나 테스트할 때는 글로벌로 설치된 `ps` 명령어와 충돌을 피하기 위해 다음 방법을 사용할 수 있습니다:
+
+### 방법 1: 절대 경로로 직접 실행 (외부 폴더 테스트 가능)
+
+```bash
+# 빌드
+bun run build
+
+# 프로젝트 디렉토리에서 절대 경로로 실행
+/path/to/ps-cli/dist/index.js init
+/path/to/ps-cli/dist/index.js fetch 1000
+
+# 또는 프로젝트 디렉토리로 이동 후
+cd /path/to/ps-cli
+node dist/index.js init
+```
+
+### 방법 2: npm link 사용 (주의 필요)
+
+```bash
+# 프로젝트 디렉토리에서
+bun run build
+npm link
+
+# 외부 폴더에서 테스트
+cd /path/to/test-project
+ps init  # 로컬 버전이 사용됨
+
+# 테스트 후 링크 해제
+npm unlink -g @rhseung/ps-cli
+```
+
+**주의:** `npm link`를 사용하면 글로벌 설치된 버전이 링크된 버전으로 대체됩니다.
+
+### 방법 3: 프로젝트 내에서만 테스트
+
+```bash
+# 빌드
+bun run build
+
+# 프로젝트 디렉토리 내에서만
+bun run ps init
+bun run ps fetch 1000
+```
 
 ## 라이선스
 

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

@@ -9924,7 +9924,7 @@ var config = new Conf({
     autoOpenEditor: false,
     // 기본값: 자동 열기 비활성화
     solvedAcHandle: void 0,
-    problemDir: "problems",
+    archiveDir: "problems",
     // 기본값: problems 디렉토리
     solvingDir: "solving"
     // 기본값: solving 디렉토리
@@ -10009,12 +10009,12 @@ function getSolvedAcHandle() {
   }
   return config.get("solvedAcHandle");
 }
-function getProblemDir() {
+function getArchiveDir() {
   const projectConfig = getProjectConfigSync();
-  if (projectConfig?.problemDir !== void 0) {
-    return projectConfig.problemDir;
+  if (projectConfig?.archiveDir !== void 0) {
+    return projectConfig.archiveDir;
   }
-  return config.get("problemDir") ?? "problems";
+  return config.get("archiveDir") ?? "problems";
 }
 function getSolvingDir() {
   const projectConfig = getProjectConfigSync();
@@ -10264,11 +10264,11 @@ function getArchiveSubPath(problemId, strategy = "flat", problem) {
   }
 }
 function detectProblemIdFromPath(cwd = process.cwd()) {
-  const problemDir = getProblemDir();
+  const archiveDir = getArchiveDir();
   const solvingDir = getSolvingDir();
   const archiveStrategy = getArchiveStrategy();
   const normalizedPath = cwd.replace(/\\/g, "/");
-  const dirsToCheck = [problemDir, solvingDir].filter(
+  const dirsToCheck = [archiveDir, solvingDir].filter(
     (dir) => dir && dir !== "." && dir !== ""
   );
   if (dirsToCheck.length === 0) {
@@ -10359,22 +10359,22 @@ function getProblemId(args, cwd = process.cwd()) {
   }
   return detectProblemIdFromPath(cwd);
 }
-function getProblemDirPath(problemId, cwd = process.cwd(), problem) {
-  const problemDir = getProblemDir();
+function getArchiveDirPath(problemId, cwd = process.cwd(), problem) {
+  const archiveDir = getArchiveDir();
   const archiveStrategy = getArchiveStrategy();
   const projectRoot = findProjectRoot(cwd);
   const baseDir = projectRoot || cwd;
   const subPath = getArchiveSubPath(problemId, archiveStrategy, problem);
-  if (problemDir === "." || problemDir === "") {
+  if (archiveDir === "." || archiveDir === "") {
     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, archiveDir, subPath, problemId.toString());
   }
-  return join2(baseDir, problemDir, problemId.toString());
+  return join2(baseDir, archiveDir, problemId.toString());
 }
 function getSolvingDirPath(problemId, cwd = process.cwd(), _) {
   const solvingDir = getSolvingDir();
@@ -10408,27 +10408,27 @@ async function resolveProblemContext(args, options = {}) {
     );
   }
   const isCurrentDir = problemId === null || problemId !== null && currentPathProblemId === problemId;
-  let problemDir;
+  let archiveDir;
   if (problemId && !isCurrentDir) {
     const solvingDirPath = getSolvingDirPath(problemId);
-    const problemDirPath = getProblemDirPath(problemId);
+    const archiveDirPath = getArchiveDirPath(problemId);
     const solvingDirExists = await directoryExists(solvingDirPath);
     if (solvingDirExists) {
-      problemDir = solvingDirPath;
+      archiveDir = solvingDirPath;
     } else {
-      const problemDirExists = await directoryExists(problemDirPath);
-      if (problemDirExists) {
-        problemDir = problemDirPath;
+      const archiveDirExists = await directoryExists(archiveDirPath);
+      if (archiveDirExists) {
+        archiveDir = archiveDirPath;
       } else {
-        problemDir = solvingDirPath;
+        archiveDir = solvingDirPath;
       }
     }
   } else {
-    problemDir = process.cwd();
+    archiveDir = process.cwd();
   }
   return {
     problemId,
-    problemDir,
+    archiveDir,
     isCurrentDir
   };
 }
@@ -10594,7 +10594,7 @@ export {
   getEditor,
   getAutoOpenEditor,
   getSolvedAcHandle,
-  getProblemDir,
+  getArchiveDir,
   getSolvingDir,
   getArchiveStrategy,
   getNextTierMinRating,
@@ -10603,8 +10603,7 @@ export {
   getTierColor,
   getTierImageUrl,
   detectProblemIdFromPath,
-  getProblemId,
-  getProblemDirPath,
+  getArchiveDirPath,
   getSolvingDirPath,
   resolveProblemContext,
   resolveLanguage,

package/dist/commands/{solve.js → archive.js}

@@ -4,26 +4,26 @@ import {
   CommandBuilder,
   CommandDef,
   findProjectRoot,
-  getProblemDirPath,
-  getProblemId,
+  getArchiveDirPath,
   getSolvingDir,
-  getSolvingDirPath
-} from "../chunk-TNGUME4H.js";
+  getSolvingDirPath,
+  resolveProblemContext
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass
 } from "../chunk-7MQMPJ3X.js";
 
-// src/commands/solve.tsx
+// src/commands/archive.tsx
 import { StatusMessage, Alert } from "@inkjs/ui";
 import { Spinner } from "@inkjs/ui";
 import { Box } from "ink";
 
-// src/hooks/use-solve.ts
+// src/hooks/use-archive.ts
 import { access, readFile, rename, mkdir, readdir, rmdir } from "fs/promises";
 import { join, dirname } from "path";
 import { execa } from "execa";
 import { useEffect, useState } from "react";
-function useSolve({
+function useArchive({
   problemId,
   onComplete
 }) {
@@ -33,7 +33,7 @@ function useSolve({
   const [message, setMessage] = useState("\uBB38\uC81C\uB97C \uC544\uCE74\uC774\uBE0C\uD558\uB294 \uC911...");
   const [error, setError] = useState(null);
   useEffect(() => {
-    async function solve() {
+    async function archive() {
       try {
         const projectRoot = findProjectRoot();
         if (!projectRoot) {
@@ -71,22 +71,22 @@ function useSolve({
           }
         } catch {
         }
-        const problemDir = getProblemDirPath(problemId, projectRoot, problem);
+        const archiveDir = getArchiveDirPath(problemId, projectRoot, problem);
         try {
-          await access(problemDir);
+          await access(archiveDir);
           throw new Error(
-            `problem \uB514\uB809\uD1A0\uB9AC\uC5D0 \uC774\uBBF8 \uBB38\uC81C ${problemId}\uAC00 \uC874\uC7AC\uD569\uB2C8\uB2E4.`
+            `archive \uB514\uB809\uD1A0\uB9AC\uC5D0 \uC774\uBBF8 \uBB38\uC81C ${problemId}\uAC00 \uC874\uC7AC\uD569\uB2C8\uB2E4.`
           );
         } catch (err) {
           if (err instanceof Error && err.message.includes("\uC774\uBBF8")) {
             throw err;
           }
         }
-        const problemDirParent = dirname(problemDir);
+        const archiveDirParent = dirname(archiveDir);
         setMessage("\uC544\uCE74\uC774\uBE0C \uB514\uB809\uD1A0\uB9AC\uB97C \uC900\uBE44\uD558\uB294 \uC911...");
-        await mkdir(problemDirParent, { recursive: true });
-        setMessage("\uBB38\uC81C\uB97C problem \uB514\uB809\uD1A0\uB9AC\uB85C \uC774\uB3D9\uD558\uB294 \uC911...");
-        await rename(solvingDir, problemDir);
+        await mkdir(archiveDirParent, { recursive: true });
+        setMessage("\uBB38\uC81C\uB97C archive \uB514\uB809\uD1A0\uB9AC\uB85C \uC774\uB3D9\uD558\uB294 \uC911...");
+        await rename(solvingDir, archiveDir);
         setMessage("\uBE48 \uB514\uB809\uD1A0\uB9AC \uC815\uB9AC \uC911...");
         try {
           const solvingDirConfig = getSolvingDir();
@@ -111,7 +111,7 @@ function useSolve({
         }
         setMessage("Git \uCEE4\uBC0B\uC744 \uC2E4\uD589\uD558\uB294 \uC911...");
         try {
-          await execa("git", ["add", problemDir], { cwd: projectRoot });
+          await execa("git", ["add", archiveDir], { cwd: projectRoot });
           const commitMessage = `solve: ${problemId} - ${problemTitle}`;
           await execa("git", ["commit", "-m", commitMessage], {
             cwd: projectRoot
@@ -123,7 +123,7 @@ function useSolve({
           );
         }
         setStatus("success");
-        setMessage(`\uBB38\uC81C ${problemId}\uB97C \uC544\uCE74\uC774\uBE0C\uD588\uC2B5\uB2C8\uB2E4: ${problemDir}`);
+        setMessage(`\uBB38\uC81C ${problemId}\uB97C \uC544\uCE74\uC774\uBE0C\uD588\uC2B5\uB2C8\uB2E4: ${archiveDir}`);
         setTimeout(() => {
           onComplete?.();
         }, 2e3);
@@ -135,7 +135,7 @@ function useSolve({
         }, 2e3);
       }
     }
-    void solve();
+    void archive();
   }, [problemId, onComplete]);
   return {
     status,
@@ -144,10 +144,10 @@ function useSolve({
   };
 }
 
-// src/commands/solve.tsx
+// src/commands/archive.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
-function SolveView({ problemId, onComplete }) {
-  const { status, message, error } = useSolve({
+function ArchiveView({ problemId, onComplete }) {
+  const { status, message, error } = useArchive({
     problemId,
     onComplete
   });
@@ -162,40 +162,40 @@ function SolveView({ problemId, onComplete }) {
   }
   return /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: "100%", children: /* @__PURE__ */ jsx(StatusMessage, { variant: "success", children: message }) });
 }
-var SolveCommand = class extends Command {
+var ArchiveCommand = class extends Command {
   async execute(args, _) {
-    const problemId = getProblemId(args);
-    if (problemId === null) {
+    const context = await resolveProblemContext(args, { requireId: false });
+    if (context.problemId === null) {
       console.error("\uC624\uB958: \uBB38\uC81C \uBC88\uD638\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694.");
-      console.error(`\uC0AC\uC6A9\uBC95: ps solve <\uBB38\uC81C\uBC88\uD638>`);
-      console.error(`\uB3C4\uC6C0\uB9D0: ps solve --help`);
+      console.error(`\uC0AC\uC6A9\uBC95: ps archive <\uBB38\uC81C\uBC88\uD638>`);
+      console.error(`\uB3C4\uC6C0\uB9D0: ps archive --help`);
       console.error(
         `\uD78C\uD2B8: solving/{\uBB38\uC81C\uBC88\uD638} \uB514\uB809\uD1A0\uB9AC\uC5D0\uC11C \uC2E4\uD589\uD558\uBA74 \uC790\uB3D9\uC73C\uB85C \uBB38\uC81C \uBC88\uD638\uB97C \uCD94\uB860\uD569\uB2C8\uB2E4.`
       );
       process.exit(1);
       return;
     }
-    await this.renderView(SolveView, {
-      problemId
+    await this.renderView(ArchiveView, {
+      problemId: context.problemId
     });
   }
 };
-SolveCommand = __decorateClass([
+ArchiveCommand = __decorateClass([
   CommandDef({
-    name: "solve",
+    name: "archive",
     description: `\uBB38\uC81C\uB97C \uC544\uCE74\uC774\uBE0C\uD558\uACE0 Git \uCEE4\uBC0B\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4.
-- solving \uB514\uB809\uD1A0\uB9AC\uC5D0\uC11C \uBB38\uC81C\uB97C \uCC3E\uC544 problem \uB514\uB809\uD1A0\uB9AC\uB85C \uC774\uB3D9
+- solving \uB514\uB809\uD1A0\uB9AC\uC5D0\uC11C \uBB38\uC81C\uB97C \uCC3E\uC544 archive \uB514\uB809\uD1A0\uB9AC\uB85C \uC774\uB3D9
 - Git add \uBC0F commit \uC2E4\uD589 (\uCEE4\uBC0B \uBA54\uC2DC\uC9C0: "solve: {\uBB38\uC81C\uBC88\uD638} - {\uBB38\uC81C\uC774\uB984}")`,
     autoDetectProblemId: true,
     requireProblemId: false,
     examples: [
-      "solve 1000",
-      "solve                    # \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC\uC5D0\uC11C \uBB38\uC81C \uBC88\uD638 \uC790\uB3D9 \uAC10\uC9C0"
+      "archive 1000",
+      "archive                    # \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC\uC5D0\uC11C \uBB38\uC81C \uBC88\uD638 \uC790\uB3D9 \uAC10\uC9C0"
     ]
   })
-], SolveCommand);
-var solve_default = CommandBuilder.fromClass(SolveCommand);
+], ArchiveCommand);
+var archive_default = CommandBuilder.fromClass(ArchiveCommand);
 export {
-  SolveCommand,
-  solve_default as default
+  ArchiveCommand,
+  archive_default as default
 };

package/dist/commands/config.js

@@ -3,13 +3,13 @@ import {
   Command,
   CommandBuilder,
   CommandDef,
+  getArchiveDir,
   getArchiveStrategy,
   getAutoOpenEditor,
   getDefaultLanguage,
   getEditor,
-  getProblemDir,
   getSolvedAcHandle
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass,
   getSupportedLanguages,
@@ -102,8 +102,8 @@ function useConfig({
           case "solved-ac-handle":
             updatedConfig.solvedAcHandle = value;
             break;
-          case "problem-dir":
-            updatedConfig.problemDir = value;
+          case "archive-dir":
+            updatedConfig.archiveDir = value;
             break;
           case "archive-strategy": {
             const validStrategies = ["flat", "by-range", "by-tier", "by-tag"];
@@ -159,7 +159,7 @@ function getConfigHelp() {
     editor                 \uC5D0\uB514\uD130 \uBA85\uB839\uC5B4 (\uC608: code, vim, nano)
     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-dir            \uC544\uCE74\uC774\uBE0C \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:
@@ -180,7 +180,7 @@ 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: "archive-dir", value: "archive-dir" },
   { label: "archive-strategy", value: "archive-strategy" }
 ];
 function ConfigView({
@@ -213,7 +213,7 @@ function ConfigView({
     const editor = config?.editor ?? getEditor();
     const autoOpen = config?.autoOpenEditor ?? getAutoOpenEditor();
     const handle = config?.solvedAcHandle ?? getSolvedAcHandle();
-    const problemDir = config?.problemDir ?? getProblemDir();
+    const archiveDir = config?.archiveDir ?? getArchiveDir();
     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)" }) }),
@@ -239,9 +239,9 @@ function ConfigView({
           /* @__PURE__ */ jsx(Text, { bold: true, color: handle ? "cyan" : "gray", children: handle || "\uC124\uC815 \uC548 \uB428" })
         ] }),
         /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: "problem-dir:" }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "archive-dir:" }),
           /* @__PURE__ */ jsx(Text, { children: " " }),
-          /* @__PURE__ */ jsx(Text, { bold: true, children: problemDir })
+          /* @__PURE__ */ jsx(Text, { bold: true, children: archiveDir })
         ] }),
         /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
           /* @__PURE__ */ jsx(Text, { color: "gray", children: "archive-strategy:" }),
@@ -266,8 +266,8 @@ function ConfigView({
       case "solved-ac-handle":
         configValue = config?.solvedAcHandle ?? getSolvedAcHandle();
         break;
-      case "problem-dir":
-        configValue = config?.problemDir ?? getProblemDir();
+      case "archive-dir":
+        configValue = config?.archiveDir ?? getArchiveDir();
         break;
       case "archive-strategy":
         configValue = config?.archiveStrategy ?? getArchiveStrategy();
@@ -440,8 +440,8 @@ var ConfigCommand = class extends Command {
           return "true \uB610\uB294 false \uC785\uB825";
         case "solved-ac-handle":
           return "Solved.ac \uD578\uB4E4 \uC785\uB825";
-        case "problem-dir":
-          return "\uBB38\uC81C \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C \uC785\uB825";
+        case "archive-dir":
+          return "\uC544\uCE74\uC774\uBE0C \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:
@@ -458,8 +458,8 @@ var ConfigCommand = class extends Command {
           return "fetch \uD6C4 \uC790\uB3D9\uC73C\uB85C \uC5D0\uB514\uD130\uB97C \uC5F4\uC9C0 \uC5EC\uBD80";
         case "solved-ac-handle":
           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-dir":
+          return '\uC544\uCE74\uC774\uBE0C \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:
@@ -474,7 +474,7 @@ var ConfigCommand = class extends Command {
           return ["code", "cursor", "vim", "nano"];
         case "auto-open-editor":
           return ["true", "false"];
-        case "problem-dir":
+        case "archive-dir":
           return ["problems", ".", ""];
         case "archive-strategy":
           return ["flat", "by-range", "by-tier", "by-tag"];

package/dist/commands/fetch.js

@@ -11,12 +11,12 @@ import {
   CommandDef,
   getAutoOpenEditor,
   getEditor,
-  getProblemId,
   getSolvingDirPath,
   getTierColor,
   getTierImageUrl,
-  getTierName
-} from "../chunk-TNGUME4H.js";
+  getTierName,
+  resolveProblemContext
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass,
   getLanguageConfig,
@@ -75,6 +75,27 @@ function parseTimeLimitToMs(timeLimit) {
   if (Number.isNaN(seconds)) return void 0;
   return Math.round(seconds * 1e3);
 }
+function ensureTrailingNewline(content) {
+  if (!content || content.trim().length === 0) {
+    return content;
+  }
+  const trimmed = content.trimEnd();
+  if (trimmed.length === 0) {
+    return content;
+  }
+  const lines = trimmed.split("\n");
+  const lastLine = lines[lines.length - 1];
+  const isListItem = /^[\s]*[-*]\s/.test(lastLine) || /^[\s]*\d+[.)]\s/.test(lastLine);
+  const isTableRow = /^\s*\|.+\|\s*$/.test(lastLine);
+  const isCodeBlock = trimmed.endsWith("```");
+  if (isListItem || isTableRow || isCodeBlock) {
+    return trimmed + "\n";
+  }
+  if (!content.endsWith("\n")) {
+    return content + "\n";
+  }
+  return content;
+}
 function getProjectRoot() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
@@ -150,16 +171,19 @@ ${separatorRow}
 ${valueRow}
 `;
   }
+  const description = ensureTrailingNewline(problem.description || "\uC124\uBA85 \uC5C6\uC74C");
+  const inputFormat = ensureTrailingNewline(
+    problem.inputFormat || "\uC785\uB825 \uD615\uC2DD \uC5C6\uC74C"
+  );
+  const outputFormat = ensureTrailingNewline(
+    problem.outputFormat || "\uCD9C\uB825 \uD615\uC2DD \uC5C6\uC74C"
+  );
   const readmeContent = `# [${problem.id}: ${problem.title}](https://www.acmicpc.net/problem/${problem.id})
 
 ${infoTable}## \uBB38\uC81C \uC124\uBA85
-${problem.description || "\uC124\uBA85 \uC5C6\uC74C"}
-
-## \uC785\uB825
-${problem.inputFormat || "\uC785\uB825 \uD615\uC2DD \uC5C6\uC74C"}
-
-## \uCD9C\uB825
-${problem.outputFormat || "\uCD9C\uB825 \uD615\uC2DD \uC5C6\uC74C"}
+${description}## \uC785\uB825
+${inputFormat}## \uCD9C\uB825
+${outputFormat}
 
 ## \uC608\uC81C
 ${problem.testCases.map(
@@ -317,8 +341,8 @@ function FetchView({
 }
 var FetchCommand = class extends Command {
   async execute(args, flags) {
-    const problemId = getProblemId(args);
-    if (problemId === null) {
+    const context = await resolveProblemContext(args, { requireId: true });
+    if (context.problemId === null) {
       console.error("\uC624\uB958: \uBB38\uC81C \uBC88\uD638\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694.");
       console.error(`\uC0AC\uC6A9\uBC95: ps fetch <\uBB38\uC81C\uBC88\uD638> [\uC635\uC158]`);
       console.error(`\uB3C4\uC6C0\uB9D0: ps fetch --help`);
@@ -338,7 +362,7 @@ var FetchCommand = class extends Command {
       return;
     }
     await this.renderView(FetchView, {
-      problemId,
+      problemId: context.problemId,
       language: language || "python"
     });
   }

package/dist/commands/init.js

@@ -3,14 +3,14 @@ import {
   Command,
   CommandBuilder,
   CommandDef,
+  getArchiveDir,
   getArchiveStrategy,
   getAutoOpenEditor,
   getDefaultLanguage,
   getEditor,
-  getProblemDir,
   getSolvedAcHandle,
   getSolvingDir
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass,
   getSupportedLanguages
@@ -32,11 +32,11 @@ import { join } from "path";
 import { execaCommand, execa } from "execa";
 import { useEffect, useState, useCallback } from "react";
 function useInit({ onComplete }) {
-  const [currentStep, setCurrentStep] = useState("problem-dir");
+  const [currentStep, setCurrentStep] = useState("archive-dir");
   const [completedSteps, setCompletedSteps] = useState([]);
   const [confirmExit, setConfirmExit] = useState(false);
   const [initialized, setInitialized] = useState(false);
-  const [problemDir, setProblemDirValue] = useState(getProblemDir());
+  const [archiveDir, setArchiveDirValue] = useState(getArchiveDir());
   const [solvingDir, setSolvingDirValue] = useState(getSolvingDir());
   const [archiveStrategy, setArchiveStrategy] = useState(getArchiveStrategy());
   const [language, setLanguage] = useState(getDefaultLanguage());
@@ -71,8 +71,8 @@ function useInit({ onComplete }) {
         await access(projectConfigPath);
         const configContent = await readFile(projectConfigPath, "utf-8");
         const projectConfig = JSON.parse(configContent);
-        if (projectConfig.problemDir)
-          setProblemDirValue(projectConfig.problemDir);
+        if (projectConfig.archiveDir)
+          setArchiveDirValue(projectConfig.archiveDir);
         if (projectConfig.solvingDir)
           setSolvingDirValue(projectConfig.solvingDir);
         if (projectConfig.archiveStrategy)
@@ -93,8 +93,8 @@ function useInit({ onComplete }) {
   }, []);
   const getStepLabel = useCallback((step) => {
     switch (step) {
-      case "problem-dir":
-        return "\uBB38\uC81C \uB514\uB809\uD1A0\uB9AC \uC124\uC815 (\uC544\uCE74\uC774\uBE0C\uB41C \uBB38\uC81C)";
+      case "archive-dir":
+        return "\uC544\uCE74\uC774\uBE0C \uB514\uB809\uD1A0\uB9AC \uC124\uC815 (\uC544\uCE74\uC774\uBE0C\uB41C \uBB38\uC81C)";
       case "solving-dir":
         return "Solving \uB514\uB809\uD1A0\uB9AC \uC124\uC815 (\uD478\uB294 \uC911\uC778 \uBB38\uC81C)";
       case "archive-strategy":
@@ -114,8 +114,8 @@ function useInit({ onComplete }) {
   const getStepValue = useCallback(
     (step) => {
       switch (step) {
-        case "problem-dir":
-          return problemDir === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : problemDir;
+        case "archive-dir":
+          return archiveDir === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : archiveDir;
         case "solving-dir":
           return solvingDir === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : solvingDir;
         case "archive-strategy": {
@@ -140,13 +140,13 @@ function useInit({ onComplete }) {
       }
     },
     [
-      problemDir,
+      archiveDir,
       solvingDir,
-      archiveStrategy,
       language,
       editor,
       autoOpen,
-      handle
+      handle,
+      archiveStrategy
     ]
   );
   const executeInit = useCallback(
@@ -155,7 +155,7 @@ function useInit({ onComplete }) {
         const cwd = process.cwd();
         const projectConfigPath = join(cwd, ".ps-cli.json");
         const projectConfig = {
-          problemDir,
+          archiveDir,
           solvingDir,
           archiveStrategy,
           defaultLanguage: language,
@@ -172,11 +172,11 @@ function useInit({ onComplete }) {
           "utf-8"
         );
         setCreated((prev) => [...prev, ".ps-cli.json"]);
-        if (problemDir !== "." && problemDir !== "") {
-          const problemDirPath = join(cwd, problemDir);
+        if (archiveDir !== "." && archiveDir !== "") {
+          const archiveDirPath = join(cwd, archiveDir);
           try {
-            await mkdir(problemDirPath, { recursive: true });
-            setCreated((prev) => [...prev, `${problemDir}/`]);
+            await mkdir(archiveDirPath, { recursive: true });
+            setCreated((prev) => [...prev, `${archiveDir}/`]);
           } catch (err) {
             const error = err;
             if (error.code !== "EEXIST") {
@@ -280,7 +280,7 @@ ${gitignorePatterns.join("\n")}
       }
     },
     [
-      problemDir,
+      archiveDir,
       solvingDir,
       archiveStrategy,
       language,
@@ -300,7 +300,7 @@ ${gitignorePatterns.join("\n")}
         setHandle(handleValue);
       }
       const stepOrder = [
-        "problem-dir",
+        "archive-dir",
         "solving-dir",
         "archive-strategy",
         "language",
@@ -322,24 +322,14 @@ ${gitignorePatterns.join("\n")}
         }
       }
     },
-    [
-      currentStep,
-      executeInit,
-      problemDir,
-      solvingDir,
-      archiveStrategy,
-      language,
-      editor,
-      autoOpen,
-      onComplete
-    ]
+    [currentStep, executeInit]
   );
   return {
     currentStep,
     completedSteps,
     confirmExit,
     initialized,
-    problemDir,
+    archiveDir,
     solvingDir,
     archiveStrategy,
     language,
@@ -349,7 +339,7 @@ ${gitignorePatterns.join("\n")}
     handleInputMode,
     created,
     cancelled,
-    setProblemDirValue,
+    setArchiveDirValue,
     setSolvingDirValue,
     setArchiveStrategy,
     setLanguage,
@@ -366,6 +356,22 @@ ${gitignorePatterns.join("\n")}
   };
 }
 
+// src/utils/version.ts
+import { readFileSync } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+function getVersion() {
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join2(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "";
+  }
+}
+
 // src/commands/init.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 function InitView({ onComplete }) {
@@ -377,7 +383,7 @@ function InitView({ onComplete }) {
     handleInputMode,
     created,
     cancelled,
-    setProblemDirValue,
+    setArchiveDirValue,
     setSolvingDirValue,
     setArchiveStrategy,
     setLanguage,
@@ -424,7 +430,7 @@ function InitView({ onComplete }) {
       ] });
     }
     switch (currentStep) {
-      case "problem-dir": {
+      case "archive-dir": {
         const options = [
           { label: "problems", value: "problems" },
           { label: ". (\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8)", value: "." }
@@ -436,7 +442,7 @@ function InitView({ onComplete }) {
             {
               options,
               onChange: (value) => {
-                setProblemDirValue(value);
+                setArchiveDirValue(value);
                 const displayValue = value === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : value;
                 moveToNextStep(displayValue, getStepLabel(currentStep));
               }
@@ -626,8 +632,16 @@ ${created.map((item) => `\u2022 ${item}`).join("\n")}` : "";
   if (!initialized) {
     return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "\uB85C\uB529 \uC911..." }) });
   }
+  const version = getVersion();
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Box, { marginBottom: completedSteps.length > 0 ? 1 : 0, children: /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u{1F680} ps-cli \uD504\uB85C\uC81D\uD2B8 \uCD08\uAE30\uD654" }) }),
+    /* @__PURE__ */ jsxs(Box, { marginBottom: completedSteps.length > 0 ? 1 : 0, children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u{1F680} ps-cli \uD504\uB85C\uC81D\uD2B8 \uCD08\uAE30\uD654" }),
+      version && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+        " ",
+        "v",
+        version
+      ] })
+    ] }),
     completedSteps.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: completedSteps.map((step, idx) => /* @__PURE__ */ jsxs(StatusMessage, { variant: "success", children: [
       step.label,
       ": ",

package/dist/commands/open.js

@@ -7,9 +7,8 @@ import {
   Command,
   CommandBuilder,
   CommandDef,
-  getProblemId,
   resolveProblemContext
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass
 } from "../chunk-7MQMPJ3X.js";
@@ -63,11 +62,7 @@ function OpenView({ problemId, onComplete }) {
 }
 var OpenCommand = class extends Command {
   async execute(args, _flags) {
-    const problemId = getProblemId(args);
-    const context = await resolveProblemContext(
-      problemId !== null ? [problemId.toString()] : [],
-      { requireId: true }
-    );
+    const context = await resolveProblemContext(args, { requireId: true });
     if (context.problemId === null) {
       console.error("\uC624\uB958: \uBB38\uC81C \uBC88\uD638\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694.");
       console.error(`\uC0AC\uC6A9\uBC95: ps open <\uBB38\uC81C\uBC88\uD638>`);

package/dist/commands/run.js

@@ -6,10 +6,9 @@ import {
   Command,
   CommandBuilder,
   CommandDef,
-  getProblemId,
   resolveLanguage,
   resolveProblemContext
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass,
   getSupportedLanguagesString
@@ -123,17 +122,14 @@ function RunView({
 }
 var RunCommand = class extends Command {
   async execute(args, flags) {
-    const problemId = getProblemId(args);
-    const context = await resolveProblemContext(
-      problemId !== null ? [problemId.toString()] : []
-    );
-    const inputPath = flags.input ? join(context.problemDir, flags.input) : await this.findInputFile(context.problemDir);
+    const context = await resolveProblemContext(args);
+    const inputPath = flags.input ? join(context.archiveDir, flags.input) : await this.findInputFile(context.archiveDir);
     const detectedLanguage = await resolveLanguage(
-      context.problemDir,
+      context.archiveDir,
       flags.language
     );
     await this.renderView(RunView, {
-      problemDir: context.problemDir,
+      problemDir: context.archiveDir,
       language: detectedLanguage,
       inputFile: inputPath
     });

package/dist/commands/search.js

@@ -16,10 +16,10 @@ import {
   Command,
   CommandBuilder,
   CommandDef,
-  getProblemDirPath,
+  getArchiveDirPath,
   getTierColor,
   getTierName
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass
 } from "../chunk-7MQMPJ3X.js";
@@ -270,7 +270,7 @@ function WorkbookSearchView({
     ] });
   }
   const problemsWithSolvedStatus = problems.map((problem) => {
-    const problemDirPath = getProblemDirPath(problem.problemId);
+    const problemDirPath = getArchiveDirPath(problem.problemId);
     const isSolved = existsSync(problemDirPath);
     return {
       problemId: problem.problemId,
@@ -362,7 +362,7 @@ function SearchView({ query, onComplete }) {
         const searchResults = await searchProblems(query, currentPage);
         const resultsWithSolvedStatus = searchResults.problems.map(
           (problem) => {
-            const problemDirPath = getProblemDirPath(problem.problemId);
+            const problemDirPath = getArchiveDirPath(problem.problemId);
             const isSolved = existsSync(problemDirPath);
             return {
               ...problem,

package/dist/commands/stats.js

@@ -14,7 +14,7 @@ import {
   getSolvedAcHandle,
   getTierColor,
   getTierName
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass
 } from "../chunk-7MQMPJ3X.js";

package/dist/commands/submit.js

@@ -8,10 +8,9 @@ import {
   CommandDef,
   detectProblemIdFromPath,
   findSolutionFile,
-  getProblemId,
   resolveLanguage,
   resolveProblemContext
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass,
   getSupportedLanguagesString
@@ -195,19 +194,15 @@ function SubmitView({
 }
 var SubmitCommand = class extends Command {
   async execute(args, flags) {
-    const problemId = getProblemId(args);
-    const context = await resolveProblemContext(
-      problemId !== null ? [problemId.toString()] : [],
-      { requireId: true }
-    );
-    const sourcePath = await findSolutionFile(context.problemDir);
+    const context = await resolveProblemContext(args, { requireId: true });
+    const sourcePath = await findSolutionFile(context.archiveDir);
     const detectedLanguage = await resolveLanguage(
-      context.problemDir,
+      context.archiveDir,
       flags.language
     );
     let finalProblemId = context.problemId;
     if (finalProblemId === null) {
-      finalProblemId = detectProblemIdFromPath(context.problemDir);
+      finalProblemId = detectProblemIdFromPath(context.archiveDir);
     }
     if (finalProblemId === null) {
       throw new Error(

package/dist/commands/test.js

@@ -6,10 +6,9 @@ import {
   Command,
   CommandBuilder,
   CommandDef,
-  getProblemId,
   resolveLanguage,
   resolveProblemContext
-} from "../chunk-TNGUME4H.js";
+} from "../chunk-F4LZ6ENP.js";
 import {
   __decorateClass,
   getSupportedLanguagesString
@@ -317,16 +316,13 @@ function TestView({
 }
 var TestCommand = class extends Command {
   async execute(args, flags) {
-    const problemId = getProblemId(args);
-    const context = await resolveProblemContext(
-      problemId !== null && problemId !== void 0 ? [problemId.toString()] : []
-    );
+    const context = await resolveProblemContext(args);
     const language = await resolveLanguage(
-      context.problemDir,
+      context.archiveDir,
       flags.language
     );
     await this.renderView(TestView, {
-      problemDir: context.problemDir,
+      problemDir: context.archiveDir,
       language,
       watch: Boolean(flags.watch),
       timeoutMs: flags.timeoutMs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhseung/ps-cli",
-  "version": "1.7.2",
+  "version": "1.7.4",
   "description": "백준(BOJ) 문제 해결을 위한 통합 CLI 도구",
   "type": "module",
   "bin": {
@@ -8,11 +8,14 @@
   },
   "files": [
     "dist",
-    "templates"
+    "templates",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup && node scripts/add-shebang.js",
+    "prepublishOnly": "npm run build",
     "dev": "tsup --watch",
+    "ps": "node dist/index.js",
     "typecheck": "tsc --noEmit",
     "lint": "eslint",
     "format": "prettier --check .",