Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

14.9 KB
Raw Blame
/**
 * 代码块语法着色的轻量词法分析器。
 *
 * **为什么不用 highlight.js**:`apps/mobile/package.json` 的依赖是 runtime
 * fingerprint 输入,加一个高亮库会触发冷更 —— 存量装机拿不到本次及后续热更,
 * 代价与技术框架变动同级(见 docs/dev-rules/mobile-development.md)。为了纯观感
 * 需求付这个代价不值,所以词法在仓内自己做:本文件是 `src/` 源码,不进依赖表,
 * 指纹不变。
 *
 * 因此它**刻意不追求 hljs 的精确度**,只覆盖"扫一眼能看出结构"所需的 6 类:
 * 注释 / 字符串 / 数字 / 关键字 / 函数名 / 属性名。语言未知或不在表内时退化为
 * 通用词法(仍能高亮字符串、数字与 `//`、`#` 注释),不会整块变纯文本。
 *
 * 属性名(`key:` 形态)这一类是必须有的:配置、样式对象、YAML、JSON 这类内容里
 * 属性名占绝大多数,少了它们整块几乎全是 plain —— 桌面 hljs 把它们归入 `attr`
 * 并着蓝色,是那类代码块最主要的视觉信号。
 *
 * 输出与颜色解耦:只给 kind,配色由 theme 的 syntax* token 决定(对齐桌面所用的
 * GitHub highlight.js 主题)。
 */

export type CodeTokenKind =
  | 'plain'
  | 'keyword'
  | 'string'
  | 'comment'
  | 'number'
  | 'function'
  /** `key:` 形态的属性名 / 字段名(对齐 hljs 的 attr,GitHub 主题着蓝)。 */
  | 'property';

export interface CodeToken {
  readonly text: string;
  readonly kind: CodeTokenKind;
}

/** 注释与字符串的语法家族 —— 决定用哪套定界符扫描。 */
type SyntaxFamily = 'c' | 'hash' | 'sql' | 'css' | 'markup' | 'json' | 'generic';

const C_KEYWORDS = [
  'abstract', 'as', 'async', 'await', 'boolean', 'break', 'case', 'catch', 'char', 'class',
  'const', 'constructor', 'continue', 'debugger', 'declare', 'default', 'delete', 'do',
  'double', 'else', 'enum', 'export', 'extends', 'false', 'final', 'finally', 'float', 'for',
  'from', 'function', 'get', 'goto', 'if', 'implements', 'import', 'in', 'instanceof', 'int',
  'interface', 'is', 'let', 'long', 'namespace', 'new', 'null', 'of', 'override', 'package',
  'private', 'protected', 'public', 'readonly', 'return', 'satisfies', 'set', 'static',
  'struct', 'super', 'switch', 'this', 'throw', 'throws', 'true', 'try', 'type', 'typeof',
  'undefined', 'union', 'unsigned', 'var', 'void', 'while', 'with', 'yield',
];

const GO_KEYWORDS = [
  'break', 'case', 'chan', 'const', 'continue', 'default', 'defer', 'else', 'fallthrough',
  'false', 'for', 'func', 'go', 'goto', 'if', 'import', 'interface', 'map', 'nil', 'package',
  'range', 'return', 'select', 'struct', 'switch', 'true', 'type', 'var',
];

const RUST_KEYWORDS = [
  'as', 'async', 'await', 'break', 'const', 'continue', 'crate', 'dyn', 'else', 'enum',
  'extern', 'false', 'fn', 'for', 'if', 'impl', 'in', 'let', 'loop', 'match', 'mod', 'move',
  'mut', 'pub', 'ref', 'return', 'self', 'static', 'struct', 'super', 'trait', 'true', 'type',
  'unsafe', 'use', 'where', 'while',
];

const PYTHON_KEYWORDS = [
  'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif',
  'else', 'except', 'False', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
  'lambda', 'None', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'True', 'try',
  'while', 'with', 'yield',
];

const SHELL_KEYWORDS = [
  'case', 'cd', 'do', 'done', 'echo', 'elif', 'else', 'esac', 'exit', 'export', 'fi', 'for',
  'function', 'if', 'in', 'local', 'return', 'set', 'source', 'then', 'unset', 'until',
  'while',
];

