soft-archmap 0.1.0__py3-none-any.whl

soft_archmap/adapters/python_adapter.py

@@ -0,0 +1,198 @@
+import ast
+import os
+from soft_archmap.core.model import Entity, Relation
+
+class PythonParser:
+    def __init__(self, repo_path: str, model):
+        self.repo_path = repo_path
+        self.model = model
+
+        self.current_module = None
+        self.current_class = None
+        self.current_function = None
+
+        # NEW: track import aliases
+        self.import_aliases = {}
+
+    # ----------------------------
+    # PUBLIC
+    # ----------------------------
+    def parse_file(self, file_path: str):
+        if any(part in {"venv", ".venv", "env", ".env"} for part in file_path.split(os.sep)):
+            return
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            print(f"Parsing {file_path}...")
+            source = f.read()
+
+        try:
+            tree = ast.parse(source, filename=file_path)
+        except SyntaxError as e:
+            print(f"Skipping {file_path} due to syntax error: {e}")
+            return
+
+        module_name = os.path.relpath(file_path, self.repo_path) \
+            .replace(os.sep, ".") \
+            .replace(".py", "")
+
+        self.current_module = module_name
+        module_id = f"module:{module_name}"
+
+        # Ensure module entity exists
+        self._ensure_entity(module_id, "module", module_name, file_path)
+
+        for node in tree.body:
+
+            # -------- Imports --------
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    real_name = alias.name
+                    alias_name = alias.asname or alias.name
+
+                    self.import_aliases[alias_name] = real_name
+                    self._add_import(module_id, real_name)
+
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    for alias in node.names:
+                        alias_name = alias.asname or alias.name
+                        full_name = f"{node.module}.{alias.name}"
+                        self.import_aliases[alias_name] = full_name
+
+                    self._add_import(module_id, node.module)
+
+            # -------- Classes --------
+            elif isinstance(node, ast.ClassDef):
+                self._handle_class(node, module_id, module_name, file_path)
+
+            # -------- Top-level Functions --------
+            elif isinstance(node, ast.FunctionDef):
+                self._handle_function(
+                    node, module_id, module_name, file_path, parent_class=None
+                )
+
+    # ----------------------------
+    # ENTITY HELPERS
+    # ----------------------------
+    def _ensure_entity(self, entity_id, entity_type, name, file):
+        if entity_id not in self.model.entities:
+            self.model.add_entity(Entity(
+                id=entity_id,
+                type=entity_type,
+                name=name,
+                file=file
+            ))
+
+    def _ensure_external_entity(self, entity_id):
+        if entity_id not in self.model.entities:
+            self.model.add_entity(Entity(
+                id=entity_id,
+                type="external",
+                name=entity_id.split(":", 1)[-1],
+                file="external"
+            ))
+
+    def _add_relation(self, src, dst, rel_type):
+        self._ensure_external_entity(dst)
+
+        self.model.add_relation(Relation(
+            src=src,
+            dst=dst,
+            type=rel_type
+        ))
+
+    # ----------------------------
+    # IMPORTS
+    # ----------------------------
+    def _add_import(self, module_id: str, imported_module: str):
+        target_id = f"module:{imported_module}"
+        self._add_relation(module_id, target_id, "imports")
+
+    # ----------------------------
+    # CLASS HANDLER
+    # ----------------------------
+    def _handle_class(self, node, module_id, module_name, file_path):
+        class_name = node.name
+        qualname = f"{module_name}.{class_name}"
+        class_id = f"class:{qualname}"
+
+        self._ensure_entity(class_id, "class", qualname, file_path)
+
+        self._add_relation(module_id, class_id, "contains")
+
+        # -------- Inheritance --------
+        for base in node.bases:
+            if isinstance(base, ast.Name):
+                base_id = f"class:{base.id}"
+                self._add_relation(class_id, base_id, "inherits")
+
+        prev_class = self.current_class
+        self.current_class = class_name
+
+        for item in node.body:
+            if isinstance(item, ast.FunctionDef):
+                self._handle_function(
+                    item, module_id, module_name, file_path, parent_class=class_name
+                )
+
+        self.current_class = prev_class
+
+    # ----------------------------
+    # FUNCTION / METHOD HANDLER
+    # ----------------------------
+    def _handle_function(self, node, module_id, module_name, file_path, parent_class):
+        func_name = node.name
+
+        if parent_class:
+            qualname = f"{module_name}.{parent_class}.{func_name}"
+            func_id = f"function:{qualname}"
+            parent_id = f"class:{module_name}.{parent_class}"
+            entity_type = "method"
+        else:
+            qualname = f"{module_name}.{func_name}"
+            func_id = f"function:{qualname}"
+            parent_id = module_id
+            entity_type = "function"
+
+        self._ensure_entity(func_id, entity_type, qualname, file_path)
+
+        self._add_relation(parent_id, func_id, "contains")
+
+        # -------- Calls --------
+        prev_function = self.current_function
+        self.current_function = func_id
+
+        for child in ast.walk(node):
+            if isinstance(child, ast.Call):
+                called_name = self._resolve_call(child.func)
+                if called_name:
+                    target_id = f"function:{called_name}"
+                    self._add_relation(func_id, target_id, "calls")
+
+        self.current_function = prev_function
+
+    # ----------------------------
+    # CALL RESOLUTION (IMPROVED)
+    # ----------------------------
+    def _resolve_call(self, node):
+        # foo()
+        if isinstance(node, ast.Name):
+            return self._resolve_alias(node.id)
+
+        # obj.method()
+        elif isinstance(node, ast.Attribute):
+            parts = []
+            while isinstance(node, ast.Attribute):
+                parts.append(node.attr)
+                node = node.value
+
+            if isinstance(node, ast.Name):
+                base = self._resolve_alias(node.id)
+                parts.append(base)
+
+            return ".".join(reversed(parts))
+
+        return None
+
+    def _resolve_alias(self, name):
+        return self.import_aliases.get(name, name)

