Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* chatPathCandidate — 聊天正文里文件/目录路径引用的纯字符串识别与换算。
* ---------------------------------------------------------------------------
* 手机版「文件 chip 点亮」的候选判定层,与桌面端保持同一套识别语义
* (apps/desktop/src/renderer/lib/{localPathResolver,markdownTarget}.ts 与
* shared/workdirPath.ts 的移植子集;两端判定规则如需调整应同步):
*
* - 识别宽松、点亮严格:这里只判「形状像不像路径」,误报由远端 stat 验证
* (remotePathVerdict)过滤——不存在的路径永远保持纯文本。
* - 行号后缀(`foo.ts:42`、`foo.ts:42:7`、`foo.ts:10-20`)拆出 line/column;
* - 目录尾斜杠形态(`src/components/`)去尾杠后按 candidate 处理;
* - workdir 相对换算兼容 Windows 被控端(反斜杠、大小写不敏感、`.` 段归一、
* `..` 逃逸拒绝),输出统一 POSIX 分隔(file-browser 全链路 relPath 约定);
* - workdir 外的绝对路径不再一票否决:文件按 absPath 走被控端媒体取件 /
* 文本预览通道打开(对齐桌面缓存副本语义),目录仍保持纯文本
* (canOpenChatPathChip)。
*
* 全部纯函数,无 IO、无 RN 依赖,可单测。
*/
const WIN_ABS_RE = /^[A-Za-z]:[\\/]/;
/** POSIX 绝对路径且带扩展名(裸 `/etc` 不算)。 */
const POSIX_ABS_PATH_RE = /^\/[^/\s][^\s]*\.[a-z0-9]{1,10}(\?[^\s]*)?$/i;
/** 相对路径:至少一个分隔符 + 扩展名 + 无空白无冒号。 */
const REL_PATH_WITH_SEP_AND_EXT_RE = /^[^\s:]*[\\/][^\s:]+\.[a-z0-9]{1,10}(\?[^\s]*)?$/i;
/** 任意 URL scheme(http://、file://、git+ssh:// …)。 */
const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
/**
* 显式绝对路径形态:`file://` scheme / POSIX `/…` / Windows 盘符。**不要求扩展名** ——
* `/etc/hosts` 与 `C:\Windows\System32` 是路径引用里最明确的形态,不该因为没有后缀就被
* 当成可疑。仅供 isAmbiguousChatPathShape 使用(桌面 markdownTarget 同名常量需同步)。
*/
const ABSOLUTE_PATH_SHAPE_RE = /^(?:file:\/\/|\/|[A-Za-z]:[\\/])/i;
/** 广义 scheme 前缀(`foo:`),用于剔除 mailto: 等非路径形态。 */
const SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
/** 尾部路径分隔符 → 目录形态。 */
const TRAILING_SEP_RE = /[\\/]$/;
/** 裸文件名引用(`package.json`):无分隔符但有 1-10 位扩展名。 */
const BARE_FILE_REF_RE = /^[^\s:<>()[\]{}"'`]+?\.[a-z0-9]{1,10}$/i;
/** 有任意扩展名(byExt 兜底判定用)。 */
const HAS_EXT_RE = /\.[a-z0-9]{1,10}(\?.*)?$/i;
const POSITIVE_LINE_NUMBER_RE = /^[1-9]\d{0,6}$/;
const LINE_RANGE_SUFFIX_RE = /^([1-9]\d{0,6})-([1-9]\d{0,6})$/;
export interface ChatPathLineSuffix {
href: string;
line?: number;
column?: number;
}
/** 拆 `path:line[:column]` / `path:start-end` 后缀(与桌面 splitLocalLineSuffix 同语义)。 */
export function splitChatPathLineSuffix(raw: string): ChatPathLineSuffix {
const href = raw.trim();
if (!href) return { href };
if (URL_SCHEME_RE.test(href) && !href.toLowerCase().startsWith('file://')) {
return { href };
}
const lastColon = href.lastIndexOf(':');
if (lastColon <= 0) return { href };
const lastPart = href.slice(lastColon + 1);
const beforeLastPart = href.slice(0, lastColon);
const rangeMatch = lastPart.match(LINE_RANGE_SUFFIX_RE);
if (rangeMatch) {
const line = Number(rangeMatch[1]);
const endLine = Number(rangeMatch[2]);
if (!Number.isSafeInteger(line) || !Number.isSafeInteger(endLine) || endLine < line) {
return { href };
}
return { href: beforeLastPart, line };
}
if (!POSITIVE_LINE_NUMBER_RE.test(lastPart)) return { href };
const previousColon = beforeLastPart.lastIndexOf(':');
const previousPart = previousColon >= 0 ? beforeLastPart.slice(previousColon + 1) : '';
const hasColumn = POSITIVE_LINE_NUMBER_RE.test(previousPart);
const base = hasColumn ? beforeLastPart.slice(0, previousColon) : beforeLastPart;
if (!base) return { href };
const line = Number(hasColumn ? previousPart : lastPart);
const column = hasColumn ? Number(lastPart) : undefined;
if (!Number.isSafeInteger(line) || line <= 0) return { href };
if (column !== undefined && (!Number.isSafeInteger(column) || column <= 0)) return { href };
return {
href: base,
line,
...(column !== undefined ? { column } : {}),
};
}
/** 尾斜杠 → 目录形态(renderer 无法 stat,尾杠是唯一可靠信号)。 */
export function looksLikeDirectoryPath(text: string): boolean {
if (!text) return false;
return TRAILING_SEP_RE.test(text);
}
/** Windows 盘符前缀(`C:\x`)不算 scheme;file:// 允许;其余 `foo:` 前缀一律拒绝。 */
function hasUnsupportedScheme(value: string): boolean {
if (WIN_ABS_RE.test(value)) return false;
if (value.toLowerCase().startsWith('file://')) return false;
return SCHEME_RE.test(value);
}
/**
* 「形状像文件路径」严判(inline code 常见标识符/命令,宽了全是误点击目标):
* Windows 绝对 / POSIX 绝对带扩展 / 相对带分隔符带扩展,三者任一。
*/
export function looksLikeFilePath(text: string): boolean {
if (!text) return false;
if (text.includes('\n')) return false;
if (URL_SCHEME_RE.test(text)) return false;
if (looksLikeDirectoryPath(text)) return false;
if (WIN_ABS_RE.test(text)) return true;
if (POSIX_ABS_PATH_RE.test(text)) return true;
if (REL_PATH_WITH_SEP_AND_EXT_RE.test(text)) return true;
return false;
}
/** 裸文件名引用(`package.json`),存在性由远端 stat 决定。 */
export function looksLikeBareFileReference(value: string): boolean {
if (!value || value.includes('\n')) return false;
if (hasUnsupportedScheme(value)) return false;
if (looksLikeDirectoryPath(value)) return false;
return BARE_FILE_REF_RE.test(value);
}
/**
* classifyMarkdownHref 的 local 判定子集(不区分 image/text/model——手机预览页
* 自己按扩展名分派):绝对路径 / 含分隔符 / 带扩展名任一即视作本地路径形态。
*/
function looksLikeLocalHref(href: string): boolean {
if (!href) return false;
if (/^https?:\/\//i.test(href)) return false;
if (href.startsWith('#')) return false;
if (URL_SCHEME_RE.test(href) && !href.startsWith('file://')) return false;
let probe = href;
if (probe.startsWith('file://')) probe = probe.slice(7);
return (
probe.startsWith('/')
|| WIN_ABS_RE.test(probe)
|| probe.includes('/')
|| probe.includes('\\')
|| HAS_EXT_RE.test(probe)
);
}
export interface ChatPathCandidate {
/** 去掉行号后缀与目录尾斜杠后的路径文本(拿去 join workdir)。 */
href: string;
line?: number;
column?: number;
/** 尾斜杠目录形态:verdict 为 unknown(乐观点亮)时按目录处理。 */
directoryShape: boolean;
/**
* 「形状上无法与普通代码/散文区分」的歧义候选。词法层真的分不开:
* - 无分隔符裸名:`package.json` 与 `array.map` / `Date.now` 结构完全同形
* (`.map` / `.log` / `.now` 既是真实扩展名也是方法名);
* - 有分隔符但无扩展名:`src/components` 与 `and/or` / `n/a` / `read/write`
* 结构完全同形。
*
* 用途是**把乐观点亮降级**(见 MessageRenderer.ChatPathChipSpan),而**不是**把它们
* 排除出候选——排除会连 `` `src/components` `` 这类真实目录引用一起砍掉,那是能力
* 倒退。歧义候选照旧发 stat,只是必须等远端明确回 file / directory 才点亮:
* 真实存在的照常可点,`and/or` 这种永远不存在的自然保持纯文本,链路断时也不会
* 变成可点的假链接。
*
* 反过来,形状明确是路径的(绝对路径 / 尾斜杠目录 / 分隔符+扩展名)不算歧义,
* 链路断时仍乐观点亮——不因断链把整条消息的 chip 全灭掉。
*/
ambiguousShape: boolean;
}
/**
* 「形状上无法与普通代码 / 散文区分」的唯一判据 —— 与桌面
* `markdownTarget.isAmbiguousPathShape` **逐字同形**(两端需同步)。
*
* 所有候选入口(行内 code / 显式 markdown 链接 / 正文裸路径)都必须经它算
* `ambiguousShape`,不得按来源硬写 true/false:DESIGN.md §14.5 的**规则 4(候选门槛)**
* 对显式链接有来源豁免,**规则 5(点亮门槛)没有** —— 混淆两者会让「有下划线 = 可点」
* 在某一个入口上失效(PR #1144 review 实捉:这里曾对链接入口恒 false)。
*
* `originalHref` 传原始文本:尾斜杠在 classify* 里会被剥掉,而尾斜杠是作者显式给出的
* 目录信号、形状明确 → 不歧义。只看剥完的 href 会把 `src/components/` 误判成歧义。
*/
export function isAmbiguousChatPathShape(href: string, originalHref?: string): boolean {
const raw = originalHref ?? href;
if (looksLikeDirectoryPath(raw)) return false;
// **绝对路径正面识别,不要求扩展名。** 不能靠 looksLikeFilePath 顺带:它的
// URL_SCHEME_RE 排除是为「别把 https:// 当本地路径」写的、POSIX 分支要求扩展名是为
// 「别让无扩展名引用触发预览」写的,照抄就会把最明确的形态判成最可疑的 ——
// `file:///Users/me/a.md`(检查点自查)与 `/etc/hosts`、`/usr/bin/node`
// (PR #1144 review 实捉)是同一根因的两个分支。
if (ABSOLUTE_PATH_SHAPE_RE.test(raw)) return false;
return !looksLikeFilePath(href);
}
/**
* inline code 文本 → 路径候选(与桌面 classifyInlineCodeTarget 同语义)。
* 首尾空白 / 多行 / scheme 前缀(`mailto:`、`git+ssh://`)一律不候选;
* 候选 ≠ 点亮,存在性由 remotePathVerdict 远端 stat 决定。
*
* 候选口径刻意保持宽松(与桌面 classifyInlineCodeTarget 同步):`src/components`
* 这类「有分隔符、无扩展名」的真实目录引用必须收进来,而它与 `and/or` / `n/a`
* 词法完全同形,想靠形状把后者排除就一定会连前者一起砍掉。精度不在这一层解决,
* 由 ambiguousShape 把点亮门槛提高(见该字段说明)。
*/
export function classifyInlineCodePathCandidate(text: string): ChatPathCandidate | null {
const raw = text.trim();
if (!raw || raw !== text || raw.includes('\n')) return null;
if (hasUnsupportedScheme(raw)) return null;
const lineInfo = splitChatPathLineSuffix(raw);
const href = lineInfo.href;
if (looksLikeDirectoryPath(href)) {
const stripped = href.replace(/[\\/]+$/, '');
if (!stripped) return null;
// 尾斜杠是作者显式给出的目录信号,形状明确 → 不算歧义(判据同下,不硬写字面量)。
return { href: stripped, directoryShape: true, ambiguousShape: isAmbiguousChatPathShape(stripped, raw) };
}
if (!looksLikeFilePath(href) && !looksLikeBareFileReference(href) && !looksLikeLocalHref(href)) {
return null;
}
return {
href,
directoryShape: false,
ambiguousShape: isAmbiguousChatPathShape(href, raw),
...(lineInfo.line !== undefined ? { line: lineInfo.line } : {}),
...(lineInfo.column !== undefined ? { column: lineInfo.column } : {}),
};
}
/**
* markdown 链接目标 → 路径候选(与桌面 classifyMarkdownLinkTarget 的 local 分支
* 同语义):`[README.md](/abs/path/README.md:17)` 这类模型高频输出的本地路径链接。
* http(s) / 锚点 / 非 file 的 scheme 一律不候选(那些走原有 link 渲染分支);
* 与 inline code 版的差异只有两处:
* ① 不要求原文无首尾空白(URL 在括号里,天然精确);
* ② 这里**保留** looksLikeLocalHref 的宽松兜底 —— `[配置](package.json)` 是作者
* (或模型)显式写出的链接目标,不存在「其实是属性访问」的歧义,所以进不进候选
* 不必按形状卡(DESIGN.md §14.5 **规则 4** 的来源豁免)。
*
* ⚠️ 但**点亮门槛(规则 5)没有来源豁免**:ambiguousShape 照样按形状算。作者声明了
* 「这是链接」并不能让远端在链路断时知道 `package.json` / `src/components` 是否存在,
* 而点亮了却点不开就正是规则 1 要防的反例。此处曾恒写 false,与桌面
* (isAmbiguousPathShape 对全部 local-candidate 一视同仁)不对称,PR #1144 review 实捉。
* 对裸路径入口(findBareFilePathMatch)这是**无操作**:它的词法强制末段带扩展名,
* looksLikeFilePath 必然为真 → 恒非歧义,能力不受影响(有用例钉住)。
*/
export function classifyChatPathLinkTarget(url: string): ChatPathCandidate | null {
let raw = url.trim();
if (/^xdt-file:\/\//i.test(raw)) {
try {
// Parse triple-slash spelling directly: Electron's standard-scheme URL parser can
// incorrectly treat the first path component as a hostname.
raw = /^xdt-file:\/\/\//i.test(raw)
? decodeURIComponent(raw.slice('xdt-file://'.length).split(/[?#]/, 1)[0])
: new URL(raw).searchParams.get('path') ?? '';
if (/^\/[A-Za-z]:[\\/]/.test(raw)) raw = raw.slice(1);
if (!isAbsolutePathShape(raw) || /[\0\r\n]/.test(raw)) return null;
} catch { return null; }
}
if (!raw || raw.includes('\n')) return null;
if (/^https?:\/\//i.test(raw)) return null;
if (raw.startsWith('#')) return null;
if (hasUnsupportedScheme(raw)) return null;
const lineInfo = splitChatPathLineSuffix(raw);
const href = lineInfo.href;
if (looksLikeDirectoryPath(href)) {
const stripped = href.replace(/[\\/]+$/, '');
if (!stripped) return null;
return { href: stripped, directoryShape: true, ambiguousShape: isAmbiguousChatPathShape(stripped, raw) };
}
if (!looksLikeLocalHref(href)) return null;
return {
href,
directoryShape: false,
ambiguousShape: isAmbiguousChatPathShape(href, raw),
...(lineInfo.line !== undefined ? { line: lineInfo.line } : {}),
...(lineInfo.column !== undefined ? { column: lineInfo.column } : {}),
};
}
/**
* href → 被控端绝对路径(与桌面 resolveLocalPath 同语义):
* file:// 解包;绝对路径原样;相对路径按 workdir 分隔符风格 join
* (workdir 含 `\` → Windows join 并把 href 的 `/` 归一为 `\`)。
* 不做存在性检查——那是 remotePathVerdict 的事。
*/
export function resolveChatAbsPath(href: string, workdir: string): string {
if (href.startsWith('file://')) {
// 非法百分号序列(`50%off.md` 的 `%of`)会让 decodeURIComponent 抛 URIError,
// 而本函数在 chip 组件 useMemo 里同步跑,异常会崩整条消息渲染——解码失败
// 回退原文(bot review 实捉);路径若真不存在由远端 stat 判 nonfile 兜底。
let p: string;
try {
p = decodeURIComponent(href.slice(7));
} catch {
p = href.slice(7);
}
if (/^\/[A-Za-z]:[\\/]/.test(p)) p = p.slice(1);
return p;
}
if (href.startsWith('/')) return href;
if (WIN_ABS_RE.test(href)) return href;
const isWin = workdir.includes('\\');
const sep = isWin ? '\\' : '/';
// 去尾部分隔符,但保住根形态(`/`、`C:\`)。
const trimmed = workdir.replace(/[\\/]+$/, '');
const base = trimmed || (workdir.startsWith('/') ? '/' : workdir);
const normalizedHref = isWin ? href.replace(/\//g, '\\') : href;
return base === '/' ? `/${normalizedHref}` : `${base}${sep}${normalizedHref}`;
}
/** 去掉路径里的 `.` 段(`/w/./a` → `/w/a`),避免同路径两形态。 */
export function dropDotSegments(p: string): string {
const isAbs = p.startsWith('/');
const segs = p.split('/').filter((s) => s !== '.' && s !== '');
return (isAbs ? '/' : '') + segs.join('/');
}
function toWorkdirRelPosix(workdir: string, absPath: string): string | null {
if (!workdir.startsWith('/') || !absPath.startsWith('/')) return null;
if (absPath.split('/').includes('..')) return null;
const base = workdir.replace(/\/+$/, '');
if (!absPath.startsWith(`${base}/`)) return null;
const rel = absPath.slice(base.length + 1);
return rel.length > 0 ? rel : null;
}
/**
* 绝对路径 → workdir 相对路径(POSIX 分隔;与桌面 shared/workdirPath.ts 同语义)。
* 不在 workdir 内(含 workdir 自身)/ `..` 逃逸 / 风格不匹配 → null。
* Windows 被控端按大小写不敏感前缀比较,输出仍统一 POSIX 分隔。
*/
export function toWorkdirRel(workdir: string, absPath: string): string | null {
if (!workdir || !absPath) return null;
if (workdir.startsWith('/')) {
return toWorkdirRelPosix(workdir, dropDotSegments(absPath));
}
if (!WIN_ABS_RE.test(workdir) || !WIN_ABS_RE.test(absPath)) return null;
const w = workdir.replace(/\\/g, '/').replace(/\/+$/, '');
const a = dropDotSegments(absPath.replace(/\\/g, '/'));
if (a.split('/').includes('..')) return null;
if (!a.toLowerCase().startsWith(`${w.toLowerCase()}/`)) return null;
const rel = a.slice(w.length + 1);
return rel.length > 0 ? rel : null;
}
/** 绝对路径形态(POSIX `/x` 或 Windows 盘符 `C:\x`),与相对路径二分。 */
export function isAbsolutePathShape(p: string): boolean {
return p.startsWith('/') || WIN_ABS_RE.test(p);
}
/** 路径显示名:最后一段(POSIX / Windows 分隔符均可,尾分隔符忽略)。 */
export function pathDisplayName(p: string): string {
const last = p.split(/[\\/]/).filter(Boolean).pop();
return last ?? p;
}
/**
* chip 是否可打开(点亮的后置条件):workdir 外(relPath 为 null)只有文件可开
* ——文件走被控端绝对路径取件通道(fs:stat-path 已验存在);目录只能靠
* 文件浏览器定位,而文件浏览器以 workdir 为根,workdir 外目录保持纯文本。
* 与桌面对齐:桌面对 workdir 外目录同样只报「不在工作目录内」,无可用动作。
*/
export function canOpenChatPathChip(kind: 'file' | 'directory', relPath: string | null): boolean {
return kind === 'file' || relPath !== null;
}
/**
* 链接 label 是否「读起来就是个文件引用」(桌面 shouldRenderCodeReferenceLabel 的
* 移植,两端口径需同步)。用途:决定**作者手写**的本地路径链接点亮后是否套等宽
* chip —— `[README.md](path)` 是作者的排版意图,保留 chip;`[看这份规则](path)`
* 是散文 label,按正文字体 + 下划线渲染。
*
* 正文裸写的路径不走这条判定(它没有独立 label),一律保持正文字体;见
* DESIGN.md §14.5 的落地推论。
*/
export function chatPathLabelReadsAsFileReference(
label: string,
candidate: ChatPathCandidate,
originalUrl: string,
): boolean {
const trimmed = label.trim();
if (!trimmed || trimmed.includes('\n')) return false;
// label 就是 href 原文(含未剥行号后缀的形态)。
if (trimmed === candidate.href || trimmed === originalUrl.trim()) return true;
// label 是末段文件名,可带 :line[:column]。
const baseName = pathDisplayName(candidate.href);
if (trimmed === baseName) return true;
if (candidate.line !== undefined) {
if (trimmed === `${baseName}:${candidate.line}`) return true;
if (candidate.column !== undefined && trimmed === `${baseName}:${candidate.line}:${candidate.column}`) {
return true;
}
}
// 形状兜底:label 自身长得像路径 / 文件名。先剥行号后缀,再复用与分类器同一组
// 谓词,「什么算文件」全仓一致。
const labelPath = splitChatPathLineSuffix(trimmed).href;
return looksLikeFilePath(labelPath) || looksLikeBareFileReference(labelPath);
}
// ── 正文纯文本裸路径的词法定位(桌面 remarkLocalPathLinks 的移植) ──────────
//
// 桌面端把「回复正文纯文本里长得像本地路径的 token」切成 mdast link 节点
// (apps/desktop/src/renderer/components/chat/remarkLocalPathLinks.ts),从而复用
// 既有链接渲染链路;手机端 messageMarkdown 的 inline 分词器没有对应入口,裸路径
// 一直只是纯文本。下面是该插件正则与 findPathMatches 的等价移植;正则任一侧改动
// 都要同步另一侧(同本文件头注释的两端同步约定)。
//
// 匹配策略沿用桌面口径(桌面侧有同款说明):
// - 用「正向路径正则」定位 token,而不是按空白切再剥边——后者在中文里
// (`src/App.tsx,然后呢` 这种路径直接黏着中文)会把尾巴一起吞掉判废。正向
// 正则在**扩展名**处收尾,尾随的中文/标点天然落在 match 之外。
// - 只认**带路径分隔符**的形态(相对含 `/` 或 `\` + 扩展名、`./` `../` `~/`
// 开头、POSIX 绝对、Windows 盘符)。裸文件名(`app.tsx`)在正文里太歧义,
// 不碰——这点比 inline code 更严(inline code 是作者主动用反引号标注的格式
// 信号,走 looksLikeBareFileReference)。
// - 左边界用负向 lookbehind 卡死:路径前一个字符必须是边界,不能是另一个路径
// 字符,避免从中文 prose 中间起切。
//
// 已知限制(CJK 既可能是 prose 也可能是真实目录名 `我的看板`,词法层无法区分,故
// 一律当作路径段字符;代价在「无空白边界紧贴中文」时显现,均与现状一致、本就点不动,
// 不是回退):
// - 前导紧贴:`见src/x.ts` → `见` 被并入 token,解析不到 → 纯文本。
// - 中文黏连两条真路径:`a/b.ts和c/d.ts` → 中间的 `和` 被当成路径段,整串吞成
// **一个** token,两条真路径都点不亮。
// 要救这些只能把 CJK 当分隔符,但那会反过来切断 `docs/设计稿/index.md` 里的中文
// 目录名,得不偿失,故不做。
// CJK / 假名 / 谚文:可作为路径段的一部分(如 `docs/设计稿/index.md`)。
const BARE_PATH_CJK = '\\u4e00-\\u9fff\\u3400-\\u4dbf\\u3040-\\u30ff\\uac00-\\ud7af';
// 路径段允许的字符(不含分隔符、不含 `:`)。`:` 留给盘符锚点与 `:line` 后缀。
const BARE_PATH_SEG = `[A-Za-z0-9._~@+\\-${BARE_PATH_CJK}]+`;
const BARE_PATH_SEP = '\\\\/'; // 反斜杠 + 正斜杠,字符类内用
// 锚点:盘符 `C:\` / `./` `../` / 单独的分隔符开头。
//
// **刻意不含 `~/`**:`~` 在本仓任何一层都没有展开 —— renderer 的 resolveLocalPath /
// resolveChatAbsPath 只做 join,被控端的 fs:stat-path / fs:resolve-path 也不展开,于是
// `~/logs/app.log` 会被 stat 成 `<workdir>/~/logs/app.log`:链路正常时判 nonfile、永远不
// 点亮(白发一次 stat),链路断时还会按「绝对形状」乐观点亮、点开错误地址。
// 在拿到可靠展开能力(被控端返回真实 home)之前,正文裸路径不认这个锚点
// (PR #1144 review 实捉;行内 code / 显式链接入口的同一问题是既有行为,属另一处 —— 修它
// 要改被控端协议,不是 renderer 能兜的,已在 PR 里记为 follow-up)。
const BARE_PATH_ANCHOR = `(?:[A-Za-z]:[${BARE_PATH_SEP}]|\\.{1,2}[${BARE_PATH_SEP}]|[${BARE_PATH_SEP}])`;
// `SEG` 含 `~`(备份文件 `file~` 等中段用途),所以只改锚点挡不住 `~/x`:
// `(?:SEG SEP)+` 一样能把 `~/` 当成「段+分隔符」吃下去。故在整条匹配前加负向前瞻,
// 明确拒绝以 `~/` `~\` 开头的 token(实测过:只删锚点里的 `~` 时 `~/logs/app.log`
// 仍然命中)。
const BARE_PATH_NO_HOME = '(?!~[\\\\/])';
// 右边界:匹配**不得停在段内字符或分隔符之前**。只排除字母数字是不够的 —— SEG 还允许
// `_ ~ @ + -` 与 CJK,分隔符也会漏过去,于是这些形态会被切出一个错误前缀、后半段留成
// 普通文本,而那个前缀形状上是「分隔符+扩展名」= 非歧义,断链时会被点亮、点开错误地址:
// src/foo.ts/bar → `src/foo.ts` + 文本 `/bar`
// src/file.tsx_backup → `src/file.tsx` + 文本 `_backup`
// src/foo.ts~ → `src/foo.ts` + 文本 `~`
// (PR #1144 review 实捉;上一轮只挡住了「超长扩展名」这一种。)
//
// **`.` 刻意不排除**:句末英文句点是最常见的紧随字符,把它加进来会让 `见 src/a.ts.`
// 整条失配(SEG 含 `.`,回溯也救不回来)。`:` 同理留给合法的 `:line` 后缀。
const BARE_PATH_RIGHT_BOUNDARY = `(?![A-Za-z0-9_~@+\\-${BARE_PATH_CJK}${BARE_PATH_SEP}])`;
// 路径主体:要么有锚点(中间段可有可无),要么是「段+分隔符」至少一组(保证含分隔符);
// 末段必须以扩展名收尾。
//
// 扩展名后的 `(?![A-Za-z0-9])` 是**右边界**,不能省:没有它,超过 10 个字符的扩展名会被
// 截成前 10 个字符当成候选(`src/file.typescriptreact` → `src/file.typescript`),而截断后
// 的前缀形状上是「分隔符+扩展名」= 非歧义,断链时会被加下划线、允许点击,点开的是一个
// **不存在的错误路径**;正文里还留着孤零零的 `react`。加了边界之后整条路径直接不识别
// (退回纯文本),这才是想要的语义(PR #1144 review 实捉,桌面 remarkLocalPathLinks 同步)。
const BARE_PATH_BODY =
`(?:${BARE_PATH_ANCHOR}(?:${BARE_PATH_SEG}[${BARE_PATH_SEP}])*`
+ `|(?:${BARE_PATH_SEG}[${BARE_PATH_SEP}])+)${BARE_PATH_SEG}\\.[A-Za-z0-9]{1,10}${BARE_PATH_RIGHT_BOUNDARY}`;
// 可选 `:line[:column]` 行号后缀。
const BARE_PATH_LINE_SUFFIX = '(?::[1-9]\\d{0,6}(?::[1-9]\\d{0,6})?)?';
// 左边界:前一个字符不能是路径字符 / 分隔符(`:` 不算,允许 `文件:src/x.ts`)。
const BARE_PATH_LEFT_BOUNDARY = `(?<![A-Za-z0-9._~@+${BARE_PATH_CJK}${BARE_PATH_SEP}])`;
const BARE_PATH_RE_SOURCE =
`${BARE_PATH_LEFT_BOUNDARY}${BARE_PATH_NO_HOME}(${BARE_PATH_BODY}${BARE_PATH_LINE_SUFFIX})`;
/**
* 边界后置过滤 —— 一条统一判据,替掉「一轮补一个字符类」。
*
* 词法层是「在散文里用正向正则定位路径」(按空白切 token 再剥边在中文里不成立,见本文件
* 头部的说明),所以必须自己保证:**命中要独占它所在的路径 token,不许从中段起、也不许把
* 紧跟的字符截断**。前四轮 review 各捉到这条规格的一个缺口(扩展名长度 / 右边界字符 /
* 空格中段 / `( ) # %` 等未支持字符 + 行号后缀),逐个补字符类注定一轮一个,故改成:
*
* 左侧:命中点前是**同一 run 内的字符**时,只有少数字符可以合法地紧邻一条路径 ——
* 开括号 / 引号 / 冒号 / 列表分隔符。其余一律拒绝(说明我们落在
* `foo(bar)/src/index.ts`、`docs/50%off/a.md`、`foo#bar/x/a.ts` 这类**未支持字符**
* 把 token 断开后的中段)。这里刻意用**白名单**:上一版用「run 前缀已含分隔符」
* 的黑名单,假设了未支持字符出现在首个分隔符之后,于是 `foo(bar)/src/index.ts`
* (括号在第一个 `/` 之前)绕过去、还切出个绝对路径 `/src/index.ts`。白名单让未知
* 字符**默认拒绝**,与本节「宁可少点亮」同向,不必再逐个补。
* 命中点前是空白时,看空白前那个 run:含分隔符**且不以扩展名收尾** → 拒绝
* (`C:\Program Files\Cindy\app.log` 被空格截断的后半段)。「不以扩展名收尾」
* 不能省,否则 `src/a.ts src/b.ts` 里的第二条会被连坐。
* 右侧:命中之后紧跟 token 字符 → 拒绝。正则自带的右边界只管到扩展名,整段行号后缀
* 之后没有边界,于是 `src/a.ts:12345678` 被截成 `:1234567`、`src/a.ts:12foo`
* 截成 `:12`(错误行号 + 正文残留)。`.` 与 `:` 本身不算 token 字符(句末句点
* `见 src/a.ts.`、句末冒号 `见 src/a.ts:` 要保住),但**它们后面还跟 token 字符**
* 时同样拒绝 —— 否则 `src/a.ts:12.5` / `src/a.ts:12:foo` 会留下错误行号 + 正文
* 残渣,而且这种前缀在链路正常时也会点亮。
*
* 好处是 `( ) # % [ ]` 之类**不需要枚举**:白名单之外一律拒绝,以后出现别的未支持字符
* 也自动覆盖,不必再来一轮。
*
* 已知误伤(显式取舍,有用例钉住):散文里紧挨着一个「含分隔符、无扩展名」的片段时会被
* 连坐,如 `见 /etc src/a.ts`。代价是少点亮一条、文本仍可读,方向与 DESIGN.md §14.5
* 「宁可少点亮一个真目录,不可多点亮一片假链接」一致。
*/
const TOKEN_CHAR_RE = new RegExp(`[A-Za-z0-9_~@+\\-${BARE_PATH_CJK}\\\\/]`);
/**
* 可以合法地紧邻一条裸路径的字符(同一 run 内)。白名单而非黑名单:未知字符默认拒绝。
* 开括号与引号 —— 路径被包裹(`见(src/a.ts)`);冒号 —— `文件:src/x.ts`;
* 列表分隔符 —— `src/a.ts,src/b.ts` 是真的两条路径。
* `>` 也放行:字面 HTML 的**元素内容**里的路径按既有口径仍识别(`<div>src/App.tsx</div>`,
* 与 strong / inlineCode / 裸 URL matcher 同口径,见 messageMarkdown 的说明),而 `>` 不可能
* 出现在路径段内,放行它不会带来错误前缀。
* 注意闭括号 `)` `]` 刻意**不在**表里:它只可能出现在被断开的 token 中间。
* `=` 同样不在表里:`--config=src/a.json` 因此不点亮 —— 那是可有可无的便利,而放行 `=` 会
* 让 `docs/a=b/c.md` 切出错误前缀 `b/c.md`(§14.5:宁可少点亮一个,不可多点亮一片)。
*/
const ALLOWED_BEFORE_RE = /[([{(【「『"'`::,;,;、>]/;
const SEP_IN_RUN_RE = /[\\/]/;
const TRAILING_EXT_RE = /\.[A-Za-z0-9]{1,10}$/;
/** 命中是否从路径 token 的**中段**起(见上方说明)。 */
function startsMidPathToken(text: string, start: number): boolean {
if (start === 0) return false;
// (1) 同一非空白 run 内:只有白名单字符可以紧邻路径,其余说明是被断开的中段。
let runStart = start - 1;
while (runStart >= 0 && !/\s/.test(text[runStart])) runStart -= 1;
const runPrefix = text.slice(runStart + 1, start);
if (runPrefix.length > 0) {
return !ALLOWED_BEFORE_RE.test(text[start - 1]);
}
// (2) 命中点前是空白:看空白前那个 run 是不是「被空格截断的前半段」。
// 只跨空格 / 制表符,不跨换行 —— 换行之后是新的一行,不是同一条路径。
let i = start - 1;
while (i >= 0 && (text[i] === ' ' || text[i] === '\t')) i -= 1;
if (i < 0 || i === start - 1) return false;
let j = i;
while (j >= 0 && !/\s/.test(text[j])) j -= 1;
const prevRun = text.slice(j + 1, i + 1);
if (!SEP_IN_RUN_RE.test(prevRun)) return false;
return !TRAILING_EXT_RE.test(prevRun);
}
/** 命中之后是否紧跟 token 字符(= 我们截断了它,见上方说明)。 */
function endsMidPathToken(text: string, end: number): boolean {
const next = text[end];
if (next === undefined) return false;
if (TOKEN_CHAR_RE.test(next)) return true;
// `.` / `:` 本身要放过(句末句点 / 句末冒号),但它们后面还跟 token 字符时说明我们把
// 一段复合后缀截断了:`src/a.ts:12.5`、`src/a.ts:12:foo`。
//
// **跳过整串标点再判,不能只看紧邻一个字符**:只看一个时 `src/a.ts:12..5`、
// `src/a.ts:12::foo`、`src/a.ts:12:.:foo` 会因为第二个标点不是 token 字符而绕过去
// (这一处被连续挖了三轮:`:12345678` → `:12.5` → `:12..5`,每轮多一层嵌套;跳整串是
// 为了把「再多一个标点」这条路一次封掉)。句末连写的省略号 `src/a.ts...` 仍保住 ——
// 跳完之后没有 token 字符。
if (next === '.' || next === ':') {
let i = end;
while (text[i] === '.' || text[i] === ':') i += 1;
const after = text[i];
return after !== undefined && TOKEN_CHAR_RE.test(after);
}
return false;
}
export interface BareFilePathMatch {
/** 在 input 里的起始下标。 */
index: number;
/** 结束下标(不含)。 */
end: number;
/** 命中的路径文本(含可能的 `:line` 后缀,交给渲染层再拆)。 */
value: string;
}
/**
* 在一段纯文本里定位从 `from` 起**第一条**「带分隔符、可解析形状」的裸路径。
* 与桌面 findPathMatches 同一套复核口径:剥行号后缀 → looksLikeFilePath,与
* inline code / 链接共用同一组谓词,「什么算文件路径」全仓一致。
*
* 候选 ≠ 点亮:`16/9.0`、`a/b.c` 这类形状达标的误命中同样返回,存在性由远端
* stat(remotePathVerdict)兜底,解析不到就保持纯文本。
*/
export function findBareFilePathMatch(
input: string,
from: number,
// Optional paragraph-local exec cache, bound to this exact immutable input.
search?: (regex: RegExp) => RegExpExecArray | null,
): BareFilePathMatch | null {
// 不含任何路径分隔符的文本一定不是带分隔符路径。这条短路在渲染热路径上逐 token
// 生效(见 messageMarkdown.findNextInlineToken),不能省。
if (!input.includes('/') && !input.includes('\\')) return null;
// 每次调用新建:`g` 标志的 lastIndex 是可变状态,模块级共享在提前 return /
// 未过重置路径时会漏匹配(同 messageMarkdown 里各 matcher 的既有约定)。
const re = new RegExp(BARE_PATH_RE_SOURCE, 'g');
re.lastIndex = Math.max(0, from);
let m: RegExpExecArray | null;
while ((m = search ? search(re) : re.exec(input)) !== null) {
const value = m[1];
if (!looksLikeFilePath(splitChatPathLineSuffix(value).href)) continue;
const index = m.index + (m[0].length - value.length);
// 边界后置过滤:命中必须独占它所在的路径 token(见 startsMidPathToken 的说明)。
if (startsMidPathToken(input, index)) continue;
if (endsMidPathToken(input, index + value.length)) continue;
return { index, end: index + value.length, value };
}
return null;
}