speccore 8.3.285 → 8.3.295

package/dist/commands/iteration/taskify.js

@@ -161,6 +161,35 @@ function extractTopic(task) {
     // 4. fallback 到 hash
     return slugify(task.name || task.functionalUnit || 'task');
 }
+/**
+ * 构建任务目录名 topic（v8.3.294+）
+ *
+ * bugfix 任务带模块血缘：目录名拼为「{模块英文}-{bug内容英文}」（如 Task-003-login-flow-timeout-crash），
+ * 同一模块的 bug 任务在 030-tasks/bugfix/ 下自然相邻，方便浏览。
+ * 模块名 AI 英译（moduleTopic）优先、拼音兜底（toSlug 内置 pinyin），
+ * 与功能单元命名「LLM 英译 + 拼音兜底」模式一致。
+ * 其余任务类型保持原语义（functionalUnit → topic → name 链）。
+ */
+function buildTaskTopic(sec, taskType) {
+    const functionalUnit = sec.functionalUnit || '';
+    const bugTopic = sec._topic || '';
+    if (taskType === 'bugfix') {
+        // 模块名：AI 英译 moduleTopic 优先 → functionalUnit 拼音兜底
+        const moduleSlug = sec._moduleTopic
+            || (functionalUnit ? (0, global_counters_1.toSlug)(functionalUnit) : '');
+        // bug 内容名：AI 英译 topic 优先 → 任务名拼音兜底
+        const bugSlug = bugTopic || (0, global_counters_1.toSlug)(sec.name || 'bug');
+        if (moduleSlug && bugSlug) {
+            // 防重复：bug 内容名已含模块名时不再叠加（如 topic 写全了 login-flow-timeout）
+            if (bugSlug.startsWith(moduleSlug))
+                return bugSlug.slice(0, 40);
+            // 模块名前段（≤15）+ 内容名，总长受 nextTaskId 的 40 字符上限约束
+            return `${moduleSlug.slice(0, 15)}-${bugSlug}`.slice(0, 40);
+        }
+        return (moduleSlug || bugSlug).slice(0, 40);
+    }
+    return functionalUnit || bugTopic || slugify(sec.name);
+}
 /**
  * 生成子任务全局唯一 ID
  * 格式: Task-{父任务ID}-{端名}
@@ -704,6 +733,11 @@ async function iterationTaskifyCommand(options) {
                     section._taskType = taskType;
                     // 保存 topic slug，用于生成任务目录名（v8.3.77+: 多层提取）
                     section._topic = extractTopic(task);
+                    // v8.3.294+: 透传 AI 提供的模块英文 slug（bugfix 目录名「模块名-内容名」拼接用），
+                    // 仅接受合法英文短横线格式，非法时回退拼音兜底
+                    if (task.moduleTopic && /^[a-z0-9-]+$/.test(task.moduleTopic)) {
+                        section._moduleTopic = task.moduleTopic;
+                    }
                     // 保存 AI 生成的实际内容（用于写入 REQ.md / TECH.md）
                     if (task.reqContent)
                         section._reqContent = task.reqContent;
@@ -712,6 +746,13 @@ async function iterationTaskifyCommand(options) {
                     // v7.4.0+: 保存 AI 生成的 DEV_GUIDE 内容
                     if (task.devGuideContent)
                         section._devGuideContent = task.devGuideContent;
+                    // v8.3.291: 保存 AI 输出的依赖关系与临时 ID——dependencies 此前只用于日志展示，
+                    // 从未写入 _dependsOn，导致 plan 拓扑排期 / execute 依赖分支合并永远拿空数组
+                    if (task.id)
+                        section._aiId = String(task.id);
+                    if (Array.isArray(task.dependencies)) {
+                        section._aiDeps = task.dependencies.filter((d) => typeof d === 'string' && d.trim());
+                    }
                     if (task.sourceFile)
                         section._sourceFile = task.sourceFile;
                     if (task.functionalUnit)
@@ -984,6 +1025,44 @@ async function iterationTaskifyCommand(options) {
                     }
                     logger_1.logger.info('');
                 }
+                // ── v8.3.291: 预分配任务 ID 并解析 AI 依赖关系 ──
+                // 修复：AI 返回的 dependencies 字段此前只用于日志展示（仅 1055 行 const deps），
+                // 从未写入 section._dependsOn，导致 TASK.md「依赖任务」恒为「无」，
+                // 下游 plan 拓扑分阶段 / execute 依赖分支合并（prepareTaskBranch）全部失效。
+                // 预分配 ID 后建立「AI 临时 id → 实际 taskId」映射，把 dependencies 解析为实际 ID。
+                const aiIdToTaskId = new Map();
+                for (const sec of sections) {
+                    // v8.3.294+: bugfix 任务目录名拼「模块英文-内容英文」，其余类型保持原链
+                    const taskType = sec._taskType || 'feature';
+                    const taskTopic = buildTaskTopic(sec, taskType);
+                    const { id: taskId } = await (0, global_counters_1.nextTaskId)(sec.name, taskTopic);
+                    sec._taskId = taskId;
+                    const aiId = sec._aiId;
+                    if (aiId)
+                        aiIdToTaskId.set(aiId, taskId);
+                }
+                let resolvedDepCount = 0;
+                for (const sec of sections) {
+                    const rawDeps = sec._aiDeps;
+                    if (!rawDeps || rawDeps.length === 0)
+                        continue;
+                    const resolved = [];
+                    for (const dep of rawDeps) {
+                        const mapped = aiIdToTaskId.get(dep);
+                        if (mapped) {
+                            resolved.push(mapped);
+                            resolvedDepCount++;
+                        }
+                        else {
+                            // 无法映射的依赖（AI 引用了不存在的任务 ID）保留原始引用，execute 阶段会给出提示
+                            resolved.push(dep);
+                        }
+                    }
+                    sec._dependsOn = resolved;
+                }
+                if (resolvedDepCount > 0) {
+                    logger_1.logger.info(`   🔗 已解析 ${resolvedDepCount} 条任务依赖关系`);
+                }
                 // 逐任务交互确认
                 const createdSections = [];
                 const moduleFilter = (unit) => {
@@ -1007,7 +1086,8 @@ async function iterationTaskifyCommand(options) {
                     }
                     const complexity = sec._complexity || {};
                     const taskType = sec._taskType || 'feature';
-                    const deps = (tasks[i].dependencies || []);
+                    // 依赖已在上方预分配阶段解析为实际 taskId（v8.3.291）
+                    const deps = (sec._dependsOn || []);
                     const acs = (tasks[i].acceptanceCriteria || []);
                     // 展示任务摘要
                     logger_1.logger.info(`\n   ━━━━ 任务 ${i + 1}/${sections.length} ━━━━`);
@@ -1035,9 +1115,10 @@ async function iterationTaskifyCommand(options) {
                     }
                     // 使用保存的 topic slug 生成任务ID
                     // v8.3.33: 优先使用 functionalUnit 作为 topic，使目录名更有意义
+                    // v8.3.291: taskId 已在预分配阶段生成（依赖解析需要），此处直接复用
                     const taskTopic = sec.functionalUnit || sec._topic || slugify(sec.name);
-                    const { id: taskId } = await (0, global_counters_1.nextTaskId)(sec.name, taskTopic);
-                    sec._taskId = taskId;
+                    const taskId = sec._taskId;
+                    void taskTopic;
                     await createTaskFromSection(iterDirFull, taskId, sec, allPlatforms, taskType, sections);
                     createdSections.push(sec);
                     logger_1.logger.info(`   ✅ 创建: ${taskId} - [${taskType}] ${sec.name}`);
@@ -1400,7 +1481,9 @@ async function iterationTaskifyCommand(options) {
         logger_1.logger.info(`Platforms: ${platforms.join(', ')}`);
         // ── 预分配任务 ID（确保所有路径使用计数器，避免编号重复） ──
         for (const section of sections) {
-            const topic = slugify(section.name);
+            // v8.3.294+: bugfix 任务目录名拼「模块英文-内容英文」，其余类型保持原链
+            const taskType = section._taskType || 'feature';
+            const topic = buildTaskTopic(section, taskType);
             const { id: taskId } = await (0, global_counters_1.nextTaskId)(section.name, topic);
             section._taskId = taskId;
         }
@@ -2341,6 +2424,29 @@ ${!isBk && docSet.hasComponentTree ? '| COMPONENT_TREE.md | ⏳ | ./COMPONENT_TR
                             logger_1.logger.info(`   📄 VERIFY_SPEC.yaml 已自动生成（${routeResult.routes.length} 个场景）`);
                         }
                     }
+                    else {
+                        // v8.3.293+: 无源码可扫描（首次建设/需求阶段）时，从 020-specs 的 UI_SPEC
+                        // 「元素标识约定」清单 + 业务流程生成流程场景骨架，selector 按清单自动装配，
+                        // 弥合「分析阶段元素约定」与「冒烟配置生成阶段」之间的断链。
+                        const specTexts = [];
+                        for (const [specKey, specBody] of Object.entries(specContents)) {
+                            if (specKey.includes(platformName) && /(UI_SPEC|TEST)\.md$/.test(specKey)
+                                && !specBody.includes('SPEC-SKELETON')) {
+                                specTexts.push(specBody);
+                            }
+                        }
+                        if (specTexts.length > 0) {
+                            const spec = (0, ui_verify_1.generateSpecFromUiSpec)(specTexts.join('\n\n'), {
+                                baseUrl: 'http://localhost:3000',
+                                platform: platformName,
+                                name: `${section.name} - ${platformName} UI 验证`,
+                            });
+                            if (spec.scenarios.length > 0) {
+                                await (0, ui_verify_1.writeVerifySpec)(spec, (0, path_1.join)(subtaskDir, 'VERIFY_SPEC.yaml'));
+                                logger_1.logger.info(`   📄 VERIFY_SPEC.yaml 已按 UI_SPEC 元素清单生成（${spec.scenarios.length} 个流程场景）`);
+                            }
+                        }
+                    }
                 }
                 catch {
                     // 静默失败：源码不可用或扫描失败时不阻断 split 流程
@@ -2787,9 +2893,25 @@ async function generateImpactGraph(iterationDir, sections, platforms) {
     }
     // 语义依赖检测
     const semanticDeps = detectSemanticDependencies(sections);
+    // v8.3.291: 显式输出 AI 声明的依赖（_dependsOn），优先级高于文本/语义推断——
+    // 这是 plan 拓扑排期与 execute 依赖分支合并的权威依据
+    const explicitDeps = new Map();
+    for (const s of sections) {
+        const taskId = s._taskId;
+        const declared = s._dependsOn;
+        if (taskId && declared && declared.length > 0)
+            explicitDeps.set(taskId, declared);
+    }
     impact += '\n## Dependencies\n\n';
-    if (uniqueDeps.length > 0 || semanticDeps.size > 0) {
+    if (uniqueDeps.length > 0 || semanticDeps.size > 0 || explicitDeps.size > 0) {
         impact += '| Consumer | -> | Producer | 类型 |\n| :--- | :---: | :--- | :--- |\n';
+        // 任务声明的依赖（权威，最先列出）
+        for (const [from, targets] of explicitDeps) {
+            const fromName = sections.find(s => s._taskId === from)?.name || from;
+            for (const target of targets) {
+                impact += `| ${from}: ${fromName.slice(0, 20)} | → | ${target} | 任务声明 |\n`;
+            }
+        }
         // API 依赖
         for (const d of uniqueDeps)
             impact += `| ${d.from}: ${d.fromName.slice(0, 20)} | → | ${d.to}: ${d.toName.slice(0, 20)} | API: \`${d.reason}\` |\n`;
@@ -3829,6 +3951,7 @@ subagent, contextType) {
     p += `[\n  {\n`;
     p += `    "id": "Task-001",\n`;
     p += `    "functionalUnit": "所属功能单元/影响域（必填！见下方类型规则）",\n`;
+    p += `    "moduleTopic": "受影响模块的英文 slug（bugfix 建议提供，如 login-flow、payment-callback，目录名拼为 模块名-bug内容名）",\n`;
     p += `    "name": "任务名称（中文）",\n`;
     p += `    "topic": "english-slug-for-directory",\n`;
     p += `    "type": "feature|bugfix|refactor|research|security|performance",\n`;
@@ -3847,7 +3970,8 @@ subagent, contextType) {
     p += '```\n\n';
     p += `> **functionalUnit 必须填写**：根据任务类型语义不同：\n`;
     p += `>   - feature → 功能模块名（如：用户管理、订单系统、支付模块）\n`;
-    p += `>   - bugfix → 受影响组件/流程（如：登录流程、支付回调、数据同步）\n`;
+    p += `>   - bugfix → 受影响组件/流程（如：登录流程、支付回调、数据同步）；目录名将拼为「模块英文-bug内容英文」，\n`;
+    p += `>     建议同时提供 moduleTopic（模块英文 slug），未提供时用拼音兜底\n`;
     p += `>   - refactor → 重构目标范围（如：数据库层、API网关、状态管理）\n`;
     p += `>   - security → 安全修复范围（如：SQL注入防护、XSS修复、鉴权加固）\n`;
     p += `>   - performance → 性能优化目标（如：查询优化、缓存策略、并发提升）\n`;
@@ -4185,7 +4309,8 @@ async function generateTaskSummary(iterationDir, tasks, createdSections) {
         const aiHours = Math.round(estimatedHours * 0.7); // 预估 70% 可由 AI 完成
         const humanHours = estimatedHours - aiHours;
         const priority = task.priority || sec._complexity?.priority || 'medium';
-        const deps = (task.dependencies || []).join(', ') || '-';
+        // v8.3.291: 依赖从解析后的 _dependsOn 读取（AI 的 dependencies 字段已映射为实际 taskId）
+        const deps = (sec._dependsOn || []).join(', ') || '-';
         const risk = task.risk || 'medium';
         totalHumanHours += humanHours;
         totalAiHours += aiHours;