@lusipad/pmspec 1.0.0

package/dist/core/parser.d.ts

@@ -0,0 +1,50 @@
+import type { Epic, Feature, Project, Milestone } from './project.js';
+import type { Team } from './team.js';
+/**
+ * Parse metadata from markdown frontmatter-style format
+ * Example:
+ * - **ID**: EPIC-001
+ * - **Status**: planning
+ */
+export declare function parseMetadata(content: string): Record<string, string>;
+/**
+ * Parse Epic from markdown file content
+ */
+export declare function parseEpic(content: string): Epic;
+/**
+ * Parse Feature from markdown file content
+ */
+export declare function parseFeature(content: string): Feature;
+/**
+ * Parse Project from project.md content
+ */
+export declare function parseProject(content: string): Project;
+/**
+ * Parse Team from team.md content
+ */
+export declare function parseTeam(content: string): Team;
+/**
+ * Parse Milestone from markdown file content
+ */
+export declare function parseMilestone(content: string): Milestone;
+/**
+ * Read and parse Epic file
+ */
+export declare function readEpicFile(filePath: string): Promise<Epic>;
+/**
+ * Read and parse Feature file
+ */
+export declare function readFeatureFile(filePath: string): Promise<Feature>;
+/**
+ * Read and parse Project file
+ */
+export declare function readProjectFile(filePath: string): Promise<Project>;
+/**
+ * Read and parse Team file
+ */
+export declare function readTeamFile(filePath: string): Promise<Team>;
+/**
+ * Read and parse Milestone file
+ */
+export declare function readMilestoneFile(filePath: string): Promise<Milestone>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/core/parser.js

