Passer au contenu
cd /languages
  • Guidé par les conventions
  • Programmation
  • Prise en charge de l’AST et des symboles

Ruby dans Maguyva : des graphes de code pour Rails et les apps Ruby

Maguyva prend en charge Ruby avec AST, symboles et graphe, pour que les agents IA suivent classes, modules, méthodes singleton et instanciations dans Rails et Ruby.

Pourquoi les dépôts Ruby posent problème aux outils d’IA superficiels

Ruby s’appuie fortement sur les conventions et la métaprogrammation. Des méthodes sont générées par attr_accessor, des classes sont rouvertes dans d’autres fichiers, et les espaces de noms imbriquent plusieurs niveaux de modules. La surface lisible cache la méthode qu’un appel atteint réellement, et une recherche textuelle brute renvoie chaque call et chaque perform de l’application.

Maguyva donne à l’agent classes, modules, méthodes et appelants sous forme de structure, pour qu’il suive un changement à travers l’application au lieu de deviner.

Ce que Maguyva extrait en Ruby

Maguyva couvre les fichiers .rb, .rbw, .rake et .gemspec, ainsi que Gemfile et Rakefile. Les méthodes d’instance et les méthodes singleton (def self.call) sont extraites, les méthodes singleton étant marquées comme statiques. Les déclarations attr_reader, attr_writer et attr_accessor comptent comme méthodes d’accès, et les symboles sont qualifiés par leur espace de noms de module et de classe.

ClassName.new et Namespace::ClassName.new comptent comme instanciation, et le typage des receveurs suit les affectations locales et les @instance_variables, de sorte qu’un appel sur un objet affecté peut se résoudre vers sa classe. Le graphe enregistre aussi l’héritage, l’inclusion de modules, les surcharges, les arêtes raise et rescue, ainsi que les lectures et écritures.

Les appels de métaprogrammation (define_method, send, method_missing, class_eval et similaires), les helpers de type T:: de Sorbet et les appels énumérables courants (each, collect, reject et similaires) sont filtrés des relations pour faire ressortir le code applicatif.

Exemples de prompts pour agents

  • « Qui appelle Billing::ChargeCustomer.call, et depuis quels jobs et contrôleurs ? » (find_symbol, puis dependency_search en incoming)
  • « Quels modèles héritent de ApplicationRecord et incluent Auditable ? » (dependency_search)
  • « Retrace ce qui se passe après qu’une commande est marquée comme payée. » (get_task_context)

Limites connues

  • En Ruby, require et load sont des appels de méthode ordinaires ; le préréglage imports de structural_search ne sélectionne donc rien. Utilisez text_pattern_search pour les lister.
  • Les méthodes créées à l’exécution avec define_method ou traitées par method_missing ne sont pas extraites comme symboles, et ces appels sont filtrés comme bruit de métaprogrammation.
  • Ruby n’a pas de syntaxe de décorateur ; les relations de décorateur sont donc marquées comme non applicables.

Étapes suivantes

Connectez un dépôt avec le démarrage rapide, puis consultez la matrice de prise en charge sur la page de compatibilité. Pour d’autres dépôts en langages dynamiques, comparez avec le guide Python.

Idéal pour

  • > Les monolithes Rails où modèles, objets de service, jobs et concerns s'appellent à travers de nombreux répertoires.
  • > Les gems et services Ruby aux espaces de noms de modules profonds et aux classes de base partagées.
  • > Les équipes qui veulent circonscrire un changement avec un agent IA avant de toucher un modèle ou un service dont dépend la moitié de l'application.

Workflows d'agent

  • > Trouver tous les appelants d'un objet de service ou d'une méthode de modèle avant d'en changer le comportement.
  • > Retracer où une classe est instanciée avec `.new` et quelles méthodes s'exécutent ensuite.
  • > Cartographier les classes qui héritent d'une classe de base ou incluent un module avant un refactoring.

Détails du moteur

  • > La prise en charge de Ruby couvre `.rb`, `.rbw`, `.rake`, `.gemspec`, `Gemfile` et `Rakefile`. Les méthodes singleton sont marquées statiques, et les déclarations `attr_*` comptent comme méthodes d'accès.
  • > `ClassName.new` compte comme instanciation, et le typage des receveurs suit les affectations locales et les variables d'instance.
  • > Les appels de métaprogrammation comme `define_method` et `send`, les helpers `T::` de Sorbet et les appels énumérables courants sont filtrés des relations.

Points d'entrée MCP utiles

  • find_symbol

    Utilisez-le pour une classe, un module ou une méthode avec espace de noms, comme `Billing::ChargeCustomer.call`.

  • dependency_search

    Utilisez la traversée incoming sur un modèle ou un objet de service pour voir appelants et sous-classes avant un changement.

  • text_pattern_search

    Utilisez-le pour les chemins `require`, les chaînes de routes et les méthodes définies dynamiquement que le graphe ne voit pas.