repl: add auto-indentation for multiline input

Automatically insert 2-space indentation on continuation lines
based on brace/bracket/paren depth when entering multiline input.

Refs: #48164
Signed-off-by: hemanth <hemanth.hm@gmail.com>

Author: hemanth

doc/api/repl.md

@@ -27,7 +27,7 @@ result. Input and output may be from `stdin` and `stdout`, respectively, or may
 be connected to any Node.js [stream][].
 
 Instances of [`repl.REPLServer`][] support automatic completion of inputs,
-completion preview, simplistic Emacs-style line editing, multi-line inputs,
+completion preview, automatic indentation, simplistic Emacs-style line editing, multi-line inputs,
 [ZSH][]-like reverse-i-search, [ZSH][]-like substring-based history search,
 ANSI-styled output, saving and restoring current REPL session state, error
 recovery, and customizable evaluation functions. Terminals that do not support
@@ -232,6 +232,18 @@ undefined
 undefined
 ```
 
+### Auto-indentation
+
+<!-- YAML
+added: REPLACEME
+-->
+
+When entering
+multi-line input (e.g., a function body or an object literal), the REPL
+automatically indents continuation lines based on the current nesting
+depth of braces (`{}`), brackets (`[]`), and parentheses (`()`). The REPL
+uses 2-space indentation following the Node.js coding convention.
+
 ### Reverse-i-search
 
 <!-- YAML

lib/internal/repl/utils.js

@@ -11,6 +11,7 @@ const {
   RegExpPrototypeExec,
   SafeSet,
   SafeStringIterator,
+  StringPrototypeCharCodeAt,
   StringPrototypeIndexOf,
   StringPrototypeLastIndexOf,
   StringPrototypeReplaceAll,
@@ -143,6 +144,130 @@ function isRecoverableError(e, code) {
   }
 }
 
+function setupAutoIndent(repl) {
+  if (!repl.terminal) {
+    return;
+  }
+
+  const kIndent = '  '; // 2-space indentation (Node.js convention)
+
+  /**
+   * Calculates the net depth change from unmatched braces, brackets,
+   * and parentheses in a given code string.
+   * @returns {number} The net depth change.
+   */
+  function calculateDepth(code) {
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    let inTemplate = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+
+    for (let i = 0; i < code.length; i++) {
+      const ch = StringPrototypeCharCodeAt(code, i);
+
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+
+      // Backslash escape
+      if (ch === 92) { // '\'
+        escaped = true;
+        continue;
+      }
+
+      // Line comments
+      if (inLineComment) {
+        if (ch === 10 || ch === 13) inLineComment = false; // newline
+        continue;
+      }
+
+      // Block comments
+      if (inBlockComment) {
+        if (ch === 42 && StringPrototypeCharCodeAt(code, i + 1) === 47) { // */
+          inBlockComment = false;
+          i++;
+        }
+        continue;
+      }
+
+      // String literals
+      if (inString) {
+        if (ch === StringPrototypeCharCodeAt(stringChar, 0)) {
+          inString = false;
+        }
+        continue;
+      }
+
+      // Template literals
+      if (inTemplate && ch === 96) { // backtick
+        inTemplate = false;
+        continue;
+      }
+
+      // Check for comment starts
+      if (ch === 47) { // '/'
+        const next = StringPrototypeCharCodeAt(code, i + 1);
+        if (next === 47) { // '//'
+          inLineComment = true;
+          i++;
+          continue;
+        }
+        if (next === 42) { // '/*'
+          inBlockComment = true;
+          i++;
+          continue;
+        }
+      }
+
+      // String start
+      if (ch === 39 || ch === 34) { // ' or "
+        inString = true;
+        stringChar = code[i];
+        continue;
+      }
+
+      // Template literal
+      if (ch === 96) { // backtick
+        inTemplate = true;
+        continue;
+      }
+
+      // Opening delimiters
+      if (ch === 123 || ch === 91 || ch === 40) { // { [ (
+        depth++;
+      }
+      // Closing delimiters
+      if (ch === 125 || ch === 93 || ch === 41) { // } ] )
+        depth--;
+      }
+    }
+
+    return depth;
+  }
+
+  /**
+   * Gets the indentation level for the next line based on the
+   * full buffered command so far.
+   * @returns {string} The indentation string.
+   */
+  repl._getAutoIndent = function(bufferedCmd) {
+    if (!bufferedCmd) return '';
+
+    const depth = calculateDepth(bufferedCmd);
+    if (depth <= 0) return '';
+
+    let indent = '';
+    for (let i = 0; i < depth; i++) {
+      indent += kIndent;
+    }
+    return indent;
+  };
+}
+
 function setupPreview(repl, contextSymbol, bufferSymbol, active) {
   // Simple terminals can't handle previews.
   if (process.env.TERM === 'dumb' || !active) {
@@ -867,6 +992,7 @@ module.exports = {
   isRecoverableError,
   kStandaloneREPL: Symbol('kStandaloneREPL'),
   setupPreview,
+  setupAutoIndent,
   setupReverseSearch,
   isObjectLiteral,
   isValidSyntax,

lib/repl.js

@@ -127,6 +127,7 @@ const {
   REPL_MODE_STRICT,
   kStandaloneREPL,
   setupPreview,
+  setupAutoIndent,
   setupReverseSearch,
   kContextId,
   getREPLResourceName,
@@ -620,6 +621,14 @@ class REPLServer extends Interface {
         if (e instanceof Recoverable && !sawCtrlD) {
           if (self.terminal) {
             self[kAddNewLineOnTTY]();
+            if (typeof self._getAutoIndent === 'function') {
+              const buffered = self[kBufferedCommandSymbol] + cmd + '\n';
+              const indent = self._getAutoIndent(buffered);
+              if (indent) {
+                self._insertString(indent);
+              }
+            }
+
           } else {
             self[kBufferedCommandSymbol] += cmd + '\n';
             self.displayPrompt();
@@ -675,6 +684,8 @@ class REPLServer extends Interface {
     });
 
     const { reverseSearch } = setupReverseSearch(this);
+    setupAutoIndent(this);
+
 
     const {
       clearPreview, showPreview,