speccore 8.3.264 → 8.3.268

package/dist/commands/iteration/taskify.js

@@ -1701,27 +1701,49 @@ async function createTaskFromSection(iterationDir, taskId, section, allPlatforms
         taskPlatforms = [section.platform];
     }
     else {
-        // v8.3.125+: 使用三层匹配推断平台（替代脆弱的字符串包含匹配）
+        // v8.3.268: 端覆盖裁剪——_matrix 显式声明优先；为空时从 020-specs 端级文档反推
+        // （仅当端级存在非骨架、≥200 字符的 TECH/TEST/UI_SPEC 才算涉及端）；
+        // 仍无结果才回退 Spec 匹配 + 六层推断。修复 _matrix platforms 全空时
+        // 每 Task 平铺全部端、幽灵端子任务无中生有（17 Task × 4 端 ≈ 半数无真实规格）。
         taskPlatforms = [];
         const sectionFeatureName = section.name.replace(/^\d+(\.\d+)*\s*/, '').trim();
-        for (const platform of allPlatforms) {
-            const bestMatch = findBestSpecMatch(specContents, sectionFeatureName, platform, 'TECH.md');
-            if (bestMatch && bestMatch.score >= 20) {
-                taskPlatforms.push(platform);
+        const matrixPlatforms = await readMatrixPlatforms(iterationDir, sectionFeatureName);
+        if (matrixPlatforms.length > 0) {
+            taskPlatforms = matrixPlatforms;
+        }
+        else {
+            for (const platform of allPlatforms) {
+                const hasRealSpec = Object.entries(specContents).some(([key, content]) => {
+                    const parts = key.split('/');
+                    return parts.length >= 3 && parts[0].includes(sectionFeatureName) && parts[1] === platform &&
+                        /(TECH|TEST|UI_SPEC)\.md$/.test(parts[2]) &&
+                        !content.includes('SPEC-SKELETON') && content.trim().length >= 200;
+                });
+                if (hasRealSpec)
+                    taskPlatforms.push(platform);
             }
         }
-        // v8.3.185+: Spec 匹配失败时，用六层端推断机制（显式声明→_matrix→目录→关键词→AI）
         if (taskPlatforms.length === 0) {
-            const { inferFeaturePlatforms } = await Promise.resolve().then(() => __importStar(require('../../core/platform-inference')));
-            const featureDir = (0, path_1.join)(iterationDir, '010-requirements', 'features', sectionFeatureName);
-            const inference = await inferFeaturePlatforms({
-                featureName: sectionFeatureName,
-                featureDir,
-                allPlatforms,
-            });
-            taskPlatforms = inference.platforms;
-            if (inference.needsConfirm || inference.source === 'ai-required') {
-                logger_1.logger.warn(`   ⚠️  功能「${sectionFeatureName}」端推断置信度 ${inference.confidence}（${inference.source}），建议人工确认 _matrix.md`);
+            // v8.3.125+: 使用三层匹配推断平台（替代脆弱的字符串包含匹配）
+            for (const platform of allPlatforms) {
+                const bestMatch = findBestSpecMatch(specContents, sectionFeatureName, platform, 'TECH.md');
+                if (bestMatch && bestMatch.score >= 20) {
+                    taskPlatforms.push(platform);
+                }
+            }
+            // v8.3.185+: Spec 匹配失败时，用六层端推断机制（显式声明→_matrix→目录→关键词→AI）
+            if (taskPlatforms.length === 0) {
+                const { inferFeaturePlatforms } = await Promise.resolve().then(() => __importStar(require('../../core/platform-inference')));
+                const featureDir = (0, path_1.join)(iterationDir, '010-requirements', 'features', sectionFeatureName);
+                const inference = await inferFeaturePlatforms({
+                    featureName: sectionFeatureName,
+                    featureDir,
+                    allPlatforms,
+                });
+                taskPlatforms = inference.platforms;
+                if (inference.needsConfirm || inference.source === 'ai-required') {
+                    logger_1.logger.warn(`   ⚠️  功能「${sectionFeatureName}」端推断置信度 ${inference.confidence}（${inference.source}），建议人工确认 _matrix.md`);
+                }
             }
         }
     }
@@ -1838,6 +1860,46 @@ ${taskPlatforms.map((p) => `| ${subtaskIdMap.get(p)} | ${p} | ${owner} | 🔲
             await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '_shared', 'API_CONTRACT.yaml'), contractYaml);
         }
     }
+    // v8.3.268: 合并端级契约——全局契约可能是空壳（apis: [] 或无接口），
+    // 真契约在各功能单元的 020-specs/{feature}/{端}/API_CONTRACT.yaml。
+    // 修复 execute 注入 _shared/API_CONTRACT.yaml 时拿到空契约、AI 无中生有发明接口的断链。
+    const featName = section.name.replace(/^\d+(\.\d+)*\s*/, '').trim();
+    const specsRoot = (0, path_1.join)(iterationDir, '020-specs');
+    const platContractParts = [];
+    if (await (0, fs_extra_1.pathExists)(specsRoot)) {
+        const featEntries = await (0, fs_extra_1.readdir)(specsRoot, { withFileTypes: true });
+        for (const fe of featEntries) {
+            if (!fe.isDirectory() || !fe.name.includes(featName))
+                continue;
+            const platEntries = await (0, fs_extra_1.readdir)((0, path_1.join)(specsRoot, fe.name), { withFileTypes: true });
+            for (const pe of platEntries) {
+                if (!pe.isDirectory())
+                    continue;
+                const contractPath = (0, path_1.join)(specsRoot, fe.name, pe.name, 'API_CONTRACT.yaml');
+                if (!(await (0, fs_extra_1.pathExists)(contractPath)))
+                    continue;
+                const contractContent = await (0, fs_extra_1.readFile)(contractPath, 'utf-8');
+                // 空壳判定：无接口条目（apis: [] / paths 缺 / 仅说明文字）
+                const hasApis = /apis:\s*[\n\r]\s*-\s/m.test(contractContent) || /^paths:\s*$/m.test(contractContent);
+                if (!hasApis)
+                    continue;
+                platContractParts.push(`## ${pe.name} 端契约（${fe.name}）\n\n${contractContent.trim()}`);
+            }
+        }
+    }
+    if (platContractParts.length > 0) {
+        const sharedContractPath = (0, path_1.join)(taskDir, '_shared', 'API_CONTRACT.yaml');
+        let baseContract = await (0, fs_extra_1.pathExists)(sharedContractPath)
+            ? await (0, fs_extra_1.readFile)(sharedContractPath, 'utf-8')
+            : '';
+        // 全局索引壳保留，但去掉空 apis 标记，避免误导（真契约已合并于下方）
+        baseContract = baseContract.replace(/\n?apis:\s*\[\]\s*$/, '').trimEnd();
+        const merged = (baseContract
+            ? `${baseContract}\n\n---\n\n`
+            : '# 任务级接口契约（合并自端级契约）\n\n') + platContractParts.join('\n\n---\n\n') + '\n';
+        await (0, fs_extra_1.writeFile)(sharedContractPath, merged);
+        logger_1.logger.debug(`   📄 ${taskDir.split('/').pop()}: _shared 契约合并 ${platContractParts.length} 份端级契约`);
+    }
     // ── 4. 核心规格写入 00-specs/（REQ/TECH/SCHEMA/CHANGELOG） ──
     const acItems = generateAcceptanceCriteria(section);
     const aiReqContent = section._reqContent;
@@ -2982,6 +3044,38 @@ function generateMonitorTemplate(section, material) {
 // 从 analyze 产出中提取任务相关内容
 // ═══════════════════════════════════════════════
 /** 加载迭代级 020-specs/ 文档内容（包括 global/ 全局文档 + 根目录回退 + 各端子目录文档） */
+/**
+ * v8.3.268: 读取功能单元的端覆盖声明（010-requirements/features/{feature}/_matrix.md 的 platforms 字段）。
+ * 修复 _matrix platforms 全空/缺失时 taskify 每 Task 平铺全部端、幽灵端子任务无中生有的问题。
+ * 解析格式：platforms: 后跟随 `  - 端名` 行；`  []`（空标记）或不存在时返回空数组，交由反推逻辑处理。
+ */
+async function readMatrixPlatforms(iterationDir, featureName) {
+    try {
+        const featuresDir = (0, path_1.join)(iterationDir, '010-requirements', 'features');
+        if (!(await (0, fs_extra_1.pathExists)(featuresDir)))
+            return [];
+        const entries = await (0, fs_extra_1.readdir)(featuresDir, { withFileTypes: true });
+        for (const e of entries) {
+            if (!e.isDirectory() || !e.name.includes(featureName))
+                continue;
+            const matrixPath = (0, path_1.join)(featuresDir, e.name, '_matrix.md');
+            if (!(await (0, fs_extra_1.pathExists)(matrixPath)))
+                continue;
+            const raw = await (0, fs_extra_1.readFile)(matrixPath, 'utf-8');
+            const m = raw.match(/platforms:\s*\n((?:\s*[-\[]?[\s\S]*?))(?=\n(?:dependencies|apis|interfaces|$))/);
+            const block = m ? m[1] : '';
+            if (!block || /^\s*\[\s*\]\s*$/.test(block.trim()))
+                continue;
+            const plats = block.split('\n')
+                .map(l => l.replace(/^\s*-\s*/, '').trim())
+                .filter(p => p && !p.startsWith('#') && !p.includes(':'));
+            if (plats.length > 0)
+                return plats;
+        }
+    }
+    catch { /* 读取失败不阻断，回退端级规格反推逻辑 */ }
+    return [];
+}
 async function loadSpecContents(iterationDir) {
     const specs = {};
     const specDir = (0, path_1.join)(iterationDir, '020-specs');
@@ -3100,6 +3194,13 @@ function findBestSpecMatch(specContents, taskName, platform, docType) {
     if (candidates.length === 0)
         return null;
     candidates.sort((a, b) => b.score - a.score);
+    // v8.3.265+: 并列最高分告警——双向 includes 在通用词任务名（如「管理」）下可能命中多个模块，静默取第一个会错配文档
+    const topScore = candidates[0].score;
+    const ties = candidates.filter(c => c.score === topScore);
+    if (ties.length > 1) {
+        logger_1.logger.warn(`   ⚠️  Spec 文档匹配并列 ${ties.length} 个候选（任务「${taskName}」，得分 ${topScore}），已取第一个: ${ties[0].key}`);
+        logger_1.logger.warn(`      并列候选: ${ties.map(t => t.key).join(' | ')}`);
+    }
     return candidates[0];
 }
 /** 从完整文档中提取与任务名相关的段落 */
@@ -3234,10 +3335,42 @@ function extractTaskDevGuideContent(specContents, section, taskPlatforms) {
     }
     return results.join('\n\n');
 }
+// v8.3.268: 按文档类型从 TECH 提取中分化内容——按 ### 标题切段，
+// 只保留与文档类型相关的段落。修复「一段多用」：ROUTES/STATE/STYLE_GUIDE/
+// COMPONENT_TREE 四份文档正文完全相同（仅标题不同）的问题。
+function extractSectionByKeywords(material, keywords) {
+    const sections = material.split(/^#{2,4}\s+/m);
+    const matched = [];
+    for (const sec of sections) {
+        const headLine = sec.split('\n')[0] || '';
+        if (keywords.some(kw => headLine.includes(kw))) {
+            matched.push(sec.trim());
+        }
+    }
+    // 无 ### 标题结构的兜底：整段中关键词密度最高的前 N 行
+    if (matched.length === 0 && material.includes('\n|')) {
+        const lines = material.split('\n');
+        const tableStart = lines.findIndex(l => keywords.some(kw => l.includes(kw)));
+        if (tableStart >= 0) {
+            const block = [];
+            for (let i = tableStart; i < lines.length; i++) {
+                if (i > tableStart && /^#{2,4}\s/.test(lines[i]))
+                    break;
+                block.push(lines[i]);
+            }
+            return block.join('\n').trim();
+        }
+    }
+    return matched.join('\n\n');
+}
 // 前端专属：组件树
 function generateComponentTree(section, platform, material) {
     if (material && material.trim().length > 200) {
-        return `# ${section.name} — 组件树 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+        // v8.3.268: 仅提取组件拆分/组件清单相关段落
+        const extracted = extractSectionByKeywords(material, ['组件拆分', '组件清单', '组件树', '共享组件']);
+        if (extracted) {
+            return `# ${section.name} — 组件树 (${platform})\n\n> 来源: analyze → TECH.md（组件拆分段提取）\n\n${extracted}\n`;
+        }
     }
     return `# ${section.name} — 组件树 (${platform})
 
@@ -3260,7 +3393,11 @@ function generateComponentTree(section, platform, material) {
 // 前端专属：路由
 function generateRoutesDoc(section, platform, material) {
     if (material && material.trim().length > 200) {
-        return `# ${section.name} — 路由设计 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+        // v8.3.268: 仅提取页面清单与路由相关段落
+        const extracted = extractSectionByKeywords(material, ['页面清单', '路由', '导航']);
+        if (extracted) {
+            return `# ${section.name} — 路由设计 (${platform})\n\n> 来源: analyze → TECH.md（页面/路由段提取）\n\n${extracted}\n`;
+        }
     }
     return `# ${section.name} — 路由设计 (${platform})
 
@@ -3278,7 +3415,11 @@ function generateRoutesDoc(section, platform, material) {
 // 前端专属：状态管理
 function generateStateDoc(section, platform, material) {
     if (material && material.trim().length > 200) {
-        return `# ${section.name} — 状态管理 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+        // v8.3.268: 仅提取状态管理/Store/数据流相关段落
+        const extracted = extractSectionByKeywords(material, ['状态管理', 'Store', '数据流', '状态枚举']);
+        if (extracted) {
+            return `# ${section.name} — 状态管理 (${platform})\n\n> 来源: analyze → TECH.md（状态管理段提取）\n\n${extracted}\n`;
+        }
     }
     return `# ${section.name} — 状态管理 (${platform})
 
@@ -3301,7 +3442,11 @@ function generateStateDoc(section, platform, material) {
 // 前端专属：样式规范
 function generateStyleGuide(section, platform, material) {
     if (material && material.trim().length > 200) {
-        return `# ${section.name} — 样式规范 (${platform})\n\n> 来源: analyze → TECH.md（自动提取）\n\n${material.trim()}\n`;
+        // v8.3.268: 仅提取样式/主题/设计 Token 相关段落
+        const extracted = extractSectionByKeywords(material, ['样式', '主题', '设计 Token', '视觉', '响应式']);
+        if (extracted) {
+            return `# ${section.name} — 样式规范 (${platform})\n\n> 来源: analyze → TECH.md（样式/主题段提取）\n\n${extracted}\n`;
+        }
     }
     const isH5 = platform.includes('h5') || platform.includes('mobile');
     const isMiniapp = platform.includes('miniapp') || platform.includes('小程序');
@@ -4136,7 +4281,11 @@ function parseFunctionMapTable(content, allPlatforms) {
             continue;
         if (cells.some(c => c.includes('功能单元')) || cells.some(c => c.includes('涉及端')))
             continue;
-        const unitName = cells[1];
+        // v8.3.268: 功能单元列取 cells[0]（表头第一列）。此前取 cells[1] 依赖旧数据
+        // 「| 目录名 | 名称 | 端列表 | …」的列错位（cells[1]=名称），一旦表格对齐表头
+        // （cells[1]=涉及端）任务名就变成端列表。「dir（名称）」格式剥尾部括号注释。
+        const unitNameRaw = cells[0] || cells[1];
+        const unitName = unitNameRaw.replace(/[（(][^）)]*[）)]$/, '').trim();
         if (!unitName || unitName === '#' || unitName === '功能单元')
             continue;
         let platforms = [];
@@ -4146,6 +4295,18 @@ function parseFunctionMapTable(content, allPlatforms) {
                 platforms = raw.split(/[,，]/).map(p => p.trim()).filter(p => p && allPlatforms.includes(p));
             }
         }
+        // v8.3.268: 端列自适应——AI 落盘 FUNCTION_MAP 表格可能列错位（涉及端表头下是
+        // 名称、端列表落在其他列），按表头解析落空时扫描整行，找「逗号分隔且 ≥2 个
+        // 值全部属于标准端名」的单元格作为端列，避免静默回退全端平铺。
+        if (platforms.length === 0) {
+            for (const cell of cells) {
+                const parts = cell.split(/[,，]/).map(p => p.trim()).filter(Boolean);
+                if (parts.length >= 2 && parts.every(p => allPlatforms.includes(p))) {
+                    platforms = parts;
+                    break;
+                }
+            }
+        }
         if (platforms.length === 0)
             platforms = [...allPlatforms];
         let sharedCapability = '无';