@robota-sdk/agent-transport 3.0.0-beta.64

package/src/tui/utils/__tests__/paste-detection.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Tests for paste detection and the full paste → label → expand pipeline.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { filterPrintable } from '../../flows/cjk-text-input-flow.js';
+import { expandPasteLabels } from '../paste-labels.js';
+
+describe('filterPrintable and newlines', () => {
+  it('should strip newlines from input (they are control chars)', () => {
+    expect(filterPrintable('line1\nline2')).toBe('line1line2');
+  });
+
+  it('should strip carriage returns', () => {
+    expect(filterPrintable('line1\r\nline2')).toBe('line1line2');
+  });
+
+  it('should strip tabs', () => {
+    expect(filterPrintable('a\tb')).toBe('ab');
+  });
+
+  it('should preserve normal text', () => {
+    expect(filterPrintable('hello world')).toBe('hello world');
+  });
+});
+
+describe('Full paste pipeline: detect → label → expand', () => {
+  it('should correctly round-trip multiline paste content', () => {
+    const pastedText = 'const a = 1;\nconst b = 2;\nconst c = 3;';
+    const store = new Map<number, string>();
+
+    // Simulate paste detection
+    expect(pastedText.length > 1 && pastedText.includes('\n')).toBe(true);
+
+    // Simulate store + label creation (as InputArea.handlePaste does)
+    const id = 1;
+    store.set(id, pastedText);
+    const lineCount = pastedText.split('\n').length;
+    const label = `[Pasted text #${id} +${lineCount} lines]`;
+    expect(label).toBe('[Pasted text #1 +3 lines]');
+
+    // Simulate submit → expand
+    const expanded = expandPasteLabels(label, store);
+    expect(expanded).toBe(pastedText);
+  });
+
+  it('should handle paste mixed with typed text', () => {
+    const pastedText = 'function hello() {\n  return "world";\n}';
+    const store = new Map<number, string>();
+    store.set(1, pastedText);
+
+    const userInput = 'Review this code: [Pasted text #1 +3 lines] and fix any bugs';
+    const expanded = expandPasteLabels(userInput, store);
+    expect(expanded).toBe(
+      'Review this code: function hello() {\n  return "world";\n} and fix any bugs',
+    );
+  });
+
+  it('should handle multiple pastes in one message', () => {
+    const store = new Map<number, string>();
+    store.set(1, 'first\npaste');
+    store.set(2, 'second\npaste\nhere');
+
+    const input = '[Pasted text #1 +2 lines] compare with [Pasted text #2 +3 lines]';
+    const expanded = expandPasteLabels(input, store);
+    expect(expanded).toBe('first\npaste compare with second\npaste\nhere');
+  });
+});
+
+describe('Paste at cursor position', () => {
+  it('label is inserted at cursor position, not end', () => {
+    const existingText = 'hello world';
+    const cursorPosition = 5; // between "hello" and " world"
+    const pastedText = 'line1\nline2';
+    const store = new Map<number, string>();
+    const id = 1;
+    store.set(id, pastedText);
+    const lineCount = pastedText.split('\n').length;
+    const label = `[Pasted text #${id} +${lineCount} lines]`;
+
+    // Simulate cursor-aware insertion (as handlePaste does)
+    const result =
+      existingText.slice(0, cursorPosition) + label + existingText.slice(cursorPosition);
+    expect(result).toBe('hello[Pasted text #1 +2 lines] world');
+
+    // Expand should restore original text at correct position
+    const expanded = expandPasteLabels(result, store);
+    expect(expanded).toBe('helloline1\nline2 world');
+  });
+
+  it('cursor hint equals cursorPosition + label.length', () => {
+    const cursorPosition = 5;
+    const label = '[Pasted text #1 +3 lines]';
+    const newCursorPos = cursorPosition + label.length;
+    expect(newCursorPos).toBe(5 + 25); // label is 25 chars
+    expect(newCursorPos).toBe(30);
+  });
+
+  it('paste at start (cursor = 0)', () => {
+    const existingText = 'existing';
+    const cursorPosition = 0;
+    const label = '[Pasted text #1 +2 lines]';
+    const result =
+      existingText.slice(0, cursorPosition) + label + existingText.slice(cursorPosition);
+    expect(result).toBe('[Pasted text #1 +2 lines]existing');
+  });
+
+  it('paste at end (cursor = text.length)', () => {
+    const existingText = 'existing';
+    const cursorPosition = existingText.length;
+    const label = '[Pasted text #1 +2 lines]';
+    const result =
+      existingText.slice(0, cursorPosition) + label + existingText.slice(cursorPosition);
+    expect(result).toBe('existing[Pasted text #1 +2 lines]');
+  });
+});