soft_archmap/analysis/cycles.py

@@ -0,0 +1,13 @@
+# analysis/cycles.py
+from soft_archmap.core.graph import DependencyGraph
+
+def detect_cycles(model):
+    """
+    Detect cycles in architecture.
+    Returns a list of cycles (list of entity IDs).
+    """
+    graph = DependencyGraph()
+    for r in model.relations:
+        graph.add_edge(r.src, r.dst)
+
+    return graph.find_cycles()

soft_archmap/analysis/health.py

@@ -0,0 +1,15 @@
+# analysis/health.py
+from soft_archmap.core.graph import DependencyGraph
+
+def compute_health(model):
+    """
+    Simple health metric: ratio of used entities to total entities.
+    """
+    graph = DependencyGraph()
+    for r in model.relations:
+        graph.add_edge(r.src, r.dst)
+
+    total = len(model.entities)
+    unused = len([e for e in model.entities.values() if not graph.dependents(e.id)])
+    score = (total - unused) / total if total else 1.0
+    return round(score, 2)

soft_archmap/analysis/impact.py

@@ -0,0 +1,22 @@
+from collections import defaultdict, deque
+from soft_archmap.core.graph import DependencyGraph
+
+class ImpactAnalyzer:
+    def __init__(self, model):
+        # Build a dependency graph from the model
+        self.graph = DependencyGraph()
+        self.graph.build_from_model(model)
+
+    def analyze(self, target):
+        visited = set()
+        result = []
+
+        def dfs(node):
+            for dep in self.graph.dependents(node):
+                if dep not in visited:
+                    visited.add(dep)
+                    result.append(dep)
+                    dfs(dep)
+
+        dfs(target)
+        return result

soft_archmap/analysis/metrics.py

@@ -0,0 +1,24 @@
+# analysis/metrics.py
+from soft_archmap.core.graph import DependencyGraph
+
+def compute_metrics(model):
+    """
+    Compute simple architecture metrics.
+    """
+    graph = DependencyGraph()
+    for r in model.relations:
+        graph.add_edge(r.src, r.dst)
+
+    num_modules = sum(1 for e in model.entities.values() if e.type == "module")
+    num_classes = sum(1 for e in model.entities.values() if e.type == "class")
+    num_functions = sum(1 for e in model.entities.values() if e.type == "function")
+    num_relations = len(model.relations)
+    num_cycles = len(graph.find_cycles())
+
+    return {
+        "modules": num_modules,
+        "classes": num_classes,
+        "functions": num_functions,
+        "relations": num_relations,
+        "cycles": num_cycles
+    }

soft_archmap/analysis/risk.py

@@ -0,0 +1,33 @@
+class RiskEngine:
+    def __init__(self, graph):
+        self.graph = graph
+
+    # -------------------------
+    # CORE RISK SCORE
+    # -------------------------
+    def compute_risk(self, node_id):
+        direct = len(self.graph.dependents(node_id))
+
+        # indirect risk (2-hop approximation)
+        indirect = 0
+        for child in self.graph.dependents(node_id):
+            indirect += len(self.graph.dependents(child))
+
+        # cycle penalty
+        cycles = self._in_cycle(node_id)
+        cycle_penalty = 2 if cycles else 0
+
+        risk_score = (
+            direct * 0.6 +
+            indirect * 0.2 +
+            cycle_penalty * 0.2
+        )
+
+        return round(risk_score, 3)
+
+    # -------------------------
+    # CHECK IF NODE IN CYCLE
+    # -------------------------
+    def _in_cycle(self, node_id):
+        cycles = self.graph.find_cycles()
+        return any(node_id in cycle for cycle in cycles)

