feat(cli): support multiline input and paste preview

Add Shift+Enter newline handling and bracketed paste support.
Keep large pasted input in the buffer while showing a compact line-count preview.

Author: rizwan3d

NanoAgent.CLI/Commands/ReplCommands/HelpCommandHandler.cs

@@ -34,7 +34,7 @@ public Task<ReplCommandResult> ExecuteAsync(
             "/thinking [on|off] - Show or set simple thinking mode.\n" +
             "/undo - Roll back the most recent tracked file edit transaction.\n" +
             "/use <model> - Switch the active model for subsequent prompts.\n\n" +
-            "Multiline input: enter \"\"\" on its own line, then finish with \"\"\" on its own line.\n\n" +
+            "Multiline input: press Shift+Enter to insert a new line, then Enter to send.\n\n" +
             "Start with --profile build, --profile plan, or --profile review to choose the initial session profile. Use --thinking <on|off> to choose initial thinking mode, or use /profile <name> and /thinking <on|off> inside an active session.\n" +
             "Invoke subagents for one turn with @general or @explore; primary agents can also delegate focused work with agent_delegate.";
 

NanoAgent.CLI/Presentation/Program.Rendering.cs

@@ -267,6 +267,14 @@ private static string BuildInputMarkup(AppState state)
             return state.ActiveModal.BuildInputMarkup();
         }
 
+        if (TryBuildLargeInputPasteMarkup(
+            state.Input.ToString(),
+            state.IsBusy || state.IsStreaming,
+            out string largePasteMarkup))
+        {
+            return largePasteMarkup;
+        }
+
         return BuildInputLineMarkup(
             state.Input.ToString(),
             state.IsBusy || state.IsStreaming);
@@ -292,8 +300,8 @@ private static string BuildFooterMarkup(AppState state)
         }
 
         return BuildFooterLineMarkup(
-            "Enter: send  |  Wheel/PgUp/PgDn: scroll  |  Esc/Ctrl+C: quit  |  /help",
-            "[grey]Enter: send[/]  [grey]|[/]  [grey]Wheel/PgUp/PgDn: scroll[/]  [grey]|[/]  [grey]Esc/Ctrl+C: quit[/]  [grey]|[/]  [grey]/help[/]",
+            "Enter: send  |  Shift+Enter: newline  |  Wheel/PgUp/PgDn: scroll  |  Esc/Ctrl+C: quit  |  /help",
+            "[grey]Enter: send[/]  [grey]|[/]  [grey]Shift+Enter: newline[/]  [grey]|[/]  [grey]Wheel/PgUp/PgDn: scroll[/]  [grey]|[/]  [grey]Esc/Ctrl+C: quit[/]  [grey]|[/]  [grey]/help[/]",
             BuildCompletionNote(state));
     }
 
@@ -386,14 +394,58 @@ private static int GetInputPanelSize(AppState state)
             return 4;
         }
 
-        int bodyLineCount = WrapInputText(
-                state.Input.ToString(),
-                GetInputFirstLineTextWidth(state.IsBusy || state.IsStreaming),
-                GetInputContinuationLineTextWidth()).Count;
+        string input = state.Input.ToString();
+        int bodyLineCount = GetInputLogicalLineCount(input) > MultilinePastePreviewLineThreshold
+            ? 1
+            : WrapInputText(
+                    input,
+                    GetInputFirstLineTextWidth(state.IsBusy || state.IsStreaming),
+                    GetInputContinuationLineTextWidth()).Count;
 
         return Math.Max(3, bodyLineCount + 2);
     }
 
