cod8a 0.1.0__py3-none-any.whl

cod8a/__init__.py

@@ -0,0 +1,3 @@
+"""
+CLI for Code Visualization and Documentation
+"""

cod8a/cli.py

@@ -0,0 +1,93 @@
+import click
+import os
+from dataclasses import asdict
+
+from cod8a.generators.mermaid.class_diagram import generate_class_diagram
+from cod8a.generators.mermaid.flowchart_diagram import generate_flowchart_diagram
+from cod8a.generators.mermaid.sequence_diagram import generate_sequence_diagram
+from cod8a.helpers.cli_helper import extract_structure, save_diagram
+from cod8a.enums.diagram_type import DiagramType
+
+
+class ExpandedHelpGroup(click.Group):
+    def format_help(self, ctx, formatter):
+        # 1. Main help (Group docstring)
+        self.format_usage(ctx, formatter)
+        self.format_help_text(ctx, formatter)
+        self.format_options(ctx, formatter)
+        
+        # 2. Subcommands and their options
+        for command_name in self.list_commands(ctx):
+            command = self.get_command(ctx, command_name)
+            if command and not command.hidden:
+                formatter.write_paragraph()
+                with formatter.section(f"Command: {command_name}"):
+                    # Usage and help text
+                    formatter.write_text(command.help or "")
+                    command.format_options(ctx, formatter)
+
+@click.group(cls=ExpandedHelpGroup)
+def cli():
+    """cod8a (pronounced codetta) is a tool for analyzing and visualizing code structure.
+    
+    It supports both Python and C# projects, generating Mermaid-compatible diagrams.
+    """
+    pass
+
+# Generation of UML Diagrams
+@cli.command(help="Generate a Mermaid diagram from the source code structure.")
+@click.option('-p', '--path', required=True, 
+              help='The path to the file or directory to analyze.')
+@click.option('-d', '--diagram', 'diagram_type', default='class', 
+              type=click.Choice(["seq", "s", "sequence", "flow", "f", "flowchart", "c", "class"]), 
+              help='The type of diagram to generate (default: class).')
+@click.option('-o', '--output', 
+              help='Optional output file path. If not provided, you will be prompted to save to the Downloads folder.')
+def uml(path, diagram_type, output):
+    """Generate UML diagram (Mermaid format)."""
+    struct = extract_structure(path)
+    base_name = os.path.basename(path or os.getcwd())
+    # print(struct)
+
+    if not struct:
+        click.echo("Error: Could not extract structure.")
+        return
+
+    canon_type = "class"
+    if DiagramType.FLOWCHART.value.startswith(diagram_type):
+        diagram = generate_flowchart_diagram(struct, base_name)
+        canon_type = "flowchart"
+    elif DiagramType.SEQUENCE.value.startswith(diagram_type):
+        diagram = generate_sequence_diagram(struct)
+        canon_type = "sequence"
+    else:
+        diagram = generate_class_diagram(struct)
+        canon_type = "class"
+        
+    print(diagram)
+    
+    # Save diagram
+    save_diagram(struct, canon_type, diagram, output, path)
+
+
+# TODO Generating code documentation 
+@click.command(help="[TODO] Generate documentation (Markdown format) from code structure.")
+@click.option('-p', '--path', help='Specific path of file(s) to analyze')
+@click.option('--json', 'output_json', is_flag=True, help='Output in JSON format')
+def doc_cli(path, output_json):
+    """Generate documentation (Markdown format)."""
+    target = path or os.getcwd()
+    struct = extract_structure(target)
+
+
+# Main entry point for cod8a
+def main():
+    cli.add_command(doc_cli, name="doc")
+    cli()
+
+# Separate entry point for code8a
+def doc_main():
+    doc_cli()
+
+if __name__ == "__main__":
+    main()

cod8a/cod8a.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == '__main__':
+    main()

cod8a/dotnet/CodeAnalysis/CodeAnalyzer.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.3.0" />
+  </ItemGroup>
+
+</Project>

cod8a/dotnet/CodeAnalysis/CodeAnalyzer.csproj.lscache

