pmpt-cli 1.0.0

package/dist/commands/submit.js

@@ -0,0 +1,103 @@
+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(`PromptWiki — 제출: ${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('오류를 수정한 후 다시 시도하세요: promptwiki 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,
+        ``,
+        `## 체크리스트`,
+        `- [ ] 본문이 명확하고 실용적인가?`,
+        `- [ ] 예시가 포함되어 있는가?`,
+        `- [ ] 제목과 내용이 일치하는가?`,
+        ``,
+        `---`,
+        `_promptwiki-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

@@ -0,0 +1,23 @@
+import * as p from '@clack/prompts';
+import { validate } from '../lib/schema.js';
+export function cmdValidate(filePath) {
+    p.intro(`PromptWiki — 검증: ${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/commands/watch.js

@@ -0,0 +1,33 @@
+import * as p from '@clack/prompts';
+import { resolve } from 'path';
+import { isInitialized, getPmptDir } from '../lib/config.js';
+import { startWatching } from '../lib/watcher.js';
+export function cmdWatch(path) {
+    const projectPath = path ? resolve(path) : process.cwd();
+    if (!isInitialized(projectPath)) {
+        p.log.error('Project not initialized. Run `pmpt init` first.');
+        process.exit(1);
+    }
+    const pmptDir = getPmptDir(projectPath);
+    p.intro('PromptWiki — File Watcher');
+    p.log.info(`Watching: ${pmptDir}`);
+    p.log.info('Auto-saving snapshots on MD file changes.');
+    p.log.info('Press Ctrl+C to stop.');
+    p.log.message('');
+    const watcher = startWatching(projectPath, (version, files, git) => {
+        let msg = `v${version} saved (${files.length} file(s))`;
+        if (git) {
+            msg += ` · ${git.commit}`;
+            if (git.dirty)
+                msg += ' (uncommitted)';
+        }
+        p.log.success(msg);
+    });
+    process.on('SIGINT', () => {
+        p.log.message('');
+        p.log.info('Stopping watcher...');
+        watcher.close();
+        p.outro('PromptWiki watcher stopped');
+        process.exit(0);
+    });
+}

package/dist/index.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { cmdNew } from './commands/new.js';
+import { cmdValidate } from './commands/validate.js';
+import { cmdSubmit } from './commands/submit.js';
+import { cmdInit } from './commands/init.js';
+import { cmdStatus } from './commands/status.js';
+import { cmdHistory } from './commands/hist.js';
+import { cmdWatch } from './commands/watch.js';
+import { cmdPlan } from './commands/plan.js';
+import { cmdSave } from './commands/save.js';
+import { cmdSquash } from './commands/squash.js';
+const program = new Command();
+program
+    .name('pmpt')
+    .description('pmpt — Record and share your AI-driven product development journey')
+    .version('1.0.0')
+    .addHelpText('after', `
+Examples:
+  $ pmpt init                    Initialize project
+  $ pmpt plan                    Start product planning (6 questions → AI prompt)
+  $ pmpt save                    Save snapshot of pmpt folder
+  $ pmpt watch                   Auto-detect file changes
+  $ pmpt history                 View version history
+  $ pmpt history --compact       Hide minor changes
+  $ pmpt squash v2 v5            Merge versions v2-v5 into v2
+
+Folder structure:
+  .promptwiki/
+  ├── config.json               Config file
+  ├── pmpt/                     Working folder (MD files)
+  └── .history/                 Version history
+
+Documentation: https://pmptwiki.com
+`);
+// Project tracking commands
+program
+    .command('init [path]')
+    .description('Initialize project folder and start history tracking')
+    .option('-r, --repo <url>', 'GitHub repository URL')
+    .action(cmdInit);
+program
+    .command('watch [path]')
+    .description('Watch for file changes and auto-save versions')
+    .action(cmdWatch);
+program
+    .command('save [path]')
+    .description('Save current state of pmpt folder as snapshot')
+    .action(cmdSave);
+program
+    .command('status [path]')
+    .description('Check project status and tracked files')
+    .action(cmdStatus);
+program
+    .command('history [path]')
+    .description('View saved version history')
+    .option('-c, --compact', 'Show compact history (hide small changes)')
+    .action(cmdHistory);
+program
+    .command('squash <from> <to> [path]')
+    .description('Squash multiple versions into one (e.g., pmpt squash v2 v5)')
+    .action(cmdSquash);
+program
+    .command('plan [path]')
+    .description('Quick product planning with 6 questions — auto-generate AI prompt')
+    .option('--reset', 'Restart plan from scratch')
+    .action(cmdPlan);
+// Contribution commands
+program
+    .command('new')
+    .description('Create new document interactively')
+    .action(cmdNew);
+program
+    .command('validate <file>')
+    .description('Validate document frontmatter and content')
+    .action((file) => {
+    const ok = cmdValidate(file);
+    if (!ok)
+        process.exit(1);
+});
+program
+    .command('submit <file>')
+    .description('Submit document via Fork → Branch → PR')
+    .action(cmdSubmit);
+program
+    .command('logout')
+    .description('Clear saved GitHub authentication')
+    .action(async () => {
+    const { clearAuth } = await import('./lib/auth.js');
+    clearAuth();
+    console.log('Logged out successfully');
+});
+program.parse();

package/dist/lib/auth.js

@@ -0,0 +1,24 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const CONFIG_DIR = join(homedir(), '.config', 'promptwiki');
+const TOKEN_FILE = join(CONFIG_DIR, 'auth.json');
+export function loadAuth() {
+    try {
+        if (!existsSync(TOKEN_FILE))
+            return null;
+        return JSON.parse(readFileSync(TOKEN_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveAuth(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(TOKEN_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function clearAuth() {
+    if (existsSync(TOKEN_FILE)) {
+        writeFileSync(TOKEN_FILE, '{}');
+    }
+}

package/dist/lib/config.js

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+const CONFIG_DIR = '.promptwiki';
+const CONFIG_FILE = 'config.json';
+const PMPT_DIR = 'pmpt'; // 작업 폴더 (추적 대상)
+const HISTORY_DIR = '.history'; // 히스토리 (숨김)
+export function getConfigDir(projectPath) {
+    return join(projectPath, CONFIG_DIR);
+}
+export function getPmptDir(projectPath) {
+    return join(getConfigDir(projectPath), PMPT_DIR);
+}
+export function getHistoryDir(projectPath) {
+    return join(getConfigDir(projectPath), HISTORY_DIR);
+}
+export function isInitialized(projectPath) {
+    return existsSync(join(getConfigDir(projectPath), CONFIG_FILE));
+}
+export function initializeProject(projectPath, options) {
+    const configDir = getConfigDir(projectPath);
+    const pmptDir = getPmptDir(projectPath);
+    const historyDir = getHistoryDir(projectPath);
+    mkdirSync(configDir, { recursive: true });
+    mkdirSync(pmptDir, { recursive: true });
+    mkdirSync(historyDir, { recursive: true });
+    const config = {
+        projectPath,
+        watchPatterns: ['.promptwiki/pmpt/**/*.md'], // pmpt 폴더만 추적
+        ignorePatterns: ['node_modules/**', '.promptwiki/.history/**', 'dist/**'],
+        createdAt: new Date().toISOString(),
+        repo: options?.repo,
+        trackGit: options?.trackGit ?? true,
+    };
+    saveConfig(projectPath, config);
+    return config;
+}
+export function loadConfig(projectPath) {
+    const configPath = join(getConfigDir(projectPath), CONFIG_FILE);
+    if (!existsSync(configPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(projectPath, config) {
+    const configPath = join(getConfigDir(projectPath), CONFIG_FILE);
+    writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}

package/dist/lib/git.js

@@ -0,0 +1,102 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * 디렉토리가 git 저장소인지 확인
+ */
+export function isGitRepo(path) {
+    return existsSync(join(path, '.git'));
+}
+/**
+ * git 명령어 실행 헬퍼
+ */
+function git(path, args) {
+    try {
+        return execSync(`git ${args}`, {
+            cwd: path,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 현재 git 상태 정보 수집
+ */
+export function getGitInfo(path, remoteUrl) {
+    if (!isGitRepo(path)) {
+        return null;
+    }
+    // 커밋 해시
+    const commitFull = git(path, 'rev-parse HEAD');
+    if (!commitFull)
+        return null;
+    const commit = git(path, 'rev-parse --short HEAD') || commitFull.slice(0, 7);
+    // 브랜치
+    const branch = git(path, 'rev-parse --abbrev-ref HEAD') || 'HEAD';
+    // uncommitted 변경 확인
+    const status = git(path, 'status --porcelain');
+    const dirty = status !== null && status.length > 0;
+    // 커밋 타임스탬프
+    const timestamp = git(path, 'log -1 --format=%cI') || new Date().toISOString();
+    // 현재 커밋의 태그
+    const tag = git(path, 'describe --tags --exact-match 2>/dev/null') || undefined;
+    // 원격 저장소 URL (제공되지 않으면 origin에서 가져옴)
+    let repo = remoteUrl;
+    if (!repo) {
+        const origin = git(path, 'remote get-url origin');
+        if (origin) {
+            // SSH URL을 HTTPS로 변환
+            repo = origin
+                .replace(/^git@github\.com:/, 'https://github.com/')
+                .replace(/\.git$/, '');
+        }
+    }
+    return {
+        repo,
+        commit,
+        commitFull,
+        branch,
+        dirty,
+        timestamp,
+        tag: tag || undefined,
+    };
+}
+/**
+ * git 상태가 clean한지 확인
+ */
+export function isGitClean(path) {
+    const status = git(path, 'status --porcelain');
+    return status !== null && status.length === 0;
+}
+/**
+ * 특정 커밋이 현재 커밋과 일치하는지 확인
+ */
+export function isCommitMatch(path, expectedCommit) {
+    const currentFull = git(path, 'rev-parse HEAD');
+    const currentShort = git(path, 'rev-parse --short HEAD');
+    if (!currentFull || !currentShort)
+        return false;
+    return (currentFull === expectedCommit ||
+        currentShort === expectedCommit ||
+        currentFull.startsWith(expectedCommit) ||
+        expectedCommit.startsWith(currentShort));
+}
+/**
+ * git 정보를 사람이 읽기 쉬운 문자열로 변환
+ */
+export function formatGitInfo(info) {
+    const parts = [
+        `commit: ${info.commit}`,
+        `branch: ${info.branch}`,
+    ];
+    if (info.tag) {
+        parts.push(`tag: ${info.tag}`);
+    }
+    if (info.dirty) {
+        parts.push('(uncommitted changes)');
+    }
+    return parts.join(' · ');
+}

package/dist/lib/github.js

@@ -0,0 +1,81 @@
+import { Octokit } from '@octokit/rest';
+import { readFileSync } from 'fs';
+const CONTENT_OWNER = 'promptwiki';
+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;
+}