PikoAi 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

Agents/Executor/executor.py

@@ -7,7 +7,7 @@ import time
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../')))
 from Utils.ter_interface import TerminalInterface
 from Utils.executor_utils import parse_tool_call
-from Agents.Executor.prompts import get_system_prompt, get_task_prompt # Import prompts
+from Agents.Executor.prompts import get_executor_prompt # Import prompts
 
 from typing import Optional
 from mistralai.models.sdkerror import SDKError # This might be an issue if LiteLLM doesn't use SDKError
@@ -22,7 +22,7 @@ from llm_interface.llm import LiteLLMInterface # Import LiteLLMInterface
 from Tools import tool_manager
 
 class RateLimiter:
-    def __init__(self, wait_time: float = 5.0, max_retries: int = 3):
+    def __init__(self, wait_time: float = 1.0, max_retries: int = 3):
         self.wait_time = wait_time
         self.max_retries = max_retries
         self.last_call_time = None
@@ -44,7 +44,7 @@ class executor:
         # self.shell_executor = ShellExecutor() # Initialize ShellExecutor
         self.message = [
             {"role": "system", "content": self.system_prompt},
-            {"role": "user", "content": self.task_prompt}
+            {"role": "user", "content": self.user_prompt}
         ]
         self.terminal = TerminalInterface()
         self.initialize_llm()
@@ -71,8 +71,7 @@ class executor:
             config = json.load(config_file)
             working_dir = config.get("working_directory", "")
 
-        self.system_prompt = get_system_prompt(self.user_prompt, working_dir, tools_details)
-        self.task_prompt = get_task_prompt()
+        self.system_prompt = get_executor_prompt(working_dir, tools_details)
 
     def run_inference(self):
         retries = 0
@@ -112,11 +111,6 @@ class executor:
         self.run_task()
 
     def run_task(self):
-        # Remove tools_details parameter since it's in the prompt
-        task_message = self.task_prompt
-
-        self.message.append({"role": "user", "content": task_message})
-
         iteration = 0
         task_done = False
 
@@ -128,13 +122,13 @@ class executor:
             if tool_call:
                 tool_name = tool_call['tool_name']
                 tool_input = tool_call['input']
-                print(f"\nIdentified tool call: {tool_name} with input {tool_input}")
+                
 
                 # Call the tool and append the result (no confirmation or special logic)
                 try:
                     tool_output_result = tool_manager.call_tool(tool_name, tool_input)
-                    self.terminal.tool_output_log(tool_output_result, tool_name)
-                    print(tool_output_result)
+                    if tool_name not in ['execute_python_code', 'execute_shell_command']:
+                        self.terminal.tool_output_log(tool_output_result, tool_name)
                     self.message.append({"role": "user", "content": tool_output_result})
                 except ValueError as e:
                     error_msg = str(e)
@@ -142,10 +136,6 @@ class executor:
                     self.message.append({"role": "user", "content": f"Tool Error: {error_msg}"})
 
             else: # Not a tool call, could be a direct response or requires clarification
-                # This part handles responses that are not formatted as tool calls.
-                # It might be a final answer, a question, or just conversational text.
-                # The existing logic for TASK_DONE or asking for next step handles this.
-                # No specific code/shell parsing here anymore as they are tools.
                 pass # Explicitly pass if no tool call and no old code/shell logic.
 
             # Check if task is done

Agents/Executor/prompts.py

@@ -2,13 +2,15 @@
 
 import platform
 
-def get_system_prompt(user_prompt: str, working_dir: str, tools_details: str) -> str:
+def get_executor_prompt(working_dir: str, tools_details: str) -> str:
     """
-    Returns the system prompt for the Executor agent.
+    Returns the main executor prompt.
     """
     os_name = platform.system()
-    return f"""You are a terminal-based operating system assistant designed to help users achieve their goals by executing tasks provided in text format. The current user goal is: {user_prompt}.
+    # tools_details is passed to the LLM but not directly included in this prompt string.
+    return f"""You are a terminal-based operating system assistant designed to help users achieve their goals.
 
+This is important information about the environment:
 Working Directory: {working_dir}
 Operating System: {os_name}
 
@@ -31,53 +33,26 @@ You must break down the user's goal into smaller steps and perform one action at
     }}
   }}
   <<END_TOOL_CALL>>
