@bicorne/task-flow 0.1.0

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

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * commands/tasks-gen/index.ts
+ * Generate PHASE-*.json files from product-requirement.md and design.md
+ * Supports AI input via stdin or --input parameter
+ */
+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.generateTasks = generateTasks;
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../../lib/config");
+const types_1 = require("./types");
+const templates_1 = require("./templates");
+const parsers_1 = require("./parsers");
+const generators_1 = require("./generators");
+const validators_1 = require("./validators");
+const doc_parser_1 = require("./doc-parser");
+function loadTemplate(name) {
+    const templatePath = path.resolve(__dirname, '../../../assets', name);
+    if (fs.existsSync(templatePath)) {
+        return fs.readFileSync(templatePath, 'utf8');
+    }
+    return null;
+}
+function createTasksTemplate(tasksPath) {
+    if (fs.existsSync(tasksPath)) {
+        return { created: false };
+    }
+    try {
+        const templateContent = loadTemplate('tasks.md') || templates_1.TASKS_MD_TEMPLATE;
+        fs.writeFileSync(tasksPath, templateContent, 'utf8');
+        return {
+            created: true,
+            reason: 'tasks-md-created',
+            message: `tasks.md created. Please edit and confirm: ${tasksPath}`,
+            tasksPath,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            created: false,
+            reason: 'file-write-error',
+            message: `Failed to create tasks.md: ${errorMessage}`,
+            tasksPath,
+        };
+    }
+}
+/**
+ * Generate task files from AI input or tasks.md
+ */
+async function generateTasks(options = {}) {
+    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
+    const changeName = (0, parsers_1.toChangeName)(options.change);
+    if (!changeName) {
+        return {
+            success: false,
+            reason: 'missing-change',
+            message: 'Missing required argument: --change <change-name>',
+        };
+    }
+    const specRoot = config.specRootAbs || path.resolve(config.projectRoot, 'spec');
+    const changeDir = path.resolve(specRoot, 'changes', changeName);
+    const productRequirementPath = path.resolve(changeDir, 'product-requirement.md');
+    const tasksPath = path.resolve(changeDir, 'tasks.md');
+    const tasksDir = path.resolve(changeDir, 'tasks');
+    const manifestPath = path.resolve(changeDir, 'manifest.json');
+    let tasks;
+    if (options.input) {
+        try {
+            tasks = (0, parsers_1.parseAiInput)(options.input);
+            console.log(`[TASKS] Parsed ${tasks.length} tasks from --input parameter`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                success: false,
+                reason: 'input-parse-error',
+                message: `Failed to parse input: ${errorMessage}`,
+            };
+        }
+    }
+    else if (!process.stdin.isTTY) {
+        try {
+            const stdinContent = await (0, parsers_1.readStdin)();
+            if (stdinContent.trim()) {
+                tasks = (0, parsers_1.parseAiInput)(stdinContent);
+                console.log(`[TASKS] Parsed ${tasks.length} tasks from stdin`);
+            }
+            else {
+                const validation = (0, validators_1.validateRequiredFiles)({ productRequirement: productRequirementPath });
+                if (!validation.valid) {
+                    return {
+                        success: false,
+                        reason: validation.reason,
+                        message: validation.message,
+                    };
+                }
+                const designPath = path.resolve(changeDir, 'design.md');
+                const hasDesign = fs.existsSync(designPath);
+                console.log('[TASKS] Attempting to extract tasks from documents...');
+                const prdContent = fs.readFileSync(productRequirementPath, 'utf8');
+                const designContent = hasDesign ? fs.readFileSync(designPath, 'utf8') : null;
+                tasks = (0, doc_parser_1.parseDocumentsToTasks)(prdContent, designContent, changeName);
+                if (tasks.length === 0) {
+                    console.log('[TASKS] No tasks extracted, falling back to tasks.md');
+                    const templateResult = createTasksTemplate(tasksPath);
+                    if (templateResult.created) {
+                        return {
+                            success: false,
+                            reason: templateResult.reason,
+                            message: templateResult.message,
+                            tasksPath: templateResult.tasksPath,
+                        };
+                    }
+                    const tasksContent = fs.readFileSync(tasksPath, 'utf8');
+                    tasks = (0, parsers_1.parseTasksMd)(tasksContent);
+                }
+                else {
+                    console.log(`[TASKS] Successfully extracted ${tasks.length} tasks from documents`);
+                }
+            }
+        }
+        catch (error) {
+            if (error.message.includes('Stdin timeout')) {
+                const validation = (0, validators_1.validateRequiredFiles)({ productRequirement: productRequirementPath });
+                if (!validation.valid) {
+                    return {
+                        success: false,
+                        reason: validation.reason,
+                        message: validation.message,
+                    };
+                }
+                const designPath = path.resolve(changeDir, 'design.md');
+                const hasDesign = fs.existsSync(designPath);
+                console.log('[TASKS] Attempting to extract tasks from documents...');
+                const prdContent = fs.readFileSync(productRequirementPath, 'utf8');
+                const designContent = hasDesign ? fs.readFileSync(designPath, 'utf8') : null;
+                tasks = (0, doc_parser_1.parseDocumentsToTasks)(prdContent, designContent, changeName);
+                if (tasks.length === 0) {
+                    console.log('[TASKS] No tasks extracted, falling back to tasks.md');
+                    const templateResult = createTasksTemplate(tasksPath);
+                    if (templateResult.created) {
+                        return {
+                            success: false,
+                            reason: templateResult.reason,
+                            message: templateResult.message,
+                            tasksPath: templateResult.tasksPath,
+                        };
+                    }
+                    const tasksContent = fs.readFileSync(tasksPath, 'utf8');
+                    tasks = (0, parsers_1.parseTasksMd)(tasksContent);
+                }
+                else {
+                    console.log(`[TASKS] Successfully extracted ${tasks.length} tasks from documents`);
+                }
+            }
+            else {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    success: false,
+                    reason: 'stdin-parse-error',
+                    message: `Failed to parse stdin: ${errorMessage}`,
+                };
+            }
+        }
+    }
+    else {
+        const validation = (0, validators_1.validateRequiredFiles)({ productRequirement: productRequirementPath });
+        if (!validation.valid) {
+            return {
+                success: false,
+                reason: validation.reason,
+                message: validation.message,
+            };
+        }
+        const designPath = path.resolve(changeDir, 'design.md');
+        const hasDesign = fs.existsSync(designPath);
+        console.log('[TASKS] Attempting to extract tasks from documents...');
+        console.log(`  PRD: ${productRequirementPath}`);
+        if (hasDesign) {
+            console.log(`  Design: ${designPath}`);
+        }
+        try {
+            const prdContent = fs.readFileSync(productRequirementPath, 'utf8');
+            const designContent = hasDesign ? fs.readFileSync(designPath, 'utf8') : null;
+            tasks = (0, doc_parser_1.parseDocumentsToTasks)(prdContent, designContent, changeName);
+            if (tasks.length > 0) {
+                console.log(`[TASKS] Successfully extracted ${tasks.length} tasks from documents`);
+            }
+            else {
+                console.log('[TASKS] No tasks extracted from documents, falling back to tasks.md');
+                const templateResult = createTasksTemplate(tasksPath);
+                if (templateResult.created) {
+                    return {
+                        success: false,
+                        reason: templateResult.reason,
+                        message: templateResult.message,
+                        tasksPath: templateResult.tasksPath,
+                    };
+                }
+                const tasksContent = fs.readFileSync(tasksPath, 'utf8');
+                tasks = (0, parsers_1.parseTasksMd)(tasksContent);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.log(`[TASKS] Failed to extract from documents: ${errorMessage}`);
+            console.log('[TASKS] Falling back to tasks.md');
+            const templateResult = createTasksTemplate(tasksPath);
+            if (templateResult.created) {
+                return {
+                    success: false,
+                    reason: templateResult.reason,
+                    message: templateResult.message,
+                    tasksPath: templateResult.tasksPath,
+                };
+            }
+            const tasksContent = fs.readFileSync(tasksPath, 'utf8');
+            tasks = (0, parsers_1.parseTasksMd)(tasksContent);
+        }
+    }
+    if (tasks.length === 0) {
+        return {
+            success: false,
+            reason: 'no-tasks',
+            message: 'No valid tasks found. Please provide tasks via --input, stdin, or tasks.md file.',
+        };
+    }
+    console.log('');
+    console.log('[TASKS] Task list preview:');
+    console.log(`  Total tasks: ${tasks.length}`);
+    console.log(`  Phases: ${[...new Set(tasks.map((t) => t.phase))].sort((a, b) => a - b).join(', ')}`);
+    console.log('');
+    if (!options.yes && process.stdin.isTTY) {
+        const confirmed = await (0, parsers_1.promptConfirmation)('Proceed to generate PHASE-*.json files? [Y/n] ');
+        if (!confirmed) {
+            return {
+                success: false,
+                reason: 'user-cancelled',
+                message: 'User cancelled the operation.',
+            };
+        }
+    }
+    const { generatedFiles, error: phaseError } = (0, generators_1.generatePhaseFiles)(tasksDir, tasks, changeName);
+    if (phaseError) {
+        return {
+            success: false,
+            reason: 'phase-file-error',
+            message: `Failed to generate phase files: ${phaseError}`,
+        };
+    }
+    const manifestResult = (0, generators_1.generateManifestFile)(manifestPath, changeName, tasks, options);
+    if (manifestResult.error) {
+        return {
+            success: false,
+            reason: 'manifest-file-error',
+            message: `Failed to generate manifest file: ${manifestResult.error}`,
+        };
+    }
+    return {
+        success: true,
+        changeName,
+        tasksPath,
+        tasksDir,
+        manifestPath,
+        generatedFiles,
+        totalTasks: tasks.length,
+    };
+}
+/**
+ * Main entry point
+ */
+function main() {
+    const args = (0, parsers_1.parseArgs)(process.argv);
+    generateTasks({
+        cwd: args.cwd,
+        change: args.change,
+        type: args.type,
+        priority: args.priority,
+        yes: args.yes === true,
+        input: args.input,
+    }).then((result) => {
+        if (!result.success) {
+            console.error(`[TASKS] ${result.message}`);
+            process.exit(result.reason === 'tasks-md-created' ? 0 : 1);
+        }
+        console.log('');
+        console.log('[TASKS] Task files generated successfully!');
+        console.log(`  Change Name: ${result.changeName}`);
+        console.log(`  Tasks Dir: ${result.tasksDir}`);
+        console.log(`  Manifest: ${result.manifestPath}`);
+        console.log(`  Generated: ${result.generatedFiles?.length || 0} PHASE-*.json files`);
+        console.log('');
+        console.log('Next steps:');
+        console.log('  1. Review generated task files');
+        console.log('  2. Run: task-flow worktree --change <change-name>');
+        console.log('');
+        process.exit(0);
+    });
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    generateTasks,
+    parseTasksMd: parsers_1.parseTasksMd,
+    generatePhaseJson: generators_1.generatePhaseJson,
+    generateManifestJson: generators_1.generateManifestJson,
+    TASK_SCHEMA: types_1.TASK_SCHEMA,
+};

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

