@lusipad/pmspec 1.0.0

package/dist/core/workload.js

@@ -0,0 +1,116 @@
+import { calculateSkillMatch, getAvailableHours, calculateLoadPercentage } from './team.js';
+/**
+ * WorkloadAnalyzer calculates assignment scores and workload summaries
+ */
+export class WorkloadAnalyzer {
+    /**
+     * Calculate assignment score for a member and feature
+     * score = skillMatch * (1 - loadPercentage/100)
+     */
+    calculateAssignmentScore(member, feature) {
+        const skillMatch = calculateSkillMatch(member.skills, feature.skillsRequired);
+        const loadPercentage = calculateLoadPercentage(member.currentLoad, member.capacity);
+        const loadFactor = Math.max(0, 1 - loadPercentage / 100);
+        const score = skillMatch * loadFactor;
+        const memberSkillsSet = new Set(member.skills.map(s => s.toLowerCase()));
+        const missingSkills = feature.skillsRequired.filter(skill => !memberSkillsSet.has(skill.toLowerCase()));
+        return {
+            member,
+            score,
+            skillMatch,
+            loadPercentage,
+            availableHours: getAvailableHours(member),
+            missingSkills,
+        };
+    }
+    /**
+     * Rank team members by assignment score for a given feature
+     * Returns top N candidates sorted by score (descending)
+     */
+    rankCandidates(team, feature, topN = 3) {
+        const scores = team.map(member => this.calculateAssignmentScore(member, feature));
+        return scores
+            .sort((a, b) => b.score - a.score)
+            .slice(0, topN);
+    }
+    /**
+     * Generate workload summary for all team members
+     */
+    generateWorkloadSummary(team, features) {
+        return team.map(member => {
+            const assignedFeatures = features
+                .filter(f => f.assignee === member.name)
+                .map(f => f.id);
+            const totalEstimate = features
+                .filter(f => f.assignee === member.name)
+                .reduce((sum, f) => sum + f.estimate, 0);
+            const loadPercentage = calculateLoadPercentage(totalEstimate, member.capacity);
+            const availableHours = getAvailableHours({
+                ...member,
+                currentLoad: totalEstimate,
+            });
+            return {
+                member,
+                assignedFeatures,
+                totalEstimate,
+                loadPercentage,
+                availableHours,
+                isOverallocated: totalEstimate > member.capacity,
+            };
+        });
+    }
+    /**
+     * Find skills that are required but missing from the team
+     */
+    findSkillGaps(team, features) {
+        const teamSkills = new Set(team.flatMap(m => m.skills.map(s => s.toLowerCase())));
+        const skillGaps = new Map();
+        for (const feature of features) {
+            const missingSkills = feature.skillsRequired.filter(skill => !teamSkills.has(skill.toLowerCase()));
+            if (missingSkills.length > 0) {
+                for (const skill of missingSkills) {
+                    if (!skillGaps.has(skill)) {
+                        skillGaps.set(skill, []);
+                    }
+                    skillGaps.get(skill).push(feature.id);
+                }
+            }
+        }
+        return skillGaps;
+    }
+    /**
+     * Find skills with high demand (required by many features but few team members have it)
+     */
+    findHighDemandSkills(team, features) {
+        const skillDemand = new Map(); // skill -> Set of feature IDs
+        const skillSupply = new Map(); // skill -> count of members
+        // Count demand
+        for (const feature of features) {
+            for (const skill of feature.skillsRequired) {
+                const key = skill.toLowerCase();
+                if (!skillDemand.has(key)) {
+                    skillDemand.set(key, new Set());
+                }
+                skillDemand.get(key).add(feature.id);
+            }
+        }
+        // Count supply
+        for (const member of team) {
+            for (const skill of member.skills) {
+                const key = skill.toLowerCase();
+                skillSupply.set(key, (skillSupply.get(key) || 0) + 1);
+            }
+        }
+        // Find high demand skills (demanded by >=3 features, but <=1 member has it)
+        const highDemand = new Map();
+        for (const [skill, featureIds] of skillDemand) {
+            const demandCount = featureIds.size;
+            const memberCount = skillSupply.get(skill) || 0;
+            if (demandCount >= 3 && memberCount <= 1) {
+                highDemand.set(skill, { demandCount, memberCount });
+            }
+        }
+        return highDemand;
+    }
+}
+//# sourceMappingURL=workload.js.map

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './core/project.js';
+export * from './core/team.js';
+export * from './core/workload.js';
+export * from './core/parser.js';
+export * from './core/changelog.js';
+export * from './core/changelog-service.js';
+export * from './core/importers.js';
+export * from './utils/markdown.js';
+export * from './utils/validation.js';
+export type { Epic, Feature, UserStory, Project } from './core/project.js';
+export type { Team, TeamMember } from './core/team.js';
+export type { ChangelogEntry, ChangelogFile, ChangelogQueryOptions } from './core/changelog.js';
+export type { ChangelogService } from './core/changelog-service.js';
+export type { ImportSource, ImportOptions, ImportResult, ImportedEpic, ImportedMilestone, Importer } from './core/importers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,11 @@
+// PMSpec Core Exports
+export * from './core/project.js';
+export * from './core/team.js';
+export * from './core/workload.js';
+export * from './core/parser.js';
+export * from './core/changelog.js';
+export * from './core/changelog-service.js';
+export * from './core/importers.js';
+export * from './utils/markdown.js';
+export * from './utils/validation.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/csv-handler.d.ts