-  This includes executing Python code and shell commands:
-  `execute_python_code`: {{"code": "your_python_code_here"}}
-  `execute_shell_command`: {{"command": "your_shell_command_here"}}
+- **Code Execution**: Write Python code when no tool is suitable or when custom logic is needed.
+the code written will be executed immediately and not saved. 
 - **Direct Response**: Provide a direct answer if the task doesn't require tools or code.
 
-### Important Notes:
-- Perform only one action per step.
-- Always evaluate the output of each action before deciding the next step.
-- Continue performing actions until the user's goal is fully achieved. Only then, include 'TASK_DONE' in your response.
-- Do not end the task immediately after a tool call or code execution without evaluating its output.
-
-Now, carefully plan your approach and start with the first step to achieve the user's goal.
-"""
 
-def get_task_prompt() -> str:
-    """
-    Returns the task prompt for the Executor agent.
-    """
-    return """
-Following are the things that you must read carefully and remember:
+These are the things that you learned from the mistakes you made earlier :
+  - When given a data file and asked to understand data/do data analysis/ data visualisation or similar stuff
+    do not use file reader and read the whole data. Only use python code to do the analysis
+  - This is a standard Python environment, not a python notebook or a repl. previous execution
+    context is not preserved between executions.
+  - Don't execute dangerous commands like rm -rf * or access sensitive files
+  - If you are stuck, have tried to fix an issue (e.g., a linter error) multiple times (e.g., 3 times) without success, or need clarification, ask the USER for input. Explain the situation clearly.
+  - Upon creating anything (like a new project, website, data analysis png) always show the output.You can do this by executing shell commands.
+  - the python/shell code execution in tool call will be executed immediately and output will be shown. it wont be saved.
 
-        - For tool calls, use:
-        <<TOOL_CALL>>
-        {
-            "tool_name": "name_of_tool",
-            "input": {
-            "key": "value"  // Use the correct parameter name for each tool
-            }
-        }
-        <<END_TOOL_CALL>>
-        Remember that executing Python code and shell commands is now done through specific tool calls (`execute_python_code` and `execute_shell_command`).
 
-        After each action, always evaluate the output to decide your next step. Only include 'TASK_DONE'
-        When the entire task is completed. Do not end the task immediately after a tool call or code execution without
-        checking its output. 
-        You can only execute a single tool call or code execution at a time, then check its ouput
-        then proceed with the next call
-        Use the working directory as the current directory for all file operations unless otherwise specified.
-        
-        
-
-        These are the things that you learn't from the mistakes you made earlier :
-
-        - When given a data file and asked to understand data/do data analysis/ data visualisation or similar stuff
-        do not use file reader and read the whole data. Only use python code to do the analysis
-        - This is a standard Python environment, not a python notebook or a repl. previous execution
-         context is not preserved between executions.
-        - You have a get_user_input tool to ask user more context before, in between or after tasks
+** Important **
+- Perform only one action per step (either a single tool call or a single code execution).
+- Always evaluate the output of each action before deciding the next step.
+- Continue performing actions until the user's goal is fully achieved. Only then, include 'TASK_DONE' in your response if that is the required signal for completion.
+- Do not end the task immediately after a tool call or code execution without evaluating its output.
 
-"""
+"""

Env/python_executor.py

