@lusipad/pmspec 1.0.0

package/dist/commands/search.js

@@ -0,0 +1,183 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { SearchService, highlightMatches } from '../core/search.js';
+/**
+ * Search command for CLI
+ */
+const searchCommand = new Command('search')
+    .description('搜索项目中的 Epic、Feature、Story 和 Milestone')
+    .argument('<query>', '搜索关键词')
+    .option('--type <type>', '限制搜索类型: epic, feature, story, milestone')
+    .option('--limit <number>', '返回结果数量限制', '20')
+    .option('--no-highlight', '禁用高亮显示')
+    .option('--json', '以 JSON 格式输出')
+    .action(async (query, options) => {
+    const startTime = Date.now();
+    try {
+        // Initialize search service
+        const searchService = new SearchService(process.cwd());
+        await searchService.index();
+        // Build search options
+        const searchOptions = {
+            limit: parseInt(options.limit, 10) || 20,
+        };
+        // Handle type filter
+        if (options.type) {
+            const validTypes = ['epic', 'feature', 'story', 'milestone'];
+            const requestedType = options.type.toLowerCase();
+            if (!validTypes.includes(requestedType)) {
+                console.error(chalk.red(`错误: 无效的类型 "${options.type}"`));
+                console.error(chalk.gray(`有效类型: ${validTypes.join(', ')}`));
+                process.exit(1);
+            }
+            searchOptions.type = requestedType;
+        }
+        // Perform search
+        const results = searchService.search(query, searchOptions);
+        const searchTime = Date.now() - startTime;
+        // Output results
+        if (options.json) {
+            outputJson(results, searchTime);
+        }
+        else {
+            outputFormatted(query, results, searchTime, options.highlight !== false);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('搜索错误:'), error.message);
+        process.exit(1);
+    }
+});
+/**
+ * Output results as JSON
+ */
+function outputJson(results, searchTime) {
+    const output = {
+        results,
+        meta: {
+            count: results.length,
+            searchTime: `${searchTime}ms`,
+        },
+    };
+    console.log(JSON.stringify(output, null, 2));
+}
+/**
+ * Output formatted results for terminal
+ */
+function outputFormatted(query, results, searchTime, useHighlight) {
+    console.log(chalk.blue.bold(`\n🔍 搜索结果: "${query}"\n`));
+    if (results.length === 0) {
+        console.log(chalk.yellow('没有找到匹配的结果'));
+        console.log(chalk.gray(`\n耗时: ${searchTime}ms`));
+        return;
+    }
+    // Group results by type
+    const grouped = groupByType(results);
+    // Output each group
+    for (const [type, typeResults] of Object.entries(grouped)) {
+        const typeLabel = getTypeLabel(type);
+        const typeColor = getTypeColor(type);
+        console.log(typeColor(`\n═══ ${typeLabel} (${typeResults.length}) ═══\n`));
+        for (const result of typeResults) {
+            outputResult(result, useHighlight);
+        }
+    }
+    // Summary
+    console.log(chalk.gray(`\n────────────────────────────────────`));
+    console.log(chalk.green(`找到 ${results.length} 个结果`));
+    console.log(chalk.gray(`耗时: ${searchTime}ms`));
+}
+/**
+ * Output a single search result
+ */
+function outputResult(result, useHighlight) {
+    const typeColor = getTypeColor(result.type);
+    const typeEmoji = getTypeEmoji(result.type);
+    // ID and Title
+    const title = useHighlight
+        ? highlightMatches(result.title, result.matches)
+        : result.title;
+    console.log(`${typeEmoji} ${typeColor(result.id)} ${chalk.white.bold(title)}`);
+    // Description (truncated)
+    if (result.description) {
+        const desc = useHighlight
+            ? highlightMatches(result.description, result.matches)
+            : result.description;
+        const truncatedDesc = truncate(desc, 100);
+        console.log(chalk.gray(`   ${truncatedDesc}`));
+    }
+    // Parent reference
+    if (result.parentId) {
+        console.log(chalk.gray.dim(`   └─ 属于: ${result.parentId}`));
+    }
+    // Score (debug info)
+    // console.log(chalk.gray.dim(`   分数: ${result.score.toFixed(2)}`));
+    console.log('');
+}
+/**
+ * Group results by type
+ */
+function groupByType(results) {
+    const groups = {};
+    for (const result of results) {
+        if (!groups[result.type]) {
+            groups[result.type] = [];
+        }
+        groups[result.type].push(result);
+    }
+    // Sort types in preferred order
+    const order = ['epic', 'feature', 'story', 'milestone'];
+    const ordered = {};
+    for (const type of order) {
+        if (groups[type]) {
+            ordered[type] = groups[type];
+        }
+    }
+    return ordered;
+}
+/**
+ * Get display label for type
+ */
+function getTypeLabel(type) {
+    const labels = {
+        epic: 'Epics',
+        feature: 'Features',
+        story: 'User Stories',
+        milestone: 'Milestones',
+    };
+    return labels[type] || type;
+}
+/**
+ * Get color for type
+ */
+function getTypeColor(type) {
+    const colors = {
+        epic: chalk.magenta,
+        feature: chalk.cyan,
+        story: chalk.blue,
+        milestone: chalk.green,
+    };
+    return colors[type] || chalk.white;
+}
+/**
+ * Get emoji for type
+ */
+function getTypeEmoji(type) {
+    const emojis = {
+        epic: '📦',
+        feature: '✨',
+        story: '📝',
+        milestone: '🎯',
+    };
+    return emojis[type] || '•';
+}
+/**
+ * Truncate text to specified length
+ */
+function truncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.substring(0, maxLength - 3) + '...';
+}
+export { searchCommand };
+//# sourceMappingURL=search.js.map

