zames_pro 2.74.0 → 2.75.0

package/scripts/tui-log-driver.mts

@@ -0,0 +1,35 @@
+// Screenshot the FullScreenApp log for a given content spec.
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+
+const NL = String.fromCharCode(10)
+function arg(n: string, d = ''): string {
+  const h = process.argv.find((a) => a.startsWith('--' + n + '='))
+  return h ? h.slice(n.length + 3) : d
+}
+const cols = Number(arg('cols', '80'))
+const rows = Number(arg('rows', '24'))
+const spec = arg('log', 'empty')
+
+const term = new Term(rows, cols)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-log-shot.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: String(cols),
+      LINES: String(rows),
+      PROBE_LOG: spec,
+    },
+  },
+)
+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-log-shot.tsx

@@ -0,0 +1,48 @@
+// Mount the REAL FullScreenApp with a log driven by PROBE_LOG (JSON entries),
+// so empty/overflowing/long-wrapped logs can be screenshotted.
+import React from 'react'
+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 store = new TuiStore()
+store.set({
+  title: 'zames',
+  version: '2.74',
+  workdir: '/tmp',
+  prompt: '\u2794 zames \u203a ',
+  locale: 'en',
+  commands: [],
+  edit: { ...initialEditState(), buf: '' },
+})
+const spec = process.env.PROBE_LOG || 'empty'
+if (spec === 'empty') {
+  // nothing
+} else if (spec === 'few') {
+  store.pushLog('user', 'hello')
+  store.pushLog('assistant', 'hi there')
+} else if (spec === 'many') {
+  for (let i = 0; i < 100; i++) store.pushLog('system', 'log line ' + i)
+} else if (spec === 'long') {
+  store.pushLog('assistant', 'L'.repeat(300))
+  store.pushLog('system', 'after long')
+}
+const inputProps = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+render(React.createElement(FullScreenApp, { store, inputProps }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+  alternateScreen: true,
+})
+setInterval(() => {}, 1 << 30)

package/scripts/tui-longpaste-driver.mts

@@ -0,0 +1,56 @@
+// Paste a long bracketed block into the REAL TuiEditor under a pty, screenshot
+// the screen (marker shown), press Enter, and print the submit log.
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const ESC = String.fromCharCode(27)
+const CR = String.fromCharCode(13)
+const NL = String.fromCharCode(10)
+const LOG = '/tmp/longpaste.log'
+try {
+  fs.unlinkSync(LOG)
+} catch {
+  /* ignore */
+}
+const lines = Number(process.argv[2] || '25')
+const body = Array.from(
+  { length: lines },
+  (_, i) => 'line ' + i + ' of the pasted block',
+).join(NL)
+const cols = Number(process.argv[3] || '80')
+const rows = Number(process.argv[4] || '24')
+const term = new Term(rows, cols)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-longpaste.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: String(cols),
+      LINES: String(rows),
+      PROBE_PASTE_LOG: LOG,
+    },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+setTimeout(() => {
+  child.stdin.write(ESC + '[200~' + body + ESC + '[201~')
+  setTimeout(() => {
+    process.stdout.write('=== SCREEN (after paste) ===' + NL)
+    process.stdout.write(term.render() + NL)
+    child.stdin.write(CR)
+    setTimeout(() => {
+      process.stdout.write('=== LOG ===' + NL)
+      try {
+        process.stdout.write(fs.readFileSync(LOG, 'utf-8'))
+      } catch {
+        /* ignore */
+      }
+      child.kill('SIGTERM')
+    }, 600)
+  }, 600)
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/tui-longpaste.tsx

@@ -0,0 +1,35 @@
+// Mount the REAL TuiEditor and log every onSubmit (the EXPANDED text), so a pty
+// can paste a LONG multi-line block and prove the agent receives all of it —
+// not the [Pasted lines#N] marker.
+import fs from 'node:fs'
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+const LOG = process.env.PROBE_PASTE_LOG || '/tmp/longpaste.log'
+fs.writeFileSync(LOG, '')
+const ed = new TuiEditor({
+  prompt: '> ',
+  commands: [],
+  locale: 'en',
+  alternateScreen: true,
+})
+ed.onSubmit = (text: string) => {
+  fs.appendFileSync(
+    LOG,
+    'SUBMIT_LEN=' +
+      text.length +
+      ' LINES=' +
+      text.split(String.fromCharCode(10)).length +
+      String.fromCharCode(10),
+  )
+  fs.appendFileSync(
+    LOG,
+    'HEAD=' + JSON.stringify(text.slice(0, 40)) + String.fromCharCode(10),
+  )
+  fs.appendFileSync(
+    LOG,
+    'TAIL=' + JSON.stringify(text.slice(-40)) + String.fromCharCode(10),
+  )
+}
+ed.onAttach = () => null
+ed.onClipboard = () => Promise.resolve(null)
+ed.start()
+setInterval(() => {}, 1 << 30)

package/scripts/tui-manyselect-shot.mts

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const ESC = String.fromCharCode(27)
+const keys = (process.argv[2] || '')
+  .split(',')
+  .filter(Boolean)
+  .map((k) => (k === 'UP' ? ESC + '[A' : k === 'DOWN' ? ESC + '[B' : k))
+const term = new Term(20, 60)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-manyselect.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '60', LINES: '20' },
+  },
+)
+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(() => {
+      process.stdout.write(term.render() + NL)
+      child.kill('SIGTERM')
+    }, 400)
+}
+setTimeout(tick, 4500)
+child.on('close', () => process.exit(0))

