prd-to-flutter 0.1.0

package/dist/core/feature-coverage-builder.js

@@ -0,0 +1,667 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { basename, extname, join, relative } from 'node:path';
+import { logger } from './logger.js';
+import { markComplete } from './run-context.js';
+const MAX_SOURCE_BYTES = 120_000;
+const MAX_DOC_BYTES = 8_000;
+const MAX_DOC_FILES = 10;
+const MAX_SOURCE_INTERACTIONS_TO_QUEUE = 16;
+export function buildFeatureCoverage(ctx, page, vueDocs) {
+    const analysisDir = join(ctx.pageDir, 'analysis');
+    mkdirSync(analysisDir, { recursive: true });
+    const jsonPath = join(analysisDir, 'feature-coverage.json');
+    const markdownPath = join(analysisDir, 'feature-coverage.md');
+    const scratch = {
+        features: [],
+        states: [],
+        interactions: [],
+        sourceFiles: [],
+        docFiles: [],
+    };
+    for (const file of page.relatedFiles) {
+        analyzeVueSourceFile(scratch, vueDocs.root, file);
+    }
+    for (const doc of collectProductDocs(vueDocs.root, page)) {
+        analyzeProductDoc(scratch, vueDocs.root, doc.path, doc.score, doc.matchedTerms);
+    }
+    const coverage = {
+        pageKey: ctx.pageKey,
+        pageName: ctx.options.pageName,
+        generatedAt: new Date().toISOString(),
+        jsonPath,
+        markdownPath,
+        sourceFiles: scratch.sourceFiles,
+        docFiles: scratch.docFiles,
+        features: dedupeFeatures(scratch.features),
+        expectedStates: dedupeStates(scratch.states),
+        expectedInteractions: dedupeInteractions(scratch.interactions),
+        runtimeCoverage: {
+            coveredByDom: [],
+            queuedForAgentExploration: [],
+            notQueued: [],
+            discoveredOnlyByRuntime: [],
+            notes: [
+                '运行态覆盖会在 build-semantic-model 合并 DOM 候选与源码/文档预期后更新。',
+            ],
+        },
+    };
+    writeFeatureCoverageFiles(ctx, coverage);
+    logger.success(`Feature coverage → features=${coverage.features.length} states=${coverage.expectedStates.length} interactions=${coverage.expectedInteractions.length}`);
+    markComplete(ctx, 'build-feature-coverage');
+    return coverage;
+}
+export function mergeFeatureCoverageIntoSemanticModel(ctx, model, coverage) {
+    const existing = new Set(model.outline.candidateInteractions
+        .map((c) => normalizeLabel(c.label ?? ''))
+        .filter(Boolean));
+    const queued = [];
+    const notQueued = [];
+    const covered = [];
+    const expectedLabels = new Set(coverage.expectedInteractions
+        .map((item) => normalizeLabel(item.label))
+        .filter(Boolean));
+    const runtimeOnly = model.outline.candidateInteractions
+        .map((item) => item.label)
+        .filter((label) => Boolean(label))
+        .filter((label) => !expectedLabels.has(normalizeLabel(label)));
+    for (const item of coverage.expectedInteractions) {
+        const normalized = normalizeLabel(item.label);
+        if (!normalized) {
+            item.runtimeStatus = 'not-queued';
+            notQueued.push(item);
+            continue;
+        }
+        if (existing.has(normalized)) {
+            item.runtimeStatus = 'covered-by-dom';
+            covered.push(item);
+            continue;
+        }
+        if (!isSafeExplorationLabel(item.label) || queued.length >= MAX_SOURCE_INTERACTIONS_TO_QUEUE) {
+            item.runtimeStatus = 'not-queued';
+            notQueued.push(item);
+            continue;
+        }
+        item.runtimeStatus = 'queued-for-agent-exploration';
+        queued.push(item);
+        existing.add(normalized);
+        model.outline.candidateInteractions.push(toCandidateInteraction(item, queued.length));
+    }
+    coverage.runtimeCoverage = {
+        coveredByDom: covered.map((i) => i.label),
+        queuedForAgentExploration: queued.map((i) => i.label),
+        notQueued: notQueued.map((i) => i.label),
+        discoveredOnlyByRuntime: dedupeBy(runtimeOnly, normalizeLabel),
+        notes: [
+            queued.length
+                ? `已为 agent live-page 探索追加 ${queued.length} 个源码/文档派生交互。`
+                : '没有追加源码/文档派生交互。',
+            '源码/文档派生候选只是线索；agent 必须检查 live page，并探索这些标签之外的可见控件。',
+        ],
+    };
+    writeFeatureCoverageFiles(ctx, coverage);
+    writeFileSync(model.candidateInteractionsPath, JSON.stringify({
+        pageKey: model.pageKey,
+        candidates: model.outline.candidateInteractions,
+        sourceCoverage: {
+            queuedForAgentExploration: coverage.runtimeCoverage.queuedForAgentExploration,
+            coveredByDom: coverage.runtimeCoverage.coveredByDom,
+        },
+    }, null, 2) + '\n', 'utf8');
+    logger.success(`Feature coverage merged → queued=${queued.length} coveredByDom=${covered.length}`);
+    markComplete(ctx, 'merge-feature-coverage');
+    return queued.length;
+}
+function analyzeVueSourceFile(scratch, root, file) {
+    if (!existsSync(file) || !statSync(file).isFile())
+        return;
+    const rel = relative(root, file);
+    const body = readLimited(file, MAX_SOURCE_BYTES);
+    const ext = extname(file).toLowerCase();
+    const isVue = ext === '.vue';
+    const template = isVue ? extractTemplate(body) : '';
+    const interactionSource = template;
+    const components = interactionSource ? extractComponents(interactionSource) : [];
+    const labels = interactionSource ? extractLabels(interactionSource).slice(0, 80) : [];
+    const handlers = interactionSource ? extractEventHandlers(interactionSource) : [];
+    scratch.sourceFiles.push({
+        path: rel,
+        components,
+        labels,
+        eventHandlers: handlers.map((h) => `${h.event}:${h.handler}`).slice(0, 80),
+    });
+    if (!isVue)
+        return;
+    for (const component of components) {
+        const feature = featureFromComponent(component);
+        if (feature) {
+            scratch.features.push({
+                id: '',
+                kind: feature.kind,
+                label: feature.label,
+                source: 'vue-source',
+                sourceFile: rel,
+                evidence: `<${component}>`,
+                confidence: 0.72,
+            });
+        }
+    }
+    for (const state of extractSourceStates(body)) {
+        scratch.states.push({
+            id: '',
+            ...state,
+            source: 'vue-source',
+            sourceFile: rel,
+        });
+    }
+    for (const tab of extractTabLabels(interactionSource)) {
+        scratch.features.push({
+            id: '',
+            kind: 'tab',
+            label: tab,
+            source: 'vue-source',
+            sourceFile: rel,
+            evidence: `tab label: ${tab}`,
+            confidence: 0.66,
+        });
+        scratch.interactions.push({
+            id: '',
+            kind: 'tab-change',
+            label: tab,
+            source: 'vue-source',
+            sourceFile: rel,
+            evidence: `tab label: ${tab}`,
+            confidence: 0.58,
+            selectorStrategy: 'text',
+            runtimeStatus: 'pending',
+        });
+    }
+    for (const event of handlers) {
+        const label = pickEventLabel(event.snippet, event.handler);
+        if (!label)
+            continue;
+        const kind = inferInteractionKind({
+            label,
+            evidence: event.snippet,
+            event: event.event,
+            handler: event.handler,
+        });
+        scratch.interactions.push({
+            id: '',
+            kind,
+            label,
+            source: 'vue-source',
+            sourceFile: rel,
+            evidence: `${event.event}: ${event.handler}`,
+            confidence: event.event === 'click' ? 0.6 : 0.54,
+            selectorStrategy: kind === 'input-focus' ? 'placeholder' : 'text',
+            runtimeStatus: 'pending',
+        });
+    }
+}
+function analyzeProductDoc(scratch, root, file, score, matchedTerms) {
+    const rel = relative(root, file);
+    const body = readLimited(file, MAX_DOC_BYTES);
+    const headings = body
+        .split(/\r?\n/)
+        .map((line) => /^#{1,4}\s+(.+)$/.exec(line)?.[1]?.trim())
+        .filter((line) => Boolean(line))
+        .slice(0, 30);
+    scratch.docFiles.push({ path: rel, score, matchedTerms, headings });
+    const interestingLines = body
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length >= 3 && line.length <= 180)
+        .filter((line) => /点击|按钮|切换|筛选|选择|搜索|输入|弹窗|下拉|列表|空态|加载|错误|Tab|tab|filter|select|search|dialog|modal|empty|loading/i.test(line))
+        .slice(0, 80);
+    for (const line of [...headings, ...interestingLines]) {
+        const kind = inferFeatureKind(line);
+        if (kind !== 'unknown') {
+            scratch.features.push({
+                id: '',
+                kind,
+                label: cleanLabel(line).slice(0, 80),
+                source: 'product-doc',
+                sourceFile: rel,
+                evidence: line,
+                confidence: Math.min(0.72, 0.42 + score / 10),
+            });
+        }
+        const state = stateFromText(line);
+        if (state) {
+            scratch.states.push({
+                id: '',
+                ...state,
+                source: 'product-doc',
+                sourceFile: rel,
+                evidence: line,
+            });
+        }
+        const label = extractActionLabelFromDocLine(line);
+        if (label) {
+            scratch.interactions.push({
+                id: '',
+                kind: inferInteractionKind({ label, evidence: line }),
+                label,
+                source: 'product-doc',
+                sourceFile: rel,
+                evidence: line,
+                confidence: Math.min(0.58, 0.36 + score / 12),
+                selectorStrategy: /输入|搜索|placeholder/i.test(line) ? 'placeholder' : 'text',
+                runtimeStatus: 'pending',
+            });
+        }
+    }
+}
+function collectProductDocs(root, page) {
+    if (page.productDocs.length) {
+        return page.productDocs.map((doc, index) => ({
+            path: doc.source,
+            score: 100 - index,
+            matchedTerms: doc.notesRef
+                ? [doc.notesRef]
+                : [page.routeInfo.label, page.routeInfo.screenId, basename(page.entryFile, extname(page.entryFile))]
+                    .filter((value) => Boolean(value)),
+        }));
+    }
+    const files = [];
+    walk(root, files);
+    const strongTerms = dedupeBy([
+        page.routeInfo.label,
+        page.routeInfo.name,
+        page.routeInfo.path,
+        page.routeInfo.screenId,
+        basename(page.entryFile, extname(page.entryFile)),
+    ].filter((v) => Boolean(v)), (term) => term.toLowerCase());
+    const weakTerms = dedupeBy([page.routeInfo.module].filter((v) => Boolean(v)), (term) => term.toLowerCase());
+    return files
+        .map((path) => {
+        const rel = relative(root, path);
+        const body = readLimited(path, MAX_DOC_BYTES).toLowerCase();
+        const lowerRel = rel.toLowerCase();
+        const strongMatches = strongTerms.filter((term) => {
+            const t = term.toLowerCase();
+            return body.includes(t) || lowerRel.includes(t);
+        });
+        const weakMatches = weakTerms.filter((term) => {
+            const t = term.toLowerCase();
+            return body.includes(t) || lowerRel.includes(t);
+        });
+        const matchedTerms = [...strongMatches, ...weakMatches];
+        const nameScore = /readme|docs?|prd|product|spec|需求|产品|功能|文档/i.test(rel) ? 2 : 0;
+        const score = strongMatches.length * 4 + weakMatches.length + nameScore;
+        return { path, score, matchedTerms };
+    })
+        .filter((item) => item.matchedTerms.some((term) => strongTerms.includes(term)))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, MAX_DOC_FILES);
+}
+function walk(dir, out, depth = 0) {
+    if (depth > 5)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        if (['node_modules', 'dist', 'build', 'coverage', 'public', 'assets', 'images'].includes(entry.name))
+            continue;
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(path, out, depth + 1);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (!['.md', '.mdx', '.txt'].includes(extname(entry.name).toLowerCase()))
+            continue;
+        out.push(path);
+    }
+}
+function writeFeatureCoverageFiles(ctx, coverage) {
+    writeFileSync(coverage.jsonPath, JSON.stringify(coverage, null, 2) + '\n', 'utf8');
+    writeFileSync(coverage.markdownPath, renderMarkdown(ctx, coverage), 'utf8');
+}
+function renderMarkdown(ctx, coverage) {
+    const lines = [];
+    lines.push(`# 功能覆盖清单 - ${coverage.pageName}`);
+    lines.push('');
+    lines.push('该文件是基于源码/文档生成的 agent 截图探索清单，本身不能证明视觉状态已覆盖。');
+    lines.push('');
+    lines.push(`- 页面目录名：\`${coverage.pageKey}\``);
+    lines.push(`- 已分析源码文件数：${coverage.sourceFiles.length}`);
+    lines.push(`- 匹配到的产品文档数：${coverage.docFiles.length}`);
+    lines.push(`- 功能数：${coverage.features.length}`);
+    lines.push(`- 预期状态数：${coverage.expectedStates.length}`);
+    lines.push(`- 预期交互数：${coverage.expectedInteractions.length}`);
+    lines.push(`- 已加入 agent 探索队列：${coverage.runtimeCoverage.queuedForAgentExploration.length}`);
+    lines.push('');
+    lines.push('## 运行态覆盖');
+    lines.push('');
+    lines.push(`- 已由 DOM 候选覆盖：${coverage.runtimeCoverage.coveredByDom.join(', ') || '（无）'}`);
+    lines.push(`- 已加入 agent 探索队列：${coverage.runtimeCoverage.queuedForAgentExploration.join(', ') || '（无）'}`);
+    lines.push(`- 仅源码/文档存在或未入队：${coverage.runtimeCoverage.notQueued.join(', ') || '（无）'}`);
+    lines.push(`- 仅运行态发现：${coverage.runtimeCoverage.discoveredOnlyByRuntime.join(', ') || '（无）'}`);
+    for (const note of coverage.runtimeCoverage.notes)
+        lines.push(`- 备注：${note}`);
+    lines.push('');
+    lines.push('## 预期交互');
+    lines.push('');
+    if (coverage.expectedInteractions.length === 0) {
+        lines.push('- （无）');
+    }
+    else {
+        for (const item of coverage.expectedInteractions.slice(0, 80)) {
+            lines.push(`- [${item.runtimeStatus}] ${item.kind} · ${item.label} · ${item.sourceFile} · ${item.evidence}`);
+        }
+    }
+    lines.push('');
+    lines.push('## 预期状态');
+    lines.push('');
+    if (coverage.expectedStates.length === 0) {
+        lines.push('- （无）');
+    }
+    else {
+        for (const state of coverage.expectedStates.slice(0, 80)) {
+            lines.push(`- ${state.kind} · ${state.label} · ${state.sourceFile}`);
+        }
+    }
+    lines.push('');
+    lines.push('## 功能清单');
+    lines.push('');
+    if (coverage.features.length === 0) {
+        lines.push('- （无）');
+    }
+    else {
+        for (const feature of coverage.features.slice(0, 120)) {
+            lines.push(`- ${feature.kind} · ${feature.label} · ${feature.sourceFile}`);
+        }
+    }
+    lines.push('');
+    lines.push('## 源码文件');
+    lines.push('');
+    for (const file of coverage.sourceFiles.slice(0, 60)) {
+        lines.push(`- \`${file.path}\` · 组件=${file.components.slice(0, 16).join(', ') || '（无）'}`);
+    }
+    lines.push('');
+    if (coverage.docFiles.length) {
+        lines.push('## 产品文档');
+        lines.push('');
+        for (const file of coverage.docFiles) {
+            lines.push(`- \`${file.path}\` · 分数=${file.score} · 命中=${file.matchedTerms.join(', ') || '文件名'}`);
+        }
+        lines.push('');
+    }
+    lines.push('## 使用方式');
+    lines.push('');
+    lines.push(`- agent 截图探索前先检查 \`${relative(ctx.taskDir, coverage.markdownPath)}\`。`);
+    lines.push('- 如果这里列出了某个功能或状态，agent 应尝试在 live prototype 中到达它，或记录无法到达的原因。');
+    lines.push('');
+    return lines.join('\n');
+}
+function toCandidateInteraction(item, seq) {
+    const encoded = encodeURIComponent(item.label);
+    return {
+        id: `src-${seq}`,
+        kind: item.kind,
+        selector: item.selectorStrategy === 'placeholder' ? `placeholder=${encoded}` : `text=${encoded}`,
+        label: item.label,
+        description: `源码/文档预期交互：${item.evidence}`,
+        confidence: item.confidence,
+    };
+}
+function extractTemplate(body) {
+    return /<template[^>]*>([\s\S]*?)<\/template>/i.exec(body)?.[1] ?? '';
+}
+function extractComponents(body) {
+    const out = new Set();
+    const re = /<([A-Za-z][\w.-]*)(?=[\s>/])/g;
+    let m;
+    while ((m = re.exec(body)) !== null) {
+        const tag = m[1];
+        if (/^(div|span|template|script|style|p|ul|li|section|main|header|footer|img|svg|path|button|input|circle|text|rect|line|g|polyline|polygon|defs|clipPath|linearGradient|stop)$/i.test(tag)) {
+            continue;
+        }
+        out.add(tag);
+    }
+    return [...out].slice(0, 80);
+}
+function featureFromComponent(component) {
+    const c = component.toLowerCase();
+    if (/tab|segment|switch/.test(c))
+        return { kind: 'tab', label: component };
+    if (/popup|dialog|modal|sheet|drawer/.test(c))
+        return { kind: 'dialog', label: component };
+    if (/picker|dropdown|select|calendar|date|filter/.test(c))
+        return { kind: 'picker', label: component };
+    if (/field|input|search|textarea|form/.test(c))
+        return { kind: 'form', label: component };
+    if (/list|cell|table|row|item/.test(c))
+        return { kind: 'list', label: component };
+    if (/chart|echart|kline|graph/.test(c))
+        return { kind: 'chart', label: component };
+    if (/collapse|expand|accordion/.test(c))
+        return { kind: 'expandable', label: component };
+    return null;
+}
+function extractLabels(body) {
+    const labels = [];
+    const attr = /(?:label|title|placeholder|name|text|button-text|confirm-button-text|cancel-button-text)\s*=\s*(['"])([^'"<>]{1,80})\1/g;
+    const boundAttr = /:(?:label|title|placeholder|name|text)\s*=\s*(['"])['"`]([^'"`<>]{1,80})['"`]\1/g;
+    const textNode = />\s*([^<>{}\n][^<>{}\n]{0,80})\s*</g;
+    for (const re of [attr, boundAttr, textNode]) {
+        let m;
+        while ((m = re.exec(body)) !== null) {
+            const label = cleanLabel(m[2] ?? m[1] ?? '');
+            if (isHumanLabel(label))
+                labels.push(label);
+        }
+    }
+    return unique(labels);
+}
+function extractTabLabels(body) {
+    const labels = [];
+    const tabTag = /<(?:van-tab|[A-Za-z][\w.-]*(?:Tab|Segment|Switch)[\w.-]*)\b[^>]*>/g;
+    let m;
+    while ((m = tabTag.exec(body)) !== null) {
+        labels.push(...extractLabels(m[0]));
+    }
+    return unique(labels).slice(0, 40);
+}
+function extractEventHandlers(body) {
+    const out = [];
+    const tagRe = /<([A-Za-z][\w.-]*)([^>]*?(?:@|v-on:)(?:click|change|select|confirm|cancel|focus|submit|input|open|close)[^>]*)>([\s\S]{0,240}?)(?:<\/\1>)?/g;
+    let m;
+    while ((m = tagRe.exec(body)) !== null) {
+        const snippet = m[0].slice(0, 500);
+        const eventRe = /(?:@|v-on:)(click|change|select|confirm|cancel|focus|submit|input|open|close)(?:\.[\w.-]+)?\s*=\s*(['"])(.*?)\2/g;
+        let e;
+        while ((e = eventRe.exec(snippet)) !== null) {
+            out.push({
+                event: e[1],
+                handler: cleanHandler(e[3]),
+                snippet: compact(snippet),
+            });
+        }
+    }
+    return out.slice(0, 120);
+}
+function extractSourceStates(body) {
+    const defs = [
+        { kind: 'loading', re: /loading|加载中|骨架屏|skeleton/i, label: 'loading' },
+        { kind: 'empty', re: /empty|noData|no-data|暂无|无数据|空状态/i, label: 'empty' },
+        { kind: 'error', re: /error|failed|异常|错误|失败/i, label: 'error' },
+        { kind: 'disabled', re: /disabled|禁用|不可用/i, label: 'disabled' },
+        { kind: 'auth', re: /login|auth|permission|登录|权限|认证/i, label: 'auth' },
+        { kind: 'expanded', re: /expanded|展开|showMore|moreVisible/i, label: 'expanded' },
+        { kind: 'collapsed', re: /collapsed|收起|fold/i, label: 'collapsed' },
+        { kind: 'success', re: /success|成功|完成/i, label: 'success' },
+        { kind: 'failure', re: /fail|失败|拒绝/i, label: 'failure' },
+    ];
+    const out = [];
+    for (const def of defs) {
+        const m = def.re.exec(body);
+        if (!m)
+            continue;
+        out.push({
+            kind: def.kind,
+            label: def.label,
+            evidence: compact(body.slice(Math.max(0, m.index - 80), m.index + 120)),
+            confidence: 0.58,
+        });
+    }
+    return out;
+}
+function pickEventLabel(snippet, handler) {
+    const labels = extractLabels(snippet);
+    if (labels.length)
+        return labels[0];
+    void handler;
+    return null;
+}
+function extractActionLabelFromDocLine(line) {
+    const quoted = /[`"“”']([^`"“”']{1,40})[`"“”']/.exec(line);
+    if (quoted && isHumanLabel(quoted[1]))
+        return cleanLabel(quoted[1]);
+    const button = /([\u4e00-\u9fa5A-Za-z0-9 /\-]{1,24})(?:按钮|入口|tab|Tab|筛选项|选项)/.exec(line);
+    if (button && isHumanLabel(button[1]))
+        return cleanLabel(button[1]);
+    return null;
+}
+function inferInteractionKind(input) {
+    const text = `${input.label} ${input.evidence} ${input.event ?? ''} ${input.handler ?? ''}`.toLowerCase();
+    if (/tab|segment|switch|切换|标签/.test(text))
+        return 'tab-change';
+    if (/input|focus|search|输入|搜索/.test(text))
+        return 'input-focus';
+    if (/picker|dropdown|select|filter|calendar|date|筛选|选择|下拉|排序/.test(text))
+        return 'dropdown';
+    if (/expand|collapse|more|展开|收起|更多/.test(text))
+        return 'expand-toggle';
+    if (/route|router|navigate|href|detail|go|to|详情|跳转|导航/.test(text))
+        return 'nav-link';
+    return 'dialog-trigger';
+}
+function inferFeatureKind(text) {
+    if (/tab|切换|标签|分段/i.test(text))
+        return 'tab';
+    if (/筛选|过滤|filter/i.test(text))
+        return 'filter';
+    if (/输入|搜索|表单|input|search|form/i.test(text))
+        return 'form';
+    if (/列表|明细|记录|list|table/i.test(text))
+        return 'list';
+    if (/空态|暂无|无数据|empty/i.test(text))
+        return 'empty-state';
+    if (/加载|loading|skeleton/i.test(text))
+        return 'loading-state';
+    if (/错误|异常|error/i.test(text))
+        return 'error-state';
+    if (/弹窗|浮层|抽屉|dialog|modal|popup|sheet/i.test(text))
+        return 'dialog';
+    if (/选择|下拉|picker|select|dropdown/i.test(text))
+        return 'picker';
+    if (/图表|chart|kline/i.test(text))
+        return 'chart';
+    if (/展开|收起|更多|expand|collapse/i.test(text))
+        return 'expandable';
+    if (/跳转|导航|入口|route|link/i.test(text))
+        return 'navigation';
+    return 'unknown';
+}
+function stateFromText(line) {
+    const map = [
+        { kind: 'loading', re: /加载|loading|skeleton/i, label: 'loading' },
+        { kind: 'empty', re: /空态|暂无|无数据|empty/i, label: 'empty' },
+        { kind: 'error', re: /错误|异常|error/i, label: 'error' },
+        { kind: 'disabled', re: /禁用|disabled/i, label: 'disabled' },
+        { kind: 'auth', re: /登录|权限|auth|login/i, label: 'auth' },
+    ];
+    const hit = map.find((item) => item.re.test(line));
+    if (!hit)
+        return null;
+    return {
+        kind: hit.kind,
+        label: hit.label,
+        evidence: line,
+        confidence: 0.5,
+    };
+}
+function dedupeFeatures(items) {
+    return dedupeBy(items, (i) => `${i.kind}:${normalizeLabel(i.label)}:${i.sourceFile}`)
+        .map((item, idx) => ({ ...item, id: `f${idx + 1}` }))
+        .slice(0, 160);
+}
+function dedupeStates(items) {
+    return dedupeBy(items, (i) => `${i.kind}:${normalizeLabel(i.label)}:${i.sourceFile}`)
+        .map((item, idx) => ({ ...item, id: `s${idx + 1}` }))
+        .slice(0, 80);
+}
+function dedupeInteractions(items) {
+    return dedupeBy(items, (i) => `${i.kind}:${normalizeLabel(i.label)}`)
+        .sort((a, b) => b.confidence - a.confidence)
+        .map((item, idx) => ({ ...item, id: `i${idx + 1}` }))
+        .slice(0, 80);
+}
+function dedupeBy(items, keyOf) {
+    const out = [];
+    const seen = new Set();
+    for (const item of items) {
+        const key = keyOf(item);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+}
+function readLimited(path, maxBytes) {
+    const buf = readFileSync(path);
+    return buf.byteLength > maxBytes ? buf.subarray(0, maxBytes).toString('utf8') : buf.toString('utf8');
+}
+function cleanHandler(value) {
+    return value.replace(/\s+/g, ' ').trim().slice(0, 100);
+}
+function cleanLabel(value) {
+    return value
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .replace(/^[-*•\d.、\s]+/, '')
+        .trim();
+}
+function compact(value) {
+    return value.replace(/\s+/g, ' ').trim().slice(0, 240);
+}
+function isHumanLabel(value) {
+    const label = cleanLabel(value);
+    if (label.length < 1 || label.length > 60)
+        return false;
+    if (/^[{}[\]().,:;|/\\]+$/.test(label))
+        return false;
+    if (/^\w+\.\w+/.test(label))
+        return false;
+    if (/^(true|false|null|undefined|class|style|src|href|key)$/i.test(label))
+        return false;
+    return /[\u4e00-\u9fa5A-Za-z0-9]/.test(label);
+}
+function normalizeLabel(value) {
+    return cleanLabel(value).toLowerCase();
+}
+function isSafeExplorationLabel(value) {
+    const label = cleanLabel(value);
+    if (!isHumanLabel(label))
+        return false;
+    if (label.includes('{{') || label.includes('}}'))
+        return false;
+    if (/^\/|https?:|\.vue$|\.js$|\.ts$/i.test(label))
+        return false;
+    return label.length <= 40;
+}
+function unique(values) {
+    return dedupeBy(values.map(cleanLabel).filter(isHumanLabel), (v) => normalizeLabel(v));
+}
+//# sourceMappingURL=feature-coverage-builder.js.map