agentcrew-ai 0.8.12__py3-none-any.whl → 0.8.13__py3-none-any.whl

AgentCrew/__init__.py

@@ -1 +1 @@
-__version__ = "0.8.12"
+__version__ = "0.8.13"

AgentCrew/main.py

@@ -86,7 +86,7 @@ def check_and_update():
         current_version = get_current_version()
 
         click.echo(f"Current version: {current_version}\nChecking for updates...")
-        latest_version = get_latest_github_version()
+        latest_version, release_notes = get_latest_release_info()
 
         if not current_version or not latest_version:
             click.echo("⚠️ Could not determine version information", err=True)
@@ -98,8 +98,20 @@ def check_and_update():
             system = platform.system().lower()
 
             if system == "linux" or system == "darwin":
+                click.echo("\n" + "=" * 60)
+                click.echo("🔄 New version available!")
+                click.echo("=" * 60)
+
+                if release_notes:
+                    click.echo("\n📝 Release Notes:")
+                    click.echo("-" * 40)
+                    click.echo(release_notes)
+                    click.echo("-" * 40 + "\n")
+                else:
+                    click.echo("\n⚠️ Could not fetch release notes.")
+
                 if click.confirm(
-                    "🔄 New version available! Do you want to update now?",
+                    "\nDo you want to update now?",
                     default=False,
                 ):
                     click.echo("🔄 Starting update...")
@@ -109,7 +121,18 @@ def check_and_update():
                     click.echo("⏭️ Skipping update. Starting application...")
             else:
                 command = "uv tool install --python=3.12 --reinstall agentcrew-ai[cpu]@latest --index https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match"
-                click.echo(f"🔄 New version available!\nRun {command} to update.")
+
+                click.echo("\n" + "=" * 60)
+                click.echo("🔄 New version available!")
+                click.echo("=" * 60)
+
+                if release_notes:
+                    click.echo("\n📝 Release Notes:")
+                    click.echo("-" * 40)
+                    click.echo(release_notes)
+                    click.echo("-" * 40 + "\n")
+
+                click.echo(f"Run the following command to update:\n\n{command}")
         else:
             click.echo("✅ You are running the latest version")
 
@@ -157,6 +180,35 @@ def get_latest_github_version():
         return None
 
 
+def get_latest_release_info():
+    """Get the latest release information including version and release notes from GitHub
+
+    Returns:
+        tuple: (version, release_notes) where both can be None if not found.
+    """
+    try:
+        api_url = (
+            "https://api.github.com/repos/saigontechnology/AgentCrew/releases/latest"
+        )
+        response = requests.get(api_url, timeout=10)
+
+        if response.status_code == 200:
+            release_data = response.json()
+            tag_name = release_data.get("tag_name", "").lstrip("v")
+            name = release_data.get("name", "")
+            body = release_data.get("body", "")
+
+            release_notes = None
+            if body:
+                release_notes = f"## {name or tag_name}\n\n{body}"
+
+            return tag_name, release_notes
+
+        return None, None
+    except Exception:
+        return None, None
+
+
 def version_is_older(current: str, latest: str) -> bool:
     """
     Compare two semantic version strings to check if current is older than latest.

AgentCrew/modules/agents/local_agent.py

@@ -604,6 +604,21 @@ Whenever condition on `when` clause in a **Behavior** matches, tailor your respo
             )
         return adaptive_messages
 
+    def _get_directory_structure(self) -> str:
+        try:
+            cwd = os.getcwd()
+            entries = []
+            for entry in sorted(os.listdir(cwd)):
+                full_path = os.path.join(cwd, entry)
+                if os.path.isdir(full_path):
+                    entries.append(f"{entry}/")
+                else:
+                    entries.append(entry)
+            return "\n".join(entries) if entries else ""
+        except Exception as e:
+            logger.warning(f"Failed to get directory structure: {e}")
+            return ""
+
     def _enhance_agent_context_messages(self, final_messages: List[Dict[str, Any]]):
         last_user_index = next(
             (
@@ -651,6 +666,16 @@ Whenever condition on `when` clause in a **Behavior** matches, tailor your respo
             - Skip agent evaluation if user request is when...,[action]... related to adaptive behaviors call `adapt` tool instead.""",
                     },
                 )
+        if last_user_index == 0:
+            dir_structure = self._get_directory_structure()
+            if dir_structure:
+                adaptive_messages["content"].append(
+                    {
+                        "type": "text",
+                        "text": f"Cwd structure:\n{dir_structure}",
+                    }
+                )
+
         if len(adaptive_messages["content"]) > 0:
             final_messages.insert(last_user_index, adaptive_messages)
 

AgentCrew/modules/code_analysis/__init__.py

