zames_pro 2.74.0 → 2.75.0

package/scripts/tui-scroll-probe.tsx

@@ -0,0 +1,46 @@
+// Mount the REAL FullScreenApp with a LONG log and log every scroll change,
+// so a pty can press PgUp/PgDn/Home/End and prove the viewport moves.
+import React from 'react'
+import fs from 'node:fs'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { FullScreenApp } from '../src/tui/FullScreenApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+
+const LOG = process.env.PROBE_SCROLL_LOG || '/tmp/scroll-probe.log'
+fs.writeFileSync(LOG, '')
+const store = new TuiStore()
+store.set({
+  title: 'probe',
+  version: '0',
+  workdir: '/tmp',
+  prompt: '\u2794 probe \u203a ',
+  locale: 'en',
+  commands: [],
+  edit: { ...initialEditState(), buf: '' },
+})
+for (let i = 0; i < 100; i++) store.pushLog('system', 'log line ' + i)
+const inputProps = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+store.subscribe(() => {
+  fs.appendFileSync(
+    LOG,
+    String(store.getSnapshot().scroll) + String.fromCharCode(10),
+  )
+})
+render(React.createElement(FullScreenApp, { store, inputProps }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+  alternateScreen: true,
+})
+setInterval(() => {}, 1 << 30)

package/scripts/tui-shot.mts

@@ -0,0 +1,106 @@
+// Take a VT100 "screenshot" of the TUI under a pty and print the grid.
+//
+// Usage: npx tsx scripts/tui-shot.mts [--inline] [--probe=tui-repro|tui-probe]
+//        [--buf=<initial buffer>] [--keys=a,LF,b,ENTER] [--cols=80] [--rows=24]
+//
+// Keys are sent ONE CHUNK AT A TIME. Tokens: LF (Ctrl+J newline), CR (Enter),
+// ESC, TAB, or any literal character. The screen is snapshotted WHILE the app
+// is still alive, so the real terminal-cursor cell is included.
+
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+
+const ESC = String.fromCharCode(27)
+const LF = String.fromCharCode(10)
+const CR = String.fromCharCode(13)
+const TAB = String.fromCharCode(9)
+
+function arg(name: string, def = ''): string {
+  const hit = process.argv.find((a) => a.startsWith('--' + name + '='))
+  return hit ? hit.slice(name.length + 3) : def
+}
+const hasFlag = (name: string): boolean => process.argv.includes('--' + name)
+
+const inline = hasFlag('inline')
+const probe = arg('probe', 'tui-repro')
+const buf = arg('buf', '')
+const keys = arg('keys', '')
+  .split(',')
+  .filter((s) => s.length > 0)
+  .map((s) => {
+    if (s === 'LF') return LF
+    if (s === 'CR' || s === 'ENTER') return CR
+    if (s === 'ESC') return ESC
+    if (s === 'TAB') return TAB
+    // Alt+Enter and Shift+Enter must arrive as ONE chunk, like a real terminal
+    // sends them; splitting them into separate chunks makes Ink read a bare
+    // Escape key instead of the modified Enter.
+    if (s === 'ALTENTER') return ESC + CR
+    if (s === 'SHIFTENTER') return ESC + '[13;2u'
+    if (s === 'UP') return ESC + '[A'
+    if (s === 'DOWN') return ESC + '[B'
+    if (s === 'RIGHT') return ESC + '[C'
+    if (s === 'LEFT') return ESC + '[D'
+    // Editing keys, so the word-delete bindings can be exercised on a real pty.
+    if (s === 'CTDL') return ESC + '[3;5~' // Ctrl+Delete (xterm)
+    if (s === 'CTDLU') return ESC + '[3;5u' // Ctrl+Delete (kitty CSI-u)
+    if (s === 'CTRLBS') return ESC + String.fromCharCode(127) // Ctrl+Backspace
+    if (s === 'CTB08') return String.fromCharCode(8) // Ctrl+Backspace (0x08)
+    if (s === 'DEL') return ESC + '[3~' // Delete
+    if (s === 'CTRLW') return String.fromCharCode(23)
+    if (s === 'CTRLU') return String.fromCharCode(21)
+    if (s === 'CTRLK') return String.fromCharCode(11)
+    if (s === 'SPACE') return ' '
+    return s
+  })
+const cols = Number(arg('cols', '80'))
+const rows = Number(arg('rows', '24'))
+const hold = Number(arg('hold', '500'))
+
+const scriptPath = 'npx tsx scripts/' + probe + '.tsx ' + JSON.stringify(buf)
+
+const term = new Term(rows, cols)
+const child = spawn('script', ['-qec', scriptPath, '/dev/null'], {
+  cwd: path.resolve('.'),
+  env: {
+    ...process.env,
+    COLUMNS: String(cols),
+    LINES: String(rows),
+    ...(inline ? { PROBE_INLINE: '1' } : {}),
+  },
+})
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 250)
+  } else {
+    setTimeout(() => {
+      const cr = term.r
+      const cc = term.c
+      const lines = term.render().split(LF)
+      if (lines[cr])
+        lines[cr] =
+          lines[cr].slice(0, cc) +
+          String.fromCharCode(9673) +
+          lines[cr].slice(cc + 1)
+      process.stdout.write(
+        lines.map((l, n) => String(n).padStart(2) + '| ' + l).join(LF) +
+          LF +
+          'cursor: row ' +
+          cr +
+          ', col ' +
+          cc +
+          LF,
+      )
+      child.kill('SIGTERM')
+    }, hold)
+  }
+}
+setTimeout(tick, 4500)
+child.on('close', () => process.exit(0))