soft_archmap/analysis/top_risk.py

@@ -0,0 +1,45 @@
+from soft_archmap.analysis.risk import RiskEngine
+
+
+# class TopRiskAnalyzer:
+#     def __init__(self, graph):
+#         self.graph = graph
+#         self.risk_engine = RiskEngine(graph)
+
+#     def get_top_risk_modules(self, top_k=10):
+#         scores = []
+
+#         for node in self.graph.nodes():
+#             score = self.risk_engine.compute_risk(node)
+#             scores.append((node, score))
+
+#         # sort by risk descending
+#         scores.sort(key=lambda x: x[1], reverse=True)
+
+#         return {
+#             "top_risk": scores[:top_k]
+#         }
+
+class TopRiskAnalyzer:
+    def __init__(self, model):
+        self.model = model
+        self.graph = model.graph
+        self.engine = RiskEngine(self.graph)
+
+    def get_top_risk_modules(self):
+        results = []
+
+        for node_id, entity in self.model.entities.items():
+
+            # 🚫 SKIP EXTERNAL CODE HERE
+            if entity.type == "external":
+                continue
+
+            score = self.engine.compute_risk(node_id)
+            results.append((node_id, score))
+
+        results.sort(key=lambda x: x[1], reverse=True)
+
+        return {
+            "top_risk": results[:10]
+        }

soft_archmap/analysis/visualize.py

@@ -0,0 +1,23 @@
+# analysis/visualize.py
+import os
+import subprocess
+import shutil
+
+def visualize_architecture(dot_file, output_file="architecture.png"):
+    """
+    Generate PNG from Graphviz DOT file.
+    Requires 'dot' (Graphviz) installed.
+    """
+    # png_path = os.path.join(output_dir, "architecture.png")
+    if not shutil.which("dot"):
+        print("Graphviz 'dot' not found. Install Graphviz to generate visualization.")
+        return
+
+    try:
+        subprocess.run(
+            ["dot", "-Tpng", dot_file, "-o", output_file],
+            check=True
+        )
+        print(f"✅ Architecture visualization saved to {output_file}")
+    except subprocess.CalledProcessError as e:
+        print(f"Error generating visualization: {e}")

soft_archmap/cli.py