package/scripts/tui-manyselect.tsx

@@ -0,0 +1,17 @@
+import React from 'react'
+import { render } from 'ink'
+import { SelectList } from '../src/tui/SelectList.js'
+const items = Array.from({ length: 30 }, (_, i) => ({
+  value: 'm' + i,
+  label: 'модель-' + i,
+}))
+render(
+  React.createElement(SelectList, {
+    title: 'Много',
+    items,
+    initial: 'm15',
+    onSelect: () => {},
+  }),
+  { exitOnCtrlC: false, patchConsole: false },
+)
+setInterval(() => {}, 1 << 30)

package/scripts/tui-mouse-churn-probe.tsx

@@ -0,0 +1,28 @@
+// Mount the REAL TuiEditor and tick the store every 150ms (like the 1s badge
+// timer does), so the raw stdout can be scanned for how many times the
+// mouse-mode sequences are written. A well-behaved hook writes them ONCE on
+// mount; a hook whose effect depends on an inline `onWheel` re-runs on every
+// render and writes `1007h` (alternate-scroll ON => wheel becomes history)
+// again and again.
+
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+
+const ed = new TuiEditor({
+  prompt: '> ',
+  commands: [],
+  locale: 'en',
+  alternateScreen: true,
+})
+ed.onSubmit = () => {}
+ed.onAttach = () => null
+ed.onClipboard = () => Promise.resolve(null)
+ed.start()
+
+let n = 0
+const timer = setInterval(() => {
+  // A no-op-ish store change: bump the queue badge, like refreshBadges does.
+  ed.store.set({ queueLength: n++ })
+  if (n > 20) clearInterval(timer)
+}, 150)
+
+setInterval(() => {}, 1 << 30)

package/scripts/tui-paste-driver.mts

