picocode-core 0.9.119

package/src/conversation-search.js

@@ -0,0 +1,101 @@
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function visibleLines(text, limit) {
+  return String(text).split('\n').slice(0, limit).join('\n')
+}
+
+export function matchOffsets(text, query) {
+  if (!query) return []
+  const matches = []
+  const pattern = new RegExp(escapeRegex(query), 'gi')
+  let match
+  while ((match = pattern.exec(String(text))) !== null) matches.push(match.index)
+  return matches
+}
+
+export function highlightMatches(text, query, currentIndex = -1, startIndex = 0) {
+  if (!query) return text
+  const pattern = new RegExp(escapeRegex(query), 'gi')
+  const parts = String(text).split(/(\x1b\[[0-9;]*m)/)
+  let index = startIndex
+  return parts.map((part) => {
+    if (part.startsWith('\x1b[')) return part
+    return part.replace(pattern, (match) => {
+      const current = index++ === currentIndex
+      return current
+        ? `\x1b[7;33m${match}\x1b[27;39m`
+        : `\x1b[7m${match}\x1b[27m`
+    })
+  }).join('')
+}
+
+function searchableFields(item, verbose) {
+  if (item.kind === 'tool-group') return item.tools.flatMap((tool) => searchableFields(tool, verbose))
+  if (item.kind === 'agent-notice-group') {
+    return verbose ? item.notices.map((notice, index) => ({ field: 'text', text: notice.text, lineOffset: 3 + index })) : []
+  }
+  if (item.kind === 'thoughts') {
+    return verbose && item.text ? [{ field: 'text', text: visibleLines(item.text, 300), lineOffset: 3 }] : []
+  }
+  if (item.kind === 'summary') {
+    const fields = [{ field: 'text', text: visibleLines(item.text, verbose ? 500 : 0), lineOffset: 3 }]
+    return verbose ? fields : []
+  }
+  if (item.kind === 'tool') {
+    const fields = [{ field: 'title', text: item.title || item.name || '', lineOffset: 1 }]
+    if (verbose && item.fullOutput) fields.push({ field: 'fullOutput', text: visibleLines(item.fullOutput, 200), lineOffset: 4 })
+    return fields
+  }
+  return item.text ? [{ field: 'text', text: item.text, lineOffset: 1 }] : []
+}
+
+export function conversationMatches(items, query, verbose = false) {
+  const matches = []
+  items.forEach((item, itemIndex) => {
+    searchableFields(item, verbose).forEach(({ field, text, lineOffset }, fieldIndex) => {
+      matchOffsets(text, query).forEach((offset, occurrenceIndex) => {
+        const line = lineOffset + String(text).slice(0, offset).split('\n').length - 1
+        matches.push({ itemIndex, field, fieldIndex, offset, line, occurrenceIndex })
+      })
+    })
+  })
+  return matches
+}
+
+export function highlightConversation(items, query, currentIndex, verbose = false) {
+  let startIndex = 0
+  function decorate(item) {
+    if (item.kind === 'tool-group') return { ...item, tools: item.tools.map(decorate) }
+    if (item.kind === 'agent-notice-group') {
+      if (!verbose) return item
+      return { ...item, notices: item.notices.map(decorate) }
+    }
+    if (item.kind === 'thoughts' && !verbose) return item
+    if (item.kind === 'summary' && !verbose) return item
+    if (item.kind === 'tool') {
+      const decorated = { ...item }
+      const title = item.title || item.name || ''
+      const titleCount = matchOffsets(title, query).length
+      decorated.title = highlightMatches(title, query, currentIndex, startIndex)
+      startIndex += titleCount
+      if (verbose && item.fullOutput) {
+        const visibleOutput = visibleLines(item.fullOutput, 200)
+        const outputCount = matchOffsets(visibleOutput, query).length
+        decorated.fullOutput = highlightMatches(item.fullOutput, query, currentIndex, startIndex)
+        startIndex += outputCount
+      }
+      return decorated
+    }
+    if (!item.text) return item
+    const visibleText = item.kind === 'thoughts' ? visibleLines(item.text, 300)
+      : item.kind === 'summary' ? visibleLines(item.text, 500)
+        : item.text
+    const count = matchOffsets(visibleText, query).length
+    const decorated = { ...item, text: highlightMatches(item.text, query, currentIndex, startIndex) }
+    startIndex += count
+    return decorated
+  }
+  return items.map(decorate)
+}

package/src/deliberation-history.js

@@ -0,0 +1,65 @@
+export function deliberationsFromEvents(events) {
+  const byId = new Map()
+
+  for (const event of events) {
+    const data = event.data || {}
+    const id = data.deliberationId
+    if (!id) continue
+
+    if (event.type === 'deliberation_dismiss') {
+      byId.delete(id)
+      continue
+    }
+
+    if (event.type === 'deliberation_start') {
+      byId.set(id, {
+        id: `deliberation-${id}`,
+        deliberationId: id,
+        role: 'deliberation',
+        description: data.brief,
+        prompt: data.brief,
+        model: data.model,
+        rounds: data.rounds,
+        status: 'running',
+        startedAt: event.at,
+        updatedAt: event.at,
+        events: [],
+        turns: [],
+        timeline: [],
+      })
+      continue
+    }
+
+    const item = byId.get(id)
+    if (!item) continue
+    item.updatedAt = event.at
+
+    if (event.type === 'deliberation_event') {
+      const recorded = { ...data.event, role: data.role, round: data.round, at: event.at }
+      item.events.push(recorded)
+      item.timeline.push({ kind: 'event', value: recorded })
+    } else if (event.type === 'deliberation_turn') {
+      const turn = { role: data.role, round: data.round, text: data.text }
+      item.turns.push(turn)
+      item.timeline.push({ kind: 'turn', value: turn })
+      item.usage = mergeUsage(item.usage, data.usage)
+    } else if (event.type === 'deliberation_result') {
+      item.result = data.result
+      item.error = data.error
+      item.usage = mergeUsage(item.usage, data.usage)
+      item.status = data.error ? 'failed' : data.interrupted ? 'cancelled' : 'completed'
+      item.endedAt = event.at
+    }
+  }
+
+  return [...byId.values()].sort((a, b) => Number(b.deliberationId) - Number(a.deliberationId))
+}
+
+function mergeUsage(current = {}, next = {}) {
+  if (!next) return current
+  return {
+    promptTokens: (current.promptTokens || 0) + (next.promptTokens || 0),
+    completionTokens: (current.completionTokens || 0) + (next.completionTokens || 0),
+    totalTokens: (current.totalTokens || 0) + (next.totalTokens || 0),
+  }
+}

package/src/deliberation.js

@@ -0,0 +1,61 @@
+import { resultText } from './agents.js'
+
+export const DEFAULT_DELIBERATION_ROUNDS = 3
+export const MAX_DELIBERATION_ROUNDS = 5
+
+export function validateDeliberation({ brief, rounds = DEFAULT_DELIBERATION_ROUNDS } = {}) {
+  if (!brief?.trim()) throw new Error('deliberation brief is required')
+  if (!Number.isInteger(rounds) || rounds < 1 || rounds > MAX_DELIBERATION_ROUNDS) {
+    throw new Error(`deliberation rounds must be between 1 and ${MAX_DELIBERATION_ROUNDS}`)
+  }
+  return { brief: brief.trim(), rounds }
+}
+
+function participantPrompt(brief, role, rounds) {
+  return `You are the ${role} in a ${rounds}-round deliberation about the following decision:\n\n${brief}\n\nResearch before making claims. Use the available project and web tools whenever they can replace assumption with evidence. Cite URLs and project paths in your response. Challenge weak premises and address the peer's strongest points. Do not seek agreement for its own sake or defend a fixed position. Change your position only when evidence warrants it, and preserve material disagreement and uncertainty. Do not modify project files. Return a concise message addressed to the other participant.`
+}
+
+function peerMessage(role, text, round, rounds) {
+  return `Round ${round} of ${rounds}. The ${role} replied:\n\n${text}\n\nResearch and respond to the substance of this message.`
+}
+
+function synthesisPrompt(brief, turns) {
+  const transcript = turns.map((turn) => `Round ${turn.round}, ${turn.role}:\n${turn.text}`).join('\n\n')
+  return `Synthesize this deliberation into a decision for the main agent. State the recommendation, decisive evidence, unresolved uncertainty, material disagreement, and implementation constraints. Do not manufacture consensus: preserve disagreements that the evidence did not resolve. Preserve useful URLs and project paths. Do not mention the deliberation process unless disagreement remains.\n\nDecision brief:\n${brief}\n\nTranscript:\n${transcript}`
+}
+
+export async function runDeliberation({ brief, rounds, runParticipant, runSynthesis, onEvent = () => {}, signal }) {
+  const valid = validateDeliberation({ brief, rounds })
+  const participants = {
+    proposer: [{ role: 'user', content: participantPrompt(valid.brief, 'proposer', valid.rounds) }],
+    reviewer: [{ role: 'user', content: participantPrompt(valid.brief, 'reviewer', valid.rounds) }],
+  }
+  const turns = []
+  let peer = null
+
+  for (let round = 1; round <= valid.rounds; round++) {
+    for (const role of ['proposer', 'reviewer']) {
+      if (signal?.aborted) return { turns, interrupted: true }
+      const history = participants[role]
+      if (peer) history.push({ role: 'user', content: peerMessage(peer.role, peer.text, round, valid.rounds) })
+      const result = await runParticipant({ role, round, rounds: valid.rounds, history: [...history], signal })
+      history.push(...(result.messages || []))
+      const text = resultText(result.messages)
+      if (result.error) return { turns, interrupted: true, error: result.error }
+      if (result.interrupted || !text) return { turns, interrupted: true, error: text ? null : 'deliberation participant returned no response' }
+      const turn = { role, round, text, messages: result.messages || [], usage: result.usage || null }
+      turns.push(turn)
+      peer = turn
+      onEvent({ type: 'deliberation_turn', ...turn })
+    }
+  }
+
+  const synthesis = await runSynthesis({ history: [{ role: 'user', content: synthesisPrompt(valid.brief, turns) }], signal })
+  return {
+    turns,
+    result: resultText(synthesis.messages),
+    usage: synthesis.usage || null,
+    interrupted: !!synthesis.interrupted,
+    error: synthesis.error || null,
+  }
+}

package/src/derive.js

@@ -0,0 +1,307 @@
+import { continuationMessage } from './compaction.js'
+import { applySteering } from './steer.js'
+
+const DROPPING_MODES = ['both', 'chat', 'summary']
+
+// context editing: a large tool result keeps getting re-sent with every
+// request long after the model has used it. once the conversation has moved
+// on (two user turns past it), the body is replaced with a short note in the
+// model's view only; the transcript and the jsonl keep the real thing, and
+// the model can re-run the tool if it truly needs the data again
+const ELIDE_MIN_CHARS = 4000
+const ELIDE_AFTER_USER_TURNS = 2
+
+function elideStaleToolResults(history) {
+  const userIndexes = []
+  history.forEach((message, i) => {
+    if (message.role === 'user') userIndexes.push(i)
+  })
+  const cutoff = userIndexes.at(-ELIDE_AFTER_USER_TURNS)
+  if (cutoff === undefined) return history
+  return history.map((message, i) => {
+    if (i >= cutoff || message.role !== 'tool') return message
+    const content = String(message.content ?? '')
+    if (content.length < ELIDE_MIN_CHARS) return message
+    return {
+      ...message,
+      content: `[tool result elided to save context: ${content.length.toLocaleString()} chars. re-run the tool if this is needed again]`,
+    }
+  })
+}
+
+function activeRewinds(events) {
+  const canceled = new Set()
+  for (const e of events) {
+    if (e.type === 'rewind_undo') canceled.add(e.data.rewindId)
+  }
+  return events.filter((e) => e.type === 'rewind' && !canceled.has(e.id))
+}
+
+function droppedIds(events) {
+  const dropped = new Set()
+  const index = new Map(events.map((e, i) => [e.id, i]))
+  for (const rewind of activeRewinds(events)) {
+    if (!DROPPING_MODES.includes(rewind.data.mode)) continue
+    const from = index.get(rewind.data.target)
+    const to = index.get(rewind.id)
+    if (from === undefined || to === undefined) continue
+    for (let i = from; i < to; i++) dropped.add(events[i].id)
+  }
+  return dropped
+}
+
+function addUsageInto(total, usage) {
+  total.promptTokens += usage.promptTokens || 0
+  total.completionTokens += usage.completionTokens || 0
+  total.totalTokens += usage.totalTokens || 0
+  total.cachedTokens += usage.cachedTokens || 0
+  total.thoughtTokens += usage.thoughtTokens || 0
+}
+
+function emptyUsage() {
+  return { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0, thoughtTokens: 0 }
+}
+
+function parseArgs(raw) {
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return { _raw: raw }
+  }
+}
+
+function pushHistory(state, message, eventId) {
+  state.providerHistory.push(message)
+  state.historyEventIds.push(eventId)
+}
+
+function foldMessage(state, event) {
+  const message = event.data.message
+  if (!message) return
+  pushHistory(state, message, event.id)
+  if (event.data.hideFromTranscript) {
+    for (const call of message.tool_calls || []) {
+      state.toolItems.set(call.id, { kind: 'tool', callId: call.id, status: 'done', hidden: true })
+    }
+    return
+  }
+  const base = {
+    messageId: event.id,
+    eventId: event.id,
+    role: message.role,
+    locked: event._sourceIndex < state.latestCompactIndex,
+    steered: !!event._steered,
+  }
+
+  if (message.role === 'system' || message.role === 'developer') {
+    state.transcript.push({ ...base, kind: message.role, text: String(message.content ?? '') })
+    return
+  }
+  if (message.role === 'user') {
+    const text = Array.isArray(message.content)
+      ? message.content
+          .map((p) => (p.type === 'text' ? p.text : `[image: ${String(p.source?.path || '').split('/').pop() || 'attached'}]`))
+          .join('')
+      : String(message.content)
+    state.transcript.push({ ...base, kind: 'user', text, content: message.content })
+    return
+  }
+  if (message.role === 'assistant') {
+    if (message.content) {
+      state.transcript.push({ ...base, kind: 'assistant', text: message.content, model: state.model })
+    }
+    for (const call of message.tool_calls || []) {
+      const item = {
+        kind: 'tool',
+        callId: call.id,
+        name: call.function.name,
+        args: parseArgs(call.function.arguments),
+        title: call.function.name,
+        status: 'done',
+        eventId: event.id,
+      }
+      state.transcript.push(item)
+      state.toolItems.set(call.id, item)
+    }
+    return
+  }
+  if (message.role === 'tool') {
+    const item = state.toolItems.get(message.tool_call_id)
+    if (item) item.resultText = String(message.content)
+  }
+}
+
+function foldRewind(state, event) {
+  const { mode, summaryText, reverted = [] } = event.data
+  for (const callId of reverted) {
+    const item = state.toolItems.get(callId)
+    if (item) item.status = 'reverted'
+  }
+  if (mode === 'summary' && summaryText) {
+    state.transcript.push({ kind: 'summary', source: 'rewind', text: summaryText })
+    pushHistory(state, {
+      role: 'assistant',
+      content: `[summary of the rewound conversation]\n${summaryText}`,
+    }, event.id)
+  }
+}
+
+export function deriveState(events) {
+  const effectiveEvents = applySteering(events)
+  const dropped = droppedIds(effectiveEvents)
+  const latestCompactIndex = effectiveEvents.reduce((latest, event) => event.type === 'clear' ? -1 : event.type === 'compact' ? events.indexOf(event) : latest, -1)
+  const canceledUndoTargets = new Set(
+    events.filter((e) => e.type === 'rewind_undo').map((e) => e.data.rewindId),
+  )
+
+  const spentUsage = emptyUsage()
+  const spentUsageByModel = {}
+  for (const event of events) {
+    if (event.type !== 'usage') continue
+    addUsageInto(spentUsage, event.data.usage)
+    addUsageInto((spentUsageByModel[event.data.model] ||= emptyUsage()), event.data.usage)
+  }
+
+  const state = {
+    transcript: [],
+    providerHistory: [],
+    historyEventIds: [],
+    model: null,
+    effort: undefined,
+    usage: spentUsage,
+    usageByModel: spentUsageByModel,
+    usageActive: emptyUsage(),
+    usageActiveByModel: {},
+    lastPromptTokens: 0,
+    lastPromptModel: null,
+    loadedContext: new Set(),
+    toolItems: new Map(),
+    latestCompactIndex,
+  }
+
+  for (const event of effectiveEvents) {
+    if (event.type === 'usage') {
+      if (!dropped.has(event.id)) {
+        addUsageInto(state.usageActive, event.data.usage)
+        const activeByModel = (state.usageActiveByModel[event.data.model] ||= emptyUsage())
+        addUsageInto(activeByModel, event.data.usage)
+        // only events that recorded the final request's size can drive the
+        // context meter; older cumulative-only events would overstate it
+        if (event.data.lastPrompt !== undefined) {
+          state.lastPromptTokens = event.data.lastPrompt
+          state.lastPromptModel = event.data.model
+        }
+      }
+      continue
+    }
+    if (dropped.has(event.id)) continue
+
+    switch (event.type) {
+      case 'message':
+        foldMessage(state, event)
+        break
+      case 'turn_transcript':
+        for (const item of event.data.items || []) {
+          const restored = { ...item, eventId: event.id }
+          state.transcript.push(restored)
+          if (restored.kind === 'tool' && restored.callId) state.toolItems.set(restored.callId, restored)
+        }
+        break
+      case 'tool_meta': {
+        const item = state.toolItems.get(event.data.callId)
+        if (item) Object.assign(item, event.data, { kind: 'tool', callId: item.callId })
+        break
+      }
+      case 'interrupt': {
+        const last = state.transcript.at(-1)
+        if (last?.kind === 'assistant') last.interrupted = true
+        if (last?.kind === 'tool' && last.status === 'running') last.status = 'interrupted'
+        break
+      }
+      case 'model_switch':
+        state.model = event.data.to
+        break
+      case 'effort':
+        state.effort = event.data.to
+        break
+      case 'title':
+        state.title = event.data.text
+        break
+      case 'color':
+        state.color = event.data.value
+        break
+      case 'rewind':
+        if (!canceledUndoTargets.has(event.id)) foldRewind(state, event)
+        break
+      case 'compact': {
+        const { summary, keepFrom, sessionFile } = event.data
+        if (keepFrom !== undefined || sessionFile) {
+          const idx = keepFrom ? state.historyEventIds.indexOf(keepFrom) : -1
+          const kept = idx >= 0 ? state.providerHistory.slice(idx) : []
+          const keptIds = idx >= 0 ? state.historyEventIds.slice(idx) : []
+          state.providerHistory = [
+            { role: 'user', content: continuationMessage(summary, { sessionFile, recentKept: kept.length > 0 }) },
+            ...kept,
+          ]
+          state.historyEventIds = [null, ...keptIds]
+        } else {
+          state.providerHistory = [
+            { role: 'user', content: `[conversation summary]\n${summary}` },
+            { role: 'assistant', content: 'Got it. Continuing from that summary.' },
+          ]
+          state.historyEventIds = [null, null]
+        }
+        state.transcript.push({ kind: 'summary', source: 'compact', text: summary })
+        state.lastPromptTokens = 0
+        break
+      }
+      case 'clear':
+        state.transcript = []
+        state.providerHistory = []
+        state.historyEventIds = []
+        state.toolItems = new Map()
+        state.lastPromptTokens = 0
+        break
+      case 'context_file':
+        state.loadedContext.add(event.data.path)
+        break
+      case 'skill':
+        state.transcript.push({ kind: 'skill', name: event.data.name })
+        break
+      case 'thoughts':
+        state.transcript.push({ kind: 'thoughts', text: event.data.text })
+        break
+      case 'shell_note':
+      case 'system_note': {
+        pushHistory(state, { role: 'user', content: event.data.text }, event.id)
+        const lines = event.data.text.split('\n').filter(Boolean)
+        const agentCompletions = lines.filter((line) => /^Agent \d+ \(.+\) finished with status /.test(line))
+        if (agentCompletions.length) {
+          for (const text of agentCompletions) state.transcript.push({ kind: 'notice', text, agentCompletion: true })
+        } else {
+          state.transcript.push({ kind: 'notice', text: lines[0] || '' })
+        }
+        break
+      }
+    }
+  }
+
+  state.providerHistory = elideStaleToolResults(state.providerHistory)
+  return state
+}
+
+export function userEntries(state) {
+  const entries = []
+  state.transcript.forEach((item, index) => {
+    if (item.kind === 'user') entries.push({ text: item.text, content: item.content, index, eventId: item.eventId })
+  })
+  return entries
+}
+
+export function rewindStats(state, index) {
+  const tail = state.transcript.slice(index)
+  return {
+    msgs: tail.length,
+    edits: tail.filter((m) => m.kind === 'tool' && m.revert && m.status !== 'reverted'),
+  }
+}

