refactoring

Author: tom-sapletta-com

code2logic/analyzer.py

@@ -157,6 +157,7 @@ def analyze(self) -> ProjectInfo:
             similar_functions=similar,
             total_files=len(self.modules),
             total_lines=sum(m.lines_total for m in self.modules),
+            total_bytes=sum(getattr(m, 'file_bytes', 0) for m in self.modules),
             generated_at=datetime.now().isoformat()
         )
 
@@ -208,6 +209,10 @@ def _scan_files(self):
                     continue
 
             if module:
+                try:
+                    module.file_bytes = fp.stat().st_size
+                except Exception:
+                    module.file_bytes = len(content.encode('utf-8', errors='ignore'))
                 self.modules.append(module)
 
     def _detect_entrypoints(self) -> List[str]:

code2logic/generators.py

@@ -14,11 +14,18 @@
 
 from .models import (
     ProjectInfo, ModuleInfo, ClassInfo, FunctionInfo,
-    DependencyNode, ConstantInfo
+    DependencyNode, ConstantInfo, FieldInfo
 )
 from .shared_utils import categorize_function, extract_domain, compute_hash, remove_self_from_params, compact_imports, deduplicate_imports
 
 
+def bytes_to_kb(bytes_value: int) -> float:
+    """Convert bytes to kilobytes with single decimal precision."""
+    if not bytes_value:
+        return 0.0
+    return round(bytes_value / 1024, 1)
+
+
 class MarkdownGenerator:
     """
     Generates Markdown output for project analysis.
@@ -410,6 +417,17 @@ def ser_func(f: FunctionInfo) -> dict:
                 data['lines'] = f.lines
                 data['is_private'] = f.is_private
             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
 
         def ser_class(c: ClassInfo) -> dict:
             data = {
@@ -1300,6 +1318,9 @@ def _build_flat_data(self, project: ProjectInfo, detail: str) -> dict:
     def _build_nested_data(self, project: ProjectInfo, detail: str) -> dict:
         """Build nested hierarchical data structure."""
         modules = []
+        module_overview = []
+        for m in project.modules:
+            module_overview.append(f"{m.path}:{m.lines_code}")
         for m in project.modules:
             module_data = {
                 'path': m.path,
@@ -1313,28 +1334,49 @@ def _build_nested_data(self, project: ProjectInfo, detail: str) -> dict:
 
             if m.classes:
                 module_data['classes'] = []
+                dataclass_summary = []
                 for c in m.classes:
                     cls_data = {
                         'name': c.name,
                         'bases': c.bases,
                         'docstring': c.docstring[:80] if c.docstring else '',
                     }
-                    # Include properties (critical for dataclass reproduction)
-                    if c.properties:
+                    if getattr(c, 'properties', None):
                         cls_data['properties'] = c.properties[:20]
+                    # Include properties (critical for dataclass reproduction)
+                    if getattr(c, 'is_dataclass', False):
+                        cls_data['dataclass'] = True
+                        if getattr(c, 'fields', None):
+                            cls_data['fields'] = [
+                                self._field_to_dict(field)
+                                for field in c.fields[:15]
+                            ]
+                        dataclass_summary.append({
+                            'name': c.name,
+                            'fields': [
+                                self._field_to_dict(field)
+                                for field in c.fields[:15]
+                            ] if getattr(c, 'fields', None) else []
+                        })
                     if c.methods:
                         cls_data['methods'] = [
                             self._method_to_dict(method, detail)
                             for method in c.methods[:15]
                         ]
                     module_data['classes'].append(cls_data)
+                if dataclass_summary:
+                    module_data['dataclasses'] = dataclass_summary[:10]
 
             if m.functions:
                 module_data['functions'] = [
                     self._function_to_dict(f, detail)
                     for f in m.functions[:20]
                 ]
 
+            constant_entries = self._constants_for_module_verbose(m, limit=12)
+            if constant_entries:
+                module_data['constants'] = constant_entries
+            
             modules.append(module_data)
 
         return {
@@ -1550,7 +1592,9 @@ def _build_compact_data(self, project: ProjectInfo, detail: str) -> dict:
         default_lang = max(project.languages.items(), key=lambda x: x[1])[0] if project.languages else 'python'
 
         modules = []
+        module_overview = []
         for m in project.modules:
+            module_overview.append(f"{m.path}:{m.lines_code}")
             mod_data = {
                 'p': m.path,  # path
             }
@@ -1586,24 +1630,16 @@ def _build_compact_data(self, project: ProjectInfo, detail: str) -> dict:
             modules.append(mod_data)
 
         return {
+            'header': {
+                'project': project.name,
+                'files': project.total_files,
+                'lines': project.total_lines,
+                'languages': project.languages,
+                'modules_count': len(project.modules),
+            },
+            'M': module_overview,
             'meta': {
-                'legend': {
-                    'p': 'path',
-                    'l': 'lines',
-                    'i': 'imports',
-                    'e': 'exports',
-                    'c': 'classes',
-                    'f': 'functions',
-                    'n': 'name',
-                    'd': 'docstring',
-                    'b': 'bases',
-                    'm': 'methods',
-                    'props': 'properties',
-                    'sig': 'signature (without self)',
-                    'ret': 'return_type',
-                    'async': 'is_async',
-                    'lang': 'language',
-                }
+                'legend': self.KEY_LEGEND.copy()
             },
             'defaults': {'lang': default_lang},
             'modules': modules

code2logic/models.py

@@ -165,7 +165,8 @@ class ProjectInfo:
     similar_functions: Dict[str, List[str]]
     total_files: int
     total_lines: int
-    generated_at: str
+    total_bytes: int = 0
+    generated_at: str = ""
 
 
 # Backwards compatibility aliases for tests
@@ -317,6 +318,7 @@ class ModuleInfo:
         docstring: Module docstring
         lines_total: Total line count
         lines_code: Lines of actual code (excluding comments/blanks)
+        file_bytes: Size of the source file in bytes
     """
     path: str
     language: str = "python"
