mvn-tree-visualizer 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

mvn_tree_visualizer/cli.py

@@ -1,13 +1,130 @@
 import argparse
+import time
 from pathlib import Path
+from typing import NoReturn
 
 from .diagram import create_diagram
+from .exceptions import DependencyFileNotFoundError, DependencyParsingError, MvnTreeVisualizerError, OutputGenerationError
+from .file_watcher import FileWatcher
 from .get_dependencies_in_one_file import merge_files
 from .outputs.html_output import create_html_diagram
 from .outputs.json_output import create_json_output
+from .validation import find_dependency_files, print_maven_help, validate_dependency_files, validate_output_directory
 
 
-def cli():
+def generate_diagram(
+    directory: str,
+    output_file: str,
+    filename: str,
+    keep_tree: bool,
+    output_format: str,
+    show_versions: bool,
+) -> None:
+    """Generate the dependency diagram with comprehensive error handling."""
+    timestamp = time.strftime("%H:%M:%S")
+
+    try:
+        # Validate inputs
+        validate_dependency_files(directory, filename)
+        validate_output_directory(output_file)
+
+        # Show what files we found
+        dependency_files = find_dependency_files(directory, filename)
+        if len(dependency_files) > 1:
+            print(f"[{timestamp}] Found {len(dependency_files)} dependency files")
+
+        # Setup paths
+        dir_to_create_files = Path(output_file).parent
+        dir_to_create_intermediate_files = Path(dir_to_create_files)
+        intermediate_file_path: Path = dir_to_create_intermediate_files / "dependency_tree.txt"
+
+        # Merge dependency files
+        try:
+            merge_files(
+                output_file=intermediate_file_path,
+                root_dir=directory,
+                target_filename=filename,
+            )
+        except FileNotFoundError as e:
+            raise DependencyParsingError(f"Error reading dependency file: {e}\nThe file may have been moved or deleted during processing.")
+        except PermissionError as e:
+            raise DependencyParsingError(f"Permission denied while reading dependency files: {e}\nPlease check file permissions and try again.")
+        except UnicodeDecodeError as e:
+            raise DependencyParsingError(
+                f"Error decoding dependency file content: {e}\n"
+                f"The file may contain invalid characters or use an unsupported encoding.\n"
+                f"Please ensure the file is in UTF-8 format."
+            )
+
+        # Validate merged content
+        if not intermediate_file_path.exists() or intermediate_file_path.stat().st_size == 0:
+            raise DependencyParsingError(
+                "Generated dependency tree file is empty.\n"
+                "This usually means the Maven dependency files contain no valid dependency information.\n"
+                "Please check that your Maven dependency files were generated correctly."
+            )
+
+        # Create diagram from merged content
+        try:
+            dependency_tree = create_diagram(
+                keep_tree=keep_tree,
+                intermediate_filename=str(intermediate_file_path),
+            )
+        except FileNotFoundError:
+            raise DependencyParsingError("Intermediate dependency tree file was not found.\nThis is an internal error - please report this issue.")
+        except Exception as e:
+            raise DependencyParsingError(f"Error processing dependency tree: {e}\nThe dependency file format may be invalid or corrupted.")
+
+        # Validate that we have content to work with
+        if not dependency_tree.strip():
+            raise DependencyParsingError(
+                "Dependency tree is empty after processing.\n"
+                "Please check that your Maven dependency files contain valid dependency information.\n"
+                "You can verify this by opening the files and checking their content."
+            )
+
+        # Generate output
+        try:
+            if output_format == "html":
+                create_html_diagram(dependency_tree, output_file, show_versions)
+            elif output_format == "json":
+                create_json_output(dependency_tree, output_file, show_versions)
+            else:
+                raise OutputGenerationError(f"Unsupported output format: {output_format}")
+        except PermissionError:
+            raise OutputGenerationError(
+                f"Permission denied writing to '{output_file}'.\nPlease check that you have write permissions to this location."
+            )
+        except OSError as e:
+            raise OutputGenerationError(
+                f"Error writing output file '{output_file}': {e}\nPlease check that you have enough disk space and write permissions."
+            )
+        except Exception as e:
+            raise OutputGenerationError(f"Error generating {output_format.upper()} output: {e}")
+
+        print(f"[{timestamp}] ✅ Diagram generated and saved to {output_file}")
+
+    except MvnTreeVisualizerError as e:
+        # Our custom errors already have helpful messages
+        print(f"[{timestamp}] ❌ Error: {e}")
+        if isinstance(e, DependencyFileNotFoundError):
+            print_maven_help()
+    except KeyboardInterrupt:
+        print(f"\n[{timestamp}] ⏹️  Operation cancelled by user")
+    except Exception as e:
+        # Unexpected errors
+        print(f"[{timestamp}] ❌ Unexpected error: {e}")
+        print("This is an internal error. Please report this issue with the following details:")
+        print(f"  - Directory: {directory}")
+        print(f"  - Filename: {filename}")
+        print(f"  - Output: {output_file}")
+        print(f"  - Format: {output_format}")
+        import traceback
+
+        traceback.print_exc()
+
+
+def cli() -> NoReturn:
     parser = argparse.ArgumentParser(
         prog="mvn-tree-visualizer",
         description="Generate a dependency diagram from a file.",
@@ -50,37 +167,49 @@ def cli():
         help="Keep the dependency tree file after generating the diagram. Default is False.",
     )
 
