feat(#94): add topic-based component discovery

  Add hybrid discovery that creates virtual components from topic namespaces
  when ROS 2 nodes are not available (e.g., Isaac Sim publishing topics
  without creating discoverable nodes).

  Changes:
  - Add  field to Component struct (node or topic)
  - Add discover_topic_namespaces() to extract namespaces from topics
  - Add get_topics_for_namespace() to get topics under a namespace
  - Add is_system_topic() to filter /parameter_events, /rosout, /clock
  - Add discover_topic_components() to create virtual components
  - Update discover_areas() to include topic-based namespaces
  - Update refresh_cache() to merge node-based and topic-based components

Author: mfaferek93

.devcontainer/devcontainer.json

@@ -1,5 +1,6 @@
 {
   "name": "ROS2 ros2_medkit Development",
+  "runArgs": ["--network=host"],
   "build": {
     "dockerfile": "Dockerfile",
     "context": "..",

src/ros2_medkit_gateway/include/ros2_medkit_gateway/discovery_manager.hpp

@@ -18,6 +18,7 @@
 #include <memory>
 #include <optional>
 #include <rclcpp/rclcpp.hpp>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -34,6 +35,25 @@ class DiscoveryManager {
   std::vector<Area> discover_areas();
   std::vector<Component> discover_components();
 
+  /**
+   * @brief Discover components from topic namespaces (topic-based discovery)
+   *
+   * Creates "virtual" components for topic namespaces that don't have
+   * corresponding ROS 2 nodes. This is useful for systems like Isaac Sim
+   * that publish topics without creating proper ROS 2 nodes.
+   *
+   * Example: Topics ["/carter1/odom", "/carter1/cmd_vel", "/carter2/odom"]
+   * Creates components: carter1, carter2 (if no matching nodes exist)
+   *
+   * Components are created with:
+   * - id: namespace name (e.g., "carter1")
+   * - source: "topic" (to distinguish from node-based components)
+   * - topics.publishes: all topics under this namespace
+   *
+   * @return Vector of topic-based components (excludes namespaces with existing nodes)
+   */
+  std::vector<Component> discover_topic_components();
+
   /// Discover all services in the system with their types
   std::vector<ServiceInfo> discover_services();
 
@@ -87,6 +107,9 @@ class DiscoveryManager {
   /// Extract the last segment from a path (e.g., "/a/b/c" -> "c")
   std::string extract_name_from_path(const std::string & path);
 
+  /// Get set of namespaces that have ROS 2 nodes (for deduplication)
+  std::set<std::string> get_node_namespaces();
+
   /// Check if a service path belongs to a component namespace
   bool path_belongs_to_namespace(const std::string & path, const std::string & ns) const;
 

src/ros2_medkit_gateway/include/ros2_medkit_gateway/models.hpp

@@ -147,13 +147,14 @@ struct Component {
   std::string fqn;
   std::string type = "Component";
   std::string area;
+  std::string source = "node";  ///< Discovery source: "node" or "topic"
   std::vector<ServiceInfo> services;
   std::vector<ActionInfo> actions;
   ComponentTopics topics;  ///< Topics this component publishes/subscribes
 
   json to_json() const {
-    json j = {{"id", id},     {"namespace", namespace_path}, {"fqn", fqn}, {"type", type},
-              {"area", area}, {"topics", topics.to_json()}};
+    json j = {{"id", id},         {"namespace", namespace_path}, {"fqn", fqn}, {"type", type}, {"area", area},
+              {"source", source}, {"topics", topics.to_json()}};
 
     // Add operations array combining services and actions
     json operations = json::array();

src/ros2_medkit_gateway/include/ros2_medkit_gateway/native_topic_sampler.hpp

@@ -20,6 +20,7 @@
 #include <nlohmann/json.hpp>
 #include <optional>
 #include <rclcpp/rclcpp.hpp>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ -199,6 +200,49 @@ class NativeTopicSampler {
    */
   ComponentTopics get_component_topics(const std::string & component_fqn);
 
+  /**
+   * @brief Discover unique namespace prefixes from all topics
+   *
+   * Extracts the first segment of each topic path to identify namespaces.
+   * Used for topic-based component discovery when nodes are not available
+   * (e.g., Isaac Sim publishing topics without creating ROS 2 nodes).
+   *
+   * Example: Topics ["/carter1/odom", "/carter2/cmd_vel", "/tf"]
+   * Returns: {"carter1", "carter2"} (root topics like /tf are excluded)
+   *
+   * @return Set of unique namespace prefixes (without leading slash)
+   */
+  std::set<std::string> discover_topic_namespaces();
+
+  /**
+   * @brief Get all topics under a specific namespace prefix
+   *
+   * Returns ComponentTopics containing all topics that start with the given
+   * namespace prefix. For topic-based discovery, all matched topics are
+   * placed in the 'publishes' list since direction cannot be determined
+   * without node information.
+   *
+   * @param ns_prefix Namespace prefix including leading slash (e.g., "/carter1")
+   * @return ComponentTopics with matching topics in publishes list
+   */
+  ComponentTopics get_topics_for_namespace(const std::string & ns_prefix);
+
+  /**
+   * @brief Check if a topic is a ROS 2 system/infrastructure topic
+   *
+   * System topics are filtered out during topic-based discovery to avoid
+   * creating spurious components. Filtered topics include:
+   * - /parameter_events
+   * - /rosout
+   * - /clock
+   *
+   * Note: /tf and /tf_static are NOT filtered (useful for diagnostics).
+   *
+   * @param topic_name Full topic path
+   * @return true if this is a system topic that should be filtered
+   */
+  static bool is_system_topic(const std::string & topic_name);
+
  private:
   /**
    * @brief Parse YAML-formatted message string to JSON

src/ros2_medkit_gateway/src/discovery_manager.cpp

@@ -51,6 +51,14 @@ std::vector<Area> DiscoveryManager::discover_areas() {
     area_set.insert(area);
   }
 
+  // Also include areas from topic namespaces (for topic-based discovery)
+  if (topic_sampler_) {
+    auto topic_namespaces = topic_sampler_->discover_topic_namespaces();
+    for (const auto & ns : topic_namespaces) {
+      area_set.insert(ns);
+    }
+  }
+
   // Convert set to vector of Area structs
   std::vector<Area> areas;
   for (const auto & area_name : area_set) {
@@ -360,6 +368,67 @@ std::string DiscoveryManager::extract_name_from_path(const std::string & path) {
   return path;
 }
 
+std::set<std::string> DiscoveryManager::get_node_namespaces() {
+  std::set<std::string> namespaces;
+
+  auto node_graph = node_->get_node_graph_interface();
+  auto names_and_namespaces = node_graph->get_node_names_and_namespaces();
+
+  for (const auto & name_and_ns : names_and_namespaces) {
+    std::string ns = name_and_ns.second;
+    std::string area = extract_area_from_namespace(ns);
+    if (area != "root") {
+      namespaces.insert(area);
+    }
+  }
+
+  return namespaces;
+}
+
+std::vector<Component> DiscoveryManager::discover_topic_components() {
+  std::vector<Component> components;
+
+  if (!topic_sampler_) {
+    RCLCPP_DEBUG(node_->get_logger(), "Topic sampler not set, skipping topic-based discovery");
+    return components;
+  }
+
+  // Get namespaces from topics
+  auto topic_namespaces = topic_sampler_->discover_topic_namespaces();
+
+  // Get namespaces that already have nodes (to avoid duplicates)
+  auto node_namespaces = get_node_namespaces();
+
+  RCLCPP_DEBUG(node_->get_logger(), "Topic-based discovery: %zu topic namespaces, %zu node namespaces",
+               topic_namespaces.size(), node_namespaces.size());
+
+  for (const auto & ns : topic_namespaces) {
+    // Skip if there's already a node with this namespace
+    if (node_namespaces.count(ns) > 0) {
+      RCLCPP_DEBUG(node_->get_logger(), "Skipping namespace '%s' - already has nodes", ns.c_str());
+      continue;
+    }
+
+    Component comp;
+    comp.id = ns;
+    comp.namespace_path = "/" + ns;
+    comp.fqn = "/" + ns;
+    comp.area = ns;
+    comp.source = "topic";
+
+    // Get topics for this namespace
+    comp.topics = topic_sampler_->get_topics_for_namespace("/" + ns);
+
+    RCLCPP_DEBUG(node_->get_logger(), "Created topic-based component '%s' with %zu topics", ns.c_str(),
+                 comp.topics.publishes.size());
+
+    components.push_back(comp);
+  }
+
+  RCLCPP_INFO(node_->get_logger(), "Discovered %zu topic-based components", components.size());
+  return components;
+}
+
 bool DiscoveryManager::path_belongs_to_namespace(const std::string & path, const std::string & ns) const {
   if (ns.empty() || ns == "/") {
     // Root namespace - check if path has only one segment after leading slash

src/ros2_medkit_gateway/src/gateway_node.cpp

@@ -171,22 +171,37 @@ void GatewayNode::refresh_cache() {
 
     // Discover data outside the lock to minimize lock time
     auto areas = discovery_mgr_->discover_areas();
-    auto components = discovery_mgr_->discover_components();
+
+    // Discover node-based components (standard ROS 2 nodes)
+    auto node_components = discovery_mgr_->discover_components();
+
+    // Discover topic-based components (for systems like Isaac Sim that
+    // publish topics without creating proper ROS 2 nodes)
+    auto topic_components = discovery_mgr_->discover_topic_components();
+
+    // Merge both component lists
+    std::vector<Component> all_components;
+    all_components.reserve(node_components.size() + topic_components.size());
+    all_components.insert(all_components.end(), node_components.begin(), node_components.end());
+    all_components.insert(all_components.end(), topic_components.begin(), topic_components.end());
+
     auto timestamp = std::chrono::system_clock::now();
 
     // Capture sizes before move for logging
     const size_t area_count = areas.size();
-    const size_t component_count = components.size();
+    const size_t node_component_count = node_components.size();
+    const size_t topic_component_count = topic_components.size();
 
     // Lock only for the actual cache update
     {
       std::lock_guard<std::mutex> lock(cache_mutex_);
       entity_cache_.areas = std::move(areas);
-      entity_cache_.components = std::move(components);
+      entity_cache_.components = std::move(all_components);
       entity_cache_.last_update = timestamp;
     }
 
-    RCLCPP_DEBUG(get_logger(), "Cache refreshed: %zu areas, %zu components", area_count, component_count);
+    RCLCPP_DEBUG(get_logger(), "Cache refreshed: %zu areas, %zu components (%zu node-based, %zu topic-based)",
+                 area_count, node_component_count + topic_component_count, node_component_count, topic_component_count);
   } catch (const std::exception & e) {
     RCLCPP_ERROR(get_logger(), "Failed to refresh cache: %s", e.what());
   } catch (...) {

src/ros2_medkit_gateway/src/native_topic_sampler.cpp

@@ -501,4 +501,69 @@ ComponentTopics NativeTopicSampler::get_component_topics(const std::string & com
   return ComponentTopics{};
 }
 
+bool NativeTopicSampler::is_system_topic(const std::string & topic_name) {
+  // System topics to filter out during topic-based discovery
+  // Note: /tf and /tf_static are NOT filtered (useful for diagnostics)
+  static const std::vector<std::string> system_topics = {"/parameter_events", "/rosout", "/clock"};
+
+  return std::find(system_topics.begin(), system_topics.end(), topic_name) != system_topics.end();
+}
+
+std::set<std::string> NativeTopicSampler::discover_topic_namespaces() {
+  std::set<std::string> namespaces;
+
+  auto all_topics = node_->get_topic_names_and_types();
+
+  for (const auto & [topic_name, types] : all_topics) {
+    // Skip system topics
+    if (is_system_topic(topic_name)) {
+      continue;
+    }
+
+    // Extract first segment from topic path
+    // "/carter1/odom" -> "carter1"
+    // "/tf" -> "" (root topic, skip)
+    if (topic_name.length() > 1 && topic_name[0] == '/') {
+      // Find the second slash
+      size_t second_slash = topic_name.find('/', 1);
+      if (second_slash != std::string::npos) {
+        // Has namespace: "/carter1/odom" -> "carter1"
+        std::string ns = topic_name.substr(1, second_slash - 1);
+        if (!ns.empty()) {
+          namespaces.insert(ns);
+        }
+      }
+      // else: root topic like "/tf", skip (no namespace)
+    }
+  }
+
+  RCLCPP_DEBUG(node_->get_logger(), "Discovered %zu topic namespaces", namespaces.size());
+  return namespaces;
+}
+
+ComponentTopics NativeTopicSampler::get_topics_for_namespace(const std::string & ns_prefix) {
+  ComponentTopics topics;
+
+  auto all_topics = node_->get_topic_names_and_types();
+
+  for (const auto & [topic_name, types] : all_topics) {
+    // Skip system topics
+    if (is_system_topic(topic_name)) {
+      continue;
+    }
+
+    // Check if topic starts with namespace prefix followed by '/'
+    // ns_prefix is like "/carter1", topic is like "/carter1/odom"
+    if (topic_name.length() > ns_prefix.length() && topic_name.find(ns_prefix) == 0 &&
+        topic_name[ns_prefix.length()] == '/') {
+      // For topic-based discovery, we put all topics in 'publishes'
+      // since we can't determine direction without node info
+      topics.publishes.push_back(topic_name);
+    }
+  }
+
+  RCLCPP_DEBUG(node_->get_logger(), "Found %zu topics for namespace '%s'", topics.publishes.size(), ns_prefix.c_str());
+  return topics;
+}
+
 }  // namespace ros2_medkit_gateway