code2logic 1.0.41__tar.gz → 1.0.43__tar.gz

{code2logic-1.0.41 → code2logic-1.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2logic
-Version: 1.0.41
+Version: 1.0.43
 Summary: Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support.
 License: Apache-2.0
 License-File: LICENSE

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/__init__.py

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

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/benchmarks/common.py

@@ -41,6 +41,7 @@ def generate_spec(project: ProjectInfo, fmt: str) -> str:
             no_repeat_name=True,
             no_repeat_details=True,
             include_does=True,
+            context="minimal",
         )
     if fmt == "csv":
         gen = CSVGenerator()
@@ -189,22 +190,66 @@ Name the test class Test<ClassName> or TestFunctions."""
 
 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 with exact signatures.",
+        "json": """Parse the JSON structure carefully:
+- 'modules' array contains file-level info with 'classes' and 'functions'
+- Each class has 'name', 'bases', 'methods' with full signatures
+- Each function has 'name', 'params', 'returns', 'doc'
+- Implement ALL classes with their methods and ALL standalone functions
+- Use the 'doc' field to implement actual logic, not just stubs
+CRITICAL: Match every class/function name and signature exactly.""",
         "json_compact": "Parse the compact JSON and implement all elements with exact signatures.",
-        "yaml": "Parse the YAML structure and implement all classes and functions with exact signatures.",
-        "gherkin": """Parse Gherkin/BDD scenarios and implement them as working code:
-- Each Feature maps to a class or module
-- Each Scenario maps to a function
-- Given/When/Then steps describe the logic flow
-- Implement actual logic, not just stubs
-Focus on the described behavior and implement it directly.""",
-        "markdown": "Parse embedded Gherkin (behaviors) and YAML (structures). Implement all described classes and functions.",
-        "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
-- 'attrs:' = instance attributes to set in constructor
+        "yaml": """Parse the YAML structure carefully:
+- Top-level keys describe modules with classes and functions
+- Each class has 'bases', 'properties', 'methods' with signatures
+- Each function has params, return type, and docstring/intent
+- Implement ALL classes, methods, and standalone functions
+- Use intent/docstring to write actual logic, not placeholders
+CRITICAL: Match every name and signature exactly as specified.""",
+        "gherkin": """Parse Gherkin/BDD specification and reconstruct the ORIGINAL source code:
+- 'Feature:' = a class or module (use the name after Feature)
+- 'Scenario:' = a function or method to implement
+- 'Given' steps = setup / preconditions / imports needed
+- 'When' steps = the core action / logic to implement
+- 'Then' steps = expected outcomes / return values / assertions
+- 'And' continues the previous step type
+- '@tag' annotations may indicate decorators or categories
+
+IMPORTANT RULES:
+1. Each Scenario becomes a real function with actual logic (NOT test code)
+2. Given/When/Then describe behavior, translate them to implementation
+3. Include all imports mentioned in Given steps
+4. Use type hints based on parameter descriptions
+5. Implement real logic based on When/Then steps, not just stubs
+6. If a Feature has multiple Scenarios, they are methods of the same class""",
+        "markdown": """Parse the Markdown specification to reconstruct source code:
+- '## Module' or '### Class' headings define code structure
+- Embedded YAML blocks describe attributes, methods, signatures
+- Embedded Gherkin blocks describe behaviors to implement
+- Code blocks show example usage or signatures
+- Tables may list functions with their parameters and return types
+
+IMPORTANT RULES:
+1. Extract class names, method signatures, and function signatures from headings and YAML
+2. Implement all listed methods with actual logic based on descriptions
+3. Include all imports mentioned anywhere in the document
+4. Use type hints from signatures or parameter descriptions
+5. Docstrings should come from the description text""",
+        "logicml": """Parse LogicML and generate VALID, complete code:
+- 'module:' = file to generate
+- 'sig:' lines = EXACT function signatures (translate to target language)
+- 'does:' = function intent/docstring — use this to implement real logic
+- 'type: re-export' = module primarily re-exports symbols from imports
+- 'attrs:' = instance attributes to initialize in __init__/constructor
 - 'bases:' = parent classes to inherit from
