cod8a 0.1.0__py3-none-any.whl

cod8a/dotnet/CodeAnalysis/models/FileStructure.cs

@@ -0,0 +1,92 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeAnalyzer.Models
+{
+    /// <summary>
+    /// Represents the structure of a file, including its identifier and associated namespace details.
+    /// </summary>
+    public class FileStructure
+    {
+        public int Id { get; set; }
+        /// <summary>
+        /// <see langword="nameof"/>of the namespace, e.g., <c>MyNamespace</c>.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection of using directives associated with the current context.
+        /// </summary>
+        public List<UsingDirective> UsingDirectives { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection of classes associated with the current instance.
+        /// </summary>
+        public List<ClassStructure> Classes { get; set; }
+
+    }
+
+    /// <summary>
+    /// Represents the relationship the file has with other file(s)
+    /// </summary>
+    /// <param name="Id">Id of the instance</param>
+    /// <param name="Type">Type of relationship</param>
+    /// <param name="Parent">Base item</param>
+    public record RelationShip(int Id, string Type, string AssociatedItem);
+
+    public record UsingDirective(int Id, string Name);
+
+
+    /// <summary>
+    /// Represents a class, including its name and contained methods.
+    /// </summary>
+    /// <param name="Id"></param>
+    /// <param name="Name"> Gets or sets the name associated with the object. </param>
+    /// <param name="Methods"> Gets or sets the collection of methods associated with this instance. </param>
+    /// <param name="Fields"> Gets or sets the collection of field definitions associated with the structure. </param>
+    /// <param name="Type"> Gets or sets the type associated with the current instance. </param>
+    /// <param name="Relationships"> Gets or sets the collection of relationships associated with the current object. </param>
+    /// <param name="Summary"> Gets or sets the summary description for the current object. </param>
+    public record ClassStructure(int Id, string Name, List<MethodStructure> Methods, List<FieldStructure> Fields, string Type, List<RelationShip>? Relationships, string Summary);
+
+    /// <summary>
+    /// Represents the metadata for a method, including its name, access modifier, return type, and parameters.
+    /// </summary>
+    /// <param name="Id"></param>
+    /// <param name="Name"> Gets or sets the name associated with the function. </param>
+    /// <param name="Modifier"> Gets or sets the modifier associated with the function. </param>
+    /// <param name="ReturnType"> Gets or sets the return type associated with the function. </param>
+    /// <param name="Parameters"> Gets or sets the collection of parameters associated with the function. </param>
+    /// <param name="Summary"> Gets or sets the summary description for the current object. </param>
+    /// <remarks>Use this class to describe the signature and characteristics of a method in code analysis,
+    /// code generation, or documentation scenarios. The class does not represent the method's implementation or
+    /// behavior.</remarks>
+    public record MethodStructure(int Id, string Name, string Modifier, string ReturnType, List<ParameterStructure> Parameters, string Summary);
+
+
+
+    /// <param name="Id"></param>
+    /// <param name="Name"> Gets or sets the name associated with the field. </param>
+    /// <param name="Modifier"> Gets or sets the modifier associated with the field. </param>
+    /// <param name="Type"> Gets or sets the type associated with the field. </param>
+    /// <param name="Summary"> Gets or sets the summary description for the current object. </param>
+    public record FieldStructure(int Id, string Name, string Modifier, string Type, string Summary);
+
+
+
+
+
+    /// <summary>
+    /// Represents a parameter definition, including its name, modifier, and type information.
+    /// </summary>
+    /// <param name="Name"> Gets or sets the name associated with the object. </param>
+    /// <param name="Modifier"> Gets or sets the modifier associated with the current instance. </param>
+    /// <param name="Type"> Gets or sets the type associated with the current instance. </param>
+    /// <param name="Summary"> Gets or sets the summary description for the current object. </param>
+    /// <remarks>Use this class to describe parameters for methods, constructors, or other callable members.
+    /// The properties provide metadata about the parameter's identifier, its modifier (such as 'ref', 'out', or 'in'),
+    /// and its data type.</remarks>
+    public record ParameterStructure(string Name, string Modifier, string Type, string Summary);
+}

cod8a/dotnet/CodeAnalysis/models/ProjectStructure.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeAnalyzer.Models
+{
+    public class ProjectStructure
+    {
+        /// <summary>
+        /// Id of the Project
+        /// </summary>
+        public int Id { get; set; }
+
+        /// <summary>
+        /// Name of the Project
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Project Description
+        /// </summary>
+        public string Description { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection of files associated with the Project.
+        /// </summary>
+        public List<FileStructure> Files { get; set; }
+    }
+}

cod8a/dotnet/CodeAnalysis/models/SolutionStructure.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeAnalyzer.Models
+{
+    public  class SolutionStructure
+    {
+        /// <summary>
+        /// Gets or sets the ID of the Solution
+        /// </summary>
+        public int Id { get; set; }
+        /// <summary>
+        /// Gets or sets the name of the Solution
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the description associated with the object.
+        /// </summary>
+        public string Description { get; set; }
+
+        /// <summary>
+        /// Gets or sets the collection of projects within this solution
+        /// </summary>
+        public List<ProjectStructure> Projects { get; set; }
+    }
+}

cod8a/dotnet/Test/CodeAnalyzerTest.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CodeAnalysis\CodeAnalyzer.csproj" />
+  </ItemGroup>
+
+</Project>

cod8a/dotnet/Test/Mermaid/ClassDiagramTest.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Linq;
+using Xunit;
+using CodeAnalyzer.Parsers;
+using CodeAnalyzer.Models;
+
+namespace MermaidTests.Mermaid
+{
+    public class ClassDiagramTest
+    {
+        [Fact]
+        public void Parse_GeneratesCorrectRelationshipsForMermaid()
+        {
+            // Arrange
+            var testCode = @"
+            namespace TestNamespace
+            {
+                public interface IEmployee { }
+
+                public class Employee : IEmployee
+                {
+                    public string Name { get; set; }
+                }
+
+                public class Manager
+                {
+                    public Employee Employee;
+                }
+            }";
+
+            var filePath = Path.GetTempFileName() + ".cs";
+            File.WriteAllText(filePath, testCode);
+
+            try
+            {
+                var parser = new FileParser<FileStructure>
+                {
+                    FilePath = filePath,
+                    Name = Path.GetFileName(filePath)
+                };
+
+                // Act
+                var result = parser.Parse();
+
+                // Assert
+                Assert.NotNull(result);
+
+                var employeeClass = result.Classes.First(c => c.Name == "Employee");
+                var managerClass = result.Classes.First(c => c.Name == "Manager");
+
+                // Test Inheritance/Interface Relationship (Mermaid uses this for <|-- and <|..)
+                Assert.Single(employeeClass.Relationships);
+                var interfaceRel = employeeClass.Relationships.First();
+                Assert.Equal("Interface", interfaceRel.Type);
+                Assert.Equal("IEmployee", interfaceRel.AssociatedItem);
+
+                // Test Composition/Uses Relationship (Mermaid uses this for --> contains/uses)
+                Assert.Single(managerClass.Fields);
+                var employeeField = managerClass.Fields.First();
+                Assert.Equal("Employee", employeeField.Type);
+                Assert.Equal("Employee", employeeField.Name);
+            }
+            finally
+            {
+                File.Delete(filePath);
+            }
+        }
+    }
+}
+

cod8a/enums/diagram_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class DiagramType(Enum):
+    CLASS = "class"
+    SEQUENCE = "sequence"
+    FLOWCHART = "flowchart"
+    USE_CASE = "use_case"
+    ACTIVITY = "activity"
+    COMPONENT = "component"
+    DEPLOYMENT = "deployment"

cod8a/generators/mermaid/class_diagram.py

@@ -0,0 +1,165 @@
+import json
+import re
+from typing import List, Dict, Any, Union
+
+from cod8a.models.models import ClassStructure, FieldStructure, FileStructure, ProjectStructure
+
+class ClassDiagramGenerator:
+    """
+    Generates a Mermaid class diagram from a JSON representation of code structure.
+    """
+
+    def generate(self, data: Union[FileStructure, ProjectStructure, List[FileStructure]]) -> str:
+        if not isinstance(data, FileStructure | ProjectStructure | list):
+                return "Error: Invalid data structure"
+
+        # files = self._extract_files(data)
+        classes = []
+        all_classes = self._extract_classes(data, classes)
+        mermaid_lines = ["classDiagram"]
+        # 1. Generate Class Definitions
+        for cls in all_classes:
+            mermaid_lines.extend(self._generate_class_block(cls))
+        
+        # 2. Generate Relationships
+        mermaid_lines.extend(self._generate_relationships(all_classes))
+        
+        return "\n".join(mermaid_lines)
+
+    def _extract_files(self, data: Union[FileStructure | ProjectStructure]) -> List[Union[FileStructure | ProjectStructure]]:
+        files : list[FileStructure] = []
+        if isinstance(data, FileStructure):
+            if "files" in data:
+                for file in data["files"]:
+                    files.extend(file)
+            
+            else:
+                files.extend(data)
+                
+        return files
+
+    def _extract_classes(self, data: Union[FileStructure | ProjectStructure], classes: list[ClassStructure]) -> List[ClassStructure]:
+        seen_classes = set()
+        if isinstance(data, FileStructure):
+            for cls in data.classes:
+                cls_name = cls.name
+                if cls_name and cls_name not in seen_classes:
+                    classes.append(cls)
+                    seen_classes.add(cls_name)
+        elif isinstance(data, list):
+            for file in data:
+                self._extract_classes(file, classes)
+        elif isinstance(data, ProjectStructure):
+            for file in data.files:
+              self._extract_classes(file, classes)
+        else:
+            print("Invalid file structure")
+            return 
+        
+        return classes
+
+    def _generate_class_block(self, cls: ClassStructure) -> List[str]:
+        lines = [f"    class {cls.name} {{"]
+        
+        # Fields
+        for field in cls.fields:
+            f_name = field.name
+            f_type = field.type
+            f_mod = field.modifier.lower()
+            
+            visibility = self._get_visibility(f_mod)
+            lines.append(f"        {visibility}{f_type} {f_name}")
+            
+        # Methods
+        for method in cls.methods:
+            m_name = method.name
+            m_type = method.return_type
+            m_mod = method.modifier.lower()
+            
+            visibility = self._get_visibility(m_mod)
+            params_list = method.parameters
+            param_str = ", ".join([f"{p.type} {p.name}" if p.type else p.name for p in params_list])
+            
+            method_line = f"        {visibility}{m_name}({param_str})"
+            if m_type:
+                method_line += f" {m_type}"
+            lines.append(method_line)
+            
+        lines.append("    }")
+        lines.append("")
+        return lines
+
+    def _get_fields_to_show(self, cls: ClassStructure) -> List[FieldStructure]:
+        # Try to find <param name="xxx"> tags which are common in C# records
+        params = re.findall(r'<param[\s\n\r]+name\s*=\s*["\\]+([^"\\]+)["\\]+', cls.summary, re.IGNORECASE)
+
+        fields_to_show = []
+        existing_fields = {f.name: f for f in cls.fields}
+        
+        if params:
+            for p_name in params:
+                if p_name in existing_fields:
+                    fields_to_show.append(existing_fields[p_name])
+        else:
+            # No params in summary
+            for f in cls.fields:
+                fields_to_show.append(f)
+        return fields_to_show
+
+    def _get_visibility(self, modifier: str) -> str:
+        if "public" in modifier:
+            return "+"
+        if "private" in modifier:
+            return "-"
+        if "protected" in modifier:
+            return "#"
+        if "internal" in modifier:
+            return "~"
+        return "+" # Default to public
+
+    def _generate_relationships(self, classes: List[ClassStructure]) -> List[str]:
+        rel_lines = []
+        class_names = {c.name for c in classes}
+        
+        for cls in classes:
+            cls_name = cls.name
+            # Check for inheritance/implementation
+            for relation in cls.associated_item:
+                connector = "<|--" # Default to inheritance
+                label = "inherits"
+                if "interface" in relation.type.lower() or "implements" in relation.type.lower():
+                   label = "implements"
+                
+                rel_lines.append(f"    {relation.parent_name} {connector} {cls_name} : {label}")
+            
+            # Composition/Association from Fields
+            for field in cls.fields:
+                # Extract base type from List<T> or T[]
+                match = re.search(r'<([^>]+)>', field.type)
+                base_type = match.group(1) if match else field.type
+                base_type = base_type.replace('[]', '').strip()
+                
+                for name in class_names:
+                    if name in base_type and cls_name != name:
+                        connector = "-->"
+                        label = "uses"
+                        
+                        # Use composition for collections if it looks like it contains the class
+                        if "List" in field.type or "[]" in field.type:
+                            connector = "*--"
+                            label = "contains"
+                        
+                        rel_lines.append(f"    {cls_name} {connector} {name} : {label}")
+                    
+        return sorted(list(set(rel_lines)))
+
+def generate_class_diagram(data: FileStructure | ProjectStructure) -> str:
+    print("calling uml class generator ...")
+    generator = ClassDiagramGenerator()
+    return generator.generate(data)
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'r') as f:
+            print(generate_class_diagram(f.read()))

cod8a/generators/mermaid/flowchart_diagram.py

@@ -0,0 +1,51 @@
+import re
+from typing import List, Union
+
+from cod8a.models.models import FileStructure, ProjectStructure
+
+class FlowchartDiagramGenerator:
+    """
+    Generates a readable Mermaid flowchart from code structure.
+    """
+
+    def generate(self, data: Union['FileStructure', 'ProjectStructure', List['FileStructure']], file_name: str) -> str:
+        mermaid_lines = ["graph TD"]
+        
+        # Track unique IDs to avoid conflicts in Mermaid
+        self.counter = 0
+
+        # Process input
+        files =[]
+        if isinstance(data, ProjectStructure): files = data.files
+        elif isinstance(data, FileStructure): files = [data]
+        elif isinstance(data, list): files = data
+
+        for file in files:
+            file_id = f"file_{self._get_id()}"
+            mermaid_lines.append(f'    {file_id}["File: {file.name}"]')
+            
+            for cls in file.classes:
+                cls_id = f"cls_{self._get_id()}"
+                mermaid_lines.append(f'    {file_id} --> {cls_id}["Class: {cls.name}"]')
+                
+                # Exclude private Properties
+                fields = [f for f in cls.fields if f.modifier not in "private"]
+                # If too many fields, don't overwhelm the diagram truncate
+                fields = fields[:10] if len(fields) > 10 else fields
+                for field in fields:
+                    f_id = f"f_{self._get_id()}"
+                    mermaid_lines.append(f'    {cls_id} --> {f_id}["{field.name} ({field.type})"]')
+
+                # Methods: Always helpful to see
+                for method in cls.methods:
+                    m_id = f"m_{self._get_id()}"
+                    mermaid_lines.append(f'    {cls_id} --> {m_id}{{"{method.name}()"}}')
+            
+        return "\n".join(mermaid_lines)
+
+    def _get_id(self) -> int:
+        self.counter += 1
+        return self.counter
+
+def generate_flowchart_diagram(data, file_name) -> str:
+    return FlowchartDiagramGenerator().generate(data, file_name)

cod8a/generators/mermaid/sequence_diagram.py

@@ -0,0 +1,80 @@
+import re
+from typing import List, Union
+
+from cod8a.models.models import ClassStructure, FileStructure, ProjectStructure
+
+class SequenceDiagramGenerator:
+    """ Generates a generic Mermaid sequence diagram based on class structure. """
+
+    def _sanitize(self, name: str) -> str:
+        return re.sub(r'[^a-zA-Z0-9_ ]', '', name)
+
+    def generate(self, data: Union['FileStructure', 'ProjectStructure', list['FileStructure']]) -> str:
+        classes = self._extract_classes(data)
+        
+        mermaid_lines = ["sequenceDiagram", "    autonumber"]
+        
+        aliases = {}
+        mermaid_lines.append("    participant C as User")
+        
+        for i, cls in enumerate(classes):
+            alias = f"P{i}"
+            aliases[cls.name] = alias
+            mermaid_lines.append(f'    participant {alias} as "{self._sanitize(cls.name)}"')
+
+        mermaid_lines.append("") 
+
+        # Generic Interaction Logic
+        for cls in classes:
+            cls_alias = aliases[cls.name]
+            
+            # Determine if this is a Model or a Service
+            # Models have fields, Services have methods
+            is_model = len(cls.fields) > len(cls.methods) and len(cls.fields) > 0
+            
+
+            if is_model:
+                # Exclude private properties
+                fields = [f for f in cls.fields if f.modifier != "private"]
+                mermaid_lines.append(f"    C->>{cls_alias}: Create {cls.name}")
+                for field in fields[:5]: # Limit to 5 fields to avoid huge diagrams
+                    if not field.name.startswith('_'):
+                        mermaid_lines.append(f"    {cls_alias}->>{cls_alias}: Set {self._sanitize(field.name)}")
+            else:
+                # Exclude private methods
+                methods = [m for m in cls.methods if m.modifier != "private"]
+                for method in methods:
+                    if method.name.lower() in["dispose", "tostring", "equals", "gethashcode", "gettype"]:
+                        continue
+                    
+                    params = ", ".join([p.name for p in method.parameters[:2]])
+                    mermaid_lines.append(f"    C->>{cls_alias}: {self._sanitize(method.name)}({params})")
+                    
+                    # If the method returns something meaningful, show the return
+                    ret = self._clean_type(method.return_type)
+                    if ret and ret != "void":
+                        mermaid_lines.append(f"    {cls_alias}-->>C: {ret}")
+            
+            mermaid_lines.append("") 
+
+        return "\n".join(mermaid_lines)
+
+    def _extract_classes(self, data) -> List['ClassStructure']:
+        # Generic extraction for any input type
+        if hasattr(data, 'files'): return [c for f in data.files for c in f.classes]
+        if isinstance(data, list): return [c for item in data for c in item.classes]
+        if hasattr(data, 'classes'): return data.classes
+        return[]
+
+    def _clean_type(self, type_str: str) -> str:
+        if not type_str: return ""
+        return re.split(r'[<\[]', type_str)[0].replace('?', '').split('.')[-1].strip()
+
+def generate_sequence_diagram(data) -> str:
+    return SequenceDiagramGenerator().generate(data)
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'r') as f:
+            print(generate_sequence_diagram(f.read()))

