rtl-text

1import { atom, read, update } from 'claude-code'
2import type { Register } from 'claude-code'
3
4import { markRtlMarkdown, markRtlPlain } from './bidi'
5
6const isOn = atom({ plugin: 'rtl-text', key: 'isOn' } as const, true)
7
8export const register: Register = on => {
9  on('session.start', async ($, e, next) => {
10    await $.command.register({
11      name: 'rtl',
12      description: 'Turn right-to-left display of Persian, Arabic and Hebrew on or off',
13      argumentHint: '[on|off]',
14      immediate: true,
15    })
16
17    const saved = await $.store.get('isOn')
18
19    if (typeof saved === 'boolean') {
20      await update($, isOn, () => saved)
21    }
22
23    return next(e)
24  })
25
26  on('command.run', { command: 'rtl' }, async ($, e) => {
27    const arg = e.args.trim().toLowerCase()
28    const want = arg === 'on' ? true : arg === 'off' ? false : !(await read($, isOn))
29
30    await update($, isOn, () => want)
31    await $.store.set('isOn', want)
32
33    return { text: want ? 'RTL display is on.' : 'RTL display is off.' }
34  })
35
36  // The terminal draws cells in place, so an isolate there helps only where
37  // the terminal itself runs the bidi algorithm; it is left as the engine has it.
38  on('ui.render', { component: 'AssistantMessage' }, async ($, e, next) => {
39    if (e.surface === 'terminal' || !(await read($, isOn))) {
40      return next(e)
41    }
42
43    const text = markRtlMarkdown(e.props.text)
44
45    return text === e.props.text ? next(e) : next({ ...e, props: { ...e.props, text } })
46  })
47
48  on('ui.render', { component: 'UserMessage' }, async ($, e, next) => {
49    if (e.surface === 'terminal' || !(await read($, isOn))) {
50      return next(e)
51    }
52
53    const text = markRtlPlain(e.props.text)
54
55    return text === e.props.text ? next(e) : next({ ...e, props: { ...e.props, text } })
56  })
57}
58