+    parser.add_argument(
+        "--show-versions",
+        action="store_true",
+        help="Show dependency versions in the diagram. Applicable to both HTML and JSON output formats.",
+    )
+
+    parser.add_argument(
+        "--watch",
+        action="store_true",
+        help="Watch for changes in Maven dependency files and automatically regenerate the diagram.",
+    )
+
     args = parser.parse_args()
     directory: str = args.directory
     output_file: str = args.output
     filename: str = args.filename
     keep_tree: bool = args.keep_tree
     output_format: str = args.format
+    show_versions: bool = args.show_versions
+    watch_mode: bool = args.watch
 
-    dir_to_create_files = Path(output_file).parent
+    # Generate initial diagram
+    print("Generating initial diagram...")
+    generate_diagram(directory, output_file, filename, keep_tree, output_format, show_versions)
 
-    dir_to_create_intermediate_files = Path(dir_to_create_files)
+    if not watch_mode:
+        print("You can open it in your browser to view the dependency tree.")
+        print("Thank you for using mvn-tree-visualizer!")
+        return
 
-    merge_files(
-        output_file=dir_to_create_intermediate_files / "dependency_tree.txt",
-        root_dir=directory,
-        target_filename=filename,
-    )
-
-    dependency_tree = create_diagram(
-        keep_tree=keep_tree,
-        intermediate_filename="dependency_tree.txt",
-    )
+    # Watch mode
+    def regenerate_callback():
+        """Callback function for file watcher."""
+        generate_diagram(directory, output_file, filename, keep_tree, output_format, show_versions)
 
-    if output_format == "html":
-        create_html_diagram(dependency_tree, output_file)
-    elif output_format == "json":
-        create_json_output(dependency_tree, output_file)
+    watcher = FileWatcher(directory, filename, regenerate_callback)
+    watcher.start()
 
-    print(f"Diagram generated and saved to {output_file}")
-    print("You can open it in your browser to view the dependency tree.")
-    print("Thank you for using mvn-tree-visualizer!")
+    try:
+        watcher.wait()
+    finally:
+        print("Thank you for using mvn-tree-visualizer!")
 
 
 if __name__ == "__main__":
-    cli()
+    cli()

mvn_tree_visualizer/diagram.py

@@ -1,13 +1,26 @@
+import os
+
+
 def create_diagram(
     keep_tree: bool = False,
     intermediate_filename: str = "dependency_tree.txt",
-):
-    with open(intermediate_filename, "r") as file:
-        dependency_tree = file.read()
+) -> str:
+    """Create diagram from dependency tree file."""
+    try:
+        with open(intermediate_filename, "r", encoding="utf-8") as file:
+            dependency_tree: str = file.read()
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Dependency tree file '{intermediate_filename}' not found")
+    except PermissionError:
+        raise PermissionError(f"Permission denied reading '{intermediate_filename}'")
+    except UnicodeDecodeError as e:
+        raise UnicodeDecodeError(e.encoding, e.object, e.start, e.end, f"Error decoding '{intermediate_filename}': {e.reason}")
 
     if not keep_tree:
-        import os
+        try:
+            os.remove(intermediate_filename)
+        except OSError:
+            # If we can't remove the intermediate file, it's not critical
+            pass
 
-        os.remove(intermediate_filename)
-    
     return dependency_tree

mvn_tree_visualizer/exceptions.py

@@ -0,0 +1,25 @@
+"""Custom exceptions for mvn-tree-visualizer."""
+
+
+class MvnTreeVisualizerError(Exception):
+    """Base exception for mvn-tree-visualizer errors."""
+
+    pass
+
+
+class DependencyFileNotFoundError(MvnTreeVisualizerError):
+    """Raised when no dependency files are found."""
+
+    pass
+
+
+class DependencyParsingError(MvnTreeVisualizerError):
+    """Raised when there's an error parsing dependency files."""
+
+    pass
+
+
+class OutputGenerationError(MvnTreeVisualizerError):
+    """Raised when there's an error generating output files."""
+
+    pass

mvn_tree_visualizer/file_watcher.py

