claude-flow-novice 2.18.13 → 2.18.14

package/.claude/skills/cfn-local-ruvector-accelerator/src/extractors/mod.rs

@@ -0,0 +1,251 @@
+//! AST extractors for different programming languages
+//!
+//! This module contains language-specific extractors that parse source code
+//! using tree-sitter and extract structured information about entities and references.
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+
+pub mod rust;
+pub mod typescript;
+pub mod text_fallback;
+
+/// Create a Rust extractor instance
+pub fn create_rust_extractor() -> Result<rust::RustExtractor> {
+    rust::RustExtractor::new()
+}
+
+/// Create a TypeScript extractor instance
+pub fn create_typescript_extractor() -> Result<typescript::TypeScriptExtractor> {
+    typescript::TypeScriptExtractor::new()
+}
+
+/// Create a text fallback extractor instance
+pub fn create_text_fallback_extractor() -> Result<text_fallback::TextFallbackExtractor> {
+    text_fallback::TextFallbackExtractor::new()
+}
+
+/// Common entity kinds across languages
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum EntityKind {
+    // Functions
+    Function,
+    Method,
+    Constructor,
+    Getter,
+    Setter,
+
+    // Types
+    Class,
+    Interface,
+    Struct,
+    Enum,
+    TypeAlias,
+    Trait,
+
+    // Modules
+    Module,
+    Namespace,
+
+    // Variables
+    Variable,
+    Constant,
+    Parameter,
+
+    // Other
+    Import,
+}
+
+impl EntityKind {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            EntityKind::Function => "function",
+            EntityKind::Method => "method",
+            EntityKind::Constructor => "constructor",
+            EntityKind::Getter => "getter",
+            EntityKind::Setter => "setter",
+            EntityKind::Class => "class",
+            EntityKind::Interface => "interface",
+            EntityKind::Struct => "struct",
+            EntityKind::Enum => "enum",
+            EntityKind::TypeAlias => "typealias",
+            EntityKind::Trait => "trait",
+            EntityKind::Module => "module",
+            EntityKind::Namespace => "namespace",
+            EntityKind::Variable => "variable",
+            EntityKind::Constant => "constant",
+            EntityKind::Parameter => "parameter",
+            EntityKind::Import => "import",
+        }
+    }
+}
+
+/// Reference kinds between entities
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum RefKind {
+    Calls,           // Function calls
+    Extends,         // Class inheritance
+    Implements,      // Interface implementation
+    Imports,         // Import statements
+    Uses,            // Type usage
+    Instantiates,    // Class instantiation (new)
+    Overrides,       // Method overriding
+    Reads,           // Variable read
+    Writes,          // Variable write
+}
+
+/// Visibility levels
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Visibility {
+    Public,
+    Private,
+    Protected,
+    Internal,
+    FilePrivate,
+}
+
+/// A extracted code entity
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Entity {
+    pub id: String,              // Unique identifier
+    pub kind: EntityKind,        // Type of entity
+    pub name: String,            // Entity name
+    pub file_path: String,       // Source file path
+    pub line: usize,             // Line number (0-indexed)
+    pub column: usize,           // Column number (0-indexed)
+    pub signature: String,       // Full signature including params/types
+    pub visibility: Visibility,  // Visibility level
+    pub parent_id: Option<String>, // Parent entity if nested
+    pub metadata: HashMap<String, String>, // Language-specific metadata
+}
+
+/// A reference between entities
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Reference {
+    pub id: String,              // Unique identifier
+    pub file_path: String,       // Source file path
+    pub line: usize,             // Line number (0-indexed)
+    pub column: usize,           // Column number (0-indexed)
+    pub ref_kind: RefKind,       // Type of reference
+    pub source_id: Option<String>, // Source entity (if applicable)
+    pub target_name: String,     // Target entity name
+    pub target_file: Option<String>, // Target file if known
+    pub metadata: HashMap<String, String>, // Additional context
+}
+
+/// Result of extraction
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExtractionResult {
+    pub entities: Vec<Entity>,
+    pub references: Vec<Reference>,
+    pub errors: Vec<String>,
+}
+
+/// Trait for language-specific extractors
+pub trait Extractor: Send + Sync {
+    /// Extract entities and references from source code
+    fn extract(&mut self, file_path: &str, source: &str) -> Result<ExtractionResult>;
+
+    /// Get the file extensions this extractor handles
+    fn extensions(&self) -> &[&str];
+
+    /// Get the language name
+    fn language(&self) -> &str;
+}
+
+/// Utility functions for extractors
+pub mod utils {
+    use super::*;
+    
+use tree_sitter::Node;
+
+    /// Get the text content of a node
+    pub fn node_text<'a>(node: &Node, source: &'a str) -> &'a str {
+        &source[node.start_byte()..node.end_byte()]
+    }
+
+    /// Get the text of a named child by field name
+    pub fn child_text<'a>(node: &Node, source: &'a str, field: &str) -> Option<&'a str> {
+        node.child_by_field_name(field)
+            .map(|child| node_text(&child, source))
+    }
+
+    /// Extract identifier name from node
+    pub fn extract_name(node: &Node, source: &str) -> Option<String> {
+        let name_node = node.child_by_field_name("name")
+            .or_else(|| node.child_by_field_name("property"))
+            .or_else(|| node.child_by_field_name("binding"));
+
+        name_node.map(|n| node_text(&n, source).trim().to_string())
+    }
+
+    /// Extract visibility from modifiers
+    pub fn extract_visibility(node: &Node, _source: &str, default: Visibility) -> Visibility {
+        // Check for visibility modifiers in children
+        let mut cursor = node.walk();
+        for child in node.children(&mut cursor) {
+            match child.kind() {
+                "public" | "export" => return Visibility::Public,
+                "private" => return Visibility::Private,
+                "protected" => return Visibility::Protected,
+                "internal" => return Visibility::Internal,
+                _ => {}
+            }
+        }
+        default
+    }
+
+    /// Generate unique ID for entity
+    pub fn generate_entity_id(file_path: &str, line: usize, name: &str) -> String {
+        format!("{}:{}:{}", file_path.replace(':', "_"), line, name)
+    }
+
+    /// Generate unique ID for reference
+    pub fn generate_ref_id(file_path: &str, line: usize, column: usize) -> String {
+        format!("ref:{}:{}:{}", file_path.replace(':', "_"), line, column)
+    }
+
+    /// Check if node is exported
+    pub fn is_exported(node: &Node) -> bool {
+        let mut cursor = node.walk();
+        for child in node.children(&mut cursor) {
+            if child.kind() == "export" || child.kind() == "export_statement" {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Extract type annotation
+    pub fn extract_type_annotation(node: &Node, source: &str) -> Option<String> {
+        if let Some(type_node) = node.child_by_field_name("type") {
+            Some(node_text(&type_node, source).trim().to_string())
+        } else {
+            None
+        }
+    }
+
+    /// Extract parameters from a parameter list
+    pub fn extract_parameters(node: &Node, source: &str) -> Vec<(String, Option<String>)> {
+        let mut params = Vec::new();
+
+        if let Some(param_list) = node.child_by_field_name("parameters") {
+            let mut cursor = param_list.walk();
+            for child in param_list.named_children(&mut cursor) {
+                if child.kind() == "required_parameter"
+                   || child.kind() == "optional_parameter"
+                   || child.kind() == "rest_parameter"
+                   || child.kind() == "parameter" {
+                    if let Some(name) = extract_name(&child, source) {
+                        let type_annot = extract_type_annotation(&child, source);
+                        params.push((name, type_annot));
+                    }
+                }
+            }
+        }
+
+        params
+    }
+}

package/.claude/skills/cfn-local-ruvector-accelerator/src/extractors/rust.rs

@@ -0,0 +1,425 @@
+//! Rust AST extractor implementation
+//!
+//! Extracts entities and references from Rust source code using tree-sitter-rust.
+
+use anyhow::{Result, anyhow};
+use crate::extractors::*;
+use tree_sitter::{Parser, Node};
+
+/// Rust extractor implementation
+pub struct RustExtractor {
+    parser: Parser,
+}
+
+impl Clone for RustExtractor {
+    fn clone(&self) -> Self {
+        // Create a new parser instance since tree_sitter::Parser doesn't implement Clone
+        let mut parser = Parser::new();
+        // Note: we can't recover the language from the parser, so we set it again
+        parser.set_language(tree_sitter_rust::language()).ok();
+        Self { parser }
+    }
+}
+
+impl RustExtractor {
+    /// Create a new Rust extractor
+    pub fn new() -> Result<Self> {
+        let mut parser = Parser::new();
+        parser.set_language(tree_sitter_rust::language())?;
+
+        Ok(Self { parser })
+    }
+
+    /// Extract function entity
+    fn extract_function(&self, node: &Node, source: &str, file_path: &str) -> Option<Entity> {
+        if node.kind() != "function_item" {
+            return None;
+        }
+
+        let name = node.child_by_field_name("name")?;
+        let name_text = utils::node_text(&name, source);
+
+        let signature = source[node.start_byte()..node.end_byte()].to_string();
+
+        let visibility = if utils::extract_visibility(node, source, Visibility::Private) == Visibility::Public {
+            Visibility::Public
+        } else {
+            Visibility::Private
+        };
+
+        Some(Entity {
+            id: utils::generate_entity_id(file_path, node.start_position().row, name_text),
+            kind: EntityKind::Function,
+            name: name_text.to_string(),
+            file_path: file_path.to_string(),
+            line: node.start_position().row,
+            column: node.start_position().column,
+            signature,
+            visibility,
+            parent_id: None,
+            metadata: {
+                let mut meta = std::collections::HashMap::new();
+
+                // Extract parameters
+                if let Some(params) = node.child_by_field_name("parameters") {
+                    let param_list = utils::extract_parameters(&params, source);
+                    let param_names: Vec<String> = param_list.iter().map(|(name, _)| name.clone()).collect();
+                    meta.insert("parameters".to_string(), param_names.join(", "));
+                }
+
+                // Extract return type
+                if let Some(ret_type) = node.child_by_field_name("return_type") {
+                    if let Some(type_text) = utils::extract_type_annotation(&ret_type, source) {
+                        meta.insert("return_type".to_string(), type_text);
+                    }
+                }
+
+                meta
+            },
+        })
+    }
+
+    /// Extract struct entity
+    fn extract_struct(&self, node: &Node, source: &str, file_path: &str) -> Option<Entity> {
+        if node.kind() != "struct_item" {
+            return None;
+        }
+
+        let name = node.child_by_field_name("name")?;
+        let name_text = utils::node_text(&name, source);
+
+        let signature = source[node.start_byte()..node.end_byte()].to_string();
+
+        let visibility = if utils::extract_visibility(node, source, Visibility::Private) == Visibility::Public {
+            Visibility::Public
+        } else {
+            Visibility::Private
+        };
+
+        Some(Entity {
+            id: utils::generate_entity_id(file_path, node.start_position().row, name_text),
+            kind: EntityKind::Struct,
+            name: name_text.to_string(),
+            file_path: file_path.to_string(),
+            line: node.start_position().row,
+            column: node.start_position().column,
+            signature,
+            visibility,
+            parent_id: None,
+            metadata: {
+                let mut meta = std::collections::HashMap::new();
+
+                // Extract fields
+                if let Some(field_list) = node.child_by_field_name("body") {
+                    let mut cursor = field_list.walk();
+                    let mut field_num = 0;
+                    for child in field_list.named_children(&mut cursor) {
+                        if child.kind() == "field_declaration" {
+                            if let Some(field_name) = utils::extract_name(&child, source) {
+                                if let Some(field_type) = utils::extract_type_annotation(&child, source) {
+                                    meta.insert(format!("field_{}", field_num),
+                                            format!("{}: {}", field_name, field_type));
+                                    field_num += 1;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                meta
+            },
+        })
+    }
+
+    /// Extract trait entity
+    fn extract_trait(&self, node: &Node, source: &str, file_path: &str) -> Option<Entity> {
+        if node.kind() != "trait_item" {
+            return None;
+        }
+
+        let name = node.child_by_field_name("name")?;
+        let name_text = utils::node_text(&name, source);
+
+        let signature = source[node.start_byte()..node.end_byte()].to_string();
+
+        let visibility = if utils::extract_visibility(node, source, Visibility::Private) == Visibility::Public {
+            Visibility::Public
+        } else {
+            Visibility::Private
+        };
+
+        Some(Entity {
+            id: utils::generate_entity_id(file_path, node.start_position().row, name_text),
+            kind: EntityKind::Trait,
+            name: name_text.to_string(),
+            file_path: file_path.to_string(),
+            line: node.start_position().row,
+            column: node.start_position().column,
+            signature,
+            visibility,
+            parent_id: None,
+            metadata: std::collections::HashMap::new(),
+        })
+    }
+
+    /// Extract impl block
+    fn extract_impl(&self, node: &Node, source: &str, file_path: &str) -> Option<Entity> {
+        if node.kind() != "impl_item" {
+            return None;
+        }
+
+        let type_name = node.child_by_field_name("type")?;
+        let type_text = utils::node_text(&type_name, source);
+
+        let signature = source[node.start_byte()..node.end_byte()].to_string();
+
+        Some(Entity {
+            id: utils::generate_entity_id(file_path, node.start_position().row, type_text),
+            kind: EntityKind::Class, // Use Class for impl blocks
+            name: type_text.to_string(),
+            file_path: file_path.to_string(),
+            line: node.start_position().row,
+            column: node.start_position().column,
+            signature,
+            visibility: Visibility::Public,
+            parent_id: None,
+            metadata: {
+                let mut meta = std::collections::HashMap::new();
+
+                // Check if it's a trait implementation
+                if let Some(trait_type) = node.child_by_field_name("trait") {
+                    let trait_text = utils::node_text(&trait_type, source);
+                    meta.insert("trait".to_string(), trait_text.to_string());
+                }
+
+                meta
+            },
+        })
+    }
+
+    /// Extract enum entity
+    fn extract_enum(&self, node: &Node, source: &str, file_path: &str) -> Option<Entity> {
+        if node.kind() != "enum_item" {
+            return None;
+        }
+
+        let name = node.child_by_field_name("name")?;
+        let name_text = utils::node_text(&name, source);
+
+        let signature = source[node.start_byte()..node.end_byte()].to_string();
+
+        let visibility = if utils::extract_visibility(node, source, Visibility::Private) == Visibility::Public {
+            Visibility::Public
+        } else {
+            Visibility::Private
+        };
+
+        Some(Entity {
+            id: utils::generate_entity_id(file_path, node.start_position().row, name_text),
+            kind: EntityKind::Enum,
+            name: name_text.to_string(),
+            file_path: file_path.to_string(),
+            line: node.start_position().row,
+            column: node.start_position().column,
+            signature,
+            visibility,
+            parent_id: None,
+            metadata: std::collections::HashMap::new(),
+        })
+    }
+
+    /// Extract references (function calls, type usage, etc.)
+    fn extract_references(&self, node: &Node, source: &str, file_path: &str) -> Vec<Reference> {
+        let mut references = Vec::new();
+
+        match node.kind() {
+            "call_expression" => {
+                // Extract function call reference
+                if let Some(func_node) = node.child_by_field_name("function") {
+                    let func_text = utils::node_text(&func_node, source);
+
+                    // Handle simple identifiers
+                    if func_node.kind() == "identifier" {
+                        references.push(Reference {
+                            id: utils::generate_ref_id(file_path, node.start_position().row, node.start_position().column),
+                            file_path: file_path.to_string(),
+                            line: node.start_position().row,
+                            column: node.start_position().column,
+                            ref_kind: RefKind::Calls,
+                            source_id: None,
+                            target_name: func_text.to_string(),
+                            target_file: None,
+                            metadata: std::collections::HashMap::new(),
+                        });
+                    }
+                    // Handle field expressions (e.g., module::function)
+                    else if func_node.kind() == "field_expression" {
+                        if let Some(field_node) = func_node.child_by_field_name("field") {
+                            let field_text = utils::node_text(&field_node, source);
+                            references.push(Reference {
+                                id: utils::generate_ref_id(file_path, node.start_position().row, node.start_position().column),
+                                file_path: file_path.to_string(),
+                                line: node.start_position().row,
+                                column: node.start_position().column,
+                                ref_kind: RefKind::Calls,
+                                source_id: None,
+                                target_name: field_text.to_string(),
+                                target_file: None,
+                                metadata: std::collections::HashMap::new(),
+                            });
+                        }
+                    }
+                }
+            }
+
+            "type_identifier" => {
+                // Extract type usage
+                let type_text = utils::node_text(&node, source);
+                references.push(Reference {
+                    id: utils::generate_ref_id(file_path, node.start_position().row, node.start_position().column),
+                    file_path: file_path.to_string(),
+                    line: node.start_position().row,
+                    column: node.start_position().column,
+                    ref_kind: RefKind::Uses,
+                    source_id: None,
+                    target_name: type_text.to_string(),
+                    target_file: None,
+                    metadata: std::collections::HashMap::new(),
+                });
+            }
+
+            "use_declaration" => {
+                // Extract import reference
+                if let Some(path_node) = node.child_by_field_name("path") {
+                    let path_text = utils::node_text(&path_node, source);
+
+                    // Get the last segment of the path
+                    let segments: Vec<&str> = path_text.split("::").collect();
+                    if let Some(last_segment) = segments.last() {
+                        references.push(Reference {
+                            id: utils::generate_ref_id(file_path, node.start_position().row, node.start_position().column),
+                            file_path: file_path.to_string(),
+                            line: node.start_position().row,
+                            column: node.start_position().column,
+                            ref_kind: RefKind::Imports,
+                            source_id: None,
+                            target_name: last_segment.to_string(),
+                            target_file: None,
+                            metadata: {
+                                let mut meta = std::collections::HashMap::new();
+                                meta.insert("full_path".to_string(), path_text.to_string());
+                                meta
+                            },
+                        });
+                    }
+                }
+            }
+
+            _ => {}
+        }
+
+        // Recursively check children
+        let mut cursor = node.walk();
+        for child in node.children(&mut cursor) {
+            references.extend(self.extract_references(&child, source, file_path));
+        }
+
+        references
+    }
+}
+
+impl Extractor for RustExtractor {
+    fn extract(&mut self, file_path: &str, source: &str) -> Result<ExtractionResult> {
+        let tree = self.parser.parse(source, None)
+            .ok_or_else(|| anyhow!("Failed to parse Rust code"))?;
+
+        let root = tree.root_node();
+        let mut entities = Vec::new();
+        let mut references = Vec::new();
+        let mut errors = Vec::new();
+
+        // Walk the tree and extract entities
+        let mut cursor = root.walk();
+        for node in root.children(&mut cursor) {
+            match node.kind() {
+                "function_item" => {
+                    if let Some(entity) = self.extract_function(&node, source, file_path) {
+                        entities.push(entity);
+                    }
+                }
+                "struct_item" => {
+                    if let Some(entity) = self.extract_struct(&node, source, file_path) {
+                        entities.push(entity);
+                    }
+                }
+                "trait_item" => {
+                    if let Some(entity) = self.extract_trait(&node, source, file_path) {
+                        entities.push(entity);
+                    }
+                }
+                "impl_item" => {
+                    if let Some(entity) = self.extract_impl(&node, source, file_path) {
+                        entities.push(entity);
+                    }
+                }
+                "enum_item" => {
+                    if let Some(entity) = self.extract_enum(&node, source, file_path) {
+                        entities.push(entity);
+                    }
+                }
+                "source_file" => {
+                    // Recursively process the source file
+                    let mut inner_cursor = node.walk();
+                    for child in node.named_children(&mut inner_cursor) {
+                        match child.kind() {
+                            "function_item" => {
+                                if let Some(entity) = self.extract_function(&child, source, file_path) {
+                                    entities.push(entity);
+                                }
+                            }
+                            "struct_item" => {
+                                if let Some(entity) = self.extract_struct(&child, source, file_path) {
+                                    entities.push(entity);
+                                }
+                            }
+                            "trait_item" => {
+                                if let Some(entity) = self.extract_trait(&child, source, file_path) {
+                                    entities.push(entity);
+                                }
+                            }
+                            "impl_item" => {
+                                if let Some(entity) = self.extract_impl(&child, source, file_path) {
+                                    entities.push(entity);
+                                }
+                            }
+                            "enum_item" => {
+                                if let Some(entity) = self.extract_enum(&child, source, file_path) {
+                                    entities.push(entity);
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Extract all references
+        references = self.extract_references(&root, source, file_path);
+
+        Ok(ExtractionResult {
+            entities,
+            references,
+            errors,
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["rs"]
+    }
+
+    fn language(&self) -> &str {
+        "rust"
+    }
+}