-CRITICAL: Ensure valid syntax - balanced brackets, proper indentation, no undefined variables.""",
+- 'decorators:' = decorators to apply
+- 'calls:' = other functions this function calls (implement the call chain)
+- 'raises:' = exceptions this function may raise
+
+CRITICAL RULES:
+1. Translate EVERY 'sig:' line into a real function with actual logic
+2. Use 'does:' text to implement meaningful function bodies
+3. Ensure valid syntax - balanced brackets, proper indentation
+4. Include ALL imports listed in the module""",
         "toon": """Parse TOON (Token-Oriented Object Notation) format carefully:
 
 STRUCTURE:
@@ -222,19 +267,43 @@ DECORATORS:
 - 'decorators: @property' = add @property decorator
 - 'decorators: @staticmethod|@cache' = multiple decorators
 
-CRITICAL: Use imports[], function_docs, and exact signatures to reproduce code accurately.""",
-        "csv": """Parse the CSV table where each row describes a code element:
-- Columns: path, type (class/method/function), name, signature, language, intent, category, domain, imports
-- 'method' rows belong to the class in the preceding 'class' row
-- Implement all elements with the exact signatures shown
-Generate complete code with all classes, methods, and functions.""",
-        "function.toon": """Parse the function-logic TOON format:
-- 'modules[N]{path,lang,items}:' lists files
-- 'function_details:' contains per-module function listings
-- Each function has: line number, name, signature, description
-- 'ClassName.method_name' = method of that class
-- 'cc:N' after name = cyclomatic complexity
-Implement all listed functions with matching signatures and described behavior.""",
+CRITICAL RULES:
+1. Use imports[] to generate all import statements
+2. Use function_docs to write real function bodies (not stubs)
+3. Match exact signatures from sig: fields
+4. Include ALL classes with their methods and ALL standalone functions
+5. Preserve async functions (marked with 'async: true')""",
+        "csv": """Parse the CSV table to reconstruct source code:
+- Columns: path, type, name, signature, language, intent, category, domain, imports
+- 'type=class' rows define classes (look at 'bases' if present)
+- 'type=method' rows are methods of the preceding class
+- 'type=function' rows are standalone functions
+- 'signature' column has the exact function signature to use
+- 'intent' column describes what the function does — use it to implement real logic
+- 'imports' column lists required imports
+
+IMPORTANT RULES:
+1. Group methods under their parent class
+2. Include all imports from the 'imports' column
+3. Match signatures exactly as shown
+4. Use 'intent' to implement actual logic, not just stubs
+5. Add type hints based on signature information""",
+        "function.toon": """Parse the function-logic TOON format to reconstruct source code:
+- 'modules[N]{path,lang,items}:' lists source files and their function count
+- 'function_details:' contains per-module function listings as tables
+- Table columns: line, name, sig[, does, decorators, calls, raises]
+- 'ClassName.method_name' = this is a method of ClassName (create the class)
+- '~function_name' = async function (add async keyword)
+- 'cc:N' suffix on name = cyclomatic complexity hint (more complex logic needed)
+- 'sig' column has exact signature: (params)->ReturnType
+
+CRITICAL RULES:
+1. Create classes for any ClassName that appears as prefix in 'ClassName.method'
+2. Translate EVERY listed function into real code with actual logic
+3. Use 'does' column text to implement meaningful function bodies
+4. Match signatures EXACTLY from the 'sig' column
+5. Include imports needed for the types and calls referenced
+6. Preserve method grouping under their classes""",
     }
 
     # Language-specific guidance appended to prompt
@@ -248,7 +317,7 @@ Implement all listed functions with matching signatures and described behavior."
         "sql": "Use standard SQL: CREATE TABLE/VIEW/FUNCTION, proper column types, constraints.",
     }
 
-    max_spec = 8000
+    max_spec = 12000
     spec_truncated = spec[:max_spec] if len(spec) > max_spec else spec
 
     language_norm = (language or "python").strip().lower()
@@ -267,15 +336,20 @@ Implement all listed functions with matching signatures and described behavior."
     lang_hint = lang_hints.get(language_norm, '')
     lang_hint_line = f"\n{lang_hint}" if lang_hint else ''
 
-    prompt = f"""Generate {lang_label} code from this {fmt.upper()} specification.
+    prompt = f"""Generate complete {lang_label} source code from this {fmt.upper()} specification.
 {format_hints.get(fmt, '')}{lang_hint_line}
 
+SPECIFICATION:
 {spec_truncated}
 
-Requirements:
-- Complete, working {lang_label} code for {file_name}
-- Include imports and type hints
-- Implement all functions with actual logic
+REQUIREMENTS:
+- Output complete, working {lang_label} code for {file_name}
+- Include ALL imports at the top
+- Implement ALL classes, methods, and functions listed in the specification
+- Use type hints throughout
+- Write real logic based on descriptions/intents, NOT placeholder stubs
+- Match function signatures EXACTLY as specified
+- Output ONLY the code, no explanations
 
 ```{language_norm}
 """

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/benchmarks/results.py