@@ -0,0 +1,71 @@
+"""File watcher functionality for monitoring Maven dependency files."""
+
+import time
+from typing import Callable
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+
+class DependencyFileHandler(FileSystemEventHandler):
+    """Handler for file system events to trigger diagram regeneration."""
+
+    def __init__(
+        self,
+        filename: str,
+        callback: Callable[[], None],
+    ):
+        """Initialize the file handler.
+
+        Args:
+            filename: Name of the file to monitor for changes
+            callback: Function to call when file changes are detected
+        """
+        self.filename = filename
+        self.callback = callback
+
+    def on_modified(self, event):
+        """Handle file modification events."""
+        if not event.is_directory and event.src_path.endswith(self.filename):
+            print(f"Detected change in {event.src_path}")
+            self.callback()
+
+
+class FileWatcher:
+    """File system watcher for monitoring Maven dependency files."""
+
+    def __init__(self, directory: str, filename: str, callback: Callable[[], None]):
+        """Initialize the file watcher.
+
+        Args:
+            directory: Directory to watch for file changes
+            filename: Name of the file to monitor
+            callback: Function to call when file changes are detected
+        """
+        self.directory = directory
+        self.filename = filename
+        self.callback = callback
+        self.observer = Observer()
+        self.event_handler = DependencyFileHandler(filename, callback)
+
+    def start(self) -> None:
+        """Start watching for file changes."""
+        print(f"Watching for changes in '{self.filename}' files in '{self.directory}'...")
+        print("Press Ctrl+C to stop watching.")
+
+        self.observer.schedule(self.event_handler, self.directory, recursive=True)
+        self.observer.start()
+
+    def stop(self) -> None:
+        """Stop watching for file changes."""
+        print("\nStopping file watcher...")
+        self.observer.stop()
+        self.observer.join()
+
+    def wait(self) -> None:
+        """Wait for file changes (blocking)."""
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            self.stop()

mvn_tree_visualizer/get_dependencies_in_one_file.py

@@ -1,11 +1,40 @@
 import os
+from pathlib import Path
+from typing import Union
 
 
-def merge_files(output_file: str, root_dir: str = ".", target_filename: str = "maven_dependency_file"):
-    with open(output_file, "w", encoding="utf-8") as outfile:
-        for dirpath, _, filenames in os.walk(root_dir):
-            for fname in filenames:
-                if fname == target_filename:
-                    file_path = os.path.join(dirpath, fname)
-                    with open(file_path, "r", encoding="utf-8") as infile:
-                        outfile.write(infile.read())
+def merge_files(output_file: Union[str, Path], root_dir: str = ".", target_filename: str = "maven_dependency_file") -> None:
+    """Merge all dependency files from the directory tree into a single file."""
+    files_found = 0
+
+    try:
+        with open(output_file, "w", encoding="utf-8") as outfile:
+            for dirpath, _, filenames in os.walk(root_dir):
+                for fname in filenames:
+                    if fname == target_filename:
+                        file_path: str = os.path.join(dirpath, fname)
+                        try:
+                            with open(file_path, "r", encoding="utf-8") as infile:
+                                content = infile.read()
+                                if content.strip():  # Only write non-empty content
+                                    outfile.write(content)
+                                    if not content.endswith("\n"):
+                                        outfile.write("\n")
+                                    files_found += 1
+                        except UnicodeDecodeError as e:
+                            raise UnicodeDecodeError(
+                                e.encoding,
+                                e.object,
+                                e.start,
+                                e.end,
+                                f"Error reading '{file_path}': {e.reason}. Please ensure the file is in UTF-8 format.",
+                            )
+                        except PermissionError:
+                            raise PermissionError(f"Permission denied reading '{file_path}'")
+    except PermissionError:
+        raise PermissionError(f"Permission denied writing to '{output_file}'")
+    except OSError as e:
+        raise OSError(f"Error writing to '{output_file}': {e}")
+
+    if files_found == 0:
+        raise FileNotFoundError(f"No '{target_filename}' files found in '{root_dir}' or its subdirectories")

mvn_tree_visualizer/outputs/html_output.py

@@ -1,49 +1,65 @@
 from pathlib import Path
+from typing import List, Set, Tuple
+
 from jinja2 import BaseLoader, Environment
+
 from ..TEMPLATE import HTML_TEMPLATE
 
-def create_html_diagram(dependency_tree: str, output_filename: str):
-    mermaid_diagram = _convert_to_mermaid(dependency_tree)
+
+def create_html_diagram(dependency_tree: str, output_filename: str, show_versions: bool = False) -> None:
+    mermaid_diagram: str = _convert_to_mermaid(dependency_tree, show_versions)
     template = Environment(loader=BaseLoader).from_string(HTML_TEMPLATE)