@@ -0,0 +1,246 @@
+import { readFile } from 'fs/promises';
+/**
+ * Parse metadata from markdown frontmatter-style format
+ * Example:
+ * - **ID**: EPIC-001
+ * - **Status**: planning
+ */
+export function parseMetadata(content) {
+    const metadata = {};
+    const metadataRegex = /^-\s+\*\*(.+?)\*\*:\s*(.+)$/gm;
+    let match;
+    while ((match = metadataRegex.exec(content)) !== null) {
+        const key = match[1].trim();
+        const value = match[2].trim();
+        metadata[key] = value;
+    }
+    return metadata;
+}
+/**
+ * Parse Epic from markdown file content
+ */
+export function parseEpic(content) {
+    const metadata = parseMetadata(content);
+    // Parse Features list
+    const featuresSection = content.match(/## Features\n([\s\S]*?)(?=\n##|$)/);
+    const features = [];
+    if (featuresSection) {
+        const featureRegex = /-\s+\[[x ]\]\s+(FEAT-\d+)/g;
+        let match;
+        while ((match = featureRegex.exec(featuresSection[1])) !== null) {
+            features.push(match[1]);
+        }
+    }
+    // Parse Description
+    const descSection = content.match(/## Description\n([\s\S]*?)(?=\n##|$)/);
+    const description = descSection ? descSection[1].trim() : undefined;
+    // Parse title from header
+    const titleMatch = content.match(/^#\s+Epic:\s+(.+)$/m);
+    const title = titleMatch ? titleMatch[1].trim() : metadata['Title'] || 'Untitled';
+    return {
+        id: metadata['ID'],
+        title,
+        status: metadata['Status'],
+        owner: metadata['Owner'],
+        estimate: parseFloat(metadata['Estimate']) || 0,
+        actual: parseFloat(metadata['Actual']) || 0,
+        description,
+        features,
+    };
+}
+/**
+ * Parse Feature from markdown file content
+ */
+export function parseFeature(content) {
+    const metadata = parseMetadata(content);
+    // Parse UserStories
+    const storiesSection = content.match(/## User Stories\n([\s\S]*?)(?=\n##|$)/);
+    const userStories = [];
+    if (storiesSection) {
+        const storyRegex = /-\s+\[[x ]\]\s+(STORY-\d+):\s+(.+?)\s+\((\d+)h\)/g;
+        let match;
+        while ((match = storyRegex.exec(storiesSection[1])) !== null) {
+            userStories.push({
+                id: match[1],
+                title: match[2].trim(),
+                estimate: parseInt(match[3], 10),
+                status: 'todo',
+                featureId: metadata['ID'],
+            });
+        }
+    }
+    // Parse Acceptance Criteria
+    const criteriaSection = content.match(/## Acceptance Criteria\n([\s\S]*?)(?=\n##|$)/);
+    const acceptanceCriteria = [];
+    if (criteriaSection) {
+        const criteriaRegex = /-\s+\[[x ]\]\s+(.+)$/gm;
+        let match;
+        while ((match = criteriaRegex.exec(criteriaSection[1])) !== null) {
+            acceptanceCriteria.push(match[1].trim());
+        }
+    }
+    // Parse Description
+    const descSection = content.match(/## Description\n([\s\S]*?)(?=\n##|$)/);
+    const description = descSection ? descSection[1].trim() : undefined;
+    // Parse title from header
+    const titleMatch = content.match(/^#\s+Feature:\s+(.+)$/m);
+    const title = titleMatch ? titleMatch[1].trim() : metadata['Title'] || 'Untitled';
+    // Parse skills required
+    const skillsStr = metadata['Skills Required'] || '';
+    const skillsRequired = skillsStr ? skillsStr.split(',').map(s => s.trim()).filter(Boolean) : [];
+    // Parse Dependencies
+    const depsSection = content.match(/## Dependencies\n([\s\S]*?)(?=\n##|$)/);
+    const dependencies = [];
+    if (depsSection) {
+        // Parse blocks: FEAT-002, FEAT-003
+        const blocksMatch = depsSection[1].match(/-\s+blocks:\s+(.+)/i);
+        if (blocksMatch) {
+            const blockIds = blocksMatch[1].split(',').map(s => s.trim()).filter(s => /^FEAT-\d+$/.test(s));
+            blockIds.forEach(id => dependencies.push({ featureId: id, type: 'blocks' }));
+        }
+        // Parse relates-to: FEAT-005
+        const relatesToMatch = depsSection[1].match(/-\s+relates-to:\s+(.+)/i);
+        if (relatesToMatch) {
+            const relatedIds = relatesToMatch[1].split(',').map(s => s.trim()).filter(s => /^FEAT-\d+$/.test(s));
+            relatedIds.forEach(id => dependencies.push({ featureId: id, type: 'relates-to' }));
+        }
+    }
+    return {
+        id: metadata['ID'],
+        title,
+        epicId: metadata['Epic'],
+        status: metadata['Status'],
+        assignee: metadata['Assignee'],
+        estimate: parseFloat(metadata['Estimate']) || 0,
+        actual: parseFloat(metadata['Actual']) || 0,
+        skillsRequired,
+        description,
+        userStories,
+        acceptanceCriteria,
+        dependencies,
+    };
+}
+/**
+ * Parse Project from project.md content
+ */
+export function parseProject(content) {
+    // Parse title from header
+    const titleMatch = content.match(/^#\s+Project:\s+(.+)$/m);
+    const name = titleMatch ? titleMatch[1].trim() : 'Untitled Project';
+    // Parse Overview
+    const overviewSection = content.match(/## Overview\n([\s\S]*?)(?=\n##|$)/);
+    const overview = overviewSection ? overviewSection[1].trim() : undefined;
+    // Parse Timeline
+    const timelineMatch = content.match(/## Timeline\n-\s+Start:\s+(.+)\n-\s+End:\s+(.+)/);
+    const timeline = timelineMatch ? {
+        start: timelineMatch[1].trim(),
+        end: timelineMatch[2].trim(),
+    } : undefined;
+    // Parse Team Capacity
+    const capacityMatch = content.match(/## Team Capacity\n-\s+Total:\s+(\d+)[^\n]*\n-\s+Available:\s+(\d+)/);
+    const teamCapacity = capacityMatch ? {
+        total: parseInt(capacityMatch[1], 10),
+        available: parseInt(capacityMatch[2], 10),
+    } : undefined;
+    return {
+        name,
+        overview,
+        timeline,
+        teamCapacity,
+    };
+}
+/**
+ * Parse Team from team.md content
+ */
+export function parseTeam(content) {
+    const members = [];
+    // Match each member section (### [Name])
+    const memberRegex = /###\s+(.+?)\n([\s\S]*?)(?=\n###|$)/g;
+    let match;
+    while ((match = memberRegex.exec(content)) !== null) {
+        const name = match[1].trim();
+        const memberContent = match[2];
+        // Parse skills
+        const skillsMatch = memberContent.match(/-\s+\*\*Skills\*\*:\s+(.+)/);
+        const skills = skillsMatch ? skillsMatch[1].split(',').map(s => s.trim()) : [];
+        // Parse capacity
+        const capacityMatch = memberContent.match(/-\s+\*\*Capacity\*\*:\s+(\d+)\s+hours?\/week/);
+        const capacity = capacityMatch ? parseInt(capacityMatch[1], 10) : 40;
+        // Parse current load
+        const loadMatch = memberContent.match(/-\s+\*\*Current Load\*\*:\s+(\d+)\s+hours?\/week/);
+        const currentLoad = loadMatch ? parseInt(loadMatch[1], 10) : 0;
+        members.push({
+            name,
+            skills,
+            capacity,
+            currentLoad,
+        });
+    }
+    return { members };
+}
+/**
+ * Parse Milestone from markdown file content
+ */
+export function parseMilestone(content) {
+    const metadata = parseMetadata(content);
+    // Parse title from header
+    const titleMatch = content.match(/^#\s+Milestone:\s+(.+)$/m);
+    const title = titleMatch ? titleMatch[1].trim() : metadata['Title'] || 'Untitled';
+    // Parse Description
+    const descSection = content.match(/## Description\n([\s\S]*?)(?=\n##|$)/);
+    const description = descSection ? descSection[1].trim() : undefined;
+    // Parse Features list (with checkboxes)
+    const featuresSection = content.match(/## Features\n([\s\S]*?)(?=\n##|$)/);
+    const features = [];
+    if (featuresSection) {
+        const featureRegex = /-\s+\[[x ]\]\s+(FEAT-\d+)/g;
+        let match;
+        while ((match = featureRegex.exec(featuresSection[1])) !== null) {
+            features.push(match[1]);
+        }
+    }
+    return {
+        id: metadata['ID'],
+        title,
+        description,
+        targetDate: metadata['Target Date'],
+        status: metadata['Status'],
+        features,
+    };
+}
+/**
+ * Read and parse Epic file
+ */
+export async function readEpicFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    return parseEpic(content);
+}
+/**
+ * Read and parse Feature file
+ */
+export async function readFeatureFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    return parseFeature(content);
+}
+/**
+ * Read and parse Project file
+ */
+export async function readProjectFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    return parseProject(content);
+}
+/**
+ * Read and parse Team file
+ */
+export async function readTeamFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    return parseTeam(content);
+}
+/**
+ * Read and parse Milestone file
+ */
+export async function readMilestoneFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    return parseMilestone(content);
+}
+//# sourceMappingURL=parser.js.map

package/dist/core/project.d.ts

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+export declare const EpicStatus: z.ZodEnum<{
+    planning: "planning";
+    "in-progress": "in-progress";
+    completed: "completed";
+}>;
+export type EpicStatus = z.infer<typeof EpicStatus>;
+export declare const MilestoneStatus: z.ZodEnum<{
+    completed: "completed";
+    upcoming: "upcoming";
+    active: "active";
+    missed: "missed";
+}>;
+export type MilestoneStatus = z.infer<typeof MilestoneStatus>;
+export declare const FeatureStatus: z.ZodEnum<{
+    "in-progress": "in-progress";
+    todo: "todo";
+    done: "done";
+}>;
+export type FeatureStatus = z.infer<typeof FeatureStatus>;
+export declare const StoryStatus: z.ZodEnum<{
+    "in-progress": "in-progress";
+    todo: "todo";
+    done: "done";
+}>;
+export type StoryStatus = z.infer<typeof StoryStatus>;
+export declare const UserStorySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    estimate: z.ZodNumber;
+    status: z.ZodEnum<{
+        "in-progress": "in-progress";
+        todo: "todo";
+        done: "done";
+    }>;
+    featureId: z.ZodString;
+}, z.core.$strip>;
+export type UserStory = z.infer<typeof UserStorySchema>;
+export declare const DependencyType: z.ZodEnum<{
+    blocks: "blocks";
+    "relates-to": "relates-to";
+}>;
+export type DependencyType = z.infer<typeof DependencyType>;
+export declare const DependencySchema: z.ZodObject<{
+    featureId: z.ZodString;
+    type: z.ZodEnum<{
+        blocks: "blocks";
+        "relates-to": "relates-to";
+    }>;
+}, z.core.$strip>;
+export type Dependency = z.infer<typeof DependencySchema>;
+export declare const FeatureSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    epicId: z.ZodString;
+    status: z.ZodEnum<{
+        "in-progress": "in-progress";
+        todo: "todo";
+        done: "done";
+    }>;
+    assignee: z.ZodOptional<z.ZodString>;
+    estimate: z.ZodNumber;
+    actual: z.ZodDefault<z.ZodNumber>;
+    skillsRequired: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+    userStories: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        estimate: z.ZodNumber;
+        status: z.ZodEnum<{
+            "in-progress": "in-progress";
+            todo: "todo";
+            done: "done";
+        }>;
+        featureId: z.ZodString;
+    }, z.core.$strip>>>;
+    acceptanceCriteria: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        featureId: z.ZodString;
+        type: z.ZodEnum<{
+            blocks: "blocks";
+            "relates-to": "relates-to";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Feature = z.infer<typeof FeatureSchema>;
+export declare const EpicSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        planning: "planning";
+        "in-progress": "in-progress";
+        completed: "completed";
+    }>;
+    owner: z.ZodOptional<z.ZodString>;
+    estimate: z.ZodNumber;
+    actual: z.ZodDefault<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    features: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type Epic = z.infer<typeof EpicSchema>;
+export declare const MilestoneSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    targetDate: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        upcoming: "upcoming";
+        active: "active";
+        missed: "missed";
+    }>;
+    features: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type Milestone = z.infer<typeof MilestoneSchema>;
+export declare const ProjectSchema: z.ZodObject<{
+    name: z.ZodString;
+    overview: z.ZodOptional<z.ZodString>;
+    timeline: z.ZodOptional<z.ZodObject<{
+        start: z.ZodOptional<z.ZodString>;
+        end: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    teamCapacity: z.ZodOptional<z.ZodObject<{
+        total: z.ZodOptional<z.ZodNumber>;
+        available: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Project = z.infer<typeof ProjectSchema>;
+/**
+ * Parse ID number from Epic/Feature/Story ID string
+ * @example parseIdNumber('EPIC-001') => 1
+ */
+export declare function parseIdNumber(id: string): number;
+/**
+ * Generate next available ID based on existing IDs
+ * @example generateNextId('EPIC', ['EPIC-001', 'EPIC-003']) => 'EPIC-004'
+ */
+export declare function generateNextId(prefix: 'EPIC' | 'FEAT' | 'STORY' | 'MILE', existingIds: string[]): string;
+/**
+ * Validate that all referenced IDs exist
+ */
+export declare function validateReferences(epics: Epic[], features: Feature[]): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Check for duplicate IDs
+ */
+export declare function checkDuplicateIds(epics: Epic[], features: Feature[]): {
+    valid: boolean;
+    errors: string[];
+};
+//# sourceMappingURL=project.d.ts.map

package/dist/core/project.js

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+// Status enums
+export const EpicStatus = z.enum(['planning', 'in-progress', 'completed']);
+export const MilestoneStatus = z.enum(['upcoming', 'active', 'completed', 'missed']);
+export const FeatureStatus = z.enum(['todo', 'in-progress', 'done']);
+export const StoryStatus = z.enum(['todo', 'in-progress', 'done']);
+// UserStory schema
+export const UserStorySchema = z.object({
+    id: z.string().regex(/^STORY-\d+$/),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    estimate: z.number().positive(),
+    status: StoryStatus,
+    featureId: z.string().regex(/^FEAT-\d+$/),
+});
+// Dependency type enum
+export const DependencyType = z.enum(['blocks', 'relates-to']);
+// Dependency schema
+export const DependencySchema = z.object({
+    featureId: z.string().regex(/^FEAT-\d+$/),
+    type: DependencyType,
+});
+// Feature schema
+export const FeatureSchema = z.object({
+    id: z.string().regex(/^FEAT-\d+$/),
+    title: z.string().min(1),
+    epicId: z.string().regex(/^EPIC-\d+$/),
+    status: FeatureStatus,
+    assignee: z.string().optional(),
+    estimate: z.number().positive(),
+    actual: z.number().nonnegative().default(0),
+    skillsRequired: z.array(z.string()).default([]),
+    description: z.string().optional(),
+    userStories: z.array(UserStorySchema).default([]),
+    acceptanceCriteria: z.array(z.string()).default([]),
+    dependencies: z.array(DependencySchema).default([]),
+});
+// Epic schema
+export const EpicSchema = z.object({
+    id: z.string().regex(/^EPIC-\d+$/),
+    title: z.string().min(1),
+    status: EpicStatus,
+    owner: z.string().optional(),
+    estimate: z.number().positive(),
+    actual: z.number().nonnegative().default(0),
+    description: z.string().optional(),
+    features: z.array(z.string().regex(/^FEAT-\d+$/)).default([]), // Feature IDs
+});
+// Milestone schema
+export const MilestoneSchema = z.object({
+    id: z.string().regex(/^MILE-\d{3}$/),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    targetDate: z.string(), // ISO date YYYY-MM-DD
+    status: MilestoneStatus,
+    features: z.array(z.string().regex(/^FEAT-\d+$/)).default([]), // Feature IDs
+});
+// Project schema
+export const ProjectSchema = z.object({
+    name: z.string().min(1),
+    overview: z.string().optional(),
+    timeline: z.object({
+        start: z.string().optional(), // YYYY-MM-DD
+        end: z.string().optional(),
+    }).optional(),
+    teamCapacity: z.object({
+        total: z.number().optional(),
+        available: z.number().optional(),
+    }).optional(),
+});
+/**
+ * Parse ID number from Epic/Feature/Story ID string
+ * @example parseIdNumber('EPIC-001') => 1
+ */
+export function parseIdNumber(id) {
+    const match = id.match(/-(\d+)$/);
+    if (!match) {
+        throw new Error(`Invalid ID format: ${id}`);
+    }
+    return parseInt(match[1], 10);
+}
+/**
+ * Generate next available ID based on existing IDs
+ * @example generateNextId('EPIC', ['EPIC-001', 'EPIC-003']) => 'EPIC-004'
+ */
+export function generateNextId(prefix, existingIds) {
+    if (existingIds.length === 0) {
+        return `${prefix}-001`;
+    }
+    const numbers = existingIds.map(id => parseIdNumber(id));
+    const maxNumber = Math.max(...numbers);
+    const nextNumber = maxNumber + 1;
+    return `${prefix}-${nextNumber.toString().padStart(3, '0')}`;
+}
+/**
+ * Validate that all referenced IDs exist
+ */
+export function validateReferences(epics, features) {
+    const errors = [];
+    const epicIds = new Set(epics.map(e => e.id));
+    const featureIds = new Set(features.map(f => f.id));
+    // Check that Features reference existing Epics
+    for (const feature of features) {
+        if (!epicIds.has(feature.epicId)) {
+            errors.push(`Feature ${feature.id} references non-existent Epic ${feature.epicId}`);
+        }
+    }
+    // Check that Epics reference existing Features
+    for (const epic of epics) {
+        for (const featureId of epic.features) {
+            if (!featureIds.has(featureId)) {
+                errors.push(`Epic ${epic.id} references non-existent Feature ${featureId}`);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Check for duplicate IDs
+ */
+export function checkDuplicateIds(epics, features) {
+    const errors = [];
+    const allIds = [];
+    epics.forEach(e => allIds.push(e.id));
+    features.forEach(f => {
+        allIds.push(f.id);
+        f.userStories.forEach(s => allIds.push(s.id));
+    });
+    const seen = new Set();
+    for (const id of allIds) {
+        if (seen.has(id)) {
+            errors.push(`Duplicate ID found: ${id}`);
+        }
+        seen.add(id);
+    }
+    return { valid: errors.length === 0, errors };
+}
+//# sourceMappingURL=project.js.map