package/dist/commands/serve.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const serveCommand: Command;
+//# sourceMappingURL=serve.d.ts.map

package/dist/commands/serve.js

@@ -0,0 +1,68 @@
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import open from 'open';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const serveCommand = new Command('serve')
+    .description('Start the PMSpec Web UI server')
+    .option('-p, --port <port>', 'Port to run the server on', '3000')
+    .option('-o, --open', 'Open browser automatically')
+    .action(async (options) => {
+    const port = parseInt(options.port) || 3000;
+    const shouldOpen = options.open || false;
+    console.log(`\n🚀 Starting PMSpec Web Server...\n`);
+    // Path to backend server
+    const backendPath = path.join(__dirname, '../../web/backend/src/server.ts');
+    // Check if backend exists
+    const fs = await import('fs/promises');
+    try {
+        await fs.access(backendPath);
+    }
+    catch (error) {
+        console.error('❌ Error: Web backend not found.');
+        console.error('   Please ensure the web/ directory is set up correctly.');
+        process.exit(1);
+    }
+    // Start backend server
+    const backendProcess = spawn('npx', ['ts-node-dev', '--respawn', '--transpile-only', backendPath], {
+        cwd: path.join(__dirname, '../../web/backend'),
+        env: { ...process.env, PORT: port.toString() },
+        stdio: 'inherit',
+        shell: true,
+    });
+    // Wait a bit for server to start
+    setTimeout(() => {
+        const url = `http://localhost:${port}`;
+        if (shouldOpen) {
+            console.log(`\n📖 Opening browser at ${url}...\n`);
+            open(url).catch((err) => {
+                console.error('Could not open browser:', err.message);
+            });
+        }
+        console.log(`\n✨ PMSpec Web UI is running!`);
+        console.log(`   - URL: ${url}`);
+        console.log(`   - API: ${url}/api`);
+        console.log(`\n   Press Ctrl+C to stop the server.\n`);
+    }, 2000);
+    // Handle graceful shutdown
+    const cleanup = () => {
+        console.log('\n\n⏹  Shutting down PMSpec Web Server...');
+        backendProcess.kill('SIGTERM');
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    backendProcess.on('error', (error) => {
+        console.error('❌ Failed to start server:', error);
+        process.exit(1);
+    });
+    backendProcess.on('exit', (code) => {
+        if (code !== 0 && code !== null) {
+            console.error(`❌ Server exited with code ${code}`);
+            process.exit(code);
+        }
+    });
+});
+//# sourceMappingURL=serve.js.map

package/dist/commands/show.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const showCommand: Command;
+//# sourceMappingURL=show.d.ts.map

package/dist/commands/show.js

@@ -0,0 +1,152 @@
+import { Command } from 'commander';
+import { readdir } from 'fs/promises';
+import { join } from 'path';
+import chalk from 'chalk';
+import { readEpicFile, readFeatureFile, readMilestoneFile } from '../core/parser.js';
+export const showCommand = new Command('show')
+    .description('Show details of an Epic, Feature, or Milestone')
+    .argument('<id>', 'ID of Epic, Feature, or Milestone (e.g., EPIC-001, FEAT-001, MILE-001)')
+    .action(async (id) => {
+    const pmspaceDir = join(process.cwd(), 'pmspace');
+    try {
+        if (id.startsWith('EPIC-')) {
+            await showEpic(pmspaceDir, id);
+        }
+        else if (id.startsWith('FEAT-')) {
+            await showFeature(pmspaceDir, id);
+        }
+        else if (id.startsWith('MILE-')) {
+            await showMilestone(pmspaceDir, id);
+        }
+        else {
+            console.error(chalk.red(`Invalid ID format: ${id}`));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            console.error(chalk.red(`${id} not found.`));
+            process.exit(1);
+        }
+        throw error;
+    }
+});
+async function showEpic(pmspaceDir, id) {
+    const filePath = join(pmspaceDir, 'epics', `${id.toLowerCase()}.md`);
+    const epic = await readEpicFile(filePath);
+    console.log(chalk.bold.cyan(`\n# Epic: ${epic.title}\n`));
+    console.log(chalk.gray(`ID:       ${epic.id}`));
+    console.log(chalk.gray(`Status:   ${epic.status}`));
+    if (epic.owner) {
+        console.log(chalk.gray(`Owner:    ${epic.owner}`));
+    }
+    console.log(chalk.gray(`Estimate: ${epic.estimate} hours`));
+    console.log(chalk.gray(`Actual:   ${epic.actual} hours`));
+    if (epic.description) {
+        console.log(chalk.bold('\n## Description\n'));
+        console.log(epic.description);
+    }
+    if (epic.features.length > 0) {
+        console.log(chalk.bold('\n## Features\n'));
+        // Calculate progress
+        const featuresDir = join(pmspaceDir, 'features');
+        const files = await readdir(featuresDir);
+        const featureFiles = files.filter(f => f.endsWith('.md'));
+        let completed = 0;
+        for (const featureId of epic.features) {
+            try {
+                const filePath = join(featuresDir, `${featureId.toLowerCase()}.md`);
+                const feature = await readFeatureFile(filePath);
+                const checkbox = feature.status === 'done' ? '[x]' : '[ ]';
+                console.log(`  ${checkbox} ${feature.id}: ${feature.title}`);
+                if (feature.status === 'done')
+                    completed++;
+            }
+            catch {
+                console.log(`  [ ] ${featureId}: [Not found]`);
+            }
+        }
+        const progress = epic.features.length > 0 ? Math.round((completed / epic.features.length) * 100) : 0;
+        console.log(chalk.gray(`\nProgress: ${completed}/${epic.features.length} (${progress}%)`));
+    }
+    console.log('');
+}
+async function showFeature(pmspaceDir, id) {
+    const filePath = join(pmspaceDir, 'features', `${id.toLowerCase()}.md`);
+    const feature = await readFeatureFile(filePath);
+    console.log(chalk.bold.cyan(`\n# Feature: ${feature.title}\n`));
+    console.log(chalk.gray(`ID:        ${feature.id}`));
+    console.log(chalk.gray(`Epic:      ${feature.epicId}`));
+    console.log(chalk.gray(`Status:    ${feature.status}`));
+    if (feature.assignee) {
+        console.log(chalk.gray(`Assignee:  ${feature.assignee}`));
+    }
+    console.log(chalk.gray(`Estimate:  ${feature.estimate} hours`));
+    console.log(chalk.gray(`Actual:    ${feature.actual} hours`));
+    if (feature.skillsRequired.length > 0) {
+        console.log(chalk.gray(`Skills:    ${feature.skillsRequired.join(', ')}`));
+    }
+    if (feature.description) {
+        console.log(chalk.bold('\n## Description\n'));
+        console.log(feature.description);
+    }
+    if (feature.userStories.length > 0) {
+        console.log(chalk.bold('\n## User Stories\n'));
+        for (const story of feature.userStories) {
+            const checkbox = story.status === 'done' ? '[x]' : '[ ]';
+            console.log(`  ${checkbox} ${story.id}: ${story.title} (${story.estimate}h)`);
+        }
+    }
+    if (feature.acceptanceCriteria.length > 0) {
+        console.log(chalk.bold('\n## Acceptance Criteria\n'));
+        for (const criterion of feature.acceptanceCriteria) {
+            console.log(`  - [ ] ${criterion}`);
+        }
+    }
+    if (feature.dependencies && feature.dependencies.length > 0) {
+        console.log(chalk.bold('\n## Dependencies\n'));
+        const blocks = feature.dependencies.filter(d => d.type === 'blocks');
+        const relatesTo = feature.dependencies.filter(d => d.type === 'relates-to');
+        if (blocks.length > 0) {
+            console.log(chalk.gray(`  Blocks: ${blocks.map(d => d.featureId).join(', ')}`));
+        }
+        if (relatesTo.length > 0) {
+            console.log(chalk.gray(`  Relates to: ${relatesTo.map(d => d.featureId).join(', ')}`));
+        }
+    }
+    console.log('');
+}
+async function showMilestone(pmspaceDir, id) {
+    const filePath = join(pmspaceDir, 'milestones', `${id.toLowerCase()}.md`);
+    const milestone = await readMilestoneFile(filePath);
+    console.log(chalk.bold.cyan(`\n# Milestone: ${milestone.title}\n`));
+    console.log(chalk.gray(`ID:          ${milestone.id}`));
+    console.log(chalk.gray(`Target Date: ${milestone.targetDate}`));
+    console.log(chalk.gray(`Status:      ${milestone.status}`));
+    if (milestone.description) {
+        console.log(chalk.bold('\n## Description\n'));
+        console.log(milestone.description);
+    }
+    if (milestone.features.length > 0) {
+        console.log(chalk.bold('\n## Features\n'));
+        const featuresDir = join(pmspaceDir, 'features');
+        let completed = 0;
+        for (const featureId of milestone.features) {
+            try {
+                const featurePath = join(featuresDir, `${featureId.toLowerCase()}.md`);
+                const feature = await readFeatureFile(featurePath);
+                const checkbox = feature.status === 'done' ? '[x]' : '[ ]';
+                console.log(`  ${checkbox} ${feature.id}: ${feature.title}`);
+                if (feature.status === 'done')
+                    completed++;
+            }
+            catch {
+                console.log(`  [ ] ${featureId}: [Not found]`);
+            }
+        }
+        const progress = milestone.features.length > 0 ? Math.round((completed / milestone.features.length) * 100) : 0;
+        console.log(chalk.gray(`\nProgress: ${completed}/${milestone.features.length} (${progress}%)`));
+    }
+    console.log('');
+}
+//# sourceMappingURL=show.js.map

package/dist/commands/simple.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+declare const simpleCommand: Command;
+declare const generateCommand: Command;
+declare const listCommand: Command;
+declare const statsCommand: Command;
+export { simpleCommand, generateCommand, listCommand, statsCommand };
+//# sourceMappingURL=simple.d.ts.map