@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/components/StatusLine.js

@@ -0,0 +1,288 @@
+import { MACRO, feature } from '../recovery/bunBundleShim.js';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useCallback, useEffect, useRef } from 'react';
+import { logEvent } from '../services/analytics/index.js';
+import { useAppState, useSetAppState } from '../state/AppState.js';
+import { getIsRemoteMode, getKairosActive, getMainThreadAgentType, getOriginalCwd, getSdkBetas, getSessionId } from '../bootstrap/state.js';
+import { DEFAULT_OUTPUT_STYLE_NAME } from '../constants/outputStyles.js';
+import { useNotifications } from '../context/notifications.js';
+import { getTotalAPIDuration, getTotalCost, getTotalDuration, getTotalInputTokens, getTotalLinesAdded, getTotalLinesRemoved, getTotalOutputTokens } from '../cost-tracker.js';
+import { useMainLoopModel } from '../hooks/useMainLoopModel.js';
+import { useSettings } from '../hooks/useSettings.js';
+import { Ansi, Box, Text } from '../ink.js';
+import { getRawUtilization } from '../services/claudeAiLimits.js';
+import { checkHasTrustDialogAccepted } from '../utils/config.js';
+import { calculateContextPercentages, getContextWindowForModel } from '../utils/context.js';
+import { getCwd } from '../utils/cwd.js';
+import { logForDebugging } from '../utils/debug.js';
+import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';
+import { createBaseHookInput, executeStatusLineCommand } from '../utils/hooks.js';
+import { getLastAssistantMessage } from '../utils/messages.js';
+import { getRuntimeMainLoopModel, renderModelName } from '../utils/model/model.js';
+import { getCurrentSessionTitle } from '../utils/sessionStorage.js';
+import { doesMostRecentAssistantMessageExceed200k, getCurrentUsage } from '../utils/tokens.js';
+import { getCurrentWorktreeSession } from '../utils/worktree.js';
+import { isVimModeEnabled } from './PromptInput/utils.js';
+export function statusLineShouldDisplay(settings) {
+    // Assistant mode: statusline fields (model, permission mode, cwd) reflect the
+    // REPL/daemon process, not what the agent child is actually running. Hide it.
+    if (feature('KAIROS') && getKairosActive())
+        return false;
+    return settings?.statusLine !== undefined;
+}
+function buildStatusLineCommandInput(permissionMode, exceeds200kTokens, settings, messages, addedDirs, mainLoopModel, vimMode) {
+    const agentType = getMainThreadAgentType();
+    const worktreeSession = getCurrentWorktreeSession();
+    const runtimeModel = getRuntimeMainLoopModel({
+        permissionMode,
+        mainLoopModel,
+        exceeds200kTokens
+    });
+    const outputStyleName = settings?.outputStyle || DEFAULT_OUTPUT_STYLE_NAME;
+    const currentUsage = getCurrentUsage(messages);
+    const contextWindowSize = getContextWindowForModel(runtimeModel, getSdkBetas());
+    const contextPercentages = calculateContextPercentages(currentUsage, contextWindowSize);
+    const sessionId = getSessionId();
+    const sessionName = getCurrentSessionTitle(sessionId);
+    const rawUtil = getRawUtilization();
+    const rateLimits = {
+        ...(rawUtil.five_hour && {
+            five_hour: {
+                used_percentage: rawUtil.five_hour.utilization * 100,
+                resets_at: rawUtil.five_hour.resets_at
+            }
+        }),
+        ...(rawUtil.seven_day && {
+            seven_day: {
+                used_percentage: rawUtil.seven_day.utilization * 100,
+                resets_at: rawUtil.seven_day.resets_at
+            }
+        })
+    };
+    return {
+        ...createBaseHookInput(),
+        ...(sessionName && {
+            session_name: sessionName
+        }),
+        model: {
+            id: runtimeModel,
+            display_name: renderModelName(runtimeModel)
+        },
+        workspace: {
+            current_dir: getCwd(),
+            project_dir: getOriginalCwd(),
+            added_dirs: addedDirs
+        },
+        version: MACRO.VERSION,
+        output_style: {
+            name: outputStyleName
+        },
+        cost: {
+            total_cost_usd: getTotalCost(),
+            total_duration_ms: getTotalDuration(),
+            total_api_duration_ms: getTotalAPIDuration(),
+            total_lines_added: getTotalLinesAdded(),
+            total_lines_removed: getTotalLinesRemoved()
+        },
+        context_window: {
+            total_input_tokens: getTotalInputTokens(),
+            total_output_tokens: getTotalOutputTokens(),
+            context_window_size: contextWindowSize,
+            current_usage: currentUsage,
+            used_percentage: contextPercentages.used,
+            remaining_percentage: contextPercentages.remaining
+        },
+        exceeds_200k_tokens: exceeds200kTokens,
+        ...((rateLimits.five_hour || rateLimits.seven_day) && {
+            rate_limits: rateLimits
+        }),
+        ...(isVimModeEnabled() && {
+            vim: {
+                mode: vimMode ?? 'INSERT'
+            }
+        }),
+        ...(agentType && {
+            agent: {
+                name: agentType
+            }
+        }),
+        ...(getIsRemoteMode() && {
+            remote: {
+                session_id: getSessionId()
+            }
+        }),
+        ...(worktreeSession && {
+            worktree: {
+                name: worktreeSession.worktreeName,
+                path: worktreeSession.worktreePath,
+                branch: worktreeSession.worktreeBranch,
+                original_cwd: worktreeSession.originalCwd,
+                original_branch: worktreeSession.originalBranch
+            }
+        })
+    };
+}
+export function getLastAssistantMessageId(messages) {
+    return getLastAssistantMessage(messages)?.uuid ?? null;
+}
+function StatusLineInner({ messagesRef, lastAssistantMessageId, vimMode }) {
+    const abortControllerRef = useRef(undefined);
+    const permissionMode = useAppState(s => s.toolPermissionContext.mode);
+    const additionalWorkingDirectories = useAppState(s => s.toolPermissionContext.additionalWorkingDirectories);
+    const statusLineText = useAppState(s => s.statusLineText);
+    const orchestrationActivity = useAppState(s => s.orchestrationActivity);
+    const setAppState = useSetAppState();
+    const settings = useSettings();
+    const { addNotification } = useNotifications();
+    // AppState-sourced model — same source as API requests. getMainLoopModel()
+    // re-reads settings.json on every call, so another session's /model write
+    // would leak into this session's statusline (anthropics/claude-code#37596).
+    const mainLoopModel = useMainLoopModel();
+    // Keep latest values in refs for stable callback access
+    const settingsRef = useRef(settings);
+    settingsRef.current = settings;
+    const vimModeRef = useRef(vimMode);
+    vimModeRef.current = vimMode;
+    const permissionModeRef = useRef(permissionMode);
+    permissionModeRef.current = permissionMode;
+    const addedDirsRef = useRef(additionalWorkingDirectories);
+    addedDirsRef.current = additionalWorkingDirectories;
+    const mainLoopModelRef = useRef(mainLoopModel);
+    mainLoopModelRef.current = mainLoopModel;
+    // Track previous state to detect changes and cache expensive calculations
+    const previousStateRef = useRef({
+        messageId: null,
+        exceeds200kTokens: false,
+        permissionMode,
+        vimMode,
+        mainLoopModel
+    });
+    // Debounce timer ref
+    const debounceTimerRef = useRef(undefined);
+    // True when the next invocation should log its result (first run or after settings reload)
+    const logNextResultRef = useRef(true);
+    // Stable update function — reads latest values from refs
+    const doUpdate = useCallback(async () => {
+        // Cancel any in-flight requests
+        abortControllerRef.current?.abort();
+        const controller = new AbortController();
+        abortControllerRef.current = controller;
+        const msgs = messagesRef.current;
+        const logResult = logNextResultRef.current;
+        logNextResultRef.current = false;
+        try {
+            let exceeds200kTokens = previousStateRef.current.exceeds200kTokens;
+            // Only recalculate 200k check if messages changed
+            const currentMessageId = getLastAssistantMessageId(msgs);
+            if (currentMessageId !== previousStateRef.current.messageId) {
+                exceeds200kTokens = doesMostRecentAssistantMessageExceed200k(msgs);
+                previousStateRef.current.messageId = currentMessageId;
+                previousStateRef.current.exceeds200kTokens = exceeds200kTokens;
+            }
+            const statusInput = buildStatusLineCommandInput(permissionModeRef.current, exceeds200kTokens, settingsRef.current, msgs, Array.from(addedDirsRef.current.keys()), mainLoopModelRef.current, vimModeRef.current);
+            const text = await executeStatusLineCommand(statusInput, controller.signal, undefined, logResult);
+            if (!controller.signal.aborted) {
+                setAppState(prev => {
+                    if (prev.statusLineText === text)
+                        return prev;
+                    return {
+                        ...prev,
+                        statusLineText: text
+                    };
+                });
+            }
+        }
+        catch {
+            // Silently ignore errors in status line updates
+        }
+    }, [messagesRef, setAppState]);
+    // Stable debounced schedule function — no deps, uses refs
+    const scheduleUpdate = useCallback(() => {
+        if (debounceTimerRef.current !== undefined) {
+            clearTimeout(debounceTimerRef.current);
+        }
+        debounceTimerRef.current = setTimeout((ref, doUpdate) => {
+            ref.current = undefined;
+            void doUpdate();
+        }, 300, debounceTimerRef, doUpdate);
+    }, [doUpdate]);
+    // Only trigger update when assistant message, permission mode, vim mode, or model actually changes
+    useEffect(() => {
+        if (lastAssistantMessageId !== previousStateRef.current.messageId || permissionMode !== previousStateRef.current.permissionMode || vimMode !== previousStateRef.current.vimMode || mainLoopModel !== previousStateRef.current.mainLoopModel) {
+            // Don't update messageId here — let doUpdate handle it so
+            // exceeds200kTokens is recalculated with the latest messages
+            previousStateRef.current.permissionMode = permissionMode;
+            previousStateRef.current.vimMode = vimMode;
+            previousStateRef.current.mainLoopModel = mainLoopModel;
+            scheduleUpdate();
+        }
+    }, [lastAssistantMessageId, permissionMode, vimMode, mainLoopModel, scheduleUpdate]);
+    // When the statusLine command changes (hot reload), log the next result
+    const statusLineCommand = settings?.statusLine?.command;
+    const isFirstSettingsRender = useRef(true);
+    useEffect(() => {
+        if (isFirstSettingsRender.current) {
+            isFirstSettingsRender.current = false;
+            return;
+        }
+        logNextResultRef.current = true;
+        void doUpdate();
+    }, [statusLineCommand, doUpdate]);
+    // Separate effect for logging on mount
+    useEffect(() => {
+        const statusLine = settings?.statusLine;
+        if (statusLine) {
+            logEvent('tengu_status_line_mount', {
+                command_length: statusLine.command.length,
+                padding: statusLine.padding
+            });
+            // Log if status line is configured but disabled by disableAllHooks
+            if (settings.disableAllHooks === true) {
+                logForDebugging('La barra de estado está configurada pero disableAllHooks es true', {
+                    level: 'warn'
+                });
+            }
+            // executeStatusLineCommand (hooks.ts) returns undefined when trust is
+            // blocked — statusLineText stays undefined forever, user sees nothing,
+            // and tengu_status_line_mount above fires anyway so telemetry looks fine.
+            if (!checkHasTrustDialogAccepted()) {
+                addNotification({
+                    key: 'statusline-trust-blocked',
+                    text: 'barra de estado omitida · reinicia para arreglar',
+                    color: 'warning',
+                    priority: 'low'
+                });
+                logForDebugging('Comando de barra de estado omitido: confianza del espacio de trabajo no aceptada', {
+                    level: 'warn'
+                });
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        // biome-ignore lint/correctness/useExhaustiveDependencies: intentional
+    }, []); // Only run once on mount - settings stable for initial logging
+    // Initial update on mount + cleanup on unmount
+    useEffect(() => {
+        void doUpdate();
+        return () => {
+            abortControllerRef.current?.abort();
+            if (debounceTimerRef.current !== undefined) {
+                clearTimeout(debounceTimerRef.current);
+            }
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        // biome-ignore lint/correctness/useExhaustiveDependencies: intentional
+    }, []); // Only run once on mount, not when doUpdate changes
+    // Get padding from settings or default to 0
+    const paddingX = settings?.statusLine?.padding ?? 0;
+    const orchestrationText = orchestrationActivity ? ['Orquestacion', orchestrationActivity.progressPercent === undefined ? null : `${orchestrationActivity.progressPercent}%`, orchestrationActivity.teamName, orchestrationActivity.domainName, orchestrationActivity.agentLabel, orchestrationActivity.phase, orchestrationActivity.detail].filter(Boolean).join(' · ') : null;
+    const displayText = orchestrationText && statusLineText ? `${orchestrationText} | ${statusLineText}` : orchestrationText ?? statusLineText;
+    // StatusLine must have stable height in fullscreen — the footer is
+    // flexShrink:0 so a 0→1 row change when the command finishes steals
+    // a row from ScrollBox and shifts content. Reserve the row while loading
+    // (same trick as PromptInputFooterLeftSide).
+    return _jsx(Box, { paddingX: paddingX, gap: 2, children: displayText ? _jsx(Text, { dimColor: true, wrap: "truncate", children: _jsx(Ansi, { children: displayText }) }) : isFullscreenEnvEnabled() ? _jsx(Text, { children: " " }) : null });
+}
+// Parent (PromptInputFooter) re-renders on every setMessages, but StatusLine's
+// own props now only change when lastAssistantMessageId flips — memo keeps it
+// from being dragged along (previously ~18 no-prop-change renders per session).
+export const StatusLine = memo(StatusLineInner);

package/dist/src/components/StatusNotices.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { use } from 'react';
+import { Box } from '../ink.js';
+import { getMemoryFiles } from '../utils/claudemd.js';
+import { getGlobalConfig } from '../utils/config.js';
+import { getActiveNotices } from '../utils/statusNoticeDefinitions.js';
+/**
+ * StatusNotices contains the information displayed to users at startup. We have
+ * moved neutral or positive status to src/components/Status.tsx instead, which
+ * users can access through /status.
+ */
+export function StatusNotices(t0) {
+    const $ = _c(4);
+    const { agentDefinitions } = t0 === undefined ? {} : t0;
+    const t1 = getGlobalConfig();
+    let t2;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t2 = getMemoryFiles();
+        $[0] = t2;
+    }
+    else {
+        t2 = $[0];
+    }
+    const context = {
+        config: t1,
+        agentDefinitions,
+        memoryFiles: use(t2)
+    };
+    const activeNotices = getActiveNotices(context);
+    if (activeNotices.length === 0) {
+        return null;
+    }
+    const T0 = Box;
+    const t3 = "column";
+    const t4 = 1;
+    const t5 = activeNotices.map(notice => _jsx(React.Fragment, { children: notice.render(context) }, notice.id));
+    let t6;
+    if ($[1] !== T0 || $[2] !== t5) {
+        t6 = _jsx(T0, { flexDirection: t3, paddingLeft: t4, children: t5 });
+        $[1] = T0;
+        $[2] = t5;
+        $[3] = t6;
+    }
+    else {
+        t6 = $[3];
+    }
+    return t6;
+}

package/dist/src/components/StructuredDiff/Fallback.js

@@ -0,0 +1,335 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { diffWordsWithSpace } from 'diff';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { Box, NoSelect, Text, useTheme, wrapText } from '../../ink.js';
+// Threshold for when we show a full-line diff instead of word-level diffing
+const CHANGE_THRESHOLD = 0.4;
+export function StructuredDiffFallback(t0) {
+    const $ = _c(10);
+    const { patch, dim, width } = t0;
+    const [theme] = useTheme();
+    let t1;
+    if ($[0] !== dim || $[1] !== patch.lines || $[2] !== patch.oldStart || $[3] !== theme || $[4] !== width) {
+        t1 = formatDiff(patch.lines, patch.oldStart, width, dim, theme);
+        $[0] = dim;
+        $[1] = patch.lines;
+        $[2] = patch.oldStart;
+        $[3] = theme;
+        $[4] = width;
+        $[5] = t1;
+    }
+    else {
+        t1 = $[5];
+    }
+    const diff = t1;
+    let t2;
+    if ($[6] !== diff) {
+        t2 = diff.map(_temp);
+        $[6] = diff;
+        $[7] = t2;
+    }
+    else {
+        t2 = $[7];
+    }
+    let t3;
+    if ($[8] !== t2) {
+        t3 = _jsx(Box, { flexDirection: "column", flexGrow: 1, children: t2 });
+        $[8] = t2;
+        $[9] = t3;
+    }
+    else {
+        t3 = $[9];
+    }
+    return t3;
+}
+// Transform lines to line objects with type information
+function _temp(node, i) {
+    return _jsx(Box, { children: node }, i);
+}
+export function transformLinesToObjects(lines) {
+    return lines.map(code => {
+        if (code.startsWith('+')) {
+            return {
+                code: code.slice(1),
+                i: 0,
+                type: 'add',
+                originalCode: code.slice(1)
+            };
+        }
+        if (code.startsWith('-')) {
+            return {
+                code: code.slice(1),
+                i: 0,
+                type: 'remove',
+                originalCode: code.slice(1)
+            };
+        }
+        return {
+            code: code.slice(1),
+            i: 0,
+            type: 'nochange',
+            originalCode: code.slice(1)
+        };
+    });
+}
+// Group adjacent add/remove lines for word-level diffing
+export function processAdjacentLines(lineObjects) {
+    const processedLines = [];
+    let i = 0;
+    while (i < lineObjects.length) {
+        const current = lineObjects[i];
+        if (!current) {
+            i++;
+            continue;
+        }
+        // Find a sequence of remove followed by add (possible word-level diff candidates)
+        if (current.type === 'remove') {
+            const removeLines = [current];
+            let j = i + 1;
+            // Collect consecutive remove lines
+            while (j < lineObjects.length && lineObjects[j]?.type === 'remove') {
+                const line = lineObjects[j];
+                if (line) {
+                    removeLines.push(line);
+                }
+                j++;
+            }
+            // Check if there are add lines following the remove lines
+            const addLines = [];
+            while (j < lineObjects.length && lineObjects[j]?.type === 'add') {
+                const line = lineObjects[j];
+                if (line) {
+                    addLines.push(line);
+                }
+                j++;
+            }
+            // If we have both remove and add lines, perform word-level diffing
+            if (removeLines.length > 0 && addLines.length > 0) {
+                // For word diffing, we'll compare each pair of lines or the closest available match
+                const pairCount = Math.min(removeLines.length, addLines.length);
+                // Add paired lines with word diff info
+                for (let k = 0; k < pairCount; k++) {
+                    const removeLine = removeLines[k];
+                    const addLine = addLines[k];
+                    if (removeLine && addLine) {
+                        removeLine.wordDiff = true;
+                        addLine.wordDiff = true;
+                        // Store the matched pair for later word diffing
+                        removeLine.matchedLine = addLine;
+                        addLine.matchedLine = removeLine;
+                    }
+                }
+                // Add all remove lines (both paired and unpaired)
+                processedLines.push(...removeLines.filter(Boolean));
+                // Then add all add lines (both paired and unpaired)
+                processedLines.push(...addLines.filter(Boolean));
+                i = j; // Skip all the lines we've processed
+            }
+            else {
+                // No matching add lines, just add the current remove line
+                processedLines.push(current);
+                i++;
+            }
+        }
+        else {
+            // Not a remove line, just add it
+            processedLines.push(current);
+            i++;
+        }
+    }
+    return processedLines;
+}
+// Calculate word-level diffs between two text strings
+export function calculateWordDiffs(oldText, newText) {
+    // Use diffWordsWithSpace instead of diffWords to preserve whitespace
+    // This ensures spaces between tokens like > and { are preserved
+    const result = diffWordsWithSpace(oldText, newText, {
+        ignoreCase: false
+    });
+    return result;
+}
+// Process word-level diffs with manual wrapping support
+function generateWordDiffElements(item, width, maxWidth, dim, overrideTheme) {
+    const { type, i, wordDiff, matchedLine, originalCode } = item;
+    if (!wordDiff || !matchedLine) {
+        return null; // This function only handles word-level diff rendering
+    }
+    const removedLineText = type === 'remove' ? originalCode : matchedLine.originalCode;
+    const addedLineText = type === 'remove' ? matchedLine.originalCode : originalCode;
+    const wordDiffs = calculateWordDiffs(removedLineText, addedLineText);
+    // Check if we should use word-level diffing
+    const totalLength = removedLineText.length + addedLineText.length;
+    const changedLength = wordDiffs.filter(part => part.added || part.removed).reduce((sum, part) => sum + part.value.length, 0);
+    const changeRatio = changedLength / totalLength;
+    if (changeRatio > CHANGE_THRESHOLD || dim) {
+        return null; // Fall back to standard rendering for major changes
+    }
+    // Calculate available width for content
+    const diffPrefix = type === 'add' ? '+' : '-';
+    const diffPrefixWidth = diffPrefix.length;
+    const availableContentWidth = Math.max(1, width - maxWidth - 1 - diffPrefixWidth);
+    // Manually wrap the word diff parts with better space efficiency
+    const wrappedLines = [];
+    let currentLine = [];
+    let currentLineWidth = 0;
+    wordDiffs.forEach((part, partIndex) => {
+        // Determine if this part should be shown for this line type
+        let shouldShow = false;
+        let partBgColor;
+        if (type === 'add') {
+            if (part.added) {
+                shouldShow = true;
+                partBgColor = 'diffAddedWord';
+            }
+            else if (!part.removed) {
+                shouldShow = true;
+            }
+        }
+        else if (type === 'remove') {
+            if (part.removed) {
+                shouldShow = true;
+                partBgColor = 'diffRemovedWord';
+            }
+            else if (!part.added) {
+                shouldShow = true;
+            }
+        }
+        if (!shouldShow)
+            return;
+        // Use wrapText to wrap this individual part if it's long
+        const partWrapped = wrapText(part.value, availableContentWidth, 'wrap');
+        const partLines = partWrapped.split('\n');
+        partLines.forEach((partLine, lineIdx) => {
+            if (!partLine)
+                return;
+            // Check if we need to start a new line
+            if (lineIdx > 0 || currentLineWidth + stringWidth(partLine) > availableContentWidth) {
+                if (currentLine.length > 0) {
+                    wrappedLines.push({
+                        content: [...currentLine],
+                        contentWidth: currentLineWidth
+                    });
+                    currentLine = [];
+                    currentLineWidth = 0;
+                }
+            }
+            currentLine.push(_jsx(Text, { backgroundColor: partBgColor, children: partLine }, `part-${partIndex}-${lineIdx}`));
+            currentLineWidth += stringWidth(partLine);
+        });
+    });
+    if (currentLine.length > 0) {
+        wrappedLines.push({
+            content: currentLine,
+            contentWidth: currentLineWidth
+        });
+    }
+    // Render each wrapped line as a separate Text element
+    return wrappedLines.map(({ content, contentWidth }, lineIndex) => {
+        const key = `${type}-${i}-${lineIndex}`;
+        const lineBgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : dim ? 'diffRemovedDimmed' : 'diffRemoved';
+        const lineNum = lineIndex === 0 ? i : undefined;
+        const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
+        // Calculate padding to fill the entire terminal width
+        const usedWidth = lineNumStr.length + diffPrefixWidth + contentWidth;
+        const padding = Math.max(0, width - usedWidth);
+        return _jsxs(Box, { flexDirection: "row", children: [_jsx(NoSelect, { fromLeftEdge: true, children: _jsxs(Text, { color: overrideTheme ? 'text' : undefined, backgroundColor: lineBgColor, dimColor: dim, children: [lineNumStr, diffPrefix] }) }), _jsxs(Text, { color: overrideTheme ? 'text' : undefined, backgroundColor: lineBgColor, dimColor: dim, children: [content, ' '.repeat(padding)] })] }, key);
+    });
+}
+function formatDiff(lines, startingLineNumber, width, dim, overrideTheme) {
+    // Ensure width is at least 1 to prevent rendering issues with very narrow terminals
+    const safeWidth = Math.max(1, Math.floor(width));
+    // Step 1: Transform lines to line objects with type information
+    const lineObjects = transformLinesToObjects(lines);
+    // Step 2: Group adjacent add/remove lines for word-level diffing
+    const processedLines = processAdjacentLines(lineObjects);
+    // Step 3: Number the diff lines
+    const ls = numberDiffLines(processedLines, startingLineNumber);
+    // Find max line number width for alignment
+    const maxLineNumber = Math.max(...ls.map(({ i }) => i), 0);
+    const maxWidth = Math.max(maxLineNumber.toString().length + 1, 0);
+    // Step 4: Render formatting
+    return ls.flatMap((item) => {
+        const { type, code, i, wordDiff, matchedLine } = item;
+        // Handle word-level diffing for add/remove pairs
+        if (wordDiff && matchedLine) {
+            const wordDiffElements = generateWordDiffElements(item, safeWidth, maxWidth, dim, overrideTheme);
+            // word-diff might refuse (e.g. due to lines being substantially different) in which
+            // case we'll fall through to normal renderin gbelow
+            if (wordDiffElements !== null) {
+                return wordDiffElements;
+            }
+        }
+        // Standard rendering for lines without word diffing or as fallback
+        // Calculate available width accounting for line number + space + diff prefix
+        const diffPrefixWidth = 2; // "  " for unchanged, "+ " or "- " for changes
+        const availableContentWidth = Math.max(1, safeWidth - maxWidth - 1 - diffPrefixWidth); // -1 for space after line number
+        const wrappedText = wrapText(code, availableContentWidth, 'wrap');
+        const wrappedLines = wrappedText.split('\n');
+        return wrappedLines.map((line, lineIndex) => {
+            const key = `${type}-${i}-${lineIndex}`;
+            const lineNum = lineIndex === 0 ? i : undefined;
+            const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
+            const sigil = type === 'add' ? '+' : type === 'remove' ? '-' : ' ';
+            // Calculate padding to fill the entire terminal width
+            const contentWidth = lineNumStr.length + 1 + stringWidth(line); // lineNum + sigil + code
+            const padding = Math.max(0, safeWidth - contentWidth);
+            const bgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : type === 'remove' ? dim ? 'diffRemovedDimmed' : 'diffRemoved' : undefined;
+            // Gutter (line number + sigil) is wrapped in <NoSelect> so fullscreen
+            // text selection yields clean code. bgColor carries across both boxes
+            // so the visual continuity (solid red/green bar) is unchanged.
+            return _jsxs(Box, { flexDirection: "row", children: [_jsx(NoSelect, { fromLeftEdge: true, children: _jsxs(Text, { color: overrideTheme ? 'text' : undefined, backgroundColor: bgColor, dimColor: dim || type === 'nochange', children: [lineNumStr, sigil] }) }), _jsxs(Text, { color: overrideTheme ? 'text' : undefined, backgroundColor: bgColor, dimColor: dim, children: [line, ' '.repeat(padding)] })] }, key);
+        });
+    });
+}
+export function numberDiffLines(diff, startLine) {
+    let i = startLine;
+    const result = [];
+    const queue = [...diff];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const { code, type, originalCode, wordDiff, matchedLine } = current;
+        const line = {
+            code,
+            type,
+            i,
+            originalCode,
+            wordDiff,
+            matchedLine
+        };
+        // Update counters based on change type
+        switch (type) {
+            case 'nochange':
+                i++;
+                result.push(line);
+                break;
+            case 'add':
+                i++;
+                result.push(line);
+                break;
+            case 'remove':
+                {
+                    result.push(line);
+                    let numRemoved = 0;
+                    while (queue[0]?.type === 'remove') {
+                        i++;
+                        const current = queue.shift();
+                        const { code, type, originalCode, wordDiff, matchedLine } = current;
+                        const line = {
+                            code,
+                            type,
+                            i,
+                            originalCode,
+                            wordDiff,
+                            matchedLine
+                        };
+                        result.push(line);
+                        numRemoved++;
+                    }
+                    i -= numRemoved;
+                    break;
+                }
+        }
+    }
+    return result;
+}