@@ -0,0 +1,262 @@
+version=1
+
+# This file caches language service data to improve the performance of C# Dev Kit.
+# It is not intended for manual editing. It can safely be deleted and will be
+# regenerated automatically. For more information, see https://aka.ms/lscache
+#
+# To control where cache files are stored, use the following VS Code setting:
+#   "dotnet.projectsystem.cacheInProjectFolder": true
+
+[project]
+language=C#
+primary
+lastDtbSucceeded
+
+[properties]
+AssemblyName=CodeAnalyzer
+CommandLineArgsForDesignTimeEvaluation=-langversion:14.0 -define:TRACE
+CompilerGeneratedFilesOutputPath=
+MaxSupportedLangVersion=14.0
+ProjectAssetsFile=<PATH>obj/project.assets.json
+RootNamespace=CodeAnalyzer
+RunAnalyzers=
+RunAnalyzersDuringLiveAnalysis=
+SolutionPath=<PATH>../../../../cod8a.sln
+TargetFrameworkIdentifier=.NETCoreApp
+TargetPath=<PATH>bin/Debug/net10.0/CodeAnalyzer.dll
+TargetRefPath=<PATH>obj/Debug/net10.0/ref/CodeAnalyzer.dll
+TemporaryDependencyNodeTargetIdentifier=net10.0
+
+[commandLineArguments]
+/noconfig
+/unsafe-
+/checked-
+/nowarn:1701,1702,1701,1702
+/fullpaths
+/nostdlib+
+/errorreport:prompt
+/warn:10
+/define:TRACE;DEBUG;NET;NET10_0;NETCOREAPP;NET5_0_OR_GREATER;NET6_0_OR_GREATER;NET7_0_OR_GREATER;NET8_0_OR_GREATER;NET9_0_OR_GREATER;NET10_0_OR_GREATER;NETCOREAPP1_0_OR_GREATER;NETCOREAPP1_1_OR_GREATER;NETCOREAPP2_0_OR_GREATER;NETCOREAPP2_1_OR_GREATER;NETCOREAPP2_2_OR_GREATER;NETCOREAPP3_0_OR_GREATER;NETCOREAPP3_1_OR_GREATER
+/highentropyva+
+/nullable:enable
+/features:"InterceptorsNamespaces=;Microsoft.Extensions.Validation.Generated"
+/debug+
+/debug:portable
+/filealign:512
+/optimize-
+/out:obj/Debug/net10.0/CodeAnalyzer.dll
+/refout:obj/Debug/net10.0/refint/CodeAnalyzer.dll
+/target:exe
+/warnaserror-
+/utf8output
+/deterministic+
+/langversion:14.0
+/warnaserror+:NU1605,SYSLIB0011
+
+[sourceFiles]
+models/
+ FileStructure.cs
+ ProjectStructure.cs
+ SolutionStructure.cs
+obj/Debug/net10.0/
+ .NETCoreApp,Version=v10.0.AssemblyAttributes.cs
+ CodeAnalyzer.AssemblyInfo.cs
+ CodeAnalyzer.GlobalUsings.g.cs
+Parsers/
+ BaseParser.cs
+ FileParser.cs
+ ProjectParser.cs
+ SolutionParser.cs
+Program.cs
+
+[metadataReferences]
+<DOTNET>/packs/Microsoft.NETCore.App.Ref/10.0.3/ref/net10.0/
+ Microsoft.CSharp.dll
+ Microsoft.VisualBasic.Core.dll
+ Microsoft.VisualBasic.dll
+ Microsoft.Win32.Primitives.dll
+ Microsoft.Win32.Registry.dll
+ mscorlib.dll
+ netstandard.dll
+ System.AppContext.dll
+ System.Buffers.dll
+ System.Collections.Concurrent.dll
+ System.Collections.dll
+ System.Collections.Immutable.dll
+ System.Collections.NonGeneric.dll
+ System.Collections.Specialized.dll
+ System.ComponentModel.Annotations.dll
+ System.ComponentModel.DataAnnotations.dll
+ System.ComponentModel.dll
+ System.ComponentModel.EventBasedAsync.dll
+ System.ComponentModel.Primitives.dll
+ System.ComponentModel.TypeConverter.dll
+ System.Configuration.dll
+ System.Console.dll
+ System.Core.dll
+ System.Data.Common.dll
+ System.Data.DataSetExtensions.dll
+ System.Data.dll
+ System.Diagnostics.Contracts.dll
+ System.Diagnostics.Debug.dll
+ System.Diagnostics.DiagnosticSource.dll
+ System.Diagnostics.FileVersionInfo.dll
+ System.Diagnostics.Process.dll
+ System.Diagnostics.StackTrace.dll
+ System.Diagnostics.TextWriterTraceListener.dll
+ System.Diagnostics.Tools.dll
+ System.Diagnostics.TraceSource.dll
+ System.Diagnostics.Tracing.dll
+ System.dll
+ System.Drawing.dll
+ System.Drawing.Primitives.dll
+ System.Dynamic.Runtime.dll
+ System.Formats.Asn1.dll
+ System.Formats.Tar.dll
+ System.Globalization.Calendars.dll
+ System.Globalization.dll
+ System.Globalization.Extensions.dll
+ System.IO.Compression.Brotli.dll
+ System.IO.Compression.dll
+ System.IO.Compression.FileSystem.dll
+ System.IO.Compression.ZipFile.dll
+ System.IO.dll
+ System.IO.FileSystem.AccessControl.dll
+ System.IO.FileSystem.dll
+ System.IO.FileSystem.DriveInfo.dll
+ System.IO.FileSystem.Primitives.dll
+ System.IO.FileSystem.Watcher.dll
+ System.IO.IsolatedStorage.dll
+ System.IO.MemoryMappedFiles.dll
+ System.IO.Pipelines.dll
+ System.IO.Pipes.AccessControl.dll
+ System.IO.Pipes.dll
+ System.IO.UnmanagedMemoryStream.dll
+ System.Linq.AsyncEnumerable.dll
+ System.Linq.dll
+ System.Linq.Expressions.dll
+ System.Linq.Parallel.dll
+ System.Linq.Queryable.dll
+ System.Memory.dll
+ System.Net.dll
+ System.Net.Http.dll
+ System.Net.Http.Json.dll
+ System.Net.HttpListener.dll
+ System.Net.Mail.dll
+ System.Net.NameResolution.dll
+ System.Net.NetworkInformation.dll
+ System.Net.Ping.dll
+ System.Net.Primitives.dll
+ System.Net.Quic.dll
+ System.Net.Requests.dll
+ System.Net.Security.dll
+ System.Net.ServerSentEvents.dll
+ System.Net.ServicePoint.dll
+ System.Net.Sockets.dll
+ System.Net.WebClient.dll
+ System.Net.WebHeaderCollection.dll
+ System.Net.WebProxy.dll
+ System.Net.WebSockets.Client.dll
+ System.Net.WebSockets.dll
+ System.Numerics.dll
+ System.Numerics.Vectors.dll
+ System.ObjectModel.dll
+ System.Reflection.DispatchProxy.dll
+ System.Reflection.dll
+ System.Reflection.Emit.dll
+ System.Reflection.Emit.ILGeneration.dll
+ System.Reflection.Emit.Lightweight.dll
+ System.Reflection.Extensions.dll
+ System.Reflection.Metadata.dll
+ System.Reflection.Primitives.dll
+ System.Reflection.TypeExtensions.dll
+ System.Resources.Reader.dll
+ System.Resources.ResourceManager.dll
+ System.Resources.Writer.dll
+ System.Runtime.CompilerServices.Unsafe.dll
+ System.Runtime.CompilerServices.VisualC.dll
+ System.Runtime.dll
+ System.Runtime.Extensions.dll
+ System.Runtime.Handles.dll
+ System.Runtime.InteropServices.dll
+ System.Runtime.InteropServices.JavaScript.dll
+ System.Runtime.InteropServices.RuntimeInformation.dll
+ System.Runtime.Intrinsics.dll
+ System.Runtime.Loader.dll
+ System.Runtime.Numerics.dll
+ System.Runtime.Serialization.dll
+ System.Runtime.Serialization.Formatters.dll
+ System.Runtime.Serialization.Json.dll
+ System.Runtime.Serialization.Primitives.dll
+ System.Runtime.Serialization.Xml.dll
+ System.Security.AccessControl.dll
+ System.Security.Claims.dll
+ System.Security.Cryptography.Algorithms.dll
+ System.Security.Cryptography.Cng.dll
+ System.Security.Cryptography.Csp.dll
+ System.Security.Cryptography.dll
+ System.Security.Cryptography.Encoding.dll
+ System.Security.Cryptography.OpenSsl.dll
+ System.Security.Cryptography.Primitives.dll
+ System.Security.Cryptography.X509Certificates.dll
+ System.Security.dll
+ System.Security.Principal.dll
+ System.Security.Principal.Windows.dll
+ System.Security.SecureString.dll
+ System.ServiceModel.Web.dll
+ System.ServiceProcess.dll
+ System.Text.Encoding.CodePages.dll
+ System.Text.Encoding.dll
+ System.Text.Encoding.Extensions.dll
+ System.Text.Encodings.Web.dll
+ System.Text.Json.dll
+ System.Text.RegularExpressions.dll
+ System.Threading.AccessControl.dll
+ System.Threading.Channels.dll
+ System.Threading.dll
+ System.Threading.Overlapped.dll
+ System.Threading.Tasks.Dataflow.dll
+ System.Threading.Tasks.dll
+ System.Threading.Tasks.Extensions.dll
+ System.Threading.Tasks.Parallel.dll
+ System.Threading.Thread.dll
+ System.Threading.ThreadPool.dll
+ System.Threading.Timer.dll
+ System.Transactions.dll
+ System.Transactions.Local.dll
+ System.ValueTuple.dll
+ System.Web.dll
+ System.Web.HttpUtility.dll
+ System.Windows.dll
+ System.Xml.dll
+ System.Xml.Linq.dll
+ System.Xml.ReaderWriter.dll
+ System.Xml.Serialization.dll
+ System.Xml.XDocument.dll
+ System.Xml.XmlDocument.dll
+ System.Xml.XmlSerializer.dll
+ System.Xml.XPath.dll
+ System.Xml.XPath.XDocument.dll
+ WindowsBase.dll
+<NUGET>/
+ microsoft.codeanalysis.common/5.3.0/lib/net10.0/Microsoft.CodeAnalysis.dll
+ microsoft.codeanalysis.csharp/5.3.0/lib/net10.0/Microsoft.CodeAnalysis.CSharp.dll
+
+[analyzerReferences]
+<DOTNET>/packs/Microsoft.NETCore.App.Ref/10.0.3/analyzers/dotnet/cs/
+ Microsoft.Interop.ComInterfaceGenerator.dll
+ Microsoft.Interop.JavaScript.JSImportGenerator.dll
+ Microsoft.Interop.LibraryImportGenerator.dll
+ Microsoft.Interop.SourceGeneration.dll
+ System.Text.Json.SourceGeneration.dll
+ System.Text.RegularExpressions.Generator.dll
+<DOTNET>/sdk/10.0.103/Sdks/Microsoft.NET.Sdk/analyzers/
+ Microsoft.CodeAnalysis.CSharp.NetAnalyzers.dll
+ Microsoft.CodeAnalysis.NetAnalyzers.dll
+<NUGET>/microsoft.codeanalysis.analyzers/5.3.0-2.25625.1/analyzers/dotnet/cs/
+ Microsoft.CodeAnalysis.Analyzers.dll
+ Microsoft.CodeAnalysis.CSharp.Analyzers.dll
+
+[analyzerConfigFiles]
+<DOTNET>/sdk/10.0.103/Sdks/Microsoft.NET.Sdk/analyzers/build/config/analysislevel_10_default.globalconfig
+obj/Debug/net10.0/CodeAnalyzer.GeneratedMSBuildEditorConfig.editorconfig

