perf(agent-status): scan Command Code transcripts backward from EOF (#10742)
Co-authored-by: Orca <help@stably.ai>
This commit is contained in:
Neil
GitHub
parent
6b16c20796
commit
4109f4eec5
|
|
@ -0,0 +1,427 @@
|
|||
#!/usr/bin/env node
|
||||
// Benchmark: cost of resolving a Command Code turn prompt from the transcript,
|
||||
// paid on EVERY command-code hook event (PreToolUse/PostToolUse fire once per
|
||||
// tool call, so many per second during an active agent turn).
|
||||
//
|
||||
// Before the fix, readLastCommandCodeUserPromptEntryFromTranscript() read up to
|
||||
// TRANSCRIPT_MAX_SCAN_BYTES (4 MB) synchronously, decoded it all to a JS string,
|
||||
// and JSON-parsed EVERY line to the end of the buffer to find the LAST user
|
||||
// entry — so cost grew with the transcript, which only grows as a session runs.
|
||||
//
|
||||
// The fix scans backward from EOF in TRANSCRIPT_CHUNK_BYTES blocks and returns
|
||||
// on the first user line, the shape the sibling readLastTextFromTranscriptOnce
|
||||
// already used. The answer sits near EOF in a real session (the current turn's
|
||||
// prompt precedes only this turn's output), so the scan reads one or two blocks
|
||||
// instead of the whole file.
|
||||
//
|
||||
// Both implementations are mirrored here: node cannot import the .ts source,
|
||||
// matching the other benchmarks in this directory. Constants are re-read from
|
||||
// the real module so a drifted cap fails loudly instead of measuring dead code.
|
||||
import {
|
||||
closeSync,
|
||||
mkdtempSync,
|
||||
openSync,
|
||||
readFileSync,
|
||||
readSync,
|
||||
rmSync,
|
||||
statSync,
|
||||
writeFileSync
|
||||
} from 'node:fs'
|
||||
import { tmpdir } from 'node:os'
|
||||
import { join } from 'node:path'
|
||||
import { performance } from 'node:perf_hooks'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
|
||||
const LISTENER_SOURCE = readFileSync(
|
||||
fileURLToPath(new URL('../../src/shared/agent-hook-listener.ts', import.meta.url)),
|
||||
'utf8'
|
||||
)
|
||||
|
||||
function readMirroredConstant(name) {
|
||||
const match = LISTENER_SOURCE.match(new RegExp(`const ${name} = ([^\\n]+)`))
|
||||
if (!match) {
|
||||
throw new Error(`agent-hook-listener.ts no longer defines ${name}; re-sync this benchmark.`)
|
||||
}
|
||||
const value = Number(new Function(`return (${match[1]})`)())
|
||||
if (!Number.isInteger(value) || value <= 0) {
|
||||
throw new Error(`${name} did not resolve to a positive integer`)
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
const TRANSCRIPT_CHUNK_BYTES = readMirroredConstant('TRANSCRIPT_CHUNK_BYTES')
|
||||
const TRANSCRIPT_MAX_SCAN_BYTES = readMirroredConstant('TRANSCRIPT_MAX_SCAN_BYTES')
|
||||
const EMPTY_REGION = Buffer.alloc(0)
|
||||
const ITERATIONS = Number.parseInt(process.env.ORCA_CC_SCAN_BENCH_ITERATIONS ?? '150', 10)
|
||||
const WARMUP = Number.parseInt(process.env.ORCA_CC_SCAN_BENCH_WARMUP ?? '20', 10)
|
||||
|
||||
for (const [name, value] of [
|
||||
['ORCA_CC_SCAN_BENCH_ITERATIONS', ITERATIONS],
|
||||
['ORCA_CC_SCAN_BENCH_WARMUP', WARMUP]
|
||||
]) {
|
||||
if (!Number.isInteger(value) || value <= 0) {
|
||||
throw new Error(`${name} must be a positive integer, received ${value}`)
|
||||
}
|
||||
}
|
||||
|
||||
// Mirror of parseAgentHookJson: the real reader scans a line's structure before
|
||||
// parsing it, on BOTH sides of this comparison. Omitting it made the pre-fix
|
||||
// column ~9x too fast and invented a regression that does not exist.
|
||||
const HOOK_STRUCTURAL_TOKENS = 128 * 1024
|
||||
const HOOK_NESTING_DEPTH = 64
|
||||
|
||||
function assertJsonStructure(content) {
|
||||
let structuralTokens = 0
|
||||
let depth = 0
|
||||
let inString = false
|
||||
let escaped = false
|
||||
for (let index = 0; index < content.length; index += 1) {
|
||||
const character = content[index]
|
||||
if (inString) {
|
||||
if (escaped) {
|
||||
escaped = false
|
||||
} else if (character === '\\') {
|
||||
escaped = true
|
||||
} else if (character === '"') {
|
||||
inString = false
|
||||
}
|
||||
continue
|
||||
}
|
||||
if (character === '"') {
|
||||
inString = true
|
||||
continue
|
||||
}
|
||||
if (
|
||||
character !== '{' &&
|
||||
character !== '}' &&
|
||||
character !== '[' &&
|
||||
character !== ']' &&
|
||||
character !== ',' &&
|
||||
character !== ':'
|
||||
) {
|
||||
continue
|
||||
}
|
||||
structuralTokens += 1
|
||||
if (structuralTokens > HOOK_STRUCTURAL_TOKENS) {
|
||||
throw new Error('structuralTokens')
|
||||
}
|
||||
if (character === '{' || character === '[') {
|
||||
depth += 1
|
||||
if (depth > HOOK_NESTING_DEPTH) {
|
||||
throw new Error('nestingDepth')
|
||||
}
|
||||
} else if (character === '}' || character === ']') {
|
||||
depth = Math.max(0, depth - 1)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function extractUserPrompt(line) {
|
||||
let entry
|
||||
try {
|
||||
assertJsonStructure(line)
|
||||
entry = JSON.parse(line)
|
||||
} catch {
|
||||
return undefined
|
||||
}
|
||||
if (typeof entry !== 'object' || entry === null || entry.role !== 'user') {
|
||||
return undefined
|
||||
}
|
||||
const content = entry.content
|
||||
if (typeof content === 'string' && content.trim().length > 0) {
|
||||
return content
|
||||
}
|
||||
if (Array.isArray(content)) {
|
||||
for (const part of content) {
|
||||
if (typeof part === 'object' && part !== null) {
|
||||
const text = part.text
|
||||
if (typeof text === 'string' && text.trim().length > 0) {
|
||||
return text
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
// Pre-fix: read the capped window, then parse every line to the end.
|
||||
function readForward(path) {
|
||||
const size = statSync(path).size
|
||||
if (size <= 0) {
|
||||
return undefined
|
||||
}
|
||||
const bytesToRead = Math.min(size, TRANSCRIPT_MAX_SCAN_BYTES)
|
||||
const position = size - bytesToRead
|
||||
const fd = openSync(path, 'r')
|
||||
try {
|
||||
const buffer = Buffer.alloc(bytesToRead)
|
||||
let filled = 0
|
||||
while (filled < bytesToRead) {
|
||||
const n = readSync(fd, buffer, filled, bytesToRead - filled, position + filled)
|
||||
if (n === 0) {
|
||||
break
|
||||
}
|
||||
filled += n
|
||||
}
|
||||
let text = buffer.subarray(0, filled).toString('utf8')
|
||||
if (position > 0) {
|
||||
const firstNewline = text.indexOf('\n')
|
||||
text = firstNewline === -1 ? '' : text.slice(firstNewline + 1)
|
||||
}
|
||||
let last
|
||||
for (const line of text.split('\n')) {
|
||||
const prompt = extractUserPrompt(line.trim())
|
||||
if (prompt !== undefined) {
|
||||
last = prompt
|
||||
}
|
||||
}
|
||||
return last
|
||||
} finally {
|
||||
closeSync(fd)
|
||||
}
|
||||
}
|
||||
|
||||
function findLastPromptInRegion(region) {
|
||||
let lineEnd = region.length
|
||||
for (let index = region.length - 1; index >= -1; index--) {
|
||||
if (index >= 0 && region[index] !== 0x0a) {
|
||||
continue
|
||||
}
|
||||
const lineStart = index + 1
|
||||
if (lineEnd > lineStart) {
|
||||
const prompt = extractUserPrompt(region.subarray(lineStart, lineEnd).toString('utf8').trim())
|
||||
if (prompt !== undefined) {
|
||||
return prompt
|
||||
}
|
||||
}
|
||||
lineEnd = index
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
// Post-fix: walk backward from EOF, return on the first user line. The carry is
|
||||
// a chunk list, not a re-joined buffer, so one oversized line stays linear.
|
||||
function readBackward(path) {
|
||||
const size = statSync(path).size
|
||||
if (size <= 0) {
|
||||
return undefined
|
||||
}
|
||||
const fd = openSync(path, 'r')
|
||||
try {
|
||||
let carryChunks = []
|
||||
let bytesRead = 0
|
||||
let scanEnd = size
|
||||
while (scanEnd > 0 && bytesRead < TRANSCRIPT_MAX_SCAN_BYTES) {
|
||||
const chunkSize = Math.min(
|
||||
scanEnd,
|
||||
TRANSCRIPT_CHUNK_BYTES,
|
||||
TRANSCRIPT_MAX_SCAN_BYTES - bytesRead
|
||||
)
|
||||
const position = scanEnd - chunkSize
|
||||
const buffer = Buffer.alloc(chunkSize)
|
||||
let filled = 0
|
||||
while (filled < chunkSize) {
|
||||
const n = readSync(fd, buffer, filled, chunkSize - filled, position + filled)
|
||||
if (n === 0) {
|
||||
break
|
||||
}
|
||||
filled += n
|
||||
}
|
||||
if (filled < chunkSize) {
|
||||
break
|
||||
}
|
||||
bytesRead += filled
|
||||
scanEnd = position
|
||||
const firstNewline = buffer.indexOf(0x0a)
|
||||
const atStart = position === 0
|
||||
let completeRegion
|
||||
if (atStart) {
|
||||
completeRegion = carryChunks.length === 0 ? buffer : Buffer.concat([buffer, ...carryChunks])
|
||||
carryChunks = []
|
||||
} else if (firstNewline === -1) {
|
||||
completeRegion = EMPTY_REGION
|
||||
carryChunks.unshift(buffer)
|
||||
} else {
|
||||
const afterNewline = buffer.subarray(firstNewline + 1)
|
||||
completeRegion =
|
||||
carryChunks.length === 0 ? afterNewline : Buffer.concat([afterNewline, ...carryChunks])
|
||||
carryChunks = [buffer.subarray(0, firstNewline)]
|
||||
}
|
||||
if (completeRegion.length > 0) {
|
||||
const found = findLastPromptInRegion(completeRegion)
|
||||
if (found !== undefined) {
|
||||
return found
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
} finally {
|
||||
closeSync(fd)
|
||||
}
|
||||
}
|
||||
|
||||
// A real session: many completed turns, then THIS turn's prompt, then the tool
|
||||
// output produced since. The prompt therefore sits near EOF.
|
||||
function writeTranscript(path, priorTurns) {
|
||||
const lines = []
|
||||
for (let index = 0; index < priorTurns; index += 1) {
|
||||
lines.push(
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: `older turn ${index}` }] })
|
||||
)
|
||||
lines.push(
|
||||
JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: `${'assistant output '.repeat(30)}${index}` }]
|
||||
})
|
||||
)
|
||||
}
|
||||
lines.push(
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'the current prompt' }] })
|
||||
)
|
||||
for (let index = 0; index < 40; index += 1) {
|
||||
lines.push(
|
||||
JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: `${'current turn output '.repeat(30)}${index}` }]
|
||||
})
|
||||
)
|
||||
}
|
||||
writeFileSync(path, `${lines.join('\n')}\n`)
|
||||
}
|
||||
|
||||
// A turn already in progress: `trailingBytes` of tool output sits between the
|
||||
// prompt and EOF, which is what the backward scan has to read past.
|
||||
function writeTranscriptWithTrailing(path, priorTurns, trailingBytes) {
|
||||
const lines = []
|
||||
for (let index = 0; index < priorTurns; index += 1) {
|
||||
lines.push(
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: `older turn ${index}` }] })
|
||||
)
|
||||
lines.push(
|
||||
JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: `${'assistant output '.repeat(30)}${index}` }]
|
||||
})
|
||||
)
|
||||
}
|
||||
lines.push(
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'the current prompt' }] })
|
||||
)
|
||||
let written = 0
|
||||
let index = 0
|
||||
while (written < trailingBytes) {
|
||||
const line = JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: `${'current turn output '.repeat(30)}${index}` }]
|
||||
})
|
||||
lines.push(line)
|
||||
written += line.length + 1
|
||||
index += 1
|
||||
}
|
||||
writeFileSync(path, `${lines.join('\n')}\n`)
|
||||
}
|
||||
|
||||
// One tool result larger than many read blocks — the shape with no newline for
|
||||
// the backward scan to stop on.
|
||||
function writeTranscriptWithHugeLine(path, lineBytes) {
|
||||
const lines = [
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'the current prompt' }] }),
|
||||
JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'x'.repeat(lineBytes) }] })
|
||||
]
|
||||
writeFileSync(path, `${lines.join('\n')}\n`)
|
||||
}
|
||||
|
||||
function measure(fn, path) {
|
||||
for (let index = 0; index < WARMUP; index += 1) {
|
||||
fn(path)
|
||||
}
|
||||
const samples = []
|
||||
for (let round = 0; round < 3; round += 1) {
|
||||
const start = performance.now()
|
||||
for (let index = 0; index < ITERATIONS; index += 1) {
|
||||
fn(path)
|
||||
}
|
||||
samples.push((performance.now() - start) / ITERATIONS)
|
||||
}
|
||||
samples.sort((a, b) => a - b)
|
||||
return samples[1]
|
||||
}
|
||||
|
||||
const dir = mkdtempSync(join(tmpdir(), 'orca-cc-transcript-bench-'))
|
||||
try {
|
||||
const rows = []
|
||||
for (const priorTurns of [250, 1000, 3000, 6000]) {
|
||||
const path = join(dir, `transcript-${priorTurns}.jsonl`)
|
||||
writeTranscript(path, priorTurns)
|
||||
const forward = readForward(path)
|
||||
const backward = readBackward(path)
|
||||
if (forward !== backward) {
|
||||
throw new Error(`prompt mismatch at ${priorTurns} prior turns: ${forward} vs ${backward}`)
|
||||
}
|
||||
if (backward !== 'the current prompt') {
|
||||
throw new Error(`benchmark fixture resolved the wrong prompt: ${backward}`)
|
||||
}
|
||||
rows.push({
|
||||
sizeMb: statSync(path).size / (1024 * 1024),
|
||||
beforeMs: measure(readForward, path),
|
||||
afterMs: measure(readBackward, path)
|
||||
})
|
||||
}
|
||||
|
||||
const pad = (value, width) => String(value).padStart(width)
|
||||
console.log('Command Code transcript prompt read, per hook event')
|
||||
console.log(`iterations=${ITERATIONS} warmup=${WARMUP} (median of 3 rounds)`)
|
||||
console.log(
|
||||
`${pad('size', 9)} ${pad('before ms', 11)} ${pad('after ms', 10)} ${pad('speedup', 9)}`
|
||||
)
|
||||
for (const row of rows) {
|
||||
console.log(
|
||||
`${pad(`${row.sizeMb.toFixed(2)} MB`, 9)} ${pad(row.beforeMs.toFixed(3), 11)} ${pad(row.afterMs.toFixed(3), 10)} ${pad(`${(row.beforeMs / row.afterMs).toFixed(0)}x`, 9)}`
|
||||
)
|
||||
}
|
||||
console.log(
|
||||
'\nThe old cost grows with the transcript; the new cost is flat because the\ncurrent turn’s prompt sits near EOF and the scan stops at the first hit.'
|
||||
)
|
||||
|
||||
// Worst cases, reported even where the ratio is below 1x. The new cost scales
|
||||
// with bytes-AFTER the prompt, so a long turn (many tool calls since the ask)
|
||||
// and a single oversized tool result are where the win decays or inverts.
|
||||
const worst = []
|
||||
for (const trailingKb of [32, 256, 1024, 3072]) {
|
||||
const path = join(dir, `trailing-${trailingKb}.jsonl`)
|
||||
writeTranscriptWithTrailing(path, 1500, trailingKb * 1024)
|
||||
if (readForward(path) !== readBackward(path)) {
|
||||
throw new Error(`prompt mismatch at trailing ${trailingKb} KB`)
|
||||
}
|
||||
worst.push({
|
||||
label: `${(trailingKb / 1024).toFixed(2)} MB after prompt`,
|
||||
beforeMs: measure(readForward, path),
|
||||
afterMs: measure(readBackward, path)
|
||||
})
|
||||
}
|
||||
const hugePath = join(dir, 'huge-line.jsonl')
|
||||
writeTranscriptWithHugeLine(hugePath, 3 * 1024 * 1024)
|
||||
if (readForward(hugePath) !== readBackward(hugePath)) {
|
||||
throw new Error('prompt mismatch on the oversized-line fixture')
|
||||
}
|
||||
worst.push({
|
||||
label: '3 MB single line',
|
||||
beforeMs: measure(readForward, hugePath),
|
||||
afterMs: measure(readBackward, hugePath)
|
||||
})
|
||||
|
||||
console.log('\nWorst cases (win decays as a turn progresses; <1x means slower):')
|
||||
console.log(
|
||||
`${pad('case', 22)} ${pad('before ms', 11)} ${pad('after ms', 10)} ${pad('ratio', 9)}`
|
||||
)
|
||||
for (const row of worst) {
|
||||
console.log(
|
||||
`${pad(row.label, 22)} ${pad(row.beforeMs.toFixed(3), 11)} ${pad(row.afterMs.toFixed(3), 10)} ${pad(`${(row.beforeMs / row.afterMs).toFixed(2)}x`, 9)}`
|
||||
)
|
||||
}
|
||||
console.log(
|
||||
'\nThe win shrinks toward parity as output accumulates after the prompt, since\nthe backward scan has to read past all of it. The single-line row is the floor:\nno newline to stop on, so the scan reads the line in blocks and joins once where\nthe old code issued one flat read. Both sides pay the same per-line structure\nscan, and the carry is a chunk list, so cost stays linear either way.'
|
||||
)
|
||||
} finally {
|
||||
rmSync(dir, { recursive: true, force: true })
|
||||
}
|
||||
|
|
@ -971,6 +971,292 @@ describe('shared agent-hook-listener', () => {
|
|||
}
|
||||
})
|
||||
|
||||
// Why these three: the prompt read scans backward from EOF and stops at the
|
||||
// first user line, so the cases that can break are a prompt spanning a chunk
|
||||
// boundary, a later prompt that must win over an earlier one, and the byte
|
||||
// offset in interactionKey, which the old forward pass computed absolutely.
|
||||
it('reads a Command Code prompt that straddles the backward-scan chunk boundary', () => {
|
||||
const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-chunk-straddle-'))
|
||||
const transcriptPath = join(tmpDir, 'transcript.jsonl')
|
||||
try {
|
||||
const promptLine = JSON.stringify({
|
||||
role: 'user',
|
||||
content: [{ type: 'text', text: 'straddling prompt' }]
|
||||
})
|
||||
// Place the prompt so it spans the 64 KiB read boundary counted back from
|
||||
// EOF: the scan must stitch the two reads together to see the whole line.
|
||||
const chunkBytes = 64 * 1024
|
||||
const bytesAfterPrompt = chunkBytes - Math.floor(Buffer.byteLength(promptLine) / 2)
|
||||
const tail = Array.from({ length: 271 }, (_value, index) =>
|
||||
JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: `${'t'.repeat(180)}${index}` }]
|
||||
})
|
||||
)
|
||||
let tailText = `${tail.join('\n')}\n`
|
||||
const padBytes = bytesAfterPrompt - Buffer.byteLength(tailText)
|
||||
expect(padBytes).toBeGreaterThan(0)
|
||||
tailText = `${'x'.repeat(padBytes - 1)}\n${tailText}`
|
||||
expect(Buffer.byteLength(tailText)).toBe(bytesAfterPrompt)
|
||||
const head = Array.from({ length: 200 }, (_value, index) =>
|
||||
JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: `${'h'.repeat(180)}${index}` }]
|
||||
})
|
||||
)
|
||||
writeFileSync(transcriptPath, `${head.join('\n')}\n${promptLine}\n${tailText}`)
|
||||
|
||||
const tool = normalizeHookPayload(
|
||||
state,
|
||||
'command-code',
|
||||
{
|
||||
paneKey: PANE_KEY,
|
||||
tabId: 'tab-1',
|
||||
worktreeId: 'wt',
|
||||
env: 'production',
|
||||
version: '1',
|
||||
payload: {
|
||||
hook_event_name: 'PreToolUse',
|
||||
transcript_path: transcriptPath,
|
||||
tool_name: 'shell_command',
|
||||
tool_input: { command: 'pwd' }
|
||||
}
|
||||
},
|
||||
'production'
|
||||
)
|
||||
expect(tool?.payload.prompt).toBe('straddling prompt')
|
||||
} finally {
|
||||
rmSync(tmpDir, { recursive: true, force: true })
|
||||
}
|
||||
})
|
||||
|
||||
it('reads a prompt behind one oversized line without quadratic carry copying', () => {
|
||||
const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-huge-line-'))
|
||||
const transcriptPath = join(tmpDir, 'transcript.jsonl')
|
||||
const originalConcat = Buffer.concat
|
||||
let concatenatedBytes = 0
|
||||
try {
|
||||
// A single tool result spanning many 64 KiB read blocks. Re-joining the
|
||||
// accumulated carry per block copies O(line^2) bytes; the chunk list defers
|
||||
// to one join, so total copied bytes stay proportional to the line.
|
||||
const lineBytes = 2 * 1024 * 1024
|
||||
const hugeLine = JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: 'x'.repeat(lineBytes) }]
|
||||
})
|
||||
const promptLine = JSON.stringify({
|
||||
role: 'user',
|
||||
content: [{ type: 'text', text: 'prompt behind a huge tool result' }]
|
||||
})
|
||||
writeFileSync(transcriptPath, `${promptLine}\n${hugeLine}\n`)
|
||||
|
||||
Buffer.concat = ((list: readonly Uint8Array[], totalLength?: number) => {
|
||||
const joined = originalConcat(list as Uint8Array[], totalLength)
|
||||
concatenatedBytes += joined.length
|
||||
return joined
|
||||
}) as typeof Buffer.concat
|
||||
|
||||
const tool = normalizeHookPayload(
|
||||
state,
|
||||
'command-code',
|
||||
{
|
||||
paneKey: PANE_KEY,
|
||||
tabId: 'tab-1',
|
||||
worktreeId: 'wt',
|
||||
env: 'production',
|
||||
version: '1',
|
||||
payload: {
|
||||
hook_event_name: 'PreToolUse',
|
||||
transcript_path: transcriptPath,
|
||||
tool_name: 'shell_command',
|
||||
tool_input: { command: 'pwd' }
|
||||
}
|
||||
},
|
||||
'production'
|
||||
)
|
||||
|
||||
expect(tool?.payload.prompt).toBe('prompt behind a huge tool result')
|
||||
// Linear copies once (~lineBytes). The quadratic form copied ~16x that at
|
||||
// this size and grows with the square, so 4x separates them decisively.
|
||||
expect(concatenatedBytes).toBeLessThan(lineBytes * 4)
|
||||
} finally {
|
||||
Buffer.concat = originalConcat
|
||||
rmSync(tmpDir, { recursive: true, force: true })
|
||||
}
|
||||
})
|
||||
|
||||
it('reads a Command Code prompt line that spans several read blocks', () => {
|
||||
const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-long-line-'))
|
||||
const transcriptPath = join(tmpDir, 'transcript.jsonl')
|
||||
try {
|
||||
// A prompt longer than one 64 KiB block: the scan sees consecutive blocks
|
||||
// with no newline at all and must stitch them before parsing.
|
||||
const promptText = `pasted prompt ${'W'.repeat(150 * 1024)}`
|
||||
writeFileSync(
|
||||
transcriptPath,
|
||||
`${JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'earlier' }] })}\n${JSON.stringify(
|
||||
{ role: 'user', content: [{ type: 'text', text: promptText }] }
|
||||
)}\n${JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'tail' }] })}\n`
|
||||
)
|
||||
|
||||
const tool = normalizeHookPayload(
|
||||
state,
|
||||
'command-code',
|
||||
{
|
||||
paneKey: PANE_KEY,
|
||||
tabId: 'tab-1',
|
||||
worktreeId: 'wt',
|
||||
env: 'production',
|
||||
version: '1',
|
||||
payload: {
|
||||
hook_event_name: 'PreToolUse',
|
||||
transcript_path: transcriptPath,
|
||||
tool_name: 'shell_command',
|
||||
tool_input: { command: 'pwd' }
|
||||
}
|
||||
},
|
||||
'production'
|
||||
)
|
||||
|
||||
expect(tool?.payload.prompt.startsWith('pasted prompt WWW')).toBe(true)
|
||||
} finally {
|
||||
rmSync(tmpDir, { recursive: true, force: true })
|
||||
}
|
||||
})
|
||||
|
||||
it('ignores a Command Code prompt older than the transcript scan cap', () => {
|
||||
const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-over-cap-'))
|
||||
const transcriptPath = join(tmpDir, 'transcript.jsonl')
|
||||
try {
|
||||
// The only user line sits beyond the 4 MB cap, so the bounded scan must not
|
||||
// reach it — dropping the cap would restore the unbounded read this avoids.
|
||||
const filler = JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: 'f'.repeat(64 * 1024) }]
|
||||
})
|
||||
const lines = [
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'ancient prompt' }] })
|
||||
]
|
||||
for (let index = 0; index < 80; index += 1) {
|
||||
lines.push(filler)
|
||||
}
|
||||
writeFileSync(transcriptPath, `${lines.join('\n')}\n`)
|
||||
expect(statSync(transcriptPath).size).toBeGreaterThan(4 * 1024 * 1024)
|
||||
|
||||
const tool = normalizeHookPayload(
|
||||
state,
|
||||
'command-code',
|
||||
{
|
||||
paneKey: PANE_KEY,
|
||||
tabId: 'tab-1',
|
||||
worktreeId: 'wt',
|
||||
env: 'production',
|
||||
version: '1',
|
||||
payload: {
|
||||
hook_event_name: 'PreToolUse',
|
||||
transcript_path: transcriptPath,
|
||||
tool_name: 'shell_command',
|
||||
tool_input: { command: 'pwd' }
|
||||
}
|
||||
},
|
||||
'production'
|
||||
)
|
||||
|
||||
expect(tool?.payload.prompt ?? '').toBe('')
|
||||
} finally {
|
||||
rmSync(tmpDir, { recursive: true, force: true })
|
||||
}
|
||||
})
|
||||
|
||||
it('resolves the last Command Code prompt, not an earlier one', () => {
|
||||
const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-last-prompt-'))
|
||||
const transcriptPath = join(tmpDir, 'transcript.jsonl')
|
||||
try {
|
||||
writeFileSync(
|
||||
transcriptPath,
|
||||
`${[
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'first ask' }] }),
|
||||
JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'first answer' }] }),
|
||||
JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'second ask' }] }),
|
||||
JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'second answer' }] })
|
||||
].join('\n')}\n`
|
||||
)
|
||||
|
||||
const tool = normalizeHookPayload(
|
||||
state,
|
||||
'command-code',
|
||||
{
|
||||
paneKey: PANE_KEY,
|
||||
tabId: 'tab-1',
|
||||
worktreeId: 'wt',
|
||||
env: 'production',
|
||||
version: '1',
|
||||
payload: {
|
||||
hook_event_name: 'PreToolUse',
|
||||
transcript_path: transcriptPath,
|
||||
tool_name: 'shell_command',
|
||||
tool_input: { command: 'pwd' }
|
||||
}
|
||||
},
|
||||
'production'
|
||||
)
|
||||
expect(tool?.payload.prompt).toBe('second ask')
|
||||
} finally {
|
||||
rmSync(tmpDir, { recursive: true, force: true })
|
||||
}
|
||||
})
|
||||
|
||||
it('keys the Command Code interaction by the absolute prompt line offset', () => {
|
||||
const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-offset-'))
|
||||
const transcriptPath = join(tmpDir, 'transcript.jsonl')
|
||||
try {
|
||||
const prompt = JSON.stringify({
|
||||
role: 'user',
|
||||
content: [{ type: 'text', text: 'same text' }]
|
||||
})
|
||||
const answer = JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'a' }] })
|
||||
// Why past one chunk: the offset is absolute over the whole file, so the
|
||||
// prompt must sit beyond a single backward-scan read for a chunk-relative
|
||||
// offset to be distinguishable from the correct one.
|
||||
const filler = Array.from({ length: 900 }, (_value, index) =>
|
||||
JSON.stringify({
|
||||
role: 'assistant',
|
||||
content: [{ type: 'text', text: `${'f'.repeat(200)}${index}` }]
|
||||
})
|
||||
)
|
||||
const head = `${filler.join('\n')}\n`
|
||||
writeFileSync(transcriptPath, `${head}${prompt}\n${answer}\n`)
|
||||
const promptOffset = Buffer.byteLength(head)
|
||||
expect(promptOffset).toBeGreaterThan(64 * 1024)
|
||||
|
||||
const key = normalizeHookPayload(
|
||||
createHookListenerState(),
|
||||
'command-code',
|
||||
{
|
||||
paneKey: PANE_KEY,
|
||||
tabId: 'tab-1',
|
||||
worktreeId: 'wt',
|
||||
env: 'production',
|
||||
version: '1',
|
||||
payload: {
|
||||
hook_event_name: 'PreToolUse',
|
||||
transcript_path: transcriptPath,
|
||||
tool_name: 'shell_command',
|
||||
tool_input: { command: 'pwd' }
|
||||
}
|
||||
},
|
||||
'production'
|
||||
)?.promptInteractionKey
|
||||
|
||||
// The offset segment must be the prompt line's real position in the file;
|
||||
// a chunk-relative value would make two turns collide across reads.
|
||||
// Key shape: command-code-transcript-<pathHash>-<offset>-<textHash>.
|
||||
expect(key?.split('-')[4]).toBe(String(promptOffset))
|
||||
} finally {
|
||||
rmSync(tmpDir, { recursive: true, force: true })
|
||||
}
|
||||
})
|
||||
|
||||
it('trims surrounding whitespace from extracted prompt text', () => {
|
||||
const event = normalizeHookPayload(
|
||||
state,
|
||||
|
|
|
|||
|
|
@ -835,6 +835,7 @@ function extractToolResponseText(toolResponse: unknown): string | undefined {
|
|||
|
||||
const TRANSCRIPT_CHUNK_BYTES = 64 * 1024
|
||||
const TRANSCRIPT_MAX_SCAN_BYTES = 4 * 1024 * 1024
|
||||
const EMPTY_TRANSCRIPT_REGION = Buffer.alloc(0)
|
||||
const AMP_THREAD_ID_MAX_LENGTH = 256
|
||||
const AMP_MAX_SCOPED_THREAD_CACHE_KEYS = 32
|
||||
const GROK_SESSION_CWD_MAX_LENGTH = 4096
|
||||
|
|
@ -959,7 +960,32 @@ function hashInteractionKeyPart(value: string): string {
|
|||
return createHash('sha256').update(value).digest('hex').slice(0, 12)
|
||||
}
|
||||
|
||||
function readLastCommandCodeUserPromptEntryFromTranscript(
|
||||
// Why byte offsets: the caller's interactionKey embeds the prompt's absolute
|
||||
// position, so the backward scan has to report the same offset the old
|
||||
// read-everything-then-take-the-last-match pass produced.
|
||||
function findLastCommandCodePromptInRegion(
|
||||
region: Buffer
|
||||
): { prompt: string; byteOffset: number } | undefined {
|
||||
let lineEnd = region.length
|
||||
for (let index = region.length - 1; index >= -1; index--) {
|
||||
if (index >= 0 && region[index] !== 0x0a) {
|
||||
continue
|
||||
}
|
||||
const lineStart = index + 1
|
||||
if (lineEnd > lineStart) {
|
||||
const prompt = extractCommandCodeUserPromptFromLine(
|
||||
region.subarray(lineStart, lineEnd).toString('utf8').trim()
|
||||
)
|
||||
if (prompt !== undefined) {
|
||||
return { prompt, byteOffset: lineStart }
|
||||
}
|
||||
}
|
||||
lineEnd = index
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
export function readLastCommandCodeUserPromptEntryFromTranscript(
|
||||
transcriptPath: unknown
|
||||
): { text: string; interactionKey: string } | undefined {
|
||||
if (typeof transcriptPath !== 'string' || transcriptPath.length === 0) {
|
||||
|
|
@ -971,46 +997,79 @@ function readLastCommandCodeUserPromptEntryFromTranscript(
|
|||
if (size <= 0) {
|
||||
return undefined
|
||||
}
|
||||
const bytesToRead = Math.min(size, TRANSCRIPT_MAX_SCAN_BYTES)
|
||||
const position = size - bytesToRead
|
||||
const fd = openSync(transcriptPath, 'r')
|
||||
try {
|
||||
const buffer = Buffer.alloc(bytesToRead)
|
||||
let filled = 0
|
||||
while (filled < bytesToRead) {
|
||||
const n = readSync(fd, buffer, filled, bytesToRead - filled, position + filled)
|
||||
if (n === 0) {
|
||||
// Why scan backward: the answer is the LAST user line, so walking up from
|
||||
// EOF returns on the first hit instead of parsing every line of a
|
||||
// multi-megabyte transcript on every hook event.
|
||||
// Why a chunk list: carry holds a partial line, and re-concatenating it per
|
||||
// block made one oversized line (a big tool result) cost O(line^2).
|
||||
let carryChunks: Buffer[] = []
|
||||
let bytesRead = 0
|
||||
let scanEnd = size
|
||||
while (scanEnd > 0 && bytesRead < TRANSCRIPT_MAX_SCAN_BYTES) {
|
||||
const chunkSize = Math.min(
|
||||
scanEnd,
|
||||
TRANSCRIPT_CHUNK_BYTES,
|
||||
TRANSCRIPT_MAX_SCAN_BYTES - bytesRead
|
||||
)
|
||||
const position = scanEnd - chunkSize
|
||||
const buffer = Buffer.alloc(chunkSize)
|
||||
let filled = 0
|
||||
while (filled < chunkSize) {
|
||||
const n = readSync(fd, buffer, filled, chunkSize - filled, position + filled)
|
||||
if (n === 0) {
|
||||
break
|
||||
}
|
||||
filled += n
|
||||
}
|
||||
// Why bail on a short read: the file shrank under us, so the bytes above
|
||||
// this block no longer line up and any stitched offset would be wrong.
|
||||
if (filled < chunkSize) {
|
||||
break
|
||||
}
|
||||
filled += n
|
||||
}
|
||||
let text = buffer.subarray(0, filled).toString('utf8')
|
||||
let textBasePosition = position
|
||||
if (position > 0) {
|
||||
const firstNewline = text.indexOf('\n')
|
||||
textBasePosition += firstNewline + 1
|
||||
text = firstNewline === -1 ? '' : text.slice(firstNewline + 1)
|
||||
}
|
||||
let lastPrompt: string | undefined
|
||||
let lastPromptOffset = 0
|
||||
for (const { line, byteOffset } of iterateTranscriptLinesWithByteOffsets(text)) {
|
||||
const prompt = extractCommandCodeUserPromptFromLine(line.trim())
|
||||
if (prompt !== undefined) {
|
||||
lastPrompt = prompt
|
||||
lastPromptOffset = textBasePosition + byteOffset
|
||||
bytesRead += filled
|
||||
scanEnd = position
|
||||
// Why search only the new block: carry is always the run before a newline,
|
||||
// so it holds none of its own.
|
||||
const firstNewline = buffer.indexOf(0x0a)
|
||||
// Why only at a true file start: a scan that stops on the size cap must
|
||||
// discard its leading partial line, exactly as the capped read did.
|
||||
const atStart = position === 0
|
||||
let completeRegion: Buffer
|
||||
let regionPosition: number
|
||||
if (atStart) {
|
||||
completeRegion =
|
||||
carryChunks.length === 0 ? buffer : Buffer.concat([buffer, ...carryChunks])
|
||||
regionPosition = position
|
||||
carryChunks = []
|
||||
} else if (firstNewline === -1) {
|
||||
completeRegion = EMPTY_TRANSCRIPT_REGION
|
||||
regionPosition = position
|
||||
carryChunks.unshift(buffer)
|
||||
} else {
|
||||
const afterNewline = buffer.subarray(firstNewline + 1)
|
||||
completeRegion =
|
||||
carryChunks.length === 0 ? afterNewline : Buffer.concat([afterNewline, ...carryChunks])
|
||||
regionPosition = position + firstNewline + 1
|
||||
carryChunks = [buffer.subarray(0, firstNewline)]
|
||||
}
|
||||
if (completeRegion.length > 0) {
|
||||
const found = findLastCommandCodePromptInRegion(completeRegion)
|
||||
if (found) {
|
||||
return {
|
||||
text: found.prompt,
|
||||
interactionKey: [
|
||||
'command-code-transcript',
|
||||
hashInteractionKeyPart(transcriptPath),
|
||||
String(regionPosition + found.byteOffset),
|
||||
hashInteractionKeyPart(found.prompt)
|
||||
].join('-')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return lastPrompt
|
||||
? {
|
||||
text: lastPrompt,
|
||||
interactionKey: [
|
||||
'command-code-transcript',
|
||||
hashInteractionKeyPart(transcriptPath),
|
||||
String(lastPromptOffset),
|
||||
hashInteractionKeyPart(lastPrompt)
|
||||
].join('-')
|
||||
}
|
||||
: undefined
|
||||
return undefined
|
||||
} finally {
|
||||
closeSync(fd)
|
||||
}
|
||||
|
|
@ -1019,24 +1078,6 @@ function readLastCommandCodeUserPromptEntryFromTranscript(
|
|||
}
|
||||
}
|
||||
|
||||
function* iterateTranscriptLinesWithByteOffsets(
|
||||
text: string
|
||||
): Generator<{ line: string; byteOffset: number }> {
|
||||
let lineStart = 0
|
||||
let byteOffset = 0
|
||||
|
||||
for (let index = 0; index <= text.length; index++) {
|
||||
if (index < text.length && text.charCodeAt(index) !== 10) {
|
||||
continue
|
||||
}
|
||||
|
||||
const line = text.slice(lineStart, index)
|
||||
yield { line, byteOffset }
|
||||
byteOffset += Buffer.byteLength(line, 'utf8') + (index < text.length ? 1 : 0)
|
||||
lineStart = index + 1
|
||||
}
|
||||
}
|
||||
|
||||
function extractCommandCodeAssistantTextFromLine(line: string): string | undefined {
|
||||
let entry: unknown
|
||||
try {
|
||||
|
|
|
|||
Loading…
Reference in New Issue