calc

1import type { EngineInterface, Register } from 'claude-code'
2
3import { STRINGS } from './strings'
4
5// cockpit: the language set in /cockpit (English when the hub is not installed)
6const LANG = { plugin: 'cockpit', key: 'lang' } as const
7
8const strings = async ($: EngineInterface) => STRINGS[(await $.state.get(LANG)).value ?? 'en']
9
10// The typed text, else the mouse selection, else ''.
11const input = async ($: EngineInterface, args: string): Promise<string> => {
12  if (args.trim() !== '') {
13    return args.trim()
14  }
15
16  try {
17    return ((await $.ui.selection())?.text ?? '').trim()
18  } catch {
19    return ''
20  }
21}
22
23type Token = { text: string; at: number; value?: number }
24type Failure = { kind: 'character' | 'unexpected' | 'end' | 'paren' | 'zero' | 'invalid'; found: string; at: number }
25
26const fail = (kind: Failure['kind'], found = '', at = 0): never => {
27  throw { kind, found, at } satisfies Failure
28}
29
30// Numbers, operators and parentheses; `at` is the 1-based position in the text.
31const tokenize = (text: string): Token[] => {
32  const tokens: Token[] = []
33  const number = /\d+\.?\d*|\.\d+/y
34  let at = 0
35
36  while (at < text.length) {
37    const char = text.charAt(at)
38    number.lastIndex = at
39    const hit = number.exec(text)
40
41    if (/\s/.test(char)) {
42      at += 1
43    } else if (hit !== null) {
44      tokens.push({ text: hit[0], at: at + 1, value: Number(hit[0]) })
45      at = number.lastIndex
46    } else if ('+-*/%^()'.includes(char)) {
47      tokens.push({ text: char, at: at + 1 })
48      at += 1
49    } else {
50      fail('character', char, at + 1)
51    }
52  }
53
54  return tokens
55}
56
57// Recursive descent: expr > term > unary > power > primary. `^` binds tighter than a unary minus and is right-associative.
58const evaluate = (text: string): number => {
59  const tokens = tokenize(text)
60  let at = 0
61  const isOp = (value: string) => tokens[at]?.value === undefined && tokens[at]?.text === value
62  const take = (value: string) => {
63    if (!isOp(value)) {
64      return false
65    }
66
67    at += 1
68
69    return true
70  }
71  const primary = (): number => {
72    const token = tokens[at]
73
74    if (token === undefined) {
75      return fail('end')
76    }
77
78    if (token.value !== undefined) {
79      at += 1
80
81      return token.value
82    }
83
84    if (token.text !== '(') {
85      return fail('unexpected', token.text, token.at)
86    }
87
88    at += 1
89    const inner = expr()
90
91    if (!take(')')) {
92      const next = tokens[at]
93
94      return next === undefined ? fail('paren', '(', token.at) : fail('unexpected', next.text, next.at)
95    }
96
97    return inner
98  }
99  const power = (): number => {
100    const base = primary()
101
102    return take('^') ? base ** unary() : base
103  }
104  const unary = (): number => {
105    if (take('-')) {
106      return -unary()
107    }
108
109    return take('+') ? unary() : power()
110  }
111  const term = (): number => {
112    let value = unary()
113
114    for (;;) {
115      const op = ['*', '/', '%'].find(take)
116
117      if (op === undefined) {
118        return value
119      }
120
121      const right = unary()
122
123      if (op !== '*' && right === 0) {
124        fail('zero')
125      }
126
127      value = op === '*' ? value * right : op === '/' ? value / right : value % right
128    }
129  }
130  const expr = (): number => {
131    let value = term()
132
133    for (;;) {
134      if (take('+')) {
135        value += term()
136      } else if (take('-')) {
137        value -= term()
138      } else {
139        return value
140      }
141    }
142  }
143  const value = expr()
144  const left = tokens[at]
145
146  if (left !== undefined) {
147    fail('unexpected', left.text, left.at)
148  }
149
150  return Number.isFinite(value) ? value : fail('invalid')
151}
152
153// The result as text, or the message for what is wrong with the expression.
154const calculate = (text: string, s: (typeof STRINGS)['en']): { result?: string; error?: string } => {
155  try {
156    return { result: String(Number(evaluate(text).toPrecision(12))) }
157  } catch (thrown) {
158    const failure = thrown as Failure
159
160    switch (failure.kind) {
161      case 'character':
162        return { error: s.character(failure.found, failure.at) }
163      case 'unexpected':
164        return { error: s.unexpected(failure.found, failure.at) }
165      case 'paren':
166        return { error: s.paren(failure.at) }
167      case 'zero':
168        return { error: s.zero }
169      case 'invalid':
170        return { error: s.invalid }
171      default:
172        return { error: s.end }
173    }
174  }
175}
176
177export const register: Register = on => {
178  on('session.start', async ($, e, next) => {
179    const s = await strings($)
180    await $.command.register({ name: 'calc', description: s.command, argumentHint: s.hint })
181
182    return next(e)
183  })
184
185  on('command.run', { command: 'calc' }, async ($, e) => {
186    const s = await strings($)
187    const text = await input($, e.args)
188
189    if (text === '') {
190      return { text: s.usage }
191    }
192
193    const { result, error } = calculate(text, s)
194
195    if (result === undefined) {
196      return { text: error }
197    }
198
199    await $.ui.copy({ text: result })
200
201    return { text: `${text} = ${result}\n${s.copied}` }
202  })
203}
204