@@ -332,3 +334,4 @@ class ModuleInfo:
     docstring: Optional[str] = None
     lines_total: int = 0
     lines_code: int = 0
+    file_bytes: int = 0

code2logic/parsers.py

@@ -58,6 +58,16 @@ def _combine_import_name(module_name: str, identifier: str) -> str:
     return f"{module_name}.{identifier}"
 
 
+def _truncate_constant_value(value_text: str, limit: int = 400) -> str:
+    """Return a trimmed single-line snippet for constant values."""
+    if not value_text:
+        return ''
+    snippet = value_text.replace('\n', ' ').strip()
+    if len(snippet) > limit:
+        snippet = snippet[: limit - 3].rstrip() + '...'
+    return snippet
+
+
 class TreeSitterParser:
     """
     Parser using Tree-sitter for high-accuracy AST parsing.
@@ -206,6 +216,7 @@ def _parse_python(self, filepath: str, content: str, tree) -> ModuleInfo:
 
         # Deduplicate imports and normalize names at extraction time
         lines = content.split('\n')
+        file_bytes = len(content.encode('utf-8', errors='ignore'))
 
         # Extract TYPE_CHECKING and aliases from the entire tree
         type_checking_imports = self._extract_type_checking_imports(root, content)
@@ -230,7 +241,8 @@ def _parse_python(self, filepath: str, content: str, tree) -> ModuleInfo:
             aliases=aliases,
             docstring=self._truncate_docstring(docstring),
             lines_total=len(lines),
-            lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('#')])
+            lines_code=len([l for l in lines if l.strip() and not l.strip().startswith('#')]),
+            file_bytes=file_bytes,
         )
 
     def _extract_constants(self, tree, content: str) -> List[ConstantInfo]:
@@ -676,7 +688,7 @@ def _extract_py_constant(self, node, content: str) -> Optional[ConstantInfo]:
                         # Get the value
                         if right:
                             value_text = self._text(right, content).strip()
-                            const.value = value_text if len(value_text) <= 200 else None
+                            const.value = _truncate_constant_value(value_text)
 
                             # For dictionaries, extract keys
                             if value_text.startswith('{') and value_text.endswith('}'):
@@ -1116,9 +1128,9 @@ def _parse_python(self, filepath: str, content: str) -> Optional[ModuleInfo]:
                 if func:
                     functions.append(func)
             elif isinstance(node, ast.Assign):
-                for t in node.targets:
-                    if isinstance(t, ast.Name) and t.id.isupper():
-                        constants.append(t.id)
+                const = self._extract_ast_constant(node, content)
+                if const:
+                    constants.append(const)
 
         exports = [c.name for c in classes if not c.name.startswith('_')]
         exports += [f.name for f in functions if not f.name.startswith('_')]
@@ -1248,6 +1260,48 @@ def _extract_ast_class(self, node: ast.ClassDef) -> ClassInfo:
             is_abstract='ABC' in bases or is_dataclass,
             generic_params=[]
         )
+
+    def _extract_ast_constant(self, node: ast.Assign, content: str) -> Optional[ConstantInfo]:
+        """Extract ConstantInfo from an AST assignment node if applicable."""
+        if not node.targets:
+            return None
+        target = node.targets[0]
+        if not isinstance(target, ast.Name) or not target.id.isupper():
+            return None
+
+        const = ConstantInfo(name=target.id)
+        value_text = self._format_ast_value(node.value, content)
+        if value_text:
+            const.value = _truncate_constant_value(value_text)
+
+        if isinstance(node.value, ast.Dict):
+            keys = []
+            for key in node.value.keys:
+                if isinstance(key, ast.Constant) and isinstance(key.value, str):
+                    keys.append(key.value)
+            if keys:
+                const.value_keys = keys[:10]
+        return const
+
+    def _format_ast_value(self, value_node: ast.AST, content: str) -> str:
+        """Best-effort string representation of an AST value node."""
+        if value_node is None:
+            return ''
+        try:
+            import ast
+            if hasattr(ast, "unparse"):
+                return ast.unparse(value_node)
+        except Exception:
+            pass
+        try:
+            segment = ast.get_source_segment(content, value_node)
+            if segment:
+                return segment
+        except Exception:
+            pass
+        if isinstance(value_node, ast.Constant):
+            return repr(value_node.value)
+        return ''
 
     def _ann_str(self, node) -> str:
         """Convert AST annotation to string."""