Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { describe, expect, it } from 'vitest'
import { editFilesFromToolPair, isEditToolName } from './native-chat-edit-normalize'
import { MAX_EDIT_CHARS, unifiedLineNumber } from './native-chat-edit-model'
import { editLinesFromUnifiedPatch } from './native-chat-unified-patch'
import { unwrapBeginPatch } from './native-chat-begin-patch'
const gutter = (files: ReturnType<typeof editFilesFromToolPair>): (number | null)[] =>
(files ?? []).flatMap((file) => file.lines.map((line) => unifiedLineNumber(line)))
/** Cards require landed-edit evidence; default fixtures report completed calls, lifecycle cases supply their own state. */
const settledFiles = (
pair: Parameters<typeof editFilesFromToolPair>[0]
): ReturnType<typeof editFilesFromToolPair> =>
editFilesFromToolPair({ state: 'completed', ...pair })
describe('editLinesFromUnifiedPatch', () => {
it('numbers deletes from the old side and adds from the new side', () => {
const parsed = editLinesFromUnifiedPatch('@@ -12,3 +12,3 @@\n ctx\n-was\n+now\n tail')
expect(parsed?.lineNumbersKnown).toBe(true)
expect(parsed?.lines.map((line) => [line.kind, unifiedLineNumber(line)])).toEqual([
['context', 12],
['del', 13],
['add', 13],
['context', 14]
])
})
it('leaves rows unnumbered when the hunk header carries no ranges', () => {
const parsed = editLinesFromUnifiedPatch('@@\n ctx\n-was\n+now')
expect(parsed?.lineNumbersKnown).toBe(false)
expect(parsed?.lines.every((line) => unifiedLineNumber(line) === null)).toBe(true)
})
it('returns null for text with no hunk header', () => {
expect(editLinesFromUnifiedPatch('just prose\n- a bullet')).toBeNull()
})
it('keeps the hunk open across a mid-hunk no-newline marker', () => {
const parsed = editLinesFromUnifiedPatch(
'@@ -1,2 +1,2 @@\n keep\n-old\n\\ No newline at end of file\n+new\n\\ No newline at end of file'
)
expect(parsed?.lines.map((line) => [line.kind, line.text])).toEqual([
['context', 'keep'],
['del', 'old'],
['add', 'new']
])
})
it('reads a removed line that starts with `--` as content, not a file header', () => {
const parsed = editLinesFromUnifiedPatch('@@ -1,4 +1,3 @@\n keep\n--- comment\n-gone\n tail')
expect(parsed?.lines.map((line) => [line.kind, line.text])).toEqual([
['context', 'keep'],
['del', '-- comment'],
['del', 'gone'],
['context', 'tail']
])
})
it('skips a real file header pair, which only appears outside a hunk', () => {
const parsed = editLinesFromUnifiedPatch(
'diff --git a/a.ts b/a.ts\n--- a/a.ts\n+++ b/a.ts\n@@ -1,1 +1,1 @@\n-was\n+now'
)
expect(parsed?.lines.map((line) => [line.kind, line.text])).toEqual([
['del', 'was'],
['add', 'now']
])
})
it('splits CRLF rows without leaving a carriage return or a phantom row', () => {
const parsed = editLinesFromUnifiedPatch('@@ -1,2 +1,2 @@\r\n ctx\r\n-was\r\n+now\r\n')
expect(parsed?.lines.map((line) => line.text)).toEqual(['ctx', 'was', 'now'])
})
it('reports truncation when the patch text runs past the character cap', () => {
const body = `@@ -1,1 +1,1 @@\n${'+x\n'.repeat(MAX_EDIT_CHARS)}`
expect(editLinesFromUnifiedPatch(body)?.truncated).toBe(true)
})
it('marks the break between hunks, and only between them', () => {
const parsed = editLinesFromUnifiedPatch(
'@@ -40,2 +40,2 @@\n keep\n-was\n@@ -310,2 +310,2 @@\n+now\n tail'
)
expect(parsed?.lines.map((line) => [line.kind, unifiedLineNumber(line)])).toEqual([
['context', 40],
['del', 41],
['gap', null],
['add', 310],
['context', 311]
])
})
it('reads a body that opens with no hunk header as an unlocatable hunk', () => {
const parsed = editLinesFromUnifiedPatch('-was\n+now', { implicitFirstHunk: true })
expect(parsed?.lines.map((line) => line.kind)).toEqual(['del', 'add'])
expect(parsed?.lineNumbersKnown).toBe(false)
// Without the option the same body is not a patch at all.
expect(editLinesFromUnifiedPatch('-was\n+now')).toBeNull()
})
})
describe('unwrapBeginPatch', () => {
it('recovers an envelope carried in one word of an argument vector', () => {
const envelope = '*** Begin Patch\n*** Update File: a.ts\n@@\n-x\n+y\n*** End Patch'
expect(
unwrapBeginPatch({
command: ['bash', '-lc', `apply_patch <<'EOF'\n${envelope}\nEOF`],
workdir: '/repo'
})
).toBe(envelope)
})
it('leaves an already-decoded envelope alone', () => {
const plain = '*** Begin Patch\n*** Update File: a.ts\n@@\n-x\n+y\n*** End Patch'
expect(unwrapBeginPatch(plain)).toBe(plain)
})
it('ignores input with no envelope', () => {
expect(unwrapBeginPatch('ls -la')).toBeNull()
})
it('declines an envelope with no closing marker rather than swallowing the command line', () => {
const command = 'bash -c "*** Begin Patch\n*** Update File: a.ts\n@@\n-x\n+y" && echo ok'
expect(unwrapBeginPatch(command)).toBeNull()
expect(settledFiles({ name: 'shell', input: command })).toBeNull()
})
})
describe('editFilesFromToolPair', () => {
it('renders an apply_patch run through a command tool, which produced no diff', () => {
const files = settledFiles({
name: 'exec',
input: {
command: [
'bash',
'-lc',
"apply_patch <<'EOF'\n*** Begin Patch\n*** Update File: src/a.ts\n@@\n ctx\n-was\n+now\n*** End Patch\nEOF"
]
}
})
expect(files).toHaveLength(1)
expect(files?.[0]?.path).toBe('src/a.ts')
expect(files?.[0]?.changeKind).toBe('edited')
expect(files?.[0]?.added).toBe(1)
expect(files?.[0]?.removed).toBe(1)
// Codex hunk headers are context anchors, so no row may claim a file position.
expect(files?.[0]?.lineNumbersKnown).toBe(false)
})
it('numbers an added file from 1', () => {
const files = settledFiles({
name: 'exec',
input:
"apply_patch <<'EOF'\n*** Begin Patch\n*** Add File: new.ts\n+one\n+two\n*** End Patch\nEOF"
})
expect(files?.[0]?.changeKind).toBe('added')
expect(files?.[0]?.lineNumbersKnown).toBe(true)
expect(gutter(files)).toEqual([1, 2])
})
it('keeps a file whose update body carries no hunk header', () => {
const files = settledFiles({
name: 'apply_patch',
input: {
input:
'*** Begin Patch\n*** Update File: first.ts\n ctx\n-was\n+now\n*** Update File: second.ts\n@@ -1,1 +1,1 @@\n-a\n+b\n*** End Patch'
}
})
expect(files?.map((file) => file.path)).toEqual(['first.ts', 'second.ts'])
expect(files?.[0]?.lines.map((line) => line.kind)).toEqual(['context', 'del', 'add'])
expect(files?.[0]?.lineNumbersKnown).toBe(false)
})
it('does not render envelope control lines as file content', () => {
const files = settledFiles({
name: 'apply_patch',
input: {
input:
'*** Begin Patch\n*** Environment ID: abc123\n*** Update File: a.ts\n@@\n-was\n+now\n*** End of File\n*** End Patch'
}
})
expect(files?.[0]?.lines.map((line) => line.text)).toEqual(['was', 'now'])
})
it('reports a delete that names the file and carries no body', () => {
const files = settledFiles({
name: 'apply_patch',
input: { input: '*** Begin Patch\n*** Delete File: gone.ts\n*** End Patch' }
})
expect(files).toHaveLength(1)
expect(files?.[0]?.changeKind).toBe('deleted')
expect(files?.[0]?.path).toBe('gone.ts')
expect(files?.[0]?.lines).toEqual([])
})
it('reads a CRLF envelope, whose markers otherwise match nothing', () => {
const files = settledFiles({
name: 'apply_patch',
input: {
input:
'*** Begin Patch\r\n*** Update File: a.ts\r\n@@ -1,2 +1,2 @@\r\n-was\r\n+now\r\n*** End Patch'
}
})
expect(files).toHaveLength(1)
expect(files?.[0]?.path).toBe('a.ts')
expect(files?.[0]?.lines.map((line) => line.text)).toEqual(['was', 'now'])
})
it('marks the break between resolved hunks that sit far apart', () => {
const files = settledFiles({
name: 'Edit',
input: { file_path: '/repo/a.ts' },
result: {
editPatch: {
filePath: '/repo/a.ts',
hunks: [
{ oldStart: 42, oldLines: 1, newStart: 42, newLines: 1, lines: ['-was', '+now'] },
{ oldStart: 310, oldLines: 1, newStart: 310, newLines: 1, lines: ['-old', '+new'] }
]
}
}
})
expect(files?.[0]?.lines.map((line) => line.kind)).toEqual(['del', 'add', 'gap', 'del', 'add'])
// A break marks nothing at either end, and counts no change of its own.
expect(files?.[0]?.added).toBe(2)
expect(files?.[0]?.removed).toBe(2)
expect(gutter(files)).toEqual([42, 42, null, 310, 310])
})
it('reads a move header as a rename', () => {
const files = settledFiles({
name: 'exec',
input:
"apply_patch <<'EOF'\n*** Begin Patch\n*** Update File: old.ts\n*** Move to: new.ts\n@@\n-a\n+b\n*** End Patch\nEOF"
})
expect(files?.[0]?.changeKind).toBe('renamed')
expect(files?.[0]?.oldPath).toBe('old.ts')
expect(files?.[0]?.path).toBe('new.ts')
})
it('interleaves a Claude snippet pair without claiming line positions', () => {
const files = settledFiles({
name: 'Edit',
input: {
file_path: '/repo/a.ts',
old_string: 'keep\nwas\ntail',
new_string: 'keep\nnow\ntail'
}
})
expect(files?.[0]?.lines.map((line) => line.kind)).toEqual(['context', 'del', 'add', 'context'])
expect(files?.[0]?.lineNumbersKnown).toBe(false)
})
it('prefers the resolved hunks on the result over the snippet pair', () => {
const files = settledFiles({
name: 'Edit',
input: { file_path: '/repo/a.ts', old_string: 'was', new_string: 'now' },
result: {
editPatch: {
filePath: '/repo/a.ts',
hunks: [
{
oldStart: 12,
oldLines: 3,
newStart: 12,
newLines: 3,
lines: [' ctx', '-was', '+now', ' tail']
}
]
}
}
})
expect(files?.[0]?.lineNumbersKnown).toBe(true)
expect(gutter(files)).toEqual([12, 13, 13, 14])
})
it('treats a Write the provider reported as a creation as an added file', () => {
const files = settledFiles({
name: 'Write',
input: { file_path: '/repo/new.ts', content: 'one\ntwo\n' },
result: { output: 'File created successfully at: /repo/new.ts' }
})
expect(files?.[0]?.changeKind).toBe('added')
expect(gutter(files)).toEqual([1, 2])
})
it('does not claim a creation for a Write over an existing file', () => {
const overwrite = settledFiles({
name: 'Write',
input: { file_path: '/repo/a.ts', content: 'one\ntwo\n' },
result: { output: 'The file /repo/a.ts has been updated.' }
})
expect(overwrite?.[0]?.changeKind).toBe('edited')
// With no result at all there is no evidence of a creation either.
const unreported = settledFiles({
name: 'Write',
input: { file_path: '/repo/a.ts', content: 'one\n' }
})
expect(unreported?.[0]?.changeKind).toBe('edited')
})
it('reads a MultiEdit, whose snippet pairs sit in edits[]', () => {
const files = settledFiles({
name: 'MultiEdit',
input: {
file_path: '/repo/a.ts',
edits: [
{ old_string: 'was', new_string: 'now' },
{ old_string: 'gone', new_string: 'kept' }
]
}
})
expect(files).toHaveLength(1)
expect(files?.[0]?.path).toBe('/repo/a.ts')
// Each entry is its own region, so a break separates them.
expect(files?.[0]?.lines.map((line) => [line.kind, line.text])).toEqual([
['del', 'was'],
['add', 'now'],
['gap', ''],
['del', 'gone'],
['add', 'kept']
])
expect(files?.[0]?.added).toBe(2)
expect(files?.[0]?.removed).toBe(2)
})
it('leaves NotebookEdit to the generic tool view', () => {
expect(isEditToolName('NotebookEdit')).toBe(false)
})
it('drops the gutter numbers whenever they locate a snippet rather than the file', () => {
const files = settledFiles({
name: 'Edit',
input: { file_path: '/repo/a.ts', old_string: 'keep\nwas', new_string: 'keep\nnow' }
})
expect(files?.[0]?.lineNumbersKnown).toBe(false)
expect(gutter(files)).toEqual([null, null, null])
expect(
files?.[0]?.lines.every((line) => line.oldLineNumber === null && line.newLineNumber === null)
).toBe(true)
})
it('renders no card for an edit the provider rejected or has not landed', () => {
const failedInput = { file_path: '/repo/a.ts', old_string: 'missing', new_string: 'now' }
expect(
settledFiles({
name: 'Edit',
input: failedInput,
result: { output: 'String to replace not found in file.', isError: true }
})
).toBeNull()
expect(
settledFiles({
name: 'apply_patch',
input: {
changes: [{ path: 'a.ts', kind: { type: 'update' }, diff: '@@ -1 +1 @@\n-a\n+b' }]
},
state: 'failed'
})
).toBeNull()
expect(settledFiles({ name: 'Edit', input: failedInput, state: 'running' })).toBeNull()
})
it('does not read a command tool result as a file edit', () => {
const patch = 'diff --git a/a.ts b/a.ts\n--- a/a.ts\n+++ b/a.ts\n@@ -1 +1 @@\n-was\n+now'
expect(
settledFiles({
name: 'exec',
input: { command: 'git diff' },
result: { output: patch }
})
).toBeNull()
// The structured journal's `Diff` item carries its patch only on the result.
const diffed = settledFiles({
name: 'Diff',
input: { path: '/repo/a.ts' },
result: { output: patch }
})
expect(diffed?.[0]?.path).toBe('/repo/a.ts')
expect(diffed?.[0]?.added).toBe(1)
})
it('reports truncation when the content runs past the character cap', () => {
const files = settledFiles({
name: 'Write',
input: { file_path: '/repo/a.ts', content: `${'x'.repeat(MAX_EDIT_CHARS)}\nlast\n` }
})
expect(files?.[0]?.truncated).toBe(true)
// The clipped body ends mid-line, so its one row is real and must survive.
expect(files?.[0]?.lines).toHaveLength(1)
})
it('reads Codex structured changes, stripping the move marker from the body', () => {
const files = settledFiles({
name: 'apply_patch',
input: {
changes: [
{
path: 'old.ts',
kind: { type: 'update', move_path: 'new.ts' },
diff: '@@ -1,2 +1,2 @@\n-a\n+b\n\nMoved to: new.ts'
}
]
}
})
expect(files?.[0]?.changeKind).toBe('renamed')
expect(files?.[0]?.lines.some((line) => line.text.includes('Moved to'))).toBe(false)
expect(gutter(files)).toEqual([1, 1])
})
it('reads a Codex add change, which arrives as raw content with no hunk header', () => {
const files = settledFiles({
name: 'apply_patch',
input: { changes: [{ path: 'new.ts', kind: { type: 'add' }, diff: 'one\ntwo' }] }
})
expect(files?.[0]?.changeKind).toBe('added')
expect(files?.[0]?.added).toBe(2)
})
it('renders the file a write actually wrote, not one its content quotes', () => {
const files = settledFiles({
name: 'Write',
input: {
file_path: 'docs/patch-format.md',
content:
'Example:\n\n*** Begin Patch\n*** Update File: src/victim.ts\n@@\n-a\n+b\n*** End Patch\n'
},
result: { output: 'File created successfully at: docs/patch-format.md' }
})
expect(files?.map((file) => file.path)).toEqual(['docs/patch-format.md'])
expect(files?.[0]?.lines.some((line) => line.text.includes('Begin Patch'))).toBe(true)
})
it('finds an envelope in a command payload that arrived as JSON text', () => {
const envelope = '*** Begin Patch\n*** Update File: src/a.ts\n@@\n-was\n+now\n*** End Patch'
const files = settledFiles({
name: 'shell',
input: JSON.stringify({
command: ['bash', '-lc', `apply_patch <<'EOF'\n${envelope}\nEOF`],
workdir: '/repo'
})
})
expect(files?.[0]?.path).toBe('src/a.ts')
expect(files?.[0]?.added).toBe(1)
})
it('renders no card for a call the turn never answered', () => {
const input = { file_path: '/repo/a.ts', old_string: 'was', new_string: 'now' }
// No lifecycle and no result: nothing says the edit was applied.
expect(editFilesFromToolPair({ name: 'Edit', input })).toBeNull()
expect(editFilesFromToolPair({ name: 'Edit', input, state: 'completed' })).toHaveLength(1)
expect(editFilesFromToolPair({ name: 'Edit', input, result: { output: 'ok' } })).toHaveLength(1)
})
it('splits a multi-file patch into one card per file', () => {
const files = settledFiles({
name: 'Diff',
input: { path: '/repo/one.ts' },
result: {
output:
'diff --git a/one.ts b/one.ts\n--- a/one.ts\n+++ b/one.ts\n@@ -1,1 +1,1 @@\n-first\n+FIRST\n' +
'diff --git a/two.ts b/two.ts\n--- a/two.ts\n+++ b/two.ts\n@@ -10,1 +10,1 @@\n-second\n+SECOND'
}
})
expect(files?.map((file) => file.path)).toEqual(['one.ts', 'two.ts'])
expect(files?.[0]?.lines.map((line) => line.text)).toEqual(['first', 'FIRST'])
expect(gutter(files?.slice(1) ?? null)).toEqual([10, 10])
})
it('keeps a file whose envelope section carries no body at all', () => {
const files = settledFiles({
name: 'apply_patch',
input: {
input:
'*** Begin Patch\n*** Update File: first.ts\n@@\n-a\n+b\n*** Update File: second.ts\n*** Update File: third.ts\n@@\n-c\n+d\n*** End Patch'
}
})
expect(files?.map((file) => file.path)).toEqual(['first.ts', 'second.ts', 'third.ts'])
expect(files?.[1]?.lines).toEqual([])
})
it('splits a multi-file patch written without per-file preamble lines', () => {
const files = settledFiles({
name: 'Diff',
input: { path: '/repo/one.ts' },
result: {
output:
'--- a/one.ts\n+++ b/one.ts\n@@ -1,1 +1,1 @@\n-first\n+FIRST\n' +
'--- a/two.ts\n+++ b/two.ts\n@@ -10,1 +10,1 @@\n-second\n+SECOND'
}
})
expect(files?.map((file) => file.path)).toEqual(['one.ts', 'two.ts'])
expect(gutter(files?.slice(1) ?? null)).toEqual([10, 10])
})
it('refuses a card when the call names a file count instead of a file', () => {
expect(
settledFiles({
name: 'Diff',
input: { path: '2 files' },
result: { output: '@@\n-a\n+b\n@@\n-c\n+d' }
})
).toBeNull()
})
it('reports a clipped patch as truncated instead of rendering its marker', () => {
const files = settledFiles({
name: 'Diff',
input: { path: 'src/a.ts' },
result: { output: '@@ -1,3 +1,3 @@\n ctx\n-was\n+now\n… (48210 bytes)' }
})
expect(files?.[0]?.truncated).toBe(true)
expect(files?.[0]?.lines.map((line) => line.text)).toEqual(['ctx', 'was', 'now'])
})
it('reads a move appended to the patch body as a rename, as the other lane does', () => {
const files = settledFiles({
name: 'Diff',
input: { path: 'src/old.ts' },
result: { output: '@@ -1,1 +1,1 @@\n-a\n+b\n\nMoved to: src/new.ts' }
})
expect(files?.[0]?.changeKind).toBe('renamed')
expect(files?.[0]?.path).toBe('src/new.ts')
expect(files?.[0]?.oldPath).toBe('src/old.ts')
expect(files?.[0]?.lines.some((line) => line.text.includes('Moved to'))).toBe(false)
})
it('does not read a row that merely mentions a move as one', () => {
const body = '@@ -1,2 +1,2 @@\n ctx\n+See Moved to: docs/archive/index.md'
const fromPatch = settledFiles({
name: 'Diff',
input: { path: 'docs/index.md' },
result: { output: body }
})
const fromChanges = settledFiles({
name: 'apply_patch',
input: { changes: [{ path: 'docs/index.md', kind: { type: 'update' }, diff: body }] }
})
for (const files of [fromPatch, fromChanges]) {
expect(files?.[0]?.changeKind).toBe('edited')
expect(files?.[0]?.oldPath).toBeNull()
expect(files?.[0]?.path).toBe('docs/index.md')
expect(files?.[0]?.lines.at(-1)?.text).toBe('See Moved to: docs/archive/index.md')
}
})
it('accepts either spelling of the command that applies an envelope', () => {
const envelope = '*** Begin Patch\n*** Update File: src/a.ts\n@@\n-was\n+now\n*** End Patch'
const files = settledFiles({
name: 'shell',
input: { command: ['bash', '-lc', `applypatch <<'EOF'\n${envelope}\nEOF`] }
})
expect(files?.[0]?.path).toBe('src/a.ts')
})
it('keeps the header destination for a rename the call names by its old path', () => {
const files = settledFiles({
name: 'Diff',
input: { path: 'old.txt' },
result: {
output:
'diff --git a/old.txt b/new.txt\n--- a/old.txt\n+++ b/new.txt\n@@ -1,1 +1,1 @@\n-a\n+b'
}
})
expect(files?.[0]?.path).toBe('new.txt')
expect(files?.[0]?.oldPath).toBe('old.txt')
})
it('does not read a command that only quotes an envelope as an edit', () => {
const envelope = '*** Begin Patch\n*** Update File: src/real.ts\n@@\n-a\n+b\n*** End Patch'
expect(
settledFiles({
name: 'shell',
input: { command: ['bash', '-lc', `cat > notes.md <<'EOF'\n${envelope}\nEOF`] }
})
).toBeNull()
})
it('does not call two compared directories a rename', () => {
const files = settledFiles({
name: 'Diff',
input: {},
result: { output: '--- d1/x.ts\n+++ d2/x.ts\n@@ -1,1 +1,1 @@\n-a\n+b' }
})
expect(files?.[0]?.changeKind).toBe('edited')
expect(files?.[0]?.oldPath).toBeNull()
expect(files?.[0]?.path).toBe('d2/x.ts')
})
it('lets the call name the file when a preamble precedes the only header', () => {
const files = settledFiles({
name: 'Diff',
input: { path: '/repo/one.ts' },
result: {
output:
'warning: something\ndiff --git a/one.ts b/one.ts\n--- a/one.ts\n+++ b/one.ts\n@@ -1,1 +1,1 @@\n-a\n+b'
}
})
// Unnamed preambles must not make single-file patches appear multi-file.
expect(files?.map((file) => file.path)).toEqual(['/repo/one.ts'])
})
it('returns null for a tool that did not edit a file', () => {
expect(settledFiles({ name: 'Bash', input: { command: 'ls' } })).toBeNull()
expect(isEditToolName('Bash')).toBe(false)
expect(isEditToolName('Edit')).toBe(true)
})
})