@@ -0,0 +1,225 @@
+import os
+import sys
+
+from soft_archmap.core.model import ArchitectureModel
+from soft_archmap.adapters.python_adapter import PythonParser
+from soft_archmap.export.graphviz import export_graphviz
+from soft_archmap.export.json_export import export_json
+from soft_archmap.analysis.cycles import detect_cycles
+from soft_archmap.analysis.health import compute_health
+from soft_archmap.analysis.metrics import compute_metrics
+from soft_archmap.analysis.impact import ImpactAnalyzer
+from soft_archmap.analysis.risk import RiskEngine
+from soft_archmap.analysis.top_risk import TopRiskAnalyzer
+
+
+class CLI:
+    def __init__(self):
+        self.args = sys.argv
+        self.command = self.args[1] if len(self.args) > 1 else None
+        self.input_repo = self.args[2] if len(self.args) > 2 else None
+        self.target = self.args[3] if len(self.args) > 3 else None
+
+        self.model = None
+        self.graph = None
+        self.parsed = False  # avoid multiple parses
+
+    # -------------------------
+    # ENTRY POINT
+    # -------------------------
+    def run(self):
+        if not self.command:
+            self.help()
+            return
+
+        command_map = {
+            "analyze": self.analyze,
+            "impact": self.impact,
+            "report": self.report,
+            "top-risk": self.top_risk
+        }
+
+        handler = command_map.get(self.command)
+
+        if not handler:
+            print(f"Unknown command: {self.command}")
+            self.help()
+            return
+
+        # Parse repo first if command needs it
+        if self.command in ["analyze", "impact", "top-risk"]:
+            if not self.input_repo:
+                print("Error: repo path is required for this command")
+                return
+            self.parse_repo()
+
+        # Execute command
+        handler()
+
+    # -------------------------
+    # PARSING REPO ONCE
+    # -------------------------
+    def parse_repo(self):
+        if self.parsed:
+            return
+
+        if not self.input_repo or not os.path.isdir(self.input_repo):
+            print("Invalid repository path")
+            sys.exit(1)
+
+        print(f"Parsing repository: {self.input_repo} ...")
+        self.model = ArchitectureModel()
+        parser = PythonParser(self.input_repo, self.model)
+
+        for root, dirs, files in os.walk(self.input_repo):
+            dirs[:] = [d for d in dirs if d not in {
+                    "venv", ".venv", "env", ".env",
+                    "__pycache__", ".git",
+                    "build", "dist",
+                    ".mypy_cache", ".pytest_cache"}]
+            for file in files:
+                if file.endswith(".py"):
+                    file_path = os.path.join(root, file)
+                    print(f"Parsing {file_path}")
+                    parser.parse_file(file_path)
+
+        # Ensure we have a dependency graph
+        from soft_archmap.core.graph import DependencyGraph
+        if not hasattr(self.model, "graph") or self.model.graph is None:
+            self.model.graph = DependencyGraph()
+            self.model.graph.build_from_model(self.model)
+
+        self.graph = self.model.graph
+        self.parsed = True
+        print("Repository parsed successfully.\n")
+
+    # -------------------------
+    # COMMANDS
+    # -------------------------
+    def analyze(self):
+        print(f"Analyzing repo: {self.input_repo}")
+
+        output_dir = self.get_output_dir()
+
+        json_path = os.path.join(output_dir, "architecture.json")
+        dot_path = os.path.join(output_dir, "architecture.dot")
+
+        export_json(self.model, json_path)
+        export_graphviz(self.model, dot_path)
+
+        print("\n--- ANALYSIS COMPLETE ---")
+        print("Cycles:", detect_cycles(self.model))
+        print("Health:", compute_health(self.model))
+        print("Metrics:", compute_metrics(self.model))
+        print("Analysis complete.")
+
+    def impact(self):
+        if not self.target:
+            print("Error: target is required for impact analysis")
+            return
+
+        targets = self.resolve_target(self.target)
+        if not targets:
+            print(f"No entities matched target '{self.target}'")
+            return
+
+        analyzer = ImpactAnalyzer(self.model)
+        result = []
+        for t in targets:
+            result.extend(analyzer.analyze(t))
+
+        # Remove duplicates
+        result = list(set(result))
+        result.sort(key=lambda x: ("module" in x, "class" in x, "function" in x))
+
+        print("\n--- IMPACT RESULT ---")
+        print({
+            "target": self.target,
+            "impact_count": len(result),
+            "impacted_nodes": result
+        })
+
+    def top_risk(self):
+        analyzer = TopRiskAnalyzer(self.model)
+        # analyzer = TopRiskAnalyzer(self.graph)
+        result = analyzer.get_top_risk_modules()
+
+        print("\n--- TOP RISK MODULES ---")
+        for node, score in result["top_risk"]:
+            print(f"{node} -> {score}")
+
+    # -------------------------
+    # HELPERS
+    # -------------------------
+    def resolve_target(self, target: str):
+        if not target:
+            return []
+
+        matches = []
+        for eid, entity in self.model.entities.items():
+            file_match = entity.file and target in entity.file
+            name_match = target == entity.name
+            id_match = target == eid
+            if file_match or name_match or id_match:
+                matches.append(eid)
+
+        return list(set(matches))
+
+    def report(self):
+        print("[REPORT GENERATION] pending....")
+
+    def get_output_dir(self):
+        """
+        Ask user for output directory with validation.
+        Falls back to current working directory.
+        """
+
+        while True:
+            path = input("Enter output directory path (press Enter for default): ").strip()
+
+            # fallback case
+            if not path:
+                print(f"Using default path: {os.getcwd()}")
+                return os.getcwd()
+
+            # valid path
+            if os.path.isdir(path):
+                return os.path.abspath(path)
+
+            # try creating it
+            try:
+                os.makedirs(path, exist_ok=True)
+                print(f"Created and using: {path}")
+                return os.path.abspath(path)
+            except Exception:
+                print("Invalid path. Try again.")
+
+    def help(self):
+        print("""
+Usage:
+  soft-archmap analyze <repo_path>
+  soft-archmap impact <repo_path> <node>
+  soft-archmap report <repo_path>              -----> not yet available
+  soft-archmap top-risk <repo_path>
+        """)
+
+def main():
+    # Display welcome message and contact info
+    border = '\n' + '=' * 100 + '\n'
+    lines = [
+        border,
+        "You are using ArchMap-Python by Excited Nuclei Tech Labs",
+        "For feedback, please email: excitednuclei.techlabs@gmail.com",
+        border
+    ]
+
+    # Print each line centered in a terminal width of 100
+    for line in lines:
+        print(line.center(100))
+
+    # Run the command-line interface
+    CLI().run()
+
+if __name__ == "__main__":
+    # CLI().run()
+    main()

soft_archmap/core/graph.py

