@lusipad/pmspec 1.0.0

package/dist/commands/create.js

@@ -0,0 +1,529 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { mkdir, readdir } from 'fs/promises';
+import { join } from 'path';
+import { EpicSchema, FeatureSchema, UserStorySchema, MilestoneSchema, generateNextId } from '../core/project.js';
+import { writeEpicFile, writeFeatureFile, writeMilestoneFile } from '../utils/markdown.js';
+import { readEpicFile, readFeatureFile, readMilestoneFile } from '../core/parser.js';
+import { getChangelogService } from '../core/changelog-service.js';
+const createCommand = new Command('create')
+    .description('Create new Epic, Feature, User Story, or Milestone')
+    .argument('<type>', 'Type of item to create (epic, feature, story, milestone)')
+    .option('-e, --epic <id>', 'Epic ID for Feature (required for feature)')
+    .option('-f, --feature <id>', 'Feature ID for Story (required for story)')
+    .option('--non-interactive', 'Skip prompts and use defaults')
+    .action(async (type, options, command) => {
+    try {
+        type = type.toLowerCase();
+        if (!['epic', 'feature', 'story', 'milestone'].includes(type)) {
+            console.error(chalk.red('Error: Type must be epic, feature, story, or milestone'));
+            process.exit(1);
+        }
+        // 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);
+        }
+        if (type === 'epic') {
+            await createEpic(options.nonInteractive);
+        }
+        else if (type === 'feature') {
+            await createFeature(options.epic, options.nonInteractive);
+        }
+        else if (type === 'story') {
+            await createStory(options.feature, options.nonInteractive);
+        }
+        else if (type === 'milestone') {
+            await createMilestone(options.nonInteractive);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+});
+async function createEpic(nonInteractive) {
+    // Get existing epics to determine next ID
+    let existingEpics = [];
+    try {
+        const epicFiles = await readdir('pmspace/epics');
+        for (const file of epicFiles) {
+            if (file.endsWith('.md')) {
+                const content = await readEpicFile(join('pmspace/epics', file));
+                existingEpics.push(content.id);
+            }
+        }
+    }
+    catch {
+        // Directory might not exist or be empty
+    }
+    const epicId = generateNextId('EPIC', existingEpics);
+    if (nonInteractive) {
+        const epic = EpicSchema.parse({
+            id: epicId,
+            title: 'New Epic',
+            status: 'planning',
+            estimate: 40,
+            description: 'Epic description',
+            features: []
+        });
+        await writeEpicFile(`pmspace/epics/${epicId.toLowerCase()}.md`, epic);
+        // Record changelog entry
+        try {
+            await getChangelogService().recordCreate('epic', epicId);
+        }
+        catch {
+            // Silently fail if changelog can't be written
+        }
+        console.log(chalk.green(`✓ Created Epic ${epicId}`));
+        return;
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'title',
+            message: 'Epic title:',
+            validate: (input) => input.trim() !== '' || 'Title is required'
+        },
+        {
+            type: 'list',
+            name: 'status',
+            message: 'Status:',
+            choices: ['planning', 'in-progress', 'completed'],
+            default: 'planning'
+        },
+        {
+            type: 'input',
+            name: 'owner',
+            message: 'Owner (optional):'
+        },
+        {
+            type: 'number',
+            name: 'estimate',
+            message: 'Estimate (hours):',
+            validate: (input) => input > 0 || 'Estimate must be positive',
+            default: 40
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description (optional):'
+        }
+    ]);
+    const epic = EpicSchema.parse({
+        id: epicId,
+        title: answers.title.trim(),
+        status: answers.status,
+        owner: answers.owner?.trim() || undefined,
+        estimate: answers.estimate,
+        description: answers.description?.trim() || undefined,
+        features: []
+    });
+    await writeEpicFile(`pmspace/epics/${epicId.toLowerCase()}.md`, epic);
+    // Record changelog entry
+    try {
+        await getChangelogService().recordCreate('epic', epicId);
+    }
+    catch {
+        // Silently fail if changelog can't be written
+    }
+    console.log(chalk.green(`✓ Created Epic ${epicId}: ${epic.title}`));
+}
+async function createFeature(epicId, nonInteractive) {
+    if (!epicId) {
+        if (nonInteractive) {
+            console.error(chalk.red('Error: Epic ID is required for feature creation'));
+            process.exit(1);
+        }
+        // Get existing epics for selection
+        const epics = [];
+        try {
+            const epicFiles = await readdir('pmspace/epics');
+            for (const file of epicFiles) {
+                if (file.endsWith('.md')) {
+                    const content = await readEpicFile(join('pmspace/epics', file));
+                    epics.push({ id: content.id, title: content.title });
+                }
+            }
+        }
+        catch {
+            console.error(chalk.red('Error: No epics found. Create an epic first.'));
+            process.exit(1);
+        }
+        if (epics.length === 0) {
+            console.error(chalk.red('Error: No epics found. Create an epic first.'));
+            process.exit(1);
+        }
+        const answer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'epicId',
+                message: 'Select Epic:',
+                choices: epics.map(e => ({ name: `${e.id}: ${e.title}`, value: e.id }))
+            }
+        ]);
+        epicId = answer.epicId;
+    }
+    // Validate epic exists
+    try {
+        await readEpicFile(`pmspace/epics/${epicId.toLowerCase()}.md`);
+    }
+    catch {
+        console.error(chalk.red(`Error: Epic ${epicId} not found`));
+        process.exit(1);
+    }
+    // Get existing features to determine next ID
+    let existingFeatures = [];
+    try {
+        const featureFiles = await readdir('pmspace/features');
+        for (const file of featureFiles) {
+            if (file.endsWith('.md')) {
+                const content = await readFeatureFile(join('pmspace/features', file));
+                existingFeatures.push(content.id);
+            }
+        }
+    }
+    catch {
+        // Directory might not exist or be empty
+    }
+    const featureId = generateNextId('FEAT', existingFeatures);
+    if (nonInteractive) {
+        const feature = FeatureSchema.parse({
+            id: featureId,
+            title: 'New Feature',
+            epicId: epicId,
+            status: 'todo',
+            estimate: 16,
+            skillsRequired: [],
+            description: 'Feature description',
+            userStories: [],
+            acceptanceCriteria: []
+        });
+        await writeFeatureFile(`pmspace/features/${featureId.toLowerCase()}.md`, feature);
+        // Record changelog entry
+        try {
+            await getChangelogService().recordCreate('feature', featureId);
+        }
+        catch {
+            // Silently fail if changelog can't be written
+        }
+        console.log(chalk.green(`✓ Created Feature ${featureId} under Epic ${epicId}`));
+        return;
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'title',
+            message: 'Feature title:',
+            validate: (input) => input.trim() !== '' || 'Title is required'
+        },
+        {
+            type: 'list',
+            name: 'status',
+            message: 'Status:',
+            choices: ['todo', 'in-progress', 'done'],
+            default: 'todo'
+        },
+        {
+            type: 'input',
+            name: 'assignee',
+            message: 'Assignee (optional):'
+        },
+        {
+            type: 'number',
+            name: 'estimate',
+            message: 'Estimate (hours):',
+            validate: (input) => input > 0 || 'Estimate must be positive',
+            default: 16
+        },
+        {
+            type: 'input',
+            name: 'skillsRequired',
+            message: 'Skills required (comma-separated, optional):',
+            filter: (input) => input.split(',').map((s) => s.trim()).filter((s) => s !== '')
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description (optional):'
+        },
+        {
+            type: 'input',
+            name: 'acceptanceCriteria',
+            message: 'Acceptance criteria (one per line, optional):',
+            filter: (input) => input.split('\n').map((s) => s.trim()).filter((s) => s !== '')
+        }
+    ]);
+    const feature = FeatureSchema.parse({
+        id: featureId,
+        title: answers.title.trim(),
+        epicId: epicId,
+        status: answers.status,
+        assignee: answers.assignee?.trim() || undefined,
+        estimate: answers.estimate,
+        skillsRequired: answers.skillsRequired,
+        description: answers.description?.trim() || undefined,
+        userStories: [],
+        acceptanceCriteria: answers.acceptanceCriteria
+    });
+    await writeFeatureFile(`pmspace/features/${featureId.toLowerCase()}.md`, feature);
+    // Update epic to include this feature
+    const epicPath = `pmspace/epics/${epicId.toLowerCase()}.md`;
+    const epic = await readEpicFile(epicPath);
+    if (!epic.features.includes(featureId)) {
+        epic.features.push(featureId);
+        await writeEpicFile(epicPath, epic);
+    }
+    // Record changelog entry
+    try {
+        await getChangelogService().recordCreate('feature', featureId);
+    }
+    catch {
+        // Silently fail if changelog can't be written
+    }
+    console.log(chalk.green(`✓ Created Feature ${featureId}: ${feature.title} under Epic ${epicId}`));
+}
+async function createStory(featureId, nonInteractive) {
+    if (!featureId) {
+        if (nonInteractive) {
+            console.error(chalk.red('Error: Feature ID is required for story creation'));
+            process.exit(1);
+        }
+        // Get existing features for selection
+        const features = [];
+        try {
+            const featureFiles = await readdir('pmspace/features');
+            for (const file of featureFiles) {
+                if (file.endsWith('.md')) {
+                    const content = await readFeatureFile(join('pmspace/features', file));
+                    features.push({ id: content.id, title: content.title });
+                }
+            }
+        }
+        catch {
+            console.error(chalk.red('Error: No features found. Create a feature first.'));
+            process.exit(1);
+        }
+        if (features.length === 0) {
+            console.error(chalk.red('Error: No features found. Create a feature first.'));
+            process.exit(1);
+        }
+        const answer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'featureId',
+                message: 'Select Feature:',
+                choices: features.map(f => ({ name: `${f.id}: ${f.title}`, value: f.id }))
+            }
+        ]);
+        featureId = answer.featureId;
+    }
+    // Validate feature exists
+    try {
+        await readFeatureFile(`pmspace/features/${featureId.toLowerCase()}.md`);
+    }
+    catch {
+        console.error(chalk.red(`Error: Feature ${featureId} not found`));
+        process.exit(1);
+    }
+    // Get existing stories to determine next ID
+    let existingStories = [];
+    try {
+        const featureFiles = await readdir('pmspace/features');
+        for (const file of featureFiles) {
+            if (file.endsWith('.md')) {
+                const content = await readFeatureFile(join('pmspace/features', file));
+                existingStories.push(...content.userStories.map((s) => s.id));
+            }
+        }
+    }
+    catch {
+        // Directory might not exist or be empty
+    }
+    const storyId = generateNextId('STORY', existingStories);
+    if (nonInteractive) {
+        const story = UserStorySchema.parse({
+            id: storyId,
+            title: 'New User Story',
+            estimate: 4,
+            status: 'todo',
+            featureId: featureId,
+            description: 'User story description'
+        });
+        // Update feature to include this story
+        const featurePath = `pmspace/features/${featureId.toLowerCase()}.md`;
+        const feature = await readFeatureFile(featurePath);
+        feature.userStories.push(story);
+        await writeFeatureFile(featurePath, feature);
+        // Record changelog entry
+        try {
+            await getChangelogService().recordCreate('story', storyId);
+        }
+        catch {
+            // Silently fail if changelog can't be written
+        }
+        console.log(chalk.green(`✓ Created User Story ${storyId} under Feature ${featureId}`));
+        return;
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'title',
+            message: 'User Story title:',
+            validate: (input) => input.trim() !== '' || 'Title is required'
+        },
+        {
+            type: 'number',
+            name: 'estimate',
+            message: 'Estimate (hours):',
+            validate: (input) => input > 0 || 'Estimate must be positive',
+            default: 4
+        },
+        {
+            type: 'list',
+            name: 'status',
+            message: 'Status:',
+            choices: ['todo', 'in-progress', 'done'],
+            default: 'todo'
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description (optional):'
+        }
+    ]);
+    const story = UserStorySchema.parse({
+        id: storyId,
+        title: answers.title.trim(),
+        estimate: answers.estimate,
+        status: answers.status,
+        featureId: featureId,
+        description: answers.description?.trim() || undefined
+    });
+    // Update feature to include this story
+    const featurePath = `pmspace/features/${featureId.toLowerCase()}.md`;
+    const feature = await readFeatureFile(featurePath);
+    feature.userStories.push(story);
+    await writeFeatureFile(featurePath, feature);
+    // Record changelog entry
+    try {
+        await getChangelogService().recordCreate('story', storyId);
+    }
+    catch {
+        // Silently fail if changelog can't be written
+    }
+    console.log(chalk.green(`✓ Created User Story ${storyId}: ${story.title} under Feature ${featureId}`));
+}
+async function createMilestone(nonInteractive) {
+    // Get existing milestones to determine next ID
+    let existingMilestones = [];
+    try {
+        const milestoneFiles = await readdir('pmspace/milestones');
+        for (const file of milestoneFiles) {
+            if (file.endsWith('.md')) {
+                const content = await readMilestoneFile(join('pmspace/milestones', file));
+                existingMilestones.push(content.id);
+            }
+        }
+    }
+    catch {
+        // Directory might not exist or be empty - create it
+        await mkdir('pmspace/milestones', { recursive: true });
+    }
+    const milestoneId = generateNextId('MILE', existingMilestones);
+    if (nonInteractive) {
+        const today = new Date();
+        const targetDate = new Date(today.getTime() + 30 * 24 * 60 * 60 * 1000); // 30 days from now
+        const milestone = MilestoneSchema.parse({
+            id: milestoneId,
+            title: 'New Milestone',
+            status: 'upcoming',
+            targetDate: targetDate.toISOString().split('T')[0],
+            description: 'Milestone description',
+            features: []
+        });
+        await writeMilestoneFile(`pmspace/milestones/${milestoneId.toLowerCase()}.md`, milestone);
+        // Record changelog entry
+        try {
+            await getChangelogService().recordCreate('milestone', milestoneId);
+        }
+        catch {
+            // Silently fail if changelog can't be written
+        }
+        console.log(chalk.green(`✓ Created Milestone ${milestoneId}`));
+        return;
+    }
+    // Get available features for selection
+    const features = [];
+    try {
+        const featureFiles = await readdir('pmspace/features');
+        for (const file of featureFiles) {
+            if (file.endsWith('.md')) {
+                const content = await readFeatureFile(join('pmspace/features', file));
+                features.push({ id: content.id, title: content.title });
+            }
+        }
+    }
+    catch {
+        // No features yet
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'title',
+            message: 'Milestone title:',
+            validate: (input) => input.trim() !== '' || 'Title is required'
+        },
+        {
+            type: 'input',
+            name: 'targetDate',
+            message: 'Target date (YYYY-MM-DD):',
+            validate: (input) => {
+                const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+                return dateRegex.test(input) || 'Date must be in YYYY-MM-DD format';
+            }
+        },
+        {
+            type: 'list',
+            name: 'status',
+            message: 'Status:',
+            choices: ['upcoming', 'active', 'completed', 'missed'],
+            default: 'upcoming'
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description (optional):'
+        },
+        {
+            type: 'checkbox',
+            name: 'features',
+            message: 'Select features for this milestone:',
+            choices: features.map(f => ({ name: `${f.id}: ${f.title}`, value: f.id })),
+            when: () => features.length > 0
+        }
+    ]);
+    const milestone = MilestoneSchema.parse({
+        id: milestoneId,
+        title: answers.title.trim(),
+        status: answers.status,
+        targetDate: answers.targetDate,
+        description: answers.description?.trim() || undefined,
+        features: answers.features || []
+    });
+    await writeMilestoneFile(`pmspace/milestones/${milestoneId.toLowerCase()}.md`, milestone);
+    // Record changelog entry
+    try {
+        await getChangelogService().recordCreate('milestone', milestoneId);
+    }
+    catch {
+        // Silently fail if changelog can't be written
+    }
+    console.log(chalk.green(`✓ Created Milestone ${milestoneId}: ${milestone.title}`));
+}
+export { createCommand };
+//# sourceMappingURL=create.js.map

package/dist/commands/history.d.ts

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