package/src/tui/utils/__tests__/paste-labels.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { expandPasteLabels } from '../paste-labels.js';
+
+describe('expandPasteLabels', () => {
+  it('should expand single paste label', () => {
+    const store = new Map([[1, 'line1\nline2\nline3']]);
+    const result = expandPasteLabels('[Pasted text #1 +3 lines]', store);
+    expect(result).toBe('line1\nline2\nline3');
+  });
+
+  it('should expand multiple paste labels', () => {
+    const store = new Map([
+      [1, 'first paste'],
+      [2, 'second paste'],
+    ]);
+    const result = expandPasteLabels(
+      'before [Pasted text #1 +1 lines] middle [Pasted text #2 +1 lines] after',
+      store,
+    );
+    expect(result).toBe('before first paste middle second paste after');
+  });
+
+  it('should return empty string for missing store entry', () => {
+    const store = new Map<number, string>();
+    const result = expandPasteLabels('[Pasted text #1 +3 lines]', store);
+    expect(result).toBe('');
+  });
+
+  it('should preserve text without paste labels', () => {
+    const store = new Map<number, string>();
+    const result = expandPasteLabels('regular text without labels', store);
+    expect(result).toBe('regular text without labels');
+  });
+
+  it('should handle label with different line counts', () => {
+    const store = new Map([[1, 'a\nb']]);
+    expect(expandPasteLabels('[Pasted text #1 +2 lines]', store)).toBe('a\nb');
+    expect(expandPasteLabels('[Pasted text #1 +99 lines]', store)).toBe('a\nb');
+  });
+
+  it('should expand label without line count (debounce pending)', () => {
+    const store = new Map([[1, 'partial paste']]);
+    const result = expandPasteLabels('[Pasted text #1]', store);
+    expect(result).toBe('partial paste');
+  });
+});