1const en = {
2  command: 'Calculate an expression with + - * / % ^, parentheses and decimals; uses the mouse selection when none is given',
3  hint: '<expression>',
4  usage: 'Usage: /calc <expression>  e.g. /calc (2 + 3) * 4 ^ 2 / 8',
5  copied: 'Result copied to the clipboard.',
6  character: (found: string, at: number) => `Unexpected character "${found}" at position ${at}.`,
7  unexpected: (found: string, at: number) => `Unexpected "${found}" at position ${at}.`,
8  end: 'The expression ends too soon: something is missing after the last operator.',
9  paren: (at: number) => `The "(" at position ${at} is never closed.`,
10  zero: 'Division by zero.',
11  invalid: 'The result is not a finite number.',
12}
13
14type Strings = typeof en
15
16const pt: Strings = {
17  command: 'Calcula uma expressão com + - * / % ^, parênteses e decimais; usa a seleção do mouse quando não há texto',
18  hint: '<expressão>',
19  usage: 'Uso: /calc <expressão>  ex.: /calc (2 + 3) * 4 ^ 2 / 8',
20  copied: 'Resultado copiado para a área de transferência.',
21  character: (found, at) => `Caractere inesperado "${found}" na posição ${at}.`,
22  unexpected: (found, at) => `"${found}" inesperado na posição ${at}.`,
23  end: 'A expressão termina cedo demais: falta algo depois do último operador.',
24  paren: at => `O "(" da posição ${at} nunca é fechado.`,
25  zero: 'Divisão por zero.',
26  invalid: 'O resultado não é um número finito.',
27}
28
29const es: Strings = {
30  command: 'Calcula una expresión con + - * / % ^, paréntesis y decimales; usa la selección del ratón cuando no hay texto',
31  hint: '<expresión>',
32  usage: 'Uso: /calc <expresión>  p. ej.: /calc (2 + 3) * 4 ^ 2 / 8',
33  copied: 'Resultado copiado al portapapeles.',
34  character: (found, at) => `Carácter inesperado "${found}" en la posición ${at}.`,
35  unexpected: (found, at) => `"${found}" inesperado en la posición ${at}.`,
36  end: 'La expresión termina demasiado pronto: falta algo después del último operador.',
37  paren: at => `El "(" de la posición ${at} nunca se cierra.`,
38  zero: 'División por cero.',
39  invalid: 'El resultado no es un número finito.',
40}
41
42export const STRINGS = { en, pt, es }
43