pmpt-cli 1.5.0 → 1.5.1

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/new.js

@@ -3,55 +3,55 @@ import { writeFileSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
 import { generateContent, generateFilePath } from '../lib/template.js';
 export async function cmdNew() {
-    p.intro('pmptwiki — 새 문서 만들기');
+    p.intro('pmptwiki — create new document');
     const answers = await p.group({
         lang: () => p.select({
-            message: '언어를 선택하세요',
+            message: 'Select language',
             options: [
-                { value: 'ko', label: '한국어 (ko)' },
+                { value: 'ko', label: 'Korean (ko)' },
                 { value: 'en', label: 'English (en)' },
             ],
         }),
         purpose: () => p.select({
-            message: '문서 유형을 선택하세요',
+            message: 'Select document type',
             options: [
-                { value: 'guide', label: '가이드', hint: '개념 설명 + 방법' },
-                { value: 'rule', label: '규칙', hint: '해야 할 것 / 하지 말 것' },
-                { value: 'template', label: '템플릿', hint: '복사해서 쓰는 프롬프트' },
-                { value: 'example', label: '사례', hint: '실제 사용 사례' },
-                { value: 'reference', label: '레퍼런스', hint: '참고 자료 모음' },
+                { value: 'guide', label: 'Guide', hint: 'Concept explanation + how-to' },
+                { value: 'rule', label: 'Rule', hint: 'Do / Don\'t' },
+                { value: 'template', label: 'Template', hint: 'Copy-paste prompt' },
+                { value: 'example', label: 'Example', hint: 'Real-world use case' },
+                { value: 'reference', label: 'Reference', hint: 'Resource collection' },
             ],
         }),
         level: () => p.select({
-            message: '난이도를 선택하세요',
+            message: 'Select difficulty',
             options: [
-                { value: 'beginner', label: '입문' },
-                { value: 'intermediate', label: '중급' },
-                { value: 'advanced', label: '고급' },
+                { value: 'beginner', label: 'Beginner' },
+                { value: 'intermediate', label: 'Intermediate' },
+                { value: 'advanced', label: 'Advanced' },
             ],
         }),
         title: () => p.text({
-            message: '제목을 입력하세요',
-            placeholder: 'AI에게 충분한 배경을 주면 답변이 달라진다',
-            validate: (v) => (v.trim().length < 5 ? '5자 이상 입력해주세요' : undefined),
+            message: 'Enter a title',
+            placeholder: 'Providing enough context to AI changes the response',
+            validate: (v) => (v.trim().length < 5 ? 'At least 5 characters required' : undefined),
         }),
         tags: () => p.text({
-            message: '태그를 입력하세요 (쉼표 구분, 선택)',
+            message: 'Enter tags (comma-separated, optional)',
             placeholder: 'context, beginner, prompt',
         }),
         persona: () => p.multiselect({
-            message: '대상 독자를 선택하세요 (선택)',
+            message: 'Select target audience (optional)',
             options: [
-                { value: 'general', label: '일반' },
-                { value: 'power-user', label: '파워유저' },
-                { value: 'developer', label: '개발자' },
-                { value: 'organization', label: '조직' },
+                { value: 'general', label: 'General' },
+                { value: 'power-user', label: 'Power User' },
+                { value: 'developer', label: 'Developer' },
+                { value: 'organization', label: 'Organization' },
             ],
             required: false,
         }),
     }, {
         onCancel: () => {
-            p.cancel('취소되었습니다');
+            p.cancel('Cancelled');
             process.exit(0);
         },
     });
@@ -69,10 +69,10 @@ export async function cmdNew() {
     const content = generateContent(fm);
     mkdirSync(dirname(filePath), { recursive: true });
     writeFileSync(filePath, content, 'utf-8');
-    p.outro(`파일이 생성되었습니다: ${filePath}
+    p.outro(`File created: ${filePath}
 
-다음 단계:
-  1. 파일을 열어 본문을 작성하세요
+Next steps:
+  1. Open the file and write the content
   2. pmpt validate ${filePath}
   3. pmpt submit ${filePath}`);
 }

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/commands/submit.js

@@ -6,98 +6,98 @@ import { createClient, createBranch, createPR, ensureFork, getAuthUser, pushFile
 import { validate } from '../lib/schema.js';
 import { today } from '../lib/template.js';
 export async function cmdSubmit(filePath) {
-    p.intro(`pmptwiki — 제출: ${filePath}`);
-    // 1. 검증
+    p.intro(`pmptwiki — submit: ${filePath}`);
+    // 1. Validate
     const s1 = p.spinner();
-    s1.start('파일 검증 중...');
+    s1.start('Validating file...');
     const result = validate(filePath);
     if (!result.valid) {
-        s1.stop('검증 실패');
+        s1.stop('Validation failed');
         for (const err of result.errors)
             p.log.error(err);
-        p.outro('오류를 수정한 후 다시 시도하세요: pmpt validate ' + filePath);
+        p.outro('Fix errors and retry: pmpt validate ' + filePath);
         process.exit(1);
     }
-    s1.stop(`검증 통과${result.warnings.length ? ` (경고 ${result.warnings.length}개)` : ''}`);
+    s1.stop(`Validation passed${result.warnings.length ? ` (${result.warnings.length} warnings)` : ''}`);
     for (const warn of result.warnings)
         p.log.warn(warn);
-    // 2. 인증
+    // 2. Auth
     let auth = loadAuth();
     if (!auth) {
-        p.log.info('GitHub 인증이 필요합니다.');
-        p.log.info('Personal Access Token을 발급하세요:\n  https://github.com/settings/tokens/new\n  필요 권한: repo (전체)');
+        p.log.info('GitHub authentication required.');
+        p.log.info('Create a Personal Access Token:\n  https://github.com/settings/tokens/new\n  Required scope: repo (full)');
         const token = await p.password({
-            message: 'GitHub PAT를 입력하세요:',
-            validate: (v) => (v.trim().length < 10 ? '올바른 토큰을 입력하세요' : undefined),
+            message: 'Enter your GitHub PAT:',
+            validate: (v) => (v.trim().length < 10 ? 'Please enter a valid token' : undefined),
         });
         if (p.isCancel(token)) {
-            p.cancel('취소됨');
+            p.cancel('Cancelled');
             process.exit(0);
         }
         const s2 = p.spinner();
-        s2.start('인증 확인 중...');
+        s2.start('Verifying authentication...');
         try {
             const octokit = createClient(token);
             const username = await getAuthUser(octokit);
             saveAuth({ token: token, username });
             auth = { token: token, username };
-            s2.stop(`인증 완료 — @${username}`);
+            s2.stop(`Authenticated — @${username}`);
         }
         catch {
-            s2.stop('인증 실패');
-            p.outro('토큰이 올바르지 않습니다. 다시 시도하세요');
+            s2.stop('Authentication failed');
+            p.outro('Invalid token. Please try again');
             process.exit(1);
         }
     }
     const octokit = createClient(auth.token);
-    // 3. 브랜치명 생성
+    // 3. Generate branch name
     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 확인 / 생성
+    // 4. Check / create fork
     const s3 = p.spinner();
-    s3.start('Fork 확인 중...');
+    s3.start('Checking fork...');
     await ensureFork(octokit, auth.username);
-    s3.stop('Fork 준비 완료');
-    // 5. 브랜치 생성
+    s3.stop('Fork ready');
+    // 5. Create branch
     const s4 = p.spinner();
-    s4.start(`브랜치 생성 중: ${branchName}`);
+    s4.start(`Creating branch: ${branchName}`);
     await createBranch(octokit, auth.username, branchName);
-    s4.stop('브랜치 생성 완료');
-    // 6. 파일 push
+    s4.stop('Branch created');
+    // 6. Push file
     const repoPath = filePath.replace(/^.*?(?=ko\/|en\/)/, '');
     const s5 = p.spinner();
-    s5.start('파일 업로드 중...');
+    s5.start('Uploading file...');
     await pushFile(octokit, auth.username, branchName, repoPath, filePath, `docs: add ${repoPath}`);
-    s5.stop('파일 업로드 완료');
-    // 7. PR 생성
+    s5.stop('File uploaded');
+    // 7. Create 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,
+        `## Document Info`,
+        `- **Title**: ${fm.title}`,
+        `- **Type**: ${fm.purpose ?? '-'}`,
+        `- **Level**: ${fm.level ?? '-'}`,
+        `- **Language**: ${fm.lang ?? '-'}`,
+        fm.tags?.length ? `- **Tags**: ${fm.tags.map((t) => `\`${t}\``).join(' ')}` : null,
         ``,
-        `## 체크리스트`,
-        `- [ ] 본문이 명확하고 실용적인가?`,
-        `- [ ] 예시가 포함되어 있는가?`,
-        `- [ ] 제목과 내용이 일치하는가?`,
+        `## Checklist`,
+        `- [ ] Is the content clear and practical?`,
+        `- [ ] Are examples included?`,
+        `- [ ] Does the title match the content?`,
         ``,
         `---`,
-        `_pmpt-cli로 제출됨_`,
+        `_Submitted via pmpt-cli_`,
     ]
         .filter((l) => l !== null)
         .join('\n');
     const s6 = p.spinner();
-    s6.start('PR 생성 중...');
+    s6.start('Creating PR...');
     const prUrl = await createPR(octokit, auth.username, branchName, prTitle, prBody);
-    s6.stop('PR 생성 완료');
-    p.outro(`제출 완료!\n\n  PR: ${prUrl}\n\n리뷰 후 머지되면 pmptwiki.com에 자동으로 반영됩니다.`);
+    s6.stop('PR created');
+    p.outro(`Submitted!\n\n  PR: ${prUrl}\n\nOnce reviewed and merged, it will be published on pmptwiki.com.`);
 }

