pmpt-cli 1.5.0 → 1.5.2

package/dist/commands/browse.js

@@ -3,27 +3,27 @@ import { fetchProjects } from '../lib/api.js';
 export async function cmdBrowse() {
     p.intro('pmpt browse');
     const s = p.spinner();
-    s.start('프로젝트 목록 불러오는 중...');
+    s.start('Loading projects...');
     let projects;
     try {
         const index = await fetchProjects();
         projects = index.projects;
     }
     catch (err) {
-        s.stop('불러오기 실패');
-        p.log.error(err instanceof Error ? err.message : '프로젝트 목록을 불러올 수 없습니다.');
+        s.stop('Failed to load');
+        p.log.error(err instanceof Error ? err.message : 'Could not load project list.');
         process.exit(1);
     }
-    s.stop(`${projects.length}개 프로젝트`);
+    s.stop(`${projects.length} projects`);
     if (projects.length === 0) {
-        p.log.info('아직 공개된 프로젝트가 없습니다.');
-        p.log.message('  pmpt publish  — 첫 번째 프로젝트를 공유해보세요!');
+        p.log.info('No published projects yet.');
+        p.log.message('  pmpt publish  — share your first project!');
         p.outro('');
         return;
     }
     // Select project
     const selected = await p.select({
-        message: '프로젝트를 선택하세요:',
+        message: 'Select a project:',
         options: projects.map((proj) => ({
             value: proj.slug,
             label: proj.projectName,
@@ -47,11 +47,11 @@ export async function cmdBrowse() {
     ].filter(Boolean).join('\n'), 'Project Details');
     // Action
     const action = await p.select({
-        message: '어떻게 할까요?',
+        message: 'What would you like to do?',
         options: [
-            { value: 'clone', label: '이 프로젝트 복제', hint: 'pmpt clone' },
-            { value: 'url', label: 'URL 표시', hint: '브라우저에서 보기' },
-            { value: 'back', label: '돌아가기' },
+            { value: 'clone', label: 'Clone this project', hint: 'pmpt clone' },
+            { value: 'url', label: 'Show URL', hint: 'View in browser' },
+            { value: 'back', label: 'Go back' },
         ],
     });
     if (p.isCancel(action) || action === 'back') {
@@ -67,7 +67,7 @@ export async function cmdBrowse() {
         const url = `https://pmptwiki.com/ko/p/${project.slug}`;
         p.log.info(`URL: ${url}`);
         p.log.message(`Download: ${project.downloadUrl}`);
-        p.log.message(`\npmpt clone ${project.slug}  — 터미널에서 복제`);
+        p.log.message(`\npmpt clone ${project.slug}  — clone via terminal`);
         p.outro('');
     }
 }

package/dist/commands/clone.js

@@ -46,31 +46,31 @@ export function restoreDocs(docsDir, docs) {
 }
 export async function cmdClone(slug) {
     if (!slug) {
-        p.log.error('slug를 입력하세요.');
-        p.log.info('사용법: pmpt clone <slug>');
+        p.log.error('Please provide a slug.');
+        p.log.info('Usage: pmpt clone <slug>');
         process.exit(1);
     }
     p.intro(`pmpt clone — ${slug}`);
     const s = p.spinner();
-    s.start('프로젝트 다운로드 중...');
+    s.start('Downloading project...');
     let fileContent;
     try {
         fileContent = await fetchPmptFile(slug);
     }
     catch (err) {
-        s.stop('다운로드 실패');
-        p.log.error(err instanceof Error ? err.message : '프로젝트를 찾을 수 없습니다.');
+        s.stop('Download failed');
+        p.log.error(err instanceof Error ? err.message : 'Project not found.');
         process.exit(1);
     }
-    s.message('검증 중...');
+    s.message('Validating...');
     const validation = validatePmptFile(fileContent);
     if (!validation.success || !validation.data) {
-        s.stop('검증 실패');
-        p.log.error(validation.error || '잘못된 .pmpt 파일입니다.');
+        s.stop('Validation failed');
+        p.log.error(validation.error || 'Invalid .pmpt file.');
         process.exit(1);
     }
     const pmptData = validation.data;
-    s.stop('다운로드 완료');
+    s.stop('Download complete');
     // Show summary
     p.note([
         `Project: ${pmptData.meta.projectName}`,
@@ -81,16 +81,16 @@ export async function cmdClone(slug) {
     const projectPath = process.cwd();
     if (isInitialized(projectPath)) {
         const overwrite = await p.confirm({
-            message: '이미 초기화된 프로젝트입니다. 히스토리를 병합하시겠습니까?',
+            message: 'Project already initialized. Merge history?',
             initialValue: true,
         });
         if (p.isCancel(overwrite) || !overwrite) {
-            p.cancel('취소됨');
+            p.cancel('Cancelled');
             process.exit(0);
         }
     }
     const importSpinner = p.spinner();
-    importSpinner.start('프로젝트 복원 중...');
+    importSpinner.start('Restoring project...');
     if (!isInitialized(projectPath)) {
         initializeProject(projectPath, { trackGit: true });
     }
@@ -113,15 +113,15 @@ export async function cmdClone(slug) {
     if (existsSync(historyDir)) {
         versionCount = readdirSync(historyDir).filter((d) => d.startsWith('v')).length;
     }
-    importSpinner.stop('복원 완료!');
+    importSpinner.stop('Restore complete!');
     p.note([
         `Project: ${pmptData.meta.projectName}`,
         `Versions: ${versionCount}`,
         `Location: ${pmptDir}`,
     ].join('\n'), 'Clone Summary');
-    p.log.info('다음 단계:');
-    p.log.message('  pmpt history    — 버전 히스토리 보기');
-    p.log.message('  pmpt plan       — AI 프롬프트 보기');
-    p.log.message('  pmpt save       — 새 스냅샷 저장');
-    p.outro('프로젝트가 복제되었습니다!');
+    p.log.info('Next steps:');
+    p.log.message('  pmpt history    — view version history');
+    p.log.message('  pmpt plan       — view AI prompt');
+    p.log.message('  pmpt save       — save a new snapshot');
+    p.outro('Project cloned!');
 }

package/dist/commands/login.js

@@ -18,34 +18,34 @@ export async function cmdLogin() {
     }
     // Step 1: Request device code
     const s = p.spinner();
-    s.start('GitHub 인증 준비 중...');
+    s.start('Preparing GitHub authentication...');
     let device;
     try {
         device = await requestDeviceCode();
-        s.stop('인증 코드가 발급되었습니다.');
+        s.stop('Verification code issued.');
     }
     catch (err) {
-        s.stop('인증 코드 발급 실패');
-        p.log.error(err instanceof Error ? err.message : '인증 준비에 실패했습니다.');
+        s.stop('Failed to issue verification code');
+        p.log.error(err instanceof Error ? err.message : 'Failed to prepare authentication.');
         process.exit(1);
     }
     // Step 2: Show code and open browser
-    p.log.info(`아래 코드를 GitHub에 입력하세요:\n\n` +
-        `  코드: ${device.userCode}\n` +
-        `  주소: ${device.verificationUri}`);
+    p.log.info(`Enter this code on GitHub:\n\n` +
+        `  Code: ${device.userCode}\n` +
+        `  URL:  ${device.verificationUri}`);
     const shouldOpen = await p.confirm({
-        message: '브라우저를 열까요?',
+        message: 'Open browser?',
         initialValue: true,
     });
     if (p.isCancel(shouldOpen)) {
-        p.cancel('취소됨');
+        p.cancel('Cancelled');
         process.exit(0);
     }
     if (shouldOpen) {
         await open(device.verificationUri);
     }
     // Step 3: Poll for token
-    s.start('GitHub 인증 대기 중... (브라우저에서 코드를 입력하세요)');
+    s.start('Waiting for GitHub authorization... (enter the code in your browser)');
     let interval = device.interval * 1000; // seconds → ms
     const deadline = Date.now() + device.expiresIn * 1000;
     while (Date.now() < deadline) {
@@ -54,8 +54,8 @@ export async function cmdLogin() {
             const result = await pollDeviceToken(device.deviceCode);
             if (result.status === 'complete') {
                 saveAuth({ token: result.token, username: result.username });
-                s.stop(`인증 완료 — @${result.username}`);
-                p.outro('로그인 완료! pmpt publish로 프로젝트를 공유하세요.');
+                s.stop(`Authenticated — @${result.username}`);
+                p.outro('Login complete! Build projects with AI using pmpt and share your vibe coding journey on pmptwiki.');
                 return;
             }
             if (result.status === 'slow_down') {
@@ -64,13 +64,13 @@ export async function cmdLogin() {
             // status === 'pending' → keep polling
         }
         catch (err) {
-            s.stop('인증 실패');
-            p.log.error(err instanceof Error ? err.message : '인증에 실패했습니다.');
+            s.stop('Authentication failed');
+            p.log.error(err instanceof Error ? err.message : 'Authentication failed.');
             process.exit(1);
         }
     }
-    s.stop('인증 코드가 만료되었습니다.');
-    p.log.error('다시 pmpt login을 실행해 주세요.');
+    s.stop('Verification code expired.');
+    p.log.error('Please run pmpt login again.');
     process.exit(1);
 }
 function sleep(ms) {

package/dist/commands/publish.js

@@ -25,12 +25,12 @@ function readDocsFolder(docsDir) {
 export async function cmdPublish(path) {
     const projectPath = path ? resolve(path) : process.cwd();
     if (!isInitialized(projectPath)) {
-        p.log.error('프로젝트가 초기화되지 않았습니다. `pmpt init`을 먼저 실행하세요.');
+        p.log.error('Project not initialized. Run `pmpt init` first.');
         process.exit(1);
     }
     const auth = loadAuth();
     if (!auth?.token || !auth?.username) {
-        p.log.error('로그인이 필요합니다. `pmpt login`을 먼저 실행하세요.');
+        p.log.error('Login required. Run `pmpt login` first.');
         process.exit(1);
     }
     p.intro('pmpt publish');
@@ -38,41 +38,41 @@ export async function cmdPublish(path) {
     const snapshots = getAllSnapshots(projectPath);
     const planProgress = getPlanProgress(projectPath);
     if (snapshots.length === 0) {
-        p.log.warn('스냅샷이 없습니다. `pmpt save` 또는 `pmpt plan`을 먼저 실행하세요.');
+        p.log.warn('No snapshots found. Run `pmpt save` or `pmpt plan` first.');
         p.outro('');
         return;
     }
     const projectName = planProgress?.answers?.projectName || basename(projectPath);
     // Collect publish info
     const slug = await p.text({
-        message: '프로젝트 slug (URL에 사용될 이름):',
+        message: 'Project slug (used in URL):',
         placeholder: projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-'),
         validate: (v) => {
             if (!/^[a-z0-9][a-z0-9-]{1,48}[a-z0-9]$/.test(v)) {
-                return '3~50자, 소문자/숫자/하이픈만 사용 가능합니다.';
+                return '3-50 chars, lowercase letters, numbers, and hyphens only.';
             }
         },
     });
     if (p.isCancel(slug)) {
-        p.cancel('취소됨');
+        p.cancel('Cancelled');
         process.exit(0);
     }
     const description = await p.text({
-        message: '프로젝트 설명 (짧게):',
+        message: 'Project description (brief):',
         placeholder: planProgress?.answers?.productIdea?.slice(0, 100) || '',
         defaultValue: planProgress?.answers?.productIdea?.slice(0, 200) || '',
     });
     if (p.isCancel(description)) {
-        p.cancel('취소됨');
+        p.cancel('Cancelled');
         process.exit(0);
     }
     const tagsInput = await p.text({
-        message: '태그 (쉼표로 구분):',
+        message: 'Tags (comma-separated):',
         placeholder: 'react, saas, mvp',
         defaultValue: '',
     });
     if (p.isCancel(tagsInput)) {
-        p.cancel('취소됨');
+        p.cancel('Cancelled');
         process.exit(0);
     }
     const tags = tagsInput
@@ -80,20 +80,20 @@ export async function cmdPublish(path) {
         .map((t) => t.trim().toLowerCase())
         .filter(Boolean);
     const category = await p.select({
-        message: '프로젝트 카테고리:',
+        message: 'Project category:',
         options: [
-            { value: 'web-app', label: '웹 앱 (Web App)' },
-            { value: 'mobile-app', label: '모바일 앱 (Mobile App)' },
-            { value: 'cli-tool', label: 'CLI 도구 (CLI Tool)' },
-            { value: 'api-backend', label: 'API/백엔드 (API/Backend)' },
+            { value: 'web-app', label: 'Web App' },
+            { value: 'mobile-app', label: 'Mobile App' },
+            { value: 'cli-tool', label: 'CLI Tool' },
+            { value: 'api-backend', label: 'API/Backend' },
             { value: 'ai-ml', label: 'AI/ML' },
-            { value: 'game', label: '게임 (Game)' },
-            { value: 'library', label: '라이브러리 (Library)' },
-            { value: 'other', label: '기타 (Other)' },
+            { value: 'game', label: 'Game' },
+            { value: 'library', label: 'Library' },
+            { value: 'other', label: 'Other' },
         ],
     });
     if (p.isCancel(category)) {
-        p.cancel('취소됨');
+        p.cancel('Cancelled');
         process.exit(0);
     }
     // Build .pmpt content (resolve from optimized snapshots)
@@ -133,16 +133,16 @@ export async function cmdPublish(path) {
         tags.length ? `Tags: ${tags.join(', ')}` : '',
     ].filter(Boolean).join('\n'), 'Publish Preview');
     const confirm = await p.confirm({
-        message: '게시하시겠습니까?',
+        message: 'Publish this project?',
         initialValue: true,
     });
     if (p.isCancel(confirm) || !confirm) {
-        p.cancel('취소됨');
+        p.cancel('Cancelled');
         process.exit(0);
     }
     // Upload
     const s = p.spinner();
-    s.start('업로드 중...');
+    s.start('Uploading...');
     try {
         const result = await publishProject(auth.token, {
             slug: slug,
@@ -151,7 +151,7 @@ export async function cmdPublish(path) {
             tags,
             category: category,
         });
-        s.stop('게시 완료!');
+        s.stop('Published!');
         // Update config
         if (config) {
             config.lastPublished = new Date().toISOString();
@@ -161,12 +161,12 @@ export async function cmdPublish(path) {
             `URL: ${result.url}`,
             `Download: ${result.downloadUrl}`,
             '',
-            `pmpt clone ${slug}  — 다른 사람이 이 프로젝트를 복제할 수 있습니다`,
+            `pmpt clone ${slug}  — others can clone this project`,
         ].join('\n'), 'Published!');
     }
     catch (err) {
-        s.stop('게시 실패');
-        p.log.error(err instanceof Error ? err.message : '게시에 실패했습니다.');
+        s.stop('Publish failed');
+        p.log.error(err instanceof Error ? err.message : 'Failed to publish.');
         process.exit(1);
     }
     p.outro('');

package/dist/index.js

@@ -17,7 +17,7 @@ const program = new Command();
 program
     .name('pmpt')
     .description('pmpt — Record and share your AI-driven product development journey')
-    .version('1.4.1')
+    .version('1.5.2')
     .addHelpText('after', `
 Examples:
   $ pmpt init                    Initialize project

package/dist/lib/git.js

@@ -2,13 +2,13 @@ import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import { join } from 'path';
 /**
- * 디렉토리가 git 저장소인지 확인
+ * Check if directory is a git repository
  */
 export function isGitRepo(path) {
     return existsSync(join(path, '.git'));
 }
 /**
- * git 명령어 실행 헬퍼
+ * Git command execution helper
  */
 function git(path, args) {
     try {
@@ -23,32 +23,32 @@ function git(path, args) {
     }
 }
 /**
- * 현재 git 상태 정보 수집
+ * Collect current git status info
  */
 export function getGitInfo(path, remoteUrl) {
     if (!isGitRepo(path)) {
         return null;
     }
-    // 커밋 해시
+    // Commit hash
     const commitFull = git(path, 'rev-parse HEAD');
     if (!commitFull)
         return null;
     const commit = git(path, 'rev-parse --short HEAD') || commitFull.slice(0, 7);
-    // 브랜치
+    // Branch
     const branch = git(path, 'rev-parse --abbrev-ref HEAD') || 'HEAD';
-    // uncommitted 변경 확인
+    // Check uncommitted changes
     const status = git(path, 'status --porcelain');
     const dirty = status !== null && status.length > 0;
-    // 커밋 타임스탬프
+    // Commit timestamp
     const timestamp = git(path, 'log -1 --format=%cI') || new Date().toISOString();
-    // 현재 커밋의 태그
+    // Current commit tag
     const tag = git(path, 'describe --tags --exact-match 2>/dev/null') || undefined;
-    // 원격 저장소 URL (제공되지 않으면 origin에서 가져옴)
+    // Remote repository URL (fetched from origin if not provided)
     let repo = remoteUrl;
     if (!repo) {
         const origin = git(path, 'remote get-url origin');
         if (origin) {
-            // SSH URL을 HTTPS로 변환
+            // Convert SSH URL to HTTPS
             repo = origin
                 .replace(/^git@github\.com:/, 'https://github.com/')
                 .replace(/\.git$/, '');
@@ -65,14 +65,14 @@ export function getGitInfo(path, remoteUrl) {
     };
 }
 /**
- * git 상태가 clean한지 확인
+ * Check if git status is clean
  */
 export function isGitClean(path) {
     const status = git(path, 'status --porcelain');
     return status !== null && status.length === 0;
 }
 /**
- * 특정 커밋이 현재 커밋과 일치하는지 확인
+ * Check if specific commit matches current commit
  */
 export function isCommitMatch(path, expectedCommit) {
     const currentFull = git(path, 'rev-parse HEAD');
@@ -85,7 +85,7 @@ export function isCommitMatch(path, expectedCommit) {
         expectedCommit.startsWith(currentShort));
 }
 /**
- * git 정보를 사람이 읽기 쉬운 문자열로 변환
+ * Convert git info to human-readable string
  */
 export function formatGitInfo(info) {
     const parts = [

package/dist/lib/history.js

@@ -4,21 +4,21 @@ import { getHistoryDir, getDocsDir, loadConfig } from './config.js';
 import { getGitInfo, isGitRepo } from './git.js';
 import glob from 'fast-glob';
 /**
- * .pmpt/docs 폴더의 MD 파일을 스냅샷으로 저장
- * 변경된 파일만 복사하여 저장 공간 최적화
+ * Save .pmpt/docs MD files as snapshot
+ * Copy only changed files to optimize storage
  */
 export function createFullSnapshot(projectPath) {
     const historyDir = getHistoryDir(projectPath);
     const docsDir = getDocsDir(projectPath);
     mkdirSync(historyDir, { recursive: true });
-    // 다음 버전 번호 찾기
+    // Find next version number
     const existing = getAllSnapshots(projectPath);
     const version = existing.length + 1;
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
     const snapshotName = `v${version}-${timestamp}`;
     const snapshotDir = join(historyDir, snapshotName);
     mkdirSync(snapshotDir, { recursive: true });
-    // docs 폴더의 MD 파일 비교 후 변경분만 복사
+    // Compare docs folder MD files and copy only changes
     const files = [];
     const changedFiles = [];
     if (existsSync(docsDir)) {
@@ -27,7 +27,7 @@ export function createFullSnapshot(projectPath) {
             const srcPath = join(docsDir, file);
             const newContent = readFileSync(srcPath, 'utf-8');
             files.push(file);
-            // 이전 버전과 비교
+            // Compare with previous version
             let hasChanged = true;
             if (existing.length > 0) {
                 const prevContent = resolveFileContent(existing, existing.length - 1, file);
@@ -37,7 +37,7 @@ export function createFullSnapshot(projectPath) {
             }
             if (hasChanged) {
                 const destPath = join(snapshotDir, file);
-                // 하위 디렉토리가 있으면 생성
+                // Create subdirectory if needed
                 const destDir = join(snapshotDir, file.split('/').slice(0, -1).join('/'));
                 if (destDir !== snapshotDir) {
                     mkdirSync(destDir, { recursive: true });
@@ -47,7 +47,7 @@ export function createFullSnapshot(projectPath) {
             }
         }
     }
-    // Git 정보 수집
+    // Collect git info
     const config = loadConfig(projectPath);
     let gitData;
     if (config?.trackGit && isGitRepo(projectPath)) {
@@ -62,7 +62,7 @@ export function createFullSnapshot(projectPath) {
             };
         }
     }
-    // 메타데이터 저장
+    // Save metadata
     const metaPath = join(snapshotDir, '.meta.json');
     writeFileSync(metaPath, JSON.stringify({
         version,
@@ -81,16 +81,16 @@ export function createFullSnapshot(projectPath) {
     };
 }
 /**
- * 단일 파일 스냅샷 (pmpt 폴더 내 특정 파일만)
- * 기존 호환성을 위해 유지하되, 내부적으로 전체 스냅샷 사용
+ * Single file snapshot (specific file in pmpt folder)
+ * Kept for backward compatibility, uses full snapshot internally
  */
 export function createSnapshot(projectPath, filePath) {
     const historyDir = getHistoryDir(projectPath);
     const docsDir = getDocsDir(projectPath);
     const relPath = relative(docsDir, filePath);
-    // 파일이 docs 폴더 외부에 있는 경우
+    // If file is outside docs folder
     if (relPath.startsWith('..')) {
-        // 프로젝트 루트 기준 상대 경로 사용
+        // Use relative path from project root
         const projectRelPath = relative(projectPath, filePath);
         return createSingleFileSnapshot(projectPath, filePath, projectRelPath);
     }
@@ -99,17 +99,17 @@ export function createSnapshot(projectPath, filePath) {
 function createSingleFileSnapshot(projectPath, filePath, relPath) {
     const historyDir = getHistoryDir(projectPath);
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    // 해당 파일의 기존 버전 수 확인
+    // Check existing version count for this file
     const existing = getFileHistory(projectPath, relPath);
     const version = existing.length + 1;
-    // 버전 폴더 생성
+    // Create version folder
     const snapshotName = `v${version}-${timestamp}`;
     const snapshotDir = join(historyDir, snapshotName);
     mkdirSync(snapshotDir, { recursive: true });
-    // 파일 복사
+    // Copy file
     const destPath = join(snapshotDir, basename(filePath));
     copyFileSync(filePath, destPath);
-    // Git 정보 수집
+    // Collect git info
     const config = loadConfig(projectPath);
     let gitData;
     if (config?.trackGit && isGitRepo(projectPath)) {
@@ -124,7 +124,7 @@ function createSingleFileSnapshot(projectPath, filePath, relPath) {
             };
         }
     }
-    // 메타데이터 저장
+    // Save metadata
     const metaPath = join(snapshotDir, '.meta.json');
     writeFileSync(metaPath, JSON.stringify({
         version,
@@ -141,7 +141,7 @@ function createSingleFileSnapshot(projectPath, filePath, relPath) {
     };
 }
 /**
- * 모든 스냅샷 목록 조회
+ * List all snapshots
  */
 export function getAllSnapshots(projectPath) {
     const historyDir = getHistoryDir(projectPath);
@@ -163,7 +163,7 @@ export function getAllSnapshots(projectPath) {
                 meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
             }
             catch {
-                // 메타 파일 파싱 실패 시 기본값 사용
+                // Use defaults if meta file parsing fails
             }
         }
         entries.push({
@@ -178,7 +178,7 @@ export function getAllSnapshots(projectPath) {
     return entries.sort((a, b) => a.version - b.version);
 }
 /**
- * 특정 파일의 히스토리 조회 (하위 호환성)
+ * Get file history (backward compatibility)
  */
 export function getFileHistory(projectPath, relPath) {
     const historyDir = getHistoryDir(projectPath);
@@ -205,7 +205,7 @@ export function getFileHistory(projectPath, relPath) {
                 gitData = meta.git;
             }
             catch {
-                // 메타 파일 파싱 실패 시 무시
+                // Skip if meta file parsing fails
             }
         }
         entries.push({
@@ -219,7 +219,7 @@ export function getFileHistory(projectPath, relPath) {
     return entries.sort((a, b) => a.version - b.version);
 }
 /**
- * 전체 히스토리 조회 (모든 스냅샷의 모든 파일)
+ * Get full history (all files across all snapshots)
  */
 export function getAllHistory(projectPath) {
     const snapshots = getAllSnapshots(projectPath);
@@ -238,7 +238,7 @@ export function getAllHistory(projectPath) {
     return entries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
 }
 /**
- * 추적 중인 파일 목록 (.pmpt/docs 기준)
+ * List tracked files (from .pmpt/docs)
  */
 export function getTrackedFiles(projectPath) {
     const docsDir = getDocsDir(projectPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmpt-cli",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "Record and share your AI-driven product development journey",
   "type": "module",
   "bin": {
@@ -35,11 +35,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
-    "@octokit/rest": "^21.0.0",
     "chokidar": "^3.6.0",
     "commander": "^12.0.0",
     "fast-glob": "^3.3.0",
-    "gray-matter": "^4.0.3",
     "open": "^11.0.0",
     "zod": "^3.22.0"
   },

package/dist/commands/new.js

@@ -1,78 +0,0 @@
-import * as p from '@clack/prompts';
-import { writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-import { generateContent, generateFilePath } from '../lib/template.js';
-export async function cmdNew() {
-    p.intro('pmptwiki — 새 문서 만들기');
-    const answers = await p.group({
-        lang: () => p.select({
-            message: '언어를 선택하세요',
-            options: [
-                { value: 'ko', label: '한국어 (ko)' },
-                { value: 'en', label: 'English (en)' },
-            ],
-        }),
-        purpose: () => p.select({
-            message: '문서 유형을 선택하세요',
-            options: [
-                { value: 'guide', label: '가이드', hint: '개념 설명 + 방법' },
-                { value: 'rule', label: '규칙', hint: '해야 할 것 / 하지 말 것' },
-                { value: 'template', label: '템플릿', hint: '복사해서 쓰는 프롬프트' },
-                { value: 'example', label: '사례', hint: '실제 사용 사례' },
-                { value: 'reference', label: '레퍼런스', hint: '참고 자료 모음' },
-            ],
-        }),
-        level: () => p.select({
-            message: '난이도를 선택하세요',
-            options: [
-                { value: 'beginner', label: '입문' },
-                { value: 'intermediate', label: '중급' },
-                { value: 'advanced', label: '고급' },
-            ],
-        }),
-        title: () => p.text({
-            message: '제목을 입력하세요',
-            placeholder: 'AI에게 충분한 배경을 주면 답변이 달라진다',
-            validate: (v) => (v.trim().length < 5 ? '5자 이상 입력해주세요' : undefined),
-        }),
-        tags: () => p.text({
-            message: '태그를 입력하세요 (쉼표 구분, 선택)',
-            placeholder: 'context, beginner, prompt',
-        }),
-        persona: () => p.multiselect({
-            message: '대상 독자를 선택하세요 (선택)',
-            options: [
-                { value: 'general', label: '일반' },
-                { value: 'power-user', label: '파워유저' },
-                { value: 'developer', label: '개발자' },
-                { value: 'organization', label: '조직' },
-            ],
-            required: false,
-        }),
-    }, {
-        onCancel: () => {
-            p.cancel('취소되었습니다');
-            process.exit(0);
-        },
-    });
-    const fm = {
-        title: answers.title,
-        purpose: answers.purpose,
-        level: answers.level,
-        lang: answers.lang,
-        tags: answers.tags
-            ? answers.tags.split(',').map((t) => t.trim()).filter(Boolean)
-            : [],
-        persona: answers.persona.length ? answers.persona : undefined,
-    };
-    const filePath = generateFilePath(fm);
-    const content = generateContent(fm);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, content, 'utf-8');
-    p.outro(`파일이 생성되었습니다: ${filePath}
-
-다음 단계:
-  1. 파일을 열어 본문을 작성하세요
-  2. pmpt validate ${filePath}
-  3. pmpt submit ${filePath}`);
-}

package/dist/commands/submit.js

@@ -1,103 +0,0 @@
-import * as p from '@clack/prompts';
-import matter from 'gray-matter';
-import { readFileSync } from 'fs';
-import { loadAuth, saveAuth } from '../lib/auth.js';
-import { createClient, createBranch, createPR, ensureFork, getAuthUser, pushFile, } from '../lib/github.js';
-import { validate } from '../lib/schema.js';
-import { today } from '../lib/template.js';
-export async function cmdSubmit(filePath) {
-    p.intro(`pmptwiki — 제출: ${filePath}`);
-    // 1. 검증
-    const s1 = p.spinner();
-    s1.start('파일 검증 중...');
-    const result = validate(filePath);
-    if (!result.valid) {
-        s1.stop('검증 실패');
-        for (const err of result.errors)
-            p.log.error(err);
-        p.outro('오류를 수정한 후 다시 시도하세요: pmpt validate ' + filePath);
-        process.exit(1);
-    }
-    s1.stop(`검증 통과${result.warnings.length ? ` (경고 ${result.warnings.length}개)` : ''}`);
-    for (const warn of result.warnings)
-        p.log.warn(warn);
-    // 2. 인증
-    let auth = loadAuth();
-    if (!auth) {
-        p.log.info('GitHub 인증이 필요합니다.');
-        p.log.info('Personal Access Token을 발급하세요:\n  https://github.com/settings/tokens/new\n  필요 권한: repo (전체)');
-        const token = await p.password({
-            message: 'GitHub PAT를 입력하세요:',
-            validate: (v) => (v.trim().length < 10 ? '올바른 토큰을 입력하세요' : undefined),
-        });
-        if (p.isCancel(token)) {
-            p.cancel('취소됨');
-            process.exit(0);
-        }
-        const s2 = p.spinner();
-        s2.start('인증 확인 중...');
-        try {
-            const octokit = createClient(token);
-            const username = await getAuthUser(octokit);
-            saveAuth({ token: token, username });
-            auth = { token: token, username };
-            s2.stop(`인증 완료 — @${username}`);
-        }
-        catch {
-            s2.stop('인증 실패');
-            p.outro('토큰이 올바르지 않습니다. 다시 시도하세요');
-            process.exit(1);
-        }
-    }
-    const octokit = createClient(auth.token);
-    // 3. 브랜치명 생성
-    const { data: fm } = matter(readFileSync(filePath, 'utf-8'));
-    const slug = filePath
-        .replace(/^.*?(?=ko\/|en\/)/, '')
-        .replace(/\.mdx?$/, '')
-        .replace(/\//g, '-');
-    const branchName = `content/${slug}-${today()}`;
-    // 4. fork 확인 / 생성
-    const s3 = p.spinner();
-    s3.start('Fork 확인 중...');
-    await ensureFork(octokit, auth.username);
-    s3.stop('Fork 준비 완료');
-    // 5. 브랜치 생성
-    const s4 = p.spinner();
-    s4.start(`브랜치 생성 중: ${branchName}`);
-    await createBranch(octokit, auth.username, branchName);
-    s4.stop('브랜치 생성 완료');
-    // 6. 파일 push
-    const repoPath = filePath.replace(/^.*?(?=ko\/|en\/)/, '');
-    const s5 = p.spinner();
-    s5.start('파일 업로드 중...');
-    await pushFile(octokit, auth.username, branchName, repoPath, filePath, `docs: add ${repoPath}`);
-    s5.stop('파일 업로드 완료');
-    // 7. PR 생성
-    const prTitle = fm.purpose
-        ? `[${fm.purpose}] ${fm.title}`
-        : fm.title;
-    const prBody = [
-        `## 문서 정보`,
-        `- **제목**: ${fm.title}`,
-        `- **유형**: ${fm.purpose ?? '-'}`,
-        `- **난이도**: ${fm.level ?? '-'}`,
-        `- **언어**: ${fm.lang ?? '-'}`,
-        fm.tags?.length ? `- **태그**: ${fm.tags.map((t) => `\`${t}\``).join(' ')}` : null,
-        ``,
-        `## 체크리스트`,
-        `- [ ] 본문이 명확하고 실용적인가?`,
-        `- [ ] 예시가 포함되어 있는가?`,
-        `- [ ] 제목과 내용이 일치하는가?`,
-        ``,
-        `---`,
-        `_pmpt-cli로 제출됨_`,
-    ]
-        .filter((l) => l !== null)
-        .join('\n');
-    const s6 = p.spinner();
-    s6.start('PR 생성 중...');
-    const prUrl = await createPR(octokit, auth.username, branchName, prTitle, prBody);
-    s6.stop('PR 생성 완료');
-    p.outro(`제출 완료!\n\n  PR: ${prUrl}\n\n리뷰 후 머지되면 pmptwiki.com에 자동으로 반영됩니다.`);
-}

package/dist/commands/validate.js

@@ -1,23 +0,0 @@
-import * as p from '@clack/prompts';
-import { validate } from '../lib/schema.js';
-export function cmdValidate(filePath) {
-    p.intro(`pmptwiki — 검증: ${filePath}`);
-    const result = validate(filePath);
-    if (result.errors.length === 0 && result.warnings.length === 0) {
-        p.outro('모든 검증 통과');
-        return true;
-    }
-    for (const err of result.errors) {
-        p.log.error(err);
-    }
-    for (const warn of result.warnings) {
-        p.log.warn(warn);
-    }
-    if (result.valid) {
-        p.outro(`검증 통과 (경고 ${result.warnings.length}개)`);
-    }
-    else {
-        p.outro(`검증 실패 (오류 ${result.errors.length}개) — 수정 후 다시 시도하세요`);
-    }
-    return result.valid;
-}

package/dist/lib/github.js

@@ -1,81 +0,0 @@
-import { Octokit } from '@octokit/rest';
-import { readFileSync } from 'fs';
-const CONTENT_OWNER = 'pmptwiki';
-const CONTENT_REPO = 'content';
-export function createClient(token) {
-    return new Octokit({ auth: token });
-}
-export async function getAuthUser(octokit) {
-    const { data } = await octokit.rest.users.getAuthenticated();
-    return data.login;
-}
-/** fork가 없으면 생성, 있으면 그대로 반환 */
-export async function ensureFork(octokit, username) {
-    try {
-        await octokit.rest.repos.get({ owner: username, repo: CONTENT_REPO });
-    }
-    catch {
-        await octokit.rest.repos.createFork({
-            owner: CONTENT_OWNER,
-            repo: CONTENT_REPO,
-        });
-        // fork 생성은 비동기 - 잠시 대기
-        await new Promise((r) => setTimeout(r, 3000));
-    }
-}
-/** 브랜치 생성 (upstream main 기준) */
-export async function createBranch(octokit, username, branchName) {
-    // upstream main의 sha 가져오기
-    const { data: ref } = await octokit.rest.git.getRef({
-        owner: CONTENT_OWNER,
-        repo: CONTENT_REPO,
-        ref: 'heads/main',
-    });
-    const sha = ref.object.sha;
-    await octokit.rest.git.createRef({
-        owner: username,
-        repo: CONTENT_REPO,
-        ref: `refs/heads/${branchName}`,
-        sha,
-    });
-}
-/** 파일을 fork의 브랜치에 커밋 */
-export async function pushFile(octokit, username, branchName, filePath, localFilePath, commitMessage) {
-    const content = Buffer.from(readFileSync(localFilePath, 'utf-8')).toString('base64');
-    // 기존 파일 sha 확인 (update용)
-    let sha;
-    try {
-        const { data } = await octokit.rest.repos.getContent({
-            owner: username,
-            repo: CONTENT_REPO,
-            path: filePath,
-            ref: branchName,
-        });
-        if (!Array.isArray(data) && 'sha' in data)
-            sha = data.sha;
-    }
-    catch {
-        // 신규 파일
-    }
-    await octokit.rest.repos.createOrUpdateFileContents({
-        owner: username,
-        repo: CONTENT_REPO,
-        path: filePath,
-        message: commitMessage,
-        content,
-        branch: branchName,
-        ...(sha ? { sha } : {}),
-    });
-}
-/** upstream으로 PR 생성 */
-export async function createPR(octokit, username, branchName, title, body) {
-    const { data } = await octokit.rest.pulls.create({
-        owner: CONTENT_OWNER,
-        repo: CONTENT_REPO,
-        title,
-        body,
-        head: `${username}:${branchName}`,
-        base: 'main',
-    });
-    return data.html_url;
-}

package/dist/lib/schema.js

@@ -1,61 +0,0 @@
-import { z } from 'zod';
-import matter from 'gray-matter';
-import { readFileSync } from 'fs';
-const frontmatterSchema = z.object({
-    title: z.string().min(5, '제목은 5자 이상이어야 합니다'),
-    purpose: z.enum(['guide', 'rule', 'template', 'example', 'reference']),
-    level: z.enum(['beginner', 'intermediate', 'advanced']),
-    lang: z.enum(['ko', 'en']),
-    persona: z.array(z.enum(['general', 'power-user', 'developer', 'organization'])).optional(),
-    status: z.enum(['draft', 'review', 'stable', 'recommended', 'deprecated']).optional(),
-    translationKey: z.string().optional(),
-    tags: z.array(z.string()).optional(),
-    created: z.string().optional(),
-    updated: z.string().optional(),
-    contributors: z.array(z.string()).optional(),
-});
-const FILE_PATH_RE = /^(ko|en)\/(guide|rule|template|example|reference)\/(beginner|intermediate|advanced)\/.+\.mdx?$/;
-export function validate(filePath) {
-    const errors = [];
-    const warnings = [];
-    // 1. 파일 경로 규칙
-    const relative = filePath.replace(/^.*?(?=ko\/|en\/)/, '');
-    if (!FILE_PATH_RE.test(relative)) {
-        errors.push(`파일 경로가 규칙에 맞지 않습니다: {lang}/{purpose}/{level}/파일명.md`);
-    }
-    // 2. 파일 읽기
-    let raw;
-    try {
-        raw = readFileSync(filePath, 'utf-8');
-    }
-    catch {
-        errors.push('파일을 읽을 수 없습니다');
-        return { valid: false, errors, warnings };
-    }
-    // 3. frontmatter 파싱
-    const { data, content } = matter(raw);
-    const result = frontmatterSchema.safeParse(data);
-    if (!result.success) {
-        for (const issue of result.error.issues) {
-            const field = issue.path.join('.');
-            errors.push(`[${field}] ${issue.message}`);
-        }
-    }
-    // 4. 본문 길이
-    const bodyLength = content.trim().length;
-    if (bodyLength < 200) {
-        errors.push(`본문이 너무 짧습니다 (현재 ${bodyLength}자, 최소 200자)`);
-    }
-    // 5. 경고
-    if (!data.tags || data.tags.length === 0) {
-        warnings.push('tags를 추가하면 검색과 관련 문서 연결에 도움이 됩니다');
-    }
-    if (!data.persona) {
-        warnings.push('persona를 지정하면 대상 독자가 명확해집니다');
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-    };
-}

package/dist/lib/template.js

@@ -1,37 +0,0 @@
-export function toSlug(title) {
-    return title
-        .toLowerCase()
-        .replace(/[^\w\s-]/g, '')
-        .trim()
-        .replace(/\s+/g, '-')
-        .replace(/-+/g, '-')
-        .slice(0, 60);
-}
-export function today() {
-    return new Date().toISOString().slice(0, 10);
-}
-export function generateFilePath(fm) {
-    const slug = toSlug(fm.title);
-    return `${fm.lang}/${fm.purpose}/${fm.level}/${slug}.md`;
-}
-export function generateContent(fm) {
-    const frontmatter = [
-        '---',
-        `title: "${fm.title}"`,
-        `purpose: ${fm.purpose}`,
-        `level: ${fm.level}`,
-        `lang: ${fm.lang}`,
-        fm.persona?.length ? `persona: [${fm.persona.map((p) => `"${p}"`).join(', ')}]` : null,
-        `status: draft`,
-        fm.tags?.length ? `tags: [${fm.tags.map((t) => `"${t}"`).join(', ')}]` : null,
-        `created: "${today()}"`,
-        `updated: "${today()}"`,
-        '---',
-    ]
-        .filter(Boolean)
-        .join('\n');
-    const body = fm.lang === 'ko'
-        ? `\n## 왜 중요한가\n\n<!-- 이 문서가 필요한 이유를 설명하세요 -->\n\n## 방법\n\n<!-- 단계별로 설명하세요 -->\n\n## 예시\n\n<!-- 실제 예시를 추가하세요 -->\n`
-        : `\n## Why it matters\n\n<!-- Explain why this document is needed -->\n\n## How to\n\n<!-- Explain step by step -->\n\n## Example\n\n<!-- Add a real example -->\n`;
-    return frontmatter + body;
-}