Address Copilot review: handle SQL quote escaping and add tests

- Fix isExitParenBalanced to handle SQL Server quote escaping rules:
  - Escaped single quotes ('') inside string literals
  - Escaped bracket identifiers (]])
- Add test cases for escaped quotes in TestIsExitParenBalanced
- Add comprehensive TestReadExitContinuation tests:
  - Continuation lines until balanced
  - Error handling on readline failure
  - Multiple continuation lines
  - Early return for already balanced input

Author: dlevy-msft-sql

pkg/sqlcmd/commands.go

@@ -210,15 +210,23 @@ func (c Commands) SetBatchTerminator(terminator string) error {
 
 // isExitParenBalanced checks if the parentheses in an EXIT command argument are balanced.
 // It tracks quotes to avoid counting parens inside string literals.
+// It handles SQL Server's quote escaping: ” inside strings and ]] inside bracket identifiers.
 func isExitParenBalanced(s string) bool {
 	depth := 0
 	var quote rune
-	for _, c := range s {
+	runes := []rune(s)
+	for i := 0; i < len(runes); i++ {
+		c := runes[i]
 		switch {
 		case quote != 0:
 			// Inside a quoted string
 			if c == quote {
-				quote = 0
+				// Check for escaped quote ('' or ]])
+				if i+1 < len(runes) && runes[i+1] == quote {
+					i++ // skip the escaped quote
+				} else {
+					quote = 0
+				}
 			}
 		case c == '\'' || c == '"':
 			quote = c

pkg/sqlcmd/commands_test.go

@@ -5,7 +5,9 @@ package sqlcmd
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
+	"io"
 	"os"
 	"strings"
 	"testing"
@@ -476,8 +478,12 @@ func TestIsExitParenBalanced(t *testing.T) {
 		{"", true},          // empty string is balanced
 		{"no parens", true}, // no parens is balanced
 		{"(", false},
-		{")", false},       // depth goes -1, not balanced
-		{"(test))", false}, // depth goes -1 at end
+		{")", false},                       // depth goes -1, not balanced
+		{"(test))", false},                 // depth goes -1 at end
+		{"(select 'can''t')", true},        // escaped single quote
+		{"(select [col]]name])", true},     // escaped bracket identifier
+		{"(select 'it''s a )test')", true}, // escaped quote with paren
+		{"(select [a]]])", true},           // escaped bracket with paren
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
@@ -486,3 +492,93 @@ func TestIsExitParenBalanced(t *testing.T) {
 		})
 	}
 }
+
+func TestReadExitContinuation(t *testing.T) {
+	t.Run("reads continuation lines until balanced", func(t *testing.T) {
+		s := &Sqlcmd{}
+		lines := []string{"+ 2)", ""}
+		lineIndex := 0
+		promptSet := ""
+		s.lineIo = &testConsole{
+			OnReadLine: func() (string, error) {
+				if lineIndex >= len(lines) {
+					return "", io.EOF
+				}
+				line := lines[lineIndex]
+				lineIndex++
+				return line, nil
+			},
+			OnPasswordPrompt: func(prompt string) ([]byte, error) {
+				return nil, nil
+			},
+		}
+		s.lineIo.SetPrompt("")
+
+		result, err := readExitContinuation(s, "(select 1")
+		assert.NoError(t, err)
+		assert.Equal(t, "(select 1\r\n+ 2)", result)
+
+		// Verify prompt was set
+		tc := s.lineIo.(*testConsole)
+		promptSet = tc.PromptText
+		assert.Equal(t, "      -> ", promptSet)
+	})
+
+	t.Run("returns error on readline failure", func(t *testing.T) {
+		s := &Sqlcmd{}
+		expectedErr := errors.New("readline error")
+		s.lineIo = &testConsole{
+			OnReadLine: func() (string, error) {
+				return "", expectedErr
+			},
+			OnPasswordPrompt: func(prompt string) ([]byte, error) {
+				return nil, nil
+			},
+		}
+
+		_, err := readExitContinuation(s, "(select 1")
+		assert.Equal(t, expectedErr, err)
+	})
+
+	t.Run("handles multiple continuation lines", func(t *testing.T) {
+		s := &Sqlcmd{}
+		lines := []string{"+ 2", "+ 3", ")"}
+		lineIndex := 0
+		s.lineIo = &testConsole{
+			OnReadLine: func() (string, error) {
+				if lineIndex >= len(lines) {
+					return "", io.EOF
+				}
+				line := lines[lineIndex]
+				lineIndex++
+				return line, nil
+			},
+			OnPasswordPrompt: func(prompt string) ([]byte, error) {
+				return nil, nil
+			},
+		}
+
+		result, err := readExitContinuation(s, "(select 1")
+		assert.NoError(t, err)
+		assert.Equal(t, "(select 1\r\n+ 2\r\n+ 3\r\n)", result)
+	})
+
+	t.Run("returns immediately if already balanced", func(t *testing.T) {
+		s := &Sqlcmd{}
+		readLineCalled := false
+		s.lineIo = &testConsole{
+			OnReadLine: func() (string, error) {
+				readLineCalled = true
+				return "", nil
+			},
+			OnPasswordPrompt: func(prompt string) ([]byte, error) {
+				return nil, nil
+			},
+		}
+
+		result, err := readExitContinuation(s, "(select 1)")
+		assert.NoError(t, err)
+		assert.Equal(t, "(select 1)", result)
+		assert.False(t, readLineCalled, "Readline should not be called for balanced input")
+	})
+}