@@ -118,6 +118,7 @@ class BenchmarkResult:
     avg_similarity: float = 0.0
     syntax_ok_rate: float = 0.0
     runs_ok_rate: float = 0.0
+    failure_rate: float = 0.0
 
     # Best format (for format comparisons)
     best_format: str = ""
@@ -144,17 +145,18 @@ class BenchmarkResult:
 
     def calculate_aggregates(self):
         """Calculate aggregate metrics from detailed results."""
-        # File results
+        # File results – include ALL scores (zeros count as failures)
         if self.file_results:
-            scores = [r.score for r in self.file_results if r.score > 0]
-            self.avg_score = sum(scores) / len(scores) if scores else 0
+            all_scores = [r.score for r in self.file_results]
+            self.avg_score = sum(all_scores) / len(all_scores) if all_scores else 0
+            self.failure_rate = sum(1 for s in all_scores if s == 0) / len(all_scores) * 100
             self.syntax_ok_rate = sum(1 for r in self.file_results if r.syntax_ok) / len(self.file_results) * 100
             self.runs_ok_rate = sum(1 for r in self.file_results if r.runs_ok) / len(self.file_results) * 100
 
-        # Function results
+        # Function results – include ALL similarities
         if self.function_results:
-            sims = [r.similarity for r in self.function_results if r.similarity > 0]
-            self.avg_similarity = sum(sims) / len(sims) if sims else 0
+            all_sims = [r.similarity for r in self.function_results]
+            self.avg_similarity = sum(all_sims) / len(all_sims) if all_sims else 0
 
         # Format results
         if self.format_results:
@@ -187,10 +189,24 @@ class BenchmarkResult:
         """Load result from JSON file."""
         data = json.loads(Path(path).read_text())
         # Reconstruct nested objects
-        file_results = [FileResult(**r) for r in data.pop('file_results', [])]
+        raw_file_results = data.pop('file_results', [])
+        file_results = []
+        for r in raw_file_results:
+            fmt_results_raw = r.pop('format_results', {})
+            fr = FileResult(**r)
+            fr.format_results = {
+                k: FormatResult(**v) if isinstance(v, dict) else v
+                for k, v in fmt_results_raw.items()
+            }
+            file_results.append(fr)
         function_results = [FunctionResult(**r) for r in data.pop('function_results', [])]
         format_results = [FormatResult(**r) for r in data.pop('format_results', [])]
 
+        # Remove unknown fields that may not be in the dataclass
+        import dataclasses
+        known_fields = {f.name for f in dataclasses.fields(cls)}
+        data = {k: v for k, v in data.items() if k in known_fields}
+
         result = cls(**data)
         result.file_results = file_results
         result.function_results = function_results

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/benchmarks/runner.py

@@ -147,11 +147,15 @@ def _structural_score(original: str, generated: str, language: str) -> float:
     if not o:
         return 0.0
     keys = list(o.keys())
-    matches = 0
+    total = 0.0
     for k in keys:
-        if o.get(k, 0) == g.get(k, 0):
-            matches += 1
-    return matches / max(len(keys), 1) * 100
+        ov = o.get(k, 0)
+        gv = g.get(k, 0)
+        if ov == 0 and gv == 0:
+            total += 1.0
+        elif max(ov, gv) > 0:
+            total += min(ov, gv) / max(ov, gv)
+    return total / max(len(keys), 1) * 100
 
 
 def _extract_code(response: str) -> str:
@@ -159,8 +163,16 @@ def _extract_code(response: str) -> str:
     if not response:
         return ""
 
-    # Try to find code block
-    for marker in ['```python', '```py', '```']:
+    # Try to find code block — check language-specific markers first, then generic
+    markers = [
+        '```python', '```py',
+        '```javascript', '```js', '```typescript', '```ts',
+        '```go', '```rust', '```rs',
+        '```java', '```csharp', '```cs', '```c#',
+        '```sql',
+        '```',
+    ]
+    for marker in markers:
         if marker in response:
             start = response.find(marker) + len(marker)
             if start < len(response) and response[start] == '\n':
@@ -469,12 +481,12 @@ class {cls}:
 
         result.total_time = time.time() - start_time
 
-        # Calculate format aggregates
+        # Calculate format aggregates – include ALL scores (zeros = failures)
         for fmt in formats:
             scores = [
                 fr.format_results[fmt].score
                 for fr in result.file_results
-                if fmt in fr.format_results and fr.format_results[fmt].score > 0
+                if fmt in fr.format_results
             ]
             if scores:
                 result.format_scores[fmt] = sum(scores) / len(scores)