package/scripts/tui-status-driver.mts

@@ -0,0 +1,24 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const cols = Number(
+  (process.argv.find((a) => a.startsWith('--cols=')) || '--cols=80').slice(7),
+)
+const rows = 8
+const term = new Term(rows, cols)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-status-shot.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: String(cols), LINES: String(rows) },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+setTimeout(() => {
+  process.stdout.write(term.render() + NL)
+  child.kill('SIGTERM')
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/tui-status-shot.tsx

@@ -0,0 +1,27 @@
+// Mount the REAL StatusBar with all badges set, to check the width math at
+// narrow terminals (truncation must not clip the badges).
+import React from 'react'
+import { render } from 'ink'
+import { StatusBar } from '../src/tui/StatusBar.js'
+import { TuiStore } from '../src/tui/store.js'
+const store = new TuiStore()
+store.set({
+  locale: 'ru',
+  busy: true,
+  animBase: 'Думаю',
+  animStart: Date.now() - 45000,
+  provider: 'DeepSeek',
+  queueLength: 2,
+  tasks: 'задачи: 2/5',
+  thinkingEnabled: true,
+  searchEnabled: true,
+  contextText: 'ctx: 302k · 30%',
+  contextLevel: 'warn',
+  statusLine: 'git:master',
+  sendState: 'generating',
+})
+render(React.createElement(StatusBar, { state: store.getSnapshot() }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+})
+setInterval(() => {}, 1 << 30)

package/scripts/tui-submit.tsx

@@ -0,0 +1,57 @@
+// Minimal probe: mount the REAL FullScreenApp with a store whose submit
+// callback logs what it receives. Used to verify the bracketed-paste ->
+// [Pasted lines#N] -> expandPastes path end to end.
+
+import React from 'react'
+import fs from 'node:fs'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { FullScreenApp } from '../src/tui/FullScreenApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+import { expandPastes } from '../src/input/layout.js'
+
+const LOG = process.env.PROBE_SUBMIT_LOG || '/tmp/paste-submit.log'
+const store = new TuiStore()
+store.set({
+  title: 'probe',
+  version: '0',
+  workdir: '/tmp',
+  prompt: '> ',
+  locale: 'en',
+  commands: [],
+  edit: { ...initialEditState(), buf: '' },
+})
+const inputProps = {
+  onSubmit: (text: string) => {
+    // Mirrors TuiEditor.handleSubmit: expand the paste markers from the
+    // CURRENT store snapshot, which is what the agent actually receives.
+    const expanded = expandPastes(store.getSnapshot().pastes, text)
+    fs.appendFileSync(
+      LOG,
+      'SUBMIT=' + JSON.stringify(expanded) + String.fromCharCode(10),
+    )
+  },
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: (p: unknown) => {
+    // Mirrors TuiEditor.buildInputProps: the adapter writes the paste list
+    // BACK into the store, which is what handleSubmit reads to expand markers.
+    store.set({ pastes: p as never })
+    fs.appendFileSync(
+      LOG,
+      'PASTES=' + JSON.stringify(p) + String.fromCharCode(10),
+    )
+  },
+}
+render(<FullScreenApp store={store} inputProps={inputProps} />, {
+  exitOnCtrlC: false,
+  patchConsole: false,
+  alternateScreen: true,
+})
+setInterval(() => {}, 1 << 30)

package/scripts/tui-wheel-driver.mts

@@ -0,0 +1,61 @@
+// Drive scripts/tui-wheel-probe.tsx under a pty and send REAL SGR wheel events
+// (mouse reporting must be on for these to arrive; the probe sets nothing, so
+// this also proves the SCROLL mode sequences are emitted). Prints the buffer
+// and scroll transitions the probe logged: the buffer must NEVER change and
+// the scroll must INCREASE on wheel-up.
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const ESC = String.fromCharCode(27)
+const LOG = '/tmp/wheel-probe.log'
+const SCROLL = process.argv.includes('--scroll')
+// SGR wheel-up = Cb 64, wheel-down = 65: ESC [ < 64 ; col ; row M
+try {
+  fs.unlinkSync(LOG)
+} catch {
+  /* ignore */
+}
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-wheel-probe.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: '80',
+      LINES: '24',
+      PROBE_WHEEL_LOG: LOG,
+      ...(SCROLL ? { PROBE_MOUSE_SCROLL: '1' } : {}),
+    },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+
+setTimeout(() => {
+  // Five wheel-up notches.
+  for (let i = 0; i < 5; i++) {
+    child.stdin.write(ESC + '[<64;10;10M')
+    setTimeout(() => {}, 50)
+  }
+  setTimeout(() => child.kill('SIGTERM'), 800)
+}, 6000)
+
+child.on('close', () => {
+  let lines: string[] = []
+  try {
+    lines = fs.readFileSync(LOG, 'utf-8').trim().split(String.fromCharCode(10))
+  } catch {
+    /* ignore */
+  }
+  const parsed = lines.map(
+    (l) => JSON.parse(l) as { buf: string; scroll: number },
+  )
+  const bufs = [...new Set(parsed.map((p) => p.buf))]
+  const scrolls = parsed.map((p) => p.scroll)
+  console.log('BUFS=' + JSON.stringify(bufs))
+  console.log('SCROLLS=' + JSON.stringify(scrolls))
+  process.exit(0)
+})

package/scripts/tui-wheel-probe.tsx

@@ -0,0 +1,48 @@
+// Mount the REAL TuiEditor with a NON-EMPTY input history and a long log, so a
+// pty can send real SGR wheel events and the probe can log whether the INPUT
+// BUFFER or the LOG scroll offset changed. This distinguishes the two failure
+// modes the operator kept hitting: wheel must scroll the LOG (SCROLL mode) and
+// must NEVER touch the input history.
+
+import fs from 'node:fs'
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+
+const LOG = process.env.PROBE_WHEEL_LOG || '/tmp/wheel-probe.log'
+fs.writeFileSync(LOG, '')
+
+const ed = new TuiEditor({
+  prompt: '> ',
+  commands: [],
+  locale: 'en',
+  alternateScreen: true,
+})
+ed.onSubmit = () => {}
+ed.onAttach = () => null
+ed.onClipboard = () => Promise.resolve(null)
+// Mouse-wheel scroll of the log is opt-in (config.ui.mouseScroll). Set it from
+// the env so the driver can exercise BOTH modes on a real pty.
+ed.setHeader?.({ mouseScroll: process.env.PROBE_MOUSE_SCROLL === '1' })
+
+// A non-empty history: a wheel-to-history bug would replace the empty buffer
+// with one of these lines.
+const snap = ed.store.getSnapshot()
+ed.store.set({
+  edit: { ...snap.edit, history: ['OLD_COMMAND_ONE', 'OLD_COMMAND_TWO'] },
+  scroll: 0,
+})
+// A tall log so there is something to scroll.
+for (let i = 0; i < 40; i++) ed.printAbove('log line ' + i)
+
+const report = (): void => {
+  const s = ed.store.getSnapshot()
+  fs.appendFileSync(
+    LOG,
+    JSON.stringify({ buf: s.edit.buf, scroll: s.scroll }) +
+      String.fromCharCode(10),
+  )
+}
+ed.store.subscribe(report)
+report()
+
+ed.start()
+setInterval(() => {}, 1 << 30)

package/scripts/tui-widgets-driver.mts

@@ -0,0 +1,20 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const term = new Term(16, 60)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-widgets.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '60', LINES: '16' },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+setTimeout(() => {
+  process.stdout.write(term.render() + NL)
+  child.kill('SIGTERM')
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/tui-widgets.tsx

@@ -0,0 +1,44 @@
+import React from 'react'
+import { render, Box, Text } from 'ink'
+import {
+  Checkbox,
+  Select,
+  Panel,
+  HintBar,
+  CodeBlock,
+} from '../src/tui/widgets.js'
+render(
+  React.createElement(
+    Box,
+    { flexDirection: 'column' },
+    React.createElement(
+      Text,
+      null,
+      'Checkbox: ',
+      React.createElement(Checkbox, { checked: true, focused: true }),
+      ' ',
+      React.createElement(Checkbox, { checked: false, focused: false }),
+    ),
+    React.createElement(
+      Text,
+      null,
+      'Select: ',
+      React.createElement(Select, { value: 'qwen3.7-plus', focused: true }),
+    ),
+    React.createElement(
+      Panel,
+      { title: 'Панель', subtitle: '2', width: 50 },
+      React.createElement(Text, null, 'содержимое'),
+    ),
+    React.createElement(HintBar, {
+      hints: [
+        ['↑/↓', 'выбор'],
+        ['Enter', 'ok'],
+        ['Esc', 'отмена'],
+      ],
+    }),
+    React.createElement(CodeBlock, { code: 'const a = 1', lang: 'ts' }),
+  ),
+  { exitOnCtrlC: false, patchConsole: false },
+)
+setInterval(() => {}, 1 << 30)