@@ -58,7 +58,7 @@ try:
 except Exception as e:
     print(f"Error: {{str(e)}}")
 """
-           
+
 
         try:
             # Execute the code in a subprocess
@@ -75,19 +75,14 @@ except Exception as e:
             stderr_data = []
             start_time = time.time()
             
-            # First read all stdout
-            for line in self.process.stdout:
-                # Check for timeout
-                if time.time() - start_time > 30:
-                    self.process.kill()
-                    return {
-                        'success': False,
-                        'output': 'Execution timed out after 30 seconds',
-                        'error': 'Timeout error'
-                    }
-                
-                stdout_data.append(line)
-                print(line, end='', flush=True)  # Print in real-time
+            # Read stdout character by character
+            while True:
+                char = self.process.stdout.read(1)
+                if char == '' and self.process.poll() is not None:
+                    break  # Process ended and no more output
+                if char:
+                    stdout_data.append(char)
+                    print(char, end='', flush=True)  # Print in real-time, no extra newline
             
             # Then read all stderr
             for line in self.process.stderr:

Env/shell.py

@@ -78,15 +78,26 @@ class ShellExecutor(BaseEnv):
                         'output': 'Blocked potentially harmful command.',
                         'error': f'Command matches forbidden pattern: {pattern}'
                     }
-            # Check for sensitive directory access
+            # Improved check for sensitive directory access
             for sensitive_dir in sensitive_dirs:
-                # Only block if the command is trying to directly access or operate on the sensitive dir
-                if re.search(rf'\b{sensitive_dir}\b', code_or_command, re.IGNORECASE):
-                    return {
-                        'success': False,
-                        'output': f'Blocked access to sensitive directory: {sensitive_dir}',
-                        'error': f'Attempted access to sensitive directory: {sensitive_dir}'
-                    }
+                # Only block if the command is trying to directly operate on the sensitive dir itself (not subpaths)
+                # For '/', block only if the command is exactly '/' or has a space and then '/'
+                if sensitive_dir == '/':
+                    if re.search(r'(\s|^)/($|\s)', code_or_command):
+                        return {
+                            'success': False,
+                            'output': f'Blocked access to sensitive directory: {sensitive_dir}',
+                            'error': f'Attempted access to sensitive directory: {sensitive_dir}'
+                        }
+                else:
+                    # Block if the command is operating on the directory itself, not a subpath (e.g., 'ls /root' but not 'ls /root/somefile')
+                    pattern = rf'(\s|^)({re.escape(sensitive_dir)})(\s|$)'
+                    if re.search(pattern, code_or_command, re.IGNORECASE):
+                        return {
+                            'success': False,
+                            'output': f'Blocked access to sensitive directory: {sensitive_dir}',
+                            'error': f'Attempted access to sensitive directory: {sensitive_dir}'
+                        }
             
             # Execute the command in a subprocess
             self.process = subprocess.Popen(
@@ -103,21 +114,16 @@ class ShellExecutor(BaseEnv):
             stderr_data = []
             start_time = time.time()
             
-            # First read all stdout
-            for line in self.process.stdout:
-                # Check for timeout
-                if time.time() - start_time > 30:
-                    self.process.kill()
-                    return {
-                        'success': False,
-                        'output': 'Execution timed out after 30 seconds',
-                        'error': 'Timeout error'
-                    }
-                
-                stdout_data.append(line)
-                print(line, end='', flush=True)  # Print in real-time
+            # First read all stdout character by character
+            while True:
+                char = self.process.stdout.read(1)
+                if char == '' and self.process.poll() is not None:
+                    break  # Process ended and no more output
+                if char:
+                    stdout_data.append(char)
+                    print(char, end='', flush=True)  # Print in real-time, no extra newline
             
-            # Then read all stderr
+            # Then read all stderr (can keep line-by-line or do char-by-char similarly)
             for line in self.process.stderr:
                 # Check for timeout
                 if time.time() - start_time > 30:

Utils/ter_interface.py

@@ -51,72 +51,32 @@ class TerminalInterface:
 
     def process_markdown_chunk(self, chunk):
         """
