pmpt-cli 1.2.1 → 1.3.0

package/dist/commands/export.js

@@ -1,125 +1,48 @@
 import * as p from '@clack/prompts';
 import { resolve, join, basename } from 'path';
-import { existsSync, writeFileSync, statSync } from 'fs';
-import { execSync } from 'child_process';
-import { isInitialized, getConfigDir, getHistoryDir, loadConfig } from '../lib/config.js';
+import { existsSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { isInitialized, getDocsDir, loadConfig } from '../lib/config.js';
 import { getAllSnapshots } from '../lib/history.js';
 import { getPlanProgress } from '../lib/plan.js';
+import { createPmptFile, SCHEMA_VERSION } from '../lib/pmptFile.js';
+import glob from 'fast-glob';
 /**
- * Create a zip file without external dependencies
- * Uses native zip command on macOS/Linux, PowerShell on Windows
+ * Read all files from a snapshot directory
  */
-function createZip(sourceDir, outputPath) {
-    try {
-        const platform = process.platform;
-        if (platform === 'win32') {
-            // PowerShell Compress-Archive
-            execSync(`powershell -command "Compress-Archive -Path '${sourceDir}/*' -DestinationPath '${outputPath}'"`, {
-                stdio: 'pipe',
-            });
+function readSnapshotFiles(snapshotDir) {
+    const files = {};
+    if (!existsSync(snapshotDir))
+        return files;
+    const mdFiles = glob.sync('**/*.md', { cwd: snapshotDir });
+    for (const file of mdFiles) {
+        const filePath = join(snapshotDir, file);
+        try {
+            files[file] = readFileSync(filePath, 'utf-8');
         }
-        else {
-            // Unix zip command
-            execSync(`cd "${sourceDir}" && zip -r "${outputPath}" .`, {
-                stdio: 'pipe',
-            });
+        catch {
+            // Skip files that can't be read
         }
-        return true;
-    }
-    catch {
-        return false;
     }
+    return files;
 }
 /**
- * Generate metadata markdown file
+ * Read current docs folder
  */
-function generateMetadataMarkdown(projectPath, snapshots, planProgress, config) {
-    const answers = planProgress?.answers || {};
-    const projectName = answers.projectName || basename(projectPath);
-    // Timeline info
-    const firstSnapshot = snapshots[0];
-    const lastSnapshot = snapshots[snapshots.length - 1];
-    const startDate = firstSnapshot?.timestamp || 'N/A';
-    const lastDate = lastSnapshot?.timestamp || 'N/A';
-    // Git info from last snapshot
-    const gitInfo = lastSnapshot?.git;
-    // All unique files across snapshots
-    const allFiles = new Set();
-    for (const snapshot of snapshots) {
-        for (const file of snapshot.files) {
-            allFiles.add(file);
+function readDocsFolder(docsDir) {
+    const files = {};
+    if (!existsSync(docsDir))
+        return files;
+    const mdFiles = glob.sync('**/*.md', { cwd: docsDir });
+    for (const file of mdFiles) {
+        const filePath = join(docsDir, file);
+        try {
+            files[file] = readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            // Skip files that can't be read
         }
     }
-    // Parse features
-    const features = answers.coreFeatures
-        ? answers.coreFeatures
-            .split(/[,;\n]/)
-            .map((f) => f.trim())
-            .filter((f) => f)
-            .map((f) => `- ${f}`)
-            .join('\n')
-        : 'Not specified';
-    let md = `# ${projectName}
-
-> Exported from pmpt-cli
-
-## Project Overview
-
-**Product Idea:**
-${answers.productIdea || 'Not specified'}
-
-${answers.additionalContext ? `**Additional Context:**\n${answers.additionalContext}\n` : ''}
-**Key Features:**
-${features}
-
-**Tech Stack:**
-${answers.techStack || 'Not specified'}
-
----
-
-## Export Information
-
-| Item | Value |
-|------|-------|
-| Total Iterations | ${snapshots.length} |
-| First Version | ${startDate} |
-| Last Version | ${lastDate} |
-| Files Tracked | ${allFiles.size} |
-`;
-    if (gitInfo) {
-        md += `| Git Branch | ${gitInfo.branch} |
-| Last Commit | ${gitInfo.commit} |
-`;
-    }
-    md += `
----
-
-## Version Timeline
-
-| Version | Date | Files | Git |
-|---------|------|-------|-----|
-`;
-    for (const snapshot of snapshots) {
-        const gitCol = snapshot.git
-            ? `${snapshot.git.commit}${snapshot.git.dirty ? ' (dirty)' : ''}`
-            : '-';
-        md += `| v${snapshot.version} | ${snapshot.timestamp} | ${snapshot.files.length} | ${gitCol} |\n`;
-    }
-    md += `
----
-
-## File List
-
-`;
-    for (const file of Array.from(allFiles).sort()) {
-        md += `- ${file}\n`;
-    }
-    md += `
----
-
-*Generated by [pmpt-cli](https://pmptwiki.com)*
-`;
-    return md;
+    return files;
 }
 export async function cmdExport(path, options) {
     const projectPath = path ? resolve(path) : process.cwd();
@@ -138,69 +61,75 @@ export async function cmdExport(path, options) {
         return;
     }
     const projectName = planProgress?.answers?.projectName || basename(projectPath);
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 10);
-    const exportName = `pmpt-export-${projectName}-${timestamp}`;
-    // Output path
+    const timestamp = new Date().toISOString().slice(0, 10);
+    const exportName = `${projectName}-${timestamp}`;
+    // Output path - .pmpt extension
     const outputPath = options?.output
         ? resolve(options.output)
-        : resolve(projectPath, `${exportName}.zip`);
+        : resolve(projectPath, `${exportName}.pmpt`);
     const s = p.spinner();
-    s.start('Preparing export...');
-    // Create temp directory for export
-    const tempDir = join(projectPath, '.pmpt', '.export-temp');
-    execSync(`rm -rf "${tempDir}" && mkdir -p "${tempDir}"`, { stdio: 'pipe' });
-    // Copy history folder
-    const historyDir = getHistoryDir(projectPath);
-    execSync(`cp -r "${historyDir}" "${tempDir}/history"`, { stdio: 'pipe' });
-    // Generate and save metadata
-    const metadataContent = generateMetadataMarkdown(projectPath, snapshots, planProgress, config);
-    writeFileSync(join(tempDir, 'README.md'), metadataContent, 'utf-8');
-    // Copy current docs if exists
-    const docsDir = join(getConfigDir(projectPath), 'docs');
-    if (existsSync(docsDir)) {
-        execSync(`cp -r "${docsDir}" "${tempDir}/docs"`, { stdio: 'pipe' });
-    }
-    // Copy config (without sensitive data)
-    if (config) {
-        const exportConfig = {
-            projectPath: basename(projectPath),
-            docsPath: config.docsPath,
-            createdAt: config.createdAt,
-            trackGit: config.trackGit,
-        };
-        writeFileSync(join(tempDir, 'config.json'), JSON.stringify(exportConfig, null, 2), 'utf-8');
+    s.start('Creating .pmpt file...');
+    // Build history array with file contents
+    const history = [];
+    for (const snapshot of snapshots) {
+        const files = readSnapshotFiles(snapshot.snapshotDir);
+        history.push({
+            version: snapshot.version,
+            timestamp: snapshot.timestamp,
+            files,
+            git: snapshot.git,
+        });
     }
-    // Copy plan progress if exists
-    if (planProgress) {
-        writeFileSync(join(tempDir, 'plan.json'), JSON.stringify(planProgress, null, 2), 'utf-8');
+    // Read current docs
+    const docsDir = getDocsDir(projectPath);
+    const docs = readDocsFolder(docsDir);
+    // Build metadata
+    const meta = {
+        projectName,
+        description: planProgress?.answers?.productIdea,
+        createdAt: config?.createdAt || new Date().toISOString(),
+        exportedAt: new Date().toISOString(),
+    };
+    // Convert plan answers to typed format
+    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;
+    // Create .pmpt file content
+    const pmptContent = createPmptFile(meta, planAnswers, docs, history);
+    // Write file
+    try {
+        writeFileSync(outputPath, pmptContent, 'utf-8');
     }
-    s.message('Creating archive...');
-    // Create zip
-    const zipSuccess = createZip(tempDir, outputPath);
-    // Cleanup temp directory
-    execSync(`rm -rf "${tempDir}"`, { stdio: 'pipe' });
-    if (!zipSuccess) {
+    catch (err) {
         s.stop('Export failed');
-        p.log.error('Failed to create zip archive.');
-        p.log.info('Make sure `zip` command is available on your system.');
+        p.log.error('Failed to write .pmpt file.');
         process.exit(1);
     }
     s.stop('Export complete!');
-    // Summary
+    // File size
     const fileSizeBytes = statSync(outputPath).size;
     const fileSize = fileSizeBytes < 1024
         ? `${fileSizeBytes} B`
         : fileSizeBytes < 1024 * 1024
             ? `${(fileSizeBytes / 1024).toFixed(1)} KB`
             : `${(fileSizeBytes / 1024 / 1024).toFixed(1)} MB`;
+    // Summary
     const summary = [
         `Project: ${projectName}`,
         `Versions: ${snapshots.length}`,
+        `Schema: v${SCHEMA_VERSION}`,
         `Size: ${fileSize}`,
         '',
         `Output: ${outputPath}`,
     ];
     p.note(summary.join('\n'), 'Export Summary');
-    p.log.info('Share this file to let others reproduce your AI development journey!');
+    p.log.info('Share this .pmpt file to let others reproduce your AI development journey!');
+    p.log.message('  pmpt import <file.pmpt>  — Import on another machine');
     p.outro('');
 }

package/dist/commands/import.js

@@ -1,50 +1,98 @@
 import * as p from '@clack/prompts';
-import { resolve, join } from 'path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, rmSync } from 'fs';
-import { execSync } from 'child_process';
+import { resolve, join, dirname } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'fs';
 import { isInitialized, getConfigDir, getHistoryDir, getDocsDir, initializeProject } from '../lib/config.js';
+import { validatePmptFile } from '../lib/pmptFile.js';
 /**
- * Extract zip file
- * Uses native unzip command on macOS/Linux, PowerShell on Windows
+ * Restore history from .pmpt file
  */
-function extractZip(zipPath, destDir) {
-    try {
-        const platform = process.platform;
-        mkdirSync(destDir, { recursive: true });
-        if (platform === 'win32') {
-            // PowerShell Expand-Archive
-            execSync(`powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`, {
-                stdio: 'pipe',
-            });
-        }
-        else {
-            // Unix unzip command
-            execSync(`unzip -o "${zipPath}" -d "${destDir}"`, {
-                stdio: 'pipe',
-            });
+function restoreHistory(historyDir, history) {
+    mkdirSync(historyDir, { recursive: true });
+    for (const version of history) {
+        const timestamp = version.timestamp.replace(/[:.]/g, '-').slice(0, 19);
+        const snapshotName = `v${version.version}-${timestamp}`;
+        const snapshotDir = join(historyDir, snapshotName);
+        mkdirSync(snapshotDir, { recursive: true });
+        // Write files
+        for (const [filename, content] of Object.entries(version.files)) {
+            const filePath = join(snapshotDir, filename);
+            const fileDir = dirname(filePath);
+            if (fileDir !== snapshotDir) {
+                mkdirSync(fileDir, { recursive: true });
+            }
+            writeFileSync(filePath, content, 'utf-8');
         }
-        return true;
+        // Write metadata
+        const metaPath = join(snapshotDir, '.meta.json');
+        writeFileSync(metaPath, JSON.stringify({
+            version: version.version,
+            timestamp: version.timestamp,
+            files: Object.keys(version.files),
+            git: version.git,
+        }, null, 2), 'utf-8');
     }
-    catch {
-        return false;
+}
+/**
+ * Restore docs from .pmpt file
+ */
+function restoreDocs(docsDir, docs) {
+    mkdirSync(docsDir, { recursive: true });
+    for (const [filename, content] of Object.entries(docs)) {
+        const filePath = join(docsDir, filename);
+        const fileDir = dirname(filePath);
+        if (fileDir !== docsDir) {
+            mkdirSync(fileDir, { recursive: true });
+        }
+        writeFileSync(filePath, content, 'utf-8');
     }
 }
-export async function cmdImport(zipFile, options) {
-    if (!zipFile) {
-        p.log.error('Please provide a zip file path.');
-        p.log.info('Usage: pmpt import <file.zip>');
+export async function cmdImport(pmptFile, options) {
+    if (!pmptFile) {
+        p.log.error('Please provide a .pmpt file path.');
+        p.log.info('Usage: pmpt import <file.pmpt>');
         process.exit(1);
     }
-    const zipPath = resolve(zipFile);
-    if (!existsSync(zipPath)) {
-        p.log.error(`File not found: ${zipPath}`);
+    const filePath = resolve(pmptFile);
+    if (!existsSync(filePath)) {
+        p.log.error(`File not found: ${filePath}`);
         process.exit(1);
     }
-    if (!zipPath.endsWith('.zip')) {
-        p.log.error('Please provide a .zip file.');
+    if (!filePath.endsWith('.pmpt')) {
+        p.log.error('Please provide a .pmpt file.');
+        p.log.info('Use `pmpt export` to create a .pmpt file.');
         process.exit(1);
     }
     p.intro('pmpt import');
+    const s = p.spinner();
+    s.start('Reading .pmpt file...');
+    // Read file
+    let fileContent;
+    try {
+        fileContent = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        s.stop('Read failed');
+        p.log.error('Failed to read file.');
+        process.exit(1);
+    }
+    // Validate
+    s.message('Validating...');
+    const validation = validatePmptFile(fileContent);
+    if (!validation.success || !validation.data) {
+        s.stop('Validation failed');
+        p.log.error(validation.error || 'Invalid .pmpt file.');
+        process.exit(1);
+    }
+    const pmptData = validation.data;
+    s.stop('Validation passed');
+    // Show summary and confirm
+    const summaryLines = [
+        `Project: ${pmptData.meta.projectName}`,
+        `Versions: ${pmptData.history.length}`,
+        `Schema: v${pmptData.schemaVersion}`,
+        pmptData.meta.description ? `Description: ${pmptData.meta.description.slice(0, 50)}...` : '',
+    ].filter(Boolean);
+    p.note(summaryLines.join('\n'), 'Import Preview');
     const projectPath = process.cwd();
     // Check if already initialized
     if (isInitialized(projectPath) && !options?.force) {
@@ -62,84 +110,40 @@ export async function cmdImport(zipFile, options) {
             return;
         }
     }
-    const s = p.spinner();
-    s.start('Extracting archive...');
-    // Create temp directory for extraction
-    const tempDir = join(projectPath, '.pmpt-import-temp');
-    rmSync(tempDir, { recursive: true, force: true });
-    const extracted = extractZip(zipPath, tempDir);
-    if (!extracted) {
-        rmSync(tempDir, { recursive: true, force: true });
-        s.stop('Extraction failed');
-        p.log.error('Failed to extract zip file.');
-        p.log.info('Make sure `unzip` command is available on your system.');
-        process.exit(1);
-    }
-    s.message('Importing project...');
-    // Read imported data
-    let importedPlan = null;
-    let importedConfig = null;
-    let projectName = 'imported-project';
-    // Read plan.json if exists
-    const planPath = join(tempDir, 'plan.json');
-    if (existsSync(planPath)) {
-        try {
-            importedPlan = JSON.parse(readFileSync(planPath, 'utf-8'));
-            if (importedPlan.answers?.projectName) {
-                projectName = importedPlan.answers.projectName;
-            }
-        }
-        catch {
-            // Ignore parse errors
-        }
-    }
-    // Read config.json if exists
-    const configPath = join(tempDir, 'config.json');
-    if (existsSync(configPath)) {
-        try {
-            importedConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            // Ignore parse errors
-        }
-    }
+    const importSpinner = p.spinner();
+    importSpinner.start('Importing project...');
     // Initialize project if not exists
     if (!isInitialized(projectPath)) {
-        initializeProject(projectPath, {
-            trackGit: importedConfig?.trackGit ?? true,
-        });
+        initializeProject(projectPath, { trackGit: true });
     }
     const pmptDir = getConfigDir(projectPath);
     const historyDir = getHistoryDir(projectPath);
     const docsDir = getDocsDir(projectPath);
-    // Import history
-    const importedHistoryDir = join(tempDir, 'history');
-    if (existsSync(importedHistoryDir)) {
-        // Copy all version folders
-        cpSync(importedHistoryDir, historyDir, { recursive: true, force: true });
-    }
-    // Import docs
-    const importedDocsDir = join(tempDir, 'docs');
-    if (existsSync(importedDocsDir)) {
-        cpSync(importedDocsDir, docsDir, { recursive: true, force: true });
+    // Restore history
+    restoreHistory(historyDir, pmptData.history);
+    // Restore docs
+    if (pmptData.docs) {
+        restoreDocs(docsDir, pmptData.docs);
     }
-    // Import plan progress
-    if (importedPlan) {
+    // Restore plan progress
+    if (pmptData.plan) {
         const planProgressPath = join(pmptDir, 'plan-progress.json');
-        writeFileSync(planProgressPath, JSON.stringify(importedPlan, null, 2), 'utf-8');
+        writeFileSync(planProgressPath, JSON.stringify({
+            completed: true,
+            startedAt: pmptData.meta.createdAt,
+            updatedAt: pmptData.meta.exportedAt,
+            answers: pmptData.plan,
+        }, null, 2), 'utf-8');
     }
     // Count imported versions
     let versionCount = 0;
     if (existsSync(historyDir)) {
-        const { readdirSync } = await import('fs');
         versionCount = readdirSync(historyDir).filter(d => d.startsWith('v')).length;
     }
-    // Cleanup temp directory
-    rmSync(tempDir, { recursive: true, force: true });
-    s.stop('Import complete!');
+    importSpinner.stop('Import complete!');
     // Summary
     const summary = [
-        `Project: ${projectName}`,
+        `Project: ${pmptData.meta.projectName}`,
         `Versions imported: ${versionCount}`,
         `Location: ${pmptDir}`,
     ];

package/dist/index.js

@@ -16,7 +16,7 @@ const program = new Command();
 program
     .name('pmpt')
     .description('pmpt — Record and share your AI-driven product development journey')
-    .version('1.0.0')
+    .version('1.3.0')
     .addHelpText('after', `
 Examples:
   $ pmpt init                    Initialize project
@@ -26,8 +26,8 @@ Examples:
   $ pmpt history                 View version history
   $ pmpt history --compact       Hide minor changes
   $ pmpt squash v2 v5            Merge versions v2-v5 into v2
-  $ pmpt export                  Export history as shareable zip
-  $ pmpt import <file.zip>       Import project from zip
+  $ pmpt export                  Export as .pmpt file (single JSON)
+  $ pmpt import <file.pmpt>      Import from .pmpt file
 
 Folder structure:
   .pmpt/

package/dist/lib/pmptFile.js

@@ -0,0 +1,106 @@
+/**
+ * .pmpt File Format Schema (v1.0)
+ *
+ * Single JSON file format for sharing pmpt projects.
+ */
+import { z } from 'zod';
+// Schema version
+export const SCHEMA_VERSION = '1.0';
+export const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+// Git info schema
+const GitInfoSchema = z.object({
+    commit: z.string(),
+    commitFull: z.string().optional(),
+    branch: z.string().optional(),
+    dirty: z.boolean().optional(),
+    tag: z.string().optional(),
+}).optional();
+// Single version/snapshot schema
+const VersionSchema = z.object({
+    version: z.number().min(1),
+    timestamp: z.string(),
+    files: z.record(z.string(), z.string()), // filename -> content
+    git: GitInfoSchema,
+});
+// Plan answers schema
+const PlanSchema = z.object({
+    projectName: z.string(),
+    productIdea: z.string().optional(),
+    additionalContext: z.string().optional(),
+    coreFeatures: z.string().optional(),
+    techStack: z.string().optional(),
+}).optional();
+// Project metadata schema
+const MetaSchema = z.object({
+    projectName: z.string(),
+    author: z.string().optional(),
+    description: z.string().optional(),
+    createdAt: z.string(),
+    exportedAt: z.string(),
+});
+// Full .pmpt file schema
+export const PmptFileSchema = z.object({
+    schemaVersion: z.string(),
+    cliMinVersion: z.string().optional(),
+    meta: MetaSchema,
+    plan: PlanSchema,
+    docs: z.record(z.string(), z.string()).optional(), // current docs
+    history: z.array(VersionSchema),
+});
+/**
+ * Validate .pmpt file content
+ */
+export function validatePmptFile(content) {
+    // Check size
+    if (content.length > MAX_FILE_SIZE) {
+        return {
+            success: false,
+            error: `File too large. Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB`,
+        };
+    }
+    // Parse JSON
+    let json;
+    try {
+        json = JSON.parse(content);
+    }
+    catch {
+        return {
+            success: false,
+            error: 'Invalid JSON format',
+        };
+    }
+    // Validate schema
+    const result = PmptFileSchema.safeParse(json);
+    if (!result.success) {
+        const firstError = result.error.errors[0];
+        return {
+            success: false,
+            error: `Validation error: ${firstError.path.join('.')} - ${firstError.message}`,
+        };
+    }
+    // Check schema version
+    if (result.data.schemaVersion !== SCHEMA_VERSION) {
+        return {
+            success: false,
+            error: `Unsupported schema version: ${result.data.schemaVersion}. Current: ${SCHEMA_VERSION}`,
+        };
+    }
+    return {
+        success: true,
+        data: result.data,
+    };
+}
+/**
+ * Create .pmpt file content from project data
+ */
+export function createPmptFile(meta, plan, docs, history) {
+    const pmptFile = {
+        schemaVersion: SCHEMA_VERSION,
+        cliMinVersion: '1.3.0',
+        meta,
+        plan,
+        docs,
+        history,
+    };
+    return JSON.stringify(pmptFile, null, 2);
+}

package/package.json

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