@lusipad/pmspec 1.0.0

package/dist/core/search.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Searchable document type
+ */
+export type SearchableType = 'epic' | 'feature' | 'story' | 'milestone';
+/**
+ * Searchable document interface
+ */
+export interface Searchable {
+    id: string;
+    type: SearchableType;
+    title: string;
+    description?: string;
+    content?: string;
+    parentId?: string;
+}
+/**
+ * Search options
+ */
+export interface SearchOptions {
+    type?: SearchableType | SearchableType[];
+    fuzzy?: number | boolean;
+    prefix?: boolean;
+    limit?: number;
+    boost?: Record<string, number>;
+}
+/**
+ * Search result with match information
+ */
+export interface SearchResult {
+    id: string;
+    type: SearchableType;
+    title: string;
+    description?: string;
+    score: number;
+    matches: SearchMatch[];
+    parentId?: string;
+}
+/**
+ * Match information for highlighting
+ */
+export interface SearchMatch {
+    field: string;
+    term: string;
+    positions?: number[];
+}
+/**
+ * Search Service using MiniSearch
+ */
+export declare class SearchService {
+    private miniSearch;
+    private documents;
+    private projectRoot;
+    private initialized;
+    constructor(projectRoot?: string);
+    /**
+     * Initialize and index all documents from the project
+     */
+    index(): Promise<void>;
+    /**
+     * Index all epic files
+     */
+    private indexEpics;
+    /**
+     * Index all feature files and their user stories
+     */
+    private indexFeatures;
+    /**
+     * Index all milestone files
+     */
+    private indexMilestones;
+    /**
+     * Add a document to the search index
+     */
+    addDocument(doc: Searchable): void;
+    /**
+     * Remove a document from the search index
+     */
+    removeDocument(id: string): void;
+    /**
+     * Update a document in the search index
+     */
+    updateDocument(doc: Searchable): void;
+    /**
+     * Search for documents matching the query
+     */
+    search(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Get document by ID
+     */
+    getDocument(id: string): Searchable | undefined;
+    /**
+     * Get all documents
+     */
+    getAllDocuments(): Searchable[];
+    /**
+     * Get document count
+     */
+    getDocumentCount(): number;
+    /**
+     * Check if the service is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Clear all documents from the index
+     */
+    clear(): void;
+}
+/**
+ * Highlight matching terms in text
+ */
+export declare function highlightMatches(text: string, matches: SearchMatch[], highlightStart?: string, // Yellow ANSI
+highlightEnd?: string): string;
+/**
+ * Highlight matches with HTML tags (for web)
+ */
+export declare function highlightMatchesHtml(text: string, matches: SearchMatch[], className?: string): string;
+export declare function getSearchService(projectRoot?: string): SearchService;
+export default SearchService;
+//# sourceMappingURL=search.d.ts.map

package/dist/core/search.js

@@ -0,0 +1,299 @@
+import MiniSearch from 'minisearch';
+import { readdir, readFile } from 'fs/promises';
+import path from 'path';
+import { parseEpic, parseFeature, parseMilestone } from './parser.js';
+/**
+ * Default search options
+ */
+const DEFAULT_OPTIONS = {
+    fuzzy: 0.2,
+    prefix: true,
+    limit: 20,
+    boost: {
+        title: 2,
+        description: 1,
+        content: 0.5,
+    },
+};
+/**
+ * Search Service using MiniSearch
+ */
+export class SearchService {
+    miniSearch;
+    documents = new Map();
+    projectRoot;
+    initialized = false;
+    constructor(projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.miniSearch = new MiniSearch({
+            fields: ['title', 'description', 'content'],
+            storeFields: ['id', 'type', 'title', 'description', 'parentId'],
+            idField: 'id',
+            // Custom tokenizer for Chinese text support
+            tokenize: (text) => {
+                // Split on spaces, punctuation, and support Chinese character segmentation
+                return text.toLowerCase().split(/[\s\p{P}]+/u).filter(Boolean);
+            },
+            // Process search terms similarly
+            processTerm: (term) => term.toLowerCase(),
+        });
+    }
+    /**
+     * Initialize and index all documents from the project
+     */
+    async index() {
+        const pmspaceDir = path.join(this.projectRoot, 'pmspace');
+        // Clear existing index
+        this.miniSearch.removeAll();
+        this.documents.clear();
+        // Index epics
+        await this.indexEpics(pmspaceDir);
+        // Index features (and their user stories)
+        await this.indexFeatures(pmspaceDir);
+        // Index milestones
+        await this.indexMilestones(pmspaceDir);
+        this.initialized = true;
+    }
+    /**
+     * Index all epic files
+     */
+    async indexEpics(pmspaceDir) {
+        try {
+            const epicsDir = path.join(pmspaceDir, 'epics');
+            const files = await readdir(epicsDir);
+            for (const file of files) {
+                if (!file.endsWith('.md'))
+                    continue;
+                try {
+                    const content = await readFile(path.join(epicsDir, file), 'utf-8');
+                    const epic = parseEpic(content);
+                    if (epic.id) {
+                        const doc = {
+                            id: epic.id,
+                            type: 'epic',
+                            title: epic.title,
+                            description: epic.description,
+                        };
+                        this.addDocument(doc);
+                    }
+                }
+                catch (err) {
+                    // Skip invalid files
+                }
+            }
+        }
+        catch (err) {
+            // Epics directory doesn't exist
+        }
+    }
+    /**
+     * Index all feature files and their user stories
+     */
+    async indexFeatures(pmspaceDir) {
+        try {
+            const featuresDir = path.join(pmspaceDir, 'features');
+            const files = await readdir(featuresDir);
+            for (const file of files) {
+                if (!file.endsWith('.md'))
+                    continue;
+                try {
+                    const content = await readFile(path.join(featuresDir, file), 'utf-8');
+                    const feature = parseFeature(content);
+                    if (feature.id) {
+                        // Build content from acceptance criteria
+                        const contentParts = [];
+                        if (feature.acceptanceCriteria) {
+                            contentParts.push(...feature.acceptanceCriteria);
+                        }
+                        const doc = {
+                            id: feature.id,
+                            type: 'feature',
+                            title: feature.title,
+                            description: feature.description,
+                            content: contentParts.join(' '),
+                            parentId: feature.epicId,
+                        };
+                        this.addDocument(doc);
+                        // Index user stories
+                        if (feature.userStories) {
+                            for (const story of feature.userStories) {
+                                const storyDoc = {
+                                    id: story.id,
+                                    type: 'story',
+                                    title: story.title,
+                                    description: story.description,
+                                    parentId: feature.id,
+                                };
+                                this.addDocument(storyDoc);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    // Skip invalid files
+                }
+            }
+        }
+        catch (err) {
+            // Features directory doesn't exist
+        }
+    }
+    /**
+     * Index all milestone files
+     */
+    async indexMilestones(pmspaceDir) {
+        try {
+            const milestonesDir = path.join(pmspaceDir, 'milestones');
+            const files = await readdir(milestonesDir);
+            for (const file of files) {
+                if (!file.endsWith('.md'))
+                    continue;
+                try {
+                    const content = await readFile(path.join(milestonesDir, file), 'utf-8');
+                    const milestone = parseMilestone(content);
+                    if (milestone.id) {
+                        const doc = {
+                            id: milestone.id,
+                            type: 'milestone',
+                            title: milestone.title,
+                            description: milestone.description,
+                        };
+                        this.addDocument(doc);
+                    }
+                }
+                catch (err) {
+                    // Skip invalid files
+                }
+            }
+        }
+        catch (err) {
+            // Milestones directory doesn't exist
+        }
+    }
+    /**
+     * Add a document to the search index
+     */
+    addDocument(doc) {
+        // Remove existing document if present
+        if (this.documents.has(doc.id)) {
+            this.removeDocument(doc.id);
+        }
+        this.documents.set(doc.id, doc);
+        this.miniSearch.add(doc);
+    }
+    /**
+     * Remove a document from the search index
+     */
+    removeDocument(id) {
+        const doc = this.documents.get(id);
+        if (doc) {
+            this.miniSearch.remove(doc);
+            this.documents.delete(id);
+        }
+    }
+    /**
+     * Update a document in the search index
+     */
+    updateDocument(doc) {
+        this.addDocument(doc); // addDocument handles removal if exists
+    }
+    /**
+     * Search for documents matching the query
+     */
+    search(query, options = {}) {
+        const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+        // Build filter for type restriction
+        const typeFilter = mergedOptions.type
+            ? Array.isArray(mergedOptions.type)
+                ? mergedOptions.type
+                : [mergedOptions.type]
+            : null;
+        const searchOptions = {
+            fuzzy: mergedOptions.fuzzy,
+            prefix: mergedOptions.prefix,
+            boost: mergedOptions.boost,
+        };
+        // Add filter if type is specified
+        if (typeFilter) {
+            searchOptions.filter = (result) => typeFilter.includes(result.type);
+        }
+        const results = this.miniSearch.search(query, searchOptions);
+        return results
+            .slice(0, mergedOptions.limit)
+            .map((result) => ({
+            id: result.id,
+            type: result.type,
+            title: result.title,
+            description: result.description,
+            score: result.score,
+            parentId: result.parentId,
+            matches: Object.entries(result.match).map(([term, fields]) => ({
+                field: fields[0] || 'title',
+                term,
+            })),
+        }));
+    }
+    /**
+     * Get document by ID
+     */
+    getDocument(id) {
+        return this.documents.get(id);
+    }
+    /**
+     * Get all documents
+     */
+    getAllDocuments() {
+        return Array.from(this.documents.values());
+    }
+    /**
+     * Get document count
+     */
+    getDocumentCount() {
+        return this.documents.size;
+    }
+    /**
+     * Check if the service is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Clear all documents from the index
+     */
+    clear() {
+        this.miniSearch.removeAll();
+        this.documents.clear();
+        this.initialized = false;
+    }
+}
+/**
+ * Highlight matching terms in text
+ */
+export function highlightMatches(text, matches, highlightStart = '\x1b[33m', // Yellow ANSI
+highlightEnd = '\x1b[0m' // Reset ANSI
+) {
+    if (!text || matches.length === 0)
+        return text;
+    const terms = matches.map((m) => m.term.toLowerCase());
+    // Create regex pattern for all matching terms
+    const pattern = new RegExp(`(${terms.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})`, 'gi');
+    return text.replace(pattern, `${highlightStart}$1${highlightEnd}`);
+}
+/**
+ * Highlight matches with HTML tags (for web)
+ */
+export function highlightMatchesHtml(text, matches, className = 'search-highlight') {
+    return highlightMatches(text, matches, `<mark class="${className}">`, '</mark>');
+}
+/**
+ * Create a singleton search service instance
+ */
+let searchServiceInstance = null;
+export function getSearchService(projectRoot) {
+    if (!searchServiceInstance || (projectRoot && projectRoot !== searchServiceInstance['projectRoot'])) {
+        searchServiceInstance = new SearchService(projectRoot);
+    }
+    return searchServiceInstance;
+}
+export default SearchService;
+//# sourceMappingURL=search.js.map

package/dist/core/simple-model.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+export declare const SimpleFeatureSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    estimate: z.ZodNumber;
+    assignee: z.ZodString;
+    priority: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    status: z.ZodEnum<{
+        "in-progress": "in-progress";
+        todo: "todo";
+        done: "done";
+        blocked: "blocked";
+    }>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    createdDate: z.ZodOptional<z.ZodString>;
+    dueDate: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SimpleFeature = z.infer<typeof SimpleFeatureSchema>;
+export declare const FeaturesTableSchema: z.ZodObject<{
+    features: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        estimate: z.ZodNumber;
+        assignee: z.ZodString;
+        priority: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        status: z.ZodEnum<{
+            "in-progress": "in-progress";
+            todo: "todo";
+            done: "done";
+            blocked: "blocked";
+        }>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        createdDate: z.ZodOptional<z.ZodString>;
+        dueDate: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastUpdated: z.ZodOptional<z.ZodString>;
+    version: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type FeaturesTable = z.infer<typeof FeaturesTableSchema>;
+//# sourceMappingURL=simple-model.d.ts.map

package/dist/core/simple-model.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export const SimpleFeatureSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    estimate: z.number().positive(),
+    assignee: z.string(),
+    priority: z.enum(['low', 'medium', 'high', 'critical']),
+    status: z.enum(['todo', 'in-progress', 'done', 'blocked']),
+    category: z.string().optional(), // 用于分组，相当于 Epic
+    tags: z.array(z.string()).default([]),
+    createdDate: z.string().optional(),
+    dueDate: z.string().optional(),
+});
+export const FeaturesTableSchema = z.object({
+    features: z.array(SimpleFeatureSchema),
+    lastUpdated: z.string().optional(),
+    version: z.string().default('1.0'),
+});
+//# sourceMappingURL=simple-model.js.map

package/dist/core/team.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const TeamMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    capacity: z.ZodNumber;
+    currentLoad: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TeamMember = z.infer<typeof TeamMemberSchema>;
+export declare const TeamSchema: z.ZodObject<{
+    members: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        capacity: z.ZodNumber;
+        currentLoad: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Team = z.infer<typeof TeamSchema>;
+/**
+ * Calculate skill match score between member skills and required skills
+ * Uses Jaccard similarity: |intersection| / |union|
+ * @returns score between 0 and 1
+ */
+export declare function calculateSkillMatch(memberSkills: string[], requiredSkills: string[]): number;
+/**
+ * Get missing skills (required but not possessed by member)
+ */
+export declare function getMissingSkills(memberSkills: string[], requiredSkills: string[]): string[];
+/**
+ * Calculate current load percentage
+ * @returns percentage between 0 and 100+
+ */
+export declare function calculateLoadPercentage(currentLoad: number, capacity: number): number;
+/**
+ * Check if member is overallocated
+ */
+export declare function isOverallocated(member: TeamMember): boolean;
+/**
+ * Get available hours for a team member
+ */
+export declare function getAvailableHours(member: TeamMember): number;
+//# sourceMappingURL=team.d.ts.map

package/dist/core/team.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+// TeamMember schema
+export const TeamMemberSchema = z.object({
+    name: z.string().min(1),
+    skills: z.array(z.string()).default([]),
+    capacity: z.number().positive(), // hours per week
+    currentLoad: z.number().nonnegative().default(0), // hours currently assigned
+});
+// Team schema
+export const TeamSchema = z.object({
+    members: z.array(TeamMemberSchema).default([]),
+});
+/**
+ * Calculate skill match score between member skills and required skills
+ * Uses Jaccard similarity: |intersection| / |union|
+ * @returns score between 0 and 1
+ */
+export function calculateSkillMatch(memberSkills, requiredSkills) {
+    if (requiredSkills.length === 0) {
+        return 1.0; // No skill requirements = perfect match
+    }
+    const memberSet = new Set(memberSkills.map(s => s.toLowerCase()));
+    const requiredSet = new Set(requiredSkills.map(s => s.toLowerCase()));
+    const intersection = new Set([...memberSet].filter(s => requiredSet.has(s)));
+    const union = new Set([...memberSet, ...requiredSet]);
+    return intersection.size / union.size;
+}
+/**
+ * Get missing skills (required but not possessed by member)
+ */
+export function getMissingSkills(memberSkills, requiredSkills) {
+    const memberSet = new Set(memberSkills.map(s => s.toLowerCase()));
+    return requiredSkills.filter(skill => !memberSet.has(skill.toLowerCase()));
+}
+/**
+ * Calculate current load percentage
+ * @returns percentage between 0 and 100+
+ */
+export function calculateLoadPercentage(currentLoad, capacity) {
+    if (capacity === 0) {
+        return 0;
+    }
+    return (currentLoad / capacity) * 100;
+}
+/**
+ * Check if member is overallocated
+ */
+export function isOverallocated(member) {
+    return member.currentLoad > member.capacity;
+}
+/**
+ * Get available hours for a team member
+ */
+export function getAvailableHours(member) {
+    return Math.max(0, member.capacity - member.currentLoad);
+}
+//# sourceMappingURL=team.js.map

package/dist/core/workload.d.ts

@@ -0,0 +1,49 @@
+import type { TeamMember } from './team.js';
+import type { Feature } from './project.js';
+export interface AssignmentScore {
+    member: TeamMember;
+    score: number;
+    skillMatch: number;
+    loadPercentage: number;
+    availableHours: number;
+    missingSkills: string[];
+}
+export interface WorkloadSummary {
+    member: TeamMember;
+    assignedFeatures: string[];
+    totalEstimate: number;
+    loadPercentage: number;
+    availableHours: number;
+    isOverallocated: boolean;
+}
+/**
+ * WorkloadAnalyzer calculates assignment scores and workload summaries
+ */
+export declare class WorkloadAnalyzer {
+    /**
+     * Calculate assignment score for a member and feature
+     * score = skillMatch * (1 - loadPercentage/100)
+     */
+    calculateAssignmentScore(member: TeamMember, feature: Feature): AssignmentScore;
+    /**
+     * Rank team members by assignment score for a given feature
+     * Returns top N candidates sorted by score (descending)
+     */
+    rankCandidates(team: TeamMember[], feature: Feature, topN?: number): AssignmentScore[];
+    /**
+     * Generate workload summary for all team members
+     */
+    generateWorkloadSummary(team: TeamMember[], features: Feature[]): WorkloadSummary[];
+    /**
+     * Find skills that are required but missing from the team
+     */
+    findSkillGaps(team: TeamMember[], features: Feature[]): Map<string, string[]>;
+    /**
+     * Find skills with high demand (required by many features but few team members have it)
+     */
+    findHighDemandSkills(team: TeamMember[], features: Feature[]): Map<string, {
+        demandCount: number;
+        memberCount: number;
+    }>;
+}
+//# sourceMappingURL=workload.d.ts.map