pmpt-cli 1.13.0 → 1.14.1

package/dist/commands/squash.js

@@ -1,15 +1,99 @@
 import * as p from '@clack/prompts';
-import { resolve, join } from 'path';
-import { existsSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { resolve, join, basename } from 'path';
+import { existsSync, rmSync, renameSync, 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();
+export async function cmdSquash(from, to, opts) {
+    const projectPath = opts?.path ? resolve(opts.path) : process.cwd();
     if (!isInitialized(projectPath)) {
         p.log.error('Project not initialized. Run `pmpt init` first.');
         process.exit(1);
     }
-    // Parse version numbers
+    const snapshots = getAllSnapshots(projectPath);
+    if (snapshots.length === 0) {
+        p.log.error('No snapshots found.');
+        process.exit(1);
+    }
+    if (opts?.auto) {
+        return autoSquash(projectPath, snapshots);
+    }
+    // Manual squash: require from and to
+    if (!from || !to) {
+        p.log.error('Usage: pmpt squash v2 v5  or  pmpt squash --auto');
+        process.exit(1);
+    }
+    return manualSquash(projectPath, snapshots, from, to);
+}
+/**
+ * Renumber remaining snapshots to v1, v2, v3... sequentially.
+ * Renames directories and updates .meta.json version fields.
+ */
+function renumberSnapshots(projectPath) {
+    const historyDir = getHistoryDir(projectPath);
+    const remaining = getAllSnapshots(projectPath); // sorted by version
+    for (let i = 0; i < remaining.length; i++) {
+        const snap = remaining[i];
+        const newVersion = i + 1;
+        if (snap.version === newVersion)
+            continue; // already correct
+        // Rename directory: v5-20260228T164006 → v2-20260228T164006
+        const dirName = basename(snap.snapshotDir);
+        const newDirName = dirName.replace(/^v\d+/, `v${newVersion}`);
+        const newDir = join(historyDir, newDirName);
+        renameSync(snap.snapshotDir, newDir);
+        // Update .meta.json
+        const metaPath = join(newDir, '.meta.json');
+        if (existsSync(metaPath)) {
+            const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+            meta.version = newVersion;
+            writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+        }
+    }
+}
+async function autoSquash(projectPath, snapshots) {
+    // Find empty snapshots (no changed files)
+    const emptySnapshots = snapshots.filter(s => s.changedFiles && s.changedFiles.length === 0);
+    if (emptySnapshots.length === 0) {
+        p.log.info('No empty snapshots found. Nothing to clean up.');
+        return;
+    }
+    p.intro('pmpt squash --auto');
+    p.log.info(`Found ${emptySnapshots.length} empty snapshot(s) (no file changes):`);
+    for (const s of emptySnapshots) {
+        const git = s.git ? ` [${s.git.commit}]` : '';
+        p.log.message(`  v${s.version} — ${s.timestamp.slice(0, 16)}${git}`);
+    }
+    const confirm = await p.confirm({
+        message: `Delete ${emptySnapshots.length} empty snapshot(s) and renumber?`,
+        initialValue: true,
+    });
+    if (p.isCancel(confirm) || !confirm) {
+        p.cancel('Cancelled');
+        process.exit(0);
+    }
+    const sp = p.spinner();
+    sp.start('Removing empty snapshots...');
+    try {
+        let deleted = 0;
+        for (const snapshot of emptySnapshots) {
+            if (existsSync(snapshot.snapshotDir)) {
+                rmSync(snapshot.snapshotDir, { recursive: true });
+                deleted++;
+            }
+        }
+        renumberSnapshots(projectPath);
+        sp.stop('Cleaned up');
+        const remaining = snapshots.length - deleted;
+        p.log.success(`Removed ${deleted} empty snapshot(s), renumbered to v1-v${remaining}`);
+    }
+    catch (error) {
+        sp.stop('Failed');
+        p.log.error(error.message);
+        process.exit(1);
+    }
+    p.outro('View history: pmpt history');
+}
+async function manualSquash(projectPath, snapshots, from, to) {
     const fromVersion = parseInt(from.replace(/^v/, ''), 10);
     const toVersion = parseInt(to.replace(/^v/, ''), 10);
     if (isNaN(fromVersion) || isNaN(toVersion)) {
@@ -20,11 +104,6 @@ export async function cmdSquash(from, to, path) {
         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);
-    }
     const versionList = snapshots.map(s => `v${s.version}`).join(', ');
     // Find snapshots to squash
     const toSquash = snapshots.filter(s => s.version >= fromVersion && s.version <= toVersion);
@@ -46,7 +125,6 @@ export async function cmdSquash(from, to, path) {
     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
@@ -64,8 +142,10 @@ export async function cmdSquash(from, to, path) {
             meta.squashedAt = new Date().toISOString();
             writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
         }
+        renumberSnapshots(projectPath);
         s.stop('Squashed');
-        p.log.success(`Squashed v${fromVersion}-v${toVersion} into v${fromVersion}`);
+        const remaining = getAllSnapshots(projectPath);
+        p.log.success(`Squashed v${fromVersion}-v${toVersion}, renumbered to v1-v${remaining.length}`);
         p.log.info(`Deleted ${deleteSnapshots.length} version(s)`);
     }
     catch (error) {

package/dist/index.js

@@ -68,6 +68,7 @@ Examples:
   $ pmpt diff v1 v2              Compare two versions
   $ pmpt diff v3                 Compare v3 to working copy
   $ pmpt squash v2 v5            Merge versions v2-v5 into v2
+  $ pmpt squash --auto           Auto-remove empty snapshots
   $ pmpt export                  Export as .pmpt file (single JSON)
   $ pmpt import <file.pmpt>      Import from .pmpt file
   $ pmpt login                   Authenticate with pmptwiki
@@ -119,9 +120,11 @@ program
     .option('-f, --file <name>', 'Compare specific file only')
     .action(cmdDiff);
 program
-    .command('squash <from> <to> [path]')
-    .description('Squash multiple versions into one (e.g., pmpt squash v2 v5)')
-    .action(cmdSquash);
+    .command('squash [from] [to]')
+    .description('Squash versions: pmpt squash v2 v5  or  pmpt squash --auto')
+    .option('--auto', 'Auto-remove empty snapshots (no file changes)')
+    .option('-p, --path <path>', 'Project path')
+    .action((from, to, opts) => cmdSquash(from, to, opts));
 program
     .command('export [path]')
     .description('Export project history as a shareable .pmpt file')

package/dist/mcp.js

@@ -12,7 +12,7 @@ import { resolve, join } from 'path';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import glob from 'fast-glob';
 import { createRequire } from 'module';
-import { isInitialized, loadConfig, getDocsDir } from './lib/config.js';
+import { isInitialized, loadConfig, getDocsDir, getHistoryDir } from './lib/config.js';
 import { createFullSnapshot, getAllSnapshots, getTrackedFiles, resolveFullSnapshot } from './lib/history.js';
 import { computeQuality } from './lib/quality.js';
 import { getPlanProgress, savePlanProgress, savePlanDocuments, PLAN_QUESTIONS } from './lib/plan.js';
@@ -98,7 +98,10 @@ function formatDiffs(diffs) {
     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 }) => {
+server.tool('pmpt_save', 'Save a snapshot of .pmpt/docs/ files. Call after completing features, fixes, or milestones. IMPORTANT: Always provide a summary describing what was accomplished — this gets recorded in the project development log.', {
+    projectPath: z.string().optional().describe('Project root path. Defaults to cwd.'),
+    summary: z.string().optional().describe('What was accomplished since the last save. This is recorded in pmpt.md as a development log entry. Examples: "Implemented user auth with JWT", "Fixed responsive layout on mobile", "Added search filtering by category".'),
+}, async ({ projectPath, summary }) => {
     try {
         const pp = resolveProjectPath(projectPath);
         assertInitialized(pp);
@@ -106,13 +109,37 @@ server.tool('pmpt_save', 'Save a snapshot of .pmpt/docs/ files. Call after compl
         if (tracked.length === 0) {
             return { content: [{ type: 'text', text: 'No files to save. Add .md files to .pmpt/docs/ first.' }] };
         }
-        const entry = createFullSnapshot(pp);
+        // Auto-update pmpt.md with summary before snapshot
+        if (summary) {
+            const docsDir = getDocsDir(pp);
+            const pmptMdPath = join(docsDir, 'pmpt.md');
+            if (existsSync(pmptMdPath)) {
+                let content = readFileSync(pmptMdPath, 'utf-8');
+                const snapshots = getAllSnapshots(pp);
+                const nextVersion = snapshots.length + 1;
+                const date = new Date().toISOString().slice(0, 10);
+                const entry = `\n### v${nextVersion} — ${date}\n- ${summary}\n`;
+                const logIndex = content.indexOf('## Snapshot Log');
+                if (logIndex !== -1) {
+                    const afterHeader = content.indexOf('\n', logIndex);
+                    const nextSection = content.indexOf('\n## ', afterHeader + 1);
+                    const insertPos = nextSection !== -1 ? nextSection : content.length;
+                    content = content.slice(0, insertPos) + entry + content.slice(insertPos);
+                }
+                else {
+                    content += `\n## Snapshot Log${entry}`;
+                }
+                writeFileSync(pmptMdPath, content, 'utf-8');
+            }
+        }
+        const entry = createFullSnapshot(pp, summary ? { note: summary } : undefined);
         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).`,
+                        summary ? `Summary: ${summary}` : '',
                         '',
                         `Files: ${entry.files.join(', ')}`,
                         entry.changedFiles ? `Changed: ${entry.changedFiles.join(', ')}` : '',
@@ -218,6 +245,64 @@ server.tool('pmpt_diff', 'Compare two versions, or a version against the current
         return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
     }
 });
+server.tool('pmpt_squash', 'Remove empty snapshots (no file changes) and renumber remaining versions sequentially. Use this to clean up history when there are snapshots with no actual content changes.', {
+    projectPath: z.string().optional().describe('Project root path. Defaults to cwd.'),
+}, async ({ projectPath }) => {
+    try {
+        const pp = resolveProjectPath(projectPath);
+        assertInitialized(pp);
+        const snapshots = getAllSnapshots(pp);
+        if (snapshots.length === 0) {
+            return { content: [{ type: 'text', text: 'No snapshots found.' }] };
+        }
+        const emptySnapshots = snapshots.filter(s => s.changedFiles && s.changedFiles.length === 0);
+        if (emptySnapshots.length === 0) {
+            return { content: [{ type: 'text', text: 'No empty snapshots found. History is clean.' }] };
+        }
+        // Delete empty snapshots
+        const { rmSync, renameSync } = await import('fs');
+        const { basename } = await import('path');
+        for (const snap of emptySnapshots) {
+            if (existsSync(snap.snapshotDir)) {
+                rmSync(snap.snapshotDir, { recursive: true });
+            }
+        }
+        // Renumber remaining snapshots
+        const historyDir = getHistoryDir(pp);
+        const remaining = getAllSnapshots(pp);
+        for (let i = 0; i < remaining.length; i++) {
+            const snap = remaining[i];
+            const newVersion = i + 1;
+            if (snap.version === newVersion)
+                continue;
+            const dirName = basename(snap.snapshotDir);
+            const newDirName = dirName.replace(/^v\d+/, `v${newVersion}`);
+            const newDir = join(historyDir, newDirName);
+            renameSync(snap.snapshotDir, newDir);
+            const metaPath = join(newDir, '.meta.json');
+            if (existsSync(metaPath)) {
+                const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+                meta.version = newVersion;
+                writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+            }
+        }
+        const finalCount = getAllSnapshots(pp).length;
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `Squashed: removed ${emptySnapshots.length} empty snapshot(s).`,
+                        `Remaining: ${finalCount} snapshot(s), renumbered v1-v${finalCount}.`,
+                        '',
+                        `Removed versions: ${emptySnapshots.map(s => `v${s.version}`).join(', ')}`,
+                    ].join('\n'),
+                }],
+        };
+    }
+    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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmpt-cli",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "description": "Record and share your AI-driven product development journey",
   "type": "module",
   "bin": {