Add Location wrapping and quote-aware key=value parsing for context view

- Location field now wraps long paths across multiple lines
- Custom and Environment edits now support quoted values:
  KEY="sentence with spaces", KEY='value', KEY=`value`
- Added wrapText helper that breaks on path separators
- Added parseKeyValue function with tests

Author: zach-source

internal/components/contextview/model.go

@@ -60,6 +60,7 @@ const (
 	EditAWSRegion  EditField = "aws.region"
 	EditGitBranch  EditField = "git.branch"
 	EditEnvVar     EditField = "env"
+	EditCustom     EditField = "custom"
 )
 
 // Model represents the context component state
@@ -214,6 +215,48 @@ func (m Model) handleEditKeys(msg tea.KeyMsg) (Model, tea.Cmd) {
 	return m, cmd
 }
 
+// parseKeyValue parses a KEY=VALUE string where VALUE can be quoted with ", ', or `
+// Examples:
+//   - "foo=bar" -> ("foo", "bar")
+//   - "foo='hello world'" -> ("foo", "hello world")
+//   - `foo="my sentence"` -> ("foo", "my sentence")
+//   - "foo=`backtick quoted`" -> ("foo", "backtick quoted")
+func parseKeyValue(input string) (key, value string, ok bool) {
+	// Find the first = sign
+	eqIdx := -1
+	for i, c := range input {
+		if c == '=' {
+			eqIdx = i
+			break
+		}
+	}
+
+	if eqIdx <= 0 {
+		return "", "", false
+	}
+
+	key = input[:eqIdx]
+	remainder := input[eqIdx+1:]
+
+	// Check if value is quoted
+	if len(remainder) >= 2 {
+		first := remainder[0]
+		if first == '"' || first == '\'' || first == '`' {
+			// Find matching closing quote
+			for i := len(remainder) - 1; i > 0; i-- {
+				if remainder[i] == first {
+					value = remainder[1:i]
+					return key, value, true
+				}
+			}
+		}
+	}
+
+	// Not quoted, use the whole remainder
+	value = remainder
+	return key, value, true
+}
+
 // saveEdit saves the current edit to the context
 func (m *Model) saveEdit() {
 	if m.current == nil {
@@ -243,6 +286,26 @@ func (m *Model) saveEdit() {
 		if git := m.current.GetGit(); git != nil {
 			git.Branch = value
 		}
+	case EditEnvVar:
+		// Parse KEY=VALUE with quote support and merge into existing env
+		if k, v, ok := parseKeyValue(value); ok {
+			env := m.current.GetEnv()
+			if env == nil {
+				env = make(map[string]string)
+			}
+			env[k] = v
+			m.current.SetEnv(env)
+		}
+	case EditCustom:
+		// Parse KEY=VALUE with quote support and merge into existing custom
+		if k, v, ok := parseKeyValue(value); ok {
+			custom := m.current.GetCustom()
+			if custom == nil {
+				custom = make(map[string]string)
+			}
+			custom[k] = v
+			m.current.SetCustom(custom)
+		}
 	}
 
 	// Save context

internal/components/contextview/model_test.go

@@ -0,0 +1,97 @@
+package contextview
+
+import (
+	"testing"
+)
+
+func TestParseKeyValue(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		wantKey string
+		wantVal string
+		wantOk  bool
+	}{
+		{
+			name:    "simple key=value",
+			input:   "foo=bar",
+			wantKey: "foo",
+			wantVal: "bar",
+			wantOk:  true,
+		},
+		{
+			name:    "double quoted value",
+			input:   `foo="hello world"`,
+			wantKey: "foo",
+			wantVal: "hello world",
+			wantOk:  true,
+		},
+		{
+			name:    "single quoted value",
+			input:   `foo='hello world'`,
+			wantKey: "foo",
+			wantVal: "hello world",
+			wantOk:  true,
+		},
+		{
+			name:    "backtick quoted value",
+			input:   "foo=`hello world`",
+			wantKey: "foo",
+			wantVal: "hello world",
+			wantOk:  true,
+		},
+		{
+			name:    "quoted sentence",
+			input:   `TARGET="production cluster in us-east-1"`,
+			wantKey: "TARGET",
+			wantVal: "production cluster in us-east-1",
+			wantOk:  true,
+		},
+		{
+			name:    "value with equals",
+			input:   `CONNECT_STRING="user=admin host=localhost"`,
+			wantKey: "CONNECT_STRING",
+			wantVal: "user=admin host=localhost",
+			wantOk:  true,
+		},
+		{
+			name:   "no equals sign",
+			input:  "justkey",
+			wantOk: false,
+		},
+		{
+			name:   "empty key",
+			input:  "=value",
+			wantOk: false,
+		},
+		{
+			name:    "empty value",
+			input:   "key=",
+			wantKey: "key",
+			wantVal: "",
+			wantOk:  true,
+		},
+		{
+			name:    "unquoted with spaces",
+			input:   "key=hello world",
+			wantKey: "key",
+			wantVal: "hello world",
+			wantOk:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			key, val, ok := parseKeyValue(tt.input)
+			if ok != tt.wantOk {
+				t.Errorf("parseKeyValue(%q) ok = %v, want %v", tt.input, ok, tt.wantOk)
+			}
+			if ok && key != tt.wantKey {
+				t.Errorf("parseKeyValue(%q) key = %q, want %q", tt.input, key, tt.wantKey)
+			}
+			if ok && val != tt.wantVal {
+				t.Errorf("parseKeyValue(%q) val = %q, want %q", tt.input, val, tt.wantVal)
+			}
+		})
+	}
+}

