pmpt-cli 1.0.0

package/dist/lib/history.js

@@ -0,0 +1,233 @@
+import { copyFileSync, existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
+import { basename, join, relative } from 'path';
+import { getHistoryDir, getPmptDir, loadConfig } from './config.js';
+import { getGitInfo, isGitRepo } from './git.js';
+import glob from 'fast-glob';
+/**
+ * pmpt 폴더 전체를 스냅샷으로 저장
+ * .history/v{N}-{timestamp}/ 폴더에 모든 파일 복사
+ */
+export function createFullSnapshot(projectPath) {
+    const historyDir = getHistoryDir(projectPath);
+    const pmptDir = getPmptDir(projectPath);
+    mkdirSync(historyDir, { recursive: true });
+    // 다음 버전 번호 찾기
+    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 });
+    // pmpt 폴더의 모든 MD 파일 복사
+    const files = [];
+    if (existsSync(pmptDir)) {
+        const mdFiles = glob.sync('**/*.md', { cwd: pmptDir });
+        for (const file of mdFiles) {
+            const srcPath = join(pmptDir, file);
+            const destPath = join(snapshotDir, file);
+            // 하위 디렉토리가 있으면 생성
+            const destDir = join(snapshotDir, file.split('/').slice(0, -1).join('/'));
+            if (destDir !== snapshotDir) {
+                mkdirSync(destDir, { recursive: true });
+            }
+            copyFileSync(srcPath, destPath);
+            files.push(file);
+        }
+    }
+    // Git 정보 수집
+    const config = loadConfig(projectPath);
+    let gitData;
+    if (config?.trackGit && isGitRepo(projectPath)) {
+        const gitInfo = getGitInfo(projectPath, config.repo);
+        if (gitInfo) {
+            gitData = {
+                commit: gitInfo.commit,
+                commitFull: gitInfo.commitFull,
+                branch: gitInfo.branch,
+                dirty: gitInfo.dirty,
+                tag: gitInfo.tag,
+            };
+        }
+    }
+    // 메타데이터 저장
+    const metaPath = join(snapshotDir, '.meta.json');
+    writeFileSync(metaPath, JSON.stringify({
+        version,
+        timestamp,
+        files,
+        git: gitData,
+    }, null, 2), 'utf-8');
+    return {
+        version,
+        timestamp,
+        snapshotDir,
+        files,
+        git: gitData,
+    };
+}
+/**
+ * 단일 파일 스냅샷 (pmpt 폴더 내 특정 파일만)
+ * 기존 호환성을 위해 유지하되, 내부적으로 전체 스냅샷 사용
+ */
+export function createSnapshot(projectPath, filePath) {
+    const historyDir = getHistoryDir(projectPath);
+    const pmptDir = getPmptDir(projectPath);
+    const relPath = relative(pmptDir, filePath);
+    // 파일이 pmpt 폴더 외부에 있는 경우
+    if (relPath.startsWith('..')) {
+        // 프로젝트 루트 기준 상대 경로 사용
+        const projectRelPath = relative(projectPath, filePath);
+        return createSingleFileSnapshot(projectPath, filePath, projectRelPath);
+    }
+    return createSingleFileSnapshot(projectPath, filePath, relPath);
+}
+function createSingleFileSnapshot(projectPath, filePath, relPath) {
+    const historyDir = getHistoryDir(projectPath);
+    const fileName = basename(filePath, '.md');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    // 해당 파일의 기존 버전 수 확인
+    const existing = getFileHistory(projectPath, relPath);
+    const version = existing.length + 1;
+    // 버전 폴더 생성
+    const snapshotName = `v${version}-${timestamp}`;
+    const snapshotDir = join(historyDir, snapshotName);
+    mkdirSync(snapshotDir, { recursive: true });
+    // 파일 복사
+    const destPath = join(snapshotDir, basename(filePath));
+    copyFileSync(filePath, destPath);
+    // Git 정보 수집
+    const config = loadConfig(projectPath);
+    let gitData;
+    if (config?.trackGit && isGitRepo(projectPath)) {
+        const gitInfo = getGitInfo(projectPath, config.repo);
+        if (gitInfo) {
+            gitData = {
+                commit: gitInfo.commit,
+                commitFull: gitInfo.commitFull,
+                branch: gitInfo.branch,
+                dirty: gitInfo.dirty,
+                tag: gitInfo.tag,
+            };
+        }
+    }
+    // 메타데이터 저장
+    const metaPath = join(snapshotDir, '.meta.json');
+    writeFileSync(metaPath, JSON.stringify({
+        version,
+        timestamp,
+        filePath: relPath,
+        git: gitData,
+    }, null, 2), 'utf-8');
+    return {
+        version,
+        timestamp,
+        filePath: relPath,
+        historyPath: destPath,
+        git: gitData,
+    };
+}
+/**
+ * 모든 스냅샷 목록 조회
+ */
+export function getAllSnapshots(projectPath) {
+    const historyDir = getHistoryDir(projectPath);
+    if (!existsSync(historyDir))
+        return [];
+    const entries = [];
+    const dirs = readdirSync(historyDir);
+    for (const dir of dirs) {
+        const match = dir.match(/^v(\d+)-(.+)$/);
+        if (!match)
+            continue;
+        const snapshotDir = join(historyDir, dir);
+        if (!statSync(snapshotDir).isDirectory())
+            continue;
+        const metaPath = join(snapshotDir, '.meta.json');
+        let meta = {};
+        if (existsSync(metaPath)) {
+            try {
+                meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+            }
+            catch {
+                // 메타 파일 파싱 실패 시 기본값 사용
+            }
+        }
+        entries.push({
+            version: parseInt(match[1], 10),
+            timestamp: match[2].replace(/-/g, ':'),
+            snapshotDir,
+            files: meta.files || [],
+            git: meta.git,
+        });
+    }
+    return entries.sort((a, b) => a.version - b.version);
+}
+/**
+ * 특정 파일의 히스토리 조회 (하위 호환성)
+ */
+export function getFileHistory(projectPath, relPath) {
+    const historyDir = getHistoryDir(projectPath);
+    if (!existsSync(historyDir))
+        return [];
+    const fileName = basename(relPath);
+    const entries = [];
+    const dirs = readdirSync(historyDir);
+    for (const dir of dirs) {
+        const match = dir.match(/^v(\d+)-(.+)$/);
+        if (!match)
+            continue;
+        const snapshotDir = join(historyDir, dir);
+        if (!statSync(snapshotDir).isDirectory())
+            continue;
+        const filePath = join(snapshotDir, fileName);
+        if (!existsSync(filePath))
+            continue;
+        const metaPath = join(snapshotDir, '.meta.json');
+        let gitData;
+        if (existsSync(metaPath)) {
+            try {
+                const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+                gitData = meta.git;
+            }
+            catch {
+                // 메타 파일 파싱 실패 시 무시
+            }
+        }
+        entries.push({
+            version: parseInt(match[1], 10),
+            timestamp: match[2].replace(/-/g, ':'),
+            filePath: relPath,
+            historyPath: filePath,
+            git: gitData,
+        });
+    }
+    return entries.sort((a, b) => a.version - b.version);
+}
+/**
+ * 전체 히스토리 조회 (모든 스냅샷의 모든 파일)
+ */
+export function getAllHistory(projectPath) {
+    const snapshots = getAllSnapshots(projectPath);
+    const entries = [];
+    for (const snapshot of snapshots) {
+        for (const file of snapshot.files) {
+            entries.push({
+                version: snapshot.version,
+                timestamp: snapshot.timestamp,
+                filePath: file,
+                historyPath: join(snapshot.snapshotDir, file),
+                git: snapshot.git,
+            });
+        }
+    }
+    return entries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+}
+/**
+ * 추적 중인 파일 목록 (pmpt 폴더 기준)
+ */
+export function getTrackedFiles(projectPath) {
+    const pmptDir = getPmptDir(projectPath);
+    if (!existsSync(pmptDir))
+        return [];
+    return glob.sync('**/*.md', { cwd: pmptDir });
+}

