code2logic 1.0.26__tar.gz → 1.0.27__tar.gz

{code2logic-1.0.26 → code2logic-1.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: code2logic
-Version: 1.0.26
+Version: 1.0.27
 Summary: Convert source code to logical representation for LLM analysis
 License: Apache-2.0
 Keywords: code-analysis,llm,ast,static-analysis,tree-sitter,code-understanding,documentation,dependency-graph,nlp

{code2logic-1.0.26 → code2logic-1.0.27}/code2logic/__init__.py

@@ -18,7 +18,7 @@ Example:
     >>> print(output)
 """
 
-__version__ = "1.0.26"
+__version__ = "1.0.27"
 __author__ = "Softreck"
 __email__ = "info@softreck.dev"
 __license__ = "MIT"

{code2logic-1.0.26 → code2logic-1.0.27}/code2logic/analyzer.py

@@ -52,6 +52,7 @@ class ProjectAnalyzer:
         '.java': 'java',
         '.go': 'go',
         '.rs': 'rust',
+        '.cs': 'csharp',
         '.c': 'cpp',
         '.cpp': 'cpp',
         '.cc': 'cpp',

{code2logic-1.0.26 → code2logic-1.0.27}/code2logic/benchmarks/common.py

@@ -174,19 +174,16 @@ Name the test class Test<ClassName> or TestFunctions."""
     return prompt
 
 
-def get_token_reproduction_prompt(spec: str, fmt: str, file_name: str) -> str:
+def get_token_reproduction_prompt(spec: str, fmt: str, file_name: str, language: str = "python") -> str:
     format_hints = {
         "json": "Parse the JSON structure and implement all classes and functions.",
         "json_compact": "Parse the compact JSON and implement all elements.",
         "yaml": "Parse the YAML structure and implement all classes and functions with exact signatures.",
-        "gherkin": "Implement scenarios as SIMPLE, MINIMAL Python code. NO extra error classes, NO over-engineering. Keep code short and direct.",
+        "gherkin": "Implement scenarios as SIMPLE, MINIMAL code. NO over-engineering. Keep code short and direct.",
         "markdown": "Parse embedded Gherkin (behaviors) and YAML (structures).",
-        "logicml": """Parse LogicML and generate VALID Python code:
-- 'sig: (params) -> Type' = def func(params) -> Type
-- 'sig: async (params)' = async def func(params)
-- 'sig: @property (self)' = @property decorator
-- 'bases: [BaseModel]' = class X(BaseModel) with Field()
-- 'type: re-export' = from .module import X
+        "logicml": """Parse LogicML and generate VALID code:
+- 'sig:' lines describe function signatures (translate to the target language)
+- 'type: re-export' means this module primarily re-exports symbols
 CRITICAL: Ensure valid syntax - balanced brackets, proper indentation, no undefined variables.""",
         "toon": """Parse TOON (Token-Oriented Object Notation) format carefully:
 
@@ -211,17 +208,30 @@ CRITICAL: Use imports[], function_docs, and exact signatures to reproduce code a
     max_spec = 5000
     spec_truncated = spec[:max_spec] if len(spec) > max_spec else spec
 
-    prompt = f"""Generate Python code from this {fmt.upper()} specification.
+    language_norm = (language or "python").strip().lower()
+    lang_label_map = {
+        "python": "Python",
+        "javascript": "JavaScript",
+        "typescript": "TypeScript",
+        "go": "Go",
+        "rust": "Rust",
+        "java": "Java",
+        "csharp": "C#",
+        "sql": "SQL",
+    }
+    lang_label = lang_label_map.get(language_norm, language_norm)
+
+    prompt = f"""Generate {lang_label} code from this {fmt.upper()} specification.
 {format_hints.get(fmt, '')}
 
 {spec_truncated}
 
 Requirements:
-- Complete, working Python code for {file_name}
+- Complete, working {lang_label} code for {file_name}
 - Include imports and type hints
 - Implement all functions with actual logic
 
-```python
+```{language_norm}
 """
     return prompt
 

{code2logic-1.0.26 → code2logic-1.0.27}/code2logic/benchmarks/runner.py

@@ -17,6 +17,7 @@ Usage:
 
 import sys
 import time
+import difflib
 from pathlib import Path
 from typing import List, Optional
 
@@ -56,6 +57,98 @@ def _test_python_runs(code: str, timeout: int = 5) -> bool:
         return True  # Timeout might mean waiting for input
 
 
+def _basic_syntax_ok(code: str, language: str) -> bool:
+    """Heuristic syntax check for non-Python languages."""
+    s = (code or "").strip()
+    if not s:
+        return False
+    if language in ("javascript", "typescript"):
+        # Basic bracket/brace balance to catch the most common truncations
+        pairs = {')': '(', ']': '[', '}': '{'}
+        stack: List[str] = []
+        for ch in s:
+            if ch in "([{":
+                stack.append(ch)
+            elif ch in ")]}":
+                if not stack or stack[-1] != pairs.get(ch):
+                    return False
+                stack.pop()
+        return not stack
+    if language == "go":
+        return "package" in s and "func" in s
+    if language == "rust":
+        return "fn" in s or "struct" in s or "enum" in s
+    if language == "java":
+        return "class" in s or "interface" in s
+    if language == "csharp":
+        return "class" in s or "interface" in s or "record" in s
+    if language == "sql":
+        upper = s.upper()
+        return "CREATE" in upper or "SELECT" in upper or "INSERT" in upper
+    return len(s) > 10
+
+
+def _count_structural_elements(code: str, language: str) -> dict:
+    s = code or ""
+    if language == "python":
+        return {
+            'classes': len(re.findall(r'^class\s+\w+', s, re.MULTILINE)),
+            'functions': len(re.findall(r'^def\s+\w+', s, re.MULTILINE)),
+            'imports': len(re.findall(r'^(?:from|import)\s+', s, re.MULTILINE)),
+        }
+    if language in ("javascript", "typescript"):
+        return {
+            'classes': len(re.findall(r'\bclass\s+\w+', s)),
+            'functions': len(re.findall(r'\bfunction\s+\w+\s*\(', s)) + len(re.findall(r'\bconst\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>', s)),
+            'types': len(re.findall(r'\binterface\s+\w+', s)) + len(re.findall(r'\btype\s+\w+\s*=', s)) + len(re.findall(r'\benum\s+\w+', s)),
+            'imports': len(re.findall(r'^import\s+', s, re.MULTILINE)) + len(re.findall(r'\brequire\(', s)),
+        }
+    if language == "go":
+        return {
+            'types': len(re.findall(r'^type\s+\w+\s+(?:struct|interface)\b', s, re.MULTILINE)),
+            'functions': len(re.findall(r'^func\s+(?:\([^)]*\)\s*)?\w+\s*\(', s, re.MULTILINE)),
+            'imports': len(re.findall(r'^import\b', s, re.MULTILINE)),
+        }
+    if language == "rust":
+        return {
+            'types': len(re.findall(r'\bstruct\s+\w+', s)) + len(re.findall(r'\benum\s+\w+', s)) + len(re.findall(r'\btrait\s+\w+', s)),
+            'functions': len(re.findall(r'\bfn\s+\w+\s*\(', s)),
+            'imports': len(re.findall(r'^use\s+', s, re.MULTILINE)),
+        }
+    if language == "java":
+        return {
+            'types': len(re.findall(r'\bclass\s+\w+', s)) + len(re.findall(r'\binterface\s+\w+', s)) + len(re.findall(r'\benum\s+\w+', s)) + len(re.findall(r'\brecord\s+\w+', s)),
+            'functions': len(re.findall(r'\b\w+\s+\w+\s*\([^)]*\)\s*\{', s)),
+            'imports': len(re.findall(r'^import\s+', s, re.MULTILINE)),
+        }
+    if language == "csharp":
+        return {
+            'types': len(re.findall(r'\bclass\s+\w+', s)) + len(re.findall(r'\binterface\s+\w+', s)) + len(re.findall(r'\brecord\s+\w+', s)),
+            'functions': len(re.findall(r'\b\w+\s+\w+\s*\([^)]*\)\s*\{', s)),
+            'imports': len(re.findall(r'^using\s+', s, re.MULTILINE)),
+        }
+    if language == "sql":
+        upper = s.upper()
+        return {
+            'types': len(re.findall(r'\bCREATE\s+TABLE\s+\w+', upper)) + len(re.findall(r'\bCREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+\w+', upper)),
+            'functions': len(re.findall(r'\bCREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+\w+', upper)),
+        }
+    return {}
+
+
+def _structural_score(original: str, generated: str, language: str) -> float:
+    o = _count_structural_elements(original, language)
+    g = _count_structural_elements(generated, language)
+    if not o:
+        return 0.0
+    keys = list(o.keys())
+    matches = 0
+    for k in keys:
+        if o.get(k, 0) == g.get(k, 0):
+            matches += 1
+    return matches / max(len(keys), 1) * 100
+
+
 def _extract_code(response: str) -> str:
     """Extract code from LLM response."""
     if not response:
@@ -111,8 +204,8 @@ class BenchmarkRunner:
             self.client = get_client()
         return self.client
 
-    def _template_generate_code(self, spec: str, fmt: str, file_name: str) -> str:
-        """Generate minimal Python code without an LLM (fallback mode)."""
+    def _template_generate_code(self, spec: str, fmt: str, file_name: str, language: str = "python") -> str:
+        """Generate minimal code without an LLM (fallback mode)."""
         import re
 
         # Try to infer class/function names from spec
@@ -139,11 +232,35 @@ class BenchmarkRunner:
         classes = [c for c in uniq(classes) if c.isidentifier()][:5]
         functions = [f for f in uniq(functions) if f.isidentifier() and f not in classes][:10]
 
-        code = """from __future__ import annotations
+        language_norm = (language or "python").strip().lower()
+        if language_norm == "python":
+            code = """from __future__ import annotations
 
 from dataclasses import dataclass
 from typing import Any, Optional, List, Dict
 
+"""
+        elif language_norm in ("javascript", "typescript"):
+            code = """// Auto-generated placeholder
+"""
+        elif language_norm == "go":
+            code = """package main
+
+"""
+        elif language_norm == "rust":
+            code = """// Auto-generated placeholder
+"""
+        elif language_norm == "java":
+            code = """// Auto-generated placeholder
+"""
+        elif language_norm == "csharp":
+            code = """// Auto-generated placeholder
+"""
+        elif language_norm == "sql":
+            code = """-- Auto-generated placeholder
+"""
+        else:
+            code = """// Auto-generated placeholder
 """
 
         if not classes and not functions:
@@ -153,20 +270,56 @@ from typing import Any, Optional, List, Dict
             classes = ["GeneratedClass"]
             functions = ["generated_function"]
 
-        for cls in classes:
-            code += f"""@dataclass
+        if language_norm == "python":
+            for cls in classes:
+                code += f"""@dataclass
 class {cls}:
     \"\"\"Generated placeholder for {file_name} ({fmt}).\"\"\"
     value: Any = None
 
 """
 
-        for fn in functions:
-            code += f"""def {fn}(*args: Any, **kwargs: Any) -> Any:
+            for fn in functions:
+                code += f"""def {fn}(*args: Any, **kwargs: Any) -> Any:
     \"\"\"Generated placeholder for {file_name} ({fmt}).\"\"\"
     return None
 
 """
+        elif language_norm in ("javascript", "typescript"):
+            for fn in functions:
+                export_kw = "export " if language_norm == "typescript" else ""
+                code += f"{export_kw}function {fn}(...args) {{\n  return null;\n}}\n\n"
+            for cls in classes:
+                export_kw = "export " if language_norm == "typescript" else ""
+                code += f"{export_kw}class {cls} {{\n  constructor() {{}}\n}}\n\n"
+        elif language_norm == "go":
+            for fn in functions:
+                code += f"func {fn}() {{\n}}\n\n"
+            for cls in classes:
+                code += f"type {cls} struct {{\n}}\n\n"
+        elif language_norm == "rust":
+            for fn in functions:
+                code += f"pub fn {fn}() {{\n}}\n\n"
+            for cls in classes:
+                code += f"pub struct {cls} {{\n}}\n\n"
+        elif language_norm == "java":
+            safe_class = classes[0] if classes else "Generated"
+            code += f"public class {safe_class} {{\n"
+            for fn in functions:
+                code += f"    public static void {fn}() {{ }}\n"
+            code += "}\n"
+        elif language_norm == "csharp":
+            safe_class = classes[0] if classes else "Generated"
+            code += f"public class {safe_class} {{\n"
+            for fn in functions:
+                code += f"    public static void {fn}() {{ }}\n"
+            code += "}\n"
+        elif language_norm == "sql":
+            for cls in classes:
+                code += f"CREATE TABLE {cls} (id INT);\n"
+        else:
+            for fn in functions:
+                code += f"function {fn}() {{}}\n"
 
         return code
 
@@ -213,45 +366,35 @@ class {cls}:
 
         # Analyze project
         path = Path(folder)
-        py_files = list(path.glob('*.py'))
-        if limit:
-            py_files = py_files[:limit]
+        project = analyze_project(str(path), use_treesitter=False)
+        modules = project.modules[:limit] if limit else project.modules
 
-        result.total_files = len(py_files)
+        result.total_files = len(modules)
 
         if verbose:
             render.heading(2, "Format Benchmark")
             render.codeblock("yaml", f"folder: {folder}\nfiles: {len(py_files)}\nformats: [{', '.join(formats)}]")
 
-        project = analyze_project(str(path), use_treesitter=False)
-
         start_time = time.time()
 
         # Process each file with each format
-        for py_file in py_files:
-            original = py_file.read_text()
-
-            # Find module info
-            module_info = None
-            for m in project.modules:
-                if Path(m.path).name == py_file.name:
-                    module_info = m
-                    break
-
-            if not module_info:
+        for module_info in modules:
+            abs_file = path / module_info.path
+            if not abs_file.exists():
                 continue
+            original = abs_file.read_text(encoding='utf-8', errors='ignore')
 
-            single_project = create_single_project(module_info, py_file)
+            single_project = create_single_project(module_info, abs_file)
 
             file_result = FileResult(
-                file_path=str(py_file),
-                language='python',
+                file_path=str(abs_file),
+                language=module_info.language,
                 original_size=len(original),
             )
 
             for fmt in formats:
                 fmt_result = self._test_format(
-                    single_project, original, fmt, py_file.name, client, verbose
+                    single_project, original, fmt, abs_file.name, client, verbose, language=module_info.language
                 )
                 file_result.format_results[fmt] = fmt_result
 
@@ -288,6 +431,7 @@ class {cls}:
         file_name: str,
         client: Optional[BaseLLMClient],
         verbose: bool = False,
+        language: str = "python",
     ) -> FormatResult:
         """Test a single format."""
         result = FormatResult(format_name=fmt)
@@ -299,12 +443,12 @@ class {cls}:
             result.spec_tokens = estimate_tokens(spec)
 
             # Generate prompt
-            prompt = get_token_reproduction_prompt(spec, fmt, file_name)
+            prompt = get_token_reproduction_prompt(spec, fmt, file_name, language=language)
 
             # Reproduce
             start = time.time()
             if client is None:
-                generated = self._template_generate_code(spec, fmt, file_name)
+                generated = self._template_generate_code(spec, fmt, file_name, language=language)
                 result.gen_time = 0.0
             else:
                 response = client.generate(prompt, max_tokens=self.config.max_tokens)
@@ -313,15 +457,26 @@ class {cls}:
             result.generated_size = len(generated)
 
             # Test quality
-            result.syntax_ok = _test_python_syntax(generated)
-            if result.syntax_ok:
-                result.runs_ok = _test_python_runs(generated)
+            language_norm = (language or "python").strip().lower()
+            if language_norm == 'python':
+                result.syntax_ok = _test_python_syntax(generated)
+                if result.syntax_ok:
+                    result.runs_ok = _test_python_runs(generated)
+            else:
+                result.syntax_ok = _basic_syntax_ok(generated, language_norm)
+                result.runs_ok = False
 
             # Calculate metrics
             if original and generated:
-                analysis = self._metrics.analyze(original, generated, spec, format_name=fmt)
-                result.score = analysis.overall_score
-                result.similarity = analysis.overall_score
+                if language_norm == 'python':
+                    analysis = self._metrics.analyze(original, generated, spec, format_name=fmt)
+                    result.score = analysis.overall_score
+                    result.similarity = analysis.text.char_similarity
+                else:
+                    sim = difflib.SequenceMatcher(None, ' '.join(original.split()), ' '.join(generated.split())).ratio() * 100
+                    struct = _structural_score(original, generated, language_norm)
+                    result.similarity = sim
+                    result.score = (sim * 0.7) + (struct * 0.3)
 
             # Efficiency
             if result.spec_size and len(original) > 0:
@@ -753,7 +908,7 @@ Requirements:
 
             # Test format
             fmt_result = self._test_format(
-                single_project, original, fmt, abs_path.name, client, verbose=False
+                single_project, original, fmt, abs_path.name, client, verbose=False, language=module_info.language
             )
 
             file_result.format_results[fmt] = fmt_result

{code2logic-1.0.26 → code2logic-1.0.27}/code2logic/logicml.py

@@ -129,12 +129,16 @@ class LogicMLGenerator:
             lines.append("# Re-export module")
             lines.append("type: re-export")
             lines.append("exports:")
-            for imp in module.imports[:20]:
-                # Extract export name from import
-                if '.' in imp:
-                    export_name = imp.split('.')[-1]
-                else:
-                    export_name = imp
+            export_items: List[str] = []
+            if getattr(module, "exports", None):
+                export_items = [e for e in (module.exports or []) if e]
+            else:
+                export_items = [i for i in (module.imports or []) if i]
+
+            for item in export_items[:20]:
+                export_name = item.strip()
+                if export_name.endswith(".*"):
+                    export_name = "*"
                 lines.append(f"  - {export_name}")
             return '\n'.join(lines)
 

{code2logic-1.0.26 → code2logic-1.0.27}/code2logic/parsers.py

@@ -1424,8 +1424,18 @@ class UniversalParser:
 
         if language == 'python':
             return self._parse_python(filepath, content)
-        elif language in ('javascript', 'typescript'):
+        if language in ('javascript', 'typescript'):
             return self._parse_js_ts(filepath, content, language)
+        if language == 'go':
+            return self._parse_go(filepath, content)
+        if language == 'rust':
+            return self._parse_rust(filepath, content)
+        if language == 'java':
+            return self._parse_java(filepath, content)
+        if language == 'csharp':
+            return self._parse_csharp(filepath, content)
+        if language == 'sql':
+            return self._parse_sql(filepath, content)
         return None
 
     def _parse_python(self, filepath: str, content: str) -> Optional[ModuleInfo]:
@@ -1948,6 +1958,359 @@ class UniversalParser:
             lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('//')])
         )
 
