refactoring

Author: tom-sapletta-com

code2logic/analyzer.py

@@ -48,6 +48,7 @@ class ProjectAnalyzer:
         '.jsx': 'javascript',
         '.ts': 'typescript',
         '.tsx': 'typescript',
+        '.sql': 'sql',
         '.java': 'java',
         '.go': 'go',
         '.rs': 'rust',

code2logic/benchmarks/common.py

@@ -16,7 +16,7 @@ def create_single_project(module_info, file_path: Path) -> ProjectInfo:
     return ProjectInfo(
         name=file_path.name,
         root_path=str(file_path.parent),
-        languages={"python": 1},
+        languages={getattr(module_info, "language", "python") or "python": 1},
         modules=[module_info],
         dependency_graph={},
         dependency_metrics={},

code2logic/chunked_reproduction.py

@@ -13,7 +13,7 @@
 
 import re
 from dataclasses import dataclass
-from typing import List
+from typing import List, Optional
 
 from .utils import estimate_tokens
 
@@ -348,10 +348,13 @@ def merge_chunk_codes(codes: List[str], file_name: str) -> str:
 class ChunkedReproducer:
     """Reproduce code from chunked specifications."""
 
-    def __init__(self, client, model_name: str = 'default'):
+    def __init__(self, client, model_name: str = 'default', max_tokens: Optional[int] = None):
         self.client = client
         self.model_name = model_name
-        self.max_tokens = get_llm_limit(model_name) // 2  # Leave room for response
+        if max_tokens is None:
+            self.max_tokens = get_llm_limit(model_name) // 2  # Leave room for response
+        else:
+            self.max_tokens = int(max_tokens)
 
     def reproduce(self, spec: str, fmt: str, file_name: str) -> ChunkedResult:
         """Reproduce code from specification, chunking if needed."""

code2logic/parsers.py

@@ -1449,6 +1449,8 @@ def _parse_python(self, filepath: str, content: str) -> Optional[ModuleInfo]:
                 module = node.module or ''
                 for alias in node.names:
                     if alias.name == '*':
+                        if module:
+                            imports.append(f"{module}.*")
                         continue
                     imports.append(_combine_import_name(module, alias.name))
             elif isinstance(node, ast.ClassDef):
@@ -1814,6 +1816,50 @@ def _parse_js_ts(self, filepath: str, content: str, language: str) -> ModuleInfo
         for m in re.finditer(r"import\s+.*?from\s+['\"]([^'\"]+)['\"]", content):
             imports.append(m.group(1))
 
+        # Re-export patterns (export * / export {...} from)
+        for m in re.finditer(r"export\s+\*\s+from\s+['\"]([^'\"]+)['\"]", content):
+            mod = m.group(1)
+            imports.append(mod)
+            exports.append(f"* from {mod}")
+
+        for m in re.finditer(r"export\s+\*\s+as\s+(\w+)\s+from\s+['\"]([^'\"]+)['\"]", content):
+            name = m.group(1)
+            mod = m.group(2)
+            imports.append(mod)
+            exports.append(f"* as {name} from {mod}")
+            exports.append(name)
+
+        for m in re.finditer(r"export\s+\{([^}]+)\}\s+from\s+['\"]([^'\"]+)['\"]", content):
+            items = m.group(1)
+            mod = m.group(2)
+            imports.append(mod)
+            for raw in (items or '').split(','):
+                part = raw.strip()
+                if not part:
+                    continue
+                if ' as ' in part:
+                    exported = part.split(' as ', 1)[1].strip()
+                else:
+                    exported = part
+                if exported:
+                    exports.append(exported)
+
+        # Local export list (export { A, B as C };)
+        for m in re.finditer(r"export\s+\{([^}]+)\}\s*;", content):
+            if 'from' in m.group(0):
+                continue
+            items = m.group(1)
+            for raw in (items or '').split(','):
+                part = raw.strip()
+                if not part:
+                    continue
+                if ' as ' in part:
+                    exported = part.split(' as ', 1)[1].strip()
+                else:
+                    exported = part
+                if exported:
+                    exports.append(exported)
+
         # Class patterns
         for m in re.finditer(
             r'(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?',