fix(go): harden import parsing

Author: johnhuang316

src/code_index_mcp/indexing/strategies/go_strategy.py

@@ -21,40 +21,18 @@ def parse_file(self, file_path: str, content: str) -> Tuple[Dict[str, SymbolInfo
         """Parse Go file using regex patterns."""
         symbols = {}
         functions = []
+        lines = content.splitlines()
         classes = []  # Go doesn't have classes, but we'll track structs/interfaces
-        imports = []
+        imports = self._extract_go_imports(lines)
         package = None
 
-        lines = content.splitlines()
-        in_import_block = False
-
         for i, line in enumerate(lines):
             line = line.strip()
 
             # Package declaration
             if line.startswith('package '):
                 package = line.split('package ')[1].strip()
 
-            # Import statements
-            elif line.startswith('import '):
-                # Single import: import "package"
-                import_match = re.search(r'import\s+"([^"]+)"', line)
-                if import_match:
-                    imports.append(import_match.group(1))
-                # Multi-line import block: import (
-                elif '(' in line:
-                    in_import_block = True
-            
-            # Inside import block
-            elif in_import_block:
-                if ')' in line:
-                    in_import_block = False
-                else:
-                    # Extract import path from quotes
-                    import_match = re.search(r'"([^"]+)"', line)
-                    if import_match:
-                        imports.append(import_match.group(1))
-
             # Function declarations
             elif line.startswith('func '):
                 func_match = re.match(r'func\s+(\w+)\s*\(', line)
@@ -170,6 +148,141 @@ def _extract_go_function_name(self, line: str) -> Optional[str]:
             pass
         return None
 
+    def _extract_go_imports(self, lines: List[str]) -> List[str]:
+        """Extract Go import paths, handling multi-line blocks and comments."""
+        imports: List[str] = []
+        in_block_comment = False
+        paren_depth = 0
+
+        for raw_line in lines:
+            clean_line, in_block_comment = self._strip_go_comments(raw_line, in_block_comment)
+            stripped = clean_line.strip()
+
+            if not stripped:
+                continue
+
+            if paren_depth == 0:
+                if not stripped.startswith('import '):
+                    continue
+
+                remainder = stripped[len('import '):].strip()
+                if not remainder:
+                    continue
+
+                imports.extend(self._extract_string_literals(remainder))
+
+                paren_depth = (
+                    self._count_unquoted_characters(remainder, '(')
+                    - self._count_unquoted_characters(remainder, ')')
+                )
+                if paren_depth <= 0:
+                    paren_depth = 0
+                continue
+
+            imports.extend(self._extract_string_literals(clean_line))
+            paren_depth += self._count_unquoted_characters(clean_line, '(')
+            paren_depth -= self._count_unquoted_characters(clean_line, ')')
+            if paren_depth <= 0:
+                paren_depth = 0
+
+        return imports
+
+    def _strip_go_comments(self, line: str, in_block_comment: bool) -> Tuple[str, bool]:
+        """Remove Go comments from a line while tracking block comment state."""
+        result: List[str] = []
+        i = 0
+        length = len(line)
+
+        while i < length:
+            if in_block_comment:
+                if line.startswith('*/', i):
+                    in_block_comment = False
+                    i += 2
+                else:
+                    i += 1
+                continue
+
+            if line.startswith('//', i):
+                break
+
+            if line.startswith('/*', i):
+                in_block_comment = True
+                i += 2
+                continue
+
+            result.append(line[i])
+            i += 1
+
+        return ''.join(result), in_block_comment
+
+    def _extract_string_literals(self, line: str) -> List[str]:
+        """Return string literal values found in a line (supports " and `)."""
+        literals: List[str] = []
+        i = 0
+        length = len(line)
+
+        while i < length:
+            char = line[i]
+            if char not in ('"', '`'):
+                i += 1
+                continue
+
+            delimiter = char
+            i += 1
+            buffer: List[str] = []
+            while i < length:
+                current = line[i]
+                if delimiter == '"':
+                    if current == '\\':
+                        if i + 1 < length:
+                            buffer.append(line[i + 1])
+                            i += 2
+                            continue
+                    elif current == '"':
+                        literals.append(''.join(buffer))
+                        i += 1
+                        break
+                else:  # Raw string delimited by backticks
+                    if current == '`':
+                        literals.append(''.join(buffer))
+                        i += 1
+                        break
+
+                buffer.append(current)
+                i += 1
+            else:
+                break
+
+        return literals
+
+    def _count_unquoted_characters(self, line: str, target: str) -> int:
+        """Count occurrences of a character outside string literals."""
+        count = 0
+        i = 0
+        length = len(line)
+        delimiter: Optional[str] = None
+
+        while i < length:
+            char = line[i]
+            if delimiter is None:
+                if char in ('"', '`'):
+                    delimiter = char
+                elif char == target:
+                    count += 1
+            else:
+                if delimiter == '"':
+                    if char == '\\':
+                        i += 2
+                        continue
+                    if char == '"':
+                        delimiter = None
+                elif delimiter == '`' and char == '`':
+                    delimiter = None
+
+            i += 1
+
+        return count
+
     def _extract_go_comment(self, lines: List[str], line_index: int) -> Optional[str]:
         """Extract Go comment (docstring) from lines preceding the given line.
         
@@ -244,4 +357,3 @@ def _extract_go_called_functions(self, line: str) -> List[str]:
             called_functions.extend(matches)
 
         return called_functions
-

tests/strategies/test_go_discovery.py

@@ -1,9 +1,6 @@
 #!/usr/bin/env python3
-"""
-Test for Go symbol discovery including all symbol types.
-"""
+"""Test for Go symbol discovery including all symbol types."""
 import pytest
-from textwrap import dedent
 
 from code_index_mcp.indexing.strategies.go_strategy import GoParsingStrategy
 
@@ -15,12 +12,17 @@ def test_code_with_all_symbols():
 package main
 
 import (
-    "fmt"
-    "strings"
+    "fmt" // comment mentioning ) parentheses )
+    strutil "strings"
+    helper "example.com/project/toolkit"
+) // closing comment with ) ) characters
+import ("math" /* inline comment ) inside */)
+import . "errors"
+import _ "embed"
+import (
+    "time"
 )
 
-import "errors"
-
 // Application version constant
 const VERSION = "1.0.0"
 
@@ -154,10 +156,14 @@ def test_go_symbol_discovery(test_code_with_all_symbols):
     # Verify package is extracted
     assert file_info.package == "main"
 
-    # Verify imports are extracted (both multi-line block and single-line)
+    # Verify imports are extracted (including tricky formats and aliases)
     assert "fmt" in file_info.imports
     assert "strings" in file_info.imports
     assert "errors" in file_info.imports
+    assert "example.com/project/toolkit" in file_info.imports
+    assert "math" in file_info.imports
+    assert "embed" in file_info.imports
+    assert "time" in file_info.imports
 
     # Verify all expected functions are in file_info
     discovered_functions = file_info.symbols.get('functions', [])