pmpt-cli 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+# promptwiki-cli
+
+CLI tool for contributing to [PromptWiki](https://pmptwiki.com) — a community-driven guide to working with AI.
+
+## Install
+
+```bash
+npm install -g promptwiki-cli
+```
+
+## Usage
+
+### Create a new document
+
+```bash
+promptwiki new
+```
+
+Interactive prompts will guide you through creating a properly structured markdown file.
+
+### Validate a document
+
+```bash
+promptwiki validate ko/guide/beginner/my-guide.md
+```
+
+Checks frontmatter schema, required fields, and minimum content length before submission.
+
+### Submit via Pull Request
+
+```bash
+promptwiki submit ko/guide/beginner/my-guide.md
+```
+
+Automatically forks `promptwiki/content`, creates a branch, and opens a Pull Request. Requires a GitHub Personal Access Token with `repo` scope (you'll be prompted on first use).
+
+### Logout
+
+```bash
+promptwiki logout
+```
+
+Removes stored GitHub credentials from `~/.config/promptwiki/auth.json`.
+
+## Workflow
+
+```
+promptwiki new          # create file interactively
+# edit the file in your editor
+promptwiki validate     # check before submitting
+promptwiki submit       # fork → branch → PR
+```
+
+Once your PR is merged into `promptwiki/content`, the site at pmptwiki.com updates automatically.
+
+## License
+
+MIT

package/dist/commands/hist.js

@@ -0,0 +1,90 @@
+import * as p from '@clack/prompts';
+import { resolve, join } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import { isInitialized } from '../lib/config.js';
+import { getAllSnapshots } from '../lib/history.js';
+// Simple diff calculation: count changed lines
+function calculateDiffSize(oldContent, newContent) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    let changes = 0;
+    const maxLen = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLen; i++) {
+        if (oldLines[i] !== newLines[i]) {
+            changes++;
+        }
+    }
+    return changes;
+}
+// Get total diff between two snapshots
+function getSnapshotDiff(prev, curr) {
+    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') : '';
+        totalChanges += calculateDiffSize(prevContent, currContent);
+    }
+    return totalChanges;
+}
+export function cmdHistory(path, options) {
+    const projectPath = path ? resolve(path) : process.cwd();
+    if (!isInitialized(projectPath)) {
+        p.log.error('Project not initialized. Run `pmpt init` first.');
+        process.exit(1);
+    }
+    const snapshots = getAllSnapshots(projectPath);
+    if (snapshots.length === 0) {
+        p.intro('PromptWiki — Version History');
+        p.log.warn('No snapshots saved yet.');
+        p.log.info('Save snapshots with pmpt save or pmpt watch.');
+        p.outro('');
+        return;
+    }
+    // In compact mode, filter out versions with minimal changes
+    let displaySnapshots = snapshots;
+    const hiddenVersions = [];
+    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]);
+            // Threshold: hide if less than 5 lines changed
+            if (diffSize < 5) {
+                hiddenVersions.push(snapshots[i].version);
+            }
+            else {
+                displaySnapshots.push(snapshots[i]);
+            }
+        }
+    }
+    const title = options?.compact
+        ? `PromptWiki — Version History (${displaySnapshots.length} shown, ${hiddenVersions.length} hidden)`
+        : `PromptWiki — Version History (${snapshots.length} total)`;
+    p.intro(title);
+    for (const snapshot of displaySnapshots) {
+        const dateStr = new Date(snapshot.timestamp).toLocaleString(undefined, {
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+        let header = `v${snapshot.version} — ${dateStr}`;
+        if (snapshot.git) {
+            header += ` · ${snapshot.git.commit}`;
+            if (snapshot.git.dirty)
+                header += ' (dirty)';
+        }
+        const files = snapshot.files.map((f) => `  - ${f}`).join('\n');
+        p.note(files || '  (no files)', header);
+    }
+    if (options?.compact && hiddenVersions.length > 0) {
+        p.log.info(`Hidden versions (minor changes): ${hiddenVersions.map(v => `v${v}`).join(', ')}`);
+        p.log.info('Run without --compact to see all versions.');
+    }
+    if (!options?.compact && snapshots.length > 3) {
+        p.log.info('Tip: Use --compact to hide minor changes, or "pmpt squash v1 v3" to merge.');
+    }
+    p.outro('');
+}

package/dist/commands/init.js

@@ -0,0 +1,130 @@
+import * as p from '@clack/prompts';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { initializeProject, isInitialized } from '../lib/config.js';
+import { isGitRepo, getGitInfo, formatGitInfo } from '../lib/git.js';
+import { cmdPlan } from './plan.js';
+export async function cmdInit(path, options) {
+    p.intro('PromptWiki — Project Initialization');
+    const projectPath = path ? resolve(path) : process.cwd();
+    if (!existsSync(projectPath)) {
+        p.outro(`Path does not exist: ${projectPath}`);
+        process.exit(1);
+    }
+    if (isInitialized(projectPath)) {
+        p.outro(`Project already initialized: ${projectPath}`);
+        process.exit(0);
+    }
+    // Detect Git repository
+    const isGit = isGitRepo(projectPath);
+    let repoUrl = options?.repo;
+    let gitInfo = null;
+    if (isGit) {
+        gitInfo = getGitInfo(projectPath, repoUrl);
+        if (gitInfo?.repo && !repoUrl) {
+            repoUrl = gitInfo.repo;
+        }
+    }
+    // Build confirmation message
+    const confirmMessage = [
+        `Track AI conversation history in this folder?`,
+        `  Path: ${projectPath}`,
+    ];
+    if (isGit && gitInfo) {
+        confirmMessage.push(`  Git: ${formatGitInfo(gitInfo)}`);
+        if (repoUrl) {
+            confirmMessage.push(`  Repository: ${repoUrl}`);
+        }
+    }
+    const confirm = await p.confirm({
+        message: confirmMessage.join('\n'),
+        initialValue: true,
+    });
+    if (p.isCancel(confirm) || !confirm) {
+        p.cancel('Cancelled');
+        process.exit(0);
+    }
+    // If Git repo but no repoUrl, suggest connecting
+    if (isGit && !repoUrl) {
+        p.log.info(`Tip: Connect a GitHub repo with --repo for more features!`);
+        p.log.message(`   • Auto-record commit hash for each version`);
+        p.log.message(`   • Create PRs directly with pmpt submit`);
+        p.log.message(`   • Others can reproduce exact code states`);
+        p.log.message('');
+        const repoChoice = await p.select({
+            message: 'Connect GitHub repository?',
+            options: [
+                { value: 'now', label: 'Connect now', hint: 'Enter repository URL' },
+                { value: 'later', label: 'Connect later', hint: 'Re-run with pmpt init --repo <url>' },
+                { value: 'skip', label: 'Skip', hint: 'Use Git tracking only' },
+            ],
+        });
+        if (p.isCancel(repoChoice)) {
+            p.cancel('Cancelled');
+            process.exit(0);
+        }
+        if (repoChoice === 'now') {
+            const inputRepo = await p.text({
+                message: 'Enter GitHub repository URL',
+                placeholder: 'https://github.com/username/repo',
+                validate: (value) => {
+                    if (!value)
+                        return 'Please enter repository URL';
+                    if (!value.includes('github.com'))
+                        return 'Please enter a GitHub URL';
+                    return undefined;
+                },
+            });
+            if (!p.isCancel(inputRepo) && inputRepo) {
+                repoUrl = inputRepo;
+            }
+        }
+    }
+    const s = p.spinner();
+    s.start('Initializing project...');
+    try {
+        const config = initializeProject(projectPath, {
+            repo: repoUrl,
+            trackGit: isGit,
+        });
+        s.stop('Initialized');
+        const notes = [
+            `Path: ${config.projectPath}`,
+            '',
+            'Folder structure:',
+            '  .promptwiki/',
+            '  ├── config.json     Config file',
+            '  ├── pmpt/           Working folder (MD files)',
+            '  └── .history/       Version history',
+        ];
+        if (config.repo) {
+            notes.push('', `Git repository: ${config.repo}`);
+        }
+        if (config.trackGit) {
+            notes.push(`Git tracking: Enabled`);
+        }
+        notes.push('', 'Get started with:');
+        notes.push('  pmpt plan     # Start product planning');
+        notes.push('  pmpt save     # Save current state snapshot');
+        notes.push('  pmpt watch    # Auto-detect file changes');
+        notes.push('  pmpt history  # View version history');
+        p.note(notes.join('\n'), 'Project Info');
+        // Ask to start plan mode
+        const startPlan = await p.confirm({
+            message: 'Start plan mode? (Recommended for first-timers!)',
+            initialValue: true,
+        });
+        if (!p.isCancel(startPlan) && startPlan) {
+            p.log.message('');
+            await cmdPlan(projectPath);
+        }
+        else {
+            p.outro('PromptWiki project initialized');
+        }
+    }
+    catch (error) {
+        s.stop('Initialization failed');
+        p.log.error(error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/new.js

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

package/dist/commands/plan.js

@@ -0,0 +1,158 @@
+import * as p from '@clack/prompts';
+import { resolve } from 'path';
+import { readFileSync } from 'fs';
+import { isInitialized } from '../lib/config.js';
+import { cmdWatch } from './watch.js';
+import { PLAN_QUESTIONS, getPlanProgress, initPlanProgress, savePlanProgress, savePlanDocuments, } from '../lib/plan.js';
+export async function cmdPlan(path, options) {
+    const projectPath = path ? resolve(path) : process.cwd();
+    // Check initialization
+    if (!isInitialized(projectPath)) {
+        p.intro('PromptWiki Plan');
+        p.log.error('Project not initialized.');
+        p.log.info('Run `pmpt init` first to initialize the project.');
+        p.outro('');
+        process.exit(1);
+    }
+    // Reset option
+    if (options?.reset) {
+        const confirm = await p.confirm({
+            message: 'Restart plan from scratch?',
+            initialValue: false,
+        });
+        if (p.isCancel(confirm) || !confirm) {
+            p.cancel('Cancelled');
+            process.exit(0);
+        }
+        initPlanProgress(projectPath);
+    }
+    // Check progress
+    let progress = getPlanProgress(projectPath);
+    // If already completed
+    if (progress?.completed) {
+        p.intro('PromptWiki Plan');
+        p.log.success('Plan already completed.');
+        const action = await p.select({
+            message: 'What would you like to do?',
+            options: [
+                { value: 'view', label: 'View AI prompt', hint: 'Copy and paste to AI' },
+                { value: 'restart', label: 'Restart plan', hint: 'Start fresh' },
+                { value: 'watch', label: 'Start file watching', hint: 'pmpt watch' },
+                { value: 'exit', label: 'Exit' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'exit') {
+            p.outro('See you next time!');
+            process.exit(0);
+        }
+        if (action === 'view') {
+            // Read pmpt.md from pmpt folder
+            const { getPmptDir } = await import('../lib/config.js');
+            const { existsSync } = await import('fs');
+            const { join } = await import('path');
+            const pmptDir = getPmptDir(projectPath);
+            const promptPath = join(pmptDir, 'pmpt.md');
+            try {
+                if (existsSync(promptPath)) {
+                    const content = readFileSync(promptPath, 'utf-8');
+                    p.log.message('');
+                    p.log.info('=== AI Prompt (copy the content below) ===');
+                    p.log.message('');
+                    console.log(content);
+                    p.log.message('');
+                    p.log.info(`File location: ${promptPath}`);
+                }
+                else {
+                    p.log.error('AI prompt file not found.');
+                }
+            }
+            catch {
+                p.log.error('Failed to read AI prompt file.');
+            }
+            p.outro('');
+            process.exit(0);
+        }
+        if (action === 'restart') {
+            initPlanProgress(projectPath);
+            progress = getPlanProgress(projectPath);
+        }
+        if (action === 'watch') {
+            await cmdWatch(projectPath);
+            return;
+        }
+    }
+    // Starting fresh
+    if (!progress) {
+        progress = initPlanProgress(projectPath);
+    }
+    p.intro('PromptWiki Plan — Quick Product Planning');
+    p.log.info('Answer 6 questions to generate an AI-ready prompt.');
+    p.log.message('You can answer in any language you prefer.');
+    p.log.message('');
+    const answers = {};
+    // Ask questions
+    for (let i = 0; i < PLAN_QUESTIONS.length; i++) {
+        const question = PLAN_QUESTIONS[i];
+        const questionNum = `[${i + 1}/${PLAN_QUESTIONS.length}]`;
+        const answer = await p.text({
+            message: `${questionNum} ${question.question}`,
+            placeholder: question.placeholder,
+            validate: question.required
+                ? (value) => (!value ? 'This field is required' : undefined)
+                : undefined,
+        });
+        if (p.isCancel(answer)) {
+            p.cancel('Continue later with `pmpt plan`');
+            process.exit(0);
+        }
+        answers[question.key] = answer;
+    }
+    // Generate documents
+    const s = p.spinner();
+    s.start('Generating documents...');
+    const { planPath, promptPath } = savePlanDocuments(projectPath, answers);
+    // Update progress
+    progress.completed = true;
+    progress.answers = answers;
+    savePlanProgress(projectPath, progress);
+    s.stop('Done!');
+    // Show results
+    p.log.message('');
+    p.log.success('Plan completed!');
+    p.log.message('');
+    p.log.info(`Plan document: ${planPath}`);
+    p.log.info(`AI prompt: ${promptPath}`);
+    p.log.message('');
+    // Preview AI prompt
+    const showPrompt = await p.confirm({
+        message: 'View AI prompt now?',
+        initialValue: true,
+    });
+    if (!p.isCancel(showPrompt) && showPrompt) {
+        const content = readFileSync(promptPath, 'utf-8');
+        p.log.message('');
+        p.log.info('=== AI Prompt (copy the content below) ===');
+        p.log.message('');
+        console.log(content);
+        p.log.message('');
+    }
+    // Next steps
+    p.log.message('');
+    p.log.step('Next steps:');
+    p.log.message('1. Copy the AI prompt above and paste to Claude/ChatGPT');
+    p.log.message('2. Build your product with AI');
+    p.log.message('3. Save snapshots with pmpt save (or pmpt watch for auto-save)');
+    p.log.message('');
+    const startWatch = await p.confirm({
+        message: 'Start file watching? (pmpt watch)',
+        initialValue: false,
+    });
+    if (!p.isCancel(startWatch) && startWatch) {
+        p.log.message('');
+        await cmdWatch(projectPath);
+    }
+    else {
+        p.log.info('Start watching later with `pmpt watch`');
+        p.outro('Good luck!');
+    }
+}

package/dist/commands/save.js

@@ -0,0 +1,48 @@
+import * as p from '@clack/prompts';
+import { resolve } from 'path';
+import { existsSync, statSync } from 'fs';
+import { isInitialized, getPmptDir } from '../lib/config.js';
+import { createFullSnapshot, getTrackedFiles } from '../lib/history.js';
+export async function cmdSave(fileOrPath) {
+    const projectPath = fileOrPath && existsSync(fileOrPath) && statSync(fileOrPath).isDirectory()
+        ? resolve(fileOrPath)
+        : process.cwd();
+    if (!isInitialized(projectPath)) {
+        p.log.error('Project not initialized. Run `pmpt init` first.');
+        process.exit(1);
+    }
+    p.intro('PromptWiki — Save Snapshot');
+    const pmptDir = getPmptDir(projectPath);
+    const files = getTrackedFiles(projectPath);
+    if (files.length === 0) {
+        p.log.warn('No files to save.');
+        p.log.info(`pmpt folder: ${pmptDir}`);
+        p.log.info('Start with `pmpt plan` or add MD files to the pmpt folder.');
+        p.outro('');
+        return;
+    }
+    const s = p.spinner();
+    s.start(`Creating snapshot of ${files.length} file(s)...`);
+    try {
+        const entry = createFullSnapshot(projectPath);
+        s.stop('Snapshot saved');
+        let msg = `v${entry.version} saved`;
+        if (entry.git) {
+            msg += ` · ${entry.git.commit}`;
+            if (entry.git.dirty)
+                msg += ' (uncommitted)';
+        }
+        p.log.success(msg);
+        p.log.message('');
+        p.log.info('Files included:');
+        for (const file of entry.files) {
+            p.log.message(`  - ${file}`);
+        }
+    }
+    catch (error) {
+        s.stop('Save failed');
+        p.log.error(error.message);
+        process.exit(1);
+    }
+    p.outro('View history: pmpt history');
+}

package/dist/commands/squash.js

@@ -0,0 +1,75 @@
+import * as p from '@clack/prompts';
+import { resolve, join } from 'path';
+import { existsSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { isInitialized, getHistoryDir } from '../lib/config.js';
+import { getAllSnapshots } from '../lib/history.js';
+export async function cmdSquash(from, to, path) {
+    const projectPath = path ? resolve(path) : process.cwd();
+    if (!isInitialized(projectPath)) {
+        p.log.error('Project not initialized. Run `pmpt init` first.');
+        process.exit(1);
+    }
+    // Parse version numbers
+    const fromVersion = parseInt(from.replace(/^v/, ''), 10);
+    const toVersion = parseInt(to.replace(/^v/, ''), 10);
+    if (isNaN(fromVersion) || isNaN(toVersion)) {
+        p.log.error('Invalid version format. Use: pmpt squash v2 v3');
+        process.exit(1);
+    }
+    if (fromVersion >= toVersion) {
+        p.log.error('First version must be less than second version.');
+        process.exit(1);
+    }
+    const snapshots = getAllSnapshots(projectPath);
+    if (snapshots.length === 0) {
+        p.log.error('No snapshots found.');
+        process.exit(1);
+    }
+    // Find snapshots to squash
+    const toSquash = snapshots.filter(s => s.version >= fromVersion && s.version <= toVersion);
+    if (toSquash.length < 2) {
+        p.log.error(`Need at least 2 versions to squash. Found ${toSquash.length} in range v${fromVersion}-v${toVersion}.`);
+        process.exit(1);
+    }
+    p.intro('PromptWiki — Squash Versions');
+    p.log.info(`Squashing v${fromVersion} through v${toVersion} (${toSquash.length} versions)`);
+    const confirm = await p.confirm({
+        message: `This will keep v${fromVersion} and delete v${fromVersion + 1} through v${toVersion}. Continue?`,
+        initialValue: false,
+    });
+    if (p.isCancel(confirm) || !confirm) {
+        p.cancel('Cancelled');
+        process.exit(0);
+    }
+    const s = p.spinner();
+    s.start('Squashing versions...');
+    try {
+        const historyDir = getHistoryDir(projectPath);
+        const keepSnapshot = toSquash[0]; // Keep the first one
+        const deleteSnapshots = toSquash.slice(1); // Delete the rest
+        // Delete the snapshots we're squashing
+        for (const snapshot of deleteSnapshots) {
+            const snapshotDir = snapshot.snapshotDir;
+            if (existsSync(snapshotDir)) {
+                rmSync(snapshotDir, { recursive: true });
+            }
+        }
+        // Update metadata of kept snapshot to note squash
+        const metaPath = join(keepSnapshot.snapshotDir, '.meta.json');
+        if (existsSync(metaPath)) {
+            const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+            meta.squashedFrom = toSquash.map(s => s.version);
+            meta.squashedAt = new Date().toISOString();
+            writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+        }
+        s.stop('Squashed');
+        p.log.success(`Squashed v${fromVersion}-v${toVersion} into v${fromVersion}`);
+        p.log.info(`Deleted ${deleteSnapshots.length} version(s)`);
+    }
+    catch (error) {
+        s.stop('Squash failed');
+        p.log.error(error.message);
+        process.exit(1);
+    }
+    p.outro('View history: pmpt history');
+}

package/dist/commands/status.js

@@ -0,0 +1,35 @@
+import * as p from '@clack/prompts';
+import { resolve } from 'path';
+import { isInitialized, loadConfig } from '../lib/config.js';
+import { getTrackedFiles, getAllSnapshots } from '../lib/history.js';
+export function cmdStatus(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 config = loadConfig(projectPath);
+    const tracked = getTrackedFiles(projectPath);
+    const snapshots = getAllSnapshots(projectPath);
+    p.intro('PromptWiki — Project Status');
+    const notes = [
+        `Path: ${projectPath}`,
+        `Created: ${new Date(config.createdAt).toLocaleString()}`,
+    ];
+    if (config.lastPublished) {
+        notes.push(`Last published: ${new Date(config.lastPublished).toLocaleString()}`);
+    }
+    notes.push('');
+    notes.push(`pmpt folder: .promptwiki/pmpt/`);
+    notes.push(`Snapshots: ${snapshots.length}`);
+    notes.push('');
+    notes.push(`Tracked files: ${tracked.length}`);
+    for (const f of tracked) {
+        notes.push(`  - ${f}`);
+    }
+    if (tracked.length === 0) {
+        notes.push('  (none - start with pmpt plan)');
+    }
+    p.note(notes.join('\n'), 'Project Info');
+    p.outro('');
+}