@@ -0,0 +1,88 @@
+// Feed a scripted set of bracketed pastes + Enter into the REAL TuiEditor
+// probe under a pty, then print /tmp/paste-kinds.log (what onSubmit received).
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const ESC = String.fromCharCode(27)
+const CR = String.fromCharCode(13)
+const LOG = '/tmp/paste-kinds.log'
+const TMP = '/tmp/paste-probe-tmp'
+for (const f of [LOG]) {
+  try {
+    fs.unlinkSync(f)
+  } catch {
+    /* ignore */
+  }
+}
+fs.mkdirSync(TMP, { recursive: true })
+
+const png =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
+const dataUrl = 'data:image/png;base64,' + png
+const existingFile = path.resolve('README.md')
+
+const pastes = [
+  'hello plain text',
+  'line1' +
+    String.fromCharCode(10) +
+    'line2' +
+    String.fromCharCode(10) +
+    'line3' +
+    String.fromCharCode(10) +
+    'line4',
+  existingFile,
+  dataUrl,
+]
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-paste-kinds.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      COLUMNS: '90',
+      LINES: '28',
+      PROBE_PASTE_LOG: LOG,
+      PROBE_PASTE_TMP: TMP,
+    },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+
+const enc = (s: string): string => ESC + '[200~' + s + ESC + '[201~'
+let i = 0
+const step = (): void => {
+  if (i < pastes.length) {
+    child.stdin.write(enc(pastes[i]))
+    setTimeout(() => {
+      child.stdin.write(CR)
+      i++
+      setTimeout(step, 500)
+    }, 500)
+  } else {
+    setTimeout(() => child.kill('SIGTERM'), 600)
+  }
+}
+setTimeout(step, 5000)
+child.on('close', () => {
+  let out = ''
+  try {
+    out = fs.readFileSync(LOG, 'utf-8')
+  } catch {
+    out = '(no log)'
+  }
+  process.stdout.write(out + String.fromCharCode(10))
+  try {
+    process.stdout.write('--- tmp files ---' + String.fromCharCode(10))
+    process.stdout.write(
+      fs.readdirSync(TMP).join(String.fromCharCode(10)) +
+        String.fromCharCode(10),
+    )
+  } catch {
+    /* ignore */
+  }
+  process.exit(0)
+})

package/scripts/tui-paste-kinds.tsx

@@ -0,0 +1,76 @@
+// Drive the REAL TuiEditor under a pty and log every onSubmit (text +
+// attachments) so all paste kinds can be exercised: plain text, a big
+// multi-line paste, a file path, and a data: URL image. The attach/clipboard
+// callbacks mirror index.ts (parseImagePaste -> saveToTemp; resolveAttachPath
+// -> readFile) so the probe exercises the same code path the live agent does.
+
+import fs from 'node:fs'
+import fsp from 'node:fs/promises'
+import path from 'node:path'
+import { TuiEditor } from '../src/tui/TuiEditor.js'
+import {
+  contentHash,
+  extForMime,
+  guessMime,
+  parseImagePaste,
+  saveToTemp,
+} from '../src/attachments.js'
+import { resolveAttachPath } from '../src/attach-refs.js'
+
+const LOG = process.env.PROBE_PASTE_LOG || '/tmp/paste-kinds.log'
+const TMP = process.env.PROBE_PASTE_TMP || '/tmp/paste-probe-tmp'
+const WORKDIR = process.cwd()
+const line = (s: string): void => {
+  fs.appendFileSync(LOG, s + String.fromCharCode(10))
+}
+
+const ed = new TuiEditor({
+  prompt: '> ',
+  commands: [],
+  locale: 'en',
+  alternateScreen: true,
+})
+
+ed.onSubmit = (text, atts) => {
+  line(
+    'SUBMIT text=' +
+      JSON.stringify(text) +
+      ' atts=' +
+      JSON.stringify(
+        atts.map((a) => ({ marker: a.marker, image: a.image, name: a.name })),
+      ),
+  )
+}
+ed.onAttach = async (raw: string) => {
+  const image = parseImagePaste(raw)
+  if (image) {
+    const name = 'paste' + extForMime(image.mime)
+    const p = await saveToTemp(TMP, name, image.data)
+    const att = ed.attachments.add({
+      path: p,
+      name,
+      mime: image.mime,
+      size: image.data.length,
+      hash: contentHash(image.data),
+    })
+    line('ATTACH_IMAGE ' + att.marker + ' ' + p)
+    return att
+  }
+  const filePath = await resolveAttachPath(WORKDIR, raw)
+  if (!filePath) return null
+  const data = await fsp.readFile(filePath).catch(() => null)
+  if (!data) return null
+  const name = path.basename(filePath)
+  const att = ed.attachments.add({
+    path: filePath,
+    name,
+    mime: guessMime(name),
+    size: data.length,
+  })
+  line('ATTACH_FILE ' + att.marker + ' ' + filePath)
+  return att
+}
+ed.onClipboard = () => Promise.resolve(null)
+
+ed.start()
+setInterval(() => {}, 1 << 30)

