rl-rockcli 0.0.9 → 0.0.10

package/commands/attach/ink-repl/replState.js

@@ -0,0 +1,947 @@
+/**
+ * REPL State Management
+ * Pure functions for state transitions
+ */
+
+import i18n from '../../../utils/i18n.js';
+import { processCarriageReturns } from './utils/truncate.js';
+const { t } = i18n;
+
+/**
+ * Create initial REPL state
+ */
+export function createInitialState(overrides = {}) {
+  // Welcome message as initial output
+  const welcomeOutput = {
+    id: 'welcome',
+    command: null,
+    output: t('welcome.connected'),
+    exitCode: 0,
+    timestamp: new Date(),
+    truncated: false,
+    prompt: null,
+    isWelcome: true,
+  };
+
+  return {
+    viewMode: 'repl', // 'repl' | 'detail'
+    detailContent: null,
+
+    outputs: [welcomeOutput],
+    outputScrollOffset: 0, // DEPRECATED: Item-based scrolling
+    lineScrollOffset: 0,   // Line-based scrolling: number of lines scrolled up from bottom
+
+    buffer: '',
+    cursorPosition: 0, // Cursor position in buffer (0 = start, buffer.length = end)
+    isExecuting: false,
+    executingCommand: '',
+    executionStartTime: null,
+    lastExecutionDuration: null, // in milliseconds
+
+    menuVisible: false,
+    menuItems: [],
+    selectedIndex: 0,
+    menuType: null, // 'slash' | 'path' | 'at' | null
+    atContext: null, // Context for @ completion (from parseAtContext)
+
+    historyIndex: -1,
+    commandHistory: [],
+    savedBuffer: '',
+
+    resources: null,
+    shellPrompt: '$ ',
+
+    // Console state
+    consoleVisible: false,
+    consoleLogs: [],
+    consoleScrollOffset: 0,
+    consoleSelectedIndex: -1, // -1 = no selection, 0+ = selected log index
+
+    // Exit confirmation state
+    exitPending: false,
+
+    // Mouse capture mode (SGR mouse reporting). When disabled in REPL view,
+    // terminals can use native text selection.
+    mouseCaptureEnabled: true,
+
+    // Paginated file viewing state (for large files)
+    paginatedFile: null, // { filePath, totalLines, loadedStartLine, loadedEndLine, isLoading }
+
+    ...overrides,
+  };
+}
+
+/**
+ * Determine whether InkREPL 应启用鼠标捕获模式
+ * 仅在非输入区域（detail view、console）可见时返回 true
+ * @param {Object} state
+ * @returns {boolean}
+ */
+export function shouldEnableMouseMode(state) {
+  if (!state) return false;
+  // When disabled, allow terminal native selection everywhere.
+  if (state.mouseCaptureEnabled === false) {
+    return false;
+  }
+  // REPL mode: disable mouse capture to allow terminal native text selection
+  // This enables mouse selection and copy without any additional key presses
+  if (state.viewMode === 'repl') {
+    return false;
+  }
+  // Only enable mouse capture in detail view and console
+  if (state.viewMode === 'detail' && state.detailContent) {
+    return true;
+  }
+  if (state.consoleVisible) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Toggle mouse capture mode for the REPL.
+ * DEPRECATED: Mouse mode is now always enabled.
+ * @param {Object} state
+ * @returns {Object}
+ */
+export function toggleMouseCapture(state) {
+  // Mouse mode is always enabled now, return state unchanged
+  return state;
+}
+
+/**
+ * Set exit pending state
+ */
+export function setExitPending(state, pending) {
+  return { ...state, exitPending: pending };
+}
+
+/**
+ * Add command output to history
+ * @param {Object} state
+ * @param {string} command
+ * @param {string} output
+ * @param {number} exitCode
+ * @param {string} prompt - The prompt at the time of execution (optional, uses current if not provided)
+ * @param {string} metaInfo - Optional meta info (e.g., "[exit code: 1]")
+ * @param {string} tips - Optional tips for failed commands
+ */
+export function addOutput(state, command, output, exitCode = 0, prompt = null, metaInfo = null, tips = null) {
+  // Process carriage returns to simulate terminal behavior
+  // This fixes issues with progress bars (e.g., apt-get update) that use \r
+  const processedOutput = processCarriageReturns(output);
+
+  const newOutput = {
+    id: `output-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    command,
+    output: processedOutput,
+    exitCode,
+    timestamp: Date.now(), // Unix timestamp in milliseconds
+    truncated: false,
+    prompt: prompt || state.shellPrompt, // Save the prompt at execution time
+    metaInfo,
+    tips,
+  };
+
+  // Always scroll to bottom when new output is added
+  // This ensures the new command output is always visible
+  const outputScrollOffset = 0;
+
+  return {
+    ...state,
+    outputs: [...state.outputs, newOutput],
+    outputScrollOffset,
+  };
+}
+
+/**
+ * Scroll REPL outputs (history) by N items.
+ * Offset is measured from the bottom: 0 = show latest, higher = show older.
+ *
+ * @param {Object} state
+ * @param {number} delta Positive = scroll up (older), negative = scroll down (newer)
+ * @param {number} maxVisibleOutputs How many output items can be shown at once
+ * @returns {Object} New state
+ */
+/**
+ * Scroll outputs (支持小数 delta 实现平滑滚动)
+ * @param {Object} state
+ * @param {number} delta - 滚动增量，可以是小数（如 0.2）实现渐进式滚动
+ * @param {number} maxVisibleOutputs
+ */
+/**
+ * Scroll outputs by number of lines (new line-based scrolling)
+ * @param {Object} state
+ * @param {number} deltaLines - Positive = scroll up (show older content), Negative = scroll down
+ * @param {number} totalVisibleLines - Total lines that can be displayed
+ * @returns {Object}
+ */
+export function scrollOutputsByLines(state, deltaLines, totalVisibleLines) {
+  // Calculate total lines in all outputs
+  // This will be calculated by the rendering component and passed in
+  // For now, just accumulate the delta
+  const currentOffset = typeof state.lineScrollOffset === 'number' ? state.lineScrollOffset : 0;
+  const newOffset = Math.max(0, currentOffset + deltaLines);
+  
+  return { ...state, lineScrollOffset: newOffset };
+}
+
+/**
+ * Scroll outputs by item offset (legacy item-based scrolling)
+ * @deprecated Use scrollOutputsByLines instead
+ */
+export function scrollOutputs(state, delta, maxVisibleOutputs) {
+  const maxVisible = Math.max(1, Number(maxVisibleOutputs || 1));
+  const maxOffset = Math.max(0, (state.outputs?.length || 0) - maxVisible);
+  
+  const current = typeof state.outputScrollOffset === 'number' ? state.outputScrollOffset : 0;
+  const next = Math.max(0, Math.min(maxOffset, current + delta));
+  
+  if (next === current) return state;
+  return { ...state, outputScrollOffset: next };
+}
+
+/**
+ * Show menu with items
+ * @param {Object} state
+ * @param {Array} items
+ * @param {string} menuType - 'slash' | 'path' | 'at'
+ * @param {Object} atContext - Context for @ completion (optional)
+ */
+export function showMenu(state, items, menuType = 'slash', atContext = null) {
+  return {
+    ...state,
+    menuVisible: true,
+    menuItems: items,
+    selectedIndex: 0,
+    menuType,
+    atContext: menuType === 'at' ? atContext : null,
+  };
+}
+
+/**
+ * Hide menu and reset selection
+ */
+export function hideMenu(state) {
+  return {
+    ...state,
+    menuVisible: false,
+    menuItems: [],
+    selectedIndex: 0,
+    menuType: null,
+    atContext: null,
+  };
+}
+
+/**
+ * Select next menu item (cycle)
+ */
+export function selectNext(state) {
+  if (state.menuItems.length === 0) return state;
+  return {
+    ...state,
+    selectedIndex: (state.selectedIndex + 1) % state.menuItems.length,
+  };
+}
+
+/**
+ * Select previous menu item (cycle)
+ */
+export function selectPrev(state) {
+  if (state.menuItems.length === 0) return state;
+  return {
+    ...state,
+    selectedIndex: state.selectedIndex <= 0
+      ? state.menuItems.length - 1
+      : state.selectedIndex - 1,
+  };
+}
+
+/**
+ * Start command execution
+ */
+export function startExecuting(state, command) {
+  return {
+    ...state,
+    isExecuting: true,
+    executingCommand: command,
+    executionStartTime: Date.now(),
+    buffer: '',
+  };
+}
+
+/**
+ * Finish command execution
+ */
+export function finishExecuting(state) {
+  const duration = state.executionStartTime
+    ? Date.now() - state.executionStartTime
+    : null;
+  return {
+    ...state,
+    isExecuting: false,
+    executingCommand: '',
+    executionStartTime: null,
+    lastExecutionDuration: duration,
+  };
+}
+
+/**
+ * Enter detail view mode
+ */
+export function enterDetailView(state, title, content) {
+  return {
+    ...state,
+    viewMode: 'detail',
+    detailContent: { title, content, scrollOffset: 0, wrappedLines: null, wrapWidth: null, lineCount: null },
+  };
+}
+
+/**
+ * Exit detail view mode
+ */
+export function exitDetailView(state) {
+  return {
+    ...state,
+    viewMode: 'repl',
+    detailContent: null,
+  };
+}
+
+/**
+ * Navigate history up (older commands)
+ */
+export function navigateHistoryUp(state) {
+  if (state.commandHistory.length === 0) return state;
+
+  if (state.historyIndex === -1) {
+    // First time navigating up, save current buffer
+    const newBuffer = state.commandHistory[state.commandHistory.length - 1];
+    return {
+      ...state,
+      savedBuffer: state.buffer,
+      historyIndex: state.commandHistory.length - 1,
+      buffer: newBuffer,
+      cursorPosition: newBuffer.length, // Move cursor to end
+    };
+  }
+
+  if (state.historyIndex > 0) {
+    const newIndex = state.historyIndex - 1;
+    const newBuffer = state.commandHistory[newIndex];
+    return {
+      ...state,
+      historyIndex: newIndex,
+      buffer: newBuffer,
+      cursorPosition: newBuffer.length, // Move cursor to end
+    };
+  }
+
+  return state; // at the beginning
+}
+
+/**
+ * Navigate history down (newer commands)
+ */
+export function navigateHistoryDown(state) {
+  if (state.historyIndex === -1) return state;
+
+  if (state.historyIndex < state.commandHistory.length - 1) {
+    const newIndex = state.historyIndex + 1;
+    const newBuffer = state.commandHistory[newIndex];
+    return {
+      ...state,
+      historyIndex: newIndex,
+      buffer: newBuffer,
+      cursorPosition: newBuffer.length, // Move cursor to end
+    };
+  }
+
+  // Return to saved buffer
+  const restoredBuffer = state.savedBuffer;
+  return {
+    ...state,
+    historyIndex: -1,
+    buffer: restoredBuffer,
+    cursorPosition: restoredBuffer.length, // Move cursor to end
+  };
+}
+
+/**
+ * Update buffer
+ */
+export function setBuffer(state, buffer) {
+  return {
+    ...state,
+    buffer,
+    cursorPosition: buffer.length, // Move cursor to end when setting buffer
+    historyIndex: -1, // Reset history navigation when typing
+  };
+}
+
+/**
+ * Move cursor left
+ */
+export function moveCursorLeft(state) {
+  const newPos = Math.max(0, (state.cursorPosition || 0) - 1);
+  return { ...state, cursorPosition: newPos };
+}
+
+/**
+ * Move cursor right
+ */
+export function moveCursorRight(state) {
+  const maxPos = state.buffer.length;
+  const newPos = Math.min(maxPos, (state.cursorPosition || 0) + 1);
+  return { ...state, cursorPosition: newPos };
+}
+
+/**
+ * Move cursor to start of line (Ctrl+A)
+ */
+export function moveCursorToStart(state) {
+  return { ...state, cursorPosition: 0 };
+}
+
+/**
+ * Move cursor to end of line (Ctrl+E)
+ */
+export function moveCursorToEnd(state) {
+  return { ...state, cursorPosition: state.buffer.length };
+}
+
+/**
+ * Update buffer and slash menu state together
+ * This prevents flickering by updating both in a single render
+ *
+ * @param {Object} state
+ * @param {string} buffer - New buffer value
+ * @param {Function} getSlashItems - Function that returns menu items for slash commands
+ */
+export function setBufferWithSlashMenu(state, buffer, getSlashItems) {
+  const newState = {
+    ...state,
+    buffer,
+    cursorPosition: buffer.length, // Move cursor to end when setting buffer
+    historyIndex: -1,
+  };
+
+  // Only handle slash menu auto-show/hide (not path or @ completion)
+  if (state.isExecuting) {
+    return newState;
+  }
+
+  // Check if buffer starts with /
+  if (buffer.startsWith('/')) {
+    const items = getSlashItems(buffer);
+    if (items.length > 0) {
+      // Show slash menu
+      return {
+        ...newState,
+        menuVisible: true,
+        menuItems: items,
+        selectedIndex: state.menuType === 'slash' ? state.selectedIndex : 0,
+        menuType: 'slash',
+      };
+    } else if (state.menuType === 'slash') {
+      // Hide slash menu (no matches)
+      return {
+        ...newState,
+        menuVisible: false,
+        menuItems: [],
+        selectedIndex: 0,
+        menuType: null,
+      };
+    }
+  } else if (state.menuType === 'slash') {
+    // Buffer no longer starts with /, hide slash menu
+    return {
+      ...newState,
+      menuVisible: false,
+      menuItems: [],
+      selectedIndex: 0,
+      menuType: null,
+    };
+  }
+
+  return newState;
+}
+
+/**
+ * Add command to history
+ */
+export function addToHistory(state, command) {
+  if (!command.trim()) return state;
+
+  // Avoid duplicates at end
+  const lastCommand = state.commandHistory[state.commandHistory.length - 1];
+  if (lastCommand === command) return state;
+
+  return {
+    ...state,
+    commandHistory: [...state.commandHistory, command],
+    historyIndex: -1,
+    savedBuffer: '',
+  };
+}
+
+/**
+ * Update resources
+ */
+export function updateResources(state, resources) {
+  return {
+    ...state,
+    resources,
+  };
+}
+
+/**
+ * Update shell prompt
+ */
+export function updatePrompt(state, prompt) {
+  return {
+    ...state,
+    shellPrompt: prompt,
+  };
+}
+
+/**
+ * Scroll detail view
+ * @param {Object} state - Current state
+ * @param {number} delta - Scroll amount (positive = down, negative = up)
+ * @param {number} viewportHeight - Optional viewport height for max scroll calculation
+ */
+export function scrollDetailView(state, delta, viewportHeight = 0) {
+  if (!state.detailContent) return state;
+
+  const lines = Number.isFinite(state.detailContent.lineCount)
+    ? state.detailContent.lineCount
+    : state.detailContent.content.split('\n').length;
+
+  // Calculate max scroll offset
+  // If viewport height is provided, limit so last page of content is visible
+  // Otherwise, allow scrolling to last line (legacy behavior)
+  let maxOffset;
+  if (viewportHeight > 0) {
+    // Content area height = viewportHeight - 2 (header)
+    const contentHeight = viewportHeight - 2;
+    maxOffset = Math.max(0, lines - contentHeight);
+  } else {
+    maxOffset = Math.max(0, lines - 1);
+  }
+
+  const newOffset = Math.max(0, Math.min(maxOffset, state.detailContent.scrollOffset + delta));
+
+  return {
+    ...state,
+    detailContent: {
+      ...state.detailContent,
+      scrollOffset: newOffset,
+    },
+  };
+}
+
+/**
+ * Toggle console visibility
+ */
+export function toggleConsole(state) {
+  return {
+    ...state,
+    consoleVisible: !state.consoleVisible,
+    consoleScrollOffset: 0, // Reset scroll when toggling
+  };
+}
+
+/**
+ * Add log entry to console
+ * Auto-scrolls to bottom to show latest logs
+ */
+export function addConsoleLog(state, level, message, consoleHeight = 7) {
+  const newLog = {
+    id: `log-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    level, // 'info' | 'warn' | 'error' | 'debug'
+    message,
+    timestamp: new Date(),
+  };
+
+  const newLogs = [...state.consoleLogs, newLog];
+  // Auto-scroll to bottom: offset = total logs - visible lines (keep latest visible)
+  const newScrollOffset = Math.max(0, newLogs.length - consoleHeight);
+
+  return {
+    ...state,
+    consoleLogs: newLogs,
+    consoleScrollOffset: newScrollOffset,
+  };
+}
+
+/**
+ * Clear console logs
+ */
+export function clearConsoleLogs(state) {
+  return {
+    ...state,
+    consoleLogs: [],
+    consoleScrollOffset: 0,
+  };
+}
+
+/**
+ * Scroll console
+ */
+export function scrollConsole(state, delta) {
+  const maxOffset = Math.max(0, state.consoleLogs.length - 6); // 6 visible lines
+  const newOffset = Math.max(0, Math.min(maxOffset, state.consoleScrollOffset + delta));
+
+  return {
+    ...state,
+    consoleScrollOffset: newOffset,
+  };
+}
+
+/**
+ * Select console log (up/down navigation)
+ */
+export function selectConsoleLog(state, delta) {
+  if (state.consoleLogs.length === 0) return state;
+
+  let newIndex = state.consoleSelectedIndex + delta;
+
+  // Wrap around or clamp
+  if (newIndex < 0) newIndex = 0;
+  if (newIndex >= state.consoleLogs.length) newIndex = state.consoleLogs.length - 1;
+
+  // Auto-scroll to keep selection visible
+  const visibleHeight = 7;
+  let newOffset = state.consoleScrollOffset;
+
+  if (newIndex < newOffset) {
+    newOffset = newIndex;
+  } else if (newIndex >= newOffset + visibleHeight) {
+    newOffset = newIndex - visibleHeight + 1;
+  }
+
+  return {
+    ...state,
+    consoleSelectedIndex: newIndex,
+    consoleScrollOffset: newOffset,
+  };
+}
+
+/**
+ * Get selected console log message
+ */
+export function getSelectedConsoleLog(state) {
+  if (state.consoleSelectedIndex < 0 || state.consoleSelectedIndex >= state.consoleLogs.length) {
+    return null;
+  }
+  return state.consoleLogs[state.consoleSelectedIndex];
+}
+
+/**
+ * Clear console selection
+ */
+export function clearConsoleSelection(state) {
+  return {
+    ...state,
+    consoleSelectedIndex: -1,
+  };
+}
+
+// ============================================
+// Mouse Drag Selection State Management
+// ============================================
+
+/**
+ * Selection state structure:
+ * {
+ *   isActive: boolean,      // Whether selection is in progress
+ *   startX: number,         // Start column (1-based)
+ *   startY: number,         // Start row (1-based)
+ *   endX: number,           // End column (1-based)
+ *   endY: number,           // End row (1-based)
+ *   content: string,        // Selected text content
+ *   source: 'detail' | 'console' | null,  // Source of selection
+ * }
+ */
+
+/**
+ * Start text selection
+ * @param {Object} state
+ * @param {number} x - Starting column (1-based)
+ * @param {number} y - Starting row (1-based)
+ * @param {string} source - Selection source ('detail' | 'console')
+ */
+export function startSelection(state, x, y, source = null) {
+  return {
+    ...state,
+    selection: {
+      isActive: true,
+      startX: x,
+      startY: y,
+      endX: x,
+      endY: y,
+      content: '',
+      source,
+    },
+  };
+}
+
+/**
+ * Update selection end position during drag
+ * @param {Object} state
+ * @param {number} x - Current column (1-based)
+ * @param {number} y - Current row (1-based)
+ * @param {Array<string>} lines - Text lines to extract content from
+ */
+export function updateSelection(state, x, y, lines = []) {
+  if (!state.selection || !state.selection.isActive) return state;
+
+  const selection = {
+    ...state.selection,
+    endX: x,
+    endY: y,
+  };
+
+  // Calculate selected text content
+  selection.content = extractSelectedText(selection, lines);
+
+  return {
+    ...state,
+    selection,
+  };
+}
+
+/**
+ * End selection (mouse up)
+ * @param {Object} state
+ * @param {number} x - End column (1-based)
+ * @param {number} y - End row (1-based)
+ * @param {Array<string>} lines - Text lines to extract content from
+ */
+export function endSelection(state, x, y, lines = []) {
+  if (!state.selection || !state.selection.isActive) return state;
+
+  const selection = {
+    ...state.selection,
+    isActive: false,
+    endX: x,
+    endY: y,
+  };
+
+  // Calculate final selected text content
+  selection.content = extractSelectedText(selection, lines);
+
+  return {
+    ...state,
+    selection,
+  };
+}
+
+/**
+ * Clear selection
+ * @param {Object} state
+ */
+export function clearSelection(state) {
+  return {
+    ...state,
+    selection: null,
+  };
+}
+
+/**
+ * Get selected text content
+ * @param {Object} state
+ * @returns {string|null} Selected text or null if no selection
+ */
+export function getSelectedText(state) {
+  return state.selection?.content || null;
+}
+
+/**
+ * Check if there is an active selection
+ * @param {Object} state
+ * @returns {boolean}
+ */
+export function hasSelection(state) {
+  return !!state.selection && !!state.selection.content;
+}
+
+/**
+ * Extract selected text from lines based on selection coordinates
+ * @param {Object} selection - Selection state
+ * @param {Array<string>} lines - Array of text lines
+ * @returns {string} Selected text
+ */
+function extractSelectedText(selection, lines) {
+  if (!lines || lines.length === 0) return '';
+
+  const { startX, startY, endX, endY } = normalizeSelection(selection);
+
+  // Convert 1-based coordinates to 0-based
+  const startRow = Math.max(0, startY - 1);
+  const endRow = Math.min(lines.length - 1, endY - 1);
+  const startCol = Math.max(0, startX - 1);
+  const endCol = Math.max(0, endX - 1);
+
+  if (startRow > endRow) return '';
+  if (startRow === endRow && startCol > endCol) return '';
+
+  const selectedLines = [];
+
+  for (let row = startRow; row <= endRow; row++) {
+    const line = lines[row] || '';
+
+    if (row === startRow && row === endRow) {
+      // Single line selection
+      selectedLines.push(line.substring(startCol, endCol));
+    } else if (row === startRow) {
+      // First line of multi-line selection
+      selectedLines.push(line.substring(startCol));
+    } else if (row === endRow) {
+      // Last line of multi-line selection
+      selectedLines.push(line.substring(0, endCol));
+    } else {
+      // Middle lines - select entire line
+      selectedLines.push(line);
+    }
+  }
+
+  return selectedLines.join('\n');
+}
+
+/**
+ * Normalize selection coordinates (ensure start <= end)
+ * @param {Object} selection - Selection state
+ * @returns {Object} Normalized coordinates
+ */
+function normalizeSelection(selection) {
+  let { startX, startY, endX, endY } = selection;
+
+  // Swap if end is before start
+  if (startY > endY || (startY === endY && startX > endX)) {
+    [startX, endX] = [endX, startX];
+    [startY, endY] = [endY, startY];
+  }
+
+  return { startX, startY, endX, endY };
+}
+
+/**
+ * Check if a position is within the selection
+ * @param {Object} selection - Selection state
+ * @param {number} x - Column (1-based)
+ * @param {number} y - Row (1-based)
+ * @returns {boolean}
+ */
+export function isPositionSelected(selection, x, y) {
+  if (!selection) return false;
+
+  const { startX, startY, endX, endY } = normalizeSelection(selection);
+
+  if (y < startY || y > endY) return false;
+  if (y === startY && y === endY) {
+    return x >= startX && x < endX;
+  }
+  if (y === startY) return x >= startX;
+  if (y === endY) return x < endX;
+  return true;
+}
+
+/**
+ * Check if a line has selection and return selection ranges
+ * @param {Object} selection - Selection state
+ * @param {number} lineIndex - 0-based line index
+ * @param {number} lineLength - Length of the line
+ * @returns {Array<{start: number, end: number}>} Selection ranges for this line
+ */
+export function getLineSelectionRanges(selection, lineIndex, lineLength) {
+  if (!selection) return [];
+
+  const lineY = lineIndex + 1; // Convert to 1-based
+  const { startX, startY, endX, endY } = normalizeSelection(selection);
+
+  // Line is outside selection
+  if (lineY < startY || lineY > endY) return [];
+
+  const ranges = [];
+
+  if (startY === endY) {
+    // Single line selection
+    if (lineY === startY) {
+      ranges.push({
+        start: Math.max(0, startX - 1),
+        end: Math.min(lineLength, endX - 1),
+      });
+    }
+  } else if (lineY === startY) {
+    // First line of multi-line
+    ranges.push({
+      start: Math.max(0, startX - 1),
+      end: lineLength,
+    });
+  } else if (lineY === endY) {
+    // Last line of multi-line
+    ranges.push({
+      start: 0,
+      end: Math.min(lineLength, endX - 1),
+    });
+  } else {
+    // Middle line - entire line selected
+    ranges.push({
+      start: 0,
+      end: lineLength,
+    });
+  }
+
+  return ranges;
+}
+
+/**
+ * Set paginated file state (for large file viewing)
+ */
+export function setPaginatedFile(state, fileInfo) {
+  return {
+    ...state,
+    paginatedFile: fileInfo,
+  };
+}
+
+/**
+ * Clear paginated file state
+ */
+export function clearPaginatedFile(state) {
+  return {
+    ...state,
+    paginatedFile: null,
+  };
+}
+
+/**
+ * Update paginated file loading state
+ */
+export function setPaginatedFileLoading(state, isLoading) {
+  if (!state.paginatedFile) return state;
+  return {
+    ...state,
+    paginatedFile: {
+      ...state.paginatedFile,
+      isLoading,
+    },
+  };
+}
+
+/**
+ * Extend paginated file loaded range (prepend or append content)
+ */
+export function extendPaginatedFileRange(state, newStartLine, newEndLine) {
+  if (!state.paginatedFile) return state;
+  return {
+    ...state,
+    paginatedFile: {
+      ...state.paginatedFile,
+      loadedStartLine: Math.min(state.paginatedFile.loadedStartLine, newStartLine),
+      loadedEndLine: Math.max(state.paginatedFile.loadedEndLine, newEndLine),
+    },
+  };
+}