@bicorne/task-flow 0.1.0

package/dist/commands/tasks-gen/doc-parser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * commands/tasks-gen/doc-parser.ts
+ * Parse PRD and design documents to extract tasks
+ */
+import { Task } from './types';
+export declare function parseDocumentsToTasks(prdContent: string, designContent: string | null, _changeName: string): Task[];
+export declare function extractProjectName(prdContent: string): string;

package/dist/commands/tasks-gen/doc-parser.js

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * commands/tasks-gen/doc-parser.ts
+ * Parse PRD and design documents to extract tasks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDocumentsToTasks = parseDocumentsToTasks;
+exports.extractProjectName = extractProjectName;
+const PRIORITY_MAP = {
+    P0: 'high',
+    P1: 'medium',
+    P2: 'low',
+    p0: 'high',
+    p1: 'medium',
+    p2: 'low',
+};
+function extractSection(content, sectionTitle) {
+    const lines = content.split(/\r?\n/);
+    const sectionStartRegex = new RegExp(`^(#{2,})\\s+${sectionTitle}`, 'i');
+    let startIndex = -1;
+    let endIndex = lines.length;
+    let sectionLevel = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] || '';
+        const match = line.match(sectionStartRegex);
+        if (match) {
+            startIndex = i;
+            sectionLevel = match[1]?.length || 2;
+            continue;
+        }
+        if (startIndex !== -1) {
+            const nextSectionMatch = line.match(/^(#{1,})\s+/);
+            if (nextSectionMatch) {
+                const nextLevel = nextSectionMatch[1]?.length || 0;
+                if (nextLevel <= sectionLevel) {
+                    endIndex = i;
+                    break;
+                }
+            }
+        }
+    }
+    if (startIndex === -1) {
+        return '';
+    }
+    return lines.slice(startIndex, endIndex).join('\n');
+}
+function sanitizeCell(cell) {
+    return cell
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<[^>]+>/g, '')
+        .trim();
+}
+function parseFeatureTable(section) {
+    const features = [];
+    const lines = section.split(/\r?\n/);
+    let featureCounter = 0;
+    let headerIndices = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('|') || !trimmed.endsWith('|')) {
+            continue;
+        }
+        if (trimmed.includes('---')) {
+            continue;
+        }
+        const cells = trimmed
+            .split('|')
+            .map((cell) => sanitizeCell(cell.trim()))
+            .filter((cell) => cell.length > 0);
+        if (cells.some((cell) => cell.includes('功能名称') || cell.includes('优先级'))) {
+            headerIndices = {};
+            cells.forEach((cell, idx) => {
+                const lower = cell.toLowerCase();
+                if (lower.includes('功能名称') || lower.includes('feature') || lower.includes('名称')) {
+                    headerIndices.name = idx;
+                }
+                if (lower.includes('优先级') || lower.includes('priority')) {
+                    headerIndices.priority = idx;
+                }
+                if (lower.includes('描述') || lower.includes('description')) {
+                    headerIndices.description = idx;
+                }
+                if (lower.includes('验收') || lower.includes('acceptance') || lower.includes('标准')) {
+                    headerIndices.acceptanceCriteria = idx;
+                }
+                if (lower.includes('编号') || lower.includes('id') || lower.includes('#')) {
+                    headerIndices.id = idx;
+                }
+            });
+            continue;
+        }
+        if (cells.length >= 2) {
+            featureCounter += 1;
+            const nameIdx = headerIndices.name ?? 0;
+            const priorityIdx = headerIndices.priority ?? (nameIdx + 1);
+            const descIdx = headerIndices.description ?? (priorityIdx + 1);
+            const acIdx = headerIndices.acceptanceCriteria ?? (descIdx + 1);
+            const feature = {
+                id: headerIndices.id !== undefined ? (cells[headerIndices.id] ?? `F-${featureCounter}`) : `F-${featureCounter}`,
+                name: cells[nameIdx] ?? `Feature ${featureCounter}`,
+                priority: cells[priorityIdx] ?? 'medium',
+                description: cells[descIdx] ?? '',
+                acceptanceCriteria: cells[acIdx] ?? '',
+            };
+            features.push(feature);
+        }
+    }
+    return features;
+}
+function parseDesignDocument(designContent) {
+    const design = {
+        modules: [],
+        apis: [],
+        dataModels: [],
+    };
+    const archSection = extractSection(designContent, '架构设计');
+    const moduleMatches = archSection.match(/[-*]\s+(.+)/g);
+    if (moduleMatches) {
+        design.modules = moduleMatches.map((m) => m.replace(/^[-*]\s+/, '').trim());
+    }
+    const apiSection = extractSection(designContent, '接口设计');
+    const apiMatches = apiSection.match(/[-*]\s+(.+)/g);
+    if (apiMatches) {
+        design.apis = apiMatches.map((m) => m.replace(/^[-*]\s+/, '').trim());
+    }
+    const dataSection = extractSection(designContent, '数据模型');
+    const dataMatches = dataSection.match(/[-*]\s+(.+)/g);
+    if (dataMatches) {
+        design.dataModels = dataMatches.map((m) => m.replace(/^[-*]\s+/, '').trim());
+    }
+    return design;
+}
+function inferPhase(priority) {
+    const normalizedPriority = PRIORITY_MAP[priority] || priority;
+    switch (normalizedPriority) {
+        case 'high':
+            return 2;
+        case 'medium':
+            return 3;
+        case 'low':
+            return 4;
+        default:
+            return 3;
+    }
+}
+function inferFiles(feature, _design) {
+    const files = [];
+    const featureLower = (feature.name + ' ' + feature.description).toLowerCase();
+    if (featureLower.includes('api') || featureLower.includes('接口')) {
+        files.push('src/api/');
+    }
+    if (featureLower.includes('数据') || featureLower.includes('database') || featureLower.includes('model')) {
+        files.push('src/models/');
+    }
+    if (featureLower.includes('页面') || featureLower.includes('page') || featureLower.includes('ui')) {
+        files.push('src/pages/');
+    }
+    if (featureLower.includes('组件') || featureLower.includes('component')) {
+        files.push('src/components/');
+    }
+    if (featureLower.includes('工具') || featureLower.includes('util') || featureLower.includes('helper')) {
+        files.push('src/utils/');
+    }
+    if (files.length === 0) {
+        files.push('src/');
+    }
+    return files;
+}
+function parseDocumentsToTasks(prdContent, designContent, _changeName) {
+    const tasks = [];
+    const design = designContent ? parseDesignDocument(designContent) : { modules: [], apis: [], dataModels: [] };
+    const hasArchitectureTask = design.modules.length > 0 || designContent;
+    if (hasArchitectureTask) {
+        tasks.push({
+            id: 'PHASE-1-1-1',
+            phase: 1,
+            subphase: 1,
+            sequence: 1,
+            title: '搭建基础架构',
+            type: 'feat',
+            priority: 'high',
+            status: 'pending',
+            dependencies: [],
+            spec: {
+                description: '根据技术规格搭建项目基础架构',
+                files: ['src/'],
+                context: design.modules,
+            },
+            acceptance_criteria: ['架构符合设计文档', '模块划分清晰'],
+        });
+    }
+    const featureSection = extractSection(prdContent, '(详细功能需求|功能需求)');
+    const features = parseFeatureTable(featureSection);
+    const phaseTaskCount = {};
+    for (const feature of features) {
+        const phase = inferPhase(feature.priority);
+        if (!phaseTaskCount[phase]) {
+            phaseTaskCount[phase] = 1;
+        }
+        else {
+            phaseTaskCount[phase] += 1;
+        }
+        const taskId = `PHASE-${phase}-${phase}-${phaseTaskCount[phase]}`;
+        const files = inferFiles(feature, design);
+        const priority = PRIORITY_MAP[feature.priority] || 'medium';
+        const task = {
+            id: taskId,
+            phase,
+            subphase: phase,
+            sequence: phaseTaskCount[phase],
+            title: feature.name,
+            type: 'feat',
+            priority: priority,
+            status: 'pending',
+            dependencies: hasArchitectureTask ? ['PHASE-1-1-1'] : [],
+            spec: {
+                description: feature.description || feature.name,
+                files,
+                context: [],
+            },
+            acceptance_criteria: feature.acceptanceCriteria
+                ? feature.acceptanceCriteria.split(/\n/).filter((s) => s.length > 0)
+                : ['功能正常工作', '测试通过'],
+        };
+        tasks.push(task);
+    }
+    const nonFuncSection = extractSection(prdContent, '非功能性需求');
+    if (nonFuncSection && nonFuncSection.length > 50) {
+        const lastTaskId = tasks.length > 0 ? tasks[tasks.length - 1]?.id : undefined;
+        tasks.push({
+            id: `PHASE-5-5-1`,
+            phase: 5,
+            subphase: 5,
+            sequence: 1,
+            title: '非功能性需求实现',
+            type: 'feat',
+            priority: 'medium',
+            status: 'pending',
+            dependencies: lastTaskId ? [lastTaskId] : [],
+            spec: {
+                description: '实现性能、安全、可用性等非功能性需求',
+                files: ['src/'],
+                context: [],
+            },
+            acceptance_criteria: ['性能达标', '安全检查通过', '可用性要求满足'],
+        });
+    }
+    return tasks;
+}
+function extractProjectName(prdContent) {
+    const lines = prdContent.split(/\r?\n/);
+    for (const line of lines) {
+        const headingMatch = line.match(/^#\s+(.+)$/);
+        if (headingMatch) {
+            return headingMatch[1] || 'Unknown Project';
+        }
+    }
+    return 'Unknown Project';
+}

package/dist/commands/tasks-gen/generators.d.ts

@@ -0,0 +1,33 @@
+/**
+ * commands/tasks-gen/generators.ts
+ * Task file generation utilities
+ */
+import { Task } from './types';
+/**
+ * Generate a single phase JSON object
+ */
+export declare function generatePhaseJson(task: Task, changeName: string, allTaskIds?: string[]): Record<string, unknown>;
+/**
+ * Generate manifest JSON
+ */
+export declare function generateManifestJson(changeName: string, tasks: Task[], options?: {
+    type?: string;
+    priority?: string;
+}): Record<string, unknown>;
+/**
+ * Generate phase JSON files for all tasks
+ */
+export declare function generatePhaseFiles(tasksDir: string, tasks: Task[], changeName: string): {
+    generatedFiles: string[];
+    allTaskIds: string[];
+    error?: string;
+};
+/**
+ * Generate manifest JSON file
+ */
+export declare function generateManifestFile(manifestPath: string, changeName: string, tasks: Task[], options?: {
+    type?: string;
+    priority?: string;
+}): {
+    error?: string;
+};

package/dist/commands/tasks-gen/generators.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * commands/tasks-gen/generators.ts
+ * Task file generation utilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePhaseJson = generatePhaseJson;
+exports.generateManifestJson = generateManifestJson;
+exports.generatePhaseFiles = generatePhaseFiles;
+exports.generateManifestFile = generateManifestFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Generate a single phase JSON object
+ */
+function generatePhaseJson(task, changeName, allTaskIds = []) {
+    const dependencies = task.dependencies || [];
+    const invalidDependencies = dependencies.filter((depId) => !allTaskIds.includes(depId));
+    if (invalidDependencies.length > 0) {
+        console.warn(`[TASKS] Warning: Invalid dependencies found: ${invalidDependencies.join(', ')}`);
+        console.warn(`[TASKS] Available task IDs: ${allTaskIds.join(', ')}`);
+    }
+    return {
+        id: task.id,
+        type: task.type,
+        title: task.title,
+        priority: task.priority,
+        phase: task.phase,
+        dependencies: dependencies.filter((depId) => allTaskIds.includes(depId)),
+        docs_to_read: task.docs_to_read || [
+            `spec/changes/${changeName}/product-requirement.md`,
+            `spec/changes/${changeName}/design.md`,
+        ],
+        spec: {
+            description: task.spec.description || task.title,
+            files: task.spec.files.length > 0 ? task.spec.files : ['src/README.md'],
+            context: task.spec.context || [],
+        },
+        acceptance_criteria: task.acceptance_criteria && task.acceptance_criteria.length > 0
+            ? task.acceptance_criteria
+            : ['功能正常工作'],
+        implementation: task.implementation || {
+            steps: [],
+            notes: '',
+        },
+        validation: task.validation || {
+            commands: [],
+            manual_checks: [],
+        },
+        status: task.status,
+    };
+}
+/**
+ * Generate manifest JSON
+ */
+function generateManifestJson(changeName, tasks, options = {}) {
+    return {
+        version: '1.0',
+        taskId: changeName,
+        type: options.type || 'feat',
+        priority: options.priority || 'medium',
+        title: changeName,
+        changeName,
+        totalTasks: tasks.length,
+        phases: [...new Set(tasks.map((t) => t.phase))].sort((a, b) => a - b),
+        mergeStrategy: {
+            type: 'squash',
+            deleteBranch: true,
+            deleteWorktree: true,
+        },
+        createdAt: new Date().toISOString(),
+    };
+}
+/**
+ * Generate phase JSON files for all tasks
+ */
+function generatePhaseFiles(tasksDir, tasks, changeName) {
+    try {
+        fs.mkdirSync(tasksDir, { recursive: true });
+        const allTaskIds = tasks.map((t) => t.id);
+        const generatedFiles = [];
+        for (const task of tasks) {
+            const taskJsonPath = path.resolve(tasksDir, `${task.id}.json`);
+            const taskJson = generatePhaseJson(task, changeName, allTaskIds);
+            fs.writeFileSync(taskJsonPath, JSON.stringify(taskJson, null, 2), 'utf8');
+            generatedFiles.push(taskJsonPath);
+        }
+        return { generatedFiles, allTaskIds };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return { generatedFiles: [], allTaskIds: [], error: errorMessage };
+    }
+}
+/**
+ * Generate manifest JSON file
+ */
+function generateManifestFile(manifestPath, changeName, tasks, options = {}) {
+    try {
+        const manifestJson = generateManifestJson(changeName, tasks, options);
+        fs.writeFileSync(manifestPath, JSON.stringify(manifestJson, null, 2), 'utf8');
+        return {};
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return { error: errorMessage };
+    }
+}

package/dist/commands/tasks-gen/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * commands/tasks-gen/index.ts
+ * Generate PHASE-*.json files from product-requirement.md and design.md
+ * Supports AI input via stdin or --input parameter
+ */
+import { TasksGenOptions, TasksGenResult } from './types';
+import { parseTasksMd } from './parsers';
+import { generatePhaseJson, generateManifestJson } from './generators';
+/**
+ * Generate task files from AI input or tasks.md
+ */
+export declare function generateTasks(options?: TasksGenOptions): Promise<TasksGenResult>;
+/**
+ * Main entry point
+ */
+export declare function main(): void;
+declare const _default: {
+    generateTasks: typeof generateTasks;
+    parseTasksMd: typeof parseTasksMd;
+    generatePhaseJson: typeof generatePhaseJson;
+    generateManifestJson: typeof generateManifestJson;
+    TASK_SCHEMA: {
+        required: string[];
+        idPattern: RegExp;
+        types: string[];
+        priorities: string[];
+        statuses: string[];
+    };
+};
+export default _default;