@@ -0,0 +1,15 @@
+import type { SimpleFeature } from '../core/simple-model.js';
+export declare class CSVHandler {
+    static CSV_HEADERS: string[];
+    static parseCSV(content: string): SimpleFeature[];
+    static generateCSV(features: SimpleFeature[]): string;
+    static parseMarkdown(content: string): SimpleFeature[];
+    static generateMarkdown(features: SimpleFeature[]): string;
+    private static parsePriority;
+    private static parseStatus;
+    private static completeFeature;
+    private static generateId;
+    static readFeatures(filePath: string): Promise<SimpleFeature[]>;
+    static writeFeatures(filePath: string, features: SimpleFeature[]): Promise<void>;
+}
+//# sourceMappingURL=csv-handler.d.ts.map

package/dist/utils/csv-handler.js

@@ -0,0 +1,224 @@
+import { readFile, writeFile } from 'fs/promises';
+export class CSVHandler {
+    static CSV_HEADERS = [
+        'ID',
+        '功能名称',
+        '描述',
+        '预估工作量(h)',
+        '分配给',
+        '优先级',
+        '状态',
+        '分组',
+        '标签',
+        '创建日期',
+        '截止日期'
+    ];
+    static parseCSV(content) {
+        const lines = content.trim().split('\n');
+        if (lines.length < 2) {
+            throw new Error('CSV 文件至少需要标题行和一���数据');
+        }
+        const features = [];
+        // 跳过标题行
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            // 简单的 CSV 解析（假设不包含逗号）
+            const fields = line.split(',').map(field => field.trim());
+            if (fields.length >= 7) {
+                features.push({
+                    id: fields[0],
+                    name: fields[1],
+                    description: fields[2],
+                    estimate: parseFloat(fields[3]) || 1,
+                    assignee: fields[4],
+                    priority: this.parsePriority(fields[5]),
+                    status: this.parseStatus(fields[6]),
+                    category: fields[7] || undefined,
+                    tags: fields[8] ? fields[8].split(';').map(t => t.trim()) : [],
+                    createdDate: fields[9] || undefined,
+                    dueDate: fields[10] || undefined,
+                });
+            }
+        }
+        return features;
+    }
+    static generateCSV(features) {
+        const lines = [this.CSV_HEADERS.join(',')];
+        for (const feature of features) {
+            const row = [
+                feature.id,
+                feature.name,
+                feature.description,
+                feature.estimate.toString(),
+                feature.assignee,
+                feature.priority,
+                feature.status,
+                feature.category || '',
+                feature.tags.join(';'),
+                feature.createdDate || '',
+                feature.dueDate || ''
+            ];
+            lines.push(row.join(','));
+        }
+        return lines.join('\n');
+    }
+    static parseMarkdown(content) {
+        const features = [];
+        const lines = content.trim().split('\n');
+        let currentFeature = {};
+        let inFeature = false;
+        for (const line of lines) {
+            if (line.startsWith('# Feature:')) {
+                if (inFeature && currentFeature.id) {
+                    features.push(this.completeFeature(currentFeature));
+                }
+                const name = line.replace('# Feature:', '').trim();
+                currentFeature = {
+                    id: this.generateId(name, features),
+                    name
+                };
+            }
+            else if (line.startsWith('- **描述**:')) {
+                currentFeature.description = line.replace('- **描述**:', '').trim();
+            }
+            else if (line.startsWith('- **预估工作量**:')) {
+                const hours = line.replace('- **预估工作量**:', '').replace('h', '').trim();
+                currentFeature.estimate = parseFloat(hours) || 1;
+            }
+            else if (line.startsWith('- **分配给**:')) {
+                currentFeature.assignee = line.replace('- **分配给**:', '').trim();
+            }
+            else if (line.startsWith('- **优先级**:')) {
+                currentFeature.priority = this.parsePriority(line.replace('- **优先级**:', '').trim());
+            }
+            else if (line.startsWith('- **状态**:')) {
+                currentFeature.status = this.parseStatus(line.replace('- **状态**:', '').trim());
+            }
+            else if (line.startsWith('- **分组**:')) {
+                currentFeature.category = line.replace('- **分组**:', '').trim();
+            }
+            else if (line.startsWith('- **标签**:')) {
+                const tags = line.replace('- **标签**:', '').trim();
+                currentFeature.tags = tags.split(',').map(t => t.trim());
+            }
+        }
+        if (currentFeature.id && currentFeature.name) {
+            features.push(this.completeFeature(currentFeature));
+        }
+        return features;
+    }
+    static generateMarkdown(features) {
+        const lines = ['# 功能列表\n'];
+        for (const feature of features) {
+            lines.push(`\n# Feature: ${feature.name}`);
+            lines.push(`- **ID**: ${feature.id}`);
+            lines.push(`- **描述**: ${feature.description}`);
+            lines.push(`- **预估工作量**: ${feature.estimate}h`);
+            lines.push(`- **分配给**: ${feature.assignee}`);
+            lines.push(`- **优先级**: ${feature.priority}`);
+            lines.push(`- **状态**: ${feature.status}`);
+            if (feature.category) {
+                lines.push(`- **分组**: ${feature.category}`);
+            }
+            if (feature.tags.length > 0) {
+                lines.push(`- **标签**: ${feature.tags.join(', ')}`);
+            }
+            lines.push('---');
+        }
+        return lines.join('\n');
+    }
+    static parsePriority(priority) {
+        const p = priority.toLowerCase();
+        if (['low', '低', 'l'].includes(p))
+            return 'low';
+        if (['medium', '中', 'm'].includes(p))
+            return 'medium';
+        if (['high', '高', 'h'].includes(p))
+            return 'high';
+        if (['critical', '紧急', 'critical', 'c'].includes(p))
+            return 'critical';
+        return 'medium'; // 默认值
+    }
+    static parseStatus(status) {
+        const s = status.toLowerCase();
+        if (['todo', '待办', 't'].includes(s))
+            return 'todo';
+        if (['in-progress', '进行中', 'ip', '进行'].includes(s))
+            return 'in-progress';
+        if (['done', '完成', 'd', '已完成'].includes(s))
+            return 'done';
+        if (['blocked', '阻塞', 'b', '阻塞中'].includes(s))
+            return 'blocked';
+        return 'todo'; // 默认值
+    }
+    static completeFeature(feature) {
+        return {
+            id: feature.id || '',
+            name: feature.name || '',
+            description: feature.description || '',
+            estimate: feature.estimate || 1,
+            assignee: feature.assignee || '未分配',
+            priority: feature.priority || 'medium',
+            status: feature.status || 'todo',
+            category: feature.category,
+            tags: feature.tags || [],
+            createdDate: feature.createdDate,
+            dueDate: feature.dueDate,
+        };
+    }
+    static generateId(name, existing) {
+        const base = name
+            .toLowerCase()
+            .replace(/[^a-z0-9\u4e00-\u9fa5]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        let id = `feat-${base}`;
+        let counter = 1;
+        while (existing.some(f => f.id === id)) {
+            id = `feat-${base}-${counter}`;
+            counter++;
+        }
+        return id;
+    }
+    static async readFeatures(filePath) {
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            if (filePath.endsWith('.csv')) {
+                return this.parseCSV(content);
+            }
+            else if (filePath.endsWith('.md')) {
+                return this.parseMarkdown(content);
+            }
+            else {
+                throw new Error('不支持的文件格式，请使用 .csv 或 .md 文件');
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return []; // 文件不存在，返回空数组
+            }
+            throw error;
+        }
+    }
+    static async writeFeatures(filePath, features) {
+        const featuresTable = {
+            features,
+            lastUpdated: new Date().toISOString(),
+            version: '1.0'
+        };
+        let content;
+        if (filePath.endsWith('.csv')) {
+            content = this.generateCSV(features);
+        }
+        else if (filePath.endsWith('.md')) {
+            content = this.generateMarkdown(features);
+        }
+        else {
+            throw new Error('不支持的文件格式，请使用 .csv 或 .md 文件');
+        }
+        await writeFile(filePath, content, 'utf-8');
+    }
+}
+//# sourceMappingURL=csv-handler.js.map

