rostree 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

rostree/cli.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import argparse
 import json
+import shutil
+import subprocess
 import sys
 from pathlib import Path
 
@@ -143,6 +145,447 @@ def cmd_tui(args: argparse.Namespace) -> int:
     return 0
 
 
+def _collect_edges(
+    node: DependencyNode,
+    edges: set[tuple[str, str]],
+    visited: set[str] | None = None,
+) -> None:
+    """Recursively collect all edges (parent -> child) from a dependency tree."""
+    if visited is None:
+        visited = set()
+    if node.name in visited:
+        return
+    visited.add(node.name)
+    for child in node.children:
+        # Skip special markers
+        if child.description in ("(cycle)", "(not found)", "(parse error)"):
+            continue
+        edges.add((node.name, child.name))
+        _collect_edges(child, edges, visited)
+
+
+def _collect_edges_multi(
+    trees: list[DependencyNode],
+    root_names: set[str],
+) -> tuple[set[tuple[str, str]], set[str]]:
+    """Collect edges from multiple trees, tracking which nodes are roots."""
+    edges: set[tuple[str, str]] = set()
+    all_nodes: set[str] = set()
+    for tree in trees:
+        _collect_edges(tree, edges)
+        all_nodes.add(tree.name)
+        # Also collect all node names from edges
+        for parent, child in edges:
+            all_nodes.add(parent)
+            all_nodes.add(child)
+    return edges, all_nodes
+
+
+def _generate_dot(
+    roots: list[DependencyNode],
+    title: str | None = None,
+    highlight_roots: bool = True,
+) -> str:
+    """Generate DOT (Graphviz) format from dependency trees."""
+    root_names = {r.name for r in roots}
+    edges: set[tuple[str, str]] = set()
+    for root in roots:
+        _collect_edges(root, edges)
+
+    lines = [
+        "digraph dependencies {",
+        "    rankdir=LR;",
+        '    node [shape=box, style=rounded, fontname="sans-serif"];',
+    ]
+    if title:
+        lines.insert(1, f'    label="{title}";')
+        lines.insert(2, "    labelloc=t;")
+
+    # Highlight root nodes
+    if highlight_roots:
+        for name in sorted(root_names):
+            lines.append(f'    "{name}" [style="rounded,filled", fillcolor=lightblue];')
+
+    for parent, child in sorted(edges):
+        lines.append(f'    "{parent}" -> "{child}";')
+
+    lines.append("}")
+    return "\n".join(lines)
+
+
+def _generate_mermaid(
+    roots: list[DependencyNode],
+    title: str | None = None,
+    highlight_roots: bool = True,
+) -> str:
+    """Generate Mermaid format from dependency trees."""
+    root_names = {r.name for r in roots}
+    edges: set[tuple[str, str]] = set()
+    for root in roots:
+        _collect_edges(root, edges)
+
+    lines = ["graph LR"]
+    if title:
+        lines[0] = f"---\ntitle: {title}\n---\ngraph LR"
+
+    # Style root nodes
+    if highlight_roots:
+        for name in sorted(root_names):
+            lines.append(f"    {_mermaid_id(name)}[{name}]")
+            lines.append(f"    style {_mermaid_id(name)} fill:#lightblue")
+
+    for parent, child in sorted(edges):
+        lines.append(f"    {_mermaid_id(parent)} --> {_mermaid_id(child)}")
+
+    return "\n".join(lines)
+
+
+def _mermaid_id(name: str) -> str:
+    """Convert a package name to a valid Mermaid node ID."""
+    # Replace characters that are problematic in Mermaid
+    return name.replace("-", "_").replace(".", "_")
+
+
+def _get_workspace_packages(workspace_path: Path | None = None) -> list[str]:
+    """Get packages from a workspace. If None, use current environment."""
+    if workspace_path:
+        # Scan the specified workspace
+        ws_path = Path(workspace_path).resolve()
+        src_path = ws_path / "src" if (ws_path / "src").exists() else ws_path
+        if not src_path.exists():
+            return []
+        from rostree.core.finder import _list_packages_in_src
+
+        return _list_packages_in_src(src_path)
+    else:
+        # Use packages from current environment's workspace (not system)
+        by_source = list_packages_by_source()
+        packages = []
+        for label, names in by_source.items():
+            # Only include Workspace and Source packages, not System
+            if "System" not in label:
+                packages.extend(names)
+        return packages
+
+
+# Default depth limit for graph to prevent hangs
+GRAPH_DEFAULT_DEPTH = 4
+GRAPH_MAX_PACKAGES = 50
+
+
+def _check_graphviz() -> bool:
+    """Check if Graphviz (dot) is available."""
+    return shutil.which("dot") is not None
+
+
+def _check_matplotlib() -> bool:
+    """Check if matplotlib and networkx are available."""
+    try:
+        import matplotlib  # noqa: F401
+        import networkx  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def _render_with_matplotlib(
+    edges: set[tuple[str, str]],
+    root_names: set[str],
+    output_path: Path,
+    format: str,
+    title: str | None = None,
+) -> bool:
+    """Render graph using matplotlib and networkx (pure Python, no system deps)."""
+    try:
+        import matplotlib.pyplot as plt
+        import networkx as nx
+    except ImportError:
+        print(
+            "Error: matplotlib/networkx not installed. Install with:\n"
+            "  pip install rostree[viz]\n"
+            "  # or: pip install matplotlib networkx",
+            file=sys.stderr,
+        )
+        return False
+
+    try:
+        # Create directed graph
+        G = nx.DiGraph()
+        G.add_edges_from(edges)
+
+        # Add isolated root nodes (roots with no deps)
+        for root in root_names:
+            if root not in G:
+                G.add_node(root)
+
+        if len(G.nodes()) == 0:
+            print("Error: Graph is empty", file=sys.stderr)
+            return False
+
+        # Create figure
+        fig_width = max(12, len(G.nodes()) * 0.5)
+        fig_height = max(8, len(G.nodes()) * 0.3)
+        fig, ax = plt.subplots(figsize=(fig_width, fig_height))
+
+        # Layout - hierarchical for dependency graphs
+        try:
+            # Try graphviz layout if available (best for DAGs)
+            pos = nx.nx_agraph.graphviz_layout(G, prog="dot", args="-Grankdir=LR")
+        except Exception:
+            try:
+                # Fall back to spring layout with more iterations
+                pos = nx.spring_layout(G, k=2, iterations=50, seed=42)
+            except Exception:
+                # Last resort: shell layout
+                pos = nx.shell_layout(G)
+
+        # Node colors: root nodes are highlighted
+        node_colors = ["lightblue" if n in root_names else "lightgray" for n in G.nodes()]
+
+        # Draw the graph
+        nx.draw_networkx_nodes(
+            G,
+            pos,
+            node_color=node_colors,
+            node_size=2000,
+            alpha=0.9,
+            ax=ax,
+        )
+        nx.draw_networkx_labels(
+            G,
+            pos,
+            font_size=8,
+            font_weight="bold",
+            ax=ax,
+        )
+        nx.draw_networkx_edges(
+            G,
+            pos,
+            edge_color="gray",
+            arrows=True,
+            arrowsize=15,
+            alpha=0.7,
+            ax=ax,
+        )
+
+        if title:
+            ax.set_title(title, fontsize=14, fontweight="bold")
+
+        ax.axis("off")
+        plt.tight_layout()
+
+        # Save to file
+        plt.savefig(output_path, format=format, dpi=150, bbox_inches="tight")
+        plt.close(fig)
+        return True
+
+    except Exception as e:
+        print(f"Error rendering with matplotlib: {e}", file=sys.stderr)
+        return False
+
+
+def _render_dot(dot_content: str, output_path: Path, format: str) -> bool:
+    """Render DOT content to an image file using Graphviz."""
+    if not _check_graphviz():
+        print(
+            "Error: Graphviz not found. Install it with:\n"
+            "  Ubuntu/Debian: sudo apt install graphviz\n"
+            "  macOS: brew install graphviz\n"
+            "  Or download from: https://graphviz.org/download/",
+            file=sys.stderr,
+        )
+        return False
+
+    try:
+        result = subprocess.run(
+            ["dot", f"-T{format}", "-o", str(output_path)],
+            input=dot_content,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if result.returncode != 0:
+            print(f"Graphviz error: {result.stderr}", file=sys.stderr)
+            return False
+        return True
+    except subprocess.TimeoutExpired:
+        print("Error: Graphviz timed out (graph may be too large)", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"Error running Graphviz: {e}", file=sys.stderr)
+        return False
+
+
+def _open_file(path: Path) -> bool:
+    """Open a file with the system default application."""
+    import platform
+
+    system = platform.system()
+    try:
+        if system == "Darwin":  # macOS
+            subprocess.run(["open", str(path)], check=True)
+        elif system == "Windows":
+            subprocess.run(["start", "", str(path)], shell=True, check=True)
+        else:  # Linux and others
+            subprocess.run(["xdg-open", str(path)], check=True)
+        return True
+    except Exception as e:
+        print(f"Could not open file: {e}", file=sys.stderr)
+        return False
+
+
+def cmd_graph(args: argparse.Namespace) -> int:
+    """Generate a dependency graph in DOT or Mermaid format."""
+    extra_roots = [Path(p) for p in args.source] if args.source else None
+
+    # Determine packages to graph
+    packages_to_graph: list[str] = []
+
+    if args.package:
+        packages_to_graph = [args.package]
+    elif args.workspace:
+        # Scan specified workspace
+        packages_to_graph = _get_workspace_packages(Path(args.workspace))
+        if not packages_to_graph:
+            print(f"No packages found in workspace: {args.workspace}", file=sys.stderr)
+            return 1
+    else:
+        # Use current environment's non-system packages
+        packages_to_graph = _get_workspace_packages(None)
+        if not packages_to_graph:
+            print(
+                "No workspace packages found. Specify a package or use --workspace.",
+                file=sys.stderr,
+            )
+            return 1
+
+    # Limit packages for performance
+    if len(packages_to_graph) > GRAPH_MAX_PACKAGES and not args.package:
+        print(
+            f"Warning: Limiting to first {GRAPH_MAX_PACKAGES} packages "
+            f"(found {len(packages_to_graph)}). Use -d to limit depth.",
+            file=sys.stderr,
+        )
+        packages_to_graph = packages_to_graph[:GRAPH_MAX_PACKAGES]
+
+    # Use default depth for workspace graphs (prevent hangs), unlimited for single package
+    if args.depth is not None:
+        depth = args.depth
+    elif args.package:
+        depth = None  # Unlimited for single package
+    else:
+        depth = GRAPH_DEFAULT_DEPTH  # Limited for workspace-wide
+
+    # Build trees for all packages
+    trees: list[DependencyNode] = []
+    for i, pkg in enumerate(packages_to_graph):
+        if len(packages_to_graph) > 1:
+            print(f"Processing {pkg} ({i + 1}/{len(packages_to_graph)})...", file=sys.stderr)
+        tree = build_dependency_tree(
+            pkg,
+            max_depth=depth,
+            runtime_only=args.runtime,
+            extra_source_roots=extra_roots,
+        )
+        if tree is not None:
+            trees.append(tree)
+
+    if not trees:
+        print("No valid package trees found.", file=sys.stderr)
+        return 1
+
+    # Generate title
+    if args.no_title:
+        title = None
+    elif args.package:
+        title = f"{args.package} dependencies"
+    elif args.workspace:
+        title = f"Workspace: {Path(args.workspace).name}"
+    else:
+        title = "Workspace dependencies"
+
+    if args.format == "mermaid":
+        output = _generate_mermaid(trees, title=title)
+    else:  # dot
+        output = _generate_dot(trees, title=title)
+
+    # Handle rendering to image
+    render_format = getattr(args, "render", None)
+    if render_format:
+        if args.format == "mermaid":
+            print(
+                "Error: --render only works with DOT format (not mermaid). "
+                "Remove -f mermaid or use mermaid.live for rendering.",
+                file=sys.stderr,
+            )
+            return 1
+
+        # Determine output path
+        if args.output:
+            # If output specified, use it with proper extension
+            out_path = Path(args.output)
+            if out_path.suffix.lower() not in (f".{render_format}", ".dot"):
+                out_path = out_path.with_suffix(f".{render_format}")
+        else:
+            # Default filename based on package or workspace
+            if args.package:
+                base_name = args.package.replace("/", "_")
+            elif args.workspace:
+                base_name = Path(args.workspace).name
+            else:
+                base_name = "workspace_deps"
+            out_path = Path(f"{base_name}.{render_format}")
+
+        print(f"Rendering graph to {out_path}...", file=sys.stderr)
+
+        # Try Graphviz first (best quality), fall back to matplotlib
+        rendered = False
+        if _check_graphviz():
+            rendered = _render_dot(output, out_path, render_format)
+        else:
+            # Collect edges for matplotlib rendering
+            root_names = {t.name for t in trees}
+            edges: set[tuple[str, str]] = set()
+            for tree in trees:
+                _collect_edges(tree, edges)
+
+            if _check_matplotlib():
+                print("Graphviz not found, using matplotlib...", file=sys.stderr)
+                rendered = _render_with_matplotlib(
+                    edges, root_names, out_path, render_format, title
+                )
+            else:
+                print(
+                    "Error: No rendering backend available.\n"
+                    "Install one of:\n"
+                    "  1. Graphviz (system): sudo apt install graphviz\n"
+                    "  2. matplotlib (pip): pip install rostree[viz]",
+                    file=sys.stderr,
+                )
+                return 1
+
+        if not rendered:
+            return 1
+
+        print(f"Graph image saved to: {out_path}", file=sys.stderr)
+
+        # Open the file if requested
+        if getattr(args, "open", False):
+            _open_file(out_path)
+
+        return 0
+
+    # Just output text (DOT or Mermaid)
+    if args.output:
+        Path(args.output).write_text(output)
+        print(f"Graph written to: {args.output}", file=sys.stderr)
+    else:
+        print(output)
+
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     """Main entry point for the rostree CLI."""
     parser = argparse.ArgumentParser(
@@ -262,6 +705,78 @@ def main(argv: list[str] | None = None) -> int:
     )
     tree_parser.set_defaults(func=cmd_tree)
 
+    # rostree graph
+    graph_parser = subparsers.add_parser(
+        "graph",
+        help="Generate a dependency graph (DOT/Mermaid format)",
+        description=(
+            "Generate a visual dependency graph. "
+            "Without arguments, graphs all workspace packages. "
+            "Specify a package name to graph just that package."
+        ),
+    )
+    graph_parser.add_argument(
+        "package",
+        nargs="?",
+        help="Package name to graph (optional; without it, graphs workspace)",
+    )
+    graph_parser.add_argument(
+        "-w",
+        "--workspace",
+        metavar="PATH",
+        help="Scan and graph packages from this workspace path",
+    )
+    graph_parser.add_argument(
+        "-f",
+        "--format",
+        choices=["dot", "mermaid"],
+        default="dot",
+        help="Output format: dot (Graphviz) or mermaid (default: dot)",
+    )
+    graph_parser.add_argument(
+        "-o",
+        "--output",
+        metavar="FILE",
+        help="Output file (default: stdout)",
+    )
+    graph_parser.add_argument(
+        "-d",
+        "--depth",
+        type=int,
+        default=None,
+        help=f"Maximum tree depth (default: {GRAPH_DEFAULT_DEPTH} for workspace, unlimited for single package)",
+    )
+    graph_parser.add_argument(
+        "-r",
+        "--runtime",
+        action="store_true",
+        help="Show only runtime dependencies (depend, exec_depend)",
+    )
+    graph_parser.add_argument(
+        "-s",
+        "--source",
+        action="append",
+        metavar="PATH",
+        help="Additional source directories to scan (can be repeated)",
+    )
+    graph_parser.add_argument(
+        "--no-title",
+        action="store_true",
+        help="Don't include a title in the graph",
+    )
+    graph_parser.add_argument(
+        "--render",
+        choices=["png", "svg", "pdf"],
+        metavar="FORMAT",
+        help="Render to image (png, svg, pdf). Requires Graphviz installed.",
+    )
+    graph_parser.add_argument(
+        "--open",
+        action="store_true",
+        help="Open the rendered image after creation (use with --render)",
+    )
+    graph_parser.set_defaults(func=cmd_graph)
+
     # rostree tui (default if no command)
     tui_parser = subparsers.add_parser(
         "tui",

rostree/tui/app.py

@@ -8,34 +8,27 @@ from typing import Any
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.containers import Horizontal, Vertical
+from textual.containers import Container, Vertical
 from textual.screen import ModalScreen
-from textual.widgets import Button, Footer, Header, Input, Static, Tree
+from textual.widgets import Footer, Header, Input, Static, Tree
 from textual.widgets.tree import TreeNode
 
 from rostree.api import build_tree, list_known_packages_by_source
 
-# Welcome banner: ROSTREE
-WELCOME_BANNER = """
+# Welcome banner: ROSTREE (all lines must be same length for proper centering)
+WELCOME_BANNER = """\
 [bold cyan]
-██████╗  ██████╗ ███████╗████████╗██████╗ ███████╗███████╗
-██╔══██╗██╔═══██╗██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔════╝
-██████╔╝██║   ██║███████╗   ██║   ██████╔╝█████╗  █████╗
-██╔══██╗██║   ██║╚════██║   ██║   ██╔══██╗██╔══╝  ██╔══╝
-██║  ██║╚██████╔╝███████║   ██║   ██║  ██║███████╗███████╗
-╚═╝  ╚═╝ ╚═════╝ ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝
-[/bold cyan]
-"""
-
-WELCOME_BODY = """
-[dim]Visualize ROS 2 package dependencies as a navigable tree.[/]
-
-  • [bold]CLI[/]:  rostree scan, rostree list, rostree tree <pkg>
-  • [bold]TUI[/]:  browse packages, expand/collapse, see details
-  • [bold]Library[/]: Python API for scripts and automation
-
-[dim]Requires ROS 2 env (source install/setup.bash).[/]
-"""
+██████╗   ██████╗  ███████╗ ████████╗ ██████╗  ███████╗ ███████╗
+██╔══██╗ ██╔═══██╗ ██╔════╝ ╚══██╔══╝ ██╔══██╗ ██╔════╝ ██╔════╝
+██████╔╝ ██║   ██║ ███████╗    ██║    ██████╔╝ █████╗   █████╗
+██╔══██╗ ██║   ██║ ╚════██║    ██║    ██╔══██╗ ██╔══╝   ██╔══╝
+██║  ██║ ╚██████╔╝ ███████║    ██║    ██║  ██║ ███████╗ ███████╗
+╚═╝  ╚═╝  ╚═════╝  ╚══════╝    ╚═╝    ╚═╝  ╚═╝ ╚══════╝ ╚══════╝
+[/bold cyan]"""
+
+WELCOME_DESC = """[dim]Navigate and visualize ROS 2 package dependency trees.
+Discover packages from your workspace, system installs, and custom paths.
+Search, expand, and explore the full dependency graph interactively.[/]"""
 
 # Limits to avoid huge trees and crashes
 MAX_PACKAGES_PER_SOURCE = 80  # max package names per source section
@@ -123,50 +116,67 @@ def _expand_to_depth(tn: TreeNode, depth: int, current: int = 0) -> None:
         pass
 
 
-class WelcomeScreen(ModalScreen[bool]):
-    """Welcome / presentation screen. Modal so Enter/q always work."""
+class SearchScreen(ModalScreen[str | None]):
+    """Modal to search for packages/nodes in the tree. Keyboard-only."""
 
     BINDINGS = [
-        Binding("enter", "start", "Start", show=True),
-        Binding("q", "quit", "Quit", show=True),
+        Binding("escape", "cancel", "Cancel", show=True),
     ]
 
     DEFAULT_CSS = """
-    WelcomeScreen {
+    SearchScreen {
         align: center middle;
         padding: 2 4;
     }
-    WelcomeScreen #banner {
+    SearchScreen #search_title {
         text-align: center;
         padding-bottom: 1;
     }
-    WelcomeScreen #welcome_body {
-        padding: 1 2;
+    SearchScreen #search_input {
         width: 60;
+        margin: 1 0;
     }
-    WelcomeScreen #welcome_footer {
+    SearchScreen #search_hint {
         text-align: center;
-        padding-top: 2;
+        padding-top: 1;
     }
     """
 
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._input: Input | None = None
+
     def compose(self) -> ComposeResult:
-        yield Static(WELCOME_BANNER, id="banner", markup=True)
-        yield Static(WELCOME_BODY, id="welcome_body", markup=True)
-        yield Static(
-            "[bold]This screen has focus.[/]  Press [cyan]Enter[/] to start  ·  [dim]q[/] to quit",
-            id="welcome_footer",
-            markup=True,
-        )
+        with Vertical():
+            yield Static(
+                "[bold cyan]Search[/]\n\n"
+                "Type a package name or partial match to find in the tree.",
+                id="search_title",
+                markup=True,
+            )
+            yield Input(
+                placeholder="package name...",
+                id="search_input",
+            )
+            yield Static(
+                "[dim]Enter[/] = Search  ·  [dim]Escape[/] = Cancel\n"
+                "[dim]After search: [bold]n[/bold] = next match, [bold]N[/bold] = previous[/]",
+                id="search_hint",
+                markup=True,
+            )
 
     def on_mount(self) -> None:
-        self.sub_title = "Enter = start · q = quit"
+        self._input = self.query_one("#search_input", Input)
+        self._input.focus()
 
-    def action_start(self) -> None:
-        self.dismiss(True)
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id != "search_input":
+            return
+        value = self._input.value.strip() if self._input else ""
+        self.dismiss(value if value else None)
 
-    def action_quit(self) -> None:
-        self.dismiss(False)
+    def action_cancel(self) -> None:
+        self.dismiss(None)
 
 
 class AddSourceScreen(ModalScreen[Path | None]):
@@ -250,9 +260,15 @@ class DepTreeApp(App[None]):
 
     TITLE = "rostree"
     BINDINGS = [
+        Binding("enter", "start_main", "Start", show=False),
         Binding("escape", "back", "Back", show=True),
         Binding("b", "back", "Back", show=False),
         Binding("a", "add_source", "Add source"),
+        Binding("/", "search", "Search"),
+        Binding("f", "search", "Search", show=False),
+        Binding("n", "next_match", "Next match", show=False),
+        Binding("N", "prev_match", "Prev match", show=False),
+        Binding("d", "toggle_details", "Details"),
         Binding("q", "quit", "Quit"),
         Binding("r", "refresh", "Refresh"),
         Binding("e", "expand_all", "Expand all"),
@@ -265,13 +281,41 @@ class DepTreeApp(App[None]):
         self._root_node: Any = None
         self._main_started = False
         self._extra_source_roots: list[Path] = []
+        self._search_query: str = ""
+        self._search_matches: list[TreeNode] = []
+        self._search_index: int = 0
+        self._details_visible: bool = True
 
     DEFAULT_CSS = """
-    #back_bar {
+    /* Welcome screen styles */
+    #welcome_container {
+        align: center middle;
+        width: 100%;
+        height: 100%;
+    }
+    #welcome_banner {
+        text-align: center;
+        content-align: center middle;
+        width: 100%;
+    }
+    #welcome_desc {
+        text-align: center;
+        padding: 2 4;
+    }
+    #welcome_hint {
+        text-align: center;
+        padding-top: 1;
+    }
+    /* Main view styles */
+    #main_container {
+        display: none;
+    }
+    #nav_hint {
         display: none;
         height: auto;
         padding: 0 1;
         margin-bottom: 1;
+        color: $text-muted;
     }
     #details {
         padding: 1 2;
@@ -283,25 +327,50 @@ class DepTreeApp(App[None]):
 
     def compose(self) -> ComposeResult:
         yield Header(show_clock=False)
-        with Horizontal(id="back_bar"):
-            yield Button("← Back to package list", id="back_btn", variant="primary")
-        yield Tree("Dependencies", id="dep_tree")
-        yield Static(
-            "[dim]↑/↓[/] move  ·  [dim]Enter[/]/[dim]Space[/] select  ·  [dim]Tab[/] = switch focus  ·  [dim]Esc[/]/[dim]b[/] = Back",
-            id="details",
-        )
+        # Welcome view (initial)
+        with Container(id="welcome_container"):
+            yield Static(WELCOME_BANNER, id="welcome_banner", markup=True)
+            yield Static(WELCOME_DESC, id="welcome_desc", markup=True)
+            yield Static(
+                "[cyan]Enter[/] to explore  ·  [dim]q[/] to quit",
+                id="welcome_hint",
+                markup=True,
+            )
+        # Main view (hidden initially)
+        with Container(id="main_container"):
+            yield Static(
+                "[dim]← Press [bold]Esc[/bold] or [bold]b[/bold] to return to package list[/]",
+                id="nav_hint",
+            )
+            yield Tree("Dependencies", id="dep_tree")
+            yield Static(
+                "[dim]↑/↓[/] move  ·  [dim]Enter[/]/[dim]Space[/] select  ·  [dim]Esc[/]/[dim]b[/] = Back",
+                id="details",
+            )
         yield Footer()
 
     def on_mount(self) -> None:
-        self.sub_title = "Tab = move focus · Esc = Back · Keys shown in footer"
-        self.push_screen(WelcomeScreen(), self._on_welcome_done)
-
-    def _on_welcome_done(self, start: bool) -> None:
-        if not start:
-            self.exit(0)
+        self.sub_title = "Dependency Tree Explorer"
+
+    def on_key(self, event: Any) -> None:
+        """Handle key events - specifically Enter on welcome screen."""
+        if not self._main_started and event.key == "enter":
+            event.prevent_default()
+            event.stop()
+            self.action_start_main()
+
+    def action_start_main(self) -> None:
+        """Transition from welcome screen to main view."""
+        if self._main_started:
             return
         self._main_started = True
-        self._start_main()
+        # Hide welcome, show main
+        try:
+            self.query_one("#welcome_container").styles.display = "none"
+            self.query_one("#main_container").styles.display = "block"
+        except Exception:
+            pass
+        self._load_main_view()
 
     def _source_color(self, label: str) -> str:
         if "System" in label:
@@ -314,10 +383,10 @@ class DepTreeApp(App[None]):
             return COLOR_ADDED
         return COLOR_SOURCE
 
-    def _start_main(self) -> None:
+    def _load_main_view(self) -> None:
         try:
             try:
-                self.query_one("#back_bar").styles.display = "none"
+                self.query_one("#nav_hint").styles.display = "none"
             except Exception:
                 pass
             tree = self.query_one("#dep_tree", Tree)
@@ -413,12 +482,9 @@ class DepTreeApp(App[None]):
             _expand_to_depth(tree.root, EXPAND_DEPTH_DEFAULT)
         except Exception:
             pass
-        self._set_details(
-            self._format_node(self._root_node)
-            + "\n\n[dim]Esc[/] or [dim]b[/] = Back to package list  ·  [dim]Tab[/] then [dim]Enter[/] = Back button"
-        )
+        self._set_details(self._format_node(self._root_node))
         try:
-            self.query_one("#back_bar").styles.display = "block"
+            self.query_one("#nav_hint").styles.display = "block"
             self.query_one("#dep_tree", Tree).focus()
         except Exception:
             pass
@@ -468,16 +534,12 @@ class DepTreeApp(App[None]):
         self._root_package = None
         self._root_node = None
         try:
-            self.query_one("#back_bar").styles.display = "none"
+            self.query_one("#nav_hint").styles.display = "none"
         except Exception:
             pass
         tree = self.query_one("#dep_tree", Tree)
         self._clear_tree(tree)
-        self._start_main()
-
-    def on_button_pressed(self, event: Button.Pressed) -> None:
-        if event.button.id == "back_btn":
-            self.action_back()
+        self._load_main_view()
 
     def action_refresh(self) -> None:
         if not self._main_started:
@@ -487,7 +549,7 @@ class DepTreeApp(App[None]):
         else:
             tree = self.query_one("#dep_tree", Tree)
             self._clear_tree(tree)
-            self._start_main()
+            self._load_main_view()
 
     def action_expand_all(self) -> None:
         tree = self.query_one("#dep_tree", Tree)
@@ -524,6 +586,100 @@ class DepTreeApp(App[None]):
         except Exception:
             pass
 
+    def action_search(self) -> None:
+        """Open search modal."""
+        if not self._main_started:
+            return
+        self.push_screen(SearchScreen(), self._on_search_done)
+
+    def _on_search_done(self, query: str | None) -> None:
+        if not query:
+            return
+        self._search_query = query.lower()
+        self._search_matches = []
+        self._search_index = 0
+
+        tree = self.query_one("#dep_tree", Tree)
+        self._collect_matches(tree.root, query.lower())
+
+        if not self._search_matches:
+            self.notify(f"No matches for '{query}'", severity="warning", timeout=2)
+            return
+
+        self.notify(
+            f"Found {len(self._search_matches)} match(es) for '{query}'",
+            severity="information",
+            timeout=2,
+        )
+        self._goto_match(0)
+
+    def _collect_matches(self, node: TreeNode, query: str) -> None:
+        """Recursively collect nodes matching the search query."""
+        label = str(node.label).lower()
+        # Also check the data if it's a string (package name)
+        data_str = str(node.data).lower() if node.data else ""
+        if query in label or query in data_str:
+            self._search_matches.append(node)
+        for child in node.children:
+            self._collect_matches(child, query)
+
+    def _goto_match(self, index: int) -> None:
+        """Navigate to and select a specific match."""
+        if not self._search_matches:
+            return
+        self._search_index = index % len(self._search_matches)
+        match_node = self._search_matches[self._search_index]
+
+        # Expand all ancestors so the node is visible
+        self._expand_ancestors(match_node)
+
+        # Select the node
+        tree = self.query_one("#dep_tree", Tree)
+        tree.select_node(match_node)
+        tree.scroll_to_node(match_node)
+
+        # Show match info
+        total = len(self._search_matches)
+        current = self._search_index + 1
+        self.notify(
+            f"Match {current}/{total}: {match_node.label}",
+            severity="information",
+            timeout=2,
+        )
+
+    def _expand_ancestors(self, node: TreeNode) -> None:
+        """Expand all ancestor nodes to make the target visible."""
+        ancestors = []
+        parent = node.parent
+        while parent is not None:
+            ancestors.append(parent)
+            parent = parent.parent
+        for ancestor in reversed(ancestors):
+            ancestor.expand()
+
+    def action_next_match(self) -> None:
+        """Go to next search match."""
+        if not self._search_matches:
+            self.notify("No active search. Press / to search.", severity="information", timeout=2)
+            return
+        self._goto_match(self._search_index + 1)
+
+    def action_prev_match(self) -> None:
+        """Go to previous search match."""
+        if not self._search_matches:
+            self.notify("No active search. Press / to search.", severity="information", timeout=2)
+            return
+        self._goto_match(self._search_index - 1)
+
+    def action_toggle_details(self) -> None:
+        """Toggle visibility of the details panel."""
+        self._details_visible = not self._details_visible
+        try:
+            details = self.query_one("#details", Static)
+            details.styles.display = "block" if self._details_visible else "none"
+        except Exception:
+            pass
+
     def action_quit(self) -> None:
         self.exit()
 

{rostree-0.1.0.dist-info → rostree-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rostree
-Version: 0.1.0
+Version: 0.2.0
 Summary: Explore ROS 2 package dependencies from the command line (CLI, TUI, library)
 Author: rostree contributors
 License: MIT
@@ -21,9 +21,19 @@ Requires-Dist: black==25.1.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.7; extra == 'viz'
+Requires-Dist: networkx>=3.0; extra == 'viz'
 Description-Content-Type: text/markdown
 
-# rostree
+```
+██████╗  ██████╗ ███████╗████████╗██████╗ ███████╗███████╗
+██╔══██╗██╔═══██╗██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔════╝
+██████╔╝██║   ██║███████╗   ██║   ██████╔╝█████╗  █████╗
+██╔══██╗██║   ██║╚════██║   ██║   ██╔══██╗██╔══╝  ██╔══╝
+██║  ██║╚██████╔╝███████║   ██║   ██║  ██║███████╗███████╗
+╚═╝  ╚═╝ ╚═════╝ ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝
+```
 
 [![CI](https://github.com/guilyx/rostree/actions/workflows/ci.yml/badge.svg)](https://github.com/guilyx/rostree/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/guilyx/rostree/graph/badge.svg)](https://codecov.io/gh/guilyx/rostree)
@@ -54,6 +64,10 @@ rostree list --by-source     # List packages grouped by source
 rostree tree rclpy           # Show dependency tree for a package
 rostree tree rclpy --depth 3 # Limit tree depth
 rostree tree rclpy --json    # Output as JSON
+rostree graph rclpy --render png       # Generate PNG image (requires graphviz)
+rostree graph rclpy --render svg --open # Create SVG and open it
+rostree graph -w ~/ros2_ws --render png # Graph entire workspace to image
+rostree graph rclpy -f mermaid         # Mermaid format (text)
 ```
 
 ### TUI mode

{rostree-0.1.0.dist-info → rostree-0.2.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
 rostree/__init__.py,sha256=6kFb52bjBJQMUbYeGOGuRDKpZjwKPEj1d91pw80xtD8,437
 rostree/api.py,sha256=A2L7uuj3efJXwqazsL9j6y6hgkwxPBnwGv2dYNtFTwg,3646
-rostree/cli.py,sha256=gdRS-Bj_25KQ95fZhD-HRbmQFEJGl7NqnAV4kSnGEGg,9073
+rostree/cli.py,sha256=SXdMznJJuy0wHINgZt3QE2DIinW9EfyahpVVG-berq0,25410
 rostree/core/__init__.py,sha256=glLk6MYQvGz0jTre7cVaQhQ6PiAAWa1lXFFMFnWbHbo,582
 rostree/core/finder.py,sha256=lmfzjjHX-bDHprs3x-GKPztpCS4hVsZUq2fZOg64DTg,16801
 rostree/core/parser.py,sha256=_Yhyjrg7Ir-N80KqJnxPYRcejWepDZDFbw_BTKLBySs,3094
 rostree/core/tree.py,sha256=jBvd7_Pzk4ciO9dWV1r4NyU9q6BaXKiYRimbmK72oD4,4060
 rostree/tui/__init__.py,sha256=hHtp0ZeBL6drxVxnBi1pm2uRds5O-UbNASQ6xRzOJrs,64
-rostree/tui/app.py,sha256=_vj47K70w5ZJFANRisENHk9UXlwH8YBVh_qKwfxgQv8,18678
-rostree-0.1.0.dist-info/METADATA,sha256=2uYP2pwyhSwBw5F1ye-p3jU5L3a3fk6YkiXLI_nggZg,3218
-rostree-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-rostree-0.1.0.dist-info/entry_points.txt,sha256=3FqDola110oRFImx5-IF3CEnfCXA3CDSM2fTzbES2Zo,45
-rostree-0.1.0.dist-info/licenses/LICENSE,sha256=mcuqLv_cT8O1n1fIsOkUNDMnKlrPgP5LVCMyyVl-tGk,1530
-rostree-0.1.0.dist-info/RECORD,,
+rostree/tui/app.py,sha256=xnWip-Ax1b20ZjH3w9Xs-gmnksLboHUMPV_lfLNwktE,24359
+rostree-0.2.0.dist-info/METADATA,sha256=qcIywivlvRxNz7OexDLnEKJ4hS0YsWqkhM1Ii6OXjaE,4552
+rostree-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rostree-0.2.0.dist-info/entry_points.txt,sha256=3FqDola110oRFImx5-IF3CEnfCXA3CDSM2fTzbES2Zo,45
+rostree-0.2.0.dist-info/licenses/LICENSE,sha256=mcuqLv_cT8O1n1fIsOkUNDMnKlrPgP5LVCMyyVl-tGk,1530
+rostree-0.2.0.dist-info/RECORD,,