@lusipad/pmspec 1.0.0

package/dist/commands/simple.js

@@ -0,0 +1,360 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { CSVHandler } from '../utils/csv-handler.js';
+const simpleCommand = new Command('simple')
+    .description('简化的项目管理 - 只维护一个功能表')
+    .option('--format <format>', '输出格式: csv, md', 'csv')
+    .option('--output <file>', '输出文件路径', 'features')
+    .action(async (options, command) => {
+    try {
+        const filePath = `${options.output}.${options.format}`;
+        if (options.format === 'csv') {
+            await createCSVTemplate(filePath);
+        }
+        else if (options.format === 'md') {
+            await createMarkdownTemplate(filePath);
+        }
+        else {
+            console.error(chalk.red('错误: 格式必须是 csv 或 md'));
+            process.exit(1);
+        }
+        console.log(chalk.green(`✓ 已创建模板文件: ${filePath}`));
+        console.log(chalk.yellow('请编辑文件添加功能，然后使用 AI 生成项目结构'));
+    }
+    catch (error) {
+        console.error(chalk.red('错误:'), error.message);
+        process.exit(1);
+    }
+});
+// 生成命令
+const generateCommand = new Command('generate')
+    .description('从功能表生成项目结构')
+    .option('--input <file>', '功能表文件路径', 'features.csv')
+    .option('--output <dir>', '输出目录', 'generated')
+    .option('--interactive', '交互式 AI 生成')
+    .action(async (options, command) => {
+    try {
+        const features = await CSVHandler.readFeatures(options.input);
+        if (features.length === 0) {
+            console.log(chalk.yellow('警告: 没有找到功能数据'));
+            return;
+        }
+        console.log(chalk.blue(`📊 读取到 ${features.length} 个功能`));
+        // 显示功能统计
+        displayFeaturesSummary(features);
+        if (options.interactive) {
+            // 生成 AI prompt
+            await generateAIPrompt(features, options.input);
+        }
+        else {
+            // 简单的本地生成（不使用 AI）
+            await generateProjectStructure(features, options.output);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('错误:'), error.message);
+        process.exit(1);
+    }
+});
+// 列表命令
+const listCommand = new Command('list')
+    .description('显示功能列表')
+    .option('--input <file>', '功能表文件路径', 'features.csv')
+    .option('--assignee <name>', '按分配人筛选')
+    .option('--status <status>', '按状态筛选')
+    .option('--priority <priority>', '按优先级筛选')
+    .action(async (options, command) => {
+    try {
+        const features = await CSVHandler.readFeatures(options.input);
+        let filteredFeatures = features;
+        if (options.assignee) {
+            filteredFeatures = filteredFeatures.filter(f => f.assignee.toLowerCase().includes(options.assignee.toLowerCase()));
+        }
+        if (options.status) {
+            filteredFeatures = filteredFeatures.filter(f => f.status === options.status);
+        }
+        if (options.priority) {
+            filteredFeatures = filteredFeatures.filter(f => f.priority === options.priority);
+        }
+        if (filteredFeatures.length === 0) {
+            console.log(chalk.yellow('没有找到匹配的功能'));
+            return;
+        }
+        displayFeaturesTable(filteredFeatures);
+    }
+    catch (error) {
+        console.error(chalk.red('错误:'), error.message);
+        process.exit(1);
+    }
+});
+// 统计命令
+const statsCommand = new Command('stats')
+    .description('显示项目统计信息')
+    .option('--input <file>', '功能表文件路径', 'features.csv')
+    .action(async (options, command) => {
+    try {
+        const features = await CSVHandler.readFeatures(options.input);
+        if (features.length === 0) {
+            console.log(chalk.yellow('没有功能数据'));
+            return;
+        }
+        displayStatistics(features);
+    }
+    catch (error) {
+        console.error(chalk.red('错误:'), error.message);
+        process.exit(1);
+    }
+});
+function displayFeaturesTable(features) {
+    console.log(chalk.blue.bold('\n📋 功能列表\n'));
+    // 计算列宽
+    const maxWidths = {
+        id: Math.max(8, ...features.map(f => f.id.length)),
+        name: Math.max(8, ...features.map(f => f.name.length)),
+        assignee: Math.max(6, ...features.map(f => f.assignee.length)),
+        priority: 8,
+        status: 8,
+        estimate: 8
+    };
+    // 表头
+    const header = `│ ${pad('ID', maxWidths.id)} │ ${pad('功能名称', maxWidths.name)} │ ${pad('分配给', maxWidths.assignee)} │ ${pad('优先级', maxWidths.priority)} │ ${pad('状态', maxWidths.status)} │ ${pad('工时', maxWidths.estimate)} │`;
+    const separator = `├${pad('', maxWidths.id + 2, '─')}┼${pad('', maxWidths.name + 2, '─')}┼${pad('', maxWidths.assignee + 2, '─')}┼${pad('', maxWidths.priority + 2, '─')}┼${pad('', maxWidths.status + 2, '─')}┼${pad('', maxWidths.estimate + 2, '─')}┤`;
+    console.log(header);
+    console.log(separator);
+    // 数据行
+    for (const feature of features) {
+        const priorityColor = getPriorityColor(feature.priority);
+        const statusColor = getStatusColor(feature.status);
+        const row = `│ ${pad(feature.id, maxWidths.id)} │ ${pad(feature.name, maxWidths.name)} │ ${pad(feature.assignee, maxWidths.assignee)} │ ${priorityColor(pad(feature.priority, maxWidths.priority))} │ ${statusColor(pad(feature.status, maxWidths.status))} │ ${pad(feature.estimate + 'h', maxWidths.estimate)} │`;
+        console.log(row);
+    }
+    console.log(`\n总计: ${features.length} 个功能`);
+}
+function displayStatistics(features) {
+    console.log(chalk.blue.bold('\n📊 项目统计\n'));
+    // 基础统计
+    const totalFeatures = features.length;
+    const totalHours = features.reduce((sum, f) => sum + f.estimate, 0);
+    const completedFeatures = features.filter(f => f.status === 'done').length;
+    const completionRate = ((completedFeatures / totalFeatures) * 100).toFixed(1);
+    console.log(`总功能数: ${totalFeatures}`);
+    console.log(`预估总工时: ${totalHours}h`);
+    console.log(`已完成: ${completedFeatures} (${completionRate}%)`);
+    // 按状态统计
+    console.log(chalk.yellow('\n按状态统计:'));
+    const statusStats = new Map();
+    features.forEach(f => {
+        statusStats.set(f.status, (statusStats.get(f.status) || 0) + 1);
+    });
+    for (const [status, count] of statusStats) {
+        const color = getStatusColor(status);
+        console.log(`${color(status)}: ${count}`);
+    }
+    // 按优先级统计
+    console.log(chalk.yellow('\n按优先级统计:'));
+    const priorityStats = new Map();
+    features.forEach(f => {
+        priorityStats.set(f.priority, (priorityStats.get(f.priority) || 0) + 1);
+    });
+    for (const [priority, count] of priorityStats) {
+        const color = getPriorityColor(priority);
+        console.log(`${color(priority)}: ${count}`);
+    }
+    // 按人员统计
+    console.log(chalk.yellow('\n按人员统计:'));
+    const assigneeStats = new Map();
+    features.forEach(f => {
+        const current = assigneeStats.get(f.assignee) || { count: 0, hours: 0 };
+        assigneeStats.set(f.assignee, {
+            count: current.count + 1,
+            hours: current.hours + f.estimate
+        });
+    });
+    for (const [assignee, stats] of assigneeStats) {
+        console.log(`${assignee}: ${stats.count} 个功能, ${stats.hours}h`);
+    }
+}
+function pad(text, width, fillChar = ' ') {
+    return (text + fillChar.repeat(width)).slice(0, width);
+}
+function getPriorityColor(priority) {
+    switch (priority) {
+        case 'critical': return (text) => chalk.red(text);
+        case 'high': return (text) => chalk.yellow(text);
+        case 'medium': return (text) => chalk.blue(text);
+        case 'low': return (text) => chalk.gray(text);
+        default: return (text) => text;
+    }
+}
+function getStatusColor(status) {
+    switch (status) {
+        case 'done': return (text) => chalk.green(text);
+        case 'in-progress': return (text) => chalk.blue(text);
+        case 'blocked': return (text) => chalk.red(text);
+        case 'todo': return (text) => chalk.gray(text);
+        default: return (text) => text;
+    }
+}
+async function createCSVTemplate(filePath) {
+    const template = `ID,功能名称,描述,预估工作量(h),分配给,优先级,状态,分组,标签,创建日期,截止日期
+feat-001,用户登录功能,实现用户登录、注册和密码重置功能,16,Alice,high,todo,认证,React;Node.js,2024-01-01,2024-01-15
+feat-002,商品展示功能,展示商品列表、详情和搜索功能,20,Bob,medium,todo,电商,React;CSS,2024-01-01,2024-01-20`;
+    await CSVHandler.writeFeatures(filePath, CSVHandler.parseCSV(template));
+}
+async function createMarkdownTemplate(filePath) {
+    const template = `# 功能列表
+
+# Feature: 用户登录功能
+- **ID**: feat-001
+- **描述**: 实现用户登录、注册和密码重置功能
+- **预估工作量**: 16h
+- **分配给**: Alice
+- **优先级**: high
+- **状态**: todo
+- **分组**: 认证
+- **标签**: React, Node.js
+- **创建日期**: 2024-01-01
+- **截止日期**: 2024-01-15
+
+---
+
+# Feature: 商品展示功能
+- **ID**: feat-002
+- **描述**: 展示商品列表、详情和搜索功能
+- **预估工作量**: 20h
+- **分配给**: Bob
+- **优先级**: medium
+- **状态**: todo
+- **分组**: 电商
+- **标签**: React, CSS
+- **创建��期**: 2024-01-01
+- **截止日期**: 2024-01-20`;
+    await CSVHandler.writeFeatures(filePath, CSVHandler.parseMarkdown(template));
+}
+function displayFeaturesSummary(features) {
+    console.log(chalk.blue('\n📋 功能概览\n'));
+    // 基础统计
+    const totalHours = features.reduce((sum, f) => sum + f.estimate, 0);
+    const categories = new Set(features.map(f => f.category).filter(Boolean));
+    const assignees = new Set(features.map(f => f.assignee));
+    console.log(`总功能数: ${features.length}`);
+    console.log(`总预估工时: ${totalHours}h`);
+    console.log(`涉及领域: ${categories.size} 个`);
+    console.log(`涉及人员: ${assignees.size} 个`);
+    // 按分组显示
+    console.log(chalk.yellow('\n按分组统计:'));
+    const categoryStats = new Map();
+    features.forEach(f => {
+        if (f.category) {
+            if (!categoryStats.has(f.category)) {
+                categoryStats.set(f.category, []);
+            }
+            categoryStats.get(f.category).push(f);
+        }
+    });
+    for (const [category, categoryFeatures] of categoryStats) {
+        const categoryHours = categoryFeatures.reduce((sum, f) => sum + f.estimate, 0);
+        console.log(`${category}: ${categoryFeatures.length} 个功能, ${categoryHours}h`);
+    }
+    // 未分类的功能
+    const uncategorized = features.filter(f => !f.category);
+    if (uncategorized.length > 0) {
+        const uncategorizedHours = uncategorized.reduce((sum, f) => sum + f.estimate, 0);
+        console.log(`未分类: ${uncategorized.length} 个功能, ${uncategorizedHours}h`);
+    }
+}
+async function generateAIPrompt(features, inputFile) {
+    const featuresData = features.map(f => `${f.id},${f.name},${f.description},${f.estimate}h,${f.assignee},${f.priority},${f.status},${f.category || ''},${f.tags.join(';')},${f.createdDate || ''},${f.dueDate || ''}`).join('\n');
+    const prompt = `# PMSpec 项目结构生成
+
+根据功能表自动生成完整的项目结构，包括 Epic 分组、User Stories、技术文档等。
+
+## 功能表数据
+
+${featuresData}
+
+## 输出格式
+
+请根据功能表生成以下内容：
+
+### 1. Epic 分组
+将相关功能分组为 Epic，每组功能形成一个 Epic 文件。
+
+### 2. User Stories
+为每个 Feature 生成详细的 User Stories。
+
+### 3. 项目文档
+- 项目概览
+- 团队结构
+- 时间线规划
+
+## 生成指导原则
+
+1. **Epic 分组原则**：
+   - 按业务领域或功能模块分组
+   - 每个 Epic 包含 2-5 个相关 Feature
+   - Epic 名称要体现业务价值
+
+2. **User Story 原则**：
+   - 每个 Feature 生成 2-4 个 User Stories
+   - Story 要体现用户价值
+   - 估算工时要合理（1-8 小时）
+
+3. **技术文档原则**：
+   - 基于功能的技术要求生成技能列表
+   - 考虑依赖关系和实施顺序
+   - 提供清晰的验收标准
+
+请按照以下格式输出：
+
+\`\`\`markdown
+## Epic 分组结果
+
+### Epic: [Epic 名称]
+- **包含功能**: [功能1, 功能2]
+- **预估工时**: [总工时]h
+- **业务价值**: [描述]
+
+## 详细 User Stories
+
+### [Feature 名称]
+- **Epic**: [所属 Epic]
+- **User Stories**:
+  - STORY-XXX: As [用户], I want [功能] so that [价值] ([工时]h)
+  - STORY-XXX: As [用户], I want [功能] so that [价值] ([工时]h)
+
+## 技术分析
+
+### 技能需求
+- [技能1]: [需要的人数]
+- [技能2]: [需要的人数]
+
+### 实施建议
+1. [实施步骤1]
+2. [实施步骤2]
+3. [实施步骤3]
+
+### 风险提示
+- [风险1]: [影响]
+- [风险2]: [影响]
+\`\`\``;
+    console.log(chalk.yellow('\n🤖 AI 生成提示已准备'));
+    console.log(chalk.cyan('─'.repeat(50)));
+    console.log(chalk.blue('请在 Claude 中运行以下命令：'));
+    console.log(chalk.cyan('/pmspec-generate'));
+    console.log(chalk.cyan('然后将上面的提示内容粘贴到 Claude 中'));
+    console.log(chalk.cyan('─'.repeat(50)));
+    console.log(chalk.yellow('\n💡 提示：'));
+    console.log(chalk.gray('1. 你可以将上面的提示内容保存到文件中'));
+    console.log(chalk.gray('2. AI 生成完成后，可以手动或使用脚本创建文件'));
+    console.log(chalk.gray('3. 建议先在小范围内测试生成的结构'));
+}
+async function generateProjectStructure(features, outputDir) {
+    // 简单的本地生成逻辑（不使用 AI）
+    console.log(chalk.yellow('\n📝 本地生成模式（非 AI）'));
+    // 这里可以实现简单的规则生成逻辑
+    // 但主要还是推荐使用 AI 生成
+    console.log(chalk.gray('提示：使用 --interactive 选项可以获得更好的 AI 生成结果'));
+}
+export { simpleCommand, generateCommand, listCommand, statsCommand };
+//# sourceMappingURL=simple.js.map

