statusline

1import type { EngineInterface, Register } from 'claude-code'
2
3import { branchOf, effortLevel, plainParts, SEPARATOR, statuslineInput } from './line'
4import type { Context, Engine, Facts } from './line'
5
6// 바깥에서 바뀌는 것(다른 칸의 git checkout, 셸 cd)을 알아채는 간격. 파일 하나와 경로 하나를 읽는 값싼 일이다.
7const POLL_MS = 150
8
9// 모듈 변수는 다시 실릴 때 처음으로 돌아간다 — session.start 가 다시 채운다.
10const io = {
11  // kasaterm: kasaterm 상태줄을 바로 덧그린다 · plain: kasaterm 밖이라 같은 줄을 직접 그린다 · off: 사람이 고른 상태줄이 있는 칸
12  mode: 'off' as 'kasaterm' | 'plain' | 'off',
13  base: '',
14  pane: '',
15  engineFile: '',
16  facts: {} as Facts,
17  cwd: '',
18  head: '',
19  headPath: '',
20  // kasaterm 밖에서 그릴 값 — 엔진 입력이 없으니 이벤트와 설정으로만 안다.
21  plain: { model: '', window: 0, percent: undefined as number | undefined, effort: undefined as string | undefined, icon: 'nerd-font' },
22  last: '',
23  running: false,
24  again: false,
25}
26
27async function headPath($: EngineInterface, cwd: string): Promise<string> {
28  let dir = cwd.replace(/\/+$/, '') || '/'
29  for (let depth = 0; depth < 64; depth++) {
30    const dot = `${dir === '/' ? '' : dir}/.git`
31    try {
32      const stat = await $.fs.stat(dot)
33      if (stat.kind === 'dir') return `${dot}/HEAD`
34      if (stat.kind === 'file') {
35        const gitdir = /^gitdir:\s*(.+)$/m.exec(await $.fs.read(dot))?.[1]?.trim()
36        if (gitdir) return `${gitdir.startsWith('/') ? gitdir : `${dir}/${gitdir}`}/HEAD`
37      }
38    } catch {
39      // 없으면 위로.
40    }
41    if (dir === '/') return ''
42    dir = dir.replace(/\/[^/]+$/, '') || '/'
43  }
44  return ''
45}
46
47async function readHead($: EngineInterface): Promise<string> {
48  if (!io.headPath) return ''
49  try {
50    return await $.fs.read(io.headPath)
51  } catch {
52    return ''
53  }
54}
55
56function changed($: EngineInterface) {
57  if (io.mode === 'kasaterm') void redraw($)
58  else if (io.mode === 'plain') $.ui.invalidate('ui.render')
59}
60
61// 경로·브랜치는 이벤트가 없는 바깥 손에도 바뀐다 — 짧게 다시 읽어 달라졌을 때만 다시 그린다.
62// 도구·명령 뒤에도 부르므로 던지지 않는다(던지면 그 도구의 결과가 깨진다).
63async function poll($: EngineInterface) {
64  try {
65    const cwd = await $.session.cwd()
66    let moved = false
67    if (cwd !== io.cwd) {
68      io.cwd = cwd
69      io.facts.cwd = { value: cwd, at: Date.now() }
70      io.headPath = await headPath($, cwd)
71      moved = true
72    }
73    const head = await readHead($)
74    if (head !== io.head) {
75      io.head = head
76      moved = true
77    }
78    if (moved) changed($)
79  } catch {
80    // 다음 박자에 다시 읽는다.
81  }
82}
83
84async function readEngine($: EngineInterface): Promise<Engine | null> {
85  try {
86    return JSON.parse(await $.fs.read(io.engineFile)) as Engine
87  } catch {
88    return null
89  }
90}
91
92// kasaterm 칸 — 엔진의 마지막 입력에 막 안 사실을 얹어 kasaterm 상태줄 명령으로 같은 줄을 짓고 앱에 보낸다.
93// 앱은 엔진이 자기 줄을 다시 그릴 때까지만 이 줄을 덧그린다. 짓는 동안 온 바뀜은 끝난 뒤 한 번 더 짓는다.
94async function redraw($: EngineInterface) {
95  if (io.running) {
96    io.again = true
97    return
98  }
99  io.running = true
100  try {
101    do {
102      io.again = false
103      const engine = await readEngine($)
104      if (!engine) return
105      const session = await $.session.id()
106      const input = statuslineInput(engine, io.facts, session)
107      if (!input) continue
108      const run = await $.process.run(['kasaterm-cli', 'statusline'], {
109        stdin: JSON.stringify(input),
110        env: { KASATERM_STATUSLINE_DRAW_ONLY: '1' },
111        timeoutMs: 3000,
112      })
113      const line = run.stdout.replace(/\n+$/, '')
114      if (run.exitCode !== 0 || !line || line === io.last) continue
115      // 짓는 사이 엔진이 새 입력으로 자기 줄을 그렸다 — 옛 입력으로 지은 줄을 보내면 앱이 그 새 줄을 다음 엔진
116      // 박자까지 덮는다. 새 입력으로 다시 짓는다.
117      if ((await readEngine($))?.at_ms !== engine.at_ms) {
118        io.again = true
119        continue
120      }
121      io.last = line
122      await $.http.fetch(`${io.base}/claude-mod/event`, {
123        method: 'POST',
124        headers: { 'content-type': 'application/json' },
125        body: JSON.stringify({ v: 1, surface: io.pane, session, events: [{ kind: 'status', line }] }),
126      })
127    } while (io.again)
128  } catch {
129    // 앱이나 명령에 못 닿으면 엔진 상태줄이 혼자 그린다.
130  } finally {
131    io.running = false
132  }
133}
134
135function learnContext($: EngineInterface, context: Context) {
136  io.facts.context = { value: { percent: context.percent, window: context.window, tokens: context.tokens }, at: Date.now() }
137  io.plain.window = context.window
138  io.plain.percent = context.percent
139  changed($)
140}
141
142function learnModel($: EngineInterface, model: string) {
143  if (!model || model === io.facts.model?.value) return
144  io.facts.model = { value: model, at: Date.now() }
145  io.plain.model = model
146  changed($)
147}
148
149function learnEffort($: EngineInterface, effort: string) {
150  if (io.facts.effort?.value === effort) return
151  io.facts.effort = { value: effort, at: Date.now() }
152  io.plain.effort = effort || undefined
153  changed($)
154}
155
156async function boot($: EngineInterface) {
157  const pane = (await $.env.get('KASATERM_PANE_ID')) ?? ''
158  const port = (await $.env.get('KASASPACE_MCP_PORT')) ?? ''
159  const settings = await $.settings.read()
160  const command = String((settings.statusLine as { command?: unknown } | undefined)?.command ?? '')
161  if (pane) {
162    // kasaterm 칸이라도 사람이 자기 상태줄을 골랐으면(「상태줄 직접 설정」) 손대지 않는다.
163    if (!command.includes('kasaterm-cli statusline') || !/^\d+$/.test(port)) return
164    const tmp = ((await $.env.get('TMPDIR')) || '/tmp').replace(/\/+$/, '')
165    io.mode = 'kasaterm'
166    io.base = `http://127.0.0.1:${port}`
167    io.pane = pane
168    io.engineFile = `${tmp}/kasaterm-statusline/${pane.replace(/^%/, '')}-engine.json`
169  } else {
170    io.mode = 'plain'
171    io.plain.effort = effortLevel((await $.env.get('CLAUDE_EFFORT')) ?? '') ?? effortLevel(settings.effortLevel)
172    try {
173      const home = (await $.env.get('HOME')) ?? ''
174      const config = JSON.parse(await $.fs.read(`${home}/.claude/statusline-config.json`)) as { icon_set?: string }
175      if (config.icon_set) io.plain.icon = config.icon_set
176    } catch {
177      // 설정이 없으면 Nerd Font 글리프.
178    }
179  }
180  io.plain.model = await $.session.model()
181  const usage = await $.session.usage()
182  io.plain.window = usage.context.window
183  io.plain.percent = usage.context.percent
184  await poll($)
185  $.clock.every(POLL_MS, () => void poll($))
186}
187
188export const register: Register = on => {
189  on('session.start', async ($, e, next) => {
190    const result = await next(e)
191    await boot($)
192    return result
193  })
194
195  on('classic.PostModelSwitch', async ($, e, next) => {
196    const result = await next(e)
197    if (io.mode !== 'off') {
198      learnModel($, e.to_model)
199      learnContext($, (await $.session.usage()).context)
200    }
201    return result
202  }).catch(($, e, next) => next(e))
203
204  // /effort·/model·/cd 는 명령이 끝나야 값이 바뀐다. /effort 는 다른 이벤트가 없어 인자로 안다.
205  on('command.run', async ($, e, next) => {
206    const result = await next(e)
207    if (io.mode === 'off') return result
208    if (e.command === 'effort') {
209      const level = effortLevel(e.args.trim().split(/\s+/)[0])
210      if (level) learnEffort($, level)
211    }
212    try {
213      learnModel($, await $.session.model())
214    } catch {
215      // 모델은 PostModelSwitch 가 다시 알린다.
216    }
217    await poll($)
218    return result
219  })
220
221  // 요청마다 엔진이 실제로 쓴 effort — 모델 고르기 창에서 바꾼 것도 첫 요청에 바로잡힌다.
222  on('turn.step', async function* ($, e, next) {
223    if (io.mode !== 'off' && e.agentId === undefined) {
224      const level = effortLevel(e.effort)
225      if (level) learnEffort($, level)
226    }
227    return yield* next(e)
228  })
229
230  on('session.measure', async ($, e, next) => {
231    if (io.mode !== 'off') learnContext($, e.context)
232    return next(e)
233  })
234
235  on('classic.CwdChanged', async ($, e, next) => {
236    const result = await next(e)
237    if (io.mode !== 'off') await poll($)
238    return result
239  }).catch(($, e, next) => next(e))
240
241  // git checkout·cd 는 대개 Bash 로 온다 — 끝나는 순간 다시 읽는다.
242  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
243    const result = await next(e)
244    if (io.mode !== 'off') await poll($)
245    return result
246  })
247
248  // kasaterm 밖: 상태줄 자리가 비어 있으니(엔진은 명령 상태줄만 그린다) 프롬프트 아래 모드 자리에 같은 줄을 그린다.
249  // 폭을 줄 전체로 잡으면 엔진이 힌트 줄 아래 제 줄로 내린다.
250  on('ui.render', { component: 'SessionMode' }, ($, e, next) => {
251    if (io.mode !== 'plain' || !io.plain.model) return next(e)
252    const { Box, Text } = $.ui.resolve(e)
253    const parts = plainParts({ ...io.plain, branch: branchOf(io.head), cwd: io.cwd }, io.plain.icon)
254    const columns = e.viewport?.columns ?? 80
255    return (
256      <Box flexDirection="row" width={Math.max(20, columns - 4)}>
257        {parts.flatMap((part, index) => [
258          ...(index > 0
259            ? [
260                <Text key={`sep-${index}`} color={SEPARATOR.color} dimColor>
261                  {` ${SEPARATOR.text} `}
262                </Text>,
263              ]
264            : []),
265          ...part.map((seg, at) => (
266            <Text key={`seg-${index}-${at}`} color={seg.color} bold={seg.bold} dimColor={seg.dim}>
267              {seg.text}
268            </Text>
269          )),
270        ])}
271        <Box flexGrow={1} />
272        <Text dimColor>{e.props.modes.join(' & ')}</Text>
273      </Box>
274    )
275  })
276}
277