package/src/tui/utils/__tests__/tool-call-extractor.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect } from 'vitest';
+import { extractToolCalls, extractToolCallsWithDiff } from '../tool-call-extractor.js';
+
+describe('extractToolCalls', () => {
+  it('returns empty array for empty history', () => {
+    expect(extractToolCalls([], 0)).toEqual([]);
+  });
+
+  it('returns empty array when no assistant messages have toolCalls', () => {
+    const history = [{ role: 'user' }, { role: 'assistant' }];
+    expect(extractToolCalls(history, 0)).toEqual([]);
+  });
+
+  it('extracts tool call with string first argument', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Read', arguments: '{"filePath":"/src/index.ts"}' } }],
+      },
+    ];
+    expect(extractToolCalls(history, 0)).toEqual(['Read(/src/index.ts)']);
+  });
+
+  it('extracts multiple tool calls from one message', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [
+          { function: { name: 'Bash', arguments: '{"command":"ls -la"}' } },
+          { function: { name: 'Glob', arguments: '{"pattern":"**/*.md"}' } },
+        ],
+      },
+    ];
+    expect(extractToolCalls(history, 0)).toEqual(['Bash(ls -la)', 'Glob(**/*.md)']);
+  });
+
+  it('extracts tool calls from multiple assistant messages', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Read', arguments: '{"filePath":"a.ts"}' } }],
+      },
+      { role: 'user' },
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Write', arguments: '{"filePath":"b.ts"}' } }],
+      },
+    ];
+    expect(extractToolCalls(history, 0)).toEqual(['Read(a.ts)', 'Write(b.ts)']);
+  });
+
+  it('skips messages before startIndex', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Old', arguments: '{"x":"skip"}' } }],
+      },
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'New', arguments: '{"x":"keep"}' } }],
+      },
+    ];
+    expect(extractToolCalls(history, 1)).toEqual(['New(keep)']);
+  });
+
+  it('truncates long argument values with middle ellipsis', () => {
+    const longPath =
+      '/Users/jungyoun/Documents/dev/robota/packages/agent-sdk/src/plugins/very-long-directory-name/file.ts';
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [
+          { function: { name: 'Read', arguments: JSON.stringify({ filePath: longPath }) } },
+        ],
+      },
+    ];
+    const result = extractToolCalls(history, 0);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toContain('...');
+    // Should keep the tail (file name visible)
+    expect(result[0]).toContain('file.ts');
+    // Total display length should be reasonable
+    expect(result[0].length).toBeLessThanOrEqual(90);
+  });
+
+  it('handles non-string first argument (JSON stringified)', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Tool', arguments: '{"count":42}' } }],
+      },
+    ];
+    expect(extractToolCalls(history, 0)).toEqual(['Tool(42)']);
+  });
+
+  it('handles invalid JSON arguments gracefully', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Tool', arguments: 'not json' } }],
+      },
+    ];
+    expect(extractToolCalls(history, 0)).toEqual(['Tool(not json)']);
+  });
+
+  it('skips non-assistant messages', () => {
+    const history = [
+      { role: 'user' },
+      { role: 'system' },
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Bash', arguments: '{"command":"echo hi"}' } }],
+      },
+    ];
+    expect(extractToolCalls(history, 0)).toEqual(['Bash(echo hi)']);
+  });
+});
+
+describe('extractToolCallsWithDiff', () => {
+  it('non-Edit tool has no diffLines', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Read', arguments: '{"filePath":"/src/a.ts"}' } }],
+      },
+    ];
+    const summaries = extractToolCallsWithDiff(history, 0);
+    expect(summaries).toHaveLength(1);
+    expect(summaries[0].line).toBe('Read(/src/a.ts)');
+    expect(summaries[0].diffLines).toBeUndefined();
+    expect(summaries[0].diffFile).toBeUndefined();
+  });
+
+  it('Edit tool includes diffLines and diffFile', () => {
+    const args = JSON.stringify({
+      file_path: '/src/index.ts',
+      old_string: 'const a = 1;',
+      new_string: 'const a = 2;',
+    });
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Edit', arguments: args } }],
+      },
+    ];
+    const summaries = extractToolCallsWithDiff(history, 0);
+    expect(summaries).toHaveLength(1);
+    expect(summaries[0].diffFile).toBe('/src/index.ts');
+    expect(summaries[0].diffLines).toEqual([
+      { type: 'remove', text: 'const a = 1;', lineNumber: 1 },
+      { type: 'add', text: 'const a = 2;', lineNumber: 1 },
+    ]);
+  });
+
+  it('Edit tool with identical old/new has no diffLines', () => {
+    const args = JSON.stringify({
+      file_path: '/src/index.ts',
+      old_string: 'same',
+      new_string: 'same',
+    });
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Edit', arguments: args } }],
+      },
+    ];
+    const summaries = extractToolCallsWithDiff(history, 0);
+    expect(summaries).toHaveLength(1);
+    expect(summaries[0].diffLines).toBeUndefined();
+    expect(summaries[0].diffFile).toBeUndefined();
+  });
+
+  it('multiple tools including Edit: only Edit has diff', () => {
+    const editArgs = JSON.stringify({
+      file_path: '/src/main.ts',
+      old_string: 'foo',
+      new_string: 'bar',
+    });
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [
+          { function: { name: 'Read', arguments: '{"filePath":"/src/a.ts"}' } },
+          { function: { name: 'Edit', arguments: editArgs } },
+          { function: { name: 'Bash', arguments: '{"command":"ls"}' } },
+        ],
+      },
+    ];
+    const summaries = extractToolCallsWithDiff(history, 0);
+    expect(summaries).toHaveLength(3);
+    expect(summaries[0].diffLines).toBeUndefined();
+    expect(summaries[1].diffLines).toBeDefined();
+    expect(summaries[1].diffFile).toBe('/src/main.ts');
+    expect(summaries[2].diffLines).toBeUndefined();
+  });
+
+  it('extractToolCalls (plain) returns string[] without diff info', () => {
+    const editArgs = JSON.stringify({
+      file_path: '/src/index.ts',
+      old_string: 'a',
+      new_string: 'b',
+    });
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Edit', arguments: editArgs } }],
+      },
+    ];
+    const result = extractToolCalls(history, 0);
+    expect(result).toHaveLength(1);
+    expect(typeof result[0]).toBe('string');
+    // No diff properties on plain strings
+    expect(result[0]).toContain('Edit(');
+  });
+
+  it('handles Edit tool with invalid JSON arguments gracefully', () => {
+    const history = [
+      {
+        role: 'assistant',
+        toolCalls: [{ function: { name: 'Edit', arguments: 'not json' } }],
+      },
+    ];
+    const summaries = extractToolCallsWithDiff(history, 0);
+    expect(summaries).toHaveLength(1);
+    expect(summaries[0].diffLines).toBeUndefined();
+  });
+});

