fix(queryLanguage): allow parenthesized regex alternation in filter values

Queries like `file:(test|spec)` or `-file:(test|spec)` previously failed
with "No parse at N" because the word tokenizer unconditionally deferred
to parenToken whenever a token started with balanced parentheses, even in
value contexts (right after a prefix keyword colon like `file:`, `repo:`,
`sym:`, etc.).

The fix detects value context by looking backward for a preceding ':' and,
when found, uses depth-tracking to consume the entire '(...)' as a word
instead of deferring. This correctly handles nested parens, stops at an
outer ParenExpr closing paren, and leaves all existing parse behaviour
unchanged for non-value contexts.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: brendan-kellam

packages/queryLanguage/src/tokens.ts

@@ -313,14 +313,44 @@ export const wordToken = new ExternalTokenizer((input, stack) => {
         return;
     }
 
-    // If starts with '(' and has balanced parens, don't consume as word
-    // (let parenToken handle it)
+    // If starts with '(' and has balanced parens, determine whether this is a
+    // regex alternation value (e.g. file:(test|spec)) or a ParenExpr grouping.
+    // We're in a value context when the immediately preceding non-whitespace char
+    // is ':', meaning we're right after a prefix keyword. In that case consume the
+    // entire '(...)' as a word using depth-tracking so the consuming loop doesn't
+    // stop early at ')'. Otherwise defer to parenToken for grouping.
+    let inValueParenContext = false;
     if (input.next === OPEN_PAREN && hasBalancedParensAt(input, 0)) {
-        return;
+        let backOffset = -1;
+        while (isWhitespace(input.peek(backOffset))) {
+            backOffset--;
+        }
+        if (input.peek(backOffset) === COLON) {
+            inValueParenContext = true;
+        } else {
+            return; // Not a value context — defer to parenToken for grouping
+        }
     }
-    
+
     const startPos = input.pos;
 
+    if (inValueParenContext) {
+        // Consume the parenthesized pattern with depth tracking so we consume
+        // the matching ')' without stopping early. A ')' at depth 0 means we've
+        // hit an outer ParenExpr closing paren — stop without consuming it.
+        let depth = 0;
+        while (input.next !== EOF) {
+            const ch = input.next;
+            if (isWhitespace(ch)) break;
+            if (ch === OPEN_PAREN) {
+                depth++;
+            } else if (ch === CLOSE_PAREN) {
+                if (depth === 0) break; // outer ParenExpr closing — don't consume
+                depth--;
+            }
+            input.advance();
+        }
+    } else {
     // Consume characters
     while (input.next !== EOF) {
         const ch = input.next;
@@ -339,7 +369,8 @@ export const wordToken = new ExternalTokenizer((input, stack) => {
 
         input.advance();
     }
-    
+    }
+
     if (input.pos > startPos) {
         input.acceptToken(word);
     }

packages/queryLanguage/test/negation.txt

@@ -253,3 +253,27 @@ Program(NegateExpr(ParenExpr))
 ==>
 
 Program(NegateExpr(PrefixExpr(FileExpr)))
+
+# Negate file with regex alternation in value
+
+-file:(test|spec)
+
+==>
+
+Program(NegateExpr(PrefixExpr(FileExpr)))
+
+# Negate repo with regex alternation in value
+
+-repo:(org1|org2)
+
+==>
+
+Program(NegateExpr(PrefixExpr(RepoExpr)))
+
+# Complex query with negated file alternation
+
+chat lang:TypeScript -file:(test|spec)
+
+==>
+
+Program(AndExpr(Term,PrefixExpr(LangExpr),NegateExpr(PrefixExpr(FileExpr))))

packages/queryLanguage/test/prefixes.txt

@@ -334,3 +334,43 @@ Program(ParenExpr(PrefixExpr(FileExpr)))
 
 Program(ParenExpr(AndExpr(PrefixExpr(FileExpr),PrefixExpr(LangExpr))))
 
+# File with regex alternation in value
+
+file:(test|spec)
+
+==>
+
+Program(PrefixExpr(FileExpr))
+
+# Repo with regex alternation in value
+
+repo:(org1|org2)
+
+==>
+
+Program(PrefixExpr(RepoExpr))
+
+# Sym with regex alternation in value
+
+sym:(Foo|Bar)
+
+==>
+
+Program(PrefixExpr(SymExpr))
+
+# Content with regex alternation in value
+
+content:(error|warning)
+
+==>
+
+Program(PrefixExpr(ContentExpr))
+
+# File alternation combined with other filters
+
+file:(test|spec) lang:TypeScript
+
+==>
+
+Program(AndExpr(PrefixExpr(FileExpr),PrefixExpr(LangExpr)))
+