speccore 8.3.267 → 8.3.269

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');
@@ -3078,7 +3172,10 @@ function findBestSpecMatch(specContents, taskName, platform, docType) {
             continue;
         let score = 0;
         // 第一层：精确匹配（字符串包含，最高权重）
-        const normalizedTask = taskName.toLowerCase().replace(/\s+/g, '');
+        // v8.3.269: 归一化对称——taskName 与 key 同样去除分隔符（-/_.）。
+        // 此前 taskName 只去空格、key 去分隔符，含连字符的任务名（如 admin-web-02-会议室管理）
+        // 第一层 includes 永远不命中，端前缀匹配失效，只能靠二三层同义词/标题刷分兜底。
+        const normalizedTask = taskName.toLowerCase().replace(/[\s\/\-_\.]+/g, '');
         const normalizedKey = key.toLowerCase().replace(/[\/\-_\.]/g, '');
         if (normalizedKey.includes(normalizedTask) || normalizedTask.includes(normalizedKey)) {
             score += 100;
@@ -3110,6 +3207,17 @@ function findBestSpecMatch(specContents, taskName, platform, docType) {
     return candidates[0];
 }
 /** 从完整文档中提取与任务名相关的段落 */
+/** v8.3.269: 展开 analyze 落盘的 Python 数组字面量（['| a | b |', '| c | d |']）为多行表格行。
+ * analyze 阶段 AI 用 Python 生成验收标准表格时偶发未展开数组即写入 Markdown，
+ * taskify 提取时原样搬运会把不可读的单行数组塞进 REQ.md，此处做数据容错还原。 */
+function expandPythonListLiteral(content) {
+    if (!content.includes("['"))
+        return content;
+    return content.replace(/\['((?=[^']*\|)[^']*(?:'\s*,\s*'[^']*)*)'\]/g, (...args) => {
+        const inner = args[1];
+        return inner.split(/'\s*,\s*'/).join('\n');
+    });
+}
 function extractRelevantSection(fullContent, taskName, sectionHint) {
     if (!fullContent || !taskName)
         return '';
@@ -3163,7 +3271,7 @@ function extractRelevantSection(fullContent, taskName, sectionHint) {
         }
     }
     if (matched.length > 0)
-        return matched.join('\n\n');
+        return expandPythonListLiteral(matched.join('\n\n'));
     // 回退：提取包含关键词的连续行
     const fallback = [];
     for (const line of lines) {
@@ -3171,7 +3279,7 @@ function extractRelevantSection(fullContent, taskName, sectionHint) {
         if (kwArray.some(kw => lower.includes(kw)))
             fallback.push(line);
     }
-    return fallback.length > 0 ? fallback.join('\n') : '';
+    return fallback.length > 0 ? expandPythonListLiteral(fallback.join('\n')) : '';
 }
 /** 从 TECH.md 提取前端平台相关内容 */
 function extractFrontendContent(techContent, taskName, platform) {
@@ -3241,10 +3349,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})
 
@@ -3267,7 +3407,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})
 
@@ -3285,7 +3429,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})
 
@@ -3308,7 +3456,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('小程序');
@@ -4143,7 +4295,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 = [];
@@ -4153,6 +4309,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 = '无';