smolerclaw 0.1.0

package/src/types.ts

@@ -0,0 +1,55 @@
+export interface MessageImage {
+  mediaType: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp'
+  base64: string
+}
+
+export interface Message {
+  role: 'user' | 'assistant'
+  content: string
+  images?: MessageImage[]
+  toolCalls?: ToolCall[]
+  usage?: { inputTokens: number; outputTokens: number; costCents: number }
+  timestamp: number
+}
+
+export interface ToolCall {
+  id: string
+  name: string
+  input: Record<string, unknown>
+  result: string
+}
+
+export interface Session {
+  id: string
+  name: string
+  messages: Message[]
+  created: number
+  updated: number
+}
+
+export interface TinyClawConfig {
+  apiKey: string
+  authMode: 'auto' | 'api-key' | 'subscription'
+  model: string
+  maxTokens: number
+  maxHistory: number
+  systemPrompt: string
+  skillsDir: string
+  dataDir: string
+  toolApproval: ToolApprovalMode
+  language: string
+  maxSessionCost: number // max cost in cents per session. 0 = unlimited
+}
+
+export type ToolApprovalMode = 'auto' | 'confirm-writes' | 'confirm-all'
+
+export type ChatEvent =
+  | { type: 'text'; text: string }
+  | { type: 'tool_call'; id: string; name: string; input: unknown }
+  | { type: 'tool_result'; id: string; name: string; result: string }
+  | { type: 'tool_blocked'; id: string; name: string; reason: string }
+  | { type: 'usage'; inputTokens: number; outputTokens: number }
+  | { type: 'retry'; attempt: number; waitMs: number; reason: string }
+  | { type: 'context_trimmed'; dropped: number }
+  | { type: 'done' }
+  | { type: 'error'; error: string }

package/src/undo.ts

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { join, dirname, basename } from 'node:path'
+
+const MAX_UNDO_ENTRIES = 50
+
+interface UndoEntry {
+  path: string
+  content: string  // original content before change
+  timestamp: number
+  existed: boolean // false if file was newly created
+}
+
+/**
+ * Tracks file changes for undo support.
+ * Stores original content before each write/edit in memory.
+ */
+export class UndoStack {
+  private entries: UndoEntry[] = []
+
+  /**
+   * Save the current state of a file before modifying it.
+   * Call this BEFORE writing/editing.
+   */
+  saveState(filePath: string): void {
+    const existed = existsSync(filePath)
+    const content = existed ? readFileSync(filePath, 'utf-8') : ''
+
+    this.entries.push({
+      path: filePath,
+      content,
+      timestamp: Date.now(),
+      existed,
+    })
+
+    // Cap the stack
+    if (this.entries.length > MAX_UNDO_ENTRIES) {
+      this.entries = this.entries.slice(-MAX_UNDO_ENTRIES)
+    }
+  }
+
+  /**
+   * Undo the last file change. Restores original content.
+   * Returns description of what was undone, or null if stack is empty.
+   */
+  undo(): string | null {
+    const entry = this.entries.pop()
+    if (!entry) return null
+
+    if (!entry.existed) {
+      // File was newly created — we could delete it, but safer to leave it
+      // and just report. Deleting is destructive.
+      return `Undo: ${basename(entry.path)} was a new file. Remove it manually if needed.`
+    }
+
+    writeFileSync(entry.path, entry.content)
+    const lines = entry.content.split('\n').length
+    return `Undo: restored ${basename(entry.path)} (${lines} lines, from ${formatAge(entry.timestamp)})`
+  }
+
+  /**
+   * Get the stack size.
+   */
+  get size(): number {
+    return this.entries.length
+  }
+
+  /**
+   * Peek at what would be undone.
+   */
+  peek(): string | null {
+    if (this.entries.length === 0) return null
+    const entry = this.entries[this.entries.length - 1]
+    return `${basename(entry.path)} (${formatAge(entry.timestamp)})`
+  }
+}
+
+function formatAge(timestamp: number): string {
+  const seconds = Math.floor((Date.now() - timestamp) / 1000)
+  if (seconds < 60) return `${seconds}s ago`
+  const minutes = Math.floor(seconds / 60)
+  if (minutes < 60) return `${minutes}m ago`
+  return `${Math.floor(minutes / 60)}h ago`
+}