1// Marks right-to-left lines of markdown with a Unicode isolate (RLI, U+2067).
2// A renderer that lays every block out left-to-right then still orders the
3// words, punctuation and embedded English of a Persian, Arabic or Hebrew
4// paragraph the way a reader expects. What the text says is unchanged.
5
6import type { Direction } from '../types'
7
8const LRI = '\u2066'
9const RLI = '\u2067'
10const PDI = '\u2069'
11const RLM = '\u200F'
12const LRM = '\u200E'
13
14const RTL_LETTER =
15  /[\u05D0-\u05F2\u0620-\u064A\u066E-\u06D5\u06EE\u06EF\u06FA-\u06FF\u0700-\u08FF\uFB1D-\uFDFF\uFE70-\uFEFC]/
16const LTR_LETTER = /[A-Za-z\u00C0-\u024F\u0370-\u03FF\u0400-\u04FF]/
17
18// A line that already opens with an explicit bidi mark is left as written.
19const BIDI_MARK = /^[\u200E\u200F\u061C\u202A-\u202E\u2066-\u2069]/
20
21// Arabic-script punctuation and digits turn up only in RTL prose.
22const RTL_SIGN = /[\u060C\u061B\u061F\u0660-\u0669\u06F0-\u06F9]/
23
24// What a reader does not read as words of the sentence: code spans, link
25// targets, bare URLs and HTML tags.
26const NOT_PROSE = /`[^`]*`|\]\([^)]*\)|https?:\/\/\S+|<[^>]+>/g
27
28// A colon or Arabic comma right after an English word or a digit joins it to
29// the English after it ("PR ۱: merge شد" draws as "شد PR ۱: merge"); an RLM
30// after it keeps them apart. It goes before a closing ** or _ so emphasis
31// still closes.
32const JOINING_PUNCTUATION =
33  /(?<=[A-Za-z0-9\u00C0-\u024F\u0370-\u03FF\u0400-\u04FF\u0660-\u0669\u06F0-\u06F9])([:\u060C\u061B])(?=(?:\*{1,2}|_{1,2})?\s)/g
34// A number a reader takes as one left-to-right unit, which the bidi
35// algorithm splits in RTL text: a signed number ("-5" draws as "5-") and a
36// phone number in spaced groups ("+98 912 123 4567" draws reversed). Each
37// goes in a left-to-right isolate.
38const NUMBER_UNIT =
39  /(?<=^|[\s(])(?:\+[0-9\u0660-\u0669\u06F0-\u06F9]{1,4}(?:[ -][0-9\u0660-\u0669\u06F0-\u06F9]{1,5})+|[0-9\u0660-\u0669\u06F0-\u06F9]{2,}(?: [0-9\u0660-\u0669\u06F0-\u06F9]{2,}){2,}|[-+\u2212][0-9\u0660-\u0669\u06F0-\u06F9]+(?:[.,\u066B][0-9\u0660-\u0669\u06F0-\u06F9]+)*%?)/g
40
41// + and # that end an English word or a number ("C++", "C#", "18+") are
42// neutral, so in RTL text they jump to the word's other side ("++C"); an LRM
43// after them keeps them with it. It goes before a closing ** or _ too.
44const TRAILING_SYMBOLS =
45  /(?<=[A-Za-z0-9])([+#]+)(?=[\s.,;:!?)\]*_'"\u00AB\u00BB\u060C\u061B\u061F]|$)/g
46
47// What a fix never reaches into: code spans, link targets and URLs.
48const PROTECTED = /(`[^`]*`|\]\([^)]*\)|https?:\/\/\S+)/
49
50const FENCE = /^[ \t]*(`{3,}|~{3,})/
51const QUOTE = /^[ \t]*>[ \t]?/
52const LIST_ITEM = /^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]+(?:\[[ xX]\][ \t]+)?/
53const HEADING = /^[ \t]*#{1,6}[ \t]+/
54const INDENT = /^[ \t]*/
55const TABLE_ROW = /^[ \t]*\|/
56const TABLE_CELL = /(\|[ \t]*)((?:\\\||`[^`]*`|[^|`])+)/g
57
58function directionOf(ch: string): Direction | undefined {
59  if (RTL_LETTER.test(ch)) {
60    return 'rtl'
61  }
62
63  return LTR_LETTER.test(ch) ? 'ltr' : undefined
64}
65
66function isDirection(dir: Direction | undefined): dir is Direction {
67  return dir !== undefined
68}
69
70function directionsOf(text: string): Direction[] {
71  return [...text].map(directionOf).filter(isDirection)
72}
73
74/**
75 * Whether a line reads right-to-left. Persian and Arabic sentences often open
76 * or close with an English word ("PR ۱: merge شد"), so once a line has RTL
77 * letters any one of these is enough: its first or last letter is RTL, at
78 * least half its words are RTL, or it uses Arabic-script digits or punctuation.
79 */
80export function isRtl(text: string): boolean {
81  const prose = text.replace(NOT_PROSE, ' ')
82  const letters = directionsOf(prose)
83
84  if (!letters.includes('rtl')) {
85    return false
86  }
87
88  const words = prose
89    .split(/\s+/)
90    .map(word => directionsOf(word)[0])
91    .filter(isDirection)
92  const rtlWords = words.filter(dir => dir === 'rtl').length
93
94  return (
95    letters[0] === 'rtl' ||
96    letters.at(-1) === 'rtl' ||
97    rtlWords * 2 >= words.length ||
98    RTL_SIGN.test(prose)
99  )
100}
101
102/**
103 * Splits a markdown line into its block markers (indent, `>`, list bullet,
104 * checkbox, `#`) and the text after them, where the isolate goes.
105 */
106function splitPrefix(line: string): [string, string] {
107  let at = 0
108
109  for (;;) {
110    const rest = line.slice(at)
111    const marker = QUOTE.exec(rest) ?? LIST_ITEM.exec(rest)
112
113    if (marker) {
114      at += marker[0].length
115      continue
116    }
117
118    at += (HEADING.exec(rest) ?? INDENT.exec(rest) ?? [''])[0].length
119
120    return [line.slice(0, at), line.slice(at)]
121  }
122}
123
124/**
125 * Keeps English and number runs where a reader expects them: an RLM after a
126 * colon or Arabic comma that ends an English word or a number, an LRM after
127 * "C++"-style symbols, and signed or phone numbers in a left-to-right
128 * isolate. Protected parts (code spans, link targets, URLs) land at odd
129 * indexes of the split and are left alone.
130 */
131function separateRuns(text: string): string {
132  return text
133    .split(PROTECTED)
134    .map((part, at) =>
135      at % 2 === 1
136        ? part
137        : part
138            .replace(JOINING_PUNCTUATION, `$1${RLM}`)
139            .replace(TRAILING_SYMBOLS, `$1${LRM}`)
140            .replace(NUMBER_UNIT, number => LRI + number + PDI),
141    )
142    .join('')
143}
144
145function mark(text: string, isClosed: boolean): string {
146  if (BIDI_MARK.test(text) || !isRtl(text)) {
147    return text
148  }
149
150  const body = text.trimEnd()
151  const tail = text.slice(body.length)
152
153  return RLI + separateRuns(body) + (isClosed ? PDI : '') + tail
154}
155
156function markLines(text: string, isClosed: boolean): string {
157  let fence: string | undefined
158
159  return text
160    .split('\n')
161    .map(line => {
162      const fenced = FENCE.exec(line)?.[1]
163
164      if (fence !== undefined) {
165        const isClose =
166          fenced !== undefined &&
167          fenced[0] === fence[0] &&
168          fenced.length >= fence.length &&
169          line.trim() === fenced
170
171        if (isClose) {
172          fence = undefined
173        }
174
175        return line
176      }
177
178      if (fenced !== undefined) {
179        fence = fenced
180
181        return line
182      }
183
184      if (TABLE_ROW.test(line)) {
185        return line.replace(TABLE_CELL, (_, open: string, cell: string) => open + mark(cell, true))
186      }
187
188      const [prefix, rest] = splitPrefix(line)
189
190      return prefix + mark(rest, isClosed)
191    })
192    .join('\n')
193}
194
195/**
196 * For a reply's markdown: each RTL line opens an isolate the block closes,
197 * so a paragraph written over several lines nests and still reads in order.
198 */
199export function markRtlMarkdown(text: string): string {
200  return markLines(text, false)
201}
202
203/**
204 * For text drawn line by line (a prompt as typed): each RTL line is its own
205 * closed isolate.
206 */
207export function markRtlPlain(text: string): string {
208  return markLines(text, true)
209}
210

1export type Direction = 'rtl' | 'ltr'
2
3declare module 'claude-code' {
4  interface PluginState {
5    'rtl-text': { isOn: boolean }
6  }
7}
8