synaptic-graph 0.1.0__py3-none-any.whl

synaptic/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

synaptic/cli.py

@@ -0,0 +1,214 @@
+"""
+cli.py — Synaptic CLI built with Typer + Rich.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+import sys
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich import print as rprint
+
+from synaptic import __version__
+
+app = typer.Typer(
+    name="synaptic",
+    help="[bold cyan]synaptic[/] — visualize the dependency graph of any Python project.",
+    rich_markup_mode="rich",
+    add_completion=True,
+)
+
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        rprint(f"[bold cyan]synaptic[/] version [bold]{__version__}[/]")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-v",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+) -> None:
+    pass
+
+
+@app.command()
+def scan(
+    project: Path = typer.Argument(
+        ...,
+        help="Root path of the Python project to analyse.",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True,
+    ),
+    output: Path = typer.Option(
+        Path("synaptic_graph.html"),
+        "--output", "-o",
+        help="Output file path. Extension determines format: .html (interactive) or .svg.",
+    ),
+    cloud: bool = typer.Option(True,  "--cloud/--no-cloud",  help="Detect AWS / GCP / Azure SDK usage."),
+    http:  bool = typer.Option(True,  "--http/--no-http",    help="Detect HTTP client library usage."),
+    tests: bool = typer.Option(False, "--tests/--no-tests",  help="Include test files in the scan."),
+    filter_stdlib:    bool = typer.Option(True,  "--filter-stdlib/--no-filter-stdlib",       help="Exclude Python stdlib modules from the graph."),
+    filter_external:  bool = typer.Option(False, "--filter-external/--no-filter-external",   help="Exclude third-party (non-project) modules from the graph."),
+    circular: bool = typer.Option(False, "--circular", "-c", help="Highlight circular dependencies in red."),
+) -> None:
+    """Scan *PROJECT* and generate a dependency graph."""
+
+    console.print(
+        Panel.fit(
+            f"[bold cyan]synaptic[/] [dim]v{__version__}[/]\n"
+            f"[dim]Scanning:[/] [bold]{project}[/]",
+            border_style="cyan",
+        )
+    )
+
+    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), console=console) as progress:
+
+        # 1. Scan files
+        task = progress.add_task("Scanning .py files...", total=None)
+        from synaptic.scanner import scan as do_scan
+        files = do_scan(project, include_tests=tests)
+        progress.update(task, description=f"[green]Found {len(files)} Python files[/]", completed=True)
+
+        if not files:
+            console.print("[yellow]No Python files found. Is the path correct?[/]")
+            raise typer.Exit(1)
+
+        # 2. Parse imports
+        task = progress.add_task("Parsing imports (AST)...", total=None)
+        from synaptic.parser import parse_project
+        edges = parse_project(files, project)
+        progress.update(task, description=f"[green]Parsed {len(edges)} import edges[/]", completed=True)
+
+        # 3. Cloud detection
+        cloud_deps = []
+        if cloud:
+            task = progress.add_task("Detecting cloud SDKs...", total=None)
+            from synaptic.cloud_detector import detect as detect_cloud
+            cloud_deps = detect_cloud(edges)
+            progress.update(task, description=f"[green]Found {len(cloud_deps)} cloud dependencies[/]", completed=True)
+
+        # 4. HTTP detection
+        http_deps = []
+        if http:
+            task = progress.add_task("Detecting HTTP clients...", total=None)
+            from synaptic.http_detector import detect as detect_http
+            http_deps = detect_http(edges)
+            progress.update(task, description=f"[green]Found {len(http_deps)} HTTP dependencies[/]", completed=True)
+
+        # 5. Build graph
+        task = progress.add_task("Building graph...", total=None)
+        from synaptic.utils import get_stdlib_modules, resolve_internal_modules, choose_output_format
+        from synaptic.graph import build, render_html, render_svg
+
+        internal_modules = resolve_internal_modules(files, project)
+        stdlib_modules = get_stdlib_modules()
+
+        G = build(
+            edges=edges,
+            cloud_deps=cloud_deps,
+            http_deps=http_deps,
+            internal_modules=internal_modules,
+            stdlib_modules=stdlib_modules,
+            filter_stdlib=filter_stdlib,
+            filter_external=filter_external,
+            highlight_circular=circular,
+        )
+        progress.update(task, description=f"[green]Graph: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges[/]", completed=True)
+
+        # 6. Render
+        fmt = choose_output_format(output)
+        task = progress.add_task(f"Rendering {fmt.upper()}...", total=None)
+        if fmt == "html":
+            render_html(G, output)
+        else:
+            render_svg(G, output)
+        progress.update(task, description=f"[green]Saved to {output}[/]", completed=True)
+
+    # Summary
+    console.print()
+    console.print(
+        Panel(
+            f"[bold green]Done![/]\n\n"
+            f"  [dim]Files scanned:[/]     [bold]{len(files)}[/]\n"
+            f"  [dim]Import edges:[/]      [bold]{len(edges)}[/]\n"
+            f"  [dim]Cloud deps:[/]        [bold]{len(cloud_deps)}[/]\n"
+            f"  [dim]HTTP deps:[/]         [bold]{len(http_deps)}[/]\n"
+            f"  [dim]Graph nodes:[/]       [bold]{G.number_of_nodes()}[/]\n"
+            f"  [dim]Graph edges:[/]       [bold]{G.number_of_edges()}[/]\n\n"
+            f"  [dim]Output:[/] [bold cyan]{output.resolve()}[/]",
+            title="[bold cyan]synaptic[/]",
+            border_style="green",
+        )
+    )
+
+
+@app.command()
+def tui(
+    project: Path = typer.Argument(
+        ...,
+        help="Root path of the Python project to analyse.",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True,
+    ),
+    cloud: bool = typer.Option(True,  "--cloud/--no-cloud",  help="Detect AWS / GCP / Azure SDK usage."),
+    http:  bool = typer.Option(True,  "--http/--no-http",    help="Detect HTTP client library usage."),
+    tests: bool = typer.Option(False, "--tests/--no-tests",  help="Include test files in the scan."),
+    filter_stdlib:   bool = typer.Option(True,  "--filter-stdlib/--no-filter-stdlib",     help="Exclude stdlib modules from the graph."),
+    filter_external: bool = typer.Option(False, "--filter-external/--no-filter-external", help="Exclude third-party modules."),
+    circular: bool = typer.Option(True, "--circular/--no-circular", help="Highlight circular dependencies."),
+) -> None:
+    """Launch the interactive TUI graph explorer for *PROJECT*."""
+    from synaptic.scanner import scan as do_scan
+    from synaptic.parser import parse_project
+    from synaptic.cloud_detector import detect as detect_cloud
+    from synaptic.http_detector import detect as detect_http
+    from synaptic.graph import build
+    from synaptic.utils import get_stdlib_modules, resolve_internal_modules
+    from synaptic.tui import launch
+
+    with console.status("[cyan]Building graph…[/]"):
+        files = do_scan(project, include_tests=tests)
+        if not files:
+            console.print("[yellow]No Python files found.[/]")
+            raise typer.Exit(1)
+
+        edges = parse_project(files, project)
+        cloud_deps = detect_cloud(edges) if cloud else []
+        http_deps = detect_http(edges) if http else []
+
+        internal_modules = resolve_internal_modules(files, project)
+        stdlib_modules = get_stdlib_modules()
+
+        G = build(
+            edges=edges,
+            cloud_deps=cloud_deps,
+            http_deps=http_deps,
+            internal_modules=internal_modules,
+            stdlib_modules=stdlib_modules,
+            filter_stdlib=filter_stdlib,
+            filter_external=filter_external,
+            highlight_circular=circular,
+        )
+
+    launch(G, project)
+
+
+if __name__ == "__main__":
+    app()

synaptic/cloud_detector.py

@@ -0,0 +1,47 @@
+"""
+cloud_detector.py — Identify cloud SDK usage from import edges.
+"""
+
+from dataclasses import dataclass
+from synaptic.parser import ImportEdge
+
+# Map root package prefixes → (provider, service label)
+CLOUD_SIGNATURES: dict[str, tuple[str, str]] = {
+    "boto3":            ("AWS", "boto3"),
+    "botocore":         ("AWS", "botocore"),
+    "aiobotocore":      ("AWS", "aiobotocore"),
+    "google.cloud":     ("GCP", "google-cloud"),
+    "google.api_core":  ("GCP", "google-api-core"),
+    "firebase_admin":   ("GCP", "firebase-admin"),
+    "googleapiclient":  ("GCP", "google-api-python-client"),
+    "azure":            ("Azure", "azure-sdk"),
+    "msrest":           ("Azure", "msrest"),
+}
+
+
+@dataclass
+class CloudDependency:
+    source: str       # module that imports the SDK
+    provider: str     # AWS | GCP | Azure
+    sdk: str          # human-readable SDK name
+    raw_import: str   # original import target string
+
+
+def detect(edges: list[ImportEdge]) -> list[CloudDependency]:
+    """Return CloudDependency entries found in the import edge list."""
+    found: list[CloudDependency] = []
+
+    for edge in edges:
+        for prefix, (provider, sdk) in CLOUD_SIGNATURES.items():
+            if edge.target == prefix or edge.target.startswith(prefix + "."):
+                found.append(
+                    CloudDependency(
+                        source=edge.source,
+                        provider=provider,
+                        sdk=sdk,
+                        raw_import=edge.target,
+                    )
+                )
+                break  # first match wins
+
+    return found

synaptic/graph.py

@@ -0,0 +1,166 @@
+"""
+graph.py — Build a dependency graph and render it as SVG or interactive HTML.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import networkx as nx
+
+from synaptic.parser import ImportEdge
+from synaptic.cloud_detector import CloudDependency
+from synaptic.http_detector import HttpDependency
+
+# Node kinds → visual properties
+_COLORS = {
+    "internal": "#4F8EF7",   # blue
+    "stdlib":   "#A0A0A0",   # grey
+    "external": "#F7A24F",   # orange
+    "AWS":      "#FF9900",   # AWS orange
+    "GCP":      "#4285F4",   # Google blue
+    "Azure":    "#0089D6",   # Azure blue
+    "http":     "#E84393",   # pink
+}
+
+
+def build(
+    edges: list[ImportEdge],
+    cloud_deps: list[CloudDependency],
+    http_deps: list[HttpDependency],
+    internal_modules: set[str],
+    stdlib_modules: set[str],
+    filter_stdlib: bool = True,
+    filter_external: bool = False,
+    highlight_circular: bool = False,
+) -> nx.DiGraph:
+    G = nx.DiGraph()
+
+    def node_kind(name: str) -> str:
+        if name in internal_modules:
+            return "internal"
+        if name in stdlib_modules:
+            return "stdlib"
+        return "external"
+
+    # Internal import edges
+    for edge in edges:
+        src_kind = node_kind(edge.source)
+        tgt_kind = node_kind(edge.target)
+
+        if filter_stdlib and (src_kind == "stdlib" or tgt_kind == "stdlib"):
+            continue
+        if filter_external and tgt_kind == "external":
+            continue
+
+        for n, k in [(edge.source, src_kind), (edge.target, tgt_kind)]:
+            if n not in G:
+                G.add_node(n, kind=k, color=_COLORS.get(k, "#cccccc"), label=n.split(".")[-1])
+
+        G.add_edge(edge.source, edge.target, kind="import")
+
+    # Cloud dependency edges
+    for dep in cloud_deps:
+        node_id = f"[{dep.provider}] {dep.sdk}"
+        if node_id not in G:
+            G.add_node(node_id, kind=dep.provider, color=_COLORS.get(dep.provider, "#cccccc"), label=dep.sdk)
+        if dep.source not in G:
+            G.add_node(dep.source, kind="internal", color=_COLORS["internal"], label=dep.source.split(".")[-1])
+        G.add_edge(dep.source, node_id, kind="cloud")
+
+    # HTTP dependency edges
+    for dep in http_deps:
+        node_id = f"[HTTP] {dep.library}"
+        if node_id not in G:
+            G.add_node(node_id, kind="http", color=_COLORS["http"], label=dep.library)
+        if dep.source not in G:
+            G.add_node(dep.source, kind="internal", color=_COLORS["internal"], label=dep.source.split(".")[-1])
+        G.add_edge(dep.source, node_id, kind="http")
+
+    # Mark circular dependencies
+    if highlight_circular:
+        cycles = list(nx.simple_cycles(G))
+        for cycle in cycles:
+            for i, node in enumerate(cycle):
+                next_node = cycle[(i + 1) % len(cycle)]
+                if G.has_edge(node, next_node):
+                    G[node][next_node]["circular"] = True
+
+    return G
+
+
+def render_svg(G: nx.DiGraph, output: Path) -> Path:
+    """Render graph to SVG using graphviz."""
+    try:
+        import graphviz as gv
+    except ImportError:
+        raise RuntimeError("graphviz package not installed. Run: pip install graphviz")
+
+    dot = gv.Digraph(
+        name="synaptic",
+        graph_attr={"rankdir": "LR", "bgcolor": "#1a1a2e", "fontname": "Helvetica"},
+        node_attr={"style": "filled", "fontname": "Helvetica", "fontcolor": "white", "fontsize": "11"},
+        edge_attr={"color": "#666688", "arrowsize": "0.7"},
+    )
+
+    for node, data in G.nodes(data=True):
+        color = data.get("color", "#cccccc")
+        label = data.get("label", node)
+        dot.node(node, label=label, fillcolor=color)
+
+    for src, tgt, data in G.edges(data=True):
+        attrs: dict[str, str] = {}
+        if data.get("circular"):
+            attrs = {"color": "#FF4444", "penwidth": "2"}
+        elif data.get("kind") == "cloud":
+            attrs = {"color": "#FF9900", "style": "dashed"}
+        elif data.get("kind") == "http":
+            attrs = {"color": "#E84393", "style": "dashed"}
+        dot.edge(src, tgt, **attrs)
+
+    out = output.with_suffix("")
+    try:
+        dot.render(str(out), format="svg", cleanup=True)
+    except Exception as exc:
+        if "ExecutableNotFound" in type(exc).__name__ or "dot" in str(exc).lower():
+            raise RuntimeError(
+                "Graphviz binary not found. Install it with:\n"
+                "  sudo apt install graphviz   # Debian/Ubuntu/WSL\n"
+                "  brew install graphviz       # macOS"
+            ) from exc
+        raise
+    return output
+
+
+def render_html(G: nx.DiGraph, output: Path) -> Path:
+    """Render interactive HTML graph using pyvis."""
+    try:
+        from pyvis.network import Network
+    except ImportError:
+        raise RuntimeError("pyvis package not installed. Run: pip install pyvis")
+
+    net = Network(
+        height="900px",
+        width="100%",
+        bgcolor="#1a1a2e",
+        font_color="white",
+        directed=True,
+        notebook=False,
+    )
+    net.barnes_hut(gravity=-8000, central_gravity=0.3, spring_length=150)
+
+    for node, data in G.nodes(data=True):
+        color = data.get("color", "#cccccc")
+        label = data.get("label", node)
+        title = f"<b>{node}</b><br/>kind: {data.get('kind', '?')}"
+        net.add_node(node, label=label, color=color, title=title, size=20)
+
+    for src, tgt, data in G.edges(data=True):
+        color = "#FF4444" if data.get("circular") else (
+            "#FF9900" if data.get("kind") == "cloud" else (
+            "#E84393" if data.get("kind") == "http" else "#666688"
+        ))
+        net.add_edge(src, tgt, color=color, arrows="to")
+
+    net.write_html(str(output))
+    return output