@@ -0,0 +1,125 @@
+from collections import defaultdict
+
+
+class DependencyGraph:
+    def __init__(self):
+        # node -> {neighbor: set(relation_types)}
+        self.adj = defaultdict(lambda: defaultdict(set))
+
+        # reverse graph
+        self.rev_adj = defaultdict(lambda: defaultdict(set))
+
+    # ----------------------------
+    # BUILD GRAPH
+    # ----------------------------
+    def add_edge(self, src: str, dst: str, rel_type: str = "depends"):
+        self.adj[src][dst].add(rel_type)
+        self.rev_adj[dst][src].add(rel_type)
+
+    def build_from_model(self, model, allowed_types=None):
+        """
+        Build graph from ArchitectureModel
+        """
+        for r in model.relations:
+            if allowed_types and r.type not in allowed_types:
+                continue
+
+            self.add_edge(r.src, r.dst, r.type)
+
+    # ----------------------------
+    # BASIC QUERIES
+    # ----------------------------
+    def nodes(self):
+        return set(self.adj.keys()) | set(self.rev_adj.keys())
+
+    def neighbors(self, node, rel_type=None):
+        if node not in self.adj:
+            return set()
+
+        if rel_type:
+            return {
+                n for n, types in self.adj[node].items()
+                if rel_type in types
+            }
+
+        return set(self.adj[node].keys())
+
+    def dependents(self, node):
+        return set(self.rev_adj.get(node, {}).keys())
+
+    # ----------------------------
+    # CYCLE DETECTION (IMPROVED)
+    # ----------------------------
+    def find_cycles(self):
+        visited = set()
+        stack = []
+        stack_set = set()
+        cycles = set()
+
+        def normalize_cycle(cycle):
+            """
+            Normalize cycle to avoid duplicates:
+            rotate so smallest node is first
+            """
+            min_node = min(cycle)
+            min_index = cycle.index(min_node)
+            rotated = cycle[min_index:] + cycle[:min_index]
+            return tuple(rotated)
+
+        def dfs(node):
+            visited.add(node)
+            stack.append(node)
+            stack_set.add(node)
+
+            for neighbor in self.adj.get(node, {}):
+                if neighbor not in visited:
+                    dfs(neighbor)
+                elif neighbor in stack_set:
+                    idx = stack.index(neighbor)
+                    cycle = stack[idx:]
+                    cycles.add(normalize_cycle(cycle))
+
+            stack.pop()
+            stack_set.remove(node)
+
+        for node in self.nodes():
+            if node not in visited:
+                dfs(node)
+
+        return [list(c) for c in cycles]
+
+    # ----------------------------
+    # ADVANCED ANALYSIS
+    # ----------------------------
+    def find_dependency_chain(self, start, end, max_depth=10):
+        """
+        Find path from start → end
+        """
+        paths = []
+
+        def dfs(node, path):
+            if len(path) > max_depth:
+                return
+
+            if node == end:
+                paths.append(path[:])
+                return
+
+            for neighbor in self.adj.get(node, {}):
+                if neighbor not in path:
+                    dfs(neighbor, path + [neighbor])
+
+        dfs(start, [start])
+        return paths
+
+    def subgraph(self, nodes):
+        """
+        Extract subgraph
+        """
+        g = DependencyGraph()
+        for src in nodes:
+            for dst, types in self.adj.get(src, {}).items():
+                if dst in nodes:
+                    for t in types:
+                        g.add_edge(src, dst, t)
+        return g

soft_archmap/core/model.py

@@ -0,0 +1,105 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Set, Tuple, Optional
+from collections import defaultdict
+
+
+# ----------------------------
+# ENTITY
+# ----------------------------
+@dataclass
+class Entity:
+    id: str
+    type: str   # "module" | "class" | "function" | "method" | "external"
+    name: str
+    file: str
+    line: Optional[int] = None   # NEW (useful later)
+
+
+# ----------------------------
+# RELATION
+# ----------------------------
+@dataclass
+class Relation:
+    src: str
+    dst: str
+    type: str   # "imports" | "contains" | "inherits" | "calls"
+    weight: int = 1  # NEW: useful for call frequency
+
+
+# ----------------------------
+# ARCHITECTURE MODEL
+# ----------------------------
+@dataclass
+class ArchitectureModel:
+    entities: Dict[str, Entity] = field(default_factory=dict)
+    relations: List[Relation] = field(default_factory=list)
+
+    # NEW: for deduplication + fast lookup
+    _relation_set: Set[Tuple[str, str, str]] = field(default_factory=set, init=False)
+    _forward_index: Dict[str, Set[str]] = field(default_factory=lambda: defaultdict(set), init=False)
+    _reverse_index: Dict[str, Set[str]] = field(default_factory=lambda: defaultdict(set), init=False)
+
+    # ----------------------------
+    # ENTITY METHODS
+    # ----------------------------
+    def add_entity(self, entity: Entity):
+        """
+        Add or update an entity.
+        """
+        self.entities[entity.id] = entity
+
+    def get_entity(self, entity_id: str) -> Optional[Entity]:
+        return self.entities.get(entity_id)
+
+    def ensure_entity(self, entity_id: str, entity_type="external", name=None, file="external"):
+        """
+        Create entity if it doesn't exist.
+        """
+        if entity_id not in self.entities:
+            self.entities[entity_id] = Entity(
+                id=entity_id,
+                type=entity_type,
+                name=name or entity_id.split(":", 1)[-1],
+                file=file
+            )
+
+    # ----------------------------
+    # RELATION METHODS
+    # ----------------------------
+    def add_relation(self, relation: Relation):
+        key = (relation.src, relation.dst, relation.type)
+
+        if key not in self._relation_set:
+            self.relations.append(relation)
+            self._relation_set.add(key)
+
+            # build graph indexes
+            self._forward_index[relation.src].add(relation.dst)
+            self._reverse_index[relation.dst].add(relation.src)
+
+        else:
+            for r in self.relations:
+                if (r.src, r.dst, r.type) == key:
+                    r.weight += 1
+                    break
+
+    def dependencies(self, node_id: str) -> Set[str]:
+        return self._forward_index.get(node_id, set())
+    
+    def dependents(self, node_id: str) -> Set[str]:
+        return self._reverse_index.get(node_id, set())
+
+    def get_relations(self, src=None, dst=None, type=None) -> List[Relation]:
+        """
+        Flexible query API (VERY useful later).
+        """
+        results = self.relations
+
+        if src:
+            results = [r for r in results if r.src == src]
+        if dst:
+            results = [r for r in results if r.dst == dst]
+        if type:
+            results = [r for r in results if r.type == type]
+
+        return results