package/dist/commands/update.d.ts

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

package/dist/commands/update.js

@@ -0,0 +1,247 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readEpicFile, readFeatureFile } from '../core/parser.js';
+import { writeEpicFile, writeFeatureFile } from '../utils/markdown.js';
+import { EpicStatus, FeatureStatus, StoryStatus } from '../core/project.js';
+import { join } from 'path';
+import { getChangelogService } from '../core/changelog-service.js';
+const updateCommand = new Command('update')
+    .description('Update status, actual hours, or assignee of existing items')
+    .argument('<id>', 'ID of Epic, Feature, or Story to update')
+    .option('-s, --status <status>', 'Update status')
+    .option('-a, --actual <hours>', 'Update actual hours')
+    .option('--assignee <name>', 'Update assignee (for Features)')
+    .action(async (id, options, command) => {
+    try {
+        // Determine item type from ID
+        const itemType = getItemType(id);
+        if (itemType === 'epic') {
+            await updateEpic(id, options);
+        }
+        else if (itemType === 'feature') {
+            await updateFeature(id, options);
+        }
+        else if (itemType === 'story') {
+            await updateStory(id, options);
+        }
+        else {
+            console.error(chalk.red(`Error: Invalid ID format: ${id}`));
+            console.error(chalk.yellow('Expected format: EPIC-001, FEAT-001, or STORY-001'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+});
+function getItemType(id) {
+    if (id.startsWith('EPIC-'))
+        return 'epic';
+    if (id.startsWith('FEAT-'))
+        return 'feature';
+    if (id.startsWith('STORY-'))
+        return 'story';
+    return null;
+}
+async function updateEpic(id, options) {
+    const filePath = `pmspace/epics/${id.toLowerCase()}.md`;
+    try {
+        const epic = await readEpicFile(filePath);
+        let changed = false;
+        const changes = {};
+        // Update status
+        if (options.status) {
+            if (!EpicStatus.options.includes(options.status)) {
+                console.error(chalk.red(`Error: Invalid status "${options.status}" for Epic`));
+                console.error(chalk.yellow('Valid statuses:', EpicStatus.options.join(', ')));
+                process.exit(1);
+            }
+            changes.status = { oldValue: epic.status, newValue: options.status };
+            epic.status = options.status;
+            changed = true;
+            console.log(chalk.green(`✓ Updated ${id} status to ${options.status}`));
+        }
+        // Update actual hours
+        if (options.actual !== undefined) {
+            const actualHours = parseFloat(options.actual);
+            if (isNaN(actualHours) || actualHours < 0) {
+                console.error(chalk.red('Error: Actual hours must be a non-negative number'));
+                process.exit(1);
+            }
+            changes.actual = { oldValue: epic.actual, newValue: actualHours };
+            epic.actual = actualHours;
+            changed = true;
+            // Calculate variance
+            const variance = epic.actual - epic.estimate;
+            const variancePercent = ((variance / epic.estimate) * 100).toFixed(1);
+            const varianceStr = variance >= 0 ? `+${variance}h (+${variancePercent}%)` : `${variance}h (${variancePercent}%)`;
+            console.log(chalk.green(`✓ Updated ${id} actual hours to ${actualHours}h`));
+            console.log(chalk.blue(`  Estimate: ${epic.estimate}h, Actual: ${epic.actual}h, Variance: ${varianceStr}`));
+        }
+        // Warn about unsupported options for epics
+        if (options.assignee) {
+            console.log(chalk.yellow(`Warning: Assignee cannot be set on Epics (use Features instead)`));
+        }
+        if (changed) {
+            await writeEpicFile(filePath, epic);
+            // Record changelog entries
+            try {
+                await getChangelogService().recordUpdates('epic', id, changes);
+            }
+            catch {
+                // Silently fail if changelog can't be written
+            }
+        }
+        else {
+            console.log(chalk.yellow('No changes specified. Use --status, --actual, or --assignee'));
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            console.error(chalk.red(`Error: Epic ${id} not found`));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function updateFeature(id, options) {
+    const filePath = `pmspace/features/${id.toLowerCase()}.md`;
+    try {
+        const feature = await readFeatureFile(filePath);
+        let changed = false;
+        const changes = {};
+        // Update status
+        if (options.status) {
+            if (!FeatureStatus.options.includes(options.status)) {
+                console.error(chalk.red(`Error: Invalid status "${options.status}" for Feature`));
+                console.error(chalk.yellow('Valid statuses:', FeatureStatus.options.join(', ')));
+                process.exit(1);
+            }
+            changes.status = { oldValue: feature.status, newValue: options.status };
+            feature.status = options.status;
+            changed = true;
+            console.log(chalk.green(`✓ Updated ${id} status to ${options.status}`));
+        }
+        // Update actual hours
+        if (options.actual !== undefined) {
+            const actualHours = parseFloat(options.actual);
+            if (isNaN(actualHours) || actualHours < 0) {
+                console.error(chalk.red('Error: Actual hours must be a non-negative number'));
+                process.exit(1);
+            }
+            changes.actual = { oldValue: feature.actual, newValue: actualHours };
+            feature.actual = actualHours;
+            changed = true;
+            // Calculate variance
+            const variance = feature.actual - feature.estimate;
+            const variancePercent = ((variance / feature.estimate) * 100).toFixed(1);
+            const varianceStr = variance >= 0 ? `+${variance}h (+${variancePercent}%)` : `${variance}h (${variancePercent}%)`;
+            console.log(chalk.green(`✓ Updated ${id} actual hours to ${actualHours}h`));
+            console.log(chalk.blue(`  Estimate: ${feature.estimate}h, Actual: ${feature.actual}h, Variance: ${varianceStr}`));
+        }
+        // Update assignee
+        if (options.assignee !== undefined) {
+            changes.assignee = { oldValue: feature.assignee, newValue: options.assignee || undefined };
+            feature.assignee = options.assignee || undefined;
+            changed = true;
+            if (feature.assignee) {
+                console.log(chalk.green(`✓ Updated ${id} assignee to ${feature.assignee}`));
+            }
+            else {
+                console.log(chalk.green(`✓ Removed assignee from ${id}`));
+            }
+        }
+        if (changed) {
+            await writeFeatureFile(filePath, feature);
+            // Record changelog entries
+            try {
+                await getChangelogService().recordUpdates('feature', id, changes);
+            }
+            catch {
+                // Silently fail if changelog can't be written
+            }
+        }
+        else {
+            console.log(chalk.yellow('No changes specified. Use --status, --actual, or --assignee'));
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            console.error(chalk.red(`Error: Feature ${id} not found`));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function updateStory(id, options) {
+    // Find the feature that contains this story
+    let found = false;
+    let featurePath = '';
+    let feature = null;
+    let storyIndex = -1;
+    try {
+        const featureFiles = await import('fs/promises').then(fs => fs.readdir('pmspace/features'));
+        for (const file of featureFiles) {
+            if (file.endsWith('.md')) {
+                const path = join('pmspace/features', file);
+                const f = await readFeatureFile(path);
+                const storyIdx = f.userStories.findIndex((s) => s.id === id);
+                if (storyIdx !== -1) {
+                    found = true;
+                    featurePath = path;
+                    feature = f;
+                    storyIndex = storyIdx;
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist
+    }
+    if (!found) {
+        console.error(chalk.red(`Error: Story ${id} not found`));
+        process.exit(1);
+    }
+    let changed = false;
+    const story = feature.userStories[storyIndex];
+    const changes = {};
+    // Update status
+    if (options.status) {
+        if (!StoryStatus.options.includes(options.status)) {
+            console.error(chalk.red(`Error: Invalid status "${options.status}" for Story`));
+            console.error(chalk.yellow('Valid statuses:', StoryStatus.options.join(', ')));
+            process.exit(1);
+        }
+        changes.status = { oldValue: story.status, newValue: options.status };
+        story.status = options.status;
+        changed = true;
+        console.log(chalk.green(`✓ Updated ${id} status to ${options.status}`));
+    }
+    // Update actual hours (stories don't have actual hours in our model)
+    if (options.actual !== undefined) {
+        console.log(chalk.yellow(`Warning: Stories don't track actual hours (use Feature instead)`));
+    }
+    // Warn about unsupported options for stories
+    if (options.assignee) {
+        console.log(chalk.yellow(`Warning: Assignee cannot be set on Stories (use Features instead)`));
+    }
+    if (changed) {
+        await writeFeatureFile(featurePath, feature);
+        // Record changelog entries
+        try {
+            await getChangelogService().recordUpdates('story', id, changes);
+        }
+        catch {
+            // Silently fail if changelog can't be written
+        }
+    }
+    else {
+        console.log(chalk.yellow('No changes specified. Use --status for stories'));
+    }
+}
+export { updateCommand };
+//# sourceMappingURL=update.js.map

package/dist/commands/validate.d.ts

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

package/dist/commands/validate.js

@@ -0,0 +1,74 @@
+import { Command } from 'commander';
+import { readdir } from 'fs/promises';
+import { join } from 'path';
+import chalk from 'chalk';
+import { readEpicFile, readFeatureFile, readTeamFile } from '../core/parser.js';
+import { validateProject, formatValidationIssues } from '../utils/validation.js';
+export const validateCommand = new Command('validate')
+    .description('Validate project structure and data integrity')
+    .argument('[id]', 'Optional: validate specific Epic or Feature')
+    .action(async (id) => {
+    const pmspaceDir = join(process.cwd(), 'pmspace');
+    try {
+        if (id) {
+            await validateSpecific(pmspaceDir, id);
+        }
+        else {
+            await validateAll(pmspaceDir);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+});
+async function validateAll(pmspaceDir) {
+    console.log(chalk.cyan('Validating project...\n'));
+    // Read all Epics
+    const epicsDir = join(pmspaceDir, 'epics');
+    const epicFiles = await readdir(epicsDir);
+    const epics = [];
+    for (const file of epicFiles.filter(f => f.endsWith('.md'))) {
+        const epic = await readEpicFile(join(epicsDir, file));
+        epics.push(epic);
+    }
+    // Read all Features
+    const featuresDir = join(pmspaceDir, 'features');
+    const featureFiles = await readdir(featuresDir);
+    const features = [];
+    for (const file of featureFiles.filter(f => f.endsWith('.md'))) {
+        const feature = await readFeatureFile(join(featuresDir, file));
+        features.push(feature);
+    }
+    // Read Team (optional)
+    let team;
+    try {
+        team = await readTeamFile(join(pmspaceDir, 'team.md'));
+    }
+    catch {
+        // Team file not required
+    }
+    // Validate
+    const result = validateProject(epics, features, team);
+    console.log(formatValidationIssues(result));
+    if (!result.valid) {
+        process.exit(1);
+    }
+}
+async function validateSpecific(pmspaceDir, id) {
+    if (id.startsWith('EPIC-')) {
+        const filePath = join(pmspaceDir, 'epics', `${id.toLowerCase()}.md`);
+        const epic = await readEpicFile(filePath);
+        console.log(chalk.green(`✓ ${epic.id} is valid`));
+    }
+    else if (id.startsWith('FEAT-')) {
+        const filePath = join(pmspaceDir, 'features', `${id.toLowerCase()}.md`);
+        const feature = await readFeatureFile(filePath);
+        console.log(chalk.green(`✓ ${feature.id} is valid`));
+    }
+    else {
+        console.error(chalk.red(`Invalid ID: ${id}`));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=validate.js.map