Address second round of PR #113 review comments

- regex.ts: raise branch length threshold from >= 1 to >= 3 in
  extractApiTerm — short branches like /a|bc/ now fall through to the
  longest-literal path which enforces the existing '< 3 chars → warn'
  rule, preventing extremely broad API queries such as 'a OR bc'
- aggregate.ts: align regexFilter type with buildApiQuery return value;
  accept RegExp | null | undefined (via RegExp | null optional param) and
  update guard from !== undefined to != null so callers can pass the
  result of buildApiQuery directly without a null→undefined conversion
- regex.test.ts: add test for short-branch alternation fallback (/a|bc/)
- aggregate.test.ts: add test for null regexFilter treated as no-op

Author: shouze

src/aggregate.test.ts

@@ -195,6 +195,16 @@ describe("aggregate — regexFilter", () => {
     expect(groups).toHaveLength(2);
   });
 
+  it("keeps all matches when regexFilter is null (backward compat — null treated as no filter)", () => {
+    const matches: CodeMatch[] = [
+      makeMatchWithFragments("myorg/repoA", "src/a.ts", ["const x = 1"]),
+      makeMatchWithFragments("myorg/repoB", "src/b.ts", ["const y = 2"]),
+    ];
+
+    const groups = aggregate(matches, new Set(), new Set(), false, null);
+    expect(groups).toHaveLength(2);
+  });
+
   it("respects regex flags (case-insensitive)", () => {
     const matches: CodeMatch[] = [
       makeMatchWithFragments("myorg/repoA", "src/a.ts", ["import AXIOS from 'axios'"]),

src/aggregate.ts

@@ -34,15 +34,15 @@ export function aggregate(
   excludedRepos: Set<string>,
   excludedExtractRefs: Set<string>,
   includeArchived = false,
-  regexFilter?: RegExp,
+  regexFilter?: RegExp | null,
 ): RepoGroup[] {
   const map = new Map<string, CodeMatch[]>();
   for (const m of matches) {
     if (excludedRepos.has(m.repoFullName)) continue;
     if (!includeArchived && m.archived) continue;
     // Fix: when a regex filter is active, only keep matches where at least one
     // text_match fragment satisfies the pattern — see issue #111
-    if (regexFilter !== undefined) {
+    if (regexFilter != null) {
       const hasMatch = m.textMatches.some((tm) => {
         // Fix: reset lastIndex before each call — a global/sticky regex is
         // stateful and would produce false negatives on subsequent fragments.

src/regex.test.ts

@@ -69,6 +69,15 @@ describe("buildApiQuery — top-level alternation → OR", () => {
     expect(r.warn).toBeUndefined();
   });
 
+  it("/a|bc/ — short branches (< 3 chars each) fall back to longest literal and warn", () => {
+    // branches: "a" (1 char) and "bc" (2 chars) — both < 3 → fall back to
+    // longestLiteralSequence("a|bc") → "bc" (2 chars) < 3 → warn + empty term
+    const r = buildApiQuery("/a|bc/");
+    expect(r.warn).toBeDefined();
+    expect(r.apiQuery).toBe("");
+    expect(r.regexFilter).not.toBeNull();
+  });
+
   it("/\\\\|foo/ — escaped backslash before | → | is top-level → falls back to longest literal 'foo'", () => {
     // Pattern \\|foo: \\ is an escaped backslash (matches literal \), | is top-level.
     // splitTopLevelAlternation gives ["\\", "foo"]; "\\" yields no useful literal

src/regex.ts

@@ -108,10 +108,12 @@ function extractApiTerm(pattern: string): { term: string; warn?: string } {
   // 1. Top-level alternation detection.
   const branches = splitTopLevelAlternation(pattern);
   if (branches.length > 1) {
-    // Each branch must yield a meaningful literal to use the OR strategy;
-    // otherwise fall through to the longest-literal approach.
+    // Each branch must yield a meaningful literal (>= 3 chars) to use the OR
+    // strategy — the same minimum enforced by the single-literal path below.
+    // Branches shorter than 3 chars (e.g. /a|bc/) fall through so the global
+    // "< 3 chars → warn + empty term" rule still applies.
     const branchTerms = branches.map((b) => longestLiteralSequence(b));
-    if (branchTerms.every((t) => t.length >= 1)) {
+    if (branchTerms.every((t) => t.length >= 3)) {
       return { term: branchTerms.join(" OR ") };
     }
   }