package/src/windows.ts

@@ -0,0 +1,299 @@
+/**
+ * Windows-specific utilities for the business assistant.
+ * All operations are non-destructive (read-only or open-only).
+ *
+ * getDateTimeInfo() is cross-platform (pure JS, no Windows APIs).
+ */
+
+import { IS_WINDOWS } from './platform'
+
+// ─── Security: PowerShell input sanitization ────────────────
+
+/** Characters that can break out of a PowerShell double-quoted string or inject commands */
+const PS_DANGEROUS = /[";`$\n\r|&<>{}()]/
+
+/**
+ * Validate a string is safe for embedding in a PowerShell command.
+ * Rejects any string containing shell metacharacters rather than
+ * trying to escape them (defense-in-depth).
+ */
+function validatePsInput(value: string, label: string): string | null {
+  if (!value || typeof value !== 'string') {
+    return `Error: ${label} is required.`
+  }
+  if (value.length > 500) {
+    return `Error: ${label} too long (max 500 chars).`
+  }
+  if (PS_DANGEROUS.test(value)) {
+    return `Error: ${label} contains invalid characters. Avoid: " ; \` $ | & < > { } ( ) and newlines.`
+  }
+  return null
+}
+
+// ─── Process helpers with timeout and deadlock prevention ───
+
+const SPAWN_TIMEOUT_MS = 15_000
+
+/**
+ * Spawn a PowerShell command with timeout and concurrent pipe drainage.
+ * Returns { stdout, stderr, exitCode }.
+ */
+async function runPowerShell(cmd: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const proc = Bun.spawn(
+    ['powershell', '-NoProfile', '-NonInteractive', '-Command', cmd],
+    { stdout: 'pipe', stderr: 'pipe' },
+  )
+
+  const timer = setTimeout(() => proc.kill(), SPAWN_TIMEOUT_MS)
+
+  // Drain both pipes concurrently to prevent deadlock
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ])
+  const exitCode = await proc.exited
+  clearTimeout(timer)
+
+  return { stdout, stderr, exitCode }
+}
+
+// ─── App Launcher ───────────────────────────────────────────
+
+/** Known Windows applications with their executable paths/commands */
+const KNOWN_APPS: Record<string, string> = {
+  // Microsoft Office (protocol URIs for MSIX/Store apps)
+  excel: 'excel',
+  word: 'winword',
+  powerpoint: 'powerpnt',
+  outlook: 'ms-outlook:',
+  onenote: 'onenote',
+  teams: 'msteams:',
+
+  // Browsers
+  edge: 'msedge',
+  chrome: 'chrome',
+  firefox: 'firefox',
+
+  // System tools
+  calculator: 'calc',
+  notepad: 'notepad',
+  terminal: 'wt',
+  explorer: 'explorer',
+  taskmanager: 'taskmgr',
+  settings: 'ms-settings:',
+  paint: 'mspaint',
+  snip: 'snippingtool',
+
+  // Dev tools
+  vscode: 'code',
+  cursor: 'cursor',
+  postman: 'Postman',
+}
+
+/**
+ * Open a Windows application by name. Non-destructive.
+ */
+export async function openApp(name: string, args?: string): Promise<string> {
+  if (!IS_WINDOWS) return 'Error: this command is only available on Windows.'
+
+  const key = name.toLowerCase().replace(/\s+/g, '')
+  const exe = KNOWN_APPS[key]
+
+  if (!exe) {
+    const available = Object.keys(KNOWN_APPS).join(', ')
+    return `Unknown app: "${name}". Available: ${available}`
+  }
+
+  // Validate optional argument (file path to open in the app)
+  if (args) {
+    const err = validatePsInput(args, 'argument')
+    if (err) return err
+  }
+
+  const cmd = args
+    ? `Start-Process '${exe}' -ArgumentList '${args}'`
+    : `Start-Process '${exe}'`
+
+  try {
+    const { exitCode, stderr } = await runPowerShell(cmd)
+    if (exitCode !== 0 && stderr.trim()) {
+      return `Error opening ${name}: ${stderr.trim()}`
+    }
+    return `Opened: ${name}`
+  } catch (err) {
+    return `Error opening ${name}: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+/**
+ * Open a URL in the default browser.
+ */
+export async function openUrl(url: string): Promise<string> {
+  if (!IS_WINDOWS) return 'Error: this command is only available on Windows.'
+
+  // Validate URL scheme
+  if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    return 'Error: URL must start with http:// or https://'
+  }
+
+  const err = validatePsInput(url, 'URL')
+  if (err) return err
+
+  try {
+    const { exitCode, stderr } = await runPowerShell(`Start-Process '${url}'`)
+    if (exitCode !== 0 && stderr.trim()) {
+      return `Error: ${stderr.trim()}`
+    }
+    return `Opened in browser: ${url}`
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+/**
+ * Open a file with its default application.
+ */
+export async function openFile(filePath: string): Promise<string> {
+  if (!IS_WINDOWS) return 'Error: this command is only available on Windows.'
+
+  const err = validatePsInput(filePath, 'file path')
+  if (err) return err
+
+  try {
+    const { exitCode, stderr } = await runPowerShell(`Invoke-Item '${filePath}'`)
+    if (exitCode !== 0 && stderr.trim()) {
+      return `Error: ${stderr.trim()}`
+    }
+    return `Opened: ${filePath}`
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+// ─── System Info ────────────────────────────────────────────
+
+/**
+ * Get a summary of running processes (top by CPU/memory).
+ * Non-destructive — read-only.
+ */
+export async function getRunningApps(): Promise<string> {
+  if (!IS_WINDOWS) return 'Error: this command is only available on Windows.'
+
+  try {
+    const cmd = `Get-Process | Where-Object {$_.MainWindowTitle -ne ''} | Sort-Object -Property WorkingSet64 -Descending | Select-Object -First 15 Name, @{N='Memory(MB)';E={[math]::Round($_.WorkingSet64/1MB,1)}}, MainWindowTitle | Format-Table -AutoSize | Out-String -Width 200`
+    const { stdout, stderr } = await runPowerShell(cmd)
+    if (stderr.trim()) {
+      return `Error: ${stderr.trim()}`
+    }
+    return stdout.trim() || 'No windowed applications running.'
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+/**
+ * Get system resource summary (CPU, RAM, disk).
+ */
+export async function getSystemInfo(): Promise<string> {
+  if (!IS_WINDOWS) return 'Error: this command is only available on Windows.'
+
+  const commands = [
+    `$cpu = (Get-CimInstance Win32_Processor | Measure-Object -Property LoadPercentage -Average).Average; "CPU: $cpu%"`,
+    `$os = Get-CimInstance Win32_OperatingSystem; $total = [math]::Round($os.TotalVisibleMemorySize/1MB,1); $free = [math]::Round($os.FreePhysicalMemory/1MB,1); $used = $total - $free; "RAM: $used GB / $total GB (Free: $free GB)"`,
+    `Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3" | ForEach-Object { $free = [math]::Round($_.FreeSpace/1GB,1); $total = [math]::Round($_.Size/1GB,1); "$($_.DeviceID) $free GB free / $total GB" }`,
+    `$uptime = (Get-Date) - (Get-CimInstance Win32_OperatingSystem).LastBootUpTime; "Uptime: $($uptime.Days)d $($uptime.Hours)h $($uptime.Minutes)m"`,
+    `$b = Get-CimInstance Win32_Battery -ErrorAction SilentlyContinue; if ($b) { "Battery: $($b.EstimatedChargeRemaining)%" } else { "Battery: N/A (desktop)" }`,
+  ]
+
+  try {
+    const { stdout, stderr } = await runPowerShell(commands.join('; '))
+    if (!stdout.trim() && stderr.trim()) {
+      return `Error: ${stderr.trim()}`
+    }
+    return stdout.trim() || 'System info unavailable.'
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+/**
+ * Get today's date/time info. Cross-platform (pure JS).
+ */
+export async function getDateTimeInfo(): Promise<string> {
+  const now = new Date()
+  const lines: string[] = []
+
+  const weekday = now.toLocaleDateString('pt-BR', { weekday: 'long' })
+  const date = now.toLocaleDateString('pt-BR', { day: '2-digit', month: '2-digit', year: 'numeric' })
+  const time = now.toLocaleTimeString('pt-BR', { hour: '2-digit', minute: '2-digit' })
+
+  lines.push(`${weekday}, ${date} — ${time}`)
+
+  // ISO 8601 week number calculation
+  const target = new Date(now.valueOf())
+  target.setDate(target.getDate() + 3 - ((target.getDay() + 6) % 7))
+  const jan4 = new Date(target.getFullYear(), 0, 4)
+  const weekNum = 1 + Math.round(((target.getTime() - jan4.getTime()) / 86_400_000 - 3 + ((jan4.getDay() + 6) % 7)) / 7)
+  lines.push(`Semana ${weekNum} do ano`)
+
+  // Business hours check
+  const hour = now.getHours()
+  if (hour >= 8 && hour < 18) {
+    lines.push('Status: horario comercial')
+  } else if (hour >= 18 && hour < 22) {
+    lines.push('Status: pos-expediente')
+  } else {
+    lines.push('Status: fora do horario comercial')
+  }
+
+  return lines.join('\n')
+}
+
+// ─── Outlook Calendar (if available) ────────────────────────
+
+/**
+ * Get today's Outlook calendar events (read-only).
+ * Falls back gracefully if Outlook is not installed.
+ * Uses olFolderCalendar = 9 from the Outlook COM object model.
+ */
+export async function getOutlookEvents(): Promise<string> {
+  if (!IS_WINDOWS) return 'Outlook integration only available on Windows.'
+
+  const cmd = [
+    'try {',
+    '  $outlook = New-Object -ComObject Outlook.Application -ErrorAction Stop',
+    '  $ns = $outlook.GetNamespace("MAPI")',
+    '  $cal = $ns.GetDefaultFolder(9)',  // olFolderCalendar
+    '  $today = (Get-Date).Date',
+    '  $tomorrow = $today.AddDays(1)',
+    '  $items = $cal.Items',
+    '  $items.Sort("[Start]")',
+    '  $items.IncludeRecurrences = $true',
+    '  $filter = "[Start] >= \'$($today.ToString(\'g\'))\' AND [Start] < \'$($tomorrow.ToString(\'g\'))\'"',
+    '  $events = $items.Restrict($filter)',
+    '  $results = @()',
+    '  foreach ($e in $events) {',
+    '    $start = ([DateTime]$e.Start).ToString("HH:mm")',
+    '    $end = ([DateTime]$e.End).ToString("HH:mm")',
+    '    $results += "$start-$end $($e.Subject)"',
+    '  }',
+    '  if ($results.Count -eq 0) { "Nenhum evento hoje." }',
+    '  else { $results -join [char]10 }',
+    '} catch {',
+    '  "Outlook nao disponivel ou sem eventos."',
+    '}',
+  ].join('\n')
+
+  try {
+    const { stdout } = await runPowerShell(cmd)
+    return stdout.trim() || 'Outlook nao disponivel.'
+  } catch {
+    return 'Outlook nao disponivel.'
+  }
+}
+
+// ─── Exports ────────────────────────────────────────────────
+
+export function getKnownApps(): readonly string[] {
+  return Object.keys(KNOWN_APPS)
+}

package/src/workflows.ts

@@ -0,0 +1,197 @@
+/**
+ * Workflow automation — named sequences of Windows actions.
+ * E.g. "iniciar-dia" opens Outlook + Teams + Excel.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { openApp, getKnownApps } from './windows'
+import { IS_WINDOWS } from './platform'
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface WorkflowStep {
+  action: 'open_app' | 'open_url' | 'run_command' | 'wait'
+  target: string       // app name, URL, command, or seconds
+}
+
+export interface Workflow {
+  name: string
+  description: string
+  steps: WorkflowStep[]
+}
+
+// ─── Storage ────────────────────────────────────────────────
+
+let _dataDir = ''
+let _workflows: Workflow[] = []
+
+const DATA_FILE = () => join(_dataDir, 'workflows.json')
+
+function save(): void {
+  writeFileSync(DATA_FILE(), JSON.stringify(_workflows, null, 2))
+}
+
+function load(): void {
+  const file = DATA_FILE()
+  if (!existsSync(file)) {
+    // Seed with default workflows
+    _workflows = DEFAULT_WORKFLOWS
+    save()
+    return
+  }
+  try { _workflows = JSON.parse(readFileSync(file, 'utf-8')) }
+  catch { _workflows = DEFAULT_WORKFLOWS; save() }
+}
+
+// ─── Defaults ───────────────────────────────────────────────
+
+const DEFAULT_WORKFLOWS: Workflow[] = [
+  {
+    name: 'iniciar-dia',
+    description: 'Abrir terminal e Postman',
+    steps: [
+      { action: 'open_app', target: 'terminal' },
+      { action: 'wait', target: '2' },
+      { action: 'open_app', target: 'postman' },
+    ],
+  },
+  {
+    name: 'dev',
+    description: 'Abrir ambiente de desenvolvimento: VSCode e Terminal',
+    steps: [
+      { action: 'open_app', target: 'vscode' },
+      { action: 'wait', target: '1' },
+      { action: 'open_app', target: 'terminal' },
+    ],
+  },
+]
+
+// ─── Init ───────────────────────────────────────────────────
+
+export function initWorkflows(dataDir: string): void {
+  _dataDir = dataDir
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true })
+  load()
+}
+
+// ─── Operations ─────────────────────────────────────────────
+
+export function getWorkflow(name: string): Workflow | null {
+  return _workflows.find((w) => w.name.toLowerCase() === name.toLowerCase()) || null
+}
+
+export function listWorkflows(): Workflow[] {
+  return [..._workflows]
+}
+
+export function createWorkflow(name: string, description: string, steps: WorkflowStep[]): Workflow {
+  // Remove existing with same name
+  _workflows = _workflows.filter((w) => w.name.toLowerCase() !== name.toLowerCase())
+  const workflow: Workflow = { name: name.toLowerCase(), description, steps }
+  _workflows = [..._workflows, workflow]
+  save()
+  return workflow
+}
+
+export function deleteWorkflow(name: string): boolean {
+  const before = _workflows.length
+  _workflows = _workflows.filter((w) => w.name.toLowerCase() !== name.toLowerCase())
+  if (_workflows.length === before) return false
+  save()
+  return true
+}
+
+/**
+ * Execute a workflow step by step.
+ * Returns a log of what was done.
+ */
+export async function runWorkflow(
+  name: string,
+  onStep?: (msg: string) => void,
+): Promise<string> {
+  const workflow = getWorkflow(name)
+  if (!workflow) {
+    const available = _workflows.map((w) => w.name).join(', ')
+    return `Workflow nao encontrado: "${name}". Disponiveis: ${available}`
+  }
+
+  if (!IS_WINDOWS) {
+    return 'Error: workflows are only available on Windows.'
+  }
+
+  const log: string[] = [`Executando workflow: "${workflow.name}" — ${workflow.description}`]
+
+  for (let i = 0; i < workflow.steps.length; i++) {
+    const step = workflow.steps[i]
+
+    switch (step.action) {
+      case 'open_app': {
+        onStep?.(`[${i + 1}/${workflow.steps.length}] Abrindo ${step.target}...`)
+        const result = await openApp(step.target)
+        log.push(`  ${i + 1}. ${result}`)
+        break
+      }
+
+      case 'open_url': {
+        onStep?.(`[${i + 1}/${workflow.steps.length}] Abrindo ${step.target}...`)
+        // Reuse openApp with 'edge' or just use Start-Process
+        const proc = Bun.spawn(
+          ['powershell', '-NoProfile', '-NonInteractive', '-Command', `Start-Process '${step.target}'`],
+          { stdout: 'pipe', stderr: 'pipe' },
+        )
+        const timer = setTimeout(() => proc.kill(), 10_000)
+        await Promise.all([
+          new Response(proc.stdout).text(),
+          new Response(proc.stderr).text(),
+        ])
+        await proc.exited
+        clearTimeout(timer)
+        log.push(`  ${i + 1}. Opened: ${step.target}`)
+        break
+      }
+
+      case 'run_command': {
+        onStep?.(`[${i + 1}/${workflow.steps.length}] Executando: ${step.target}...`)
+        const proc = Bun.spawn(
+          ['powershell', '-NoProfile', '-NonInteractive', '-Command', step.target],
+          { stdout: 'pipe', stderr: 'pipe' },
+        )
+        const timer = setTimeout(() => proc.kill(), 30_000)
+        const [stdout] = await Promise.all([
+          new Response(proc.stdout).text(),
+          new Response(proc.stderr).text(),
+        ])
+        await proc.exited
+        clearTimeout(timer)
+        const preview = stdout.trim().slice(0, 100)
+        log.push(`  ${i + 1}. Command: ${step.target}${preview ? ' -> ' + preview : ''}`)
+        break
+      }
+
+      case 'wait': {
+        const secs = parseInt(step.target) || 1
+        onStep?.(`[${i + 1}/${workflow.steps.length}] Aguardando ${secs}s...`)
+        await new Promise((r) => setTimeout(r, secs * 1000))
+        log.push(`  ${i + 1}. Wait: ${secs}s`)
+        break
+      }
+    }
+  }
+
+  log.push(`\nWorkflow "${workflow.name}" concluido.`)
+  return log.join('\n')
+}
+
+// ─── Formatting ─────────────────────────────────────────────
+
+export function formatWorkflowList(): string {
+  if (_workflows.length === 0) return 'Nenhum workflow configurado.'
+
+  const lines = _workflows.map((w) => {
+    const steps = w.steps.map((s) => `${s.action}:${s.target}`).join(' -> ')
+    return `  ${w.name.padEnd(15)} ${w.description}\n${' '.repeat(17)}${steps}`
+  })
+
+  return `Workflows (${_workflows.length}):\n${lines.join('\n\n')}`
+}

package/tests/ansi.test.ts

@@ -0,0 +1,58 @@
+import { describe, test, expect } from 'bun:test'
+import { stripAnsi, visibleLength, charWidth, displayWidth } from '../src/ansi'
+
+describe('stripAnsi', () => {
+  test('strips ANSI escape codes', () => {
+    expect(stripAnsi('\x1b[1mBold\x1b[0m')).toBe('Bold')
+    expect(stripAnsi('\x1b[38;5;75mColored\x1b[0m')).toBe('Colored')
+  })
+
+  test('passes plain text through', () => {
+    expect(stripAnsi('Hello world')).toBe('Hello world')
+  })
+})
+
+describe('charWidth', () => {
+  test('ASCII is width 1', () => {
+    expect(charWidth('a')).toBe(1)
+    expect(charWidth(' ')).toBe(1)
+    expect(charWidth('Z')).toBe(1)
+  })
+
+  test('CJK characters are width 2', () => {
+    expect(charWidth('\u4e2d')).toBe(2) // 中
+    expect(charWidth('\u65e5')).toBe(2) // 日
+  })
+
+  test('fullwidth characters are width 2', () => {
+    expect(charWidth('\uff01')).toBe(2) // ！
+  })
+})
+
+describe('visibleLength', () => {
+  test('ASCII string', () => {
+    expect(visibleLength('Hello')).toBe(5)
+  })
+
+  test('ANSI codes do not count', () => {
+    expect(visibleLength('\x1b[1mBold\x1b[0m')).toBe(4)
+  })
+
+  test('CJK characters count as 2', () => {
+    expect(visibleLength('\u4e2d\u6587')).toBe(4) // 中文 = 4 columns
+  })
+})
+
+describe('displayWidth', () => {
+  test('counts width of first N chars', () => {
+    expect(displayWidth('Hello', 3)).toBe(3)
+  })
+
+  test('handles CJK', () => {
+    expect(displayWidth('\u4e2d\u6587abc', 2)).toBe(4) // 2 CJK chars = 4 cols
+  })
+
+  test('handles mixed', () => {
+    expect(displayWidth('a\u4e2db', 2)).toBe(3) // 'a' + '中' = 1 + 2 = 3
+  })
+})