package/src/tui/utils/__tests__/tool-diff-summary.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest';
+import { buildToolDiffSummary } from '../tool-diff-summary.js';
+import type { IDiffLine } from '../edit-diff.js';
+
+describe('buildToolDiffSummary', () => {
+  it('builds a markdown diff fenced body while preserving file metadata', () => {
+    const lines: IDiffLine[] = [
+      { type: 'hunk', lineNumber: 10, text: '@@ -10,2 +10,2 @@' },
+      { type: 'context', lineNumber: 10, text: 'const before = true;' },
+      { type: 'remove', lineNumber: 11, text: 'const value = false;' },
+      { type: 'add', lineNumber: 11, text: 'const value = true;' },
+    ];
+
+    const summary = buildToolDiffSummary({ file: '/src/index.ts', lines });
+
+    expect(summary.file).toBe('/src/index.ts');
+    expect(summary.truncated).toBe(false);
+    expect(summary.remainingLineCount).toBe(0);
+    expect(summary.markdown).toBe(
+      [
+        '```diff',
+        '@@ -10,2 +10,2 @@',
+        '  10 | const before = true;',
+        '- 11 | const value = false;',
+        '+ 11 | const value = true;',
+        '```',
+      ].join('\n'),
+    );
+  });
+
+  it('truncates long diff bodies while keeping truncation metadata outside markdown', () => {
+    const lines = Array.from({ length: 13 }, (_, index): IDiffLine => {
+      const lineNumber = index + 1;
+      return {
+        type: index % 2 === 0 ? 'remove' : 'add',
+        lineNumber,
+        text: `line ${lineNumber}`,
+      };
+    });
+
+    const summary = buildToolDiffSummary({ lines });
+
+    expect(summary.truncated).toBe(true);
+    expect(summary.remainingLineCount).toBe(3);
+    expect(summary.markdown).toContain('-  1 | line 1');
+    expect(summary.markdown).toContain('+ 10 | line 10');
+    expect(summary.markdown).not.toContain('line 11');
+    expect(summary.markdown).not.toContain('more lines');
+  });
+
+  it('preserves the first hunk when truncating multi-hunk diffs', () => {
+    const lines: IDiffLine[] = [
+      { type: 'hunk', lineNumber: 1, text: '@@ -1,4 +1,4 @@' },
+      { type: 'context', lineNumber: 1, text: 'one' },
+      { type: 'remove', lineNumber: 2, text: 'two-old' },
+      { type: 'add', lineNumber: 2, text: 'two-new' },
+      { type: 'context', lineNumber: 3, text: 'three' },
+      { type: 'hunk', lineNumber: 20, text: '@@ -20,4 +20,4 @@' },
+      { type: 'context', lineNumber: 20, text: 'twenty' },
+      { type: 'remove', lineNumber: 21, text: 'twenty-one-old' },
+      { type: 'add', lineNumber: 21, text: 'twenty-one-new' },
+      { type: 'context', lineNumber: 22, text: 'twenty-two' },
+      { type: 'hunk', lineNumber: 40, text: '@@ -40,4 +40,4 @@' },
+      { type: 'context', lineNumber: 40, text: 'forty' },
+      { type: 'remove', lineNumber: 41, text: 'forty-one-old' },
+      { type: 'add', lineNumber: 41, text: 'forty-one-new' },
+      { type: 'context', lineNumber: 42, text: 'forty-two' },
+    ];
+
+    const summary = buildToolDiffSummary({ lines });
+
+    expect(summary.truncated).toBe(true);
+    expect(summary.remainingLineCount).toBe(5);
+    expect(summary.markdown).toContain('@@ -1,4 +1,4 @@');
+    expect(summary.markdown).toContain('two-new');
+    expect(summary.markdown).toContain('@@ -20,4 +20,4 @@');
+    expect(summary.markdown).not.toContain('@@ -40,4 +40,4 @@');
+  });
+
+  it('counts omitted lines from the actual rendered diff lines', () => {
+    const lines: IDiffLine[] = [
+      { type: 'hunk', lineNumber: 1, text: '@@ -1,5 +1,5 @@' },
+      { type: 'context', lineNumber: 1, text: 'one' },
+      { type: 'remove', lineNumber: 2, text: 'two-old' },
+      { type: 'add', lineNumber: 2, text: 'two-new' },
+      { type: 'context', lineNumber: 3, text: 'three' },
+      { type: 'context', lineNumber: 4, text: 'four' },
+      { type: 'hunk', lineNumber: 20, text: '@@ -20,4 +20,4 @@' },
+      { type: 'context', lineNumber: 20, text: 'twenty' },
+      { type: 'remove', lineNumber: 21, text: 'twenty-one-old' },
+      { type: 'add', lineNumber: 21, text: 'twenty-one-new' },
+      { type: 'context', lineNumber: 22, text: 'twenty-two' },
+      { type: 'hunk', lineNumber: 40, text: '@@ -40,1 +40,1 @@' },
+      { type: 'context', lineNumber: 40, text: 'forty' },
+    ];
+
+    const summary = buildToolDiffSummary({ lines });
+
+    expect(summary.truncated).toBe(true);
+    expect(summary.remainingLineCount).toBe(7);
+    expect(summary.markdown).toContain('@@ -1,5 +1,5 @@');
+    expect(summary.markdown).not.toContain('@@ -20,4 +20,4 @@');
+  });
+});