+    def _parse_go(self, filepath: str, content: str) -> ModuleInfo:
+        """Parse Go using regex patterns."""
+        imports: List[str] = []
+        classes: List[ClassInfo] = []
+        functions: List[FunctionInfo] = []
+        types: List[TypeInfo] = []
+        constants: List[str] = []
+        exports: List[str] = []
+
+        for m in re.finditer(r'^package\s+(\w+)', content, re.MULTILINE):
+            _ = m.group(1)
+
+        for m in re.finditer(r'^import\s+\(?\s*"([^"]+)"', content, re.MULTILINE):
+            imports.append(m.group(1))
+
+        for m in re.finditer(r'^type\s+(\w+)\s+struct\b', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name))
+            exports.append(name)
+            types.append(TypeInfo(name=name, kind='struct', definition=''))
+
+        for m in re.finditer(r'^type\s+(\w+)\s+interface\b', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name, is_interface=True))
+            exports.append(name)
+            types.append(TypeInfo(name=name, kind='interface', definition=''))
+
+        for m in re.finditer(r'^func\s+(?:\([^)]*\)\s*)?(\w+)\s*\(([^)]*)\)\s*(\([^)]*\)|\w+)?', content, re.MULTILINE):
+            name = m.group(1)
+            params = [p.strip() for p in (m.group(2) or '').split(',') if p.strip()][:8]
+            ret = (m.group(3) or '').strip()
+            functions.append(FunctionInfo(
+                name=name,
+                params=params,
+                return_type=ret,
+                docstring=None,
+                docstring_full=None,
+                calls=[],
+                raises=[],
+                decorators=[],
+                complexity=1,
+                lines=1,
+                is_async=False,
+                is_static=False,
+                is_classmethod=False,
+                is_property=False,
+                intent=self.intent_gen.generate(name),
+                start_line=0,
+                end_line=0,
+                is_private=False,
+            ))
+            exports.append(name)
+
+        for m in re.finditer(r'^const\s+([A-Z][A-Za-z0-9_]*)\b', content, re.MULTILINE):
+            constants.append(m.group(1))
+
+        lines = content.split('\n')
+        return ModuleInfo(
+            path=filepath,
+            language='go',
+            imports=imports[:20],
+            exports=list(dict.fromkeys(exports))[:50],
+            classes=classes,
+            functions=functions,
+            types=types,
+            constants=constants[:10],
+            docstring=None,
+            lines_total=len(lines),
+            lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('//')])
+        )
+
+    def _parse_rust(self, filepath: str, content: str) -> ModuleInfo:
+        """Parse Rust using regex patterns."""
+        imports: List[str] = []
+        classes: List[ClassInfo] = []
+        functions: List[FunctionInfo] = []
+        types: List[TypeInfo] = []
+        constants: List[str] = []
+        exports: List[str] = []
+
+        for m in re.finditer(r'^use\s+([^;]+);', content, re.MULTILINE):
+            imports.append(m.group(1).strip())
+
+        for m in re.finditer(r'^(?:pub\s+)?struct\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name))
+            types.append(TypeInfo(name=name, kind='struct', definition=''))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:pub\s+)?enum\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            types.append(TypeInfo(name=name, kind='enum', definition=''))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:pub\s+)?trait\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            types.append(TypeInfo(name=name, kind='trait', definition=''))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:pub\s+)?fn\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^\s{]+))?', content, re.MULTILINE):
+            name = m.group(1)
+            params = [p.strip() for p in (m.group(2) or '').split(',') if p.strip()][:8]
+            ret = (m.group(3) or '').strip()
+            functions.append(FunctionInfo(
+                name=name,
+                params=params,
+                return_type=ret,
+                docstring=None,
+                docstring_full=None,
+                calls=[],
+                raises=[],
+                decorators=[],
+                complexity=1,
+                lines=1,
+                is_async='async' in m.group(0),
+                is_static=False,
+                is_classmethod=False,
+                is_property=False,
+                intent=self.intent_gen.generate(name),
+                start_line=0,
+                end_line=0,
+                is_private=False,
+            ))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:pub\s+)?const\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
+            constants.append(m.group(1))
+
+        lines = content.split('\n')
+        return ModuleInfo(
+            path=filepath,
+            language='rust',
+            imports=imports[:20],
+            exports=list(dict.fromkeys(exports))[:50],
+            classes=classes,
+            functions=functions,
+            types=types,
+            constants=constants[:10],
+            docstring=None,
+            lines_total=len(lines),
+            lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('//')])
+        )
+
+    def _parse_java(self, filepath: str, content: str) -> ModuleInfo:
+        """Parse Java using regex patterns."""
+        imports: List[str] = []
+        classes: List[ClassInfo] = []
+        functions: List[FunctionInfo] = []
+        types: List[TypeInfo] = []
+        constants: List[str] = []
+        exports: List[str] = []
+
+        for m in re.finditer(r'^import\s+([^;]+);', content, re.MULTILINE):
+            imports.append(m.group(1).strip())
+
+        for m in re.finditer(r'^(?:public\s+)?(?:abstract\s+)?class\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name, is_abstract='abstract' in m.group(0)))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:public\s+)?interface\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name, is_interface=True))
+            exports.append(name)
+            types.append(TypeInfo(name=name, kind='interface', definition=''))
+
+        for m in re.finditer(r'^(?:public\s+)?enum\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            types.append(TypeInfo(name=name, kind='enum', definition=''))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:public\s+)?record\s+(\w+)\s*\(', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name))
+            types.append(TypeInfo(name=name, kind='record', definition=''))
+            exports.append(name)
+
+        # Very rough method detection (only top-level class members are not tracked here)
+        for m in re.finditer(r'^(?:public|protected|private)\s+(?:static\s+)?([\w<>\[\]]+)\s+(\w+)\s*\(([^)]*)\)\s*\{', content, re.MULTILINE):
+            ret_type = m.group(1)
+            name = m.group(2)
+            params = [p.strip() for p in (m.group(3) or '').split(',') if p.strip()][:8]
+            functions.append(FunctionInfo(
+                name=name,
+                params=params,
+                return_type=ret_type,
+                docstring=None,
+                docstring_full=None,
+                calls=[],
+                raises=[],
+                decorators=[],
+                complexity=1,
+                lines=1,
+                is_async=False,
+                is_static='static' in m.group(0),
+                is_classmethod=False,
+                is_property=False,
+                intent=self.intent_gen.generate(name),
+                start_line=0,
+                end_line=0,
+                is_private=False,
+            ))
+
+        for m in re.finditer(r'^(?:public\s+)?static\s+final\s+[\w<>\[\]]+\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
+            constants.append(m.group(1))
+
+        lines = content.split('\n')
+        return ModuleInfo(
+            path=filepath,
+            language='java',
+            imports=imports[:20],
+            exports=list(dict.fromkeys(exports))[:50],
+            classes=classes,
+            functions=functions,
+            types=types,
+            constants=constants[:10],
+            docstring=None,
+            lines_total=len(lines),
+            lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('//')])
+        )
+
+    def _parse_csharp(self, filepath: str, content: str) -> ModuleInfo:
+        """Parse C# using regex patterns."""
+        imports: List[str] = []
+        classes: List[ClassInfo] = []
+        functions: List[FunctionInfo] = []
+        types: List[TypeInfo] = []
+        constants: List[str] = []
+        exports: List[str] = []
+
+        for m in re.finditer(r'^using\s+([^;]+);', content, re.MULTILINE):
+            imports.append(m.group(1).strip())
+
+        for m in re.finditer(r'^(?:public\s+)?interface\s+(I\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name, is_interface=True))
+            exports.append(name)
+            types.append(TypeInfo(name=name, kind='interface', definition=''))
+
+        for m in re.finditer(r'^(?:public\s+)?(?:abstract\s+)?class\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name, is_abstract='abstract' in m.group(0)))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:public\s+)?record\s+(\w+)', content, re.MULTILINE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name))
+            exports.append(name)
+            types.append(TypeInfo(name=name, kind='record', definition=''))
+
+        for m in re.finditer(r'^(?:public|private|protected|internal)\s+(?:static\s+)?([\w<>\[\]?]+)\s+(\w+)\s*\(([^)]*)\)\s*\{', content, re.MULTILINE):
+            ret_type = m.group(1)
+            name = m.group(2)
+            params = [p.strip() for p in (m.group(3) or '').split(',') if p.strip()][:8]
+            functions.append(FunctionInfo(
+                name=name,
+                params=params,
+                return_type=ret_type,
+                docstring=None,
+                docstring_full=None,
+                calls=[],
+                raises=[],
+                decorators=[],
+                complexity=1,
+                lines=1,
+                is_async='async' in m.group(0),
+                is_static='static' in m.group(0),
+                is_classmethod=False,
+                is_property=False,
+                intent=self.intent_gen.generate(name),
+                start_line=0,
+                end_line=0,
+                is_private=False,
+            ))
+
+        for m in re.finditer(r'^(?:public\s+)?const\s+[\w<>\[\]]+\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
+            constants.append(m.group(1))
+
+        lines = content.split('\n')
+        return ModuleInfo(
+            path=filepath,
+            language='csharp',
+            imports=imports[:20],
+            exports=list(dict.fromkeys(exports))[:50],
+            classes=classes,
+            functions=functions,
+            types=types,
+            constants=constants[:10],
+            docstring=None,
+            lines_total=len(lines),
+            lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('//')])
+        )
+
+    def _parse_sql(self, filepath: str, content: str) -> ModuleInfo:
+        """Parse SQL using regex patterns."""
+        imports: List[str] = []
+        classes: List[ClassInfo] = []
+        functions: List[FunctionInfo] = []
+        types: List[TypeInfo] = []
+        constants: List[str] = []
+        exports: List[str] = []
+
+        for m in re.finditer(r'CREATE\s+TABLE\s+(\w+)', content, re.IGNORECASE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name))
+            exports.append(name)
+            types.append(TypeInfo(name=name, kind='table', definition=''))
+
+        for m in re.finditer(r'CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+(\w+)', content, re.IGNORECASE):
+            name = m.group(1)
+            classes.append(ClassInfo(name=name))
+            exports.append(name)
+            types.append(TypeInfo(name=name, kind='view', definition=''))
+
+        for m in re.finditer(r'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+(\w+)', content, re.IGNORECASE):
+            name = m.group(1)
+            functions.append(FunctionInfo(
+                name=name,
+                params=[],
+                return_type='',
+                docstring=None,
+                docstring_full=None,
+                calls=[],
+                raises=[],
+                decorators=[],
+                complexity=1,
+                lines=1,
+                is_async=False,
+                is_static=False,
+                is_classmethod=False,
+                is_property=False,
+                intent=self.intent_gen.generate(name),
+                start_line=0,
+                end_line=0,
+                is_private=False,
+            ))
+            exports.append(name)
+
+        lines = content.split('\n')
+        return ModuleInfo(
+            path=filepath,
+            language='sql',
+            imports=imports,
+            exports=list(dict.fromkeys(exports))[:50],
+            classes=classes,
+            functions=functions,
+            types=types,
+            constants=constants,
+            docstring=None,
+            lines_total=len(lines),
+            lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('--')])
+        )
+
 
 def is_tree_sitter_available() -> bool:
     """Check if Tree-sitter is available."""

{code2logic-1.0.26 → code2logic-1.0.27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "code2logic"
-version = "1.0.26"
+version = "1.0.27"
 description = "Convert source code to logical representation for LLM analysis"
 readme = "README.md"
 license = "Apache-2.0"
@@ -183,7 +183,7 @@ module = [
 ignore_missing_imports = true
 
 [tool.bumpver]
-current_version = "1.0.26"
+current_version = "1.0.27"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false
 tag = false