pmpt-cli 1.4.1 → 1.5.1

package/README.md

@@ -2,8 +2,6 @@
 
 **Record and share your AI-driven product development journey.**
 
-AI와 대화하며 제품을 만드는 여정을 기록하고 공유하세요.
-
 [![npm version](https://img.shields.io/npm/v/pmpt-cli.svg)](https://www.npmjs.com/package/pmpt-cli)
 
 **Website**: [pmptwiki.com](https://pmptwiki.com)
@@ -44,7 +42,7 @@ pmpt publish
 - **5 questions** — Quick product planning with AI-ready prompts
 - **Version history** — Track every step of your AI-assisted development
 - **Share & reproduce** — Publish projects for others to learn from and clone
-- **Project hub** — Browse and clone projects at [pmptwiki.com](https://pmptwiki.com/en/explore)
+- **Project hub** — Browse and clone projects at [pmptwiki.com](https://pmptwiki.com/explore)
 
 ---
 
@@ -141,7 +139,7 @@ Single JSON file containing your entire development journey:
 ## Links
 
 - [Website](https://pmptwiki.com)
-- [Explore Projects](https://pmptwiki.com/en/explore)
+- [Explore Projects](https://pmptwiki.com/explore)
 - [GitHub](https://github.com/pmptwiki/pmpt-cli)
 - [npm](https://www.npmjs.com/package/pmpt-cli)
 

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

@@ -2,29 +2,10 @@ import * as p from '@clack/prompts';
 import { resolve, join, basename } from 'path';
 import { existsSync, readFileSync, writeFileSync, statSync } from 'fs';
 import { isInitialized, getDocsDir, loadConfig } from '../lib/config.js';
-import { getAllSnapshots } from '../lib/history.js';
+import { getAllSnapshots, resolveFullSnapshot } from '../lib/history.js';
 import { getPlanProgress } from '../lib/plan.js';
 import { createPmptFile, SCHEMA_VERSION } from '../lib/pmptFile.js';
 import glob from 'fast-glob';
-/**
- * Read all files from a snapshot directory
- */
-function readSnapshotFiles(snapshotDir) {
-    const files = {};
-    if (!existsSync(snapshotDir))
-        return files;
-    const mdFiles = glob.sync('**/*.md', { cwd: snapshotDir });
-    for (const file of mdFiles) {
-        const filePath = join(snapshotDir, file);
-        try {
-            files[file] = readFileSync(filePath, 'utf-8');
-        }
-        catch {
-            // Skip files that can't be read
-        }
-    }
-    return files;
-}
 /**
  * Read current docs folder
  */
@@ -69,15 +50,15 @@ export async function cmdExport(path, options) {
         : resolve(projectPath, `${exportName}.pmpt`);
     const s = p.spinner();
     s.start('Creating .pmpt file...');
-    // Build history array with file contents
+    // Build history array with file contents (resolve from optimized snapshots)
     const history = [];
-    for (const snapshot of snapshots) {
-        const files = readSnapshotFiles(snapshot.snapshotDir);
+    for (let i = 0; i < snapshots.length; i++) {
+        const files = resolveFullSnapshot(snapshots, i);
         history.push({
-            version: snapshot.version,
-            timestamp: snapshot.timestamp,
+            version: snapshots[i].version,
+            timestamp: snapshots[i].timestamp,
             files,
-            git: snapshot.git,
+            git: snapshots[i].git,
         });
     }
     // Read current docs

package/dist/commands/hist.js

@@ -1,8 +1,7 @@
 import * as p from '@clack/prompts';
-import { resolve, join } from 'path';
-import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
 import { isInitialized } from '../lib/config.js';
-import { getAllSnapshots } from '../lib/history.js';
+import { getAllSnapshots, resolveFileContent } from '../lib/history.js';
 // Simple diff calculation: count changed lines
 function calculateDiffSize(oldContent, newContent) {
     const oldLines = oldContent.split('\n');
@@ -16,15 +15,15 @@ function calculateDiffSize(oldContent, newContent) {
     }
     return changes;
 }
-// Get total diff between two snapshots
-function getSnapshotDiff(prev, curr) {
+// Get total diff between two snapshots (supports optimized snapshots)
+function getSnapshotDiff(snapshots, prevIndex, currIndex) {
+    const prev = snapshots[prevIndex];
+    const curr = snapshots[currIndex];
     let totalChanges = 0;
     const allFiles = new Set([...prev.files, ...curr.files]);
     for (const file of allFiles) {
-        const prevPath = join(prev.snapshotDir, file);
-        const currPath = join(curr.snapshotDir, file);
-        const prevContent = existsSync(prevPath) ? readFileSync(prevPath, 'utf-8') : '';
-        const currContent = existsSync(currPath) ? readFileSync(currPath, 'utf-8') : '';
+        const prevContent = resolveFileContent(snapshots, prevIndex, file) || '';
+        const currContent = resolveFileContent(snapshots, currIndex, file) || '';
         totalChanges += calculateDiffSize(prevContent, currContent);
     }
     return totalChanges;
@@ -49,7 +48,7 @@ export function cmdHistory(path, options) {
     if (options?.compact && snapshots.length > 1) {
         displaySnapshots = [snapshots[0]]; // Always show first
         for (let i = 1; i < snapshots.length; i++) {
-            const diffSize = getSnapshotDiff(snapshots[i - 1], snapshots[i]);
+            const diffSize = getSnapshotDiff(snapshots, i - 1, i);
             // Threshold: hide if less than 5 lines changed
             if (diffSize < 5) {
                 hiddenVersions.push(snapshots[i].version);

package/dist/commands/login.js

@@ -1,6 +1,7 @@
 import * as p from '@clack/prompts';
+import open from 'open';
 import { loadAuth, saveAuth } from '../lib/auth.js';
-import { registerAuth } from '../lib/api.js';
+import { requestDeviceCode, pollDeviceToken } from '../lib/api.js';
 export async function cmdLogin() {
     p.intro('pmpt login');
     const existing = loadAuth();
@@ -15,32 +16,63 @@ export async function cmdLogin() {
             return;
         }
     }
-    p.log.info('GitHub Personal Access Token이 필요합니다.\n' +
-        '  https://github.com/settings/tokens/new\n' +
-        '  필요 권한: read:user');
-    const pat = await p.password({
-        message: 'GitHub PAT를 입력하세요:',
-        validate: (v) => (v.trim().length < 10 ? '올바른 토큰을 입력하세요' : undefined),
-    });
-    if (p.isCancel(pat)) {
-        p.cancel('취소됨');
-        process.exit(0);
-    }
+    // Step 1: Request device code
     const s = p.spinner();
-    s.start('인증 중...');
+    s.start('Preparing GitHub authentication...');
+    let device;
     try {
-        const result = await registerAuth(pat);
-        saveAuth({
-            token: result.token,
-            githubToken: pat,
-            username: result.username,
-        });
-        s.stop(`인증 완료 — @${result.username}`);
+        device = await requestDeviceCode();
+        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);
     }
-    p.outro('로그인 완료! pmpt publish로 프로젝트를 공유하세요.');
+    // Step 2: Show code and open browser
+    p.log.info(`Enter this code on GitHub:\n\n` +
+        `  Code: ${device.userCode}\n` +
+        `  URL:  ${device.verificationUri}`);
+    const shouldOpen = await p.confirm({
+        message: 'Open browser?',
+        initialValue: true,
+    });
+    if (p.isCancel(shouldOpen)) {
+        p.cancel('Cancelled');
+        process.exit(0);
+    }
+    if (shouldOpen) {
+        await open(device.verificationUri);
+    }
+    // Step 3: Poll for token
+    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) {
+        await sleep(interval);
+        try {
+            const result = await pollDeviceToken(device.deviceCode);
+            if (result.status === 'complete') {
+                saveAuth({ token: result.token, username: result.username });
+                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') {
+                interval = (result.interval ?? 10) * 1000;
+            }
+            // status === 'pending' → keep polling
+        }
+        catch (err) {
+            s.stop('Authentication failed');
+            p.log.error(err instanceof Error ? err.message : 'Authentication failed.');
+            process.exit(1);
+        }
+    }
+    s.stop('Verification code expired.');
+    p.log.error('Please run pmpt login again.');
+    process.exit(1);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, 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

@@ -2,26 +2,13 @@ import * as p from '@clack/prompts';
 import { resolve, basename } from 'path';
 import { readFileSync, existsSync } from 'fs';
 import { isInitialized, loadConfig, saveConfig, getDocsDir } from '../lib/config.js';
-import { getAllSnapshots } from '../lib/history.js';
+import { getAllSnapshots, resolveFullSnapshot } from '../lib/history.js';
 import { getPlanProgress } from '../lib/plan.js';
 import { createPmptFile } from '../lib/pmptFile.js';
 import { loadAuth } from '../lib/auth.js';
 import { publishProject } from '../lib/api.js';
 import glob from 'fast-glob';
 import { join } from 'path';
-function readSnapshotFiles(snapshotDir) {
-    const files = {};
-    if (!existsSync(snapshotDir))
-        return files;
-    const mdFiles = glob.sync('**/*.md', { cwd: snapshotDir });
-    for (const file of mdFiles) {
-        try {
-            files[file] = readFileSync(join(snapshotDir, file), 'utf-8');
-        }
-        catch { /* skip */ }
-    }
-    return files;
-}
 function readDocsFolder(docsDir) {
     const files = {};
     if (!existsSync(docsDir))
@@ -38,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');
@@ -51,52 +38,69 @@ 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
         .split(',')
         .map((t) => t.trim().toLowerCase())
         .filter(Boolean);
-    // Build .pmpt content (reuse export logic)
-    const history = snapshots.map((snapshot) => ({
+    const category = await p.select({
+        message: 'Project category:',
+        options: [
+            { 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' },
+        ],
+    });
+    if (p.isCancel(category)) {
+        p.cancel('Cancelled');
+        process.exit(0);
+    }
+    // Build .pmpt content (resolve from optimized snapshots)
+    const history = snapshots.map((snapshot, i) => ({
         version: snapshot.version,
         timestamp: snapshot.timestamp,
-        files: readSnapshotFiles(snapshot.snapshotDir),
+        files: resolveFullSnapshot(snapshots, i),
         git: snapshot.git,
     }));
     const docsDir = getDocsDir(projectPath);
@@ -125,27 +129,29 @@ export async function cmdPublish(path) {
         `Versions: ${snapshots.length}`,
         `Size: ${(pmptContent.length / 1024).toFixed(1)} KB`,
         `Author: @${auth.username}`,
+        `Category: ${category}`,
         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,
             pmptContent,
             description: description,
             tags,
+            category: category,
         });
-        s.stop('게시 완료!');
+        s.stop('Published!');
         // Update config
         if (config) {
             config.lastPublished = new Date().toISOString();
@@ -155,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/save.js

@@ -32,11 +32,17 @@ export async function cmdSave(fileOrPath) {
             if (entry.git.dirty)
                 msg += ' (uncommitted)';
         }
+        const changedCount = entry.changedFiles?.length ?? entry.files.length;
+        const unchangedCount = entry.files.length - changedCount;
+        if (unchangedCount > 0) {
+            msg += ` (${changedCount} changed, ${unchangedCount} skipped)`;
+        }
         p.log.success(msg);
         p.log.message('');
         p.log.info('Files included:');
         for (const file of entry.files) {
-            p.log.message(`  - ${file}`);
+            const isChanged = entry.changedFiles ? entry.changedFiles.includes(file) : true;
+            p.log.message(`  - ${file}${isChanged ? '' : ' (unchanged)'}`);
         }
     }
     catch (error) {