const SQL_KEYWORDS = [
  'and', 'alter', 'as', 'asc', 'by', 'case', 'create', 'delete', 'desc', 'distinct', 'drop',
  'else', 'end', 'exists', 'from', 'group', 'having', 'in', 'index', 'inner', 'insert',
  'into', 'is', 'join', 'left', 'like', 'limit', 'not', 'null', 'offset', 'on', 'or', 'order',
  'outer', 'primary', 'select', 'set', 'table', 'then', 'union', 'update', 'values', 'when',
  'where', 'with',
];

const RUBY_KEYWORDS = [
  'begin', 'break', 'case', 'class', 'def', 'do', 'else', 'elsif', 'end', 'ensure', 'false',
  'for', 'if', 'in', 'module', 'next', 'nil', 'not', 'or', 'require', 'rescue', 'return',
  'self', 'then', 'true', 'unless', 'until', 'when', 'while', 'yield',
];

const YAML_KEYWORDS = ['false', 'no', 'null', 'true', 'yes'];

interface LanguageSpec {
  readonly family: SyntaxFamily;
  readonly keywords: readonly string[];
  /** 关键字是否区分大小写(SQL 惯例大写,故不区分)。 */
  readonly caseSensitive?: boolean;
}

const C_LIKE: LanguageSpec = { family: 'c', keywords: C_KEYWORDS, caseSensitive: true };

/** 语言别名 → 规格。键一律小写。 */
const LANGUAGES: Readonly<Record<string, LanguageSpec>> = {
  bash: { family: 'hash', keywords: SHELL_KEYWORDS, caseSensitive: true },
  c: C_LIKE,
  'c++': C_LIKE,
  cjs: C_LIKE,
  cpp: C_LIKE,
  cs: C_LIKE,
  csharp: C_LIKE,
  css: { family: 'css', keywords: [], caseSensitive: false },
  dart: C_LIKE,
  go: { family: 'c', keywords: GO_KEYWORDS, caseSensitive: true },
  golang: { family: 'c', keywords: GO_KEYWORDS, caseSensitive: true },
  html: { family: 'markup', keywords: [], caseSensitive: false },
  java: C_LIKE,
  javascript: C_LIKE,
  js: C_LIKE,
  json: { family: 'json', keywords: ['false', 'null', 'true'], caseSensitive: true },
  json5: { family: 'c', keywords: ['false', 'null', 'true'], caseSensitive: true },
  jsonc: { family: 'c', keywords: ['false', 'null', 'true'], caseSensitive: true },
  jsx: C_LIKE,
  kotlin: C_LIKE,
  kt: C_LIKE,
  mjs: C_LIKE,
  mysql: { family: 'sql', keywords: SQL_KEYWORDS, caseSensitive: false },
  php: { family: 'c', keywords: C_KEYWORDS, caseSensitive: true },
  postgres: { family: 'sql', keywords: SQL_KEYWORDS, caseSensitive: false },
  psql: { family: 'sql', keywords: SQL_KEYWORDS, caseSensitive: false },
  py: { family: 'hash', keywords: PYTHON_KEYWORDS, caseSensitive: true },
  python: { family: 'hash', keywords: PYTHON_KEYWORDS, caseSensitive: true },
  rb: { family: 'hash', keywords: RUBY_KEYWORDS, caseSensitive: true },
  ruby: { family: 'hash', keywords: RUBY_KEYWORDS, caseSensitive: true },
  rs: { family: 'c', keywords: RUST_KEYWORDS, caseSensitive: true },
  rust: { family: 'c', keywords: RUST_KEYWORDS, caseSensitive: true },
  scala: C_LIKE,
  scss: { family: 'css', keywords: [], caseSensitive: false },
  sh: { family: 'hash', keywords: SHELL_KEYWORDS, caseSensitive: true },
  shell: { family: 'hash', keywords: SHELL_KEYWORDS, caseSensitive: true },
  sql: { family: 'sql', keywords: SQL_KEYWORDS, caseSensitive: false },
  sqlite: { family: 'sql', keywords: SQL_KEYWORDS, caseSensitive: false },
  svelte: { family: 'markup', keywords: [], caseSensitive: false },
  swift: C_LIKE,
  toml: { family: 'hash', keywords: YAML_KEYWORDS, caseSensitive: true },
  ts: C_LIKE,
  tsx: C_LIKE,
  typescript: C_LIKE,
  vue: { family: 'markup', keywords: [], caseSensitive: false },
  xml: { family: 'markup', keywords: [], caseSensitive: false },
  yaml: { family: 'hash', keywords: YAML_KEYWORDS, caseSensitive: true },
  yml: { family: 'hash', keywords: YAML_KEYWORDS, caseSensitive: true },
  zsh: { family: 'hash', keywords: SHELL_KEYWORDS, caseSensitive: true },
};