@@ -6,7 +6,15 @@ capabilities with platform-specific optimizations.
 """
 
 from .service import CodeAnalysisService
+from .parsers import (
+    BaseLanguageParser,
+    get_parser_for_language,
+    LANGUAGE_PARSER_MAP,
+)
 
 __all__ = [
     "CodeAnalysisService",
+    "BaseLanguageParser",
+    "get_parser_for_language",
+    "LANGUAGE_PARSER_MAP",
 ]

AgentCrew/modules/code_analysis/parsers/__init__.py

@@ -0,0 +1,67 @@
+"""
+Language-specific parsers for code analysis.
+
+This module provides a unified interface for parsing different programming languages
+using tree-sitter.
+"""
+
+from .base import BaseLanguageParser
+from .python_parser import PythonParser
+from .javascript_parser import JavaScriptParser
+from .java_parser import JavaParser
+from .cpp_parser import CppParser
+from .ruby_parser import RubyParser
+from .go_parser import GoParser
+from .rust_parser import RustParser
+from .php_parser import PhpParser
+from .csharp_parser import CSharpParser
+from .kotlin_parser import KotlinParser
+from .generic_parser import GenericParser
+
+LANGUAGE_PARSER_MAP = {
+    "python": PythonParser,
+    "javascript": JavaScriptParser,
+    "typescript": JavaScriptParser,
+    "java": JavaParser,
+    "cpp": CppParser,
+    "ruby": RubyParser,
+    "go": GoParser,
+    "rust": RustParser,
+    "php": PhpParser,
+    "c-sharp": CSharpParser,
+    "kotlin": KotlinParser,
+}
+
+
+def get_parser_for_language(language: str) -> BaseLanguageParser:
+    """
+    Get the appropriate parser for a given language.
+
+    Args:
+        language: The programming language name
+
+    Returns:
+        A parser instance for the language
+    """
+    parser_class = LANGUAGE_PARSER_MAP.get(language)
+    if parser_class:
+        return parser_class()
+    return GenericParser(language)
+
+
+__all__ = [
+    "BaseLanguageParser",
+    "PythonParser",
+    "JavaScriptParser",
+    "JavaParser",
+    "CppParser",
+    "RubyParser",
+    "GoParser",
+    "RustParser",
+    "PhpParser",
+    "CSharpParser",
+    "KotlinParser",
+    "GenericParser",
+    "LANGUAGE_PARSER_MAP",
+    "get_parser_for_language",
+]

AgentCrew/modules/code_analysis/parsers/base.py

@@ -0,0 +1,93 @@
+"""
+Base class for language-specific parsers.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+
+class BaseLanguageParser(ABC):
+    """Abstract base class for language-specific code parsers."""
+
+    @property
+    @abstractmethod
+    def language_name(self) -> str:
+        """Return the language name for this parser."""
+        pass
+
+    @staticmethod
+    def extract_node_text(node, source_code: bytes) -> str:
+        """Extract text from a tree-sitter node."""
+        return source_code[node.start_byte : node.end_byte].decode("utf-8")
+
+    @abstractmethod
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Process a tree-sitter node and extract relevant information.
+
+        Args:
+            node: The tree-sitter node to process
+            source_code: The source code as bytes
+            process_children_callback: Callback to process children nodes recursively
+
+        Returns:
+            Dictionary with node information or None if not relevant
+        """
+        pass
+
+    def _create_base_result(self, node) -> Dict[str, Any]:
+        """Create the base result dictionary with common fields."""
+        return {
+            "type": node.type,
+            "start_line": node.start_point[0] + 1,
+            "end_line": node.end_point[0] + 1,
+        }
+
+    def _process_children_default(
+        self, node, source_code: bytes, process_children_callback
+    ) -> List[Dict[str, Any]]:
+        """Default implementation for processing children nodes."""
+        children = []
+        for child in node.children:
+            child_result = process_children_callback(child)
+            if child_result and self._is_significant_node(child_result):
+                children.append(child_result)
+        return children
+
+    def _is_significant_node(self, result: Dict[str, Any]) -> bool:
+        """Check if a node result is significant and should be included."""
+        significant_types = {
+            "class_definition",
+            "function_definition",
+            "class_declaration",
+            "method_definition",
+            "function_declaration",
+            "interface_declaration",
+            "method_declaration",
+            "constructor_declaration",
+            "class_specifier",
+            "struct_specifier",
+            "struct_declaration",
+            "class",
+            "method",
+            "singleton_method",
+            "module",
+            "type_declaration",
+            "struct_item",
+            "impl_item",
+            "fn_item",
+            "trait_item",
+            "trait_declaration",
+            "property_declaration",
+            "field_declaration",
+            "public_field_definition",
+            "const_declaration",
+            "object_definition",
+            "trait_definition",
+            "def_definition",
+            "variable_declaration",
+            "arrow_function",
+        }
+        return result.get("type") in significant_types or "children" in result

AgentCrew/modules/code_analysis/parsers/cpp_parser.py

@@ -0,0 +1,127 @@
+"""
+C++ language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class CppParser(BaseLanguageParser):
+    """Parser for C++ source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "cpp"
+
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        result = self._create_base_result(node)
+
+        if node.type in ["class_specifier", "struct_specifier"]:
+            for child in node.children:
+                if child.type in ["identifier", "type_identifier"]:
+                    result["name"] = self.extract_node_text(child, source_code)
+                elif child.type == "field_declaration_list":
+                    children = []
+                    for body_child in child.children:
+                        child_result = process_children_callback(body_child)
+                        if child_result and self._is_significant_node(child_result):
+                            children.append(child_result)
+                    if children:
+                        result["children"] = children
+            return result
+
+        elif node.type == "function_definition":
+            for child in node.children:
+                if child.type in ["identifier", "field_identifier"]:
+                    result["name"] = self.extract_node_text(child, source_code)
+                    return result
+                elif child.type == "function_declarator":
+                    for subchild in child.children:
+                        if subchild.type in ["identifier", "field_identifier"]:
+                            result["name"] = self.extract_node_text(
+                                subchild, source_code
+                            )
+                            return result
+            return result
+
+        elif node.type == "field_declaration":
+            return self._handle_field_declaration(node, source_code, result)
+
+        elif node.type in ["declaration", "variable_declaration"]:
+            return self._handle_declaration(node, source_code, result)
+
+        children = []
+        for child in node.children:
+            child_result = process_children_callback(child)
+            if child_result and self._is_significant_node(child_result):
+                children.append(child_result)
+
+        if children:
+            result["children"] = children
+
+        return result
+
+    def _handle_field_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        field_name = None
+        field_type = None
+
+        for child in node.children:
+            if child.type in [
+                "primitive_type",
+                "type_identifier",
+                "qualified_identifier",
+                "template_type",
+            ]:
+                field_type = self.extract_node_text(child, source_code)
+            elif child.type == "field_identifier":
+                field_name = self.extract_node_text(child, source_code)
+
+        if field_name:
+            result["type"] = "field_declaration"
+            if field_type:
+                result["name"] = f"{field_type} {field_name}"
+            else:
+                result["name"] = field_name
+
+        return result
+
+    def _handle_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        var_name = None
+        var_type = None
+
+        for child in node.children:
+            if child.type in [
+                "primitive_type",
+                "type_identifier",
+                "qualified_identifier",
+                "template_type",
+            ]:
+                var_type = self.extract_node_text(child, source_code)
+            elif child.type in ["init_declarator", "declarator"]:
+                for subchild in child.children:
+                    if subchild.type == "identifier":
+                        var_name = self.extract_node_text(subchild, source_code)
+                        break
+                    elif subchild.type == "pointer_declarator":
+                        for ptr_child in subchild.children:
+                            if ptr_child.type == "identifier":
+                                var_name = self.extract_node_text(
+                                    ptr_child, source_code
+                                )
+                                break
+
+        if var_name:
+            result["type"] = "variable_declaration"
+            if var_type:
+                result["name"] = f"{var_type} {var_name}"
+            else:
+                result["name"] = var_name
+
+        return result

AgentCrew/modules/code_analysis/parsers/csharp_parser.py

@@ -0,0 +1,162 @@
+"""
+C# language parser for code analysis.
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class CSharpParser(BaseLanguageParser):
+    """Parser for C# source code."""
+
+    @property
+    def language_name(self) -> str:
+        return "c-sharp"
+
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        result = self._create_base_result(node)
+
+        if node.type == "class_declaration":
+            self._handle_class_declaration(node, source_code, result)
+
+        elif node.type == "method_declaration":
+            self._handle_method_declaration(node, source_code, result)
+
+        elif node.type == "property_declaration":
+            self._handle_property_declaration(node, source_code, result)
+
+        elif node.type == "field_declaration":
+            self._handle_field_declaration(node, source_code, result)
+
+        children = []
+        for child in node.children:
+            child_result = process_children_callback(child)
+            if child_result and self._is_significant_node(child_result):
+                children.append(child_result)
+
+        if children:
+            result["children"] = children
+
+        return result
+
+    def _handle_class_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        for child in node.children:
+            if child.type == "identifier":
+                result["name"] = self.extract_node_text(child, source_code)
+            elif child.type == "base_list":
+                if len(child.children) > 1:
+                    result["base_class"] = self.extract_node_text(
+                        child.children[1], source_code
+                    )
+
+    def _handle_method_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        method_name = None
+        parameters = []
+        access_modifiers = []
+
+        for child in node.children:
+            if child.type == "identifier":
+                method_name = self.extract_node_text(child, source_code)
+                result["name"] = method_name
+            elif child.type == "parameter_list":
+                for param in child.children:
+                    if param.type == "parameter":
+                        param_type = ""
+                        param_name = None
+
+                        type_node = param.child_by_field_name("type")
+                        name_node = param.child_by_field_name("name")
+
+                        if type_node:
+                            param_type = self.extract_node_text(type_node, source_code)
+                        if name_node:
+                            param_name = self.extract_node_text(name_node, source_code)
+
+                        if param_name:
+                            parameters.append(param_type + " " + param_name)
+
+                if parameters:
+                    result["parameters"] = parameters
+            elif child.type == "modifier":
+                modifier = self.extract_node_text(child, source_code)
+                access_modifiers.append(modifier)
+
+        if access_modifiers:
+            result["modifiers"] = access_modifiers
+
+    def _handle_property_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        property_name = None
+        property_type = None
+        modifiers = []
+
+        for child in node.children:
+            if child.type == "modifier":
+                modifiers.append(self.extract_node_text(child, source_code))
+            elif child.type in [
+                "predefined_type",
+                "nullable_type",
+                "generic_name",
+                "array_type",
+            ]:
+                property_type = self.extract_node_text(child, source_code)
+            elif child.type == "identifier":
+                if property_type is None:
+                    property_type = self.extract_node_text(child, source_code)
+                else:
+                    property_name = self.extract_node_text(child, source_code)
+
+        if property_name:
+            result["type"] = "property_declaration"
+            if property_type:
+                result["name"] = f"{property_type} {property_name}"
+            else:
+                result["name"] = property_name
+            if modifiers:
+                result["modifiers"] = modifiers
+
+    def _handle_field_declaration(
+        self, node, source_code: bytes, result: Dict[str, Any]
+    ) -> None:
+        field_name = None
+        field_type = None
+        modifiers = []
+
+        for child in node.children:
+            if child.type == "modifier":
+                modifiers.append(self.extract_node_text(child, source_code))
+            elif child.type == "variable_declaration":
+                for subchild in child.children:
+                    if subchild.type in [
+                        "predefined_type",
+                        "nullable_type",
+                        "generic_name",
+                        "array_type",
+                    ]:
+                        field_type = self.extract_node_text(subchild, source_code)
+                    elif subchild.type == "identifier" and field_type is None:
+                        field_type = self.extract_node_text(subchild, source_code)
+                    elif subchild.type == "variable_declarator":
+                        for var_child in subchild.children:
+                            if var_child.type == "identifier":
+                                field_name = self.extract_node_text(
+                                    var_child, source_code
+                                )
+                                break
+
+        if field_name:
+            result["type"] = "field_declaration"
+            if field_type:
+                result["name"] = f"{field_type} {field_name}"
+            else:
+                result["name"] = field_name
+            if modifiers:
+                result["modifiers"] = modifiers

