pmpt-cli 1.11.1 → 1.12.1

package/README.md

@@ -2,17 +2,15 @@
 
 # pmpt
 
-**Answer 5 questions. Start building with AI.**
+**Record and share your AI-driven product development journey.**
 
 [![npm version](https://img.shields.io/npm/v/pmpt-cli.svg?style=flat-square&color=cb3837)](https://www.npmjs.com/package/pmpt-cli)
 [![license](https://img.shields.io/github/license/pmptwiki/pmpt-cli?style=flat-square&v=2)](https://github.com/pmptwiki/pmpt-cli/blob/main/LICENSE)
 [![node](https://img.shields.io/badge/node-%3E%3D18-brightgreen?style=flat-square)](https://github.com/pmptwiki/pmpt-cli)
 
-The CLI that turns your idea into an AI-ready prompt in 30 seconds.
+Plan with 5 questions. Build with AI. Save every version. Share and reproduce.
 
-No coding required. No complex setup. Just answer 5 questions.
-
-[Quick Start](#quick-start) · [Commands](#commands) · [How It Works](#how-it-works) · [Explore Projects](#explore-projects)
+[Quick Start](#quick-start) · [Commands](#commands) · [MCP Server](#mcp-server) · [Explore Projects](#explore-projects)
 
 </div>
 
@@ -57,7 +55,7 @@ pmpt save
 pmpt login && pmpt publish
 
 # Bonus: Explore what others are building
-pmpt browse
+pmpt explore
 ```
 
 ---
@@ -113,17 +111,51 @@ The generated prompt is **automatically copied to your clipboard**. Just paste i
 | Command | Description |
 |---------|-------------|
 | `pmpt login` | Authenticate via GitHub (one-time) |
-| `pmpt publish` | Publish your project (requires pmpt.md, quality ≥ 40) |
-| `pmpt publish --force` | Publish even if quality score is below minimum |
+| `pmpt publish` | Publish your project (requires quality score ≥ 40) |
+| `pmpt update` | Quick re-publish: update content without changing metadata |
 | `pmpt edit` | Edit published project metadata (description, tags, category) |
 | `pmpt unpublish` | Remove a published project from pmptwiki |
 | `pmpt clone <slug>` | Clone and reproduce someone's project |
-| `pmpt browse` | Browse and search published projects |
+| `pmpt explore` | Open pmptwiki.com/explore in your browser |
+
+> Quality score below 40? pmpt copies an **AI improvement prompt** to your clipboard — paste it into your AI tool to get help improving your project.
 
 > See the full documentation at [pmptwiki.com/docs](https://pmptwiki.com/docs)
 
 ---
 
+## MCP Server
+
+pmpt includes a built-in [MCP](https://modelcontextprotocol.io) server so AI tools can interact with pmpt directly. This means Claude Code, Cursor, and other MCP-compatible tools can save snapshots, check status, and review history without you typing commands.
+
+### Setup
+
+Add to your `.mcp.json` (or IDE MCP config):
+
+```json
+{
+  "mcpServers": {
+    "pmpt": {
+      "command": "pmpt-mcp"
+    }
+  }
+}
+```
+
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `pmpt_save` | Save a snapshot after completing features, fixes, or milestones |
+| `pmpt_status` | Check tracked files, snapshot count, and quality score |
+| `pmpt_history` | View version history with git commit info |
+| `pmpt_diff` | Compare two versions, or a version against working copy |
+| `pmpt_quality` | Check quality score and publish readiness |
+
+All tools accept an optional `projectPath` parameter (defaults to cwd).
+
+---
+
 ## How It Works
 
 ```
@@ -158,7 +190,8 @@ your-project/
     ├── config.json        # Project configuration
     ├── docs/              # Generated documents
     │   ├── plan.md        # Product plan (features checklist)
-    │   └── pmpt.md        # AI-ready prompt
+    │   ├── pmpt.md        # Progress tracking & decisions
+    │   └── pmpt.ai.md     # AI-ready prompt (project context & instructions)
     └── .history/          # Auto-saved version history
         ├── v1-2024-02-20/
         ├── v2-2024-02-21/
@@ -186,7 +219,8 @@ A single portable file containing your entire development journey:
   },
   "docs": {
     "plan.md": "...",
-    "pmpt.md": "..."
+    "pmpt.md": "...",
+    "pmpt.ai.md": "..."
   },
   "history": [
     { "version": 1, "timestamp": "...", "files": {} },
@@ -210,11 +244,11 @@ Share it. Clone it. Reproduce it.
 
 ## Explore Projects
 
-Don't know what to build? Browse what others have created with AI.
+Don't know what to build? See what others have created with AI.
 
 ```bash
-# Discover projects from the community
-pmpt browse
+# Open the explore page
+pmpt explore
 
 # Found something interesting? Clone it and make it yours
 pmpt clone budget-tracker-app
@@ -222,7 +256,7 @@ pmpt clone budget-tracker-app
 
 **[Explore Projects on pmptwiki.com →](https://pmptwiki.com/explore)**
 
-See how others planned their products, what prompts they used, and how their projects evolved step by step. Clone any project and use it as a starting point for your own.
+Clone any project to see how it was planned, what prompts were used, and how it evolved step by step. The clone output shows the product idea, tech stack, and full version history.
 
 ---
 

package/dist/commands/browse.js

@@ -1,73 +1,11 @@
 import * as p from '@clack/prompts';
-import { fetchProjects } from '../lib/api.js';
-export async function cmdBrowse() {
-    p.intro('pmpt browse');
-    const s = p.spinner();
-    s.start('Loading projects...');
-    let projects;
-    try {
-        const index = await fetchProjects();
-        projects = index.projects;
-    }
-    catch (err) {
-        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} projects`);
-    if (projects.length === 0) {
-        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: 'Select a project:',
-        options: projects.map((proj) => ({
-            value: proj.slug,
-            label: proj.projectName,
-            hint: `v${proj.versionCount} · @${proj.author}${proj.description ? ` — ${proj.description.slice(0, 40)}` : ''}`,
-        })),
-    });
-    if (p.isCancel(selected)) {
-        p.cancel('');
-        process.exit(0);
-    }
-    const project = projects.find((p) => p.slug === selected);
-    // Show details
-    p.note([
-        `Project: ${project.projectName}`,
-        `Author: @${project.author}`,
-        `Versions: ${project.versionCount}`,
-        project.description ? `Description: ${project.description}` : '',
-        project.tags.length ? `Tags: ${project.tags.join(', ')}` : '',
-        `Published: ${project.publishedAt.slice(0, 10)}`,
-        `Size: ${(project.fileSize / 1024).toFixed(1)} KB`,
-    ].filter(Boolean).join('\n'), 'Project Details');
-    // Action
-    const action = await p.select({
-        message: 'What would you like to do?',
-        options: [
-            { 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') {
-        p.outro('');
-        return;
-    }
-    if (action === 'clone') {
-        const { cmdClone } = await import('./clone.js');
-        await cmdClone(project.slug);
-        return;
-    }
-    if (action === 'url') {
-        const url = `https://pmptwiki.com/p/${project.slug}`;
-        p.log.info(`URL: ${url}`);
-        p.log.message(`Download: ${project.downloadUrl}`);
-        p.log.message(`\npmpt clone ${project.slug}  — clone via terminal`);
-        p.outro('');
-    }
+import open from 'open';
+const EXPLORE_URL = 'https://pmptwiki.com/explore';
+export async function cmdExplore() {
+    p.intro('pmpt explore');
+    p.log.info(`Opening ${EXPLORE_URL}`);
+    await open(EXPLORE_URL);
+    p.log.message('  Search, filter, and clone projects from the web.');
+    p.log.message('  Found something you like? →  pmpt clone <slug>');
+    p.outro('');
 }

package/dist/commands/clone.js

@@ -82,12 +82,15 @@ export async function cmdClone(slug) {
     const pmptData = validation.data;
     s.stop('Download complete');
     // Show summary
-    p.note([
+    const infoLines = [
         `Project: ${pmptData.meta.projectName}`,
         `Versions: ${pmptData.history.length}`,
         pmptData.meta.author ? `Author: @${pmptData.meta.author}` : '',
-        pmptData.meta.description ? `Description: ${pmptData.meta.description.slice(0, 80)}` : '',
-    ].filter(Boolean).join('\n'), 'Project Info');
+        pmptData.meta.description ? `\n${pmptData.meta.description}` : '',
+        pmptData.plan?.productIdea ? `\n💡 ${pmptData.plan.productIdea.slice(0, 120)}` : '',
+        pmptData.plan?.techStack ? `🛠  ${pmptData.plan.techStack.slice(0, 80)}` : '',
+    ];
+    p.note(infoLines.filter(Boolean).join('\n'), 'Project Info');
     const projectPath = process.cwd();
     if (isInitialized(projectPath)) {
         const overwrite = await p.confirm({

package/dist/commands/init.js

@@ -2,7 +2,7 @@ import * as p from '@clack/prompts';
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
 import { initializeProject, isInitialized } from '../lib/config.js';
-import { isGitRepo, getGitInfo, formatGitInfo } from '../lib/git.js';
+import { isGitRepo, getGitInfo, formatGitInfo, getCommitCount } from '../lib/git.js';
 import { cmdPlan } from './plan.js';
 import { scanProject, scanResultToAnswers } from '../lib/scanner.js';
 import { savePlanDocuments, initPlanProgress, savePlanProgress } from '../lib/plan.js';
@@ -84,12 +84,17 @@ export async function cmdInit(path, options) {
             }
         }
     }
+    // Detect project origin
+    const gitCommits = isGit ? getCommitCount(projectPath) : 0;
+    const origin = gitCommits >= 10 ? 'adopted' : 'new';
     const s = p.spinner();
     s.start('Initializing project...');
     try {
         const config = initializeProject(projectPath, {
             repo: repoUrl,
             trackGit: isGit,
+            origin,
+            gitCommitsAtInit: isGit ? gitCommits : undefined,
         });
         s.stop('Initialized');
         // Build folder structure display

package/dist/commands/internal-seed.js

@@ -90,7 +90,6 @@ export async function cmdInternalSeed(options) {
     }
     if (spec.publish?.enabled) {
         await cmdPublish(projectPath, {
-            force: spec.publish.force ?? false,
             nonInteractive: true,
             yes: spec.publish.yes ?? true,
             metaFile: spec.publish.metaFile ? resolve(specDir, spec.publish.metaFile) : undefined,

package/dist/commands/publish.js

@@ -8,6 +8,7 @@ import { createPmptFile } from '../lib/pmptFile.js';
 import { loadAuth } from '../lib/auth.js';
 import { publishProject, fetchProjects } from '../lib/api.js';
 import { computeQuality } from '../lib/quality.js';
+import { copyToClipboard } from '../lib/clipboard.js';
 import pc from 'picocolors';
 import glob from 'fast-glob';
 import { join } from 'path';
@@ -22,6 +23,29 @@ const CATEGORY_OPTIONS = [
     { value: 'other', label: 'Other' },
 ];
 const VALID_CATEGORIES = new Set(CATEGORY_OPTIONS.map((o) => o.value));
+function generateImprovementPrompt(quality) {
+    const missing = [];
+    for (const item of quality.details) {
+        if (item.score < item.maxScore && item.tip) {
+            missing.push(`- ${item.label}: ${item.tip}`);
+        }
+    }
+    return [
+        `My pmpt project scored ${quality.score}/100 (Grade ${quality.grade}) and needs at least 40 to publish.`,
+        '',
+        'Areas to improve:',
+        ...missing,
+        '',
+        'Please help me improve the project quality:',
+        '',
+        '1. Read `.pmpt/docs/pmpt.ai.md` and `.pmpt/docs/pmpt.md`',
+        '2. Expand pmpt.ai.md to 500+ characters with clear project context, architecture, and instructions for AI',
+        '3. Make sure pmpt.md has progress tracking, decisions, and a snapshot log',
+        '4. If plan.md is missing, create it with product overview',
+        '5. After improving, run `pmpt save` to create a new snapshot',
+        '6. Then try `pmpt publish` again',
+    ].join('\n');
+}
 function normalizeTags(value) {
     if (Array.isArray(value)) {
         return value
@@ -124,11 +148,22 @@ export async function cmdPublish(path, options) {
         if (tips.length > 0) {
             p.log.info('How to improve:\n' + tips.join('\n'));
         }
-        if (!options?.force) {
-            p.log.error('Use `pmpt publish --force` to publish anyway.');
-            process.exit(1);
+        // Generate and copy AI improvement prompt
+        const improvementPrompt = generateImprovementPrompt(quality);
+        const copied = copyToClipboard(improvementPrompt);
+        if (copied) {
+            p.log.message('');
+            p.log.success('AI improvement prompt copied to clipboard!');
+            p.log.message('  Paste it into Claude Code, Cursor, or any AI tool to improve your project.');
+            p.log.message('  After improving, run `pmpt save` then `pmpt publish` again.');
+        }
+        else {
+            p.log.message('');
+            p.note(improvementPrompt, 'AI Improvement Prompt');
+            p.log.message('  Copy the prompt above and paste into your AI tool.');
         }
-        p.log.warn('Publishing with --force despite low quality score.');
+        p.outro('');
+        process.exit(1);
     }
     const projectName = planProgress?.answers?.projectName || basename(projectPath);
     // Try to load existing published data for prefill
@@ -189,89 +224,120 @@ export async function cmdPublish(path, options) {
         }
     }
     else {
-        const slugInput = await p.text({
-            message: 'Project slug (used in URL):',
-            placeholder: defaultSlug,
-            defaultValue: savedSlug || '',
-            validate: (v) => {
-                if (!/^[a-z0-9][a-z0-9-]{1,48}[a-z0-9]$/.test(v)) {
-                    return '3-50 chars, lowercase letters, numbers, and hyphens only.';
-                }
-            },
-        });
-        if (p.isCancel(slugInput)) {
-            p.cancel('Cancelled');
-            process.exit(0);
-        }
-        slug = slugInput;
-        const descriptionInput = await p.text({
-            message: 'Project description (brief):',
-            placeholder: existing?.description || planProgress?.answers?.productIdea?.slice(0, 100) || '',
-            defaultValue: existing?.description || planProgress?.answers?.productIdea?.slice(0, 200) || '',
-        });
-        if (p.isCancel(descriptionInput)) {
-            p.cancel('Cancelled');
-            process.exit(0);
-        }
-        description = descriptionInput;
-        const tagsInput = await p.text({
-            message: 'Tags (comma-separated):',
-            placeholder: 'react, saas, mvp',
-            defaultValue: existing?.tags?.join(', ') || '',
-        });
-        if (p.isCancel(tagsInput)) {
-            p.cancel('Cancelled');
-            process.exit(0);
-        }
-        tags = normalizeTags(tagsInput);
-        const categoryInput = await p.select({
-            message: 'Project category:',
-            initialValue: existing?.category || 'other',
-            options: CATEGORY_OPTIONS,
-        });
-        if (p.isCancel(categoryInput)) {
-            p.cancel('Cancelled');
-            process.exit(0);
+        // If previously published, offer to reuse settings
+        let reuseExisting = false;
+        if (existing && savedSlug) {
+            const categoryLabel = CATEGORY_OPTIONS.find((o) => o.value === existing.category)?.label ?? existing.category ?? '';
+            p.note([
+                `Slug: ${savedSlug}`,
+                `Description: ${existing.description || '(none)'}`,
+                existing.tags?.length ? `Tags: ${existing.tags.join(', ')}` : '',
+                categoryLabel ? `Category: ${categoryLabel}` : '',
+                existing.productUrl ? `Product: ${existing.productUrl}` : '',
+            ].filter(Boolean).join('\n'), 'Previous Settings');
+            const reuse = await p.confirm({
+                message: 'Publish with same settings?',
+                initialValue: true,
+            });
+            if (p.isCancel(reuse)) {
+                p.cancel('Cancelled');
+                process.exit(0);
+            }
+            reuseExisting = !!reuse;
         }
-        category = categoryInput;
-        // Product link (optional)
-        const linkTypeInput = await p.select({
-            message: 'Product link (optional):',
-            initialValue: existing?.productUrlType || 'none',
-            options: [
-                { value: 'none', label: 'No link' },
-                { value: 'git', label: 'Git Repository' },
-                { value: 'url', label: 'Website / URL' },
-            ],
-        });
-        if (p.isCancel(linkTypeInput)) {
-            p.cancel('Cancelled');
-            process.exit(0);
+        if (reuseExisting && existing && savedSlug) {
+            slug = savedSlug;
+            description = existing.description || '';
+            tags = existing.tags || [];
+            category = existing.category || 'other';
+            productUrl = existing.productUrl || '';
+            productUrlType = existing.productUrlType || '';
         }
-        if (linkTypeInput !== 'none') {
-            productUrlType = linkTypeInput;
-            const productUrlInput = await p.text({
-                message: 'Product URL:',
-                placeholder: linkTypeInput === 'git'
-                    ? `https://github.com/${auth.username}/${slug}`
-                    : 'https://...',
-                defaultValue: existing?.productUrl || '',
+        else {
+            const slugInput = await p.text({
+                message: 'Project slug (used in URL):',
+                placeholder: defaultSlug,
+                defaultValue: savedSlug || '',
                 validate: (v) => {
-                    if (!v.trim())
-                        return 'URL is required when link type is selected.';
-                    try {
-                        new URL(v);
-                    }
-                    catch {
-                        return 'Invalid URL format.';
+                    if (!/^[a-z0-9][a-z0-9-]{1,48}[a-z0-9]$/.test(v)) {
+                        return '3-50 chars, lowercase letters, numbers, and hyphens only.';
                     }
                 },
             });
-            if (p.isCancel(productUrlInput)) {
+            if (p.isCancel(slugInput)) {
                 p.cancel('Cancelled');
                 process.exit(0);
             }
-            productUrl = productUrlInput;
+            slug = slugInput;
+            const descriptionInput = await p.text({
+                message: 'Project description (brief):',
+                placeholder: existing?.description || planProgress?.answers?.productIdea?.slice(0, 100) || '',
+                defaultValue: existing?.description || planProgress?.answers?.productIdea?.slice(0, 200) || '',
+            });
+            if (p.isCancel(descriptionInput)) {
+                p.cancel('Cancelled');
+                process.exit(0);
+            }
+            description = descriptionInput;
+            const tagsInput = await p.text({
+                message: 'Tags (comma-separated):',
+                placeholder: 'react, saas, mvp',
+                defaultValue: existing?.tags?.join(', ') || '',
+            });
+            if (p.isCancel(tagsInput)) {
+                p.cancel('Cancelled');
+                process.exit(0);
+            }
+            tags = normalizeTags(tagsInput);
+            const categoryInput = await p.select({
+                message: 'Project category:',
+                initialValue: existing?.category || 'other',
+                options: CATEGORY_OPTIONS,
+            });
+            if (p.isCancel(categoryInput)) {
+                p.cancel('Cancelled');
+                process.exit(0);
+            }
+            category = categoryInput;
+            // Product link (optional)
+            const linkTypeInput = await p.select({
+                message: 'Product link (optional):',
+                initialValue: existing?.productUrlType || 'none',
+                options: [
+                    { value: 'none', label: 'No link' },
+                    { value: 'git', label: 'Git Repository' },
+                    { value: 'url', label: 'Website / URL' },
+                ],
+            });
+            if (p.isCancel(linkTypeInput)) {
+                p.cancel('Cancelled');
+                process.exit(0);
+            }
+            if (linkTypeInput !== 'none') {
+                productUrlType = linkTypeInput;
+                const productUrlInput = await p.text({
+                    message: 'Product URL:',
+                    placeholder: linkTypeInput === 'git'
+                        ? `https://github.com/${auth.username}/${slug}`
+                        : 'https://...',
+                    defaultValue: existing?.productUrl || '',
+                    validate: (v) => {
+                        if (!v.trim())
+                            return 'URL is required when link type is selected.';
+                        try {
+                            new URL(v);
+                        }
+                        catch {
+                            return 'Invalid URL format.';
+                        }
+                    },
+                });
+                if (p.isCancel(productUrlInput)) {
+                    p.cancel('Cancelled');
+                    process.exit(0);
+                }
+                productUrl = productUrlInput;
+            }
         }
     }
     // Build .pmpt content (resolve from optimized snapshots)
@@ -288,6 +354,8 @@ export async function cmdPublish(path, options) {
         description: description,
         createdAt: config?.createdAt || new Date().toISOString(),
         exportedAt: new Date().toISOString(),
+        origin: config?.origin,
+        gitCommitsAtInit: config?.gitCommitsAtInit,
     };
     const planAnswers = planProgress?.answers
         ? {

package/dist/commands/update.js

@@ -0,0 +1,154 @@
+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, 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, fetchProjects } from '../lib/api.js';
+import { computeQuality } from '../lib/quality.js';
+import glob from 'fast-glob';
+import { join } from 'path';
+function readDocsFolder(docsDir) {
+    const files = {};
+    if (!existsSync(docsDir))
+        return files;
+    const mdFiles = glob.sync('**/*.md', { cwd: docsDir });
+    for (const file of mdFiles) {
+        try {
+            files[file] = readFileSync(join(docsDir, file), 'utf-8');
+        }
+        catch { /* skip */ }
+    }
+    return files;
+}
+export async function cmdUpdate(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 auth = loadAuth();
+    if (!auth?.token || !auth?.username) {
+        p.log.error('Login required. Run `pmpt login` first.');
+        process.exit(1);
+    }
+    p.intro('pmpt update');
+    const config = loadConfig(projectPath);
+    const savedSlug = config?.lastPublishedSlug;
+    if (!savedSlug) {
+        p.log.error('No previously published project found.');
+        p.log.info('Run `pmpt publish` first to publish your project.');
+        p.outro('');
+        process.exit(1);
+    }
+    // Find existing project on platform
+    let existing;
+    try {
+        const index = await fetchProjects();
+        existing = index.projects.find((proj) => proj.slug === savedSlug && proj.author === auth.username);
+    }
+    catch {
+        p.log.error('Failed to fetch project info. Check your internet connection.');
+        p.outro('');
+        process.exit(1);
+    }
+    if (!existing) {
+        p.log.error(`Project "${savedSlug}" not found on platform.`);
+        p.log.info('Run `pmpt publish` to publish it first.');
+        p.outro('');
+        process.exit(1);
+    }
+    const snapshots = getAllSnapshots(projectPath);
+    const planProgress = getPlanProgress(projectPath);
+    if (snapshots.length === 0) {
+        p.log.warn('No snapshots found. Run `pmpt save` first.');
+        p.outro('');
+        return;
+    }
+    // Quality gate
+    const docsDir = getDocsDir(projectPath);
+    const aiMdPath = join(docsDir, 'pmpt.ai.md');
+    const aiMdContent = existsSync(aiMdPath) ? readFileSync(aiMdPath, 'utf-8').trim() : '';
+    const trackedFiles = glob.sync('**/*.md', { cwd: docsDir });
+    const hasGit = snapshots.some((s) => !!s.git);
+    const quality = computeQuality({
+        pmptAiMd: aiMdContent || null,
+        planAnswers: planProgress?.answers ?? null,
+        versionCount: snapshots.length,
+        docFiles: trackedFiles,
+        hasGit,
+    });
+    if (!quality.passesMinimum) {
+        p.log.warn(`Quality score ${quality.score}/100 is below minimum (40).`);
+        p.log.info('Run `pmpt publish` for detailed quality breakdown and improvement tips.');
+        p.outro('');
+        process.exit(1);
+    }
+    // Build .pmpt content
+    const projectName = planProgress?.answers?.projectName || basename(projectPath);
+    const history = snapshots.map((snapshot, i) => ({
+        version: snapshot.version,
+        timestamp: snapshot.timestamp,
+        files: resolveFullSnapshot(snapshots, i),
+        git: snapshot.git,
+    }));
+    const docs = readDocsFolder(docsDir);
+    const meta = {
+        projectName,
+        author: auth.username,
+        description: existing.description,
+        createdAt: config?.createdAt || new Date().toISOString(),
+        exportedAt: new Date().toISOString(),
+        origin: config?.origin,
+        gitCommitsAtInit: config?.gitCommitsAtInit,
+    };
+    const planAnswers = planProgress?.answers
+        ? {
+            projectName: planProgress.answers.projectName,
+            productIdea: planProgress.answers.productIdea,
+            additionalContext: planProgress.answers.additionalContext,
+            coreFeatures: planProgress.answers.coreFeatures,
+            techStack: planProgress.answers.techStack,
+        }
+        : undefined;
+    const pmptContent = createPmptFile(meta, planAnswers, docs, history);
+    // Show summary
+    p.note([
+        `Slug: ${savedSlug}`,
+        `Versions: ${snapshots.length}`,
+        `Size: ${(pmptContent.length / 1024).toFixed(1)} KB`,
+        `Quality: ${quality.score}/100 (${quality.grade})`,
+    ].join('\n'), 'Update Preview');
+    // Upload
+    const s = p.spinner();
+    s.start('Uploading...');
+    try {
+        const result = await publishProject(auth.token, {
+            slug: savedSlug,
+            pmptContent,
+            description: existing.description,
+            tags: existing.tags || [],
+            category: existing.category,
+            ...(existing.productUrl && { productUrl: existing.productUrl, productUrlType: existing.productUrlType }),
+        });
+        s.stop('Updated!');
+        if (config) {
+            config.lastPublished = new Date().toISOString();
+            saveConfig(projectPath, config);
+        }
+        p.note([
+            `URL: ${result.url}`,
+            '',
+            'Content updated. Metadata unchanged.',
+            'To change metadata, use `pmpt edit`.',
+        ].join('\n'), 'Updated!');
+    }
+    catch (err) {
+        s.stop('Update failed');
+        p.log.error(err instanceof Error ? err.message : 'Failed to update.');
+        process.exit(1);
+    }
+    p.outro('');
+}

package/dist/index.js

@@ -34,10 +34,11 @@ import { cmdExport } from './commands/export.js';
 import { cmdImport } from './commands/import.js';
 import { cmdLogin } from './commands/login.js';
 import { cmdPublish } from './commands/publish.js';
+import { cmdUpdate } from './commands/update.js';
 import { cmdEdit } from './commands/edit.js';
 import { cmdUnpublish } from './commands/unpublish.js';
 import { cmdClone } from './commands/clone.js';
-import { cmdBrowse } from './commands/browse.js';
+import { cmdExplore } from './commands/browse.js';
 import { cmdRecover } from './commands/recover.js';
 import { cmdDiff } from './commands/diff.js';
 import { cmdInternalSeed } from './commands/internal-seed.js';
@@ -63,8 +64,9 @@ Examples:
   $ pmpt import <file.pmpt>      Import from .pmpt file
   $ pmpt login                   Authenticate with pmptwiki
   $ pmpt publish                 Publish project to pmptwiki
+  $ pmpt update                  Quick re-publish (content only)
   $ pmpt clone <slug>            Clone a project from pmptwiki
-  $ pmpt browse                  Browse published projects
+  $ pmpt explore                  Explore projects on pmptwiki.com
   $ pmpt recover                 Recover damaged pmpt.md via AI
 
 Documentation: https://pmptwiki.com
@@ -133,7 +135,6 @@ program
 program
     .command('publish [path]')
     .description('Publish project to pmptwiki platform')
-    .option('--force', 'Publish even if quality score is below minimum')
     .option('--non-interactive', 'Run without interactive prompts')
     .option('--meta-file <file>', 'JSON file with slug, description, tags, category')
     .option('--slug <slug>', 'Project slug')
@@ -144,6 +145,10 @@ program
     .option('--product-url-type <type>', 'Product link type: git or url')
     .option('--yes', 'Skip confirmation prompt')
     .action(cmdPublish);
+program
+    .command('update [path]')
+    .description('Quick re-publish: update content without changing metadata')
+    .action(cmdUpdate);
 program
     .command('edit')
     .description('Edit published project metadata (description, tags, category)')
@@ -157,9 +162,9 @@ program
     .description('Clone a project from pmptwiki platform')
     .action(cmdClone);
 program
-    .command('browse')
-    .description('Browse and search published projects')
-    .action(cmdBrowse);
+    .command('explore')
+    .description('Open pmptwiki.com to explore and search projects')
+    .action(cmdExplore);
 program
     .command('recover [path]')
     .description('Generate a recovery prompt to regenerate pmpt.md via AI')

package/dist/lib/config.js

@@ -35,6 +35,8 @@ export function initializeProject(projectPath, options) {
         createdAt: new Date().toISOString(),
         repo: options?.repo,
         trackGit: options?.trackGit ?? true,
+        origin: options?.origin,
+        gitCommitsAtInit: options?.gitCommitsAtInit,
     };
     saveConfig(projectPath, config);
     // Create README.md if it doesn't exist

package/dist/lib/git.js

@@ -84,6 +84,13 @@ export function isCommitMatch(path, expectedCommit) {
         currentFull.startsWith(expectedCommit) ||
         expectedCommit.startsWith(currentShort));
 }
+/**
+ * Count total commits in the repository
+ */
+export function getCommitCount(path) {
+    const count = git(path, 'rev-list --count HEAD');
+    return count ? parseInt(count, 10) : 0;
+}
 /**
  * Convert git info to human-readable string
  */

package/dist/lib/pmptFile.js

@@ -65,6 +65,8 @@ const MetaSchema = z.object({
     description: z.string().optional(),
     createdAt: z.string(),
     exportedAt: z.string(),
+    origin: z.enum(['new', 'adopted']).optional(),
+    gitCommitsAtInit: z.number().optional(),
 });
 // Full .pmpt file schema
 export const PmptFileSchema = z.object({

package/dist/mcp.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * pmpt MCP Server
+ *
+ * Exposes pmpt functionality as MCP tools so AI tools
+ * (Claude Code, Cursor, etc.) can interact with pmpt directly.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { resolve, join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import glob from 'fast-glob';
+import { createRequire } from 'module';
+import { isInitialized, loadConfig, getDocsDir } from './lib/config.js';
+import { createFullSnapshot, getAllSnapshots, getTrackedFiles, resolveFullSnapshot } from './lib/history.js';
+import { computeQuality } from './lib/quality.js';
+import { getPlanProgress } from './lib/plan.js';
+import { isGitRepo } from './lib/git.js';
+import { diffSnapshots } from './lib/diff.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+// ── Server ──────────────────────────────────────────
+const server = new McpServer({
+    name: 'pmpt',
+    version,
+});
+// ── Helpers ─────────────────────────────────────────
+function resolveProjectPath(projectPath) {
+    return projectPath ? resolve(projectPath) : process.cwd();
+}
+function assertInitialized(pp) {
+    if (!isInitialized(pp)) {
+        throw new Error(`Project not initialized at ${pp}. Run \`pmpt init\` first.`);
+    }
+}
+function readWorkingCopy(pp) {
+    const docsDir = getDocsDir(pp);
+    const files = {};
+    if (!existsSync(docsDir))
+        return files;
+    const mdFiles = glob.sync('**/*.md', { cwd: docsDir });
+    for (const file of mdFiles) {
+        try {
+            files[file] = readFileSync(join(docsDir, file), 'utf-8');
+        }
+        catch { /* skip */ }
+    }
+    return files;
+}
+function buildQualityInput(pp) {
+    const docsDir = getDocsDir(pp);
+    const aiMdPath = join(docsDir, 'pmpt.ai.md');
+    const pmptAiMd = existsSync(aiMdPath) ? readFileSync(aiMdPath, 'utf-8') : null;
+    const planProgress = getPlanProgress(pp);
+    const tracked = getTrackedFiles(pp);
+    const snapshots = getAllSnapshots(pp);
+    const hasGit = snapshots.some((s) => !!s.git) || isGitRepo(pp);
+    return {
+        pmptAiMd,
+        planAnswers: planProgress?.answers ?? null,
+        versionCount: snapshots.length,
+        docFiles: tracked,
+        hasGit,
+    };
+}
+function formatDiffs(diffs) {
+    if (diffs.length === 0)
+        return 'No differences found.';
+    const lines = [];
+    const modified = diffs.filter((d) => d.status === 'modified').length;
+    const added = diffs.filter((d) => d.status === 'added').length;
+    const removed = diffs.filter((d) => d.status === 'removed').length;
+    const parts = [];
+    if (modified > 0)
+        parts.push(`${modified} modified`);
+    if (added > 0)
+        parts.push(`${added} added`);
+    if (removed > 0)
+        parts.push(`${removed} removed`);
+    lines.push(`${diffs.length} file(s) changed: ${parts.join(', ')}`);
+    lines.push('');
+    for (const fd of diffs) {
+        const icon = fd.status === 'added' ? 'A' : fd.status === 'removed' ? 'D' : 'M';
+        lines.push(`[${icon}] ${fd.fileName}`);
+        for (const hunk of fd.hunks) {
+            lines.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`);
+            for (const line of hunk.lines) {
+                const prefix = line.type === 'add' ? '+' : line.type === 'remove' ? '-' : ' ';
+                lines.push(`${prefix}${line.content}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// ── Tools ───────────────────────────────────────────
+server.tool('pmpt_save', 'Save a snapshot of .pmpt/docs/ files. Call after completing features, fixes, or milestones.', { projectPath: z.string().optional().describe('Project root path. Defaults to cwd.') }, async ({ projectPath }) => {
+    try {
+        const pp = resolveProjectPath(projectPath);
+        assertInitialized(pp);
+        const tracked = getTrackedFiles(pp);
+        if (tracked.length === 0) {
+            return { content: [{ type: 'text', text: 'No files to save. Add .md files to .pmpt/docs/ first.' }] };
+        }
+        const entry = createFullSnapshot(pp);
+        const changedCount = entry.changedFiles?.length ?? entry.files.length;
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `Snapshot v${entry.version} saved (${changedCount} changed, ${entry.files.length - changedCount} unchanged).`,
+                        '',
+                        `Files: ${entry.files.join(', ')}`,
+                        entry.changedFiles ? `Changed: ${entry.changedFiles.join(', ')}` : '',
+                        entry.git ? `Git: ${entry.git.commit} (${entry.git.branch}${entry.git.dirty ? ', dirty' : ''})` : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+    }
+});
+server.tool('pmpt_status', 'Check pmpt project status: tracked files, snapshot count, and quality score.', { projectPath: z.string().optional().describe('Project root path. Defaults to cwd.') }, async ({ projectPath }) => {
+    try {
+        const pp = resolveProjectPath(projectPath);
+        if (!isInitialized(pp)) {
+            return { content: [{ type: 'text', text: 'Project not initialized. Run `pmpt init` to start.' }] };
+        }
+        const config = loadConfig(pp);
+        const tracked = getTrackedFiles(pp);
+        const snapshots = getAllSnapshots(pp);
+        const quality = computeQuality(buildQualityInput(pp));
+        const lines = [
+            `pmpt status: ${tracked.length} file(s), ${snapshots.length} snapshot(s), quality ${quality.score}/100 (${quality.grade})`,
+            `Files: ${tracked.join(', ') || '(none)'}`,
+            config?.lastPublished ? `Last published: ${config.lastPublished.slice(0, 10)}` : '',
+            '',
+        ];
+        for (const d of quality.details) {
+            const icon = d.score === d.maxScore ? '[PASS]' : '[FAIL]';
+            lines.push(`${icon} ${d.label}: ${d.score}/${d.maxScore}${d.tip ? ` — ${d.tip}` : ''}`);
+        }
+        return { content: [{ type: 'text', text: lines.filter(Boolean).join('\n') }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+    }
+});
+server.tool('pmpt_history', 'View version history of pmpt snapshots.', {
+    projectPath: z.string().optional().describe('Project root path. Defaults to cwd.'),
+    limit: z.number().optional().describe('Max snapshots to return (most recent). Defaults to all.'),
+}, async ({ projectPath, limit }) => {
+    try {
+        const pp = resolveProjectPath(projectPath);
+        assertInitialized(pp);
+        const snapshots = getAllSnapshots(pp);
+        if (snapshots.length === 0) {
+            return { content: [{ type: 'text', text: 'No snapshots yet. Run `pmpt save` to create one.' }] };
+        }
+        let display = snapshots;
+        if (limit && limit > 0 && limit < snapshots.length) {
+            display = snapshots.slice(-limit);
+        }
+        const lines = [`${snapshots.length} snapshot(s)${limit ? `, showing last ${display.length}` : ''}:`, ''];
+        for (const s of display) {
+            const changed = s.changedFiles?.length ?? s.files.length;
+            const git = s.git ? ` [${s.git.commit}]` : '';
+            lines.push(`v${s.version} — ${s.timestamp.slice(0, 16)} — ${changed} changed, ${s.files.length} total${git}`);
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+    }
+});
+server.tool('pmpt_diff', 'Compare two versions, or a version against the current working copy.', {
+    projectPath: z.string().optional().describe('Project root path. Defaults to cwd.'),
+    v1: z.number().describe('First version number (e.g. 1 for v1).'),
+    v2: z.number().optional().describe('Second version. If omitted, compares against working copy.'),
+}, async ({ projectPath, v1, v2 }) => {
+    try {
+        const pp = resolveProjectPath(projectPath);
+        assertInitialized(pp);
+        const snapshots = getAllSnapshots(pp);
+        const fromIndex = snapshots.findIndex((s) => s.version === v1);
+        if (fromIndex === -1) {
+            return { content: [{ type: 'text', text: `Version v${v1} not found.` }], isError: true };
+        }
+        const oldFiles = resolveFullSnapshot(snapshots, fromIndex);
+        let newFiles;
+        let targetLabel;
+        if (v2 !== undefined) {
+            const toIndex = snapshots.findIndex((s) => s.version === v2);
+            if (toIndex === -1) {
+                return { content: [{ type: 'text', text: `Version v${v2} not found.` }], isError: true };
+            }
+            newFiles = resolveFullSnapshot(snapshots, toIndex);
+            targetLabel = `v${v2}`;
+        }
+        else {
+            newFiles = readWorkingCopy(pp);
+            targetLabel = 'working copy';
+        }
+        const diffs = diffSnapshots(oldFiles, newFiles);
+        return {
+            content: [
+                { type: 'text', text: `Diff: v${v1} → ${targetLabel}` },
+                { type: 'text', text: formatDiffs(diffs) },
+            ],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+    }
+});
+server.tool('pmpt_quality', 'Check project quality score and publish readiness.', { projectPath: z.string().optional().describe('Project root path. Defaults to cwd.') }, async ({ projectPath }) => {
+    try {
+        const pp = resolveProjectPath(projectPath);
+        assertInitialized(pp);
+        const quality = computeQuality(buildQualityInput(pp));
+        const lines = [
+            `Quality: ${quality.score}/100 (Grade ${quality.grade})`,
+            `Publish ready: ${quality.passesMinimum ? 'Yes' : 'No (minimum 40 required)'}`,
+            '',
+        ];
+        for (const item of quality.details) {
+            const icon = item.score === item.maxScore ? '[PASS]' : '[FAIL]';
+            lines.push(`${icon} ${item.label}: ${item.score}/${item.maxScore}${item.tip ? ` — ${item.tip}` : ''}`);
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+    }
+});
+// ── Start ───────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('pmpt MCP server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "pmpt-cli",
-  "version": "1.11.1",
+  "version": "1.12.1",
   "description": "Record and share your AI-driven product development journey",
   "type": "module",
   "bin": {
-    "pmpt": "./dist/index.js"
+    "pmpt": "./dist/index.js",
+    "pmpt-mcp": "./dist/mcp.js"
   },
   "files": [
     "dist"
@@ -35,6 +36,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "chokidar": "^3.6.0",
     "commander": "^12.0.0",
     "fast-glob": "^3.3.0",