soft_archmap/export/graphviz.py

@@ -0,0 +1,92 @@
+import re
+from collections import defaultdict
+from soft_archmap.core.model import ArchitectureModel
+
+def sanitize_id(value: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9_]", "_", value)
+
+def escape_label(value: str) -> str:
+    return value.replace('"', r'\"').replace("\n", r"\n")
+
+def node_style(entity_type: str):
+    styles = {
+        "module": ("folder", "#ECEFF1"),
+        "class": ("box", "#E3F2FD"),
+        "function": ("oval", "#E8F5E9"),
+        "method": ("oval", "#FFF3E0"),
+    }
+    return styles.get(entity_type, ("box", "#FFFFFF"))
+
+def edge_style(relation_type: str):
+    styles = {
+        "imports": 'style=dashed color="#546E7A"',
+        "calls": 'color="#2E7D32"',
+        "inherits": 'arrowhead=empty color="#1565C0"',
+        "contains": 'arrowhead=none color="#616161"',
+    }
+    return styles.get(relation_type, "")
+
+def export_graphviz(model, path="architecture.dot", group_by_file=True):
+    """
+    Export ArchitectureModel to Graphviz DOT format
+    """
+    lines = []
+    lines.append("digraph Architecture {")
+    lines.append("  rankdir=LR;")
+    lines.append("  fontname=\"Helvetica\";")
+    lines.append("  node [fontname=\"Helvetica\", style=filled];")
+    lines.append("  edge [fontname=\"Helvetica\"];")
+    lines.append("")
+
+    # Group by file
+    entities_by_file = defaultdict(list)
+    for e in sorted(model.entities.values(), key=lambda x: (x.file, x.type, x.name)):
+        entities_by_file[e.file].append(e)
+
+    for file_name, entities in sorted(entities_by_file.items()):
+        cluster_name = sanitize_id(f"cluster_{file_name}")
+        if group_by_file:
+            lines.append(f'  subgraph {cluster_name} {{')
+            lines.append(f'    label="module: {escape_label(file_name)}";')
+            lines.append("    style=rounded;")
+
+        for e in entities:
+            safe_id = sanitize_id(e.id)
+            label = f"{e.type}\\n{escape_label(e.name)}"
+            shape, color = node_style(e.type)
+            lines.append(
+                f'    "{safe_id}" [label="{label}", shape={shape}, fillcolor="{color}"];'
+            )
+
+        if group_by_file:
+            lines.append("  }")
+            lines.append("")
+
+    # Add edges
+    for r in sorted(model.relations, key=lambda x: (x.type, x.src, x.dst)):
+        src_id = sanitize_id(r.src)
+        dst_id = sanitize_id(r.dst)
+        style = edge_style(r.type)
+        lines.append(
+            f'  "{src_id}" -> "{dst_id}" [label="{r.type}" {style}];'
+        )
+
+    # Legend
+    lines.append("""
+  subgraph cluster_legend {
+    label="Legend";
+    fontsize=12;
+    style=dashed;
+
+    key_module [label="module", shape=folder, fillcolor="#ECEFF1"];
+    key_class [label="class", shape=box, fillcolor="#E3F2FD"];
+    key_function [label="function", shape=oval, fillcolor="#E8F5E9"];
+    key_method [label="method", shape=oval, fillcolor="#FFF3E0"];
+  }
+""")
+    lines.append("}")
+
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+
+    print(f"✅ Graphviz DOT exported to {path}")

