@lusipad/pmspec 1.0.0

package/dist/commands/analyze.js

@@ -0,0 +1,240 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { readdir } from 'fs/promises';
+import { join } from 'path';
+import { WorkloadAnalyzer } from '../core/workload.js';
+import { readTeamFile } from '../core/parser.js';
+import { readFeatureFile } from '../core/parser.js';
+const analyzeCommand = new Command('analyze')
+    .description('Analyze team workload and provide assignment recommendations')
+    .option('--recommend', 'Show assignment suggestions for unassigned features')
+    .option('--skills', 'Show skill gap analysis')
+    .option('--verbose', 'Show detailed analysis')
+    .action(async (options, command) => {
+    try {
+        // Check if pmspec directory exists
+        try {
+            await readdir('pmspace');
+        }
+        catch {
+            console.error(chalk.red('Error: pmspec directory not found. Run "pmspec init" first.'));
+            process.exit(1);
+        }
+        // Load team data
+        let team;
+        try {
+            team = await readTeamFile('pmspace/team.md');
+        }
+        catch {
+            console.error(chalk.red('Error: team.md not found. Make sure team file exists.'));
+            process.exit(1);
+        }
+        // Load all features
+        const features = [];
+        try {
+            const featureFiles = await readdir('pmspace/features');
+            for (const file of featureFiles) {
+                if (file.endsWith('.md')) {
+                    const feature = await readFeatureFile(join('pmspace/features', file));
+                    features.push(feature);
+                }
+            }
+        }
+        catch {
+            console.log(chalk.yellow('Warning: No features found.'));
+        }
+        const analyzer = new WorkloadAnalyzer();
+        // Display workload summary
+        displayWorkloadSummary(analyzer.generateWorkloadSummary(team.members, features));
+        // Show recommendations if requested
+        if (options.recommend) {
+            showAssignmentRecommendations(analyzer, team.members, features);
+        }
+        // Show skill analysis if requested
+        if (options.skills) {
+            showSkillAnalysis(analyzer, team.members, features);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+});
+function displayWorkloadSummary(summary) {
+    console.log(chalk.blue.bold('\n📊 Team Workload Summary'));
+    console.log(chalk.gray('─'.repeat(60)));
+    if (summary.length === 0) {
+        console.log(chalk.yellow('No team members found.'));
+        return;
+    }
+    // Create workload table
+    const workloadTable = new Table({
+        head: ['Member', 'Assigned', 'Load %', 'Available', 'Status'],
+        colWidths: [15, 12, 10, 12, 15]
+    });
+    let totalAssigned = 0;
+    let totalCapacity = 0;
+    let overallocatedCount = 0;
+    summary.forEach(member => {
+        const { member: m, assignedFeatures, totalEstimate, loadPercentage, availableHours, isOverallocated } = member;
+        totalAssigned += totalEstimate;
+        totalCapacity += m.capacity;
+        if (isOverallocated)
+            overallocatedCount++;
+        const status = isOverallocated
+            ? chalk.red('OVERALLOCATED')
+            : loadPercentage < 50
+                ? chalk.yellow('UNDERUTILIZED')
+                : chalk.green('BALANCED');
+        const loadColor = loadPercentage > 100
+            ? chalk.red
+            : loadPercentage < 50
+                ? chalk.yellow
+                : chalk.green;
+        workloadTable.push([
+            m.name,
+            `${assignedFeatures.length} feats`,
+            loadColor(`${loadPercentage.toFixed(1)}%`),
+            `${availableHours.toFixed(1)}h`,
+            status
+        ]);
+    });
+    console.log(workloadTable.toString());
+    // Summary statistics
+    const overallUtilization = totalCapacity > 0 ? (totalAssigned / totalCapacity) * 100 : 0;
+    console.log(chalk.gray('\nSummary Statistics:'));
+    console.log(`Total Team Capacity: ${totalCapacity.toFixed(1)}h/week`);
+    console.log(`Total Assigned: ${totalAssigned.toFixed(1)}h/week`);
+    console.log(`Overall Utilization: ${overallUtilization.toFixed(1)}%`);
+    if (overallocatedCount > 0) {
+        console.log(chalk.red(`⚠️  ${overallocatedCount} member(s) overallocated`));
+    }
+    // Find unassigned features
+    const unassignedFeatures = summary
+        .flatMap(m => m.assignedFeatures)
+        .length; // This should be calculated differently
+    console.log(chalk.gray('\nTeam Balance Analysis:'));
+    const balancedMembers = summary.filter(m => !m.isOverallocated && m.loadPercentage >= 50);
+    const underutilizedMembers = summary.filter(m => m.loadPercentage < 50);
+    console.log(chalk.green(`✓ Balanced members: ${balancedMembers.length}`));
+    if (underutilizedMembers.length > 0) {
+        console.log(chalk.yellow(`⚠️  Underutilized members: ${underutilizedMembers.length}`));
+    }
+}
+function showAssignmentRecommendations(analyzer, team, features) {
+    console.log(chalk.blue.bold('\n💡 Assignment Recommendations'));
+    console.log(chalk.gray('─'.repeat(60)));
+    const unassignedFeatures = features.filter(f => !f.assignee);
+    if (unassignedFeatures.length === 0) {
+        console.log(chalk.green('✓ All features are assigned!'));
+        return;
+    }
+    console.log(chalk.yellow(`Found ${unassignedFeatures.length} unassigned feature(s):\n`));
+    unassignedFeatures.forEach(feature => {
+        console.log(chalk.bold(`Feature: ${feature.id} - ${feature.title}`));
+        console.log(chalk.gray(`Estimate: ${feature.estimate}h | Skills: ${feature.skillsRequired.join(', ') || 'None'}`));
+        const candidates = analyzer.rankCandidates(team, feature, 3);
+        if (candidates.length > 0) {
+            const recommendTable = new Table({
+                head: ['Candidate', 'Score', 'Skill Match', 'Load %', 'Missing Skills'],
+                colWidths: [15, 10, 12, 10, 20]
+            });
+            candidates.forEach(candidate => {
+                const scoreColor = candidate.score >= 0.7
+                    ? chalk.green
+                    : candidate.score >= 0.4
+                        ? chalk.yellow
+                        : chalk.red;
+                const skillColor = candidate.skillMatch >= 0.8
+                    ? chalk.green
+                    : candidate.skillMatch >= 0.5
+                        ? chalk.yellow
+                        : chalk.red;
+                const loadColor = candidate.loadPercentage > 100
+                    ? chalk.red
+                    : candidate.loadPercentage > 70
+                        ? chalk.yellow
+                        : chalk.green;
+                recommendTable.push([
+                    candidate.member.name,
+                    scoreColor(candidate.score.toFixed(2)),
+                    skillColor(`${(candidate.skillMatch * 100).toFixed(0)}%`),
+                    loadColor(`${candidate.loadPercentage.toFixed(0)}%`),
+                    candidate.missingSkills.length > 0 ? candidate.missingSkills.join(', ') : 'None'
+                ]);
+            });
+            console.log(recommendTable.toString());
+        }
+        else {
+            console.log(chalk.red('No suitable candidates found.'));
+        }
+        console.log();
+    });
+}
+function showSkillAnalysis(analyzer, team, features) {
+    console.log(chalk.blue.bold('\n🔍 Skill Gap Analysis'));
+    console.log(chalk.gray('─'.repeat(60)));
+    // Find skill gaps
+    const skillGaps = analyzer.findSkillGaps(team, features);
+    if (skillGaps.size === 0) {
+        console.log(chalk.green('✓ No skill gaps found! Team has all required skills.'));
+    }
+    else {
+        console.log(chalk.yellow('Missing Skills:\n'));
+        const skillGapTable = new Table({
+            head: ['Missing Skill', 'Affected Features'],
+            colWidths: [20, 40]
+        });
+        for (const [skill, featureIds] of skillGaps) {
+            skillGapTable.push([
+                chalk.red(skill),
+                featureIds.join(', ')
+            ]);
+        }
+        console.log(skillGapTable.toString());
+    }
+    // Find high demand skills
+    const highDemandSkills = analyzer.findHighDemandSkills(team, features);
+    if (highDemandSkills.size > 0) {
+        console.log(chalk.yellow('\nHigh Demand Skills (bottleneck risk):\n'));
+        const demandTable = new Table({
+            head: ['Skill', 'Demand', 'Supply', 'Risk Level'],
+            colWidths: [20, 10, 10, 15]
+        });
+        for (const [skill, { demandCount, memberCount }] of highDemandSkills) {
+            const riskLevel = memberCount === 0
+                ? chalk.red('CRITICAL')
+                : memberCount === 1
+                    ? chalk.yellow('HIGH')
+                    : chalk.red('MEDIUM');
+            demandTable.push([
+                skill,
+                demandCount.toString(),
+                memberCount.toString(),
+                riskLevel
+            ]);
+        }
+        console.log(demandTable.toString());
+    }
+    // Show team skill overview
+    console.log(chalk.blue('\n👥 Team Skill Overview:\n'));
+    const allSkills = new Set();
+    team.forEach(member => member.skills.forEach(skill => allSkills.add(skill)));
+    const skillTable = new Table({
+        head: ['Skill', 'Team Members'],
+        colWidths: [25, 35]
+    });
+    for (const skill of Array.from(allSkills).sort()) {
+        const skilledMembers = team
+            .filter(member => member.skills.some(s => s.toLowerCase() === skill.toLowerCase()))
+            .map(member => member.name);
+        skillTable.push([
+            skill,
+            skilledMembers.join(', ') || 'None'
+        ]);
+    }
+    console.log(skillTable.toString());
+}
+export { analyzeCommand };
+//# sourceMappingURL=analyze.js.map

package/dist/commands/breakdown.d.ts

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

package/dist/commands/breakdown.js

@@ -0,0 +1,194 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readEpicFile } from '../core/parser.js';
+const breakdownCommand = new Command('breakdown')
+    .description('AI-driven breakdown of requirements into Epic/Feature/Story structure')
+    .argument('[id]', 'Epic ID to expand (optional)')
+    .option('--from <text>', 'Create new epic from requirement description')
+    .option('--apply', 'Apply AI-generated changes automatically')
+    .action(async (id, options, command) => {
+    try {
+        if (options.from) {
+            await breakdownFromDescription(options.from, options.apply);
+        }
+        else if (id) {
+            await breakdownEpic(id, options.apply);
+        }
+        else {
+            console.error(chalk.red('Error: Either provide an Epic ID or use --from option'));
+            console.log(chalk.yellow('Usage:'));
+            console.log('  pmspec breakdown EPIC-001     # Expand existing epic');
+            console.log('  pmspec breakdown --from "description"  # Create new epic from description');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+});
+async function breakdownFromDescription(description, applyChanges) {
+    console.log(chalk.blue('🤖 AI Breakdown from Description'));
+    console.log(chalk.gray('Description:'), description);
+    console.log();
+    // Generate AI prompt
+    const prompt = generateBreakdownPrompt(description);
+    console.log(chalk.yellow('📝 Please run the following prompt in Claude:'));
+    console.log(chalk.cyan('─'.repeat(50)));
+    console.log(prompt);
+    console.log(chalk.cyan('─'.repeat(50)));
+    console.log();
+    if (!applyChanges) {
+        console.log(chalk.yellow('💡 After getting the AI output, run:'));
+        console.log(chalk.cyan('pmspec breakdown --apply --from "description"'));
+        console.log();
+        console.log(chalk.gray('Or manually create the files and use pmspec validate to check'));
+        return;
+    }
+    console.log(chalk.yellow('⚠️  Auto-apply mode requires AI output to be available.'));
+    console.log(chalk.gray('This feature would be implemented with AI API integration.'));
+}
+async function breakdownEpic(epicId, applyChanges) {
+    console.log(chalk.blue(`🤖 AI Breakdown for Epic ${epicId}`));
+    // Validate epic exists
+    let epic;
+    try {
+        epic = await readEpicFile(`pmspace/epics/${epicId.toLowerCase()}.md`);
+    }
+    catch {
+        console.error(chalk.red(`Error: Epic ${epicId} not found`));
+        process.exit(1);
+    }
+    console.log(chalk.gray('Current Epic:'), epic.title);
+    console.log(chalk.gray('Description:'), epic.description || 'No description');
+    console.log();
+    // Generate AI prompt for expanding epic
+    const prompt = generateExpansionPrompt(epic);
+    console.log(chalk.yellow('📝 Please run the following prompt in Claude:'));
+    console.log(chalk.cyan('─'.repeat(50)));
+    console.log(prompt);
+    console.log(chalk.cyan('─'.repeat(50)));
+    console.log();
+    if (!applyChanges) {
+        console.log(chalk.yellow('💡 After getting the AI output, run:'));
+        console.log(chalk.cyan(`pmspec breakdown ${epicId} --apply`));
+        return;
+    }
+    console.log(chalk.yellow('⚠️  Auto-apply mode requires AI output to be available.'));
+    console.log(chalk.gray('This feature would be implemented with AI API integration.'));
+}
+function generateBreakdownPrompt(description) {
+    return `# PMSpec Breakdown
+
+将以下需求描述分解为 Epic/Feature/Story 结构：
+
+需求描述：${description}
+
+请按照以下格式输出结构化的 Markdown：
+
+\`\`\`markdown
+# Epic: [Epic 标题]
+
+- **ID**: EPIC-001
+- **Status**: planning
+- **Owner**: [建议负责人]
+- **Estimate**: [总工时] hours
+- **Actual**: 0 hours
+
+## Description
+[详细描述]
+
+## Features
+- [ ] FEAT-001: [Feature 1 标题]
+- [ ] FEAT-002: [Feature 2 标题]
+
+---
+
+# Feature: [Feature 1 标题]
+
+- **ID**: FEAT-001
+- **Epic**: EPIC-001
+- **Status**: todo
+- **Assignee**: [建议负责人]
+- **Estimate**: [工时] hours
+- **Skills Required**: [技能1], [技能2]
+
+## Description
+[详细描述]
+
+## User Stories
+- [ ] STORY-001: As a [用户类型], I want to [功能] so that [价值] ([工时]h)
+- [ ] STORY-002: As a [用户类型], I want to [功能] so that [价值] ([工时]h)
+
+## Acceptance Criteria
+- [ ] [验收条件1]
+- [ ] [验收条件2]
+\`\`\`
+
+指导原则：
+- Epic: 大的业务目标 (20-500h)
+- Feature: 可交付功能单元 (4-80h)
+- User Story: 最小可实施单元 (1-24h)
+- 每个 Story 都要体现用户价值`;
+}
+function generateExpansionPrompt(epic) {
+    return `# PMSpec Epic Expansion
+
+扩展现有的 Epic，添加更详细的 Feature 和 User Story：
+
+## 当前 Epic
+
+**标题**: ${epic.title}
+**ID**: ${epic.id}
+**描述**: ${epic.description || '无描述'}
+**当前估算**: ${epic.estimate}h
+**当前 Features**: ${epic.features.length > 0 ? epic.features.join(', ') : '无'}
+
+## 扩展要求
+
+1. 为现有 Epic 添加更多详细的 Features
+2. 为每个 Feature 添加完��的 User Stories
+3. 优化工时估算
+4. 添加所需的技能要求
+5. 设置合理的验收标准
+
+## 输出格式
+
+请按照 PMSpec 格式输出新增的 Features 和完整的更新结构，包括：
+
+- 新增的 Feature 文件内容
+- 更新的 Epic 文件内容（包含新的 Features 列表）
+- 每个新增 Feature 的 User Stories
+
+确保工时估算合理，Story 粒度适中（1-3天可完成）。`;
+}
+// Helper function to parse AI-generated markdown (placeholder for future AI integration)
+async function parseAIGeneratedContent(content) {
+    // This would parse the AI-generated markdown and extract epic/features/stories
+    // For now, return empty structure
+    return {
+        epic: null,
+        features: [],
+        errors: ['AI parsing not implemented yet']
+    };
+}
+// Helper function to validate AI-generated structure
+function validateAIStructure(epic, features) {
+    const errors = [];
+    // Validate epic
+    if (!epic || !epic.id || !epic.title) {
+        errors.push('Invalid epic structure: missing id or title');
+    }
+    // Validate features
+    features.forEach((feature, index) => {
+        if (!feature.id || !feature.title) {
+            errors.push(`Invalid feature ${index + 1}: missing id or title`);
+        }
+        if (!feature.userStories || feature.userStories.length === 0) {
+            errors.push(`Feature ${feature.id}: no user stories defined`);
+        }
+    });
+    return { valid: errors.length === 0, errors };
+}
+export { breakdownCommand };
+//# sourceMappingURL=breakdown.js.map

package/dist/commands/create.d.ts

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