package/src/events.js

@@ -0,0 +1,54 @@
+import { randomUUID } from 'node:crypto'
+import { createReadStream } from 'node:fs'
+import { createInterface } from 'node:readline'
+
+export const SESSION_VERSION = 1
+
+export function makeEvent(type, data = {}) {
+  return { id: randomUUID(), at: Date.now(), type, data }
+}
+
+export function makeHeader({ cwd, root, forkedFrom }) {
+  return {
+    type: 'session',
+    version: SESSION_VERSION,
+    id: randomUUID(),
+    cwd,
+    root,
+    createdAt: Date.now(),
+    ...(forkedFrom ? { forkedFrom } : {}),
+  }
+}
+
+export function serializeLine(event) {
+  return JSON.stringify(event) + '\n'
+}
+
+export function parseLine(line) {
+  const trimmed = line.trim()
+  if (!trimmed) return null
+  try {
+    const parsed = JSON.parse(trimmed)
+    return parsed && typeof parsed.type === 'string' ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+export function parseLines(text) {
+  return text.split('\n').map(parseLine).filter(Boolean)
+}
+
+export async function* streamEvents(file) {
+  const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity })
+  for await (const line of lines) {
+    const event = parseLine(line)
+    if (event) yield event
+  }
+}
+
+export async function readEvents(file) {
+  const events = []
+  for await (const event of streamEvents(file)) events.push(event)
+  return events
+}