const GENERIC_SPEC: LanguageSpec = { family: 'generic', keywords: [], caseSensitive: true };

/** 未知语言退化为通用词法(仍高亮字符串 / 数字 / `//` 与 `#` 注释)。 */
function resolveSpec(language: string | undefined): LanguageSpec {
  if (!language) return GENERIC_SPEC;
  const key = language.trim().toLowerCase();
  return LANGUAGES[key] ?? GENERIC_SPEC;
}

const IDENT_START = /[A-Za-z_$]/;
const IDENT_BODY = /[A-Za-z0-9_$]/;
const DIGIT = /[0-9]/;

/**
 * 着色预算 —— 超出就退回纯文本(整块或剩余部分并成一个 plain token)。
 *
 * 这不是性能洁癖,是渲染层的硬约束:每个非 plain token 在聊天流都会变成一个嵌套
 * 原生 Text(iOS 的 selectable 路径上是 UITextView 家族子节点),外层横向 ScrollView
 * **不做虚拟化**,所以挂载成本直接等于 token 数;而流式输出期间整块会随每个 chunk
 * 重新分词并重新挂载。一个几千行的日志或生成文件因此能同步挂出上万个原生节点,
 * 卡住 JS / UI 线程。
 *
 * 超预算时退回的正是**本 PR 之前的形态** —— 纯文本代码块,底色与描边都还在,不是
 * 不显示。而且屏幕上本来也只看得见几十行,超过这个量级的着色没有可感知收益。
 *
 * 两个维度都要卡:`maxSource` 挡住长块(连分词都不做),`maxTokens` 挡住"短但 token
 * 极密"的病态输入(比如一行几千个 `a:1,b:2,…`)。
 */
export const CODE_HIGHLIGHT_LIMITS = {
  maxSource: 20_000,
  maxTokens: 2_000,
} as const;

/** 整块退回纯文本。空串保持返回空数组(与主路径一致)。 */
function plainOnly(source: string): CodeToken[] {
  return source ? [{ text: source, kind: 'plain' }] : [];
}

/**
 * 把源码切成带 kind 的 token 序列。
 *
 * 单趟扫描,优先级:注释 > 字符串 > 数字 > 标识符。相邻同 kind 的片段会合并,
 * 减少渲染层要创建的 Text 节点数。超出 CODE_HIGHLIGHT_LIMITS 时退回纯文本。
 *
 * 无论走哪条分支,输出重新拼接后必须与输入逐字节相等(由测试的 assertLossless 守卫)。
 */
