prd-to-flutter 0.1.0

package/dist/core/vue-page-locator.js

@@ -0,0 +1,748 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, readdirSync } from 'node:fs';
+import { join, dirname, resolve, relative, isAbsolute, basename, extname } from 'node:path';
+import { failFast } from './fail-fast.js';
+import { logger } from './logger.js';
+import { markComplete } from './run-context.js';
+import { resolveProfilePath } from './profile.js';
+/** Max files collected by the dependency DFS (safety bound, not a hard product spec). */
+const MAX_RELATED = 60;
+/** Max import-graph depth explored. */
+const MAX_DEPTH = 3;
+export function locateVuePage(ctx, vueDocs, prototypeUrl, profile) {
+    if (!vueDocs.viewsDir) {
+        failFast({
+            stage: 'vue-page-locate',
+            action: 'locate views/ directory',
+            reason: 'Vue 原型项目没有识别到 views 目录。',
+            completedSteps: [...ctx.completedSteps],
+            pendingSteps: [...ctx.pendingSteps],
+            suggestions: [
+                '确认原型项目是否仍使用 profile.prototype.viewsDirs 中的目录存放页面。',
+                '若目录结构变更，在 p2f.config.json 中配置 prototype.viewsDirs。',
+            ],
+        });
+    }
+    const pathname = extractPathname(prototypeUrl);
+    if (!pathname) {
+        failFast({
+            stage: 'vue-page-locate',
+            action: `parse prototype URL ${prototypeUrl}`,
+            reason: '无法从 URL 中解析 pathname，请确认格式是否正确。',
+            completedSteps: [...ctx.completedSteps],
+            pendingSteps: [...ctx.pendingSteps],
+            suggestions: [
+                '确认 URL 是完整的 http(s) 链接或以 / 开头的 pathname。',
+                '如果是 hash 路由（含 #/...），注意把 hash 部分也保留下来。',
+            ],
+        });
+    }
+    const registry = buildRegistry(vueDocs, profile);
+    if (registry.length === 0) {
+        failFast({
+            stage: 'vue-page-locate',
+            action: 'load page registries',
+            reason: '未能从 specScreens / prdPageRegistry / designScreens 解析到任何页面条目。',
+            completedSteps: [...ctx.completedSteps],
+            pendingSteps: [...ctx.pendingSteps],
+            suggestions: [
+                '确认原型项目的 registry 文件存在，并匹配 profile.prototype.registryFiles。',
+                '若 registry 路径变更，在 p2f.config.json 中配置 prototype.registryFiles。',
+                '若 registry 语法变更，需要新增 prototype locator adapter。',
+            ],
+        });
+    }
+    const match = registry.find((entry) => entry.path === pathname);
+    if (!match) {
+        const suggestions = suggestNearest(registry, pathname, 5);
+        failFast({
+            stage: 'vue-page-locate',
+            action: `match pathname ${pathname} against registry`,
+            reason: `原型 registry 中找不到 path = ${pathname}。`,
+            completedSteps: [...ctx.completedSteps],
+            pendingSteps: [...ctx.pendingSteps],
+            suggestions: [
+                '确认 URL 对应的是已登记的原型页面。',
+                '检查拼写或 hash 路由中 # 后的实际 pathname。',
+                ...(suggestions.length
+                    ? [`相似候选：${suggestions.map((s) => s.path).join(', ')}`]
+                    : []),
+            ],
+            needsUserDecision: [
+                '若页面在 registry 中确实不存在，请先在原型项目登记后再还原。',
+            ],
+        });
+    }
+    const entryFile = join(vueDocs.viewsDir, match.kind, match.view);
+    if (!existsSync(entryFile)) {
+        failFast({
+            stage: 'vue-page-locate',
+            action: `resolve Vue entry ${entryFile}`,
+            reason: `registry 命中 ${match.path} 对应的 Vue 文件不存在：${entryFile}`,
+            completedSteps: [...ctx.completedSteps],
+            pendingSteps: [...ctx.pendingSteps],
+            suggestions: [
+                '可能 registry 与 views 目录不同步，等原型项目修复后重试。',
+                '手动确认文件是否被移动或重命名。',
+            ],
+        });
+    }
+    const relatedFiles = collectRelatedFiles(entryFile, vueDocs.root);
+    const sourceDir = join(ctx.pageDir, 'source');
+    mkdirSync(sourceDir, { recursive: true });
+    const entryRelative = relative(vueDocs.root, entryFile);
+    const explicitNotes = extractNotesRefs(readFileSync(entryFile, 'utf8'));
+    const notesRefs = dedupeStrings([
+        ...normalizeNotesRefs(match.notes),
+        ...explicitNotes,
+    ]);
+    const productDocs = copyProductDocs({
+        root: vueDocs.root,
+        sourceDir,
+        entryFile,
+        relatedFiles,
+        match,
+        notesRefs,
+        profile,
+    });
+    const i18nFiles = copyPrototypeI18nFiles({
+        root: vueDocs.root,
+        sourceDir,
+        screenId: match.screenId,
+        profile,
+    });
+    writeFileSync(join(sourceDir, 'vue-entry.txt'), entryRelative + '\n', 'utf8');
+    writeFileSync(join(sourceDir, 'related-files.txt'), relatedFiles.map((p) => relative(vueDocs.root, p)).join('\n') + '\n', 'utf8');
+    const routeInfo = {
+        path: match.path,
+        name: match.name,
+        label: match.label,
+        module: match.module,
+        kind: match.kind,
+        view: match.view,
+        screenId: match.screenId,
+        key: match.key,
+        notes: notesRefs.length <= 1 ? notesRefs[0] : notesRefs,
+    };
+    writeFileSync(join(sourceDir, 'route-info.json'), JSON.stringify(routeInfo, null, 2) + '\n', 'utf8');
+    logger.success(`Vue 页面命中 → ${match.path} · ${entryRelative} · related=${relatedFiles.length}`);
+    markComplete(ctx, 'locate-vue-page');
+    return {
+        entryFile,
+        entryRelative,
+        relatedFiles,
+        routeInfo,
+        productDocs,
+        i18nFiles,
+        sourceDir,
+    };
+}
+// ---------------------------------------------------------------------------
+// URL handling
+// ---------------------------------------------------------------------------
+function extractPathname(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    // Support leading fragment-only inputs: "/prototype/trade" or "#/prototype/trade".
+    if (trimmed.startsWith('#/'))
+        return trimmed.slice(1);
+    if (trimmed.startsWith('/'))
+        return trimmed;
+    try {
+        const u = new URL(trimmed);
+        if (u.hash.startsWith('#/'))
+            return u.hash.slice(1);
+        return u.pathname || '/';
+    }
+    catch {
+        return null;
+    }
+}
+function buildRegistry(vueDocs, profile) {
+    const entries = [];
+    for (const registry of profile.prototype.registryFiles) {
+        entries.push(...parseRegistry(resolveProfilePath(vueDocs.root, registry.path), registry.kind));
+    }
+    return entries;
+}
+/**
+ * Parse registry files by walking through `modules[]` / `items[]` object literals
+ * with a lightweight regex. We deliberately avoid evaluating JS because these
+ * files import Vite/Vue-only helpers.
+ *
+ * Strategy:
+ *  - Chunk file by `module: '...'` boundaries to carry module name along.
+ *  - Inside each module chunk, look for object literals that contain BOTH
+ *    a `path:` field and a `view:` field; pull their values plus any
+ *    accompanying string fields we care about.
+ */
+function parseRegistry(file, kind) {
+    if (!existsSync(file))
+        return [];
+    const src = readFileSync(file, 'utf8');
+    const chunks = splitByModuleLabel(src);
+    const out = [];
+    for (const chunk of chunks) {
+        for (const entry of extractItemsFromChunk(chunk.body)) {
+            out.push({ ...entry, kind, module: chunk.moduleName });
+        }
+    }
+    return out;
+}
+function splitByModuleLabel(src) {
+    const re = /module:\s*(['"])(.*?)\1/g;
+    const positions = [];
+    let m;
+    while ((m = re.exec(src)) !== null) {
+        positions.push({ index: m.index, name: m[2] });
+    }
+    if (positions.length === 0) {
+        return [{ moduleName: undefined, body: src }];
+    }
+    const chunks = [];
+    // Include a leading chunk for anything before the first `module: '...'`.
+    if (positions[0].index > 0) {
+        chunks.push({ moduleName: undefined, body: src.slice(0, positions[0].index) });
+    }
+    for (let i = 0; i < positions.length; i += 1) {
+        const start = positions[i].index;
+        const end = i + 1 < positions.length ? positions[i + 1].index : src.length;
+        chunks.push({ moduleName: positions[i].name, body: src.slice(start, end) });
+    }
+    return chunks;
+}
+function extractItemsFromChunk(body) {
+    // Find every object literal body (delimited by balanced braces) that mentions
+    // both a `path:` and `view:` string pair. We approximate balanced-brace
+    // scanning since our registries are flat enough.
+    const out = [];
+    const len = body.length;
+    let i = 0;
+    while (i < len) {
+        if (body[i] === '{') {
+            const end = findMatchingBrace(body, i);
+            if (end < 0)
+                break;
+            const objBody = body.slice(i + 1, end);
+            const path = pickString(objBody, 'path');
+            const view = pickString(objBody, 'view');
+            if (path && view) {
+                out.push({
+                    path,
+                    view,
+                    name: pickString(objBody, 'name'),
+                    label: pickString(objBody, 'label'),
+                    key: pickString(objBody, 'key'),
+                    screenId: pickString(objBody, 'screenId'),
+                    notes: pickStringOrStringArray(objBody, 'notes'),
+                });
+            }
+            i = end + 1;
+            continue;
+        }
+        i += 1;
+    }
+    return out;
+}
+function findMatchingBrace(src, open) {
+    let depth = 0;
+    let inStr = null;
+    let escape = false;
+    for (let i = open; i < src.length; i += 1) {
+        const c = src[i];
+        if (inStr) {
+            if (escape)
+                escape = false;
+            else if (c === '\\')
+                escape = true;
+            else if (c === inStr)
+                inStr = null;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === '`') {
+            inStr = c;
+            continue;
+        }
+        if (c === '{')
+            depth += 1;
+        else if (c === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function pickString(body, field) {
+    const re = new RegExp(`(?:^|[,{\\s])${field}\\s*:\\s*(['"])(.*?)\\1`);
+    const m = re.exec(body);
+    return m ? m[2] : undefined;
+}
+function pickStringOrStringArray(body, field) {
+    const single = pickString(body, field);
+    if (single)
+        return single;
+    const arrayRe = new RegExp(`(?:^|[,{\\s])${field}\\s*:\\s*\\[([\\s\\S]*?)\\]`);
+    const m = arrayRe.exec(body);
+    if (!m)
+        return undefined;
+    const values = extractStringLiterals(m[1] ?? '');
+    return values.length ? values : undefined;
+}
+function copyProductDocs(input) {
+    rmSync(join(input.sourceDir, 'product-docs'), { recursive: true, force: true });
+    const missing = [];
+    const docs = findProductDocs(input, missing);
+    writeProductDocsIndex(input.root, input.sourceDir, docs, input.notesRefs, missing);
+    return docs;
+}
+function findProductDocs(input, missing) {
+    const candidates = [];
+    for (const ref of input.notesRefs) {
+        const found = resolveNoteRef(input.root, ref, input.profile);
+        if (found) {
+            candidates.push({
+                source: found,
+                reason: '页面 usePageSetup 或 registry 显式声明 notes',
+                notesRef: ref,
+            });
+        }
+        else {
+            missing.push({
+                notesRef: ref,
+                reason: '页面显式声明了 notes，但没有找到对应 `.md` 文件',
+            });
+        }
+    }
+    const inferred = inferNoteCandidates(input.root, input.match.view, input.profile);
+    for (const source of inferred) {
+        candidates.push({
+            source,
+            reason: '按页面 view 文件名自动匹配 notes',
+        });
+    }
+    const entryName = basename(input.entryFile, extname(input.entryFile));
+    for (const source of findNotesByBasename(input.root, entryName, input.profile)) {
+        candidates.push({
+            source,
+            reason: '按 Vue 组件名匹配 notes 文件',
+        });
+    }
+    for (const vueFile of input.relatedFiles.filter((file) => extname(file).toLowerCase() === '.vue')) {
+        if (vueFile === input.entryFile)
+            continue;
+        const componentName = basename(vueFile, extname(vueFile));
+        for (const source of findNotesByBasename(input.root, componentName, input.profile)) {
+            candidates.push({
+                source,
+                reason: '按相关 Vue 组件名匹配 notes 文件',
+            });
+        }
+    }
+    const unique = dedupeBy(candidates, (item) => normalizeAbsPath(item.source));
+    const docs = [];
+    for (const item of unique) {
+        if (!existsSync(item.source))
+            continue;
+        const rel = relative(input.root, item.source);
+        const copiedTo = join(input.sourceDir, 'product-docs', rel);
+        mkdirSync(dirname(copiedTo), { recursive: true });
+        copyFileSync(item.source, copiedTo);
+        docs.push({
+            source: item.source,
+            copiedTo,
+            relativeSource: rel,
+            relativeCopiedTo: relative(input.sourceDir, copiedTo),
+            reason: item.reason,
+            notesRef: item.notesRef,
+        });
+    }
+    return docs;
+}
+function resolveNoteRef(root, ref, profile) {
+    const clean = ref.trim().replace(/^\/+/, '').replace(/\.md$/i, '');
+    if (!clean || clean.includes('..'))
+        return null;
+    for (const notesRoot of profile.prototype.notesRoots) {
+        const path = join(resolveProfilePath(root, notesRoot), clean + '.md');
+        if (existsSync(path))
+            return path;
+    }
+    return null;
+}
+function inferNoteCandidates(root, view, profile) {
+    const withoutExt = view.replace(/\.[^.]+$/, '');
+    const candidates = profile.prototype.notesRoots.flatMap((notesRoot) => {
+        const base = resolveProfilePath(root, notesRoot);
+        return [
+            join(base, withoutExt + '.md'),
+            join(base, basename(withoutExt) + '.md'),
+        ];
+    });
+    return candidates.filter((path) => existsSync(path));
+}
+function findNotesByBasename(root, componentName, profile) {
+    const out = [];
+    for (const notesRoot of profile.prototype.notesRoots) {
+        walkFiles(resolveProfilePath(root, notesRoot), out, {
+            maxDepth: 5,
+            include: (path) => basename(path).toLowerCase() === `${componentName.toLowerCase()}.md`,
+        });
+    }
+    return out;
+}
+function writeProductDocsIndex(root, sourceDir, docs, notesRefs, missing) {
+    const jsonPath = join(sourceDir, 'product-docs-index.json');
+    const mdPath = join(sourceDir, 'product-docs-index.md');
+    writeFileSync(jsonPath, JSON.stringify({
+        generatedAt: new Date().toISOString(),
+        notesRefs,
+        missing,
+        files: docs.map((doc) => ({
+            source: doc.relativeSource,
+            copiedTo: doc.relativeCopiedTo,
+            reason: doc.reason,
+            ...(doc.notesRef ? { notesRef: doc.notesRef } : {}),
+        })),
+    }, null, 2) + '\n', 'utf8');
+    const lines = [];
+    lines.push('# 产品文档源码产物');
+    lines.push('');
+    lines.push('该文件记录本次页面定位阶段从原型项目同步出来的产品文档。');
+    lines.push('');
+    lines.push(`- 原型根目录：\`${root}\``);
+    lines.push(`- 文档数量：${docs.length}`);
+    if (notesRefs.length)
+        lines.push(`- notes 引用：${notesRefs.map((ref) => `\`${ref}\``).join(', ')}`);
+    lines.push('');
+    if (missing.length) {
+        lines.push('## 未命中的 notes');
+        lines.push('');
+        for (const item of missing) {
+            lines.push(`- \`${item.notesRef}\`：${item.reason}`);
+        }
+        lines.push('');
+    }
+    if (!docs.length) {
+        lines.push('## 结果');
+        lines.push('');
+        lines.push('- 未找到当前页面对应的 `.md` 产品文档。');
+        lines.push('- 查找规则：优先读取页面显式 `notes`，其次按 `view` 和 Vue 组件名匹配 profile.prototype.notesRoots。');
+        lines.push('');
+    }
+    else {
+        lines.push('## 文件');
+        lines.push('');
+        for (const doc of docs) {
+            lines.push(`- \`${doc.relativeCopiedTo}\``);
+            lines.push(`  - 来源：\`${doc.relativeSource}\``);
+            lines.push(`  - 命中原因：${doc.reason}${doc.notesRef ? `（notes: \`${doc.notesRef}\`）` : ''}`);
+        }
+        lines.push('');
+    }
+    writeFileSync(mdPath, lines.join('\n'), 'utf8');
+}
+function copyPrototypeI18nFiles(input) {
+    rmSync(join(input.sourceDir, 'i18n'), { recursive: true, force: true });
+    const files = [];
+    if (input.screenId) {
+        for (const i18nRoot of input.profile.prototype.i18nPrototypeRoots) {
+            const source = join(resolveProfilePath(input.root, i18nRoot), `${input.screenId}.json`);
+            if (!existsSync(source))
+                continue;
+            const copiedTo = join(input.sourceDir, 'i18n', `${input.screenId}.json`);
+            mkdirSync(dirname(copiedTo), { recursive: true });
+            copyFileSync(source, copiedTo);
+            const summary = summarizeI18nFile(source);
+            files.push({
+                source,
+                copiedTo,
+                relativeSource: relative(input.root, source),
+                relativeCopiedTo: relative(input.sourceDir, copiedTo),
+                screenId: input.screenId,
+                locales: summary.locales,
+                keyCount: summary.keys.length,
+            });
+            writePrototypeI18nMarkdown(input.sourceDir, input.root, files[0], summary);
+            break;
+        }
+    }
+    writePrototypeI18nIndex(input.sourceDir, input.root, input.screenId, files);
+    if (files.length === 0) {
+        writePrototypeI18nMarkdown(input.sourceDir, input.root, undefined, emptyI18nSummary());
+    }
+    return files;
+}
+function summarizeI18nFile(path) {
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf8'));
+        if (!isRecord(raw))
+            return emptyI18nSummary();
+        const locales = Object.keys(raw).filter((key) => isRecord(raw[key]));
+        const keySet = new Set();
+        for (const locale of locales) {
+            for (const key of Object.keys(raw[locale]))
+                keySet.add(key);
+        }
+        const keys = [...keySet].sort();
+        const rows = keys.slice(0, 120).map((key) => {
+            const values = {};
+            for (const locale of locales) {
+                const value = raw[locale][key];
+                values[locale] = typeof value === 'string' ? value : value == null ? '' : String(value);
+            }
+            return { key, values };
+        });
+        return { locales, keys, rows };
+    }
+    catch {
+        return emptyI18nSummary();
+    }
+}
+function emptyI18nSummary() {
+    return { locales: [], keys: [], rows: [] };
+}
+function writePrototypeI18nIndex(sourceDir, root, screenId, files) {
+    writeFileSync(join(sourceDir, 'prototype-i18n-index.json'), JSON.stringify({
+        generatedAt: new Date().toISOString(),
+        screenId,
+        root,
+        files: files.map((file) => ({
+            source: file.relativeSource,
+            copiedTo: file.relativeCopiedTo,
+            screenId: file.screenId,
+            locales: file.locales,
+            keyCount: file.keyCount,
+        })),
+    }, null, 2) + '\n', 'utf8');
+}
+function writePrototypeI18nMarkdown(sourceDir, root, file, summary) {
+    const lines = [];
+    lines.push('# 多语言源码产物');
+    lines.push('');
+    lines.push('该文件记录当前原型页面的 prototype i18n 数据，供 agent 实现 Flutter 文案和翻译时参考。');
+    lines.push('');
+    lines.push(`- 原型根目录：\`${root}\``);
+    if (!file) {
+        lines.push('- 结果：未找到当前页面对应的多语言 JSON。');
+        lines.push('');
+        lines.push('查找规则：使用 registry 中的 `screenId` 匹配 profile.prototype.i18nPrototypeRoots。');
+        lines.push('');
+        writeFileSync(join(sourceDir, 'prototype-i18n.md'), lines.join('\n'), 'utf8');
+        return;
+    }
+    lines.push(`- screenId：\`${file.screenId}\``);
+    lines.push(`- JSON 副本：\`${file.relativeCopiedTo}\``);
+    lines.push(`- 来源：\`${file.relativeSource}\``);
+    lines.push(`- locales：${summary.locales.map((locale) => `\`${locale}\``).join(', ') || '（无）'}`);
+    lines.push(`- key 数：${summary.keys.length}`);
+    lines.push('');
+    lines.push('## 文案对照');
+    lines.push('');
+    if (!summary.rows.length || !summary.locales.length) {
+        lines.push('- （无可展示条目，请直接查看 JSON 副本）');
+        lines.push('');
+    }
+    else {
+        lines.push(`| key | ${summary.locales.join(' | ')} |`);
+        lines.push(`| --- | ${summary.locales.map(() => '---').join(' | ')} |`);
+        for (const row of summary.rows) {
+            lines.push(`| \`${escapeMarkdownTable(row.key)}\` | ${summary.locales
+                .map((locale) => escapeMarkdownTable(row.values[locale] ?? ''))
+                .join(' | ')} |`);
+        }
+        if (summary.keys.length > summary.rows.length) {
+            lines.push('');
+            lines.push(`仅展示前 ${summary.rows.length} 个 key，其余请查看 \`${file.relativeCopiedTo}\`。`);
+        }
+        lines.push('');
+    }
+    writeFileSync(join(sourceDir, 'prototype-i18n.md'), lines.join('\n'), 'utf8');
+}
+function extractNotesRefs(source) {
+    const refs = [];
+    const singleRe = /notes\s*:\s*(['"])(.*?)\1/g;
+    let m;
+    while ((m = singleRe.exec(source)) !== null) {
+        const value = m[2]?.trim();
+        if (value)
+            refs.push(value);
+    }
+    const arrayRe = /notes\s*:\s*\[([\s\S]*?)\]/g;
+    while ((m = arrayRe.exec(source)) !== null) {
+        refs.push(...extractStringLiterals(m[1] ?? ''));
+    }
+    return dedupeStrings(refs);
+}
+function normalizeNotesRefs(value) {
+    if (!value)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function extractStringLiterals(source) {
+    const out = [];
+    const re = /(['"])(.*?)\1/g;
+    let m;
+    while ((m = re.exec(source)) !== null) {
+        const value = m[2]?.trim();
+        if (value)
+            out.push(value);
+    }
+    return out;
+}
+function walkFiles(dir, out, options, depth = 0) {
+    if (depth > options.maxDepth)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkFiles(path, out, options, depth + 1);
+            continue;
+        }
+        if (entry.isFile() && options.include(path))
+            out.push(path);
+    }
+}
+function dedupeStrings(values) {
+    return dedupeBy(values.map((value) => value.trim()).filter(Boolean), (value) => value);
+}
+function dedupeBy(items, keyOf) {
+    const out = [];
+    const seen = new Set();
+    for (const item of items) {
+        const key = keyOf(item);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+}
+function normalizeAbsPath(path) {
+    return resolve(path);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function escapeMarkdownTable(value) {
+    return value.replace(/\r?\n/g, '<br>').replace(/\|/g, '\\|');
+}
+function suggestNearest(registry, target, limit) {
+    return registry
+        .map((e) => ({ e, score: similarity(e.path, target) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+        .map((x) => x.e);
+}
+function similarity(a, b) {
+    if (a === b)
+        return 1;
+    const ap = a.split('/').filter(Boolean);
+    const bp = b.split('/').filter(Boolean);
+    let hit = 0;
+    for (let i = 0; i < Math.min(ap.length, bp.length); i += 1) {
+        if (ap[i] === bp[i])
+            hit += 1;
+        else
+            break;
+    }
+    return hit / Math.max(ap.length, bp.length);
+}
+// ---------------------------------------------------------------------------
+// Related-file DFS
+// ---------------------------------------------------------------------------
+function collectRelatedFiles(entry, projectRoot) {
+    const collected = new Map();
+    collected.set(entry, 0);
+    const queue = [{ file: entry, depth: 0 }];
+    while (queue.length > 0 && collected.size < MAX_RELATED) {
+        const { file, depth } = queue.shift();
+        if (depth >= MAX_DEPTH)
+            continue;
+        let body;
+        try {
+            body = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const target of extractImportTargets(body)) {
+            const resolved = resolveImport(target, file, projectRoot);
+            if (!resolved)
+                continue;
+            if (collected.has(resolved))
+                continue;
+            collected.set(resolved, depth + 1);
+            queue.push({ file: resolved, depth: depth + 1 });
+            if (collected.size >= MAX_RELATED)
+                break;
+        }
+    }
+    return [...collected.keys()];
+}
+function extractImportTargets(src) {
+    const out = new Set();
+    // `import ... from 'target'`
+    const reImportFrom = /import\s+(?:[^;'"`]+?\s+from\s+)?(['"])(.*?)\1/g;
+    // dynamic `import('target')`
+    const reDynamic = /import\s*\(\s*(['"])(.*?)\1\s*\)/g;
+    let m;
+    while ((m = reImportFrom.exec(src)) !== null)
+        out.add(m[2]);
+    while ((m = reDynamic.exec(src)) !== null)
+        out.add(m[2]);
+    // Bare `import 'target'` without from
+    const reBare = /import\s+(['"])(.*?)\1/g;
+    while ((m = reBare.exec(src)) !== null)
+        out.add(m[2]);
+    return [...out];
+}
+function resolveImport(target, fromFile, projectRoot) {
+    // Only follow relative imports; package imports are out of scope for DFS.
+    if (!target.startsWith('.') && !target.startsWith('/'))
+        return null;
+    const base = isAbsolute(target) ? join(projectRoot, target.slice(1)) : resolve(dirname(fromFile), target);
+    // Must stay inside the project root.
+    const rel = relative(projectRoot, base);
+    if (rel.startsWith('..'))
+        return null;
+    // Try candidate paths (direct, with suffix, index).
+    const candidates = [
+        base,
+        base + '.vue',
+        base + '.ts',
+        base + '.js',
+        base + '.mjs',
+        base + '.scss',
+        base + '.css',
+        join(base, 'index.vue'),
+        join(base, 'index.ts'),
+        join(base, 'index.js'),
+        join(base, 'index.mjs'),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c) && isFile(c))
+            return c;
+    }
+    return null;
+}
+function isFile(p) {
+    try {
+        const entries = readdirSync(dirname(p), { withFileTypes: true });
+        const name = p.slice(dirname(p).length + 1);
+        return entries.some((e) => e.name === name && e.isFile());
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=vue-page-locator.js.map