package/dist/utils/markdown.d.ts

@@ -0,0 +1,43 @@
+import type { Epic, Feature, Project, Milestone } from '../core/project.js';
+import type { Team } from '../core/team.js';
+/**
+ * Generate Epic markdown content
+ */
+export declare function generateEpicMarkdown(epic: Epic): string;
+/**
+ * Generate Feature markdown content
+ */
+export declare function generateFeatureMarkdown(feature: Feature): string;
+/**
+ * Generate Project markdown content
+ */
+export declare function generateProjectMarkdown(project: Project): string;
+/**
+ * Generate Team markdown content
+ */
+export declare function generateTeamMarkdown(team: Team): string;
+/**
+ * Generate Milestone markdown content
+ */
+export declare function generateMilestoneMarkdown(milestone: Milestone): string;
+/**
+ * Write Epic to file
+ */
+export declare function writeEpicFile(filePath: string, epic: Epic): Promise<void>;
+/**
+ * Write Feature to file
+ */
+export declare function writeFeatureFile(filePath: string, feature: Feature): Promise<void>;
+/**
+ * Write Project to file
+ */
+export declare function writeProjectFile(filePath: string, project: Project): Promise<void>;
+/**
+ * Write Team to file
+ */
+export declare function writeTeamFile(filePath: string, team: Team): Promise<void>;
+/**
+ * Write Milestone to file
+ */
+export declare function writeMilestoneFile(filePath: string, milestone: Milestone): Promise<void>;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/utils/markdown.js