-    rendered = template.render(diagram_definition=mermaid_diagram)
-    parent_dir = Path(output_filename).parent
+    rendered: str = template.render(diagram_definition=mermaid_diagram)
+    parent_dir: Path = Path(output_filename).parent
     if not parent_dir.exists():
         parent_dir.mkdir(parents=True, exist_ok=True)
     with open(output_filename, "w") as f:
         f.write(rendered)
 
-def _convert_to_mermaid(dependency_tree: str) -> str:
+
+def _convert_to_mermaid(dependency_tree: str, show_versions: bool = False) -> str:
     # generate a `graph LR` format for Mermaid
-    lines = dependency_tree.strip().split("\n")
-    mermaid_lines = set()
-    previous_dependency = []
+    lines: List[str] = dependency_tree.strip().split("\n")
+    mermaid_lines: Set[str] = set()
+    previous_dependency: List[Tuple[str, int]] = []
     for line in lines:
         if not line:
             continue
         if line.startswith("[INFO] "):
             line = line[7:]  # Remove the "[INFO] " prefix
-        parts = line.split(":")
+        parts: List[str] = line.split(":")
         if len(parts) < 3:
             continue
         if len(parts) == 4:
             group_id, artifact_id, app, version = parts
-            mermaid_lines.add(f"\t{artifact_id};")
+            if show_versions:
+                node_label: str = f"{artifact_id}:{version}"
+                mermaid_lines.add(f"\t{node_label};")
+            else:
+                node_label: str = artifact_id
+                mermaid_lines.add(f"\t{artifact_id};")
             if previous_dependency:  # Re initialize the list if it wasn't empty
                 previous_dependency = []
-            previous_dependency.append((artifact_id, 0))  # The second element is the depth
+            previous_dependency.append((node_label, 0))  # The second element is the depth
         else:
-            depth = len(parts[0].split(" ")) - 1
+            depth: int = len(parts[0].split(" ")) - 1
             if len(parts) == 6:
                 dirty_group_id, artifact_id, app, ejb_client, version, dependency = parts
             else:
                 dirty_group_id, artifact_id, app, version, dependency = parts
+
+            if show_versions:
+                node_label: str = f"{artifact_id}:{version}"
+            else:
+                node_label: str = artifact_id
+
             if previous_dependency[-1][1] < depth:
-                mermaid_lines.add(f"\t{previous_dependency[-1][0]} --> {artifact_id};")
-                previous_dependency.append((artifact_id, depth))
+                mermaid_lines.add(f"\t{previous_dependency[-1][0]} --> {node_label};")
+                previous_dependency.append((node_label, depth))
             else:
                 # remove all dependencies that are deeper or equal to the current depth
                 while previous_dependency and previous_dependency[-1][1] >= depth:
                     previous_dependency.pop()
-                mermaid_lines.add(f"\t{previous_dependency[-1][0]} --> {artifact_id};")
-                previous_dependency.append((artifact_id, depth))
+                mermaid_lines.add(f"\t{previous_dependency[-1][0]} --> {node_label};")
+                previous_dependency.append((node_label, depth))
     return "graph LR\n" + "\n".join(mermaid_lines)

mvn_tree_visualizer/outputs/json_output.py

@@ -1,9 +1,11 @@
 import json
+from typing import Any, Dict, List, Tuple
 
-def create_json_output(dependency_tree: str, output_filename: str):
-    lines = dependency_tree.strip().split("\n")
-    tree = {}
-    node_stack = []  # Stack to keep track of nodes and their depth
+
+def create_json_output(dependency_tree: str, output_filename: str, show_versions: bool = False) -> None:
+    lines: List[str] = dependency_tree.strip().split("\n")
+    tree: Dict[str, Any] = {}
+    node_stack: List[Tuple[Dict[str, Any], int]] = []  # Stack to keep track of nodes and their depth
 
     for line in lines:
         if not line:
@@ -11,33 +13,43 @@ def create_json_output(dependency_tree: str, output_filename: str):
         if line.startswith("[INFO] "):
             line = line[7:]  # Remove the "[INFO] " prefix
 
-        parts = line.split(":")
+        parts: List[str] = line.split(":")
         if len(parts) < 3:
             continue
 
         # Root node
         if len(parts) == 4:
             group_id, artifact_id, _, version = parts
-            node = {"id": f"{group_id}:{artifact_id}:{version}", "children": []}
+            if show_versions:
+                node_id: str = f"{artifact_id}:{version}"
+            else:
+                node_id: str = artifact_id
+            node: Dict[str, Any] = {"id": node_id, "children": []}
             tree = node
             node_stack = [(node, 0)]  # Reset stack with root node at depth 0
         # Child node
         else:
             # This depth calculation is based on the mermaid logic's whitespace parsing
-            depth = len(parts[0].split(" ")) - 1
+            depth: int = len(parts[0].split(" ")) - 1
 
             if len(parts) == 6:
                 _, artifact_id, _, _, version, _ = parts
             else:
                 _, artifact_id, _, version, _ = parts
 