soft_archmap/export/json_export.py

@@ -0,0 +1,31 @@
+import json
+from soft_archmap.core.model import ArchitectureModel
+
+def export_json(model, path="architecture.json"):
+    """
+    Export ArchitectureModel to JSON
+    """
+    data = {
+        "entities": [],
+        "relations": []
+    }
+
+    for e in model.entities.values():
+        data["entities"].append({
+            "id": e.id,
+            "type": e.type,
+            "name": e.name,
+            "file": e.file
+        })
+
+    for r in model.relations:
+        data["relations"].append({
+            "src": r.src,
+            "dst": r.dst,
+            "type": r.type
+        })
+
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+    print(f"✅ JSON exported to {path}")

soft_archmap-0.1.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: soft-archmap
+Version: 0.1.0
+Summary: Python tool to analyze architecture and dependencies in Python projects.
+Author-email: Excited Nuclei Tech Labs <excitednuclei.techlabs@gmail.com>
+Project-URL: Homepage, https://github.com/EN-Tech-Labs/ArchMap
+Project-URL: Repository, https://github.com/EN-Tech-Labs/ArchMap
+Project-URL: Documentation, https://github.com/EN-Tech-Labs/ArchMap
+Keywords: architecture,dependency,python,analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Classifier: License :: Other/Proprietary License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: graphviz>=0.21
+Requires-Dist: networkx>=3.6.1
+Requires-Dist: pyvis>=0.3.2
+Requires-Dist: rich>=15.0.0
+Requires-Dist: requests>=2.33.1
+Provides-Extra: dev
+Requires-Dist: asttokens==3.0.1; extra == "dev"
+Requires-Dist: build==1.5.0; extra == "dev"
+Requires-Dist: certifi==2026.4.22; extra == "dev"
+Requires-Dist: charset-normalizer==3.4.7; extra == "dev"
+Requires-Dist: colorama==0.4.6; extra == "dev"
+Requires-Dist: comm==0.2.3; extra == "dev"
+Requires-Dist: debugpy==1.8.20; extra == "dev"
+Requires-Dist: decorator==5.2.1; extra == "dev"
+Requires-Dist: docutils==0.22.4; extra == "dev"
+Requires-Dist: executing==2.2.1; extra == "dev"
+Requires-Dist: id==1.6.1; extra == "dev"
+Requires-Dist: idna==3.13; extra == "dev"
+Requires-Dist: ipykernel==7.2.0; extra == "dev"
+Requires-Dist: ipython==9.13.0; extra == "dev"
+Requires-Dist: ipython_pygments_lexers==1.1.1; extra == "dev"
+Requires-Dist: jaraco.classes==3.4.0; extra == "dev"
+Requires-Dist: jaraco.context==6.1.2; extra == "dev"
+Requires-Dist: jaraco.functools==4.4.0; extra == "dev"
+Requires-Dist: jedi==0.19.2; extra == "dev"
+Requires-Dist: Jinja2==3.1.6; extra == "dev"
+Requires-Dist: jsonpickle==4.1.1; extra == "dev"
+Requires-Dist: jupyter_client==8.8.0; extra == "dev"
+Requires-Dist: jupyter_core==5.9.1; extra == "dev"
+Requires-Dist: keyring==25.7.0; extra == "dev"
+Requires-Dist: markdown-it-py==4.0.0; extra == "dev"
+Requires-Dist: MarkupSafe==3.0.3; extra == "dev"
+Requires-Dist: matplotlib-inline==0.2.1; extra == "dev"
+Requires-Dist: mdurl==0.1.2; extra == "dev"
+Requires-Dist: more-itertools==11.0.2; extra == "dev"
+Requires-Dist: nest-asyncio==1.6.0; extra == "dev"
+Requires-Dist: nh3==0.3.5; extra == "dev"
+Requires-Dist: packaging==26.1; extra == "dev"
+Requires-Dist: parso==0.8.6; extra == "dev"
+Requires-Dist: platformdirs==4.9.6; extra == "dev"
+Requires-Dist: prompt_toolkit==3.0.52; extra == "dev"
+Requires-Dist: psutil==7.2.2; extra == "dev"
+Requires-Dist: pure_eval==0.2.3; extra == "dev"
+Requires-Dist: Pygments==2.20.0; extra == "dev"
+Requires-Dist: pyproject_hooks==1.2.0; extra == "dev"
+Requires-Dist: python-dateutil==2.9.0.post0; extra == "dev"
+Requires-Dist: pywin32-ctypes==0.2.3; extra == "dev"
+Requires-Dist: pyzmq==27.1.0; extra == "dev"
+Requires-Dist: readme_renderer==44.0; extra == "dev"
+Requires-Dist: requests-toolbelt==1.0.0; extra == "dev"
+Requires-Dist: rfc3986==2.0.0; extra == "dev"
+Requires-Dist: six==1.17.0; extra == "dev"
+Requires-Dist: stack-data==0.6.3; extra == "dev"
+Requires-Dist: tornado==6.5.5; extra == "dev"
+Requires-Dist: traitlets==5.14.3; extra == "dev"
+Requires-Dist: twine==6.2.0; extra == "dev"
+Requires-Dist: urllib3==2.6.3; extra == "dev"
+Requires-Dist: wcwidth==0.6.0; extra == "dev"
+Dynamic: license-file
+
+# ArchMap-Python
+
+ArchMap-Python is a CLI tool by **Excited Nuclei Tech Labs** for analyzing Python software architecture. It helps developers understand dependencies, detect cycles, measure module health, compute risk, and visualize the architecture.
+
+## Features
+
+- Dependency graph generation
+- Cycle detection
+- Health metrics
+- Risk scoring of modules/functions
+- Impact analysis
+- Graphviz visualization and JSON export
+
+## Installation
+