synaptic/http_detector.py

@@ -0,0 +1,46 @@
+"""
+http_detector.py — Static detection of HTTP client library usage.
+
+We do NOT monkey-patch at runtime; instead we detect *static* import of
+common HTTP libraries and flag those modules as potential HTTP callers.
+"""
+
+from dataclasses import dataclass
+from synaptic.parser import ImportEdge
+
+HTTP_SIGNATURES: dict[str, str] = {
+    "requests":         "requests",
+    "httpx":            "httpx",
+    "aiohttp":          "aiohttp",
+    "urllib.request":   "urllib",
+    "urllib3":          "urllib3",
+    "httplib2":         "httplib2",
+    "pycurl":           "pycurl",
+    "tornado.httpclient": "tornado",
+}
+
+
+@dataclass
+class HttpDependency:
+    source: str       # module that imports the HTTP library
+    library: str      # human-readable library name
+    raw_import: str   # original import target string
+
+
+def detect(edges: list[ImportEdge]) -> list[HttpDependency]:
+    """Return HttpDependency entries found in the import edge list."""
+    found: list[HttpDependency] = []
+
+    for edge in edges:
+        for prefix, library in HTTP_SIGNATURES.items():
+            if edge.target == prefix or edge.target.startswith(prefix + "."):
+                found.append(
+                    HttpDependency(
+                        source=edge.source,
+                        library=library,
+                        raw_import=edge.target,
+                    )
+                )
+                break
+
+    return found