@@ -762,24 +774,34 @@ class {cls}:
 
             result.original_code = '\n'.join(lines[start:end])
 
-            # Create spec
+            # Create spec with richer context
+            calls_str = ', '.join(getattr(func, 'calls', []) or []) or 'None'
+            raises_str = ', '.join(getattr(func, 'raises', []) or []) or 'None'
+            cc = getattr(func, 'complexity', 1) or 1
             spec = f"""Function: {func.name}
 Language: {language}
 Signature: {func.name}({', '.join(func.params)}) -> {func.return_type or 'None'}
 Description: {func.intent or func.docstring or 'No description'}
 Is Async: {func.is_async}
 Decorators: {', '.join(func.decorators) if func.decorators else 'None'}
+Calls: {calls_str}
+Raises: {raises_str}
+Complexity: {cc}
 Lines: {func.lines}
 """
 
-            prompt = f"""Generate ONLY the function code based on this specification:
+            prompt = f"""Generate ONLY the complete function code based on this specification:
 
 {spec}
 
-Requirements:
-- Generate complete, working {language} function
-- Match the signature exactly
-- Output ONLY the function code
+REQUIREMENTS:
+- Generate a complete, working {language} function with REAL logic (not a stub)
+- Match the signature EXACTLY: {func.name}({', '.join(func.params)}) -> {func.return_type or 'None'}
+- Use the Description to implement actual behavior
+- Include decorators if specified
+- The function should be ~{func.lines} lines long
+- Include proper error handling if Raises is specified
+- Output ONLY the function code, no explanations
 
 ```{language}
 """
@@ -793,7 +815,7 @@ Requirements:
                 result.gen_time = 0.0
             else:
                 start_time = time.time()
-                response = client.generate(prompt, max_tokens=2000)
+                response = client.generate(prompt, max_tokens=3000)
                 result.gen_time = time.time() - start_time
                 result.reproduced_code = _extract_code(response)
 
@@ -942,17 +964,23 @@ Requirements:
 
         result.total_time = time.time() - start_time
 
-        # Calculate format aggregates
+        # Calculate format aggregates – include ALL scores (zeros = failures)
         for fmt in formats:
             scores = []
             for fr in result.file_results:
                 if fmt in fr.format_results:
-                    score = fr.format_results[fmt].score
-                    if score > 0:
-                        scores.append(score)
+                    scores.append(fr.format_results[fmt].score)
             if scores:
                 result.format_scores[fmt] = sum(scores) / len(scores)
 
+        # Recalculate each file's score as average across all its formats
+        for fr in result.file_results:
+            if fr.format_results:
+                fmt_scores = [r.score for r in fr.format_results.values()]
+                fr.score = sum(fmt_scores) / len(fmt_scores)
+                fr.syntax_ok = all(r.syntax_ok for r in fr.format_results.values())
+                fr.runs_ok = any(r.runs_ok for r in fr.format_results.values())
+
         result.calculate_aggregates()
 
         return result

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/cli.py

@@ -673,6 +673,13 @@ code2logic [path] [options]
         action='store_true',
         help='Include the does/intent column in function-logic TOON output. Without this flag, the does column is omitted to save tokens.'
     )
+    parser.add_argument(
+        '--function-logic-context',
+        choices=['none', 'minimal', 'full'],
+        default='none',
+        dest='function_logic_context',
+        help='Structural context in function-logic TOON: none (flat list), minimal (class headers with bases), full (classes + properties + imports). Default: none.'
+    )
     parser.add_argument(
         '--no-install',
         action='store_true',
@@ -971,11 +978,18 @@ code2logic [path] [options]
         # For TOON, --compact means ultra-compact format
         compact = args.compact if hasattr(args, 'compact') else False
         ultra_compact = args.ultra_compact if hasattr(args, 'ultra_compact') else False
+        use_hybrid = args.hybrid if hasattr(args, 'hybrid') else False
 
         # Use compact or ultra_compact flag (compact takes precedence for TOON)
         use_ultra_compact = ultra_compact or compact
 
-        if use_ultra_compact:
+        if use_hybrid:
+            output = generator.generate_hybrid(
+                project,
+                detail='full',
+                no_repeat_name=args.no_repeat_module,
+            )
+        elif use_ultra_compact:
             output = generator.generate_ultra_compact(project)
         else:
             detail_map = {
@@ -1044,6 +1058,7 @@ code2logic [path] [options]
                 no_repeat_name=args.no_repeat_module,
                 no_repeat_details=args.no_repeat_details,
                 include_does=args.does,
+                context=getattr(args, 'function_logic_context', 'none') or 'none',
             )
         else:
             logic_out = logic_gen.generate(project, detail=args.detail)

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/function_logic.py

@@ -66,7 +66,16 @@ class FunctionLogicGenerator:
         no_repeat_name: bool = False,
         no_repeat_details: bool = False,
         include_does: bool = False,
+        context: str = 'none',
     ) -> str:
+        """Generate function-logic in TOON format.
+
+        Args:
+            context: Structural context level:
+                'none'    - flat function list (original behavior)
+                'minimal' - class headers (name, bases) before methods
+                'full'    - class headers + properties + module imports
+        """
         if detail == 'detailed':
             detail = 'full'
         toon = TOONGenerator()
@@ -81,8 +90,11 @@ class FunctionLogicGenerator:
         lines: List[str] = []
 
         # Format header — helps LLM understand the structure
-        lines.append(f"# {project.name} function-logic | {len(modules_with_items)} modules")
+        ctx_label = f" | context:{context}" if context != 'none' else ""
+        lines.append(f"# {project.name} function-logic | {len(modules_with_items)} modules{ctx_label}")
         lines.append("# Convention: name with . = method, ~name = async, cc:N shown only when >1")
+        if context != 'none':
+            lines.append("# CLASS: header before methods gives structural context (bases, props)")
 
         lines.append(f"project: {toon._quote(project.name)}")
         if getattr(project, 'generated_at', None):
@@ -110,6 +122,25 @@ class FunctionLogicGenerator:
                 details_key = m.path
             lines.append(f"  {toon._quote(details_key)}:")
 
+            # Emit module imports for 'full' context
+            if context == 'full' and getattr(m, 'imports', None):
+                imports = [i for i in m.imports if i][:20]
+                if imports:
+                    lines.append(f"    imports[{len(imports)}]: {','.join(imports)}")
+
+            # Emit class context headers before function table
+            if context != 'none':
+                classes = getattr(m, 'classes', []) or []
+                if classes:
+                    for cls in classes:
+                        bases = ','.join(getattr(cls, 'bases', []) or []) or '-'
+                        cls_line = f"    CLASS {toon._quote(cls.name)}({bases})"
+                        if context == 'full':
+                            props = getattr(cls, 'properties', []) or []
+                            if props:
+                                cls_line += f" props:[{','.join(props[:15])}]"
+                        lines.append(cls_line)
+
             header = f"line{dm}name{dm}sig"
             if include_does and detail in ('standard', 'full'):
                 header += f"{dm}does"

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/logicml.py

@@ -65,7 +65,7 @@ class LogicMLGenerator:
     """
 
     FORMAT_NAME: str = "logicml"
-    FILE_EXTENSION: str = ".logicml"
+    FILE_EXTENSION: str = ".logicml.yaml"
     TOKEN_EFFICIENCY: float = 1.4  # 40% better than YAML
     REPRODUCTION_FIDELITY: float = 0.97
 
@@ -80,14 +80,22 @@ class LogicMLGenerator:
     def __init__(self, verbose: bool = False) -> None:
         self.verbose = verbose
 
-    def generate(self, project: ProjectInfo, detail: str = 'standard') -> LogicMLSpec:
-        """Generate LogicML specification for a project."""
+    def generate(self, project: ProjectInfo, detail: str = 'standard', level: str = 'typed') -> LogicMLSpec:
+        """Generate LogicML specification for a project.
+
+        Args:
+            detail: Content detail ('minimal', 'standard', 'full')
+            level: Signature richness level:
+                'compact' - short params (6 max), minimal types
+                'typed'   - full params with types (10 max), return types always shown
+                'full'    - typed + calls/raises always shown
+        """
         parts: List[str] = []
         total_classes = 0
         total_functions = 0
 
         for module in project.modules:
-            module_spec = self._generate_module(module, detail)
+            module_spec = self._generate_module(module, detail, level)
             if module_spec.strip():
                 parts.append(module_spec)
             total_classes += len(module.classes)
@@ -104,7 +112,7 @@ class LogicMLGenerator:
             function_count=total_functions,
         )
 
-    def _generate_module(self, module: ModuleInfo, detail: str) -> str:
+    def _generate_module(self, module: ModuleInfo, detail: str, level: str = 'typed') -> str:
         """Generate LogicML for a single module."""
         lines: List[str] = []
         path = Path(module.path)
@@ -158,12 +166,12 @@ class LogicMLGenerator:
 
         # Classes
         for cls in module.classes:
-            class_yaml = self._generate_class(cls, detail)
+            class_yaml = self._generate_class(cls, detail, level)
             lines.append(class_yaml)
 
         # Top-level functions
         if module.functions:
-            funcs_yaml = self._generate_functions(module.functions, detail)
+            funcs_yaml = self._generate_functions(module.functions, detail, level)
             lines.append(funcs_yaml)
 
         return '\n'.join(lines)
@@ -196,7 +204,7 @@ class LogicMLGenerator:
 
         return '\n'.join(lines) if len(lines) > 1 else ''
 
-    def _generate_class(self, cls: ClassInfo, detail: str) -> str:
+    def _generate_class(self, cls: ClassInfo, detail: str, level: str = 'typed') -> str:
         """Generate LogicML for a class."""
         lines: List[str] = [f'\n{cls.name}:']
 
@@ -245,22 +253,27 @@ class LogicMLGenerator:
         if cls.methods:
             lines.append('  methods:')
             for method in cls.methods[:20]:
-                method_yaml = self._generate_method(method, detail, indent=4)
+                method_yaml = self._generate_method(method, detail, level, indent=4)
                 lines.append(method_yaml)
 
         return '\n'.join(lines)
 
-    def _generate_method(self, method: FunctionInfo, detail: str, indent: int = 2) -> str:
-        """Generate LogicML for a method."""
+    def _generate_method(self, method: FunctionInfo, detail: str, level: str = 'typed', indent: int = 2) -> str:
+        """Generate LogicML for a method.
+
+        Args:
+            level: 'compact' (6 params), 'typed' (10 params, full types), 'full' (typed + calls/raises)
+        """
         prefix = ' ' * indent
         lines: List[str] = [f'{prefix}{method.name}:']
 
         # Check for property decorator
         is_property = 'property' in method.decorators
 
-        # Signature - remove self/cls for compactness
-        clean_params = remove_self_from_params(method.params[:7])
-        params = ', '.join(clean_params[:6])
+        # Signature - param count depends on level
+        max_params = 6 if level == 'compact' else 10
+        clean_params = remove_self_from_params(method.params[:max_params + 1])
+        params = ', '.join(clean_params[:max_params])
         ret = method.return_type or 'None'
 
         sig = f'({params}) -> {ret}'
@@ -271,19 +284,31 @@ class LogicMLGenerator:
 
         lines.append(f'{prefix}  sig: {sig}')
 
-        # Intent/docstring as "does" - truncated for efficiency
+        # Intent/docstring as "does" - longer for typed/full levels
+        does_max = 80 if level in ('typed', 'full') else 60
         if method.docstring:
-            does = truncate_docstring(method.docstring, max_length=60)
+            does = truncate_docstring(method.docstring, max_length=does_max)
             if does:
                 lines.append(f'{prefix}  does: "{does}"')
         elif method.intent:
-            intent = method.intent[:60].replace('\n', ' ').replace('"', "'")
+            intent = method.intent[:does_max].replace('\n', ' ').replace('"', "'")
             lines.append(f'{prefix}  does: "{intent}"')
 
         # Edge cases (from raises)
         if method.raises and detail in ('standard', 'full'):
             for exc in method.raises[:2]:
                 lines.append(f'{prefix}  edge: "error → raise {exc}"')
+            # In 'full' level, also emit raises as list for LLM reconstruction
+            if level == 'full':
+                raises_str = ", ".join(method.raises[:5])
+                lines.append(f'{prefix}  raises: [{raises_str}]')
+
+        # Calls (only in 'full' level or detail='full')
+        if level == 'full' and getattr(method, 'calls', None):
+            calls = (method.calls or [])[:10]
+            if calls:
+                calls_str = ", ".join(calls)
+                lines.append(f'{prefix}  calls: [{calls_str}]')
 
         # Side effects
         side_effects = self._detect_side_effects(method)
@@ -298,12 +323,12 @@ class LogicMLGenerator:
 
         return '\n'.join(lines)
 
-    def _generate_functions(self, functions: List[FunctionInfo], detail: str) -> str:
+    def _generate_functions(self, functions: List[FunctionInfo], detail: str, level: str = 'typed') -> str:
         """Generate LogicML for top-level functions."""
         lines: List[str] = ['\nfunctions:']
 
         for func in functions[:20]:
-            func_yaml = self._generate_method(func, detail, indent=2)
+            func_yaml = self._generate_method(func, detail, level, indent=2)
             lines.append(func_yaml)
 
         return '\n'.join(lines)

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/metrics.py

@@ -303,23 +303,11 @@ class ReproductionMetrics:
         return (dot_product / (magnitude1 * magnitude2)) * 100
 
     def _compute_structural_metrics(self, original: str, generated: str) -> StructuralMetrics:
-        """Compute structural metrics."""
+        """Compute structural metrics using AST when possible, regex as fallback."""
         metrics = StructuralMetrics()
 
-        # Count elements
-        def count_elements(code: str) -> Dict[str, int]:
-            return {
-                'classes': len(re.findall(r'^class\s+\w+', code, re.MULTILINE)),
-                'functions': len(re.findall(r'^(?:async\s+)?def\s+\w+', code, re.MULTILINE)),
-                'methods': len(re.findall(r'^\s+(?:async\s+)?def\s+\w+', code, re.MULTILINE)),
-                'imports': len(re.findall(r'^(?:from|import)\s+', code, re.MULTILINE)),
-                # Capture both annotated attributes and simple assignments.
-                # This is still heuristic, but avoids undercounting common code.
-                'attributes': len(re.findall(r'^\s+\w+\s*(?::\s*[^=\n]+)?\s*=', code, re.MULTILINE)),
-            }
-
-        orig = count_elements(original)
-        gen = count_elements(generated)
+        orig = self._count_elements_ast(original)
+        gen = self._count_elements_ast(generated)
 
         metrics.classes_original = orig['classes']
         metrics.classes_generated = gen['classes']
@@ -341,15 +329,15 @@ class ReproductionMetrics:
         metrics.attributes_generated = gen['attributes']
         metrics.attributes_match = orig['attributes'] == gen['attributes']
 
-        # Structural score
-        matches = sum([
-            metrics.classes_match,
-            metrics.functions_match,
-            metrics.methods_match,
-            metrics.imports_match,
-            metrics.attributes_match,
-        ])
-        metrics.structural_score = (matches / 5) * 100
+        # Ratio-based structural score (partial credit instead of binary)
+        total = 0.0
+        for key in ('classes', 'functions', 'methods', 'imports', 'attributes'):
+            ov, gv = orig[key], gen[key]
+            if ov == 0 and gv == 0:
+                total += 1.0
+            elif max(ov, gv) > 0:
+                total += min(ov, gv) / max(ov, gv)
+        metrics.structural_score = (total / 5) * 100
 
         # Element coverage
         total_orig = sum(orig.values())
@@ -359,6 +347,59 @@ class ReproductionMetrics:
 
         return metrics
 
+    @staticmethod
+    def _count_elements_ast(code: str) -> Dict[str, int]:
+        """Count structural elements using Python AST, with regex fallback."""
+        import ast as _ast
+
+        try:
+            tree = _ast.parse(code)
+        except SyntaxError:
+            # Fallback to regex for unparseable code
+            return {
+                'classes': len(re.findall(r'^class\s+\w+', code, re.MULTILINE)),
+                'functions': len(re.findall(r'^(?:async\s+)?def\s+\w+', code, re.MULTILINE)),
+                'methods': len(re.findall(r'^\s+(?:async\s+)?def\s+\w+', code, re.MULTILINE)),
+                'imports': len(re.findall(r'^(?:from|import)\s+', code, re.MULTILINE)),
+                'attributes': len(re.findall(r'^\s+\w+\s*(?::\s*[^=\n]+)?\s*=', code, re.MULTILINE)),
+            }
+
+        classes = 0
+        functions = 0
+        methods = 0
+        imports = 0
+        attributes = 0
+
+        for node in _ast.walk(tree):
+            if isinstance(node, _ast.ClassDef):
+                classes += 1
+                # Count methods inside classes
+                for item in node.body:
+                    if isinstance(item, (_ast.FunctionDef, _ast.AsyncFunctionDef)):
+                        methods += 1
+                    # Count class-level attributes (annotated or assigned)
+                    elif isinstance(item, (_ast.Assign, _ast.AnnAssign)):
+                        attributes += 1
+            elif isinstance(node, (_ast.FunctionDef, _ast.AsyncFunctionDef)):
+                # Only count as top-level function if not inside a class
+                # (methods already counted above)
+                pass
+            elif isinstance(node, (_ast.Import, _ast.ImportFrom)):
+                imports += 1
+
+        # Count top-level functions (not methods)
+        for node in _ast.iter_child_nodes(tree):
+            if isinstance(node, (_ast.FunctionDef, _ast.AsyncFunctionDef)):
+                functions += 1
+
+        return {
+            'classes': classes,
+            'functions': functions,
+            'methods': methods,
+            'imports': imports,
+            'attributes': attributes,
+        }
+
     def _compute_semantic_metrics(self, original: str, generated: str) -> SemanticMetrics:
         """Compute semantic preservation metrics."""
         metrics = SemanticMetrics()

{code2logic-1.0.41 → code2logic-1.0.43}/code2logic/toon_format.py

@@ -132,6 +132,92 @@ class TOONGenerator:
 
         return '\n'.join(lines)
 
+    def generate_hybrid(
+        self,
+        project: ProjectInfo,
+        detail: str = 'full',
+        no_repeat_name: bool = True,
+        hub_top_n: int = 5,
+        hub_functions_detail: str = 'full',
+    ) -> str:
+        """Generate TOON-Hybrid: project structure + function-logic for hub modules.
+
+        Combines project-level TOON (classes, imports, structure) with
+        selective function-logic details for the most important modules.
+
+        Args:
+            project: Analyzed project info
+            detail: Detail level for project structure
+            no_repeat_name: Compress repeated directory prefixes
+            hub_top_n: Number of top modules to include function details for
+            hub_functions_detail: Detail level for function-logic ('standard', 'full')
+
+        Returns:
+            Hybrid TOON string
+        """
+        from .function_logic import FunctionLogicGenerator
+        from .shared_utils import remove_self_from_params
+
+        # Generate base project TOON
+        base = self.generate(project, detail=detail, no_repeat_name=no_repeat_name)
+
+        # Identify hub modules: use dependency_metrics if available, otherwise sort by function count
+        hub_paths: set = set()
+        dep_metrics = getattr(project, 'dependency_metrics', {}) or {}
+        if dep_metrics:
+            ranked = sorted(dep_metrics.items(), key=lambda x: getattr(x[1], 'pagerank', 0), reverse=True)
+            hub_paths = {path for path, node in ranked[:hub_top_n]}
+        else:
+            # Fallback: rank by total functions + methods
+            def _item_count(m):
+                return len(getattr(m, 'functions', []) or []) + sum(
+                    len(getattr(c, 'methods', []) or []) for c in (getattr(m, 'classes', []) or [])
+                )
+            ranked_modules = sorted(project.modules, key=_item_count, reverse=True)
+            hub_paths = {m.path for m in ranked_modules[:hub_top_n]}
+
+        if not hub_paths:
+            return base
+
+        # Generate function-logic section for hub modules only
+        hub_modules = [m for m in project.modules if m.path in hub_paths]
+        if not hub_modules:
+            return base
+
+        logic_gen = FunctionLogicGenerator()
+        lines = [base, "", "# === Hub Module Function Details ==="]
+
+        for m in hub_modules:
+            items = logic_gen._module_items(m)
+            if not items:
+                continue
+            lines.append(f"  {self._quote(m.path)}:")
+
+            # Emit class context
+            classes = getattr(m, 'classes', []) or []
+            for cls in classes:
+                bases = ','.join(getattr(cls, 'bases', []) or []) or '-'
+                lines.append(f"    CLASS {self._quote(cls.name)}({bases})")
+
+            # Emit function table
+            header = f"line{self.delim_marker}name{self.delim_marker}sig{self.delim_marker}does"
+            lines.append(f"    functions[{len(items)}]{{{header}}}:")
+
+            for kind, qname, func in items:
+                sig = logic_gen._build_sig(func, include_async_prefix=False, language=m.language)
+                start_line = str(getattr(func, 'start_line', 0) or 0)
+                display_name = qname
+                if getattr(func, 'is_async', False):
+                    display_name = f"~{qname}"
+                cc = getattr(func, 'complexity', 1) or 1
+                if cc > 1:
+                    display_name = f"{display_name} cc:{cc}"
+                does = logic_gen._build_does(func)
+                row = [start_line, self._quote(display_name), self._quote(sig), self._quote(does)]
+                lines.append(f"      {self.delimiter.join(row)}")
+
+        return '\n'.join(lines)
+
     def _generate_modules(self, modules: List[ModuleInfo], detail: str, no_repeat_name: bool = False) -> List[str]:
         """Generate modules section."""
         lines = []

{code2logic-1.0.41 → code2logic-1.0.43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "code2logic"
-version = "1.0.41"
+version = "1.0.43"
 description = "Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support."
 readme = "README.md"
 license = "Apache-2.0"