internal/components/contextview/view.go

@@ -8,6 +8,34 @@ import (
 	"github.com/charmbracelet/lipgloss/table"
 )
 
+// wrapText wraps text at the given width, breaking on path separators when possible
+func wrapText(text string, width int) []string {
+	if len(text) <= width {
+		return []string{text}
+	}
+
+	var lines []string
+	remaining := text
+
+	for len(remaining) > width {
+		// Find a good break point (prefer / for paths)
+		breakAt := width
+		for i := width - 1; i > width/2; i-- {
+			if remaining[i] == '/' {
+				breakAt = i + 1
+				break
+			}
+		}
+		lines = append(lines, remaining[:breakAt])
+		remaining = remaining[breakAt:]
+	}
+	if len(remaining) > 0 {
+		lines = append(lines, remaining)
+	}
+
+	return lines
+}
+
 // View renders the context display
 func (m Model) View() string {
 	if m.editMode {
@@ -33,9 +61,18 @@ func (m Model) renderCurrentContext() string {
 		return sb.String()
 	}
 
-	// Project info
-	sb.WriteString(m.theme.Selected.Render("📁 Project:") + " ")
-	sb.WriteString(m.theme.Normal.Render(m.current.ProjectRoot) + "\n\n")
+	// Project info - wrap long paths across multiple lines
+	sb.WriteString(m.theme.Selected.Render("📁 Location:") + "\n")
+	// Wrap the path with a reasonable width
+	pathWidth := m.width - 4
+	if pathWidth < 40 {
+		pathWidth = 40
+	}
+	wrappedPath := wrapText(m.current.ProjectRoot, pathWidth)
+	for _, line := range wrappedPath {
+		sb.WriteString("   " + m.theme.Normal.Render(line) + "\n")
+	}
+	sb.WriteString("\n")
 
 	// Build table rows for context details
 	var rows [][]string
@@ -206,6 +243,13 @@ func (m Model) renderEditView() string {
 
 	sb.WriteString(m.theme.Dim.Render("Field: ") + m.theme.Normal.Render(string(m.editField)) + "\n\n")
 	sb.WriteString(m.editInput.View() + "\n\n")
+
+	// Show format hint for key=value fields
+	if m.editField == EditEnvVar || m.editField == EditCustom {
+		sb.WriteString(m.theme.Dim.Render("Format: KEY=value or KEY=\"sentence with spaces\"") + "\n")
+		sb.WriteString(m.theme.Dim.Render("        Quotes: \" ' or ` for multi-word values") + "\n\n")
+	}
+
 	sb.WriteString(m.theme.Dim.Render("Enter:save  Esc:cancel"))
 
 	return sb.String()