@@ -0,0 +1,202 @@
+import { writeFile, mkdir } from 'fs/promises';
+import { dirname } from 'path';
+/**
+ * Generate Epic markdown content
+ */
+export function generateEpicMarkdown(epic) {
+    const lines = [];
+    lines.push(`# Epic: ${epic.title}`);
+    lines.push('');
+    lines.push(`- **ID**: ${epic.id}`);
+    lines.push(`- **Status**: ${epic.status}`);
+    if (epic.owner) {
+        lines.push(`- **Owner**: ${epic.owner}`);
+    }
+    lines.push(`- **Estimate**: ${epic.estimate} hours`);
+    lines.push(`- **Actual**: ${epic.actual} hours`);
+    lines.push('');
+    if (epic.description) {
+        lines.push('## Description');
+        lines.push(epic.description);
+        lines.push('');
+    }
+    if (epic.features.length > 0) {
+        lines.push('## Features');
+        for (const featureId of epic.features) {
+            lines.push(`- [ ] ${featureId}: [Feature title]`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate Feature markdown content
+ */
+export function generateFeatureMarkdown(feature) {
+    const lines = [];
+    lines.push(`# Feature: ${feature.title}`);
+    lines.push('');
+    lines.push(`- **ID**: ${feature.id}`);
+    lines.push(`- **Epic**: ${feature.epicId}`);
+    lines.push(`- **Status**: ${feature.status}`);
+    if (feature.assignee) {
+        lines.push(`- **Assignee**: ${feature.assignee}`);
+    }
+    lines.push(`- **Estimate**: ${feature.estimate} hours`);
+    lines.push(`- **Actual**: ${feature.actual} hours`);
+    if (feature.skillsRequired.length > 0) {
+        lines.push(`- **Skills Required**: ${feature.skillsRequired.join(', ')}`);
+    }
+    lines.push('');
+    if (feature.description) {
+        lines.push('## Description');
+        lines.push(feature.description);
+        lines.push('');
+    }
+    if (feature.userStories.length > 0) {
+        lines.push('## User Stories');
+        for (const story of feature.userStories) {
+            const checkbox = story.status === 'done' ? '[x]' : '[ ]';
+            lines.push(`- ${checkbox} ${story.id}: ${story.title} (${story.estimate}h)`);
+        }
+        lines.push('');
+    }
+    if (feature.acceptanceCriteria.length > 0) {
+        lines.push('## Acceptance Criteria');
+        for (const criterion of feature.acceptanceCriteria) {
+            lines.push(`- [ ] ${criterion}`);
+        }
+        lines.push('');
+    }
+    if (feature.dependencies && feature.dependencies.length > 0) {
+        lines.push('## Dependencies');
+        const blocks = feature.dependencies.filter(d => d.type === 'blocks').map(d => d.featureId);
+        const relatesTo = feature.dependencies.filter(d => d.type === 'relates-to').map(d => d.featureId);
+        if (blocks.length > 0) {
+            lines.push(`- blocks: ${blocks.join(', ')}`);
+        }
+        if (relatesTo.length > 0) {
+            lines.push(`- relates-to: ${relatesTo.join(', ')}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate Project markdown content
+ */
+export function generateProjectMarkdown(project) {
+    const lines = [];
+    lines.push(`# Project: ${project.name}`);
+    lines.push('');
+    if (project.overview) {
+        lines.push('## Overview');
+        lines.push(project.overview);
+        lines.push('');
+    }
+    if (project.timeline) {
+        lines.push('## Timeline');
+        if (project.timeline.start) {
+            lines.push(`- Start: ${project.timeline.start}`);
+        }
+        if (project.timeline.end) {
+            lines.push(`- End: ${project.timeline.end}`);
+        }
+        lines.push('');
+    }
+    if (project.teamCapacity) {
+        lines.push('## Team Capacity');
+        if (project.teamCapacity.total !== undefined) {
+            lines.push(`- Total: ${project.teamCapacity.total} person-weeks`);
+        }
+        if (project.teamCapacity.available !== undefined) {
+            lines.push(`- Available: ${project.teamCapacity.available} person-weeks`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate Team markdown content
+ */
+export function generateTeamMarkdown(team) {
+    const lines = [];
+    lines.push('# Team');
+    lines.push('');
+    lines.push('## Members');
+    lines.push('');
+    for (const member of team.members) {
+        lines.push(`### ${member.name}`);
+        lines.push(`- **Skills**: ${member.skills.join(', ')}`);
+        lines.push(`- **Capacity**: ${member.capacity} hours/week`);
+        lines.push(`- **Current Load**: ${member.currentLoad} hours/week`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate Milestone markdown content
+ */
+export function generateMilestoneMarkdown(milestone) {
+    const lines = [];
+    lines.push(`# Milestone: ${milestone.title}`);
+    lines.push('');
+    lines.push(`- **ID**: ${milestone.id}`);
+    lines.push(`- **Target Date**: ${milestone.targetDate}`);
+    lines.push(`- **Status**: ${milestone.status}`);
+    lines.push('');
+    if (milestone.description) {
+        lines.push('## Description');
+        lines.push(milestone.description);
+        lines.push('');
+    }
+    if (milestone.features.length > 0) {
+        lines.push('## Features');
+        for (const featureId of milestone.features) {
+            lines.push(`- [ ] ${featureId}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Write Epic to file
+ */
+export async function writeEpicFile(filePath, epic) {
+    const content = generateEpicMarkdown(epic);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
+}
+/**
+ * Write Feature to file
+ */
+export async function writeFeatureFile(filePath, feature) {
+    const content = generateFeatureMarkdown(feature);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
+}
+/**
+ * Write Project to file
+ */
+export async function writeProjectFile(filePath, project) {
+    const content = generateProjectMarkdown(project);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
+}
+/**
+ * Write Team to file
+ */
+export async function writeTeamFile(filePath, team) {
+    const content = generateTeamMarkdown(team);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
+}
+/**
+ * Write Milestone to file
+ */
+export async function writeMilestoneFile(filePath, milestone) {
+    const content = generateMilestoneMarkdown(milestone);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
+}
+//# sourceMappingURL=markdown.js.map

package/dist/utils/validation.d.ts

@@ -0,0 +1,35 @@
+import type { Epic, Feature } from '../core/project.js';
+import type { Team } from '../core/team.js';
+export interface ValidationIssue {
+    level: 'ERROR' | 'WARNING';
+    message: string;
+    location?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+}
+/**
+ * Check that all feature dependencies reference existing features
+ */
+export declare function validateDependencies(features: Feature[]): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Detect circular dependencies among features
+ * Uses depth-first search to find cycles
+ */
+export declare function detectCircularDependencies(features: Feature[]): {
+    hasCycle: boolean;
+    cycles: string[][];
+};
+/**
+ * Validate entire project structure
+ */
+export declare function validateProject(epics: Epic[], features: Feature[], team?: Team): ValidationResult;
+/**
+ * Format validation issues for display
+ */
+export declare function formatValidationIssues(result: ValidationResult): string;
+//# sourceMappingURL=validation.d.ts.map