package/scripts/tui-pastetest.mts

@@ -0,0 +1,38 @@
+// Reproduce the [Pasted lines#N] path end to end under a pty: send ONE
+// bracketed-paste chunk with several lines, press Enter, and print what the
+// onSubmit callback actually received (that is what reaches the agent).
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import fs from 'node:fs'
+
+const ESC = String.fromCharCode(27)
+const LF = String.fromCharCode(10)
+const CR = String.fromCharCode(13)
+const LOG = '/tmp/paste-submit.log'
+fs.writeFileSync(LOG, '')
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-submit.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LINES: '24', PROBE_SUBMIT_LOG: LOG },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+
+setTimeout(() => {
+  const paste =
+    ESC + '[200~' + ['l1', 'l2', 'l3', 'l4', 'l5'].join(LF) + ESC + '[201~'
+  child.stdin.write(paste)
+  setTimeout(() => {
+    child.stdin.write(CR)
+    setTimeout(() => child.kill('SIGTERM'), 800)
+  }, 800)
+}, 4500)
+
+child.on('close', () => {
+  process.stdout.write(fs.readFileSync(LOG, 'utf-8'))
+  process.exit(0)
+})

package/scripts/tui-repro.tsx

@@ -0,0 +1,64 @@
+// Reproduce the LIVE TUI scenario for the input-box geometry bug.
+//
+// The stock probe uses a bare `> ` prompt, an empty command list and no header, which is why the gated pty test stays green while the live agent still overprints the second input line. This probe mounts the same FullScreenApp with a realistic prompt, a non-empty slash command list and a long title.
+//
+// NOT shipped: a dev probe only.
+
+import React from 'react'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { FullScreenApp } from '../src/tui/FullScreenApp.js'
+import { TuiApp } from '../src/tui/TuiApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+
+const store = new TuiStore()
+const commands = [
+  { name: '/help', description: 'show help' },
+  { name: '/history', description: 'input history' },
+  { name: '/new', description: 'new chat' },
+  { name: '/resume', description: 'open a chat' },
+  { name: '/config', description: 'settings' },
+  {
+    name: '/self-review',
+    description:
+      'snapshot src/ and review the current working tree for bugs and risks',
+  },
+]
+store.set({
+  title: 'zames_pro',
+  version: '2.34.0',
+  workdir: '/workspaces/zames/zames_pro',
+  prompt: '➔ zames_pro › ',
+  locale: 'en',
+  commands,
+  edit: { ...initialEditState(), buf: process.argv[2] ?? '' },
+})
+
+store.pushLog('system', 'log line one')
+store.pushLog('system', 'log line two')
+
+const INLINE = process.env.PROBE_INLINE === '1'
+
+const inputProps = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+
+render(
+  INLINE ? (
+    <TuiApp store={store} inputProps={inputProps} />
+  ) : (
+    <FullScreenApp store={store} inputProps={inputProps} />
+  ),
+  { exitOnCtrlC: false, patchConsole: false, alternateScreen: !INLINE },
+)
+
+setInterval(() => {}, 1 << 30)

package/scripts/tui-resize.mts