synaptic/parser.py

@@ -0,0 +1,60 @@
+"""
+parser.py — Parse Python files with AST and extract import relationships.
+"""
+
+import ast
+from pathlib import Path
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ImportEdge:
+    source: str          # dotted module name of the importing file
+    target: str          # dotted module name being imported
+    names: list[str] = field(default_factory=list)   # specific names imported
+
+
+def file_to_module(path: Path, root: Path) -> str:
+    """Convert a file path to a dotted module name relative to *root*."""
+    rel = path.relative_to(root)
+    parts = list(rel.with_suffix("").parts)
+    if parts[-1] == "__init__":
+        parts = parts[:-1]
+    return ".".join(parts) if parts else path.stem
+
+
+def parse_file(path: Path, root: Path) -> list[ImportEdge]:
+    """Return all ImportEdge entries found in *path*."""
+    try:
+        source = path.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(source, filename=str(path))
+    except SyntaxError:
+        return []
+
+    module_name = file_to_module(path, root)
+    edges: list[ImportEdge] = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                edges.append(ImportEdge(source=module_name, target=alias.name))
+
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                names = [a.name for a in node.names]
+                # Handle relative imports: level > 0 means relative to current package
+                target = node.module
+                if node.level and node.level > 0:
+                    pkg_parts = module_name.split(".")[: -node.level]
+                    target = ".".join(pkg_parts + [node.module]) if pkg_parts else node.module
+                edges.append(ImportEdge(source=module_name, target=target, names=names))
+
+    return edges
+
+
+def parse_project(files: list[Path], root: Path) -> list[ImportEdge]:
+    """Aggregate all import edges across the entire project."""
+    all_edges: list[ImportEdge] = []
+    for f in files:
+        all_edges.extend(parse_file(f, root))
+    return all_edges