soft_archmap-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+soft_archmap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+soft_archmap/cli.py,sha256=9mhwXfKcZzupEf0YSg8il30RKqRw0YlOpqLjdLANkWw,7288
+soft_archmap/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+soft_archmap/adapters/python_adapter.py,sha256=N7IKYi4DBPVCT9t7vmB6_Wxc74YIelGjcf2ARWSvGdg,6780
+soft_archmap/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+soft_archmap/analysis/cycles.py,sha256=1Usg5shzRJdlwV9BHPIQpjlYppdGmWKQdNc_HrDKsjE,342
+soft_archmap/analysis/health.py,sha256=G8FWtqY4z0OfPrp5SAB_STyTQKCI3M2pgu0oMbQScJc,495
+soft_archmap/analysis/impact.py,sha256=xTesRJ3D-HZVC35lQhXpc76LUkNAtmAwxS_gMcxa70A,640
+soft_archmap/analysis/metrics.py,sha256=fx31_xuR_cXpt3tES9BOEMqFlQ65uhG3NE7AIip1eZE,791
+soft_archmap/analysis/risk.py,sha256=n-MtdCJmoqs7bQYsdG_vpgPnauApDj9wmsXI4vZNy0Q,958
+soft_archmap/analysis/top_risk.py,sha256=fGBAYdEorCEb_dlNBdJQYL8oxeGv5mB74jbvakLlmB0,1221
+soft_archmap/analysis/visualize.py,sha256=3UMdq6l1FjHzfj_QwvCVXp7cNjeZLVAjSVat7rpaapc,751
+soft_archmap/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+soft_archmap/core/graph.py,sha256=5s8BTkvTAE4_TfGCW57quqngQ88xW5Z3eInEFJnhfWM,3647
+soft_archmap/core/model.py,sha256=o359dQJF7fcrz5ZASyY61P8-afL6BXblcH9j24DKhlY,3389
+soft_archmap/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+soft_archmap/export/graphviz.py,sha256=JTDUzWqCQdlNXzXCMrQG7Mqcr9g-UpeC3M6a6bM8F3M,3122
+soft_archmap/export/json_export.py,sha256=Wxzxg6EHByGoVgqWikvOMKLQi9vmXmPl92eiYg06yTE,743
+soft_archmap-0.1.0.dist-info/licenses/LICENSE,sha256=lqGthu8C6vpsctKYU8Ut1VKkLyZIH35aH-LRPLLtmdE,385
+soft_archmap-0.1.0.dist-info/METADATA,sha256=A0P5rxIA-ad7KMxPHk3j9shQf2GHH1USgNylVV5CqIk,4012
+soft_archmap-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+soft_archmap-0.1.0.dist-info/entry_points.txt,sha256=lE_xF1fhLvsWsncW62Vrw0RTK2FJb9vnn9GHMacyyV0,55
+soft_archmap-0.1.0.dist-info/top_level.txt,sha256=HbBX86q0aJSaO6AF0dG9cNbJQmVEQf3qM2ogQGPNYcw,13
+soft_archmap-0.1.0.dist-info/RECORD,,

soft_archmap-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

soft_archmap-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+soft-archmap = soft_archmap.cli:main

soft_archmap-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2026 Excited Nuclei Tech Labs
+All rights reserved.
+
+No part of this software may be reproduced, distributed, or transmitted in any form
+or by any means, including photocopying, recording, or other electronic or mechanical
+methods, without the prior written permission of Excited Nuclei Tech Labs.
+
+For permission requests, contact: excitednuclei.techlabs@gmail.com

soft_archmap-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+soft_archmap