AgentCrew/modules/code_analysis/parsers/generic_parser.py

@@ -0,0 +1,63 @@
+"""
+Generic language parser for code analysis (fallback for unsupported languages).
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseLanguageParser
+
+
+class GenericParser(BaseLanguageParser):
+    """Generic parser for languages without specific implementation."""
+
+    def __init__(self, language: str = "unknown"):
+        self._language = language
+
+    @property
+    def language_name(self) -> str:
+        return self._language
+
+    def process_node(
+        self, node, source_code: bytes, process_children_callback
+    ) -> Optional[Dict[str, Any]]:
+        result = self._create_base_result(node)
+
+        if node.type in [
+            "type_declaration",
+            "function_declaration",
+            "method_declaration",
+            "interface_declaration",
+        ]:
+            for child in node.children:
+                if child.type in ["identifier", "field_identifier"]:
+                    result["name"] = self.extract_node_text(child, source_code)
+                    result["first_line"] = (
+                        self.extract_node_text(node, source_code)
+                        .split("\n")[0]
+                        .strip("{")
+                    )
+                    return result
+            return result
+
+        elif node.type in ["var_declaration", "const_declaration"]:
+            for child in node.children:
+                if child.type in ["var_spec", "const_spec"]:
+                    for subchild in child.children:
+                        if subchild.type == "identifier":
+                            result["type"] = "variable_declaration"
+                            result["name"] = self.extract_node_text(
+                                subchild, source_code
+                            )
+                            return result
+            return result
+
+        children = []
+        for child in node.children:
+            child_result = process_children_callback(child)
+            if child_result and self._is_significant_node(child_result):
+                children.append(child_result)
+
+        if children:
+            result["children"] = children
+
+        return result