praisonAI 2.3.76__tar.gz → 2.3.78__tar.gz

{praisonai-2.3.76 → praisonai-2.3.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 2.3.76
+Version: 2.3.78
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT

{praisonai-2.3.76 → praisonai-2.3.78}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 2.3.76
+Version: 2.3.78
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT

{praisonai-2.3.76 → praisonai-2.3.78}/praisonai/cli/features/at_mentions.py

@@ -105,6 +105,7 @@ class FileSearchService:
     - Fuzzy match file paths
     - Cache results with TTL
     - Respect .gitignore (basic)
+    - Support absolute paths (@/Users/...) and home paths (@~/...)
     """
     
     def __init__(
@@ -125,9 +126,10 @@ class FileSearchService:
         # Cache: query -> (results, timestamp)
         self._cache: Dict[str, Tuple[List[FileSuggestion], float]] = {}
         
-        # File list cache
+        # File list cache per directory
         self._file_list: Optional[List[str]] = None
         self._file_list_time: float = 0
+        self._file_list_dir: Optional[str] = None
     
     def _should_ignore(self, name: str) -> bool:
         """Check if file/dir should be ignored."""
@@ -136,20 +138,23 @@ class FileSearchService:
                 return True
         return False
     
-    def _get_file_list(self) -> List[str]:
+    def _get_file_list(self, search_dir: str = None) -> List[str]:
         """Get list of all files (cached)."""
         now = time.time()
+        target_dir = search_dir or self._root
         
-        # Return cached if fresh
-        if self._file_list is not None and (now - self._file_list_time) < self._cache_ttl:
+        # Return cached if fresh and same directory
+        if (self._file_list is not None and 
+            self._file_list_dir == target_dir and
+            (now - self._file_list_time) < self._cache_ttl):
             return self._file_list
         
         files = []
         
         try:
-            for root, dirs, filenames in os.walk(self._root):
+            for root, dirs, filenames in os.walk(target_dir):
                 # Calculate depth
-                rel_root = os.path.relpath(root, self._root)
+                rel_root = os.path.relpath(root, target_dir)
                 depth = 0 if rel_root == '.' else rel_root.count(os.sep) + 1
                 
                 if depth > self._max_depth:
@@ -161,19 +166,20 @@ class FileSearchService:
                 
                 # Add directories
                 for d in dirs:
-                    rel_path = os.path.relpath(os.path.join(root, d), self._root)
+                    rel_path = os.path.relpath(os.path.join(root, d), target_dir)
                     files.append(rel_path + os.sep)
                 
                 # Add files
                 for f in filenames:
                     if not self._should_ignore(f):
-                        rel_path = os.path.relpath(os.path.join(root, f), self._root)
+                        rel_path = os.path.relpath(os.path.join(root, f), target_dir)
                         files.append(rel_path)
         except OSError:
             pass
         
         self._file_list = files
         self._file_list_time = now
+        self._file_list_dir = target_dir
         return files
     
     def _fuzzy_match(self, text: str, query: str) -> int:
@@ -221,6 +227,11 @@ class FileSearchService:
         """
         Search for files matching query.
         
+        Supports:
+        - Relative paths: @file.txt, @src/main.py
+        - Home paths: @~/Documents, @~/.config
+        - Absolute paths: @/Users/name/file.txt, @/etc/hosts
+        
         Args:
             query: Search query (fuzzy matched)
             max_results: Maximum results to return
@@ -228,8 +239,51 @@ class FileSearchService:
         Returns:
             List of FileSuggestion sorted by score
         """
+        # Determine search directory based on query
+        search_dir = self._root
+        search_query = query
+        prefix = ""
+        
+        # Handle home directory paths (@~/)
+        if query.startswith('~'):
+            expanded = os.path.expanduser(query)
+            # Find the directory part and filename part
+            if os.path.isdir(expanded):
+                search_dir = expanded
+                search_query = ""
+                prefix = query.rstrip('/') + '/'
+            else:
+                parent = os.path.dirname(expanded)
+                if os.path.isdir(parent):
+                    search_dir = parent
+                    search_query = os.path.basename(expanded)
+                    prefix = os.path.dirname(query).rstrip('/') + '/'
+                else:
+                    # Just expand ~ and search from home
+                    search_dir = os.path.expanduser('~')
+                    search_query = query[2:] if query.startswith('~/') else query[1:]
+                    prefix = "~/"
+        
+        # Handle absolute paths (@/Users/..., @/etc/...)
+        elif query.startswith('/'):
+            if os.path.isdir(query):
+                search_dir = query
+                search_query = ""
+                prefix = query.rstrip('/') + '/'
+            else:
+                parent = os.path.dirname(query)
+                if os.path.isdir(parent):
+                    search_dir = parent
+                    search_query = os.path.basename(query)
+                    prefix = parent.rstrip('/') + '/'
+                else:
+                    # Search from root with the query
+                    search_dir = '/'
+                    search_query = query[1:]
+                    prefix = "/"
+        
         # Check cache
-        cache_key = f"{query}:{max_results}"
+        cache_key = f"{search_dir}:{search_query}:{max_results}"
         now = time.time()
         
         if cache_key in self._cache:
@@ -237,25 +291,26 @@ class FileSearchService:
             if (now - cached_time) < self._cache_ttl:
                 return results
         
-        # Get all files
-        all_files = self._get_file_list()
+        # Get all files from the appropriate directory
+        all_files = self._get_file_list(search_dir)
         
         # Score and filter
         scored: List[Tuple[int, str]] = []
         for path in all_files:
-            score = self._fuzzy_match(path, query)
+            score = self._fuzzy_match(path, search_query)
             if score > 0:
                 scored.append((score, path))
         
         # Sort by score descending
         scored.sort(key=lambda x: (-x[0], x[1]))
         
-        # Build results
+        # Build results with proper prefix
         results = []
         for score, path in scored[:max_results]:
             file_type = "directory" if path.endswith(os.sep) else "file"
+            display_path = prefix + path if prefix else path
             results.append(FileSuggestion(
-                path=path,
+                path=display_path,
                 file_type=file_type,
                 score=score
             ))

{praisonai-2.3.76 → praisonai-2.3.78}/praisonai/cli/features/compare.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 COMPARE_MODES = {
     "basic": {},
-    "tools": {"tools": "internet_search"},
+    "tools": {"tools": "calculator,internet_search"},
     "research": {"research": True},
     "planning": {"planning": True},
     "memory": {"memory": True},
@@ -407,13 +407,7 @@ class CompareHandler:
                     from praisonaiagents.tools import internet_search
                     tools.append(internet_search)
                 elif name == "calculator":
-                    def calculator(expression: str) -> str:
-                        """Evaluate a mathematical expression."""
-                        try:
-                            return str(eval(expression))
-                        except Exception as e:
-                            return f"Error: {e}"
-                    tools.append(calculator)
+                    tools.append(_calculator_tool)
             except ImportError:
                 logger.warning(f"Could not load tool: {name}")
         
@@ -466,3 +460,50 @@ class CompareHandler:
                 print(f"[red]Failed to save results to: {output_path}[/red]")
         
         return result
+
+
+def _calculator_tool(expression: str) -> str:
+    """
+    Evaluate a mathematical expression safely.
+    
+    Args:
+        expression: Mathematical expression to evaluate (e.g., "2+2", "15*3", "100/4")
+        
+    Returns:
+        The result of the calculation as a string
+    """
+    import ast
+    import operator
+    
+    # Safe operators
+    operators = {
+        ast.Add: operator.add,
+        ast.Sub: operator.sub,
+        ast.Mult: operator.mul,
+        ast.Div: operator.truediv,
+        ast.Pow: operator.pow,
+        ast.USub: operator.neg,
+        ast.UAdd: operator.pos,
+        ast.Mod: operator.mod,
+        ast.FloorDiv: operator.floordiv,
+    }
+    
+    def _eval(node):
+        if isinstance(node, ast.Constant):
+            return node.value
+        elif isinstance(node, ast.BinOp):
+            left = _eval(node.left)
+            right = _eval(node.right)
+            return operators[type(node.op)](left, right)
+        elif isinstance(node, ast.UnaryOp):
+            operand = _eval(node.operand)
+            return operators[type(node.op)](operand)
+        else:
+            raise ValueError(f"Unsupported operation: {type(node)}")
+    
+    try:
+        tree = ast.parse(expression, mode='eval')
+        result = _eval(tree.body)
+        return str(result)
+    except Exception as e:
+        return f"Error evaluating '{expression}': {e}"

{praisonai-2.3.76 → praisonai-2.3.78}/praisonai/cli/features/eval.py

@@ -26,42 +26,68 @@ class EvalHandler:
     
     def run_accuracy(
         self,
-        agent_file: str,
-        input_text: str,
-        expected_output: str,
+        agent_file: Optional[str] = None,
+        input_text: str = "",
+        expected_output: str = "",
         iterations: int = 1,
         model: Optional[str] = None,
-        output_file: Optional[str] = None
+        output_file: Optional[str] = None,
+        prompt: Optional[str] = None,
+        llm: Optional[str] = None
     ) -> Dict[str, Any]:
         """
         Run accuracy evaluation on an agent.
         
         Args:
-            agent_file: Path to agents.yaml file
+            agent_file: Path to agents.yaml file (optional if prompt is provided)
             input_text: Input to provide to the agent
             expected_output: Expected output to compare against
             iterations: Number of evaluation iterations
             model: LLM model for judging
             output_file: Path to save results
+            prompt: Direct prompt (alternative to agent_file)
+            llm: LLM model for the agent (when using prompt)
             
         Returns:
             Evaluation result dictionary
         """
         try:
             from praisonaiagents.eval import AccuracyEvaluator
-            from praisonai.agents_generator import AgentsGenerator
+            from praisonaiagents import Agent
         except ImportError as e:
             logger.error(f"Failed to import evaluation modules: {e}")
             return {"error": str(e)}
         
         try:
-            generator = AgentsGenerator(agent_file)
-            agents = generator.generate_agents()
-            
-            if not agents:
-                return {"error": "No agents found in configuration"}
-            
-            agent = agents[0] if isinstance(agents, list) else agents
+            # Create agent either from file or from prompt
+            if prompt:
+                # Direct prompt mode - create agent on the fly
+                agent = Agent(
+                    name="EvalAgent",
+                    role="Assistant",
+                    goal="Complete the given task",
+                    backstory="You are a helpful assistant.",
+                    llm=llm or model or "gpt-4o-mini",
+                    verbose=False
+                )
+                # Use prompt as input if input_text not provided
+                if not input_text:
+                    input_text = prompt
+            elif agent_file:
+                # Load from agents.yaml
+                try:
+                    from praisonai.agents_generator import AgentsGenerator
+                    generator = AgentsGenerator(agent_file)
+                    agents = generator.generate_agents()
+                    
+                    if not agents:
+                        return {"error": "No agents found in configuration"}
+                    
+                    agent = agents[0] if isinstance(agents, list) else agents
+                except Exception as e:
+                    return {"error": f"Failed to load agents from {agent_file}: {e}"}
+            else:
+                return {"error": "Either --agent or --prompt must be provided"}
             
             evaluator = AccuracyEvaluator(
                 agent=agent,
@@ -331,8 +357,16 @@ def handle_eval_command(args) -> None:
     handler = EvalHandler(verbose=getattr(args, 'verbose', False))
     
     eval_type = getattr(args, 'eval_type', 'accuracy')
-    agent_file = getattr(args, 'agent', 'agents.yaml')
+    agent_file = getattr(args, 'agent', None)
     output_file = getattr(args, 'output', None)
+    prompt = getattr(args, 'prompt', None)
+    llm = getattr(args, 'llm', None)
+    
+    # If no agent file and no prompt, check if agents.yaml exists
+    if not agent_file and not prompt:
+        import os
+        if os.path.exists('agents.yaml'):
+            agent_file = 'agents.yaml'
     
     if eval_type == 'accuracy':
         result = handler.run_accuracy(
@@ -341,7 +375,9 @@ def handle_eval_command(args) -> None:
             expected_output=getattr(args, 'expected', ''),
             iterations=getattr(args, 'iterations', 1),
             model=getattr(args, 'model', None),
-            output_file=output_file
+            output_file=output_file,
+            prompt=prompt,
+            llm=llm
         )
     elif eval_type == 'performance':
         result = handler.run_performance(
@@ -410,8 +446,10 @@ def add_eval_parser(subparsers) -> None:
         'accuracy',
         help='Run accuracy evaluation'
     )
-    accuracy_parser.add_argument('--agent', '-a', default='agents.yaml', help='Agent config file')
-    accuracy_parser.add_argument('--input', '-i', required=True, help='Input text')
+    accuracy_parser.add_argument('--agent', '-a', help='Agent config file (optional if --prompt used)')
+    accuracy_parser.add_argument('--prompt', '-p', help='Direct prompt (alternative to --agent)')
+    accuracy_parser.add_argument('--llm', help='LLM model for agent (when using --prompt)')
+    accuracy_parser.add_argument('--input', '-i', help='Input text (defaults to --prompt if not provided)')
     accuracy_parser.add_argument('--expected', '-e', required=True, help='Expected output')
     accuracy_parser.add_argument('--iterations', '-n', type=int, default=1, help='Number of iterations')
     accuracy_parser.add_argument('--model', '-m', help='Judge model')