1export const LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'] as const
2
3export type Context = { percent?: number; window: number; tokens?: number }
4export type Fact<T> = { value: T; at: number }
5/** 엔진에 묻기 전에 이벤트로 먼저 안 값. 시각은 안 때(ms)다. effort 의 빈 글자는 「effort 없음」이다. */
6export type Facts = { model?: Fact<string>; effort?: Fact<string>; cwd?: Fact<string>; context?: Fact<Context> }
7
8/** kasaterm 상태줄 명령이 마지막으로 받은 엔진 입력(`<칸>-engine.json`). */
9export type Engine = {
10  at_ms?: number
11  session_id?: string
12  cwd?: string
13  model?: { id?: string; display_name?: string }
14  effort?: { level?: string }
15  context_window?: { used_percentage?: number; context_window_size?: number; total_input_tokens?: number }
16}
17
18export type Seg = { text: string; color?: string; bold?: boolean; dim?: boolean }
19
20/** 엔진이 상태줄에 주는 표시명(「Opus 5.5」)을 모델 id 로 짓는다 — 모델을 막 바꿔 엔진 입력에 아직 없을 때만 쓴다. */
21export function displayName(id: string): string {
22  const bare = id.replace(/\[[^\]]*\]$/, '')
23  const [vendor, family = '', ...rest] = bare.split('-')
24  const version = rest.filter(p => /^\d{1,2}$/.test(p))
25  if (vendor !== 'claude' || !/^[a-z]+$/.test(family) || version.length === 0) return bare
26  return `${family.charAt(0).toUpperCase()}${family.slice(1)} ${version.join('.')}`
27}
28
29export function effortLevel(effort: unknown): string | undefined {
30  return typeof effort === 'string' && (LEVELS as readonly string[]).includes(effort) ? effort : undefined
31}
32
33/** `.git/HEAD` 의 글자 → 상태줄의 브랜치 이름. 떨어진 HEAD 는 `HEAD`(kasaterm 상태줄과 같다). */
34export function branchOf(head: string): string {
35  const text = head.trim()
36  if (!text) return ''
37  if (!text.startsWith('ref:')) return 'HEAD'
38  const name = text.slice(4).trim()
39  return name.startsWith('refs/heads/') ? name.slice('refs/heads/'.length) : name
40}
41
42/**
43 * kasaterm 상태줄 명령에 넣을 입력 — 엔진이 마지막으로 넘긴 입력 위에 그보다 늦게 안 사실만 얹는다.
44 * 엔진은 1초 남짓마다 다시 넘기므로, 이벤트로 잘못 안 값이 있어도 그 안에 엔진 값이 이긴다.
45 *
46 * 모델을 막 바꿨고 그 뒤의 effort 를 모르면 null — 엔진은 모델을 바꾸면 effort 를 그 모델의 기본으로 되돌리는데
47 * (Opus xhigh → Sonnet medium), 옛 effort 를 얹으면 틀린 줄이 엔진 줄과 번갈아 1초 남짓 보였다(2026-10-07 실측).
48 * 그때는 엔진 줄을 기다린다(엔진은 모델을 바꾼 뒤 0.1~0.2초 안에 다시 그린다).
49 */
50export function statuslineInput(engine: Engine, facts: Facts, session: string): Record<string, unknown> | null {
51  const at = engine.at_ms ?? 0
52  const fresh = <T>(fact?: Fact<T>) => (fact && fact.at > at ? fact.value : undefined)
53  const switched = fresh(facts.model) !== undefined && facts.model?.value !== engine.model?.id
54  if (switched && !(facts.effort && facts.model && facts.effort.at >= facts.model.at)) return null
55  const input: Record<string, unknown> = { session_id: session || engine.session_id, cwd: fresh(facts.cwd) ?? engine.cwd }
56  const model = fresh(facts.model)
57  input.model =
58    model === undefined
59      ? engine.model
60      : { id: model, display_name: model === engine.model?.id ? engine.model?.display_name : displayName(model) }
61  const effort = fresh(facts.effort)
62  if (effort === undefined) {
63    if (engine.effort) input.effort = engine.effort
64  } else if (effort) {
65    input.effort = { level: effort }
66  }
67  const context = fresh(facts.context)
68  input.context_window =
69    context === undefined
70      ? engine.context_window
71      : { used_percentage: context.percent ?? 0, context_window_size: context.window, total_input_tokens: context.tokens ?? 0 }
72  return input
73}
74
75// kasaterm 상태줄(`kasaterm-cli statusline`)의 색·글리프 — kasaterm 밖 claude 에서도 같은 줄로 보이게.
76const C_MODEL = '#7aa2f7'
77const C_GIT = '#73daca'
78const C_DIR = '#bb9af7'
79const C_CTX = '#ff9e64'
80const C_DANGER = '#f7768e'
81const C_SEP = '#565f89'
82const C_EFFORT: Record<string, string> = { low: '#565f89', medium: '#7aa2f7', high: '#e0af68', xhigh: '#f7768e', max: '#bb9af7' }
83type Icons = { model: string; git: string; folder: string; effort: string }
84const NERD: Icons = { model: '\uf233', git: '\ue0a0', folder: '\uf07b', effort: '\uf0e7' }
85export const ICONS: Record<string, Icons> = {
86  'nerd-font': { model: '', git: '', folder: '', effort: '' },
87  unicode: { model: '>', git: '⎇', folder: '▸', effort: '↯' },
88  plain: { model: 'M', git: 'git', folder: 'dir', effort: 'E' },
89}
90
91export function windowLabel(window: number): string {
92  if (window >= 1_000_000) return '1M'
93  return window > 0 ? `${Math.floor(window / 1000)}k` : ''
94}
95
96export type Plain = { model: string; window: number; percent?: number; branch: string; cwd: string; effort?: string }
97
98/** kasaterm 밖 claude 의 상태줄 — kasaterm 상태줄이 칸 밖에서 짓는 줄과 같은 차례·색. 구분자는 따로 넣는다. */
99export function plainParts(v: Plain, icon = 'nerd-font'): Seg[][] {
100  const ic = ICONS[icon] ?? NERD
101  const parts: Seg[][] = []
102  if (v.model) {
103    const name = displayName(v.model)
104    const win = windowLabel(v.window)
105    parts.push([{ text: `${ic.model} ${name}`, color: C_MODEL, bold: true }, ...(win ? [{ text: ` ${win}`, dim: true }] : [])])
106  }
107  if (v.branch) parts.push([{ text: `${ic.git} ${v.branch}`, color: C_GIT }])
108  const dir = v.cwd.replace(/\/+$/, '').split('/').pop() ?? ''
109  parts.push([{ text: `${ic.folder} ${dir}`, color: C_DIR }])
110  const percent = Math.round(v.percent ?? 0)
111  parts.push([{ text: `${percent}%`, color: percent >= 90 ? C_DANGER : C_CTX }])
112  if (v.effort) parts.push([{ text: `${ic.effort} ${v.effort}`, color: C_EFFORT[v.effort] ?? C_MODEL }])
113  return parts
114}
115
116export const SEPARATOR: Seg = { text: '┃', color: C_SEP, dim: true }
117