synaptic/scanner.py

@@ -0,0 +1,39 @@
+"""
+scanner.py — Recursively walk a project directory and collect .py files.
+"""
+
+from pathlib import Path
+
+IGNORE_DIRS = {
+    "venv", ".venv", "env", ".env",
+    "__pycache__", ".git", ".tox",
+    "node_modules", "dist", "build", ".mypy_cache",
+    ".pytest_cache", "site-packages",
+}
+
+
+def scan(
+    root: Path,
+    include_tests: bool = False,
+) -> list[Path]:
+    """Return all .py files under *root*, skipping ignored directories."""
+    result: list[Path] = []
+
+    for path in sorted(root.rglob("*.py")):
+        parts = set(path.parts)
+        if parts & IGNORE_DIRS:
+            continue
+        if not include_tests and _is_test(path):
+            continue
+        result.append(path)
+
+    return result
+
+
+def _is_test(path: Path) -> bool:
+    """Heuristic: skip files/dirs that look like tests."""
+    lowered = [p.lower() for p in path.parts]
+    return any(
+        p in {"tests", "test", "testing"} or p.startswith("test_")
+        for p in lowered
+    ) or path.stem.startswith("test_") or path.stem.endswith("_test")

synaptic/tui.py

@@ -0,0 +1,562 @@
+"""
+tui.py — Interactive TUI for synaptic using Textual.
+
+Design: ego-graph explorer
+  ┌─────────────────────────────────────────────────────────────────┐
+  │  ⬡ synaptic  project · 237 nodes · 643 edges                   │
+  ├─────────────┬───────────────────────────────────────────────────┤
+  │             │  ← imported by          imports →                 │
+  │  All nodes  │                                                   │
+  │  (sidebar)  │   predecessor1 ──╮                               │
+  │             │   predecessor2 ──┤──▶ [ SELECTED NODE ] ──┬──▶  s1│
+  │  ● internal │   predecessor3 ──╯                        ├──▶  s2│
+  │  ◈ AWS                                                  ╰──▶  s3│
+  │  ◈ HTTP     │                                                   │
+  ├─────────────┴───────────────────────────────────────────────────┤
+  │  kind · in: N · out: N · ⚠ circular                             │
+  └─────────────────────────────────────────────────────────────────┘
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import networkx as nx
+from rich.align import Align
+from rich.box import ROUNDED, SIMPLE, MINIMAL
+from rich.columns import Columns
+from rich.console import Group
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+from textual import events, on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Footer, Input, Label, Static
+
+# ─── Palette ─────────────────────────────────────────────────────────────────
+
+KIND_COLOR: dict[str, str] = {
+    "internal": "#4F8EF7",
+    "external": "#888899",
+    "stdlib":   "#444466",
+    "AWS":      "#FF9900",
+    "GCP":      "#4285F4",
+    "Azure":    "#0089D6",
+    "http":     "#E84393",
+}
+
+KIND_ICON: dict[str, str] = {
+    "internal": "◉",
+    "external": "○",
+    "stdlib":   "·",
+    "AWS":      "◈",
+    "GCP":      "◈",
+    "Azure":    "◈",
+    "http":     "◈",
+}
+
+KIND_LABEL: dict[str, str] = {
+    "internal": "Internal",
+    "AWS":      "AWS SDK",
+    "GCP":      "GCP SDK",
+    "Azure":    "Azure SDK",
+    "http":     "HTTP client",
+    "external": "External pkg",
+    "stdlib":   "Stdlib",
+}
+
+
+# ─── Messages ────────────────────────────────────────────────────────────────
+
+class NodeSelected(Message):
+    def __init__(self, node: str) -> None:
+        super().__init__()
+        self.node = node
+
+
+# ─── Sidebar ─────────────────────────────────────────────────────────────────
+
+class NodeSidebar(Widget, can_focus=False):
+    DEFAULT_CSS = """
+    NodeSidebar {
+        width: 28;
+        background: #08081a;
+        border-right: solid #1e1e3a;
+        overflow-y: scroll;
+    }
+    NodeSidebar Input {
+        background: #111128;
+        border: solid #2a2a4a;
+        color: #a0a0cc;
+        margin: 0 1;
+        height: 3;
+    }
+    NodeSidebar Input:focus {
+        border: solid #4F8EF7;
+    }
+    NodeSidebar .node-row {
+        padding: 0 2;
+        height: 1;
+        color: #888899;
+    }
+    NodeSidebar .node-row:hover {
+        background: #14143a;
+        color: white;
+    }
+    NodeSidebar .node-row.--selected {
+        background: #0d2060;
+        color: white;
+    }
+    NodeSidebar .section-header {
+        padding: 0 1;
+        height: 1;
+        color: #444466;
+        background: #0a0a1e;
+    }
+    """
+
+    filter_text: reactive[str] = reactive("")
+    selected_node: reactive[str | None] = reactive(None)
+
+    def __init__(self, graph: nx.DiGraph, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.graph = graph
+        self._all_nodes: list[tuple[str, dict[str, Any]]] = sorted(
+            graph.nodes(data=True), key=lambda x: (x[1].get("kind", "z"), x[0])
+        )
+
+    def compose(self) -> ComposeResult:
+        yield Input(placeholder="🔍 filter nodes…", id="search-input")
+        yield Label(
+            f" {self.graph.number_of_nodes()} nodes · {self.graph.number_of_edges()} edges",
+            classes="section-header",
+        )
+        self._render_list()
+
+    def _render_list(self) -> None:
+        """Mount node rows, grouped by kind."""
+        # Remove existing rows
+        for w in self.query(".node-row,.section-header.kind-header"):
+            w.remove()
+
+        q = self.filter_text.lower()
+        current_kind: str | None = None
+
+        for node, data in self._all_nodes:
+            label = data.get("label", node.split(".")[-1])
+            if q and q not in node.lower() and q not in label.lower():
+                continue
+
+            kind = data.get("kind", "internal")
+            if kind != current_kind:
+                current_kind = kind
+                color = KIND_COLOR.get(kind, "#888")
+                icon = KIND_ICON.get(kind, "·")
+                kind_lbl = KIND_LABEL.get(kind, kind)
+                self.mount(
+                    Label(
+                        Text.assemble((f" {icon} {kind_lbl}", f"bold {color}")),
+                        classes="section-header kind-header",
+                    )
+                )
+
+            color = KIND_COLOR.get(kind, "#888")
+            icon = KIND_ICON.get(kind, "·")
+            is_sel = node == self.selected_node
+
+            row = Static(
+                Text.assemble(
+                    (f"  {icon} ", f"{'bold ' if is_sel else ''}{color}"),
+                    (label[:20], f"{'bold white' if is_sel else color}"),
+                ),
+                classes=f"node-row{'  --selected' if is_sel else ''}",
+            )
+            row._node_id = node  # type: ignore[attr-defined]
+            self.mount(row)
+
+    def watch_filter_text(self, _: str) -> None:
+        self._render_list()
+
+    def watch_selected_node(self, _: str | None) -> None:
+        self._render_list()
+
+    @on(Input.Changed, "#search-input")
+    def on_search(self, event: Input.Changed) -> None:
+        self.filter_text = event.value
+
+    def on_click(self, event: events.Click) -> None:
+        for child in self.query(".node-row"):
+            node_id = getattr(child, "_node_id", None)
+            if node_id and child.region.contains(event.screen_x, event.screen_y):
+                self.post_message(NodeSelected(node_id))
+                break
+
+
+# ─── Ego graph canvas ─────────────────────────────────────────────────────────
+
+class EgoCanvas(Widget, can_focus=True):
+    """
+    3-column ego graph view:
+
+      predecessors  │  center node  │  successors
+      (imported by) │               │  (imports)
+    """
+
+    DEFAULT_CSS = """
+    EgoCanvas {
+        background: #09091a;
+        height: 1fr;
+        padding: 1 2;
+    }
+    EgoCanvas:focus {
+        border: solid #4F8EF7 25%;
+    }
+    """
+
+    selected_node: reactive[str | None] = reactive(None, layout=True)
+
+    _MAX_NEIGHBORS = 18   # max per side before truncating
+
+    def __init__(self, graph: nx.DiGraph, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.graph = graph
+        self._node_order: list[str] = list(graph.nodes())
+
+    def render(self) -> Any:
+        if self.selected_node is None:
+            return self._render_welcome()
+        return self._render_ego(self.selected_node)
+
+    def _render_welcome(self) -> Panel:
+        t = Text(justify="center")
+        t.append("\n\n\n")
+        t.append("⬡ synaptic\n\n", style="bold #4F8EF7")
+        t.append("Press ", style="dim")
+        t.append("Tab", style="bold cyan")
+        t.append(" or ", style="dim")
+        t.append("click a node", style="bold cyan")
+        t.append(" in the sidebar\n", style="dim")
+        t.append("to explore its dependency graph", style="dim")
+        return Panel(Align.center(t, vertical="middle"), border_style="#1e1e3a", box=ROUNDED)
+
+    def _render_ego(self, node: str) -> Any:
+        data = self.graph.nodes.get(node, {})
+        kind = data.get("kind", "internal")
+        color = KIND_COLOR.get(kind, "#cccccc")
+        icon = KIND_ICON.get(kind, "◉")
+
+        predecessors = list(self.graph.predecessors(node))
+        successors   = list(self.graph.successors(node))
+
+        # Detect circular edges involving this node
+        circular_partners: set[str] = set()
+        for u, v, d in self.graph.edges(data=True):
+            if d.get("circular") and (u == node or v == node):
+                circular_partners.add(v if u == node else u)
+
+        # ── Center node panel ─────────────────────────────────────────
+        center_text = Text(justify="center")
+        center_text.append(f"\n{icon}\n", style=f"bold {color}")
+        center_text.append(f"{node}\n", style=f"bold {color}")
+        center_text.append(f"\n{KIND_LABEL.get(kind, kind)}", style="dim #666688")
+        center_text.append(f"\n\n← {len(predecessors)}   {len(successors)} →", style="#444466")
+        if circular_partners:
+            center_text.append(f"\n⚠ {len(circular_partners)} circular", style="bold red")
+
+        center_panel = Panel(
+            Align.center(center_text, vertical="middle"),
+            border_style=color,
+            box=ROUNDED,
+            expand=True,
+        )
+
+        # ── Predecessors column ───────────────────────────────────────
+        pred_rows = self._build_neighbor_column(
+            predecessors, circular_partners, arrow="→", title="imported by"
+        )
+
+        # ── Successors column ─────────────────────────────────────────
+        succ_rows = self._build_neighbor_column(
+            successors, circular_partners, arrow="←", title="imports"
+        )
+
+        # ── 3-column table ────────────────────────────────────────────
+        table = Table.grid(expand=True, padding=(0, 1))
+        table.add_column(ratio=3, no_wrap=False)   # predecessors
+        table.add_column(ratio=2, no_wrap=False)   # center
+        table.add_column(ratio=3, no_wrap=False)   # successors
+        table.add_row(pred_rows, center_panel, succ_rows)
+
+        return table
+
+    def _build_neighbor_column(
+        self,
+        neighbors: list[str],
+        circular_partners: set[str],
+        arrow: str,
+        title: str,
+    ) -> Panel:
+        content = Text()
+        total = len(neighbors)
+        shown = neighbors[: self._MAX_NEIGHBORS]
+
+        if not shown:
+            content.append(f"\n  (none)", style="dim #444466")
+        else:
+            for i, nb in enumerate(shown):
+                nb_data = self.graph.nodes.get(nb, {})
+                nb_kind  = nb_data.get("kind", "internal")
+                nb_color = KIND_COLOR.get(nb_kind, "#888")
+                nb_icon  = KIND_ICON.get(nb_kind, "·")
+                nb_label = nb_data.get("label", nb.split(".")[-1])
+
+                is_circ = nb in circular_partners
+                connector = "⚠ " if is_circ else "  "
+                circ_style = "bold red" if is_circ else ""
+
+                content.append(f"\n")
+                if arrow == "→":
+                    content.append(f"  {connector}", circ_style)
+                    content.append(f"{nb_icon} ", f"{nb_color}")
+                    content.append(f"{nb_label[:22]}", f"{'bold ' if is_circ else ''}{nb_color}")
+                    content.append(f"  {arrow}", "#2a3a6a")
+                else:
+                    content.append(f"  {arrow}  ", "#2a3a6a")
+                    content.append(f"{nb_icon} ", f"{nb_color}")
+                    content.append(f"{nb_label[:22]}", f"{'bold ' if is_circ else ''}{nb_color}")
+                    content.append(f"  {connector}", circ_style)
+
+            if total > self._MAX_NEIGHBORS:
+                content.append(f"\n  … +{total - self._MAX_NEIGHBORS} more", style="dim #444466")
+
+        border_title = (
+            f"[dim]← [bold]{title}[/bold]  {total}[/dim]" if arrow == "→"
+            else f"[dim]{title}  [bold]{total}[/bold] →[/dim]"
+        )
+        return Panel(
+            content,
+            title=border_title,
+            border_style="#1e1e3a",
+            box=ROUNDED,
+            expand=True,
+        )
+
+    # ── Keyboard navigation ───────────────────────────────────────────
+
+    def on_key(self, event: events.Key) -> None:
+        nodes = self._node_order
+        if not nodes:
+            return
+        if self.selected_node is None:
+            self.selected_node = nodes[0]
+            self.post_message(NodeSelected(nodes[0]))
+            return
+
+        try:
+            idx = nodes.index(self.selected_node)
+        except ValueError:
+            idx = 0
+
+        if event.key in ("tab", "down", "j", "n"):
+            new = nodes[(idx + 1) % len(nodes)]
+        elif event.key in ("shift+tab", "up", "k", "p"):
+            new = nodes[(idx - 1) % len(nodes)]
+        else:
+            return
+
+        event.stop()
+        self.selected_node = new
+        self.post_message(NodeSelected(new))
+
+    def select(self, node: str) -> None:
+        self.selected_node = node
+        self.refresh()
+
+
+# ─── Bottom detail bar ────────────────────────────────────────────────────────
+
+class DetailBar(Widget):
+    DEFAULT_CSS = """
+    DetailBar {
+        height: 3;
+        background: #0a0a1e;
+        border-top: solid #1e1e3a;
+        padding: 0 2;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="detail-text")
+
+    def update(self, node: str, graph: nx.DiGraph) -> None:
+        data = graph.nodes.get(node, {})
+        kind  = data.get("kind", "internal")
+        color = KIND_COLOR.get(kind, "#888")
+        icon  = KIND_ICON.get(kind, "·")
+
+        preds = list(graph.predecessors(node))
+        succs = list(graph.successors(node))
+        circs = [
+            (u, v) for u, v, d in graph.edges(data=True)
+            if d.get("circular") and (u == node or v == node)
+        ]
+
+        t = Text()
+        t.append(f" {icon} ", f"bold {color}")
+        t.append(node, f"bold {color}")
+        t.append("  ·  ", "dim #333355")
+        t.append(KIND_LABEL.get(kind, kind), f"dim {color}")
+        t.append("  ·  ", "dim #333355")
+        t.append("imported by ", "dim")
+        t.append(str(len(preds)), "bold #a0a0ff")
+        t.append("  imports ", "dim")
+        t.append(str(len(succs)), "bold #4F8EF7")
+        if circs:
+            t.append("  ·  ", "dim #333355")
+            t.append(f"⚠ {len(circs)} circular dep{'s' if len(circs)>1 else ''}", "bold red")
+
+        self.query_one("#detail-text", Static).update(t)
+
+
+# ─── Mini stats bar (top) ─────────────────────────────────────────────────────
+
+class StatsBar(Widget):
+    DEFAULT_CSS = """
+    StatsBar {
+        height: 1;
+        background: #111122;
+        padding: 0 2;
+        dock: top;
+    }
+    """
+
+    def __init__(self, graph: nx.DiGraph, project: Path, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.graph = graph
+        self.project = project
+
+    def render(self) -> Text:
+        from synaptic import __version__
+        G = self.graph
+
+        internals = sum(1 for _, d in G.nodes(data=True) if d.get("kind") == "internal")
+        clouds    = sum(1 for _, d in G.nodes(data=True) if d.get("kind") in ("AWS","GCP","Azure"))
+        http_     = sum(1 for _, d in G.nodes(data=True) if d.get("kind") == "http")
+        circs     = sum(1 for *_, d in G.edges(data=True) if d.get("circular"))
+
+        t = Text(no_wrap=True, overflow="crop")
+        t.append("⬡ ", "bold #4F8EF7")
+        t.append("synaptic", "bold #4F8EF7")
+        t.append(f"  {self.project.name}", "#666688")
+        t.append("  ·  ", "dim #333355")
+        t.append(str(G.number_of_nodes()), "bold #4F8EF7")
+        t.append(" nodes  ", "dim #444466")
+        t.append(str(G.number_of_edges()), "bold #4F8EF7")
+        t.append(" edges  ", "dim #444466")
+        if clouds:
+            t.append(f"  ◈ {clouds} cloud", "#FF9900")
+        if http_:
+            t.append(f"  ◈ {http_} http", "#E84393")
+        if circs:
+            t.append(f"  ⚠ {circs} circular", "bold red")
+        t.append(f"  ·  v{__version__}", "dim #333355")
+        return t
+
+
+# ─── Main App ─────────────────────────────────────────────────────────────────
+
+class SynapticApp(App[None]):
+    CSS = """
+    Screen {
+        layout: vertical;
+        background: #0d0d1a;
+    }
+    #body {
+        layout: horizontal;
+        height: 1fr;
+    }
+    #main {
+        layout: vertical;
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q",         "quit",           "Quit"),
+        Binding("tab",       "next_node",       "Next",    show=False),
+        Binding("shift+tab", "prev_node",       "Prev",    show=False),
+        Binding("r",         "reset",           "Reset"),
+        Binding("g",         "focus_canvas",    "Graph"),
+        Binding("s",         "focus_search",    "Search"),
+    ]
+
+    def __init__(self, graph: nx.DiGraph, project: Path, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.graph = graph
+        self.project = project
+
+    def compose(self) -> ComposeResult:
+        from textual.containers import Horizontal, Vertical
+
+        canvas  = EgoCanvas(self.graph, id="canvas")
+        sidebar = NodeSidebar(self.graph, id="sidebar")
+        detail  = DetailBar(id="detail")
+
+        yield StatsBar(self.graph, self.project)
+
+        with Horizontal(id="body"):
+            yield sidebar
+            with Vertical(id="main"):
+                yield canvas
+                yield detail
+
+        yield Footer()
+
+    # ── Event handlers ───────────────────────────────────────────────
+
+    def on_node_selected(self, message: NodeSelected) -> None:
+        canvas  = self.query_one("#canvas",  EgoCanvas)
+        sidebar = self.query_one("#sidebar", NodeSidebar)
+        detail  = self.query_one("#detail",  DetailBar)
+
+        canvas.selected_node     = message.node
+        sidebar.selected_node    = message.node
+        detail.update(message.node, self.graph)
+
+    # ── Actions ──────────────────────────────────────────────────────
+
+    def action_next_node(self) -> None:
+        self.query_one("#canvas", EgoCanvas).on_key(
+            events.Key(self, "tab", character=None)
+        )
+
+    def action_prev_node(self) -> None:
+        self.query_one("#canvas", EgoCanvas).on_key(
+            events.Key(self, "shift+tab", character=None)
+        )
+
+    def action_reset(self) -> None:
+        canvas  = self.query_one("#canvas",  EgoCanvas)
+        sidebar = self.query_one("#sidebar", NodeSidebar)
+        canvas.selected_node  = None
+        sidebar.selected_node = None
+
+    def action_focus_canvas(self) -> None:
+        self.query_one("#canvas", EgoCanvas).focus()
+
+    def action_focus_search(self) -> None:
+        self.query_one("#search-input", Input).focus()
+
+
+# ─── Entry point ──────────────────────────────────────────────────────────────
+
+def launch(graph: nx.DiGraph, project: Path) -> None:
+    SynapticApp(graph=graph, project=project).run()

synaptic/utils.py

@@ -0,0 +1,41 @@
+"""
+utils.py — Shared helpers for synaptic.
+"""
+
+import sys
+from pathlib import Path
+
+
+def get_stdlib_modules() -> set[str]:
+    """Return the set of top-level standard library module names."""
+    if sys.version_info >= (3, 10):
+        import sys as _sys
+        return set(_sys.stdlib_module_names)  # type: ignore[attr-defined]
+
+    # Fallback for older Pythons: a curated list of common stdlib modules
+    return {
+        "abc", "ast", "asyncio", "builtins", "collections", "contextlib",
+        "copy", "dataclasses", "datetime", "enum", "functools", "hashlib",
+        "io", "itertools", "json", "logging", "math", "operator", "os",
+        "pathlib", "pickle", "platform", "pprint", "queue", "random",
+        "re", "shutil", "signal", "socket", "sqlite3", "string", "struct",
+        "subprocess", "sys", "tempfile", "threading", "time", "traceback",
+        "typing", "unittest", "urllib", "uuid", "warnings", "weakref",
+        "xml", "xmlrpc", "zipfile", "zlib",
+    }
+
+
+def resolve_internal_modules(files: list[Path], root: Path) -> set[str]:
+    """Build the set of dotted module names that belong to the project."""
+    from synaptic.parser import file_to_module
+    return {file_to_module(f, root) for f in files}
+
+
+def choose_output_format(output: Path) -> str:
+    """Infer desired output format from the file extension."""
+    suffix = output.suffix.lower()
+    if suffix in {".html", ".htm"}:
+        return "html"
+    if suffix in {".svg"}:
+        return "svg"
+    return "html"  # default

synaptic_graph-0.1.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: synaptic-graph
+Version: 0.1.0
+Summary: Visualize the dependency graph of any Python project — internal imports, cloud SDKs and HTTP calls.
+Project-URL: Homepage, https://github.com/darkvius/synaptic
+Project-URL: Repository, https://github.com/darkvius/synaptic
+Project-URL: Issues, https://github.com/darkvius/synaptic/issues
+License: MIT
+Keywords: architecture,ast,dependencies,graph,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: graphviz>=0.20
+Requires-Dist: networkx>=3.2
+Requires-Dist: numpy>=1.24
+Requires-Dist: pyvis>=0.3
+Requires-Dist: rich>=13
+Requires-Dist: textual>=0.80
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<img src="assets/demo.svg" alt="synaptic demo" width="100%"/>
+
+# synaptic
+
+**Visualize the dependency graph of any Python project.**  
+Internal imports · Cloud SDKs · HTTP clients · Circular deps — all in one command.
+
+[![Python](https://img.shields.io/badge/python-3.10%2B-4F8EF7?style=flat-square&logo=python&logoColor=white)](https://python.org)
+[![License](https://img.shields.io/badge/license-MIT-2ecc71?style=flat-square)](LICENSE)
+[![Built with Typer](https://img.shields.io/badge/CLI-Typer-E84393?style=flat-square)](https://typer.tiangolo.com)
+[![Powered by Rich](https://img.shields.io/badge/output-Rich-FF9900?style=flat-square)](https://rich.readthedocs.io)
+
+</div>
+
+---
+
+## Features
+
+- **Static AST analysis** — no runtime execution needed
+- **Internal imports** — maps every `import` and `from X import Y` across your codebase
+- **Cloud SDK detection** — identifies AWS (`boto3`), GCP (`google.cloud`, `firebase_admin`) and Azure (`azure.*`) usage
+- **HTTP client detection** — flags modules using `requests`, `httpx`, `aiohttp`, `urllib3` and more
+- **Circular dependency highlighting** — broken cycles rendered in red
+- **Two output formats** — interactive HTML (`pyvis`) or static SVG/PNG (`graphviz`)
+- **Rich terminal output** — live progress, color-coded summary
+
+---
+
+## Installation
+
+```bash
+pip install synaptic
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/your-username/synaptic
+cd synaptic
+pip install -e .
+```
+
+> **Requirements:** Python 3.10+, `graphviz` binary installed on your system (`apt install graphviz` / `brew install graphviz`).
+
+---
+
+## Quick start
+
+```bash
+# Interactive HTML graph (default)
+synaptic scan ./my-project
+
+# Custom output path
+synaptic scan ./my-project --output architecture.html
+
+# SVG with circular dependency highlighting
+synaptic scan ./my-project --output graph.svg --circular
+
+# Skip cloud and HTTP detection, filter stdlib
+synaptic scan ./my-project --no-cloud --no-http --filter-stdlib
+
+# Include test files in the scan
+synaptic scan ./my-project --tests
+```
+
+---
+
+## Options
+
+| Flag | Default | Description |
+|---|---|---|
+| `--output`, `-o` | `synaptic_graph.html` | Output file (`.html` or `.svg`) |
+| `--cloud / --no-cloud` | `on` | Detect AWS / GCP / Azure SDKs |
+| `--http / --no-http` | `on` | Detect HTTP client libraries |
+| `--tests / --no-tests` | `off` | Include test files |
+| `--filter-stdlib / --no-filter-stdlib` | `on` | Exclude Python stdlib from graph |
+| `--filter-external / --no-filter-external` | `off` | Exclude third-party packages |
+| `--circular`, `-c` | `off` | Highlight circular dependencies in red |
+| `--version`, `-v` | — | Show version and exit |
+
+---
+
+## Architecture
+
+```
+synaptic/
+├── cli.py             # Typer CLI + Rich output
+├── scanner.py         # Recursive .py file discovery
+├── parser.py          # AST-based import analysis
+├── cloud_detector.py  # AWS / GCP / Azure SDK detection
+├── http_detector.py   # HTTP client library detection
+├── graph.py           # networkx graph + graphviz / pyvis rendering
+└── utils.py           # Shared helpers
+```
+
+---
+
+## Node types
+
+| Color | Meaning |
+|---|---|
+| 🔵 Blue | Internal project module |
+| 🟠 Orange | AWS / GCP / Azure SDK |
+| 🩷 Pink | HTTP client (requests, httpx…) |
+| ⚫ Grey | Stdlib / external package |
+| 🔴 Red edge | Circular dependency |
+
+---
+
+## License
+
+MIT © 2024

synaptic_graph-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+synaptic/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+synaptic/cli.py,sha256=z6HVgYUZgcyVL8FryP4KBTW15BcdYGVR1jleSBG5670,8203
+synaptic/cloud_detector.py,sha256=Mp0uXl8wTSDx1LI__SCPXTKWushRALUtXACrfetKy8M,1607
+synaptic/graph.py,sha256=-XuieF1M2gP7rqfG1W5s1CnGJQo1p5c3XB1oAT0sZUs,5700
+synaptic/http_detector.py,sha256=gmGza5FdyJFvJX77MkVgoTlDBcuK7Y3PJk6VBCBGcMQ,1424
+synaptic/parser.py,sha256=8oabkkTDxMSx9mcmArxKipyinHurqDXYU-1my4ZqzNo,2111
+synaptic/scanner.py,sha256=mgiXIV4RkAFRv9zVUoOneyiBY05td1vjfvmOWAMU2m8,1036
+synaptic/tui.py,sha256=3rKYsLw-AS7H-UdLuMjgoqKlyULx66XA6v5O_c4J6DU,21296
+synaptic/utils.py,sha256=QIcsYw-1P70YT5mtIl1PnPum2VwMRDPHOo6LBW0Dj2E,1515
+synaptic_graph-0.1.0.dist-info/METADATA,sha256=_IkAT4yKQ9cfOK9uSQSXAAAKXR3EH1iNs5ABBnfY-qE,4646
+synaptic_graph-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+synaptic_graph-0.1.0.dist-info/entry_points.txt,sha256=eGAKwerDsS9rPffdCXurFypd2mpw3AgGIcwamzjr4wQ,46
+synaptic_graph-0.1.0.dist-info/RECORD,,

synaptic_graph-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

synaptic_graph-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+synaptic = synaptic.cli:app