package/dist/lib/plan.js

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { getConfigDir, getPmptDir } from './config.js';
+import { createFullSnapshot } from './history.js';
+const PLAN_FILE = 'plan-progress.json';
+// 6 simple questions (answer in any language you prefer)
+export const PLAN_QUESTIONS = [
+    {
+        key: 'projectName',
+        question: 'Project name?',
+        placeholder: 'my-awesome-app',
+        required: true,
+    },
+    {
+        key: 'problem',
+        question: 'What problem are you solving?',
+        placeholder: 'e.g., Developers spend too much time finding API docs',
+        multiline: true,
+        required: true,
+    },
+    {
+        key: 'solution',
+        question: 'How will you solve it?',
+        placeholder: 'e.g., AI analyzes code and auto-generates API docs',
+        multiline: true,
+        required: true,
+    },
+    {
+        key: 'targetUser',
+        question: 'Who is your target user?',
+        placeholder: 'e.g., Startup backend developers',
+        required: true,
+    },
+    {
+        key: 'coreFeatures',
+        question: 'Core features for MVP? (one per line)',
+        placeholder: 'e.g.:\nCode upload\nAI analysis\nDoc generation',
+        multiline: true,
+        required: true,
+    },
+    {
+        key: 'techStack',
+        question: 'Preferred tech stack? (optional)',
+        placeholder: 'e.g., React, Node.js, PostgreSQL',
+        multiline: false,
+        required: false,
+    },
+];
+// Generate AI prompt (language-agnostic template)
+export function generateAIPrompt(answers) {
+    const features = answers.coreFeatures
+        .split('\n')
+        .map((f) => f.trim())
+        .filter((f) => f)
+        .map((f) => `- ${f}`)
+        .join('\n');
+    const techSection = answers.techStack
+        ? `\n## Tech Stack Preferences\n${answers.techStack}\n`
+        : '';
+    return `# ${answers.projectName} — Product Development Request
+
+## Problem
+${answers.problem}
+
+## Proposed Solution
+${answers.solution}
+
+## Target User
+${answers.targetUser}
+
+## MVP Core Features
+${features}
+${techSection}
+---
+
+Please help me build this product based on the requirements above.
+
+1. First, review the requirements and ask if anything is unclear.
+2. Propose a technical architecture.
+3. Outline the MVP implementation steps.
+4. Start coding from the first step.
+
+I'll confirm progress at each step before moving to the next.
+
+## Documentation Rule
+
+**Important:** Update this document (located at \`.promptwiki/pmpt/pmpt.md\`) at these moments:
+- When architecture or tech decisions are finalized
+- When a feature is implemented (mark as done)
+- When a development phase is completed
+- When requirements change or new decisions are made
+
+Add a "## Progress" section below and keep it updated:
+\`\`\`
+## Progress
+- [x] Completed item
+- [ ] Pending item
+\`\`\`
+
+This keeps a living record of our development journey.
+`;
+}
+// Generate plan document
+export function generatePlanDocument(answers) {
+    const features = answers.coreFeatures
+        .split('\n')
+        .map((f) => f.trim())
+        .filter((f) => f)
+        .map((f) => `- [ ] ${f}`)
+        .join('\n');
+    const techSection = answers.techStack
+        ? `\n## Tech Stack\n${answers.techStack}\n`
+        : '';
+    return `# ${answers.projectName}
+
+## Problem
+${answers.problem}
+
+## Solution
+${answers.solution}
+
+## Target User
+${answers.targetUser}
+
+## MVP Features
+${features}
+${techSection}
+---
+*Generated by PromptWiki Plan*
+`;
+}
+export function getPlanProgress(projectPath) {
+    const planPath = join(getConfigDir(projectPath), PLAN_FILE);
+    if (!existsSync(planPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(planPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function savePlanProgress(projectPath, progress) {
+    const configDir = getConfigDir(projectPath);
+    mkdirSync(configDir, { recursive: true });
+    const planPath = join(configDir, PLAN_FILE);
+    progress.updatedAt = new Date().toISOString();
+    writeFileSync(planPath, JSON.stringify(progress, null, 2), 'utf-8');
+}
+export function initPlanProgress(projectPath) {
+    const progress = {
+        completed: false,
+        startedAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    savePlanProgress(projectPath, progress);
+    return progress;
+}
+export function savePlanDocuments(projectPath, answers) {
+    const pmptDir = getPmptDir(projectPath);
+    mkdirSync(pmptDir, { recursive: true });
+    // Save plan to pmpt folder
+    const planPath = join(pmptDir, 'plan.md');
+    const planContent = generatePlanDocument(answers);
+    writeFileSync(planPath, planContent, 'utf-8');
+    // Save AI prompt to pmpt folder
+    const promptPath = join(pmptDir, 'pmpt.md');
+    const promptContent = generateAIPrompt(answers);
+    writeFileSync(promptPath, promptContent, 'utf-8');
+    // Create initial snapshot
+    createFullSnapshot(projectPath);
+    return { planPath, promptPath };
+}

package/dist/lib/schema.js

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,37 @@
+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;
+}

package/dist/lib/watcher.js

@@ -0,0 +1,63 @@
+import chokidar from 'chokidar';
+import { loadConfig, getPmptDir } from './config.js';
+import { createFullSnapshot } from './history.js';
+import { readFileSync } from 'fs';
+export function startWatching(projectPath, onSnapshot) {
+    const config = loadConfig(projectPath);
+    if (!config) {
+        throw new Error('Project not initialized. Run `pmpt init` first.');
+    }
+    const pmptDir = getPmptDir(projectPath);
+    // Watch all MD files in pmpt folder
+    const watcher = chokidar.watch('**/*.md', {
+        cwd: pmptDir,
+        ignoreInitial: true,
+        persistent: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 500,
+            pollInterval: 100,
+        },
+    });
+    const fileContents = new Map();
+    let debounceTimer = null;
+    const saveSnapshot = () => {
+        const entry = createFullSnapshot(projectPath);
+        if (onSnapshot) {
+            onSnapshot(entry.version, entry.files, entry.git);
+        }
+    };
+    // Debounced snapshot save (1 second)
+    const debouncedSave = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(saveSnapshot, 1000);
+    };
+    watcher.on('add', (path) => {
+        const fullPath = `${pmptDir}/${path}`;
+        try {
+            const content = readFileSync(fullPath, 'utf-8');
+            fileContents.set(path, content);
+            debouncedSave();
+        }
+        catch {
+            // Ignore file read errors
+        }
+    });
+    watcher.on('change', (path) => {
+        const fullPath = `${pmptDir}/${path}`;
+        try {
+            const newContent = readFileSync(fullPath, 'utf-8');
+            const oldContent = fileContents.get(path);
+            // Only snapshot if content actually changed
+            if (oldContent !== newContent) {
+                fileContents.set(path, newContent);
+                debouncedSave();
+            }
+        }
+        catch {
+            // Ignore file read errors
+        }
+    });
+    return watcher;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "pmpt-cli",
+  "version": "1.0.0",
+  "description": "Record and share your AI-driven product development journey",
+  "type": "module",
+  "bin": {
+    "pmpt": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "pmpt",
+    "cli",
+    "prompt",
+    "ai",
+    "spec",
+    "log",
+    "development"
+  ],
+  "homepage": "https://pmptwiki.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/promptwiki/cli.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "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",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}