package/src/export.js

@@ -0,0 +1,16 @@
+export function transcriptToMarkdown(transcript, { title = 'pico session' } = {}) {
+  const parts = [`# ${title}`, '']
+  for (const item of transcript) {
+    if (item.kind === 'user') {
+      parts.push('## You', '', item.text, '')
+    } else if (item.kind === 'assistant') {
+      parts.push(item.interrupted ? `${item.text}\n\n*(interrupted)*` : item.text, '')
+    } else if (item.kind === 'tool') {
+      const label = item.diff ? ` (+${item.diff.additions} -${item.diff.deletions})` : ''
+      parts.push(`> ${item.status === 'reverted' ? '↩' : '✓'} \`${item.name}\` ${item.title}${label}`, '')
+    } else if (item.kind === 'summary') {
+      parts.push(`> summary: ${item.text}`, '')
+    }
+  }
+  return parts.join('\n')
+}

package/src/files.js

@@ -0,0 +1,39 @@
+import { execFile } from 'node:child_process'
+import fg from 'fast-glob'
+
+const MAX_FILES = 5000
+const TTL = 5000
+
+let cached = { at: 0, cwd: null, files: [] }
+const pending = new Map()
+
+function ripgrepFiles(cwd) {
+  return new Promise((resolve) => {
+    const args = ['--files', '--hidden', '--glob', '!**/.git/**', '--sortr=modified']
+    execFile('rg', args, { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, stdout) => {
+      resolve(err && !stdout ? null : stdout.split('\n').filter(Boolean))
+    })
+  })
+}
+
+export function listFiles(cwd) {
+  if (cached.cwd === cwd && Date.now() - cached.at < TTL) return Promise.resolve(cached.files)
+  if (pending.has(cwd)) return pending.get(cwd)
+
+  const request = (async () => {
+    let files = await ripgrepFiles(cwd)
+    if (!files) {
+      files = await fg('**/*', {
+        cwd,
+        onlyFiles: true,
+        dot: true,
+        ignore: ['**/node_modules/**', '**/.git/**'],
+      }).catch(() => [])
+    }
+    cached = { at: Date.now(), cwd, files: files.slice(0, MAX_FILES) }
+    return cached.files
+  })().finally(() => pending.delete(cwd))
+
+  pending.set(cwd, request)
+  return request
+}

package/src/format.js

@@ -0,0 +1,6 @@
+export function compactNumber(value) {
+  const n = Math.round(value)
+  if (Math.abs(n) >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}m`
+  if (Math.abs(n) >= 1_000) return `${(n / 1_000).toFixed(1)}k`
+  return String(n)
+}