refactoring

Author: tom-sapletta-com

code2logic/cli.py

@@ -608,7 +608,10 @@ def _maybe_print_pretty_help() -> bool:
     )
     parser.add_argument(
         '--function-logic',
-        help='Write detailed function logic to a separate file (format inferred from extension: .logicml/.json/.yaml/.toon)'
+        nargs='?',
+        const='auto',
+        default=None,
+        help='Write detailed function logic to a separate file. If no path given, auto-generates based on output file or uses project.functions.logicml. Format inferred from extension: .logicml/.json/.yaml/.toon'
     )
     parser.add_argument(
         '--flat',
@@ -907,7 +910,24 @@ def _maybe_print_pretty_help() -> bool:
     # Optional: write detailed function logic to a separate file
     if args.function_logic:
         logic_gen = FunctionLogicGenerator()
-        logic_path = str(args.function_logic)
+        
+        # Auto-generate path if 'auto' was specified (--function-logic without argument)
+        if args.function_logic == 'auto':
+            if args.output:
+                # Derive from output file: project.c2l.yaml -> project.functions.yaml
+                base = args.output.rsplit('.', 1)[0]
+                if base.endswith('.c2l'):
+                    base = base[:-4]
+                ext = args.output.rsplit('.', 1)[-1] if '.' in args.output else 'logicml'
+                logic_path = f"{base}.functions.{ext}"
+            else:
+                # Default path based on format
+                ext_map = {'json': 'json', 'yaml': 'yaml', 'toon': 'toon'}
+                ext = ext_map.get(args.format, 'logicml')
+                logic_path = f"project.functions.{ext}"
+        else:
+            logic_path = str(args.function_logic)
+        
         lower = logic_path.lower()
         if lower.endswith('.json'):
             logic_out = logic_gen.generate_json(project, detail=args.detail)
@@ -917,10 +937,10 @@ def _maybe_print_pretty_help() -> bool:
             logic_out = logic_gen.generate_toon(project, detail=args.detail)
         else:
             logic_out = logic_gen.generate(project, detail=args.detail)
-        with open(args.function_logic, 'w', encoding='utf-8') as f:
+        with open(logic_path, 'w', encoding='utf-8') as f:
             f.write(logic_out)
         if args.verbose:
-            log.success(f"Function logic written to: {args.function_logic}")
+            log.success(f"Function logic written to: {logic_path}")
 
     gen_time = time.time() - gen_start
 

code2logic/generators.py

@@ -1897,6 +1897,17 @@ def _constant_to_dict(self, constant: ConstantInfo) -> dict:
             data['v'] = snippet
         return data
 
+    def _field_to_dict(self, field: FieldInfo) -> dict:
+        """Serialize dataclass FieldInfo to dictionary."""
+        data = {'name': field.name}
+        if getattr(field, 'type_annotation', None):
+            data['type'] = field.type_annotation
+        if getattr(field, 'default', None):
+            data['default'] = field.default
+        if getattr(field, 'default_factory', None):
+            data['factory'] = field.default_factory
+        return data
+
 
 # ============================================================================
 # CSV Generator  

code2logic/parsers.py

@@ -341,13 +341,27 @@ def _parse_python(self, filepath: str, content: str, tree) -> ModuleInfo:
                     if not func.name.startswith('_'):
                         exports.append(func.name)
             elif node_type == 'decorated_definition':
+                # Handle decorated functions
                 inner_func = self._find_child(child, 'function_definition')
                 if inner_func:
                     func = self._extract_py_function(inner_func, content, child)
                     if func:
                         functions.append(func)
                         if not func.name.startswith('_'):
                             exports.append(func.name)
+                
+                # Handle decorated classes (e.g., @dataclass)
+                inner_class = self._find_child(child, 'class_definition')
+                if inner_class:
+                    cls = self._extract_py_class(inner_class, content, decorated_node=child)
+                    if cls:
+                        classes.append(cls)
+                        if not cls.name.startswith('_'):
+                            exports.append(cls.name)
+                        
+                        enum_type = self._extract_py_enum(inner_class, content)
+                        if enum_type:
+                            types.append(enum_type)
 
             # Constants with enhanced extraction
             if node_type == 'expression_statement':
@@ -652,7 +666,7 @@ def _extract_py_enum(self, node, content: str) -> Optional[TypeInfo]:
         except Exception:
             return None
 
-    def _extract_py_class(self, node, content: str) -> Optional[ClassInfo]:
+    def _extract_py_class(self, node, content: str, decorated_node=None) -> Optional[ClassInfo]:
         """Extract Python class from AST node."""
         name_node = self._find_child(node, 'identifier')
         if not name_node:
@@ -670,10 +684,10 @@ def _extract_py_class(self, node, content: str) -> Optional[ClassInfo]:
         # Check for dataclass decorator
         decorators = []
         is_dataclass = False
-        # Look for parent decorated_definition
-        parent = getattr(node, 'parent', None)
-        if parent and parent.type == 'decorated_definition':
-            for c in parent.children:
+        # Use provided decorated_node or try to find parent
+        dec_source = decorated_node or getattr(node, 'parent', None)
+        if dec_source and dec_source.type == 'decorated_definition':
+            for c in dec_source.children:
                 if c.type == 'decorator':
                     dec_text = self._text(c, content).lstrip('@')
                     decorators.append(dec_text.split('(')[0])
@@ -685,6 +699,7 @@ def _extract_py_class(self, node, content: str) -> Optional[ClassInfo]:
         methods = []
         fields = []
         attributes = []
+        properties = []
         body = self._find_child(node, 'block')
         if body:
             for i, child in enumerate(body.children):
@@ -697,24 +712,29 @@ def _extract_py_class(self, node, content: str) -> Optional[ClassInfo]:
                     m = self._extract_py_function(child, content)
                     if m:
                         methods.append(m)
+                        # Extract self.x = ... from __init__ method
+                        if m.name == '__init__' and not is_dataclass:
+                            init_attrs = self._extract_init_attributes(child, content)
+                            attributes.extend(init_attrs)
                 elif child.type == 'decorated_definition':
                     inner = self._find_child(child, 'function_definition')
                     if inner:
                         m = self._extract_py_function(inner, content, child)
                         if m:
                             methods.append(m)
 
-                # Extract dataclass fields
+                # Extract dataclass fields (class-level annotated assignments)
                 elif is_dataclass and child.type == 'expression_statement':
                     field = self._extract_dataclass_field(child, content)
                     if field:
                         fields.append(field)
 
-                # Extract instance attributes (self.x = ...)
+                # Extract class-level properties (annotated assignments without dataclass)
                 elif child.type == 'expression_statement' and not is_dataclass:
-                    attr = self._extract_class_attribute(child, content)
-                    if attr:
-                        attributes.append(attr)
+                    # Check for annotated assignment like "x: int" or "x: int = 5"
+                    prop = self._extract_class_property(child, content)
+                    if prop:
+                        properties.append(prop)
 
         return ClassInfo(
             name=name,
@@ -724,6 +744,7 @@ def _extract_py_class(self, node, content: str) -> Optional[ClassInfo]:
             is_dataclass=is_dataclass,
             fields=fields,
             attributes=attributes,
+            properties=properties,
             methods=methods,
             is_interface=False,
             is_abstract='ABC' in bases or 'ABCMeta' in bases,
@@ -824,6 +845,46 @@ def _extract_class_attribute(self, node, content: str) -> Optional[AttributeInfo
                         )
         return None
 
+    def _extract_init_attributes(self, func_node, content: str) -> List[AttributeInfo]:
+        """Extract self.x = ... assignments from __init__ method body."""
+        attributes = []
+        seen_names = set()
+        
+        def scan_block(block_node):
+            """Recursively scan block for self.x assignments."""
+            if not block_node:
+                return
+            for child in block_node.children:
+                if child.type == 'expression_statement':
+                    attr = self._extract_class_attribute(child, content)
+                    if attr and attr.name not in seen_names:
+                        seen_names.add(attr.name)
+                        attributes.append(attr)
+                # Also scan nested blocks (if/for/while/try)
+                elif child.type in ('if_statement', 'for_statement', 'while_statement', 'try_statement'):
+                    for sub in child.children:
+                        if sub.type == 'block':
+                            scan_block(sub)
+        
+        body = self._find_child(func_node, 'block')
+        scan_block(body)
+        return attributes[:15]  # Limit to 15 attributes
+    
+    def _extract_class_property(self, node, content: str) -> Optional[str]:
+        """Extract class-level property from annotated assignment."""
+        try:
+            stmt_text = self._text(node, content).strip()
+        except Exception:
+            return None
+        
+        # Match annotated assignment: "name: Type" or "name: Type = value"
+        m = re.match(r'^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^=]+?)(?:\s*=.*)?$', stmt_text)
+        if m:
+            name = m.group(1)
+            type_ann = m.group(2).strip()
+            return f"{name}: {type_ann}"
+        return None
+    
     def _extract_py_import(self, node, content: str) -> List[str]:
         """Extract import statement."""
         imports = []
@@ -1575,14 +1636,26 @@ def _extract_ast_class(self, node: ast.ClassDef) -> ClassInfo:
                     if isinstance(target, ast.Name):
                         properties.append(target.id)
 
+        # Extract decorators
+        decorators = []
+        for dec in node.decorator_list:
+            if isinstance(dec, ast.Name):
+                decorators.append(dec.id)
+            elif isinstance(dec, ast.Call) and isinstance(dec.func, ast.Name):
+                decorators.append(dec.func.id)
+            elif isinstance(dec, ast.Attribute):
+                decorators.append(dec.attr)
+        
         return ClassInfo(
             name=node.name,
             bases=bases,
+            decorators=decorators,
             docstring=ast.get_docstring(node)[:100] if ast.get_docstring(node) else None,
+            is_dataclass=is_dataclass,
             methods=methods,
             properties=properties,
             is_interface=False,
-            is_abstract='ABC' in bases or is_dataclass,
+            is_abstract='ABC' in bases,
             generic_params=[]
         )