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

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/main_docker.py

@@ -1,6 +1,7 @@
 import click
 import os
 import sys
+from AgentCrew.app import common_options
 
 
 def _custom_unraisable_hook(unraisable):
@@ -48,36 +49,6 @@ def cli():
     )
 
 
-def common_options(func):
-    import functools
-
-    @click.option(
-        "--provider",
-        type=click.Choice(PROVIDER_LIST),
-        default=None,
-        help="LLM provider to use (claude, groq, openai, google, github_copilot, or deepinfra)",
-    )
-    @click.option(
-        "--agent-config", default=None, help="Path/URL to the agent configuration file."
-    )
-    @click.option(
-        "--mcp-config", default=None, help="Path to the mcp servers configuration file."
-    )
-    @click.option(
-        "--memory-llm",
-        type=click.Choice(
-            ["claude", "groq", "openai", "google", "deepinfra", "github_copilot"]
-        ),
-        default=None,
-        help="LLM Model use for analyzing and processing memory",
-    )
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 def cli_prod():
     if sys.argv[1] == "--version":
         click.echo(f"AgentCrew version: {get_current_version()}")

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 `{os.getcwd()}` structure:\n{dir_structure}",
+                    }
+                )
+
         if len(adaptive_messages["content"]) > 0:
             final_messages.insert(last_user_index, adaptive_messages)
 
@@ -738,7 +763,7 @@ Whenever condition on `when` clause in a **Behavior** matches, tailor your respo
                     continue
 
                 if is_shrinkable and i < shrink_threshold:
-                    msg["content"] = "[REDACTED]"
+                    msg["content"] = "[PRUNED]"
                     continue
 
                 # Check if content starts with [UNIQUE]

AgentCrew/modules/chat/message/command_processor.py

@@ -43,14 +43,8 @@ class CommandProcessor:
             return CommandResult(handled=True, clear_flag=True)
         elif user_input.lower().startswith("/copy"):
             return await self._handle_copy_command(user_input)
-        elif user_input.lower() == "/debug":
-            self.message_handler._notify(
-                "debug_requested", self.message_handler.agent.clean_history
-            )
-            self.message_handler._notify(
-                "debug_requested", self.message_handler.streamline_messages
-            )
-            return CommandResult(handled=True, clear_flag=True)
+        elif user_input.lower().startswith("/debug"):
+            return self._handle_debug_command(user_input)
         elif user_input.lower().startswith("/think "):
             try:
                 budget = user_input[7:].strip()
@@ -759,6 +753,37 @@ class CommandProcessor:
             self.message_handler._notify("voice_recording_completed", None)
             return CommandResult(handled=True, clear_flag=True)
 
+    def _handle_debug_command(self, user_input: str) -> CommandResult:
+        """Handle /debug command with optional filtering.
+
+        Usage:
+            /debug         - Show both agent and chat messages
+            /debug agent   - Show only agent messages
+            /debug chat    - Show only chat/streamline messages
+        """
+        parts = user_input.lower().split()
+        filter_type = parts[1] if len(parts) > 1 else None
+
+        if filter_type and filter_type not in ("agent", "chat"):
+            self.message_handler._notify(
+                "error", f"Invalid filter '{filter_type}'. Use 'agent' or 'chat'."
+            )
+            return CommandResult(handled=True, clear_flag=True)
+
+        if filter_type is None or filter_type == "agent":
+            self.message_handler._notify(
+                "debug_requested",
+                {"type": "agent", "messages": self.message_handler.agent.clean_history},
+            )
+
+        if filter_type is None or filter_type == "chat":
+            self.message_handler._notify(
+                "debug_requested",
+                {"type": "chat", "messages": self.message_handler.streamline_messages},
+            )
+
+        return CommandResult(handled=True, clear_flag=True)
+
     def _handle_toggle_transfer_command(self, user_input: str) -> CommandResult:
         """Handle /toggle_transfer command to toggle the enforce_transfer property of agent_manager."""
         try:

AgentCrew/modules/chat/message/handler.py

@@ -470,9 +470,13 @@ class MessageHandler(Observable):
             if isinstance(e, BadRequestError):
                 if e.code == "model_max_prompt_tokens_exceeded":
                     from AgentCrew.modules.agents import LocalAgent
+                    from AgentCrew.modules.llm.model_registry import ModelRegistry
 
                     if isinstance(self.agent, LocalAgent):
-                        self.agent.input_tokens_usage = 128_000
+                        max_token = ModelRegistry.get_model_limit(
+                            self.agent.get_model()
+                        )
+                        self.agent.input_tokens_usage = max_token
                         return await self.get_assistant_response()
             if self.current_user_input:
                 self.conversation_manager.store_conversation_turn(

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