@@ -0,0 +1,70 @@
+// Resize a REAL TuiEditor under a pty and screenshot the final grid. The pty
+// WINSIZE is changed mid-run so the kernel delivers SIGWINCH, which exercises
+// TuiEditor.installResizeHandler (unmount + remount), not just Ink's erase.
+//
+// Usage: npx tsx scripts/tui-resize.mts [sc sr nc nr text]
+import { spawnSync } from 'node:child_process'
+import { Term } from '../test/vt100.mts'
+
+const NL = String.fromCharCode(10)
+const sc = Number(process.argv[2] || 80)
+const sr = Number(process.argv[3] || 24)
+const nc = Number(process.argv[4] || 100)
+const nr = Number(process.argv[5] || 30)
+const text = process.argv[6] || ''
+
+// Inline python pty harness (no external file).
+const py = [
+  'import os,pty,sys,time,fcntl,termios,struct,signal,select',
+  'sc,sr,nc,nr=' + sc + ',' + sr + ',' + nc + ',' + nr,
+  'text=' + JSON.stringify(text),
+  'pid,fd=pty.fork()',
+  'if pid==0:',
+  "    os.environ['COLUMNS']=str(sc); os.environ['LINES']=str(sr)",
+  "    os.execvp('npx',['npx','tsx','scripts/tui-editor-probe.tsx'])",
+  'else:',
+  "    def sz(c,r): fcntl.ioctl(fd,termios.TIOCSWINSZ,struct.pack('HHHH',r,c,0,0))",
+  '    sz(sc,sr)',
+  "    buf=b''; start=time.time(); sent=False; resized=False",
+  '    while time.time()-start<14:',
+  '        t=time.time()-start',
+  '        if not sent and t>5:',
+  '            for ch in text:',
+  '                os.write(fd,ch.encode()); time.sleep(0.12)',
+  '            sent=True',
+  '        if not resized and t>9:',
+  '            sz(nc,nr); os.kill(pid,signal.SIGWINCH); resized=True',
+  '        r,_,_=select.select([fd],[],[],0.2)',
+  '        if r:',
+  '            try:',
+  '                d=os.read(fd,65536)',
+  '                if not d: break',
+  '                buf+=d',
+  '            except OSError: break',
+  '    time.sleep(0.5)',
+  '    try:',
+  '        while True:',
+  '            r,_,_=select.select([fd],[],[],0.2)',
+  '            if not r: break',
+  '            d=os.read(fd,65536)',
+  '            if not d: break',
+  '            buf+=d',
+  '    except OSError: pass',
+  '    try: os.kill(pid,signal.SIGKILL)',
+  '    except ProcessLookupError: pass',
+  '    sys.stdout.buffer.write(buf)',
+].join(NL)
+
+const out = spawnSync('python3', ['-c', py], {
+  encoding: 'buffer',
+  maxBuffer: 64 * 1024 * 1024,
+})
+const term = new Term(Math.max(sr, nr), Math.max(sc, nc))
+term.write(out.stdout.toString('utf-8'))
+process.stdout.write(
+  term
+    .render()
+    .split(NL)
+    .map((l, n) => String(n).padStart(2) + '| ' + l)
+    .join(NL) + NL,
+)

package/scripts/tui-scroll-driver.mts

@@ -0,0 +1,53 @@
+// Press keys on the scroll probe and print the scroll values it saw. Accepts
+// several End/Home encodings so a terminal that sends a non-xterm form can be
+// diagnosed.
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+const ESC = String.fromCharCode(27)
+const LOG = '/tmp/scroll-probe.log'
+try {
+  fs.unlinkSync(LOG)
+} catch {
+  /* ignore */
+}
+const map: Record<string, string> = {
+  PGUP: ESC + '[5~',
+  PGDN: ESC + '[6~',
+  HOME: ESC + '[H',
+  END: ESC + '[F',
+  END4: ESC + '[4~',
+  HOME1: ESC + '[1~',
+  CEND: ESC + '[1;5F',
+  CHOME: ESC + '[1;5H',
+  SPGDN: ESC + '[6;2~',
+  SPGUP: ESC + '[5;2~',
+}
+const keys = (process.argv[2] || 'PGUP').split(',').map((k) => map[k] ?? k)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-scroll-probe.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LINES: '24', PROBE_SCROLL_LOG: LOG },
+  },
+)
+child.stdout.on('data', () => {})
+child.stderr.on('data', () => {})
+let i = 0
+const tick = (): void => {
+  if (i < keys.length) {
+    child.stdin.write(keys[i])
+    i++
+    setTimeout(tick, 250)
+  } else setTimeout(() => child.kill('SIGTERM'), 400)
+}
+setTimeout(tick, 5000)
+child.on('close', () => {
+  const lines = fs
+    .readFileSync(LOG, 'utf-8')
+    .trim()
+    .split(String.fromCharCode(10))
+  console.log('SCROLL=' + JSON.stringify(lines.map(Number)))
+  process.exit(0)
+})