pmpt-cli 1.6.0 → 1.7.0

package/dist/commands/init.js

@@ -1,9 +1,12 @@
 import * as p from '@clack/prompts';
-import { existsSync } from 'fs';
+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 { cmdPlan } from './plan.js';
+import { scanProject, scanResultToAnswers } from '../lib/scanner.js';
+import { savePlanDocuments, initPlanProgress, savePlanProgress } from '../lib/plan.js';
+import { copyToClipboard } from '../lib/clipboard.js';
 export async function cmdInit(path, options) {
     p.intro('pmpt init');
     const projectPath = path ? resolve(path) : process.cwd();
@@ -12,7 +15,16 @@ export async function cmdInit(path, options) {
         process.exit(1);
     }
     if (isInitialized(projectPath)) {
-        p.outro(`Project already initialized: ${projectPath}`);
+        p.log.warn('Project already initialized.');
+        p.log.message('');
+        p.log.info('Available commands:');
+        p.log.message('  pmpt plan      — Generate or view AI prompt');
+        p.log.message('  pmpt save      — Save a snapshot');
+        p.log.message('  pmpt watch     — Auto-save on file changes');
+        p.log.message('  pmpt history   — View version history');
+        p.log.message('');
+        p.log.message('To reinitialize, remove .pmpt/ and run `pmpt init` again.');
+        p.outro('');
         process.exit(0);
     }
     // Detect Git repository
@@ -102,17 +114,137 @@ export async function cmdInit(path, options) {
         notes.push('  pmpt watch    # Auto-save on changes');
         notes.push('  pmpt history  # View versions');
         p.note(notes.join('\n'), 'Project Info');
-        // Ask to start plan mode
-        const startPlan = await p.confirm({
-            message: 'Start planning? (Generate AI prompt with 5 quick questions)',
-            initialValue: true,
-        });
-        if (!p.isCancel(startPlan) && startPlan) {
-            p.log.message('');
-            await cmdPlan(projectPath);
+        // Scan for existing project
+        const scanResult = scanProject(projectPath);
+        if (scanResult.isExistingProject) {
+            // Show scan summary
+            const scanNotes = [];
+            if (scanResult.packageInfo) {
+                scanNotes.push(`Package: ${scanResult.packageInfo.name}`);
+                if (scanResult.packageInfo.description) {
+                    scanNotes.push(`Description: ${scanResult.packageInfo.description}`);
+                }
+                scanNotes.push(`Dependencies: ${scanResult.packageInfo.dependencies.length} production, ${scanResult.packageInfo.devDependencies.length} dev`);
+            }
+            if (scanResult.detectedFramework) {
+                scanNotes.push(`Framework: ${scanResult.detectedFramework}`);
+            }
+            if (scanResult.directoryStructure.length > 0) {
+                scanNotes.push(`Structure: ${scanResult.directoryStructure.map((d) => d + '/').join(', ')}`);
+            }
+            if (scanResult.gitSummary) {
+                const gs = scanResult.gitSummary;
+                let gitLine = `Git: ${gs.totalCommits} commits`;
+                if (gs.firstCommitDate) {
+                    gitLine += ` since ${gs.firstCommitDate.split('T')[0]}`;
+                }
+                gitLine += `, ${gs.contributors} contributor(s)`;
+                scanNotes.push(gitLine);
+            }
+            p.note(scanNotes.join('\n'), 'Existing Project Detected');
+            const scanChoice = await p.select({
+                message: 'Auto-generate plan from detected project files?',
+                options: [
+                    { value: 'auto', label: 'Auto-generate plan', hint: 'Recommended — instant AI prompt from project analysis' },
+                    { value: 'manual', label: 'Manual planning', hint: '5 questions interactive flow' },
+                    { value: 'skip', label: 'Skip for now' },
+                ],
+            });
+            if (p.isCancel(scanChoice)) {
+                p.cancel('Cancelled');
+                process.exit(0);
+            }
+            if (scanChoice === 'auto') {
+                // Ask for project description
+                const defaultDesc = scanResult.readmeDescription
+                    || scanResult.packageInfo?.description
+                    || '';
+                const userDesc = await p.text({
+                    message: 'Briefly describe what this project does:',
+                    defaultValue: defaultDesc || undefined,
+                    placeholder: defaultDesc || 'e.g., A web app for sharing AI project histories',
+                });
+                if (p.isCancel(userDesc)) {
+                    p.cancel('Cancelled');
+                    process.exit(0);
+                }
+                const s2 = p.spinner();
+                s2.start('Scanning project and generating plan...');
+                const answers = scanResultToAnswers(scanResult, userDesc);
+                const { planPath, promptPath } = savePlanDocuments(projectPath, answers);
+                const progress = initPlanProgress(projectPath);
+                progress.completed = true;
+                progress.answers = answers;
+                savePlanProgress(projectPath, progress);
+                s2.stop('Plan generated!');
+                p.log.message('');
+                p.log.success('Two documents have been created:');
+                p.log.message('');
+                const docExplanation = [
+                    `1. plan.md — Your product overview`,
+                    `   Location: ${planPath}`,
+                    '',
+                    `2. pmpt.md — AI prompt (THE IMPORTANT ONE!)`,
+                    `   Copy this to Claude/ChatGPT/Codex`,
+                    `   Location: ${promptPath}`,
+                ];
+                p.note(docExplanation.join('\n'), 'Auto-generated from project scan');
+                // Copy to clipboard
+                const content = readFileSync(promptPath, 'utf-8');
+                const copied = copyToClipboard(content);
+                if (copied) {
+                    p.log.message('');
+                    p.log.success('AI prompt copied to clipboard!');
+                    p.log.message('');
+                    const banner = [
+                        '',
+                        '┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓',
+                        '┃                                                        ┃',
+                        '┃   📋  NEXT STEP                                        ┃',
+                        '┃                                                        ┃',
+                        '┃   Open your AI coding tool and press:           ┃',
+                        '┃                                                        ┃',
+                        '┃              ⌘ + V  (Mac)                              ┃',
+                        '┃             Ctrl + V (Windows/Linux)                   ┃',
+                        '┃                                                        ┃',
+                        '┃   Your project context is ready! 🚀                    ┃',
+                        '┃                                                        ┃',
+                        '┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛',
+                        '',
+                    ];
+                    console.log(banner.join('\n'));
+                }
+                else {
+                    p.log.warn('Could not copy to clipboard.');
+                    p.log.info(`Read it at: ${promptPath}`);
+                }
+                p.log.info('Tips:');
+                p.log.message('  pmpt plan     — View or edit your AI prompt');
+                p.log.message('  pmpt save     — Save a snapshot anytime');
+                p.log.message('  pmpt watch    — Auto-save on file changes');
+                p.outro('Ready to go!');
+            }
+            else if (scanChoice === 'manual') {
+                p.log.message('');
+                await cmdPlan(projectPath);
+            }
+            else {
+                p.outro('Ready! Run `pmpt plan` when you want to start.');
+            }
         }
         else {
-            p.outro('Ready! Run `pmpt plan` when you want to start.');
+            // New/empty project — original flow
+            const startPlan = await p.confirm({
+                message: 'Start planning? (Generate AI prompt with 5 quick questions)',
+                initialValue: true,
+            });
+            if (!p.isCancel(startPlan) && startPlan) {
+                p.log.message('');
+                await cmdPlan(projectPath);
+            }
+            else {
+                p.outro('Ready! Run `pmpt plan` when you want to start.');
+            }
         }
     }
     catch (error) {

package/dist/commands/plan.js

@@ -1,35 +1,10 @@
 import * as p from '@clack/prompts';
 import { resolve } from 'path';
 import { readFileSync } from 'fs';
-import { execSync } from 'child_process';
 import { isInitialized } from '../lib/config.js';
+import { copyToClipboard } from '../lib/clipboard.js';
 import { cmdWatch } from './watch.js';
 import { PLAN_QUESTIONS, getPlanProgress, initPlanProgress, savePlanProgress, savePlanDocuments, } from '../lib/plan.js';
-// Cross-platform clipboard copy
-function copyToClipboard(text) {
-    try {
-        const platform = process.platform;
-        if (platform === 'darwin') {
-            execSync('pbcopy', { input: text });
-        }
-        else if (platform === 'win32') {
-            execSync('clip', { input: text });
-        }
-        else {
-            // Linux - try xclip or xsel
-            try {
-                execSync('xclip -selection clipboard', { input: text });
-            }
-            catch {
-                execSync('xsel --clipboard --input', { input: text });
-            }
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 export async function cmdPlan(path, options) {
     const projectPath = path ? resolve(path) : process.cwd();
     // Check initialization

package/dist/lib/clipboard.js

@@ -0,0 +1,25 @@
+import { execSync } from 'child_process';
+export function copyToClipboard(text) {
+    try {
+        const platform = process.platform;
+        if (platform === 'darwin') {
+            execSync('pbcopy', { input: text });
+        }
+        else if (platform === 'win32') {
+            execSync('clip', { input: text });
+        }
+        else {
+            // Linux - try xclip or xsel
+            try {
+                execSync('xclip -selection clipboard', { input: text });
+            }
+            catch {
+                execSync('xsel --clipboard --input', { input: text });
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/scanner.js

@@ -0,0 +1,289 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { execSync } from 'child_process';
+import { isGitRepo } from './git.js';
+// ── Scanner Functions ──
+function git(path, args) {
+    try {
+        return execSync(`git ${args}`, {
+            cwd: path,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function scanPackageJson(projectPath) {
+    const pkgPath = join(projectPath, 'package.json');
+    if (!existsSync(pkgPath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return {
+            name: raw.name || basename(projectPath),
+            description: raw.description || null,
+            dependencies: Object.keys(raw.dependencies || {}),
+            devDependencies: Object.keys(raw.devDependencies || {}),
+            scripts: Object.keys(raw.scripts || {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function scanReadme(projectPath) {
+    const candidates = ['README.md', 'readme.md', 'Readme.md'];
+    let content = null;
+    for (const name of candidates) {
+        const filePath = join(projectPath, name);
+        if (existsSync(filePath)) {
+            try {
+                content = readFileSync(filePath, 'utf-8');
+                break;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    if (!content)
+        return null;
+    // Split by paragraph and find the first meaningful one
+    const paragraphs = content.split(/\n\n+/);
+    for (const p of paragraphs) {
+        const trimmed = p.trim();
+        // Skip headings, badges, images, empty lines, HTML tags
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith('#'))
+            continue;
+        if (trimmed.startsWith('[') || trimmed.startsWith('!'))
+            continue;
+        if (trimmed.startsWith('<'))
+            continue;
+        if (trimmed.startsWith('```'))
+            continue;
+        // Found a text paragraph
+        const cleaned = trimmed.replace(/\n/g, ' ').trim();
+        return cleaned.length > 500 ? cleaned.slice(0, 500) + '...' : cleaned;
+    }
+    return null;
+}
+const FRAMEWORK_CONFIGS = [
+    ['astro.config.*', 'Astro'],
+    ['next.config.*', 'Next.js'],
+    ['nuxt.config.*', 'Nuxt'],
+    ['svelte.config.*', 'SvelteKit'],
+    ['remix.config.*', 'Remix'],
+    ['gatsby-config.*', 'Gatsby'],
+    ['angular.json', 'Angular'],
+    ['vite.config.*', 'Vite'],
+];
+const DEP_FRAMEWORKS = [
+    ['next', 'Next.js'],
+    ['nuxt', 'Nuxt'],
+    ['@angular/core', 'Angular'],
+    ['svelte', 'Svelte'],
+    ['vue', 'Vue'],
+    ['react', 'React'],
+    ['express', 'Express'],
+    ['fastify', 'Fastify'],
+    ['@nestjs/core', 'NestJS'],
+    ['hono', 'Hono'],
+    ['django', 'Django'],
+    ['flask', 'Flask'],
+];
+function detectFramework(projectPath, packageInfo) {
+    // Check config files first
+    for (const [pattern, name] of FRAMEWORK_CONFIGS) {
+        if (pattern.includes('*')) {
+            const base = pattern.replace('.*', '');
+            try {
+                const files = readdirSync(projectPath);
+                if (files.some((f) => f.startsWith(base)))
+                    return name;
+            }
+            catch {
+                // ignore
+            }
+        }
+        else {
+            if (existsSync(join(projectPath, pattern)))
+                return name;
+        }
+    }
+    // Fall back to dependencies
+    if (packageInfo) {
+        const allDeps = [...packageInfo.dependencies, ...packageInfo.devDependencies];
+        for (const [dep, name] of DEP_FRAMEWORKS) {
+            if (allDeps.includes(dep))
+                return name;
+        }
+    }
+    return null;
+}
+const MEANINGFUL_DIRS = new Set([
+    'src', 'app', 'pages', 'components', 'routes', 'views',
+    'lib', 'utils', 'helpers', 'hooks', 'stores', 'store',
+    'api', 'server', 'services', 'middleware',
+    'public', 'static', 'assets', 'styles', 'css',
+    'tests', '__tests__', 'test', 'spec',
+    'scripts', 'config', 'database', 'db', 'models',
+    'layouts', 'templates',
+]);
+function scanDirectoryStructure(projectPath) {
+    try {
+        const entries = readdirSync(projectPath);
+        return entries
+            .filter((name) => {
+            if (name.startsWith('.'))
+                return false;
+            if (name === 'node_modules' || name === 'dist' || name === 'build')
+                return false;
+            try {
+                return statSync(join(projectPath, name)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .filter((name) => MEANINGFUL_DIRS.has(name))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function scanGitHistory(projectPath) {
+    if (!isGitRepo(projectPath))
+        return null;
+    const countStr = git(projectPath, 'rev-list --count HEAD');
+    if (!countStr)
+        return null;
+    const totalCommits = parseInt(countStr, 10);
+    if (isNaN(totalCommits) || totalCommits === 0)
+        return null;
+    const recentRaw = git(projectPath, 'log --oneline -5 --format=%s');
+    const recentCommits = recentRaw
+        ? recentRaw.split('\n').filter(Boolean)
+        : [];
+    const firstCommitDate = git(projectPath, 'log --reverse --format=%cI -1') || null;
+    let contributors = 1;
+    const shortlogRaw = git(projectPath, 'shortlog -sn HEAD');
+    if (shortlogRaw) {
+        contributors = shortlogRaw.split('\n').filter(Boolean).length;
+    }
+    return { totalCommits, recentCommits, firstCommitDate, contributors };
+}
+// ── Main Functions ──
+export function scanProject(projectPath) {
+    const packageInfo = scanPackageJson(projectPath);
+    const readmeDescription = scanReadme(projectPath);
+    const detectedFramework = detectFramework(projectPath, packageInfo);
+    const directoryStructure = scanDirectoryStructure(projectPath);
+    const gitSummary = scanGitHistory(projectPath);
+    const isExistingProject = packageInfo !== null ||
+        readmeDescription !== null ||
+        directoryStructure.length > 0 ||
+        (gitSummary !== null && gitSummary.totalCommits > 0);
+    return {
+        isExistingProject,
+        packageInfo,
+        readmeDescription,
+        detectedFramework,
+        directoryStructure,
+        gitSummary,
+    };
+}
+export function scanResultToAnswers(result, userDescription) {
+    // projectName
+    const projectName = result.packageInfo?.name || basename(process.cwd());
+    // productIdea — user's own description
+    const productIdea = userDescription;
+    // additionalContext — scanned technical info
+    const contextParts = [];
+    contextParts.push('Existing project with established codebase.');
+    if (result.detectedFramework) {
+        contextParts.push(`- Framework: ${result.detectedFramework}`);
+    }
+    if (result.directoryStructure.length > 0) {
+        contextParts.push(`- Project structure: ${result.directoryStructure.map((d) => d + '/').join(', ')}`);
+    }
+    if (result.gitSummary) {
+        const gs = result.gitSummary;
+        let gitLine = `- Git history: ${gs.totalCommits} commits`;
+        if (gs.firstCommitDate) {
+            gitLine += ` since ${gs.firstCommitDate.split('T')[0]}`;
+        }
+        gitLine += `, ${gs.contributors} contributor(s)`;
+        contextParts.push(gitLine);
+        if (gs.recentCommits.length > 0) {
+            contextParts.push(`- Recent work: ${gs.recentCommits.map((c) => `"${c}"`).join(', ')}`);
+        }
+    }
+    const additionalContext = contextParts.join('\n');
+    // coreFeatures — from scripts and directory structure
+    const featureParts = [];
+    if (result.packageInfo?.scripts.length) {
+        for (const script of result.packageInfo.scripts) {
+            featureParts.push(`${script} (npm script)`);
+        }
+    }
+    if (result.directoryStructure.length > 0) {
+        const dirHints = {
+            pages: 'Page routing',
+            routes: 'Route handling',
+            components: 'Component library',
+            api: 'API layer',
+            server: 'Server-side logic',
+            tests: 'Test suite',
+            __tests__: 'Test suite',
+            test: 'Test suite',
+            models: 'Data models',
+            database: 'Database layer',
+            db: 'Database layer',
+            middleware: 'Middleware',
+            layouts: 'Layout system',
+        };
+        for (const dir of result.directoryStructure) {
+            if (dirHints[dir]) {
+                featureParts.push(`${dirHints[dir]} (${dir}/ directory)`);
+            }
+        }
+    }
+    const coreFeatures = featureParts.length > 0
+        ? featureParts.join('; ')
+        : 'Existing project features';
+    // techStack — from framework + dependencies
+    const stackParts = [];
+    if (result.detectedFramework) {
+        stackParts.push(result.detectedFramework);
+    }
+    if (result.packageInfo) {
+        // Add top production dependencies (exclude framework already listed)
+        const frameworkLower = result.detectedFramework?.toLowerCase() || '';
+        const topDeps = result.packageInfo.dependencies
+            .filter((d) => !d.startsWith('@types/') && !d.toLowerCase().includes(frameworkLower))
+            .slice(0, 8);
+        stackParts.push(...topDeps);
+        // Add notable dev deps
+        const notableDevDeps = ['typescript', 'eslint', 'prettier', 'jest', 'vitest', 'mocha', 'tailwindcss'];
+        for (const d of result.packageInfo.devDependencies) {
+            if (notableDevDeps.includes(d) && !stackParts.includes(d)) {
+                stackParts.push(d);
+            }
+        }
+    }
+    const techStack = stackParts.length > 0
+        ? stackParts.join(', ')
+        : '';
+    return {
+        projectName,
+        productIdea,
+        additionalContext,
+        coreFeatures,
+        techStack,
+    };
+}

package/package.json

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