export function tokenizeCode(source: string, language?: string): CodeToken[] {
  // 长块直接退回:流式期间每个 chunk 都会重跑本函数,所以这里连分词都不做。
  if (source.length > CODE_HIGHLIGHT_LIMITS.maxSource) return plainOnly(source);

  const spec = resolveSpec(language);
  const keywords = new Set(
    spec.caseSensitive === false ? spec.keywords.map((w) => w.toLowerCase()) : spec.keywords,
  );
  const out: CodeToken[] = [];
  let plain = '';

  const flush = () => {
    if (plain) {
      out.push({ text: plain, kind: 'plain' });
      plain = '';
    }
  };
  const push = (text: string, kind: CodeTokenKind) => {
    if (!text) return;
    flush();
    const last = out[out.length - 1];
    if (last && last.kind === kind) out[out.length - 1] = { text: last.text + text, kind };
    else out.push({ text, kind });
  };

  const { family } = spec;
  const lineComment = family === 'c' ? '//' : family === 'hash' ? '#' : family === 'sql' ? '--' : family === 'generic' ? null : null;
  // json5 / jsonc 的 family 已经是 'c',由第一个分支覆盖,不单列。
  const blockComment = family === 'c' || family === 'css' || family === 'sql'
    ? (['/*', '*/'] as const)
    : family === 'markup'
      ? (['<!--', '-->'] as const)
      : null;

  // 行注释起始符:generic 家族同时认 `//` 与 `#`,尽量别把注释染成正文。
  // 与 lineComment / blockComment 一样是循环不变量,必须在循环外算 —— 放进循环
  // 等于每个字符都新建一个数组。
  const lineStarts = lineComment
    ? [lineComment]
    : family === 'generic'
      ? ['//', '#']
      : [];

  let i = 0;
  while (i < source.length) {
    // token 预算用尽:剩余源码整段并入 plain 收尾(仍然无损)。
    // 计数要带上还没 flush 的 plain,否则一轮里 flush() + push() 会连推两个 token,
    // 上界变成 maxTokens + 2。带上之后每轮"有效 token 数"最多 +1,收口后 out 至多
    // 为 maxTokens + 1(那个 +1 是收尾的 plain)。
    if (out.length + (plain ? 1 : 0) >= CODE_HIGHLIGHT_LIMITS.maxTokens) {
      plain += source.slice(i);
      break;
    }

    // 前缀判定一律用 source.startsWith(mark, i),不要先 source.slice(i) 再判。
    // 澄清一个容易想当然的点:slice 在 V8 里返回 SlicedString(O(1) 引用,不拷贝
    // 字符),所以它**不是** O(n²) —— 实测 20k 字符 0.6ms vs 0.3ms、1MB 3.4ms vs
    // 1.3ms,只是 2~3x 常数因子加一堆短命对象。之所以还是照改:同等正确、更快、
    // 更少垃圾,而这段是同步跑在渲染路径上。真正的规模保护是上面的 token 预算。
    // 块注释
    if (blockComment && source.startsWith(blockComment[0], i)) {
      const end = source.indexOf(blockComment[1], i + blockComment[0].length);
      const stop = end === -1 ? source.length : end + blockComment[1].length;
      push(source.slice(i, stop), 'comment');
      i = stop;
      continue;
    }
    // 行注释
    const hitLine = lineStarts.some((mark) => source.startsWith(mark, i));
    if (hitLine) {
      const nl = source.indexOf('\n', i);
      const stop = nl === -1 ? source.length : nl;
      push(source.slice(i, stop), 'comment');
      i = stop;
      continue;
    }
    // 字符串(未闭合时吃到行尾,避免整块串味)
    const ch = source[i];
    if (ch === '"' || ch === '\'' || ch === '`') {
      let j = i + 1;
      let closed = false;
      while (j < source.length) {
        const cj = source[j];
        if (cj === '\\') { j += 2; continue; }
        if (cj === ch) { closed = true; j += 1; break; }
        if (cj === '\n' && ch !== '`') break;
        j += 1;
      }
      const stop = closed ? j : Math.min(j, source.length);
      // 带引号的 key(JSON / JS 对象字面量)算属性名,不算普通字符串 —— 与 hljs
      // 把 JSON key 归到 attr 一致,否则 JSON 里键值同色、读不出结构。
      push(source.slice(i, stop), closed && isPropertyKey(source, stop) ? 'property' : 'string');
      i = stop;
      continue;
    }
    // 数字
    if (DIGIT.test(ch)) {
      let j = i;
      while (j < source.length && /[0-9a-fA-FxXoObB_.]/.test(source[j])) j += 1;
      push(source.slice(i, j), 'number');
      i = j;
      continue;
    }
    // 标识符 → 关键字 / 函数名 / 普通
    if (IDENT_START.test(ch)) {
      let j = i + 1;
      while (j < source.length && IDENT_BODY.test(source[j])) j += 1;
      const word = source.slice(i, j);
      const probe = spec.caseSensitive === false ? word.toLowerCase() : word;
      if (keywords.has(probe)) {
        push(word, 'keyword');
      } else if (isCallSite(source, j)) {
        push(word, 'function');
      } else if (isPropertyKey(source, j)) {
        push(word, 'property');
      } else {
        plain += word;
      }
      i = j;
      continue;
    }
    plain += ch;
    i += 1;
  }
  flush();
  return out;
}

/** 标识符后跳过空格是否紧跟 `(` —— 粗略的函数名判定。 */
function isCallSite(source: string, from: number): boolean {
  let k = from;
  while (k < source.length && (source[k] === ' ' || source[k] === '\t')) k += 1;
  return source[k] === '(';
}

/**
 * 标识符 / 字符串后跳过空格是否紧跟单个 `:` —— 粗略的属性名判定。
 *
 * 排除 `::`(C++ / Rust 作用域符)。三元表达式的 `a ? b : c` 会把 b 误判成属性名,
 * 这是刻意接受的误差:代价只是多一处蓝色,而正确覆盖对象/YAML/JSON 属性名的收益
 * 远大于此(要真正区分得做表达式级解析,那是 hljs 的量级)。
 */
function isPropertyKey(source: string, from: number): boolean {
  let k = from;
  while (k < source.length && (source[k] === ' ' || source[k] === '\t')) k += 1;
  return source[k] === ':' && source[k + 1] !== ':';
}