package/src/tui/utils/edit-diff.ts

@@ -0,0 +1,152 @@
+/**
+ * Generate diff lines from Edit tool's old_string and new_string.
+ * Includes absolute line numbers and optional context lines from the file.
+ */
+
+import { readFileSync } from 'node:fs';
+import type { TUniversalValue } from '@robota-sdk/agent-core';
+
+export interface IDiffLine {
+  type: 'add' | 'remove' | 'context' | 'hunk';
+  text: string;
+  /** Absolute line number in the file */
+  lineNumber: number;
+}
+
+/** Number of context lines to show before and after the change */
+const CONTEXT_LINES = 3;
+
+/**
+ * Generate diff lines from old and new strings with absolute line numbers.
+ * @param oldStr - The text being replaced
+ * @param newStr - The replacement text
+ * @param startLine - The 1-based line number where oldStr starts in the file
+ */
+export function generateDiffLines(
+  oldStr: string,
+  newStr: string,
+  startLine: number = 1,
+): IDiffLine[] {
+  if (oldStr === newStr) return [];
+
+  const lines: IDiffLine[] = [];
+
+  const oldLines = oldStr.split('\n');
+  const newLines = newStr.split('\n');
+
+  for (let i = 0; i < oldLines.length; i++) {
+    lines.push({ type: 'remove', text: oldLines[i], lineNumber: startLine + i });
+  }
+  for (let i = 0; i < newLines.length; i++) {
+    lines.push({ type: 'add', text: newLines[i], lineNumber: startLine + i });
+  }
+
+  return lines;
+}
+
+/**
+ * Generate diff lines with context from the modified file.
+ * Reads the file (already modified) to get surrounding lines.
+ */
+export function generateDiffLinesWithContext(
+  oldStr: string,
+  newStr: string,
+  startLine: number,
+  filePath: string,
+): IDiffLine[] {
+  if (oldStr === newStr) return [];
+
+  const diffLines = generateDiffLines(oldStr, newStr, startLine);
+
+  // Read modified file for context lines
+  let fileLines: string[];
+  try {
+    fileLines = readFileSync(filePath, 'utf-8').split('\n');
+  } catch {
+    return diffLines; // Can't read file — return without context
+  }
+
+  // Context BEFORE: lines before startLine in the file
+  const contextStart = Math.max(0, startLine - 1 - CONTEXT_LINES);
+  const beforeContext: IDiffLine[] = [];
+  for (let i = contextStart; i < startLine - 1; i++) {
+    if (i < fileLines.length) {
+      beforeContext.push({ type: 'context', text: fileLines[i], lineNumber: i + 1 });
+    }
+  }
+
+  // Context AFTER: lines after the new content in the modified file
+  const newLineCount = newStr.split('\n').length;
+  const afterStart = startLine - 1 + newLineCount;
+  const afterContext: IDiffLine[] = [];
+  for (let i = afterStart; i < afterStart + CONTEXT_LINES; i++) {
+    if (i < fileLines.length) {
+      afterContext.push({ type: 'context', text: fileLines[i], lineNumber: i + 1 });
+    }
+  }
+
+  const hunkStart =
+    beforeContext[0]?.lineNumber ??
+    diffLines[0]?.lineNumber ??
+    afterContext[0]?.lineNumber ??
+    startLine;
+  const oldLineCount = oldStr.split('\n').length;
+  const newLineCountInHunk = newStr.split('\n').length;
+  const oldHunkLineCount = beforeContext.length + oldLineCount + afterContext.length;
+  const newHunkLineCount = beforeContext.length + newLineCountInHunk + afterContext.length;
+
+  return [
+    {
+      type: 'hunk',
+      text: `@@ -${hunkStart},${oldHunkLineCount} +${hunkStart},${newHunkLineCount} @@`,
+      lineNumber: hunkStart,
+    },
+    ...beforeContext,
+    ...diffLines,
+    ...afterContext,
+  ];
+}
+
+/**
+ * Extract Edit tool diff info from tool arguments.
+ * @param toolName - Tool name (must be 'Edit')
+ * @param toolArgs - Tool arguments (filePath, oldString, newString)
+ * @param startLine - Start line number from Edit tool result (optional)
+ */
+export function extractEditDiff(
+  toolName: string,
+  toolArgs?: Record<string, TUniversalValue>,
+  startLine?: number,
+): { file: string; lines: IDiffLine[] } | null {
+  if (toolName !== 'Edit' || !toolArgs) return null;
+
+  const filePath = toolArgs.file_path ?? toolArgs.filePath;
+  const oldStr = toolArgs.old_string ?? toolArgs.oldString;
+  const newStr = toolArgs.new_string ?? toolArgs.newString;
+
+  if (typeof filePath !== 'string') return null;
+  if (typeof oldStr !== 'string' || typeof newStr !== 'string') return null;
+
+  // Resolve start line: from tool result, or by finding newString in the modified file
+  let sl = startLine ?? 0;
+  if (!sl) {
+    try {
+      const fileContent = readFileSync(filePath, 'utf-8');
+      const idx = fileContent.indexOf(newStr);
+      if (idx >= 0) {
+        sl = fileContent.substring(0, idx).split('\n').length;
+      } else {
+        sl = 1;
+      }
+    } catch {
+      sl = 1;
+    }
+  }
+
+  // Always try to include context from the file
+  const lines = generateDiffLinesWithContext(oldStr, newStr, sl, filePath);
+
+  if (lines.length === 0) return null;
+
+  return { file: filePath, lines };
+}

package/src/tui/utils/paste-labels.ts

@@ -0,0 +1,9 @@
+const PASTE_LABEL_RE = /\[Pasted text #(\d+)(?: \+\d+ lines)?\]/g;
+
+/**
+ * Replace paste label placeholders with their original content from the store.
+ * Labels that have no matching store entry are replaced with empty string.
+ */
+export function expandPasteLabels(text: string, store: Map<number, string>): string {
+  return text.replace(PASTE_LABEL_RE, (_, id: string) => store.get(Number(id)) ?? '');
+}