rulevis 1.0.3__tar.gz

rulevis-1.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zafer Balkan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rulevis-1.0.3/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: rulevis
+Version: 1.0.3
+Summary: Interactive Wazuh Rule Graph Explorer
+Author-email: Zafer Balkan <zafer@zaferbalkan.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/zbalkan/rulevis
+Project-URL: Repository, https://github.com/zbalkan/rulevis
+Project-URL: Issues, https://github.com/zbalkan/rulevis/issues
+Keywords: wazuh,detection,security,monitoring,logging,siem
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Logging
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Flask>=3.1.2
+Requires-Dist: networkx>=3.5
+Dynamic: license-file
+
+# RuleVis: Interactive Wazuh Rule Graph Explorer
+
+RuleVis is a powerful analysis tool that transforms your Wazuh ruleset into a dynamic, interactive force-directed graph. It helps you visualize the complex relationships between rules, identify critical dependencies, discover structural issues, and analyze the distribution of your rule IDs.
+
+This tool is designed for security engineers, SOC analysts, and Wazuh administrators who need to understand, maintain, and develop complex custom rulesets.
+
+![General View of RuleVis](https://github.com/zbalkan/rulevis/raw/master/assets/general-view.gif)
+
+## Features
+
+* **Interactive Graph Visualization:** Renders your entire ruleset as a graph using D3.js and HTML Canvas for high performance.
+* **Dependency Analysis:** Clearly shows parent-child relationships (`if_sid`, `if_group`, etc.) with directed edges.
+* **Node Expansion:** Interactively expand nodes to reveal their parent or child dependencies on demand.
+* **Detailed Rule Information:** Click on any rule to see its full description, groups, and a complete list of its parents and children.
+* **Powerful Search:** Instantly find and focus on any rule by its ID.
+* **Graph Statistics Panel:** Get at-a-glance insights into your ruleset with statistics like:
+  * Top 5 rules with the most direct children (foundational rules).
+  * Top 5 rules with the highest impact (most total descendants).
+  * Top 5 rules with the most complex dependencies.
+  * A list of isolated rules.
+  * Cycles in the rules
+* **Rule ID Heatmap:** Visualize the entire rule ID space from 0 to 100,000+ to see which ID ranges are heavily used and which are available for custom rules.
+* **Keyboard Shortcuts:** Pause the simulation (`Space`), close panels (`Esc`), and more for an efficient workflow.
+* **Focus:** By default, when a node is highlighted, any node except for the selected node and its neighbords are dimmed. That allows better focus minimizing visual complexity.
+
+## The Problem It Solves
+
+Wazuh's rule engine builds a complex, tree-like structure in memory. While powerful, this structure is invisible to the user. It can be difficult to:
+
+* Understand the full impact of changing a single rule.
+* Find redundant rules or overly complex dependency chains.
+* Identify structural issues like circular dependencies, which can impact performance.
+* Know which ID ranges are safe to use for new custom rules.
+
+RuleVis makes these invisible structures visible, turning abstract XML files into a tangible, explorable map.
+
+## Installation
+
+### Using pipx (recommended)
+
+`pipx install rulevis`
+
+### Using pip (for testing)
+
+`pip install rulevis`
+
+### Using source
+
+1. **Clone the repository:**
+
+    ```shell
+    git clone https://github.com/zbalkan/rulevis.git
+    cd rulevis
+    ```
+
+2. **Create and activate a Python virtual environment:**
+
+    ```shell
+    python -m venv .venv
+    source .venv/bin/activate
+    ```
+
+    Or for Windows
+
+    ```shell
+    python -m venv .venv
+    source .venv\Scripts\activate.ps1
+    ```
+
+3. **Install dependencies:**
+
+    ```shell
+    pip install -r requirements.txt
+    ```
+
+## Usage
+
+The tool is run from the command line. You must provide the path to the directory (or directories) containing your Wazuh rule XML files.
+
+```shell
+python src/rulevis.py --path /var/ossec/ruleset/rules,/var/ossec/etc/rules
+```
+
+**Arguments:**
+
+* `--path, -p`: **(Required)** A comma-separated list of paths to your Wazuh rule directories. This should include both the default rules and your custom rules.
+* `-h, --help`: Show the help message.
+
+Once executed, the script will:
+
+1. Parse all `.xml` files in the specified paths.
+2. Build a graph model of the rule relationships.
+3. Pre-calculate statistics and heatmap data.
+4. Start a local web server.
+5. Automatically open the tool in your default web browser.
+
+## Key Features in Action
+
+### Graph Statistics
+
+Quickly identify the most important and complex rules in your entire ruleset. Click on any rule in the list to instantly navigate to it in the main graph.
+
+![Statistics Panel](https://github.com/zbalkan/rulevis/raw/master/assets/stats-panel.gif)
+
+### Rule ID Heatmap
+
+Get a bird's-eye view of your rule ID landscape. Dark gray blocks are unused and available for your custom rules, while brighter red blocks indicate heavily populated ranges. This is invaluable for planning and organizing a large custom ruleset.
+
+![Heatmap View](https://github.com/zbalkan/rulevis/raw/master/assets/heatmap-view.gif)
+
+## Technical Overview
+
+The project is composed of three main Python modules and a JavaScript frontend:
+
+1. **`generator.py`:** Parses the Wazuh XML rule files and uses the `networkx` library to build a `MultiDiGraph` object representing the rule relationships. It saves this graph to a temporary file.
+2. **`analyzer.py`:** Loads the graph file and uses `networkx` to perform complex calculations (descendants, ancestors, etc.). It pre-calculates the data needed for the Statistics Panel and the Rule ID Heatmap and saves them to temporary JSON files.
+3. **`visualizer.py`:** A Flask web application that serves the frontend and provides a clean API for the visualization to fetch graph, stats, and heatmap data.
+4. **`graph.js`:** The core frontend logic. It uses **D3.js** for the force simulation and user interactions, and renders the main graph to an **HTML Canvas** for high performance. The interactive heatmap is rendered using **SVG** for its superior event handling and styling capabilities.
+
+Here’s a **ready-to-paste README subsection** that explains `rulevis` logging clearly and professionally for your users. It assumes the per-user setup you’ve implemented.
+
+---
+
+## Logging
+
+`rulevis` automatically writes diagnostic and operational logs to a user-specific location. Logs are plain text encoded in UTF-8 and include timestamps, module names, and severity levels. The application creates its log directory if it does not exist.
+
+| Platform        | Log file location                                                                           | Example path                                             |
+| --------------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| Windows     | `%LocalAppData%\rulevis\Logs\rulevis.log`                                                   | `C:\Users\<user>\AppData\Local\rulevis\Logs\rulevis.log` |
+| macOS       | `~/Library/Logs/rulevis/rulevis.log`                                                        | `/Users/<user>/Library/Logs/rulevis/rulevis.log`         |
+| Linux / BSD | `$XDG_STATE_HOME/rulevis/rulevis.log` or fallback `~/.local/share/rulevis/logs/rulevis.log` | `/home/<user>/.local/state/rulevis/rulevis.log`          |
+
+`rulevis` follows the [XDG Base Directory specification](https://specifications.freedesktop.org/basedir-spec/latest/) on Unix-like systems and Windows conventions under `%LocalAppData%`.
+
+The log file records informational messages, warnings, and errors emitted during execution. You can safely delete it; a new one will be created automatically on the next run.
+
+## Notes
+
+While the documentation defines <if_level> as another condition creating a parent-child relationship, it has not been used in any built-in rules. And as a personal choicem I decided to omit that deliberately.
+
+There is another `if`, called `<if_fts>`, that is used for *first time seen* events, not creating a parent-child relationship. Theefore it is not mentioned.

rulevis-1.0.3/README.md

@@ -0,0 +1,142 @@
+# RuleVis: Interactive Wazuh Rule Graph Explorer
+
+RuleVis is a powerful analysis tool that transforms your Wazuh ruleset into a dynamic, interactive force-directed graph. It helps you visualize the complex relationships between rules, identify critical dependencies, discover structural issues, and analyze the distribution of your rule IDs.
+
+This tool is designed for security engineers, SOC analysts, and Wazuh administrators who need to understand, maintain, and develop complex custom rulesets.
+
+![General View of RuleVis](https://github.com/zbalkan/rulevis/raw/master/assets/general-view.gif)
+
+## Features
+
+* **Interactive Graph Visualization:** Renders your entire ruleset as a graph using D3.js and HTML Canvas for high performance.
+* **Dependency Analysis:** Clearly shows parent-child relationships (`if_sid`, `if_group`, etc.) with directed edges.
+* **Node Expansion:** Interactively expand nodes to reveal their parent or child dependencies on demand.
+* **Detailed Rule Information:** Click on any rule to see its full description, groups, and a complete list of its parents and children.
+* **Powerful Search:** Instantly find and focus on any rule by its ID.
+* **Graph Statistics Panel:** Get at-a-glance insights into your ruleset with statistics like:
+  * Top 5 rules with the most direct children (foundational rules).
+  * Top 5 rules with the highest impact (most total descendants).
+  * Top 5 rules with the most complex dependencies.
+  * A list of isolated rules.
+  * Cycles in the rules
+* **Rule ID Heatmap:** Visualize the entire rule ID space from 0 to 100,000+ to see which ID ranges are heavily used and which are available for custom rules.
+* **Keyboard Shortcuts:** Pause the simulation (`Space`), close panels (`Esc`), and more for an efficient workflow.
+* **Focus:** By default, when a node is highlighted, any node except for the selected node and its neighbords are dimmed. That allows better focus minimizing visual complexity.
+
+## The Problem It Solves
+
+Wazuh's rule engine builds a complex, tree-like structure in memory. While powerful, this structure is invisible to the user. It can be difficult to:
+
+* Understand the full impact of changing a single rule.
+* Find redundant rules or overly complex dependency chains.
+* Identify structural issues like circular dependencies, which can impact performance.
+* Know which ID ranges are safe to use for new custom rules.
+
+RuleVis makes these invisible structures visible, turning abstract XML files into a tangible, explorable map.
+
+## Installation
+
+### Using pipx (recommended)
+
+`pipx install rulevis`
+
+### Using pip (for testing)
+
+`pip install rulevis`
+
+### Using source
+
+1. **Clone the repository:**
+
+    ```shell
+    git clone https://github.com/zbalkan/rulevis.git
+    cd rulevis
+    ```
+
+2. **Create and activate a Python virtual environment:**
+
+    ```shell
+    python -m venv .venv
+    source .venv/bin/activate
+    ```
+
+    Or for Windows
+
+    ```shell
+    python -m venv .venv
+    source .venv\Scripts\activate.ps1
+    ```
+
+3. **Install dependencies:**
+
+    ```shell
+    pip install -r requirements.txt
+    ```
+
+## Usage
+
+The tool is run from the command line. You must provide the path to the directory (or directories) containing your Wazuh rule XML files.
+
+```shell
+python src/rulevis.py --path /var/ossec/ruleset/rules,/var/ossec/etc/rules
+```
+
+**Arguments:**
+
+* `--path, -p`: **(Required)** A comma-separated list of paths to your Wazuh rule directories. This should include both the default rules and your custom rules.
+* `-h, --help`: Show the help message.
+
+Once executed, the script will:
+
+1. Parse all `.xml` files in the specified paths.
+2. Build a graph model of the rule relationships.
+3. Pre-calculate statistics and heatmap data.
+4. Start a local web server.
+5. Automatically open the tool in your default web browser.
+
+## Key Features in Action
+
+### Graph Statistics
+
+Quickly identify the most important and complex rules in your entire ruleset. Click on any rule in the list to instantly navigate to it in the main graph.
+
+![Statistics Panel](https://github.com/zbalkan/rulevis/raw/master/assets/stats-panel.gif)
+
+### Rule ID Heatmap
+
+Get a bird's-eye view of your rule ID landscape. Dark gray blocks are unused and available for your custom rules, while brighter red blocks indicate heavily populated ranges. This is invaluable for planning and organizing a large custom ruleset.
+
+![Heatmap View](https://github.com/zbalkan/rulevis/raw/master/assets/heatmap-view.gif)
+
+## Technical Overview
+
+The project is composed of three main Python modules and a JavaScript frontend:
+
+1. **`generator.py`:** Parses the Wazuh XML rule files and uses the `networkx` library to build a `MultiDiGraph` object representing the rule relationships. It saves this graph to a temporary file.
+2. **`analyzer.py`:** Loads the graph file and uses `networkx` to perform complex calculations (descendants, ancestors, etc.). It pre-calculates the data needed for the Statistics Panel and the Rule ID Heatmap and saves them to temporary JSON files.
+3. **`visualizer.py`:** A Flask web application that serves the frontend and provides a clean API for the visualization to fetch graph, stats, and heatmap data.
+4. **`graph.js`:** The core frontend logic. It uses **D3.js** for the force simulation and user interactions, and renders the main graph to an **HTML Canvas** for high performance. The interactive heatmap is rendered using **SVG** for its superior event handling and styling capabilities.
+
+Here’s a **ready-to-paste README subsection** that explains `rulevis` logging clearly and professionally for your users. It assumes the per-user setup you’ve implemented.
+
+---
+
+## Logging
+
+`rulevis` automatically writes diagnostic and operational logs to a user-specific location. Logs are plain text encoded in UTF-8 and include timestamps, module names, and severity levels. The application creates its log directory if it does not exist.
+
+| Platform        | Log file location                                                                           | Example path                                             |
+| --------------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| Windows     | `%LocalAppData%\rulevis\Logs\rulevis.log`                                                   | `C:\Users\<user>\AppData\Local\rulevis\Logs\rulevis.log` |
+| macOS       | `~/Library/Logs/rulevis/rulevis.log`                                                        | `/Users/<user>/Library/Logs/rulevis/rulevis.log`         |
+| Linux / BSD | `$XDG_STATE_HOME/rulevis/rulevis.log` or fallback `~/.local/share/rulevis/logs/rulevis.log` | `/home/<user>/.local/state/rulevis/rulevis.log`          |
+
+`rulevis` follows the [XDG Base Directory specification](https://specifications.freedesktop.org/basedir-spec/latest/) on Unix-like systems and Windows conventions under `%LocalAppData%`.
+
+The log file records informational messages, warnings, and errors emitted during execution. You can safely delete it; a new one will be created automatically on the next run.
+
+## Notes
+
+While the documentation defines <if_level> as another condition creating a parent-child relationship, it has not been used in any built-in rules. And as a personal choicem I decided to omit that deliberately.
+
+There is another `if`, called `<if_fts>`, that is used for *first time seen* events, not creating a parent-child relationship. Theefore it is not mentioned.

rulevis-1.0.3/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rulevis"
+version = "1.0.3"
+description = "Interactive Wazuh Rule Graph Explorer"
+readme = "README.md"
+requires-python = ">=3.9"
+
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+authors = [{ name = "Zafer Balkan", email = "zafer@zaferbalkan.com" }]
+keywords = ["wazuh", "detection", "security", "monitoring", "logging", "siem"]
+classifiers = [
+    "Topic :: Security",
+    "Topic :: System :: Logging",
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Information Technology",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14"
+]
+
+dependencies = [
+    "Flask>=3.1.2",
+    "networkx>=3.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/zbalkan/rulevis"
+Repository = "https://github.com/zbalkan/rulevis"
+Issues = "https://github.com/zbalkan/rulevis/issues"
+
+[project.scripts]
+rulevis = "rulevis:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+py-modules = ["rulevis"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"internal.static" = ["*.*"]

rulevis-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rulevis-1.0.3/src/internal/analyzer.py

@@ -0,0 +1,167 @@
+import logging
+import math
+import pickle
+import json
+import os
+from networkx import MultiDiGraph, descendants, ancestors, nodes_with_selfloops, simple_cycles
+
+
+class Analyzer:
+    """
+    Analyzes a graph from a pickle file and calculates key statistics.
+    """
+    def __init__(self, graph_path: str) -> None:
+        """
+        Initializes the Analyzer with the path to the graph file.
+
+        Args:
+            graph_path (str): The path to the .gpickle file.
+
+        Raises:
+            FileNotFoundError: If the graph file does not exist.
+        """
+        if not os.path.isfile(graph_path):
+            raise FileNotFoundError(f"Graph file not found: {graph_path}")
+        self.graph_path = graph_path
+        self.G: MultiDiGraph = self._load_graph()
+
+    def _load_graph(self) -> MultiDiGraph:
+        """Loads the graph from the pickle file."""
+        with open(self.graph_path, "rb") as f:
+            return pickle.load(f)
+
+    def calculate_statistics(self) -> dict:
+        """
+        Calculates all the required statistics for the graph, ensuring no
+        duplicate cycles are reported.
+        """
+        real_nodes = [n for n in self.G.nodes() if n != '0']
+
+        # --- Calculate Top 5 Lists ---
+        real_nodes = [n for n in self.G.nodes() if n != '0']
+        out_degrees = dict(self.G.out_degree(real_nodes))
+        in_degrees = dict(self.G.in_degree(real_nodes))
+
+        top_5_direct_descendants = sorted(out_degrees, key=out_degrees.get, reverse=True)[:5]
+        indirect_descendants_counts = {n: len(descendants(self.G, n)) for n in real_nodes}
+        top_5_indirect_descendants = sorted(indirect_descendants_counts,
+                                            key=indirect_descendants_counts.get, reverse=True)[:5]
+        top_5_direct_ancestors = sorted(in_degrees,
+                                        key=in_degrees.get, reverse=True)[:5]
+        indirect_ancestors_counts = {n: len(ancestors(self.G, n)) for n in real_nodes}
+        top_5_indirect_ancestors = sorted(indirect_ancestors_counts,
+                                          key=indirect_ancestors_counts.get, reverse=True)[:5]
+
+        isolated_rules = [
+            n for n in real_nodes
+            if self.G.out_degree(n) == 0 and list(self.G.predecessors(n)) == ['0']
+        ]
+
+        # 1. Find all nodes with self-loops first. This is our definitive list.
+        logging.info("Detecting self-loops (e.g., A -> A)...")
+        self_loop_nodes = set(nodes_with_selfloops(self.G))  # Use a set for efficient lookup
+        logging.info(f"Found {len(self_loop_nodes)} nodes with self-loops: {self_loop_nodes}")
+
+        # 2. Find all other simple cycles.
+        logging.info("Detecting multi-node cycles...")
+        all_simple_cycles = list(simple_cycles(self.G))
+
+        # 3. Filter out any multi-node cycles that contain a node we've already
+        #    identified as having a self-loop. This prevents double-reporting.
+        multi_node_cycles = [
+            cycle for cycle in all_simple_cycles
+            if not self_loop_nodes.intersection(cycle)
+        ]
+
+        logging.info(f"Found {len(multi_node_cycles)} distinct multi-node cycles.")
+        if multi_node_cycles:
+            logging.info(f"Example multi-node cycle: {multi_node_cycles[0]}")
+
+        # 4. Format the multi-node cycles for display
+        for cycle in multi_node_cycles:
+            if cycle:
+                cycle.append(cycle[0])
+
+        stats = {
+            "top_direct_descendants": [{"id": n, "count": out_degrees[n]}
+                                       for n in top_5_direct_descendants],
+            "top_indirect_descendants": [{"id": n, "count": indirect_descendants_counts[n]}
+                                         for n in top_5_indirect_descendants],
+            "top_direct_ancestors": [{"id": n, "count": in_degrees[n]} for n in top_5_direct_ancestors],
+            "top_indirect_ancestors": [{"id": n, "count": indirect_ancestors_counts[n]}
+                                       for n in top_5_indirect_ancestors],
+            "isolated_rules": [{"id": n}
+                               for n in isolated_rules],
+            "self_loops": [{"id": n}
+                           for n in self_loop_nodes],
+            "cycles": multi_node_cycles
+        }
+
+        return stats
+
+    def calculate_heatmap_data(self, block_size: int = 10) -> dict:
+        """
+        Generates data for a block-based heatmap, showing rule ID occupancy.
+        The heatmap range is dynamically calculated based on the highest rule ID found.
+
+        Args:
+            block_size (int): The size of each ID range block (e.g., 10).
+
+        Returns:
+            dict: A dictionary containing the list of blocks and metadata.
+        """
+        all_rule_ids = {int(n) for n in self.G.nodes() if n.isdigit() and n != '0'}
+
+        if not all_rule_ids:
+            # Handle case where there are no integer rules
+            return {"metadata": {"block_size": block_size, "max_id": 0, "total_blocks": 0}, "blocks": []}
+
+        actual_max_id = max(all_rule_ids)
+
+        # Calculate the upper bound for the heatmap range.
+        #    We use math.ceil to round up to the next full block.
+        #    For example, if max ID is 101234 and block size is 1000, this becomes:
+        #    ceil(101234 / 1000) * 1000  =>  ceil(101.234) * 1000  =>  102 * 1000  =>  102000
+        dynamic_max_range = math.ceil(actual_max_id / block_size) * block_size
+
+        # Ensure we have at least one block even if max_id is small
+        dynamic_max_range = max(dynamic_max_range, block_size)
+
+        blocks = []
+        # Use the dynamically calculated range for the loop
+        for i in range(0, dynamic_max_range, block_size):
+            start_range = i
+            end_range = i + block_size - 1
+
+            count = sum(1 for rule_id in all_rule_ids if start_range <= rule_id <= end_range)
+
+            blocks.append({
+                "id": f"{start_range}-{end_range}",
+                "count": count
+            })
+
+        return {
+            "metadata": {
+                "block_size": block_size,
+                "max_id": dynamic_max_range,
+                "total_blocks": len(blocks)
+            },
+            "blocks": blocks
+        }
+
+    def write_to_json(self, stats_output_path: str, heatmap_output_path: str) -> None:
+        """Calculates all data and writes to respective files."""
+
+        logging.info("Calculating graph statistics...")
+        stats_data = self.calculate_statistics()
+        logging.info(f"Writing statistics to {stats_output_path}...")
+        with open(stats_output_path, "w") as f:
+            json.dump(stats_data, f, indent=4)
+
+        logging.info("Calculating heatmap data...")
+        heatmap_data = self.calculate_heatmap_data()
+        logging.info(f"Writing heatmap data to {heatmap_output_path}...")
+        with open(heatmap_output_path, "w") as f:
+            json.dump(heatmap_data, f, indent=2)
+
+        logging.info("All analysis complete.")