-        Process a chunk of markdown text, handling code blocks, shell commands, tool calls, and regular markdown.
+        Process a chunk of markdown text, handling tool calls and regular markdown.
         Args:
         chunk (str): A piece of markdown text to process
         """
-        # Initialize tracking attributes if they don't exist yet
-        
-        
         self.buffer += chunk
         while "\n" in self.buffer:
             line, self.buffer = self.buffer.split("\n", 1)
             line_stripped = line.strip()
-            
-            # Handle code blocks
-            if line_stripped.startswith("<<CODE>>"):
-                if self.inside_code_block:
-                    # Closing code block
-                    self.console.print(Syntax(self.code_buffer, "python", theme="bw", line_numbers=False))
-                    self.inside_code_block = False
-                    self.code_buffer = ""
-                else:
-                    # Opening code block
-                    self.inside_code_block = True
-                    self.code_lang = line_stripped[8:].strip() or "python"  # default lang
-            
-            # Handle shell command blocks
-            elif line_stripped.startswith("<<SHELL_COMMAND>>"):
-                self.inside_shell_command = True
-                self.shell_command_buffer = ""
-                # Print a styled header for shell commands
-                self.console.print("[bold yellow]Shell Command:[/bold yellow]")
-            
-            elif line_stripped.startswith("<<END_SHELL_COMMAND>>"):
-                if self.inside_shell_command:
-                    # Closing shell command block
-                    self.console.print(Syntax(self.shell_command_buffer.strip(), "bash", theme="monokai", line_numbers=False))
-                    self.inside_shell_command = False
-                    self.shell_command_buffer = ""
-            
+
             # Handle tool call opening delimiter - be more flexible with whitespace
-            elif "<<TOOL_CALL>>" in line_stripped:
+            if "<<TOOL_CALL>>" in line_stripped:
                 self.inside_tool_call = True
                 self.tool_call_buffer = ""
-                # Print a styled header for tool calls
                 self.console.print("[bold cyan]Tool Call:[/bold cyan]")
-            
+
             # Handle tool call closing delimiter - be more flexible with whitespace
             elif "<<END_TOOL_CALL>>" in line_stripped:
                 self.console.print(Syntax('{"status": "end_tool_call"}', "json", theme="monokai", line_numbers=False))
                 self.console.print("[bold cyan]--------------------------------[/bold cyan]")
                 self.inside_tool_call = False
                 self.tool_call_buffer = ""
-            
-            # Handle content inside code blocks
-            elif self.inside_code_block:
-                self.code_buffer += line + "\n"
-            
-            # Handle content inside shell command blocks
-            elif self.inside_shell_command:
-                self.shell_command_buffer += line + "\n"
-            
+
             # Handle content inside tool calls
             elif self.inside_tool_call:
                 self.tool_call_buffer += line + "\n"
-                # Print the line with styling as it comes in
 
-            
             # Regular markdown content
             else:
                 self.console.print(Markdown(line))
@@ -125,14 +85,7 @@ class TerminalInterface:
         """
         Flush any remaining markdown content in the buffer.
         """
-        if self.inside_code_block:
-            self.console.print(Syntax(self.code_buffer, "python", theme="bw", line_numbers=False))
-            self.inside_code_block = False
-        elif self.inside_shell_command:
-            self.console.print(Syntax(self.shell_command_buffer.strip(), "bash", theme="monokai", line_numbers=False))
-            
-            self.inside_shell_command = False
-        elif hasattr(self, 'inside_tool_call') and self.inside_tool_call:
+        if hasattr(self, 'inside_tool_call') and self.inside_tool_call:
             # Handle case where tool call is not properly terminated
             self.console.print(Syntax(self.tool_call_buffer.strip(), "json", theme="monokai", line_numbers=False))
             self.console.print("[bold cyan]End Tool Call (forced)[/bold cyan]")
@@ -142,10 +95,7 @@ class TerminalInterface:
                 self.console.print("━" * 80)  # Print a solid line
             else:
                 self.console.print(Markdown(self.buffer))
-        
         self.buffer = ""
-        self.code_buffer = ""
-        self.shell_command_buffer = ""
         if hasattr(self, 'tool_call_buffer'):
             self.tool_call_buffer = ""
 

{pikoai-0.1.11.dist-info → pikoai-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PikoAi
-Version: 0.1.11
+Version: 0.1.13
 Summary: An AI-powered task automation tool
 Home-page: https://github.com/nihaaaar22/OS-Assistant
 Author: Nihar S

{pikoai-0.1.11.dist-info → pikoai-0.1.13.dist-info}/RECORD

@@ -2,15 +2,15 @@ OpenCopilot.py,sha256=vBAuU6MNhYdnyIIrDWOBSlxa0iyjADJLq5eCxUhlffw,12240
 cli.py,sha256=hY6KUxvKvJOFThZT--r6m2nzOEMIOVtiVptewsi9Z9w,13868
 Agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Agents/Executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Agents/Executor/executor.py,sha256=RGYh4bmG5-cvsQPrlCTGNYzQbsnZcQt7eoIpEH9g6OY,8808
-Agents/Executor/prompts.py,sha256=bcVxBBCEda7JZtnA1KoMM8KayKAqFeQCP4lY6EbodzQ,3607
+Agents/Executor/executor.py,sha256=-HvywqfroHd0QYNt5AN8vV7wjR-91hWPbSuvNzIVMMU,8191
+Agents/Executor/prompts.py,sha256=dWmUiAloNN_NKwWgaG_IqHDhCX1O-VhwbadUL-16gZw,2903
 Env/__init__.py,sha256=KLe7UcNV5L395SxhMwbYGyu7KPrSNaoV_9QJo3mLop0,196
 Env/base_env.py,sha256=K4PoWwPXn3pKeu7_-JOlUuyNbyYQ9itMhQybFOm-3K4,1563
 Env/base_executor.py,sha256=awTwJ44CKWV4JO2KUHfHDX0p1Ujw55hlaL5oNYTEW9M,893
 Env/env.py,sha256=I3lOoyBJR5QNq3tWk_HVH6ncRx1vnilRYmj7b7h4jic,114
 Env/js_executor.py,sha256=tEAg5ho8Pa8LzxUbS1Idau8XuJWZZqPiNlvFPDwGkgc,2690
-Env/python_executor.py,sha256=1PIWL3Q8cgkQ4tvarf3d75dUTZoMF_dx_HoDho_zPEQ,4811
-Env/shell.py,sha256=hquziVipyJcEabu3LbAnuACtGGZ0YIr6IaSlp6ZWMJc,7287
+Env/python_executor.py,sha256=siiR-BivXKlCHoL6Jyb3aSQkHdZXCFMNo3c3rspHllA,4664
+Env/shell.py,sha256=DuttZymCUM7QNRxIOPBB81bSBcgzH-wQdUADYridRTo,7987
 Env/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Env/tests/test_python_executor.py,sha256=5kfs0cOf-RgWTOers_1wB0yvYSF-HrHPsraJ-PxgR50,3156
 Env/tests/test_shell_executor.py,sha256=-RcCdSUMoRAXHISIh0IR5MCutco80fX2S3sQBcinc_Q,1034
@@ -24,12 +24,12 @@ Tools/web_loader.py,sha256=PyZk2g7WngZT0tCLs9Danx20dYspnaZwy4rlVE9Sx_4,5054
 Tools/web_search.py,sha256=4EGq1VZqfDgG-_yXTd4_Ha1iEUcR-szdlgRV7oFPru4,1259
 Utils/__init__.py,sha256=oukU0ufroPRd8_N8d2xiFes9CTxSaw4NA6p2nS1kkSg,16
 Utils/executor_utils.py,sha256=WwK3TKgw_hG_crg7ijRaqfidYnnNXYbbs37vKZRYK-0,491
-Utils/ter_interface.py,sha256=Zay9mwyAyKYTNQAKOWXHAa3upo9TWprSf26STiHXk0g,6255
+Utils/ter_interface.py,sha256=2k32kVxcxVBewXnjSGSPbx25ZLhKindEMtL6wSC_wL4,3829
 llm_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 llm_interface/llm.py,sha256=tI_KDOW14QLWowA7bB3GPe2qjlk0sjS5fBavs9XD1fo,5185
-pikoai-0.1.11.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
-pikoai-0.1.11.dist-info/METADATA,sha256=uM1TnOErAJmJgeepRI0N9bQZQGZdTVvllSvjKljaK60,2962
-pikoai-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pikoai-0.1.11.dist-info/entry_points.txt,sha256=xjZnheDymNDnQ0o84R0jZKEITrhNbzQWN-AhqfA_d6s,50
-pikoai-0.1.11.dist-info/top_level.txt,sha256=hWzBNE7UQsuNcENIOksGcJED08k3ZGRRn2X5jnStICU,53
-pikoai-0.1.11.dist-info/RECORD,,
+pikoai-0.1.13.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
+pikoai-0.1.13.dist-info/METADATA,sha256=mjc1I8aWnP9tMaG0Mlvme1AX-dgDIul3ugC5C5yxbXc,2962
+pikoai-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pikoai-0.1.13.dist-info/entry_points.txt,sha256=xjZnheDymNDnQ0o84R0jZKEITrhNbzQWN-AhqfA_d6s,50
+pikoai-0.1.13.dist-info/top_level.txt,sha256=hWzBNE7UQsuNcENIOksGcJED08k3ZGRRn2X5jnStICU,53
+pikoai-0.1.13.dist-info/RECORD,,