-            node = {"id": f"{artifact_id}:{version}", "children": []}
+            if show_versions:
+                node_id: str = f"{artifact_id}:{version}"
+            else:
+                node_id: str = artifact_id
+
+            node: Dict[str, Any] = {"id": node_id, "children": []}
 
             # Go up the stack to find the correct parent
             while node_stack and node_stack[-1][1] >= depth:
                 node_stack.pop()
 
             if node_stack:
+                parent_node: Dict[str, Any]
                 parent_node, _ = node_stack[-1]
                 parent_node["children"].append(node)
 

mvn_tree_visualizer/validation.py

@@ -0,0 +1,86 @@
+"""Validation utilities for mvn-tree-visualizer."""
+
+import os
+from pathlib import Path
+
+from .exceptions import DependencyFileNotFoundError, OutputGenerationError
+
+
+def find_dependency_files(directory: str, filename: str) -> list[str]:
+    """Find all dependency files in the directory tree."""
+    found_files = []
+    for dirpath, _, filenames in os.walk(directory):
+        if filename in filenames:
+            found_files.append(os.path.join(dirpath, filename))
+    return found_files
+
+
+def print_maven_help() -> None:
+    """Print helpful Maven commands for generating dependency files."""
+    print("\n💡 To generate a Maven dependency file, try one of these commands:")
+    print("   mvn dependency:tree -DoutputFile=maven_dependency_file")
+    print("   mvn dependency:tree > maven_dependency_file")
+    print("   mvn dependency:tree -DoutputFile=maven_dependency_file -DoutputType=text")
+    print("\n📍 Make sure you're in a directory with a pom.xml file.")
+
+
+def validate_directory(directory: str) -> None:
+    """Validate that the directory exists and is accessible."""
+    if not os.path.exists(directory):
+        raise DependencyFileNotFoundError(f"Directory '{directory}' does not exist.\nPlease check the path and try again.")
+
+    if not os.path.isdir(directory):
+        raise DependencyFileNotFoundError(f"'{directory}' is not a directory.\nPlease provide a valid directory path.")
+
+    if not os.access(directory, os.R_OK):
+        raise DependencyFileNotFoundError(f"Cannot read from directory '{directory}'.\nPlease check your permissions and try again.")
+
+
+def validate_dependency_files(directory: str, filename: str) -> list[str]:
+    """Validate that dependency files exist and are readable."""
+    validate_directory(directory)
+
+    dependency_files = find_dependency_files(directory, filename)
+
+    if not dependency_files:
+        abs_directory = os.path.abspath(directory)
+        raise DependencyFileNotFoundError(
+            f"No '{filename}' files found in '{abs_directory}' or its subdirectories.\n\n"
+            f"📂 Searched in: {abs_directory}\n"
+            f"🔍 Looking for: {filename}\n"
+            f"\n💡 To generate a Maven dependency file, run:"
+            f"\n   mvn dependency:tree -DoutputFile={filename}"
+            f"\n\n📍 Make sure you're in a directory with a pom.xml file."
+        )
+
+    # Validate that files are readable
+    unreadable_files = []
+    for file_path in dependency_files:
+        if not os.access(file_path, os.R_OK):
+            unreadable_files.append(file_path)
+
+    if unreadable_files:
+        files_list = "\n".join(f"  - {f}" for f in unreadable_files)
+        raise DependencyFileNotFoundError(
+            f"Found {len(dependency_files)} dependency file(s), but cannot read {len(unreadable_files)} of them:\n"
+            f"{files_list}\n\n"
+            f"Please check file permissions and try again."
+        )
+
+    return dependency_files
+
+
+def validate_output_directory(output_file: str) -> None:
+    """Validate that the output directory exists and is writable."""
+    output_dir = Path(output_file).parent
+
+    if not output_dir.exists():
+        try:
+            output_dir.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            raise OutputGenerationError(f"Cannot create output directory '{output_dir}'.\nPlease check your permissions and try again.")
+        except Exception as e:
+            raise OutputGenerationError(f"Failed to create output directory '{output_dir}': {e}")
+
+    if not os.access(output_dir, os.W_OK):
+        raise OutputGenerationError(f"Cannot write to output directory '{output_dir}'.\nPlease check your permissions and try again.")