+    private static bool TryBuildLargeInputPasteMarkup(
+        string input,
+        bool isBusy,
+        out string markup)
+    {
+        int lineCount = GetInputLogicalLineCount(input);
+        if (lineCount <= MultilinePastePreviewLineThreshold)
+        {
+            markup = string.Empty;
+            return false;
+        }
+
+        string lineLabel = lineCount == 1 ? "line is" : "lines are";
+        markup = BuildInputLineMarkup(
+            $"{lineCount} {lineLabel} pasted",
+            isBusy);
+        return true;
+    }
+
+    private static int GetInputLogicalLineCount(string input)
+    {
+        if (string.IsNullOrEmpty(input))
+        {
+            return 1;
+        }
+
+        string normalizedInput = input
+            .Replace("\r\n", "\n", StringComparison.Ordinal)
+            .Replace('\r', '\n');
+        string countableInput = normalizedInput.EndsWith('\n')
+            ? normalizedInput[..^1]
+            : normalizedInput;
+
+        if (countableInput.Length == 0)
+        {
+            return 1;
+        }
+
+        return countableInput.Count(static character => character == '\n') + 1;
+    }
+
     private static int GetInputFirstLineTextWidth(bool isBusy)
     {
         const string promptPlain = "> ";
@@ -433,14 +485,30 @@ private static IReadOnlyList<string> WrapInputText(
         }
 
         List<string> lines = [];
-        int offset = 0;
         int width = Math.Max(1, firstLineWidth);
+        string[] logicalLines = normalizedInput
+            .Replace("\r\n", "\n", StringComparison.Ordinal)
+            .Replace('\r', '\n')
+            .Split('\n');
 
-        while (offset < normalizedInput.Length)
+        foreach (string logicalLine in logicalLines)
         {
-            int length = Math.Min(width, normalizedInput.Length - offset);
-            lines.Add(normalizedInput.Substring(offset, length));
-            offset += length;
+            if (logicalLine.Length == 0)
+            {
+                lines.Add(string.Empty);
+                width = Math.Max(1, continuationLineWidth);
+                continue;
+            }
+
+            int offset = 0;
+            while (offset < logicalLine.Length)
+            {
+                int length = Math.Min(width, logicalLine.Length - offset);
+                lines.Add(logicalLine.Substring(offset, length));
+                offset += length;
+                width = Math.Max(1, continuationLineWidth);
+            }
+
             width = Math.Max(1, continuationLineWidth);
         }
 

NanoAgent.CLI/Program.cs

@@ -14,10 +14,14 @@ public static partial class Program
     private const int InputCursorColumnWidth = 1;
     private const int MessageScrollbarColumnWidth = 2;
     private const int MouseWheelScrollLineCount = 3;
+    private const int MultilinePastePreviewLineThreshold = 3;
+    private const int PasteContinuationReadTimeoutMilliseconds = 40;
     private const int TerminalSequenceReadTimeoutMilliseconds = 25;
     private const string RepositoryUrl = "github.com/rizwan3d/NanoAgent";
     private const string EnableAlternateScreenSequence = "\u001b[?1049h";
     private const string DisableAlternateScreenSequence = "\u001b[?1049l";
+    private const string EnableBracketedPasteSequence = "\u001b[?2004h";
+    private const string DisableBracketedPasteSequence = "\u001b[?2004l";
     private const string EnableWheelScrollingSequence = "\u001b[?1007h";
     private const string DisableWheelScrollingSequence = "\u001b[?1007l";
     private const string DisableMouseTrackingSequence = "\u001b[?1000l\u001b[?1002l\u001b[?1003l\u001b[?1006l";

NanoAgent.CLI/State/AppState.cs

@@ -28,6 +28,8 @@ public AppState(IUiBridge uiBridge, INanoAgentBackend backend)
 
     public StringBuilder Input { get; } = new();
 
+    public bool SkipNextInputLineFeed { get; set; }
+
     public bool IsBusy { get; set; }
 
     public bool IsReady { get; set; }

NanoAgent.CLI/Terminal/Program.Input.cs

@@ -6,6 +6,9 @@ public static partial class Program
 {
     private static void HandleInput(AppState state)
     {
+        bool appendedInputInBatch = false;
+        int pastedLineBreaksInBatch = 0;
+
         while (Console.KeyAvailable)
         {
             ConsoleKeyInfo key = Console.ReadKey(intercept: true);
@@ -22,6 +25,11 @@ private static void HandleInput(AppState state)
                 return;
             }
 
+            if (TrySkipLineFeedAfterCarriageReturn(state, key))
+            {
+                continue;
+            }
+
             if (key.Key == ConsoleKey.C &&
                 key.Modifiers.HasFlag(ConsoleModifiers.Control))
             {
@@ -52,17 +60,45 @@ private static void HandleInput(AppState state)
 
             if (IsEnterKey(key))
             {
+                if (IsMultilineEnterKey(key))
+                {
+                    AppendInputLineBreak(state, key);
+                    appendedInputInBatch = true;
+                    continue;
+                }
+
+                if (IsLikelyPastedLineBreak(key, appendedInputInBatch, pastedLineBreaksInBatch))
+                {
+                    AppendInputLineBreak(state, key);
+                    appendedInputInBatch = true;
+                    pastedLineBreaksInBatch++;
+                    continue;
+                }
+
                 SubmitInput(state);
                 return;
             }
 
             if (!char.IsControl(key.KeyChar))
             {
                 state.Input.Append(key.KeyChar);
+                state.SkipNextInputLineFeed = false;
+                appendedInputInBatch = true;
             }
         }
     }
 
+    private static bool TrySkipLineFeedAfterCarriageReturn(AppState state, ConsoleKeyInfo key)
+    {
+        if (!state.SkipNextInputLineFeed)
+        {
+            return false;
+        }
+
+        state.SkipNextInputLineFeed = false;
+        return key.KeyChar == '\n';
+    }
+
     private static bool IsBackspaceKey(ConsoleKeyInfo key)
     {
         return key.Key == ConsoleKey.Backspace ||
@@ -75,6 +111,26 @@ private static bool IsEnterKey(ConsoleKeyInfo key)
             key.KeyChar is '\r' or '\n';
     }
 
+    private static bool IsMultilineEnterKey(ConsoleKeyInfo key)
+    {
+        return IsEnterKey(key) &&
+            (key.Modifiers.HasFlag(ConsoleModifiers.Shift) ||
+                key.Modifiers.HasFlag(ConsoleModifiers.Control) ||
+                IsShiftKeyPressed() ||
+                IsControlKeyPressed());
+    }
+
+    private static bool IsLikelyPastedLineBreak(
+        ConsoleKeyInfo key,
+        bool appendedInputInBatch,
+        int pastedLineBreaksInBatch)
+    {
+        return IsEnterKey(key) &&
+            (HasBufferedInputAfterDelay(PasteContinuationReadTimeoutMilliseconds) ||
+                pastedLineBreaksInBatch > 0 ||
+                (appendedInputInBatch && key.KeyChar == '\n'));
+    }
+
     private static bool IsEscapeKey(ConsoleKeyInfo key)
     {
         return key.Key == ConsoleKey.Escape ||
@@ -242,6 +298,12 @@ private static void ConsumeSs3Input(AppState state)
 
     private static void HandleCsiKeySequence(AppState state, string sequence)
     {
+        if (sequence == "200~")
+        {
+            ConsumeBracketedPasteInput(state);
+            return;
+        }
+
         if (TryDispatchModalTerminalKeySequence(state, sequence))
         {
             return;
@@ -252,6 +314,12 @@ private static void HandleCsiKeySequence(AppState state, string sequence)
 
     private static void HandleTerminalKeySequence(AppState state, string sequence)
     {
+        if (IsMultilineEnterTerminalSequence(sequence))
+        {
+            AppendInputLineBreak(state);
+            return;
+        }
+
         switch (sequence)
         {
             case "A":
@@ -282,6 +350,96 @@ private static void HandleTerminalKeySequence(AppState state, string sequence)
         }
     }
 
+    private static bool IsMultilineEnterTerminalSequence(string sequence)
+    {
+        return sequence is "13;2u" or "13;4u" or "13;5u" or "13;6u" or "13;7u" or "13;8u";
+    }
+
+    private static void AppendInputLineBreak(AppState state)
+    {
+        AppendInputLineBreak(state, default);
+    }
+
+    private static void AppendInputLineBreak(AppState state, ConsoleKeyInfo key)
+    {
+        if (state.ActiveModal is null)
+        {
+            state.Input.Append('\n');
+        }
+
+        state.SkipNextInputLineFeed = key.KeyChar == '\r';
+    }
+
+    private static void AppendInputText(AppState state, string text)
+    {
+        if (state.ActiveModal is not null || string.IsNullOrEmpty(text))
+        {
+            return;
+        }
+
+        string normalized = text
+            .Replace("\r\n", "\n", StringComparison.Ordinal)
+            .Replace('\r', '\n');
+
+        state.Input.Append(normalized);
+        state.SkipNextInputLineFeed = false;
+    }
+
+    private static void ConsumeBracketedPasteInput(AppState state)
+    {
+        StringBuilder pastedText = new();
+
+        while (TryReadBufferedKey(out ConsoleKeyInfo key))
+        {
+            if (key.KeyChar == '\u001b' &&
+                TryConsumeBracketedPasteTerminator(pastedText))
+            {
+                AppendInputText(state, pastedText.ToString());
+                return;
+            }
+
+            pastedText.Append(key.KeyChar);
+        }
+
+        AppendInputText(state, pastedText.ToString());
+    }
+
+    private static bool TryConsumeBracketedPasteTerminator(StringBuilder pastedText)
+    {
+        if (!TryReadBufferedKey(out ConsoleKeyInfo prefixKey))
+        {
+            pastedText.Append('\u001b');
+            return false;
+        }
+
+        if (prefixKey.KeyChar != '[')
+        {
+            pastedText.Append('\u001b');
+            pastedText.Append(prefixKey.KeyChar);
+            return false;
+        }
+
+        StringBuilder sequence = new();
+        while (TryReadBufferedKey(out ConsoleKeyInfo sequenceKey))
+        {
+            sequence.Append(sequenceKey.KeyChar);
+            if (IsAnsiFinalByte(sequenceKey.KeyChar))
+            {
+                break;
+            }
+        }
+
+        if (sequence.ToString() == "201~")
+        {
+            return true;
+        }
+
+        pastedText.Append('\u001b');
+        pastedText.Append('[');
+        pastedText.Append(sequence);
+        return false;
+    }
+
     private static bool TryDispatchModalTerminalKeySequence(AppState state, string sequence)
     {
         if (state.ActiveModal is null)
@@ -332,6 +490,23 @@ private static bool TryReadBufferedKey(out ConsoleKeyInfo key)
         return true;
     }
 
+    private static bool HasBufferedInputAfterDelay(int timeoutMilliseconds)
+    {
+        DateTimeOffset deadline = DateTimeOffset.UtcNow.AddMilliseconds(timeoutMilliseconds);
+
+        while (!Console.KeyAvailable)
+        {
+            if (DateTimeOffset.UtcNow >= deadline)
+            {
+                return false;
+            }
+
+            Thread.Sleep(1);
+        }
+
+        return true;
+    }
+
     private static bool IsAnsiFinalByte(char character)
     {
         return character is >= '@' and <= '~';