@@ -0,0 +1,29 @@
+/**
+ * commands/tasks-gen/parsers.ts
+ * Parsing utilities for task generation
+ */
+import { Task } from './types';
+/**
+ * Parse CLI arguments
+ */
+export declare function parseArgs(argv: string[]): Record<string, string | boolean>;
+/**
+ * Sanitize change name
+ */
+export declare function toChangeName(input: string | undefined): string;
+/**
+ * Parse tasks from markdown content
+ */
+export declare function parseTasksMd(tasksContent: string): Task[];
+/**
+ * Parse AI input from JSON
+ */
+export declare function parseAiInput(input: string): Task[];
+/**
+ * Read stdin content
+ */
+export declare function readStdin(): Promise<string>;
+/**
+ * Prompt user for confirmation
+ */
+export declare function promptConfirmation(message: string): Promise<boolean>;

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

@@ -0,0 +1,272 @@
+"use strict";
+/**
+ * commands/tasks-gen/parsers.ts
+ * Parsing utilities for task generation
+ */
+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.parseArgs = parseArgs;
+exports.toChangeName = toChangeName;
+exports.parseTasksMd = parseTasksMd;
+exports.parseAiInput = parseAiInput;
+exports.readStdin = readStdin;
+exports.promptConfirmation = promptConfirmation;
+const readline = __importStar(require("readline"));
+const types_1 = require("./types");
+/**
+ * Parse CLI arguments
+ */
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 2; i < argv.length; i += 1) {
+        const token = argv[i] || '';
+        if (!token.startsWith('--')) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[i + 1] || '';
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        i += 1;
+    }
+    return args;
+}
+/**
+ * Sanitize change name
+ */
+function toChangeName(input) {
+    return String(input || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Parse tasks from markdown content
+ */
+function parseTasksMd(tasksContent) {
+    const tasks = [];
+    const lines = tasksContent.split(/\r?\n/);
+    let currentTask = null;
+    let inDependencySection = false;
+    for (const line of lines) {
+        const phaseMatch = line.match(/^###\s+Phase\s+(\d+)/i);
+        if (phaseMatch) {
+            continue;
+        }
+        const taskMatch = line.match(/^-\s+\[([ xX])\]\s+Task\s+(\d+)\.(\d+):\s+(.+)$/);
+        if (taskMatch) {
+            if (currentTask && currentTask.id) {
+                tasks.push(currentTask);
+            }
+            const phase = parseInt(taskMatch[2] || '0', 10);
+            const sequence = parseInt(taskMatch[3] || '0', 10);
+            currentTask = {
+                id: `PHASE-${phase}-${phase}-${sequence}`,
+                phase,
+                subphase: phase,
+                sequence,
+                title: taskMatch[4]?.trim() || '',
+                status: taskMatch[1]?.toLowerCase() === 'x' ? 'completed' : 'pending',
+                type: 'feat',
+                priority: 'medium',
+                dependencies: [],
+                spec: {
+                    description: '',
+                    files: [],
+                    context: [],
+                },
+                acceptance_criteria: [],
+            };
+            inDependencySection = false;
+            continue;
+        }
+        if (line.includes('## 任务依赖关系') || line.includes('Dependencies')) {
+            inDependencySection = true;
+            continue;
+        }
+        if (currentTask && !inDependencySection) {
+            const descMatch = line.match(/^\s+描述:\s*(.+)$/);
+            if (descMatch) {
+                currentTask.spec.description = descMatch?.[1]?.trim() || '';
+                continue;
+            }
+            const filesMatch = line.match(/^\s+文件:\s*(.+)$/);
+            if (filesMatch) {
+                currentTask.spec.files = filesMatch?.[1]?.split(',').map((f) => f.trim()).filter(Boolean) || [];
+                continue;
+            }
+            const acceptMatch = line.match(/^\s+验收:\s*(.+)$/);
+            if (acceptMatch) {
+                currentTask.acceptance_criteria = [acceptMatch?.[1]?.trim() || ''];
+                continue;
+            }
+        }
+        if (inDependencySection && currentTask) {
+            const depMatch = line.match(/Task\s+(\d+)\.(\d+)\s+(?:依赖|depends? on)\s+Task\s+(\d+)\.(\d+)/i);
+            if (depMatch) {
+                const depPhase = parseInt(depMatch[3] || '0', 10);
+                const depSeq = parseInt(depMatch[4] || '0', 10);
+                if (depPhase <= currentTask.phase) {
+                    currentTask.dependencies.push(`PHASE-${depPhase}-${depPhase}-${depSeq}`);
+                }
+            }
+        }
+    }
+    if (currentTask && currentTask.id) {
+        tasks.push(currentTask);
+    }
+    return tasks;
+}
+/**
+ * Parse AI input from JSON
+ */
+function parseAiInput(input) {
+    try {
+        const parsed = JSON.parse(input);
+        let tasks;
+        if (Array.isArray(parsed)) {
+            tasks = parsed;
+        }
+        else if (parsed && typeof parsed === 'object' && Array.isArray(parsed.tasks)) {
+            tasks = parsed.tasks;
+        }
+        else {
+            throw new Error('Invalid input format: expected array or { tasks: [] }');
+        }
+        const validTasks = [];
+        const errors = [];
+        for (let i = 0; i < tasks.length; i += 1) {
+            if (validateTask(tasks[i])) {
+                validTasks.push(tasks[i]);
+            }
+            else {
+                errors.push(`Task ${i}: validation failed`);
+            }
+        }
+        if (errors.length > 0) {
+            console.warn('[TASKS] Validation warnings:');
+            errors.forEach((err) => console.warn(`  - ${err}`));
+        }
+        return validTasks;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to parse AI input: ${errorMessage}`);
+    }
+}
+/**
+ * Read stdin content
+ */
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('readable', () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) !== null) {
+                chunks.push(chunk);
+            }
+        });
+        process.stdin.on('end', () => {
+            resolve(chunks.join(''));
+        });
+        process.stdin.on('error', (error) => {
+            reject(error);
+        });
+        setTimeout(() => {
+            if (chunks.length === 0) {
+                reject(new Error('Stdin timeout: no data received'));
+            }
+        }, 5000);
+    });
+}
+/**
+ * Prompt user for confirmation
+ */
+function promptConfirmation(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(message, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes' || answer === '');
+        });
+        rl.on('error', () => {
+            rl.close();
+            resolve(false);
+        });
+    });
+}
+/**
+ * Validate a single task object
+ */
+function validateTask(task) {
+    if (typeof task !== 'object' || task === null) {
+        return false;
+    }
+    const t = task;
+    if (typeof t.id !== 'string' || !types_1.TASK_SCHEMA.idPattern.test(t.id)) {
+        return false;
+    }
+    if (!types_1.TASK_SCHEMA.types.includes(t.type)) {
+        return false;
+    }
+    if (typeof t.title !== 'string' || t.title.length === 0) {
+        return false;
+    }
+    if (!types_1.TASK_SCHEMA.priorities.includes(t.priority)) {
+        return false;
+    }
+    if (typeof t.phase !== 'number' || t.phase < 1) {
+        return false;
+    }
+    if (!types_1.TASK_SCHEMA.statuses.includes(t.status)) {
+        return false;
+    }
+    if (typeof t.spec !== 'object' || t.spec === null) {
+        return false;
+    }
+    const spec = t.spec;
+    if (typeof spec.description !== 'string' || !Array.isArray(spec.files)) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * commands/tasks-gen/templates.ts
+ * Markdown templates for task generation
+ */
+/**
+ * Tasks.md template
+ */
+export declare const TASKS_MD_TEMPLATE = "# \u4EFB\u52A1\u6E05\u5355\n\n## \u6982\u8FF0\n<!-- \u4EFB\u52A1\u6982\u8FF0 -->\n\n## \u4EFB\u52A1\u5217\u8868\n\n### Phase 1: \u57FA\u7840\u5B9E\u73B0\n\n- [ ] Task 1.1: \u4EFB\u52A1\u6807\u9898\n  - \u63CF\u8FF0\uFF1A\u4EFB\u52A1\u63CF\u8FF0\n  - \u6587\u4EF6\uFF1Asrc/file1.ts, src/file2.ts\n  - \u9A8C\u6536\uFF1A\u9A8C\u6536\u6807\u51C6\n\n### Phase 2: \u6269\u5C55\u529F\u80FD\n\n- [ ] Task 2.1: \u4EFB\u52A1\u6807\u9898\n  - \u63CF\u8FF0\uFF1A\u4EFB\u52A1\u63CF\u8FF0\n  - \u6587\u4EF6\uFF1Asrc/file3.ts\n  - \u9A8C\u6536\uFF1A\u9A8C\u6536\u6807\u51C6\n\n---\n\n## \u4EFB\u52A1\u4F9D\u8D56\u5173\u7CFB\n\n- Task 2.1 \u4F9D\u8D56 Task 1.1\n";

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

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * commands/tasks-gen/templates.ts
+ * Markdown templates for task generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASKS_MD_TEMPLATE = void 0;
+/**
+ * Tasks.md template
+ */
+exports.TASKS_MD_TEMPLATE = `# 任务清单
+
+## 概述
+<!-- 任务概述 -->
+
+## 任务列表
+
+### Phase 1: 基础实现
+
+- [ ] Task 1.1: 任务标题
+  - 描述：任务描述
+  - 文件：src/file1.ts, src/file2.ts
+  - 验收：验收标准
+
+### Phase 2: 扩展功能
+
+- [ ] Task 2.1: 任务标题
+  - 描述：任务描述
+  - 文件：src/file3.ts
+  - 验收：验收标准
+
+---
+
+## 任务依赖关系
+
+- Task 2.1 依赖 Task 1.1
+`;