mvn_tree_visualizer-1.3.0.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: mvn-tree-visualizer
+Version: 1.3.0
+Summary: A simple command line tool to visualize the dependency tree of a Maven project in a graphical format.
+Project-URL: source, https://github.com/dyka3773/mvn-tree-visualizer
+Author-email: Iraklis Konsoulas <dyka3773@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,command-line,dependency,graph,maven,mermaid,tool,tree,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: watchdog>=6.0.0
+Description-Content-Type: text/markdown
+
+# Maven Dependency Tree Visualizer
+
+[![PyPI version](https://badge.fury.io/py/mvn-tree-visualizer.svg)](https://badge.fury.io/py/mvn-tree-visualizer)
+![Python](https://img.shields.io/badge/python-3.13+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+[![Downloads](https://pepy.tech/badge/mvn-tree-visualizer)](https://pepy.tech/project/mvn-tree-visualizer)
+[![CI](https://github.com/dyka3773/mvn-tree-visualizer/workflows/CI/badge.svg)](https://github.com/dyka3773/mvn-tree-visualizer/actions)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
+
+A simple command-line tool to visualize the dependency tree of a Maven project in a graphical and interactive format.
+
+This tool was born out of the frustration of not being able to easily visualize the dependency tree of a Maven project. The `mvn dependency:tree` command is great, but the output can be hard to read, especially for large projects. This tool aims to solve that problem by providing a simple way to generate an interactive diagram or a structured JSON output of the dependency tree.
+
+## Table of Contents
+- [Features](#features)
+- [Installation](#installation)
+- [How to Use](#how-to-use)
+- [Examples](#examples)
+- [Options](#options)
+- [Performance](#performance)
+- [Troubleshooting](#troubleshooting)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+
+Install the package from PyPI:
+
+```bash
+pip install mvn-tree-visualizer
+```
+
+## Features
+
+- **🌐 Multiple Output Formats:**
+  - **HTML:** Generates an interactive HTML diagram of your dependency tree using Mermaid.js.
+  - **JSON:** Creates a structured JSON representation of the dependency tree, perfect for scripting or integration with other tools.
+- **🔄 Watch Mode:** Automatically regenerates diagrams when Maven dependency files change using the `--watch` flag.
+- **📋 Version Display:** Show or hide dependency versions in both HTML and JSON outputs using the `--show-versions` flag.
+- **⚡ Easy to Use:** A simple command-line interface that gets the job done with minimal configuration.
+- **📂 File Merging:** Automatically finds and merges multiple `maven_dependency_file` files from different subdirectories.
+- **🎨 Customizable Output:** Specify the output file name and location.
+- **💾 SVG Export:** Download the generated diagram as an SVG file directly from the HTML page.
+
+## How to Use
+
+### Step 1: Generate the dependency file
+
+Run the following command in your terminal at the root of your Maven project. This will generate a file named `maven_dependency_file` in each module's `target` directory.
+
+```bash
+mvn dependency:tree -DoutputFile=maven_dependency_file -DappendOutput=true
+```
+
+> **💡 Tip:** You can add other options like `-Dincludes="org.example"` to filter the dependencies.
+
+### Step 2: Visualize the dependency tree
+
+Use the `mvn-tree-visualizer` command to generate the diagram.
+
+#### HTML Output (Interactive Diagram)
+```bash
+mvn_tree_visualizer --filename "maven_dependency_file" --output "diagram.html" --format html
+```
+
+#### JSON Output (Structured Data)
+```bash
+mvn_tree_visualizer --filename "maven_dependency_file" --output "dependencies.json" --format json
+```
+
+#### With Version Information
+```bash
+mvn_tree_visualizer --filename "maven_dependency_file" --output "diagram.html" --show-versions
+```
+
+#### JSON Output with Versions
+```bash
+mvn_tree_visualizer --filename "maven_dependency_file" --output "dependencies.json" --format json --show-versions
+```
+
+#### Watch Mode (Auto-regeneration)
+```bash
+mvn_tree_visualizer --filename "maven_dependency_file" --output "diagram.html" --watch
+```
+
+> **💡 Tip:** In watch mode, the tool will monitor for changes to your Maven dependency files and automatically regenerate the diagram. Perfect for development workflows! Press `Ctrl+C` to stop watching.
+
+### Step 3: View the output
+
+- **HTML:** Open the generated `diagram.html` file in your web browser to view the interactive dependency tree.
+- **JSON:** Use the `dependencies.json` file in your scripts or other tools.
+
+## Examples
+
+Check out the [`examples/`](examples/) directory for sample Maven dependency files and their outputs:
+
+- **Simple Project**: Basic Spring Boot application with common dependencies
+- **Complex Project**: Realistic microservice with comprehensive dependencies
+
+Each example includes:
+- Sample Maven dependency tree file
+- Generated HTML and JSON outputs
+- Usage instructions
+
+## Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--filename` | The name of the file containing the Maven dependency tree | `maven_dependency_file` |
+| `--output` | The name of the output file | `diagram.html` |
+| `--format` | The output format (`html` or `json`) | `html` |
+| `--show-versions` | Show dependency versions in the diagram | `False` |
+| `--watch` | Watch for file changes and auto-regenerate diagram | `False` |
+| `--directory` | The directory to scan for the Maven dependency file(s) | current directory |
+| `--keep-tree` | Keep the intermediate `dependency_tree.txt` file | `False` |
+| `--help` | Show the help message and exit | - |
+
+## Performance
+
+**For Large Projects:**
+- Consider filtering dependencies at the Maven level using `-Dincludes` or `-Dexcludes` parameters
+- The tool can handle projects with hundreds of dependencies efficiently
+
+**Memory Usage:**
+- Memory usage scales with the number of dependencies
+- Typical projects (50-200 dependencies) use minimal memory
+- Very large projects (1000+ dependencies) may require more memory
+
+## Troubleshooting
+
+### Common Issues
+
+**"No dependency files found"**
+- The tool now provides detailed guidance including:
+  - Exact directory searched and filename expected
+  - Maven commands to generate dependency files
+  - Instructions to ensure you're in a directory with pom.xml
+
+**"Empty or invalid output"**
+- Enhanced error messages now include:
+  - Specific error details (encoding, permissions, empty files)
+  - Validation of file content and format
+  - Suggestions for fixing common parsing issues
+
+**"Browser doesn't display the diagram"**
+- Ensure you're opening the HTML file in a modern browser
+- Check browser console for JavaScript errors
+- Try a different browser (Chrome, Firefox, Safari)
+
+**"Permission denied errors"**
+- Improved diagnostics for:
+  - Directory read/write permissions
+  - File access issues
+  - Output directory creation problems
+
+### Getting Help
+
+- Check the [examples](examples/) directory for working samples
+- Review the [issues](https://github.com/dyka3773/mvn-tree-visualizer/issues) page
+- Create a new issue with your Maven dependency file sample
+
+## Contributing
+
+Contributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request.
+
+Please read our [CONTRIBUTING.md](CONTRIBUTING.md) file for more details.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

mvn_tree_visualizer-1.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+mvn_tree_visualizer/TEMPLATE.py,sha256=WIQfSNBygUZVkBrERq7QzqouGURA0NYVqUUm-11wMvo,2499
+mvn_tree_visualizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mvn_tree_visualizer/__main__.py,sha256=yIQFAdWjthKAFbSzzRuz5_YGlK0c6BnR2ypjNRDq180,82
+mvn_tree_visualizer/cli.py,sha256=33K5ujgB85xejcSUKMNAwirpLfnGMGfrnhqyLFOy69k,8219
+mvn_tree_visualizer/diagram.py,sha256=UfvP_J4Im4JQLe3EWlY3TsP4tua3oYk5NiCGbZNQwoA,933
+mvn_tree_visualizer/exceptions.py,sha256=R4nnJ0xrOpd84GfPD9rFSDk40etDLoph7iZpj1CCR0c,543
+mvn_tree_visualizer/file_watcher.py,sha256=JtmV1KW08_Az-XqpKhcd342WpxV1vUW-Dge9lodjjJY,2284
+mvn_tree_visualizer/get_dependencies_in_one_file.py,sha256=nXhEhU-dI7tXa3TpoW1pv2t86t1K0yppSw8FYDtmTlQ,1973
+mvn_tree_visualizer/validation.py,sha256=UQ194gHiVS8UnJpp90sCM-Vjn3aeXT6scdwOplAoaSE,3689
+mvn_tree_visualizer/outputs/html_output.py,sha256=QwUZRzNUCKrpdOq6BHadIJSU47W_1Kat-ouzwue-olA,2857
+mvn_tree_visualizer/outputs/json_output.py,sha256=cXntw9ndE_BcrmFnuV61cEwZaRMp9Ev0SxaK1SUedlw,2037
+mvn_tree_visualizer-1.3.0.dist-info/METADATA,sha256=YHhhNT8CjZUB_rSbdOip-7anjiGD7NxmoYPdl4bZw50,7834
+mvn_tree_visualizer-1.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mvn_tree_visualizer-1.3.0.dist-info/entry_points.txt,sha256=Mu3QZhrlvbYuCxqmluVGi2efgKjkQY6T8Opf-vdb7hU,68
+mvn_tree_visualizer-1.3.0.dist-info/licenses/LICENSE,sha256=4zi6unpe17RUDMBu7ebh14jdbyvyeT-UA3n8Zl7aW74,1075
+mvn_tree_visualizer-1.3.0.dist-info/RECORD,,

mvn_tree_visualizer-1.1.0.dist-info/METADATA

@@ -1,71 +0,0 @@
-Metadata-Version: 2.4
-Name: mvn-tree-visualizer
-Version: 1.1.0
-Summary: A simple command line tool to visualize the dependency tree of a Maven project in a graphical format.
-Project-URL: source, https://github.com/dyka3773/mvn-tree-visualizer
-Author-email: Iraklis Konsoulas <dyka3773@gmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Keywords: cli,command-line,dependency,graph,maven,mermaid,tool,tree,visualization
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Build Tools
-Requires-Python: >=3.13
-Requires-Dist: jinja2>=3.1.6
-Description-Content-Type: text/markdown
-
-# Maven Dependency Tree Visualizer
-
-[![PyPI version](https://badge.fury.io/py/mvn-tree-visualizer.svg)](https://badge.fury.io/py/mvn-tree-visualizer)
-
-A simple command-line tool to visualize the dependency tree of a Maven project in a graphical and interactive format.
-
-This tool was born out of the frustration of not being able to easily visualize the dependency tree of a Maven project. The `mvn dependency:tree` command is great, but the output can be hard to read, especially for large projects. This tool aims to solve that problem by providing a simple way to generate an interactive diagram of the dependency tree.
-
-## Features
-
-*   **Interactive Diagrams:** Generates an interactive HTML diagram of your dependency tree using Mermaid.js.
-*   **Easy to Use:** A simple command-line interface that gets the job done with minimal configuration.
-*   **File Merging:** Automatically finds and merges multiple `maven_dependency_file` files from different subdirectories.
-*   **Customizable Output:** Specify the output file name and location.
-*   **SVG Export:** Download the generated diagram as an SVG file directly from the HTML page.
-
-## How to Use
-
-1.  **Generate the dependency file:**
-    Run the following command in your terminal at the root of your Maven project. This will generate a file named `maven_dependency_file` in each module's `target` directory.
-
-    ```bash
-    mvn dependency:tree -DoutputFile=maven_dependency_file -DappendOutput=true
-    ```
-    > You can add other options like `-Dincludes="org.example"` to filter the dependencies.
-
-2.  **Visualize the dependency tree:**
-    Use the `mvn-tree-visualizer` command to generate the diagram.
-
-    ```bash
-    mvn_tree_visualizer --filename "maven_dependency_file" --output "diagram.html"
-    ```
-
-3.  **View the diagram:**
-    Open the generated `diagram.html` file in your web browser to view the interactive dependency tree.
-
-## Options
-
-*   `--filename`: The name of the file containing the Maven dependency tree. Defaults to `maven_dependency_file`.
-*   `--output`: The name of the output HTML file. Defaults to `diagram.html`.
-*   `--directory`: The directory to scan for the Maven dependency file(s). Defaults to the current directory.
-*   `--keep-tree`: Keep the intermediate `dependency_tree.txt` file after generating the diagram. Defaults to `False`.
-*   `--help`: Show the help message and exit.
-
-## Contributing
-
-Contributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request.
-
-Please read our [CONTRIBUTING.md](CONTRIBUTING.md) file for more details.
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

mvn_tree_visualizer-1.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-mvn_tree_visualizer/TEMPLATE.py,sha256=WIQfSNBygUZVkBrERq7QzqouGURA0NYVqUUm-11wMvo,2499
-mvn_tree_visualizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mvn_tree_visualizer/__main__.py,sha256=yIQFAdWjthKAFbSzzRuz5_YGlK0c6BnR2ypjNRDq180,82
-mvn_tree_visualizer/cli.py,sha256=P3v27Axod-aYkhtnoAh06RnScUTR2k9QZ3vVGkolHg8,2451
-mvn_tree_visualizer/diagram.py,sha256=elUQHCFu9DPeCpcLkjlRg-xl-fAEn8TvMWpIho1vo0E,312
-mvn_tree_visualizer/get_dependencies_in_one_file.py,sha256=sX669Lo3gsv-dTvaf4PNSQMTp3Gx3CKwqBmJQFiQF04,504
-mvn_tree_visualizer/outputs/html_output.py,sha256=rCD55g8aUdYiPs2Mkd9VB0dBKvMZu0Va3uYGZkJxO20,2295
-mvn_tree_visualizer/outputs/json_output.py,sha256=v9aRPaCDMG-zyVdg82YPhPRyFCNLaWXPcdRmnpzuajg,1554
-mvn_tree_visualizer-1.1.0.dist-info/METADATA,sha256=VmIy1sZ1XHWlqnXJwzFKuG1Z3yxqZ2YV7OlEPaNvIuM,3470
-mvn_tree_visualizer-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mvn_tree_visualizer-1.1.0.dist-info/entry_points.txt,sha256=Mu3QZhrlvbYuCxqmluVGi2efgKjkQY6T8Opf-vdb7hU,68
-mvn_tree_visualizer-1.1.0.dist-info/licenses/LICENSE,sha256=4zi6unpe17RUDMBu7ebh14jdbyvyeT-UA3n8Zl7aW74,1075
-mvn_tree_visualizer-1.1.0.dist-info/RECORD,,