cod8a/dotnet/CodeAnalysis/Parsers/BaseParser.cs

@@ -0,0 +1,17 @@
+using CodeAnalyzer.Models;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeAnalyzer.Parsers
+{
+    public abstract class BaseParser<T>
+    {
+        /// <summary>
+        /// Gets the name of the file associated with this instance.
+        /// </summary>
+        public abstract string Name { get; init; }
+        public abstract T Parse();
+    }
+}

cod8a/dotnet/CodeAnalysis/Parsers/FileParser.cs

@@ -0,0 +1,150 @@
+using CodeAnalyzer.Models;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.Json;
+
+namespace CodeAnalyzer.Parsers
+{
+    /// <summary>
+    /// Provides functionality to parse C# source code files and extract their structural information, such as using
+    /// directives and class definitions.
+    /// </summary>
+    /// <remarks>Use this class to analyze the contents of a C# file by supplying its code and file name. The
+    /// parser returns a structured representation of the file, which includes details about its using directives and
+    /// classes. This class is not thread-safe.</remarks>
+    public sealed partial class FileParser<T> : BaseParser<T> where T : FileStructure
+    {
+
+        public override string Name { get; init; }
+
+        /// <summary>
+        /// Gets the code associated with this instance.
+        /// </summary>
+        public string FilePath { get; init; }
+        public override T Parse()
+        {
+            try
+            {
+                var code = File.ReadAllText(FilePath);
+                // Parse the code into a SyntaxTree
+                SyntaxTree tree = CSharpSyntaxTree.ParseText(code);
+
+                // Get the root node of the tree
+                CompilationUnitSyntax root = tree.GetCompilationUnitRoot();
+
+
+                var directory = Directory.GetCurrentDirectory();
+                var fileName = Path.GetFileName(directory);
+                var id = 0;
+                var usings = root.Usings.Select(b =>
+                {
+                    var name = GetName(b.Name);
+                    return new UsingDirective(++id, name);
+                });
+                var fileStructure = new FileStructure
+                {
+                    Id = 1,
+                    Name = fileName,
+                    UsingDirectives = usings.ToList(),
+                };
+
+
+                fileStructure.Classes = GetClassDeclaration(root);
+
+                return (T)fileStructure;
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+        }
+
+        private string GetName(NameSyntax? nameSyntax)
+        {
+            try
+            {
+                return nameSyntax switch
+                {
+                    null => string.Empty,
+                    SimpleNameSyntax simpleName => simpleName.Identifier.Text,
+                    QualifiedNameSyntax qualifiedName => qualifiedName.Right.Identifier.Text,
+                    AliasQualifiedNameSyntax aliasQualifiedName => aliasQualifiedName.Name.Identifier.Text,
+                    _ => string.Empty
+                };
+            }
+            catch( Exception ex )
+            {
+                throw;
+            }
+        }
+
+        private List<ClassStructure> GetClassDeclaration(CompilationUnitSyntax root)
+        {
+            var classes = new List<ClassStructure>();
+            try
+            {
+                var typeDeclarationSyntaxes = root.DescendantNodes().OfType<TypeDeclarationSyntax>();
+
+                foreach (var classDeclaration in typeDeclarationSyntaxes)
+                {
+                    var methodStructures = new List<MethodStructure>();
+                    var parameterStructures = new List<ParameterStructure>();
+                    var fieldStructures = new List<FieldStructure>();
+
+                    var relationships = new List<RelationShip>();
+
+                    var baseTypes = classDeclaration.BaseList?.Types;
+                    int id = 0;
+
+                    if(baseTypes is not null)
+                    {
+                        
+                        relationships.AddRange(
+                            baseTypes.Value.Select(b => {
+                                string parent = b.Type switch
+                                {
+                                    SimpleNameSyntax simpleName => simpleName.Identifier.Text,
+                                    QualifiedNameSyntax qualifiedName => qualifiedName.Right.Identifier.Text,
+                                    _ => b.Type.ToString().Split('<')[0]
+                                };
+                                var type = parent.StartsWith("I") && parent.Length > 1 && char.IsUpper(parent[1]) ? "Interface" : "Class";
+                                return new RelationShip (++id, type, parent);
+                            })
+                        );
+                    }
+
+                    // Extract standard fields and properties
+                    fieldStructures.AddRange(classDeclaration.DescendantNodes().OfType<FieldDeclarationSyntax>().Select(f => new FieldStructure(default, f.Declaration.Variables.First().Identifier.Text, f.Modifiers.ToFullString().Trim(), f.Declaration.Type.ToString(), f.GetLeadingTrivia().ToString().Trim())));
+                    fieldStructures.AddRange(classDeclaration.DescendantNodes().OfType<PropertyDeclarationSyntax>().Select(f => new FieldStructure(default, f.Identifier.Text, f.Modifiers.ToFullString().Trim(), f.Type.ToString(), f.GetLeadingTrivia().ToString().Trim())));
+                    
+                    // Extract record positional parameters as properties
+                    if (classDeclaration is RecordDeclarationSyntax recordDecl && recordDecl.ParameterList != null)
+                    {
+                        fieldStructures.AddRange(recordDecl.ParameterList.Parameters.Select(p => new FieldStructure(default, p.Identifier.Text, "public", p.Type?.ToString() ?? "", p.GetLeadingTrivia().ToString().Trim())));
+                    }
+
+                    foreach (var method in classDeclaration.Members.OfType<MethodDeclarationSyntax>())
+                    {
+                        var parameters = method.ParameterList.Parameters.Select(p => new ParameterStructure(p.Identifier.Text, p.Modifiers.ToFullString().Trim(), p.Type?.ToString() ?? "", p.GetLeadingTrivia().ToString().Trim())).ToList();
+                        parameterStructures.AddRange(parameters);
+
+                        methodStructures.Add(new MethodStructure(default, method.Identifier.Text, method.Modifiers.ToFullString().Trim(), method.ReturnType.ToString(), parameters, method.GetLeadingTrivia().ToString().Trim()));
+                    }
+                    classes.Add(new ClassStructure(default, classDeclaration.Identifier.Text, methodStructures, fieldStructures, classDeclaration.Keyword.ToFullString().Trim(), relationships, classDeclaration.GetLeadingTrivia().ToString().Trim()));
+                }
+
+                return classes;
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+        }
+    }
+}
+
+

cod8a/dotnet/CodeAnalysis/Parsers/ProjectParser.cs

@@ -0,0 +1,37 @@
+using CodeAnalyzer.Models;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeAnalyzer.Parsers
+{
+    public sealed partial class ProjectParser<T> : BaseParser<T> where T : ProjectStructure
+    {
+        public override string Name { get; init; }
+        
+        public string[] FilePaths { get; init; }
+
+        public override T Parse()
+        {
+            try
+            {
+                var projectStructure = new ProjectStructure
+                {
+                    Id = 1,
+                    Name = Name,
+                    Files = FilePaths.Select(b => new FileParser<FileStructure> { FilePath = b, Name = Path.GetFileName(b) }.Parse()).ToList(),
+                };
+                
+                return (T) projectStructure;
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+        }
+    }
+
+}

cod8a/dotnet/CodeAnalysis/Parsers/SolutionParser.cs

@@ -0,0 +1,17 @@
+using CodeAnalyzer.Models;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeAnalyzer.Parsers
+{
+    public sealed partial class SolutionParser<T> : BaseParser<T> where T : SolutionStructure
+    {
+        public override string Name { get; init; }
+
+        public override T Parse()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

cod8a/dotnet/CodeAnalysis/Program.cs

@@ -0,0 +1,58 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using CodeAnalyzer.Models;
+using CodeAnalyzer.Parsers;
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Console.WriteLine("Starting code analysis...");
+        var fileName = args.Length > 0 ? args[0] : null;
+        //Check if path is directory
+        var fileAttr = File.GetAttributes(fileName!);
+        var isDirectory = fileAttr.HasFlag(FileAttributes.Directory);
+
+
+        if(string.IsNullOrEmpty(fileName))
+        {
+            Console.Error.WriteLine(@"No file or project specified. Please provide a file/directory
+                                     containing ...cs, .csproj, or .sln file.");
+            return;
+        }
+
+        if (!File.Exists(fileName) && !isDirectory){
+            Console.Error.WriteLine($"File not found: {fileName}");
+            return;
+        }
+        
+        string json = "";
+
+        if (isDirectory || fileName.EndsWith(".csproj") || fileName.EndsWith(".sln") || fileName.EndsWith(".slnx"))
+        {
+            var csFiles = Directory.GetFiles(Path.GetDirectoryName(fileName)!, "*.cs", SearchOption.AllDirectories).Where(f => !f.Contains("obj", StringComparison.CurrentCultureIgnoreCase)).ToArray();
+
+            BaseParser<ProjectStructure> projectStructure = new ProjectParser<ProjectStructure>()
+            {
+                FilePaths = csFiles,
+                Name = Path.GetFileName(fileName),
+            };
+
+            json = JsonSerializer.Serialize(projectStructure.Parse(), new JsonSerializerOptions { WriteIndented = false });
+        }
+        else
+        {
+            BaseParser<FileStructure> fileStructure = new FileParser<FileStructure>()
+            {
+                FilePath = fileName,
+                Name = Path.GetFileName(fileName),
+            };
+
+            json = JsonSerializer.Serialize(fileStructure.Parse(), new JsonSerializerOptions { WriteIndented = false });
+        }
+
+        Console.WriteLine(json);
+    }
+}