package/dist/commands/validate.js

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

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/github.js

@@ -9,7 +9,7 @@ export async function getAuthUser(octokit) {
     const { data } = await octokit.rest.users.getAuthenticated();
     return data.login;
 }
-/** fork가 없으면 생성, 있으면 그대로 반환 */
+/** Create fork if not exists, otherwise return existing */
 export async function ensureFork(octokit, username) {
     try {
         await octokit.rest.repos.get({ owner: username, repo: CONTENT_REPO });
@@ -19,13 +19,13 @@ export async function ensureFork(octokit, username) {
             owner: CONTENT_OWNER,
             repo: CONTENT_REPO,
         });
-        // fork 생성은 비동기 - 잠시 대기
+        // Fork creation is async - wait briefly
         await new Promise((r) => setTimeout(r, 3000));
     }
 }
-/** 브랜치 생성 (upstream main 기준) */
+/** Create branch (based on upstream main) */
 export async function createBranch(octokit, username, branchName) {
-    // upstream main의 sha 가져오기
+    // Get sha of upstream main
     const { data: ref } = await octokit.rest.git.getRef({
         owner: CONTENT_OWNER,
         repo: CONTENT_REPO,
@@ -39,10 +39,10 @@ export async function createBranch(octokit, username, branchName) {
         sha,
     });
 }
-/** 파일을 fork의 브랜치에 커밋 */
+/** Commit file to fork branch */
 export async function pushFile(octokit, username, branchName, filePath, localFilePath, commitMessage) {
     const content = Buffer.from(readFileSync(localFilePath, 'utf-8')).toString('base64');
-    // 기존 파일 sha 확인 (update용)
+    // Check existing file sha (for update)
     let sha;
     try {
         const { data } = await octokit.rest.repos.getContent({
@@ -55,7 +55,7 @@ export async function pushFile(octokit, username, branchName, filePath, localFil
             sha = data.sha;
     }
     catch {
-        // 신규 파일
+        // New file
     }
     await octokit.rest.repos.createOrUpdateFileContents({
         owner: username,
@@ -67,7 +67,7 @@ export async function pushFile(octokit, username, branchName, filePath, localFil
         ...(sha ? { sha } : {}),
     });
 }
-/** upstream으로 PR 생성 */
+/** Create PR to upstream */
 export async function createPR(octokit, username, branchName, title, body) {
     const { data } = await octokit.rest.pulls.create({
         owner: CONTENT_OWNER,

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/dist/lib/schema.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import matter from 'gray-matter';
 import { readFileSync } from 'fs';
 const frontmatterSchema = z.object({
-    title: z.string().min(5, '제목은 5자 이상이어야 합니다'),
+    title: z.string().min(5, 'Title must be at least 5 characters'),
     purpose: z.enum(['guide', 'rule', 'template', 'example', 'reference']),
     level: z.enum(['beginner', 'intermediate', 'advanced']),
     lang: z.enum(['ko', 'en']),
@@ -18,21 +18,21 @@ const FILE_PATH_RE = /^(ko|en)\/(guide|rule|template|example|reference)\/(beginn
 export function validate(filePath) {
     const errors = [];
     const warnings = [];
-    // 1. 파일 경로 규칙
+    // 1. File path rules
     const relative = filePath.replace(/^.*?(?=ko\/|en\/)/, '');
     if (!FILE_PATH_RE.test(relative)) {
-        errors.push(`파일 경로가 규칙에 맞지 않습니다: {lang}/{purpose}/{level}/파일명.md`);
+        errors.push(`File path does not match: {lang}/{purpose}/{level}/filename.md`);
     }
-    // 2. 파일 읽기
+    // 2. Read file
     let raw;
     try {
         raw = readFileSync(filePath, 'utf-8');
     }
     catch {
-        errors.push('파일을 읽을 수 없습니다');
+        errors.push('Cannot read file');
         return { valid: false, errors, warnings };
     }
-    // 3. frontmatter 파싱
+    // 3. Parse frontmatter
     const { data, content } = matter(raw);
     const result = frontmatterSchema.safeParse(data);
     if (!result.success) {
@@ -41,17 +41,17 @@ export function validate(filePath) {
             errors.push(`[${field}] ${issue.message}`);
         }
     }
-    // 4. 본문 길이
+    // 4. Body length
     const bodyLength = content.trim().length;
     if (bodyLength < 200) {
-        errors.push(`본문이 너무 짧습니다 (현재 ${bodyLength}자, 최소 200자)`);
+        errors.push(`Content too short (${bodyLength} chars, minimum 200)`);
     }
-    // 5. 경고
+    // 5. Warnings
     if (!data.tags || data.tags.length === 0) {
-        warnings.push('tags를 추가하면 검색과 관련 문서 연결에 도움이 됩니다');
+        warnings.push('Adding tags helps with search and related document links');
     }
     if (!data.persona) {
-        warnings.push('persona를 지정하면 대상 독자가 명확해집니다');
+        warnings.push('Specifying a persona clarifies the target audience');
     }
     return {
         valid: errors.length === 0,

package/dist/lib/template.js

@@ -31,7 +31,7 @@ export function generateContent(fm) {
         .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## Examples\n\n<!-- Add real examples -->\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;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmpt-cli",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Record and share your AI-driven product development journey",
   "type": "module",
   "bin": {