cod8a/helpers/cli_helper.py

@@ -0,0 +1,79 @@
+import os
+import re
+from typing import Union
+
+import click
+
+from cod8a.parsers.dotnet_parser import DotnetParser
+from cod8a.parsers.python_parser import PythonParser
+from cod8a.models.models import FileStructure, ProjectStructure
+
+# Path to the C# analyzer project
+DOTNET_ANALYZER_PATH = os.path.join(os.path.dirname(__file__), "..", "dotnet", "CodeAnalysis", "CodeAnalyzer.csproj")
+
+def _get_parser(path: str):
+    print(f"Checking analyzer ...")
+    isDotnetParser = any(path.endswith(ext) for ext in [".cs", ".csproj", ".sln"]) or os.path.isdir(path) and any(f.endswith(".cs") for _, _, files in os.walk(path) for f in files) 
+    if isDotnetParser:
+        return DotnetParser(DOTNET_ANALYZER_PATH)
+    return PythonParser()
+
+# Extracts code structure from the syntax tree
+def extract_structure(path) -> Union[FileStructure | ProjectStructure | list[FileStructure]]:
+    target = path or os.getcwd()
+    parser = _get_parser(target)
+    
+    pathExists = os.path.exists(path)
+    if not pathExists:
+        print("Not found")
+        return
+    
+    struct = parser.parse(path or os.getcwd())
+    
+    return struct
+
+# Save the generated diagram to the directory provided in '-o' command
+# or root directory, if no output directory is provided (only on users authorization)
+def save_diagram(struct, canon_type, content, output=None, path=None):
+    """Helper to save mermaid diagram."""
+    try:
+        file_path = None
+        
+        # Prepare filename (PascalCase)
+        raw_name = getattr(struct, "name", "diagram")
+        base_name = os.path.splitext(raw_name)[0]
+        # Split by non-alphanumeric and capitalize first letter of each part, preserving internal caps
+        pascal_name = "".join(word[0].upper() + word[1:] for word in re.split(r'[^a-zA-Z0-9]', base_name) if word)
+        
+        if not pascal_name:
+            pascal_name = "GeneratedDiagram"
+            
+        # Append diagram type suffix
+        suffix_map = {"class": "Class", "flowchart": "Flowchart", "sequence": "Sequence"}
+        pascal_name += suffix_map.get(canon_type, "")
+
+        if output:
+            # If output is a directory, use it as base
+            if os.path.isdir(output):
+                file_path = os.path.join(output, f"{pascal_name}.mmd")
+            else:
+                # If output is a file path, use it, ensuring .mmd extension
+                file_path = output
+                if not file_path.endswith(".mmd"):
+                    file_path += ".mmd"
+        else:
+            # If no output provided, prompt the user
+            if click.confirm("\nDo you want to save the diagram to a file?", default=True):
+                # Save in the user's Downloads directory
+                save_dir = os.path.join(os.path.expanduser("~"), "Downloads")
+                file_path = os.path.join(save_dir, f"{pascal_name}.mmd")
+        
+        if file_path:
+            # Ensure the directory exists
+            os.makedirs(os.path.dirname(os.path.abspath(file_path)), exist_ok=True)
+            with open(file_path, "w") as f:
+                f.write(content)
+            click.echo(f"Diagram exported to: {file_path}")
+            
+    except Exception as e:
+        click.echo(f"Warning: Could not export diagram: {e}")