PikoAi 0.1.12__tar.gz → 0.1.14__tar.gz

{pikoai-0.1.12/Src/PikoAi.egg-info → pikoai-0.1.14}/PKG-INFO

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

{pikoai-0.1.12 → pikoai-0.1.14}/Src/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
@@ -84,7 +83,8 @@ class executor:
 
                 # Streaming is handled within LiteLLMInterface.chat()
                 # and TerminalInterface.process_markdown_chunk()
-                self.message.append({"role": "assistant", "content": response})
+                if response.strip():
+                    self.message.append({"role": "assistant", "content": response})
                 return response
 
             except Exception as e: # Catching generic Exception as LiteLLM maps to OpenAI exceptions
@@ -112,11 +112,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 +123,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 +137,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

pikoai-0.1.14/Src/Agents/Executor/prompts.py

@@ -0,0 +1,58 @@
+# This file contains the prompts used by the Executor agent.
+
+import platform
+
+def get_executor_prompt(working_dir: str, tools_details: str) -> str:
+    """
+    Returns the main executor prompt.
+    """
+    os_name = platform.system()
+    # 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}
+
+You have access to the following tools:
+{tools_details}
+
+Your primary objective is to accomplish the user's goal by performing step-by-step actions. These actions can include:
+1. Calling a tool
+2. Providing a direct response
+
+You must break down the user's goal into smaller steps and perform one action at a time. After each action, carefully evaluate the output to determine the next step.
+
+### Action Guidelines:
+- **Tool Call**: Use when a specific tool can help with the current step. Format:
+  <<TOOL_CALL>>
+  {{
+    "tool_name": "name_of_tool",
+    "input": {{
+      "key": "value"   //Replace 'key' with the actual parameter name for the tool
+    }}
+  }}
+  <<END_TOOL_CALL>>
+- **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.
+
+
+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.
+
+
+** 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.
+
+"""

{pikoai-0.1.12 → pikoai-0.1.14}/Src/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:

{pikoai-0.1.12 → pikoai-0.1.14}/Src/Env/shell.py

@@ -114,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:

{pikoai-0.1.12 → pikoai-0.1.14}/Src/OpenCopilot.py

@@ -206,12 +206,12 @@ Examples:
         
         try:
             # Get initial prompt
-            user_input = self.session.prompt(HTML("<b>Please enter your prompt: </b>"))
+            user_input = self.session.prompt(HTML("<b>Piko></b>"))
             
             # Handle special commands
             if user_input.lower() == 'help':
                 self.display_help()
-                user_input = self.session.prompt(HTML("<b>Please enter your prompt: </b>"))
+                user_input = self.session.prompt(HTML("<b>Piko></b>"))
             elif user_input.lower() == 'quit':
                 print("Goodbye!")
                 return
@@ -227,7 +227,7 @@ Examples:
             # Continue conversation loop
             while True:
                 try:
-                    user_input = self.session.prompt(HTML("<b>\nPlease enter your prompt (or 'quit' to exit): </b>"))
+                    user_input = self.session.prompt(HTML("<b>\nPiko></b>"))
                     
                     # Handle special commands
                     if user_input.lower() == 'quit':

{pikoai-0.1.12 → pikoai-0.1.14/Src/PikoAi.egg-info}/PKG-INFO

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

pikoai-0.1.14/Src/Tools/web_search.py

@@ -0,0 +1,67 @@
+import os
+from duckduckgo_search import DDGS
+from serpapi import SerpApiClient
+
+def web_search(max_results: int = 10, **kwargs) -> str:
+    """
+    Performs a DuckDuckGo web search based on your query (think a Google search) then returns the top search results.
+    If DuckDuckGo search fails, it falls back to SerpAPI.
+
+    Args:
+        query (str): The search query to perform.
+        max_results (int, optional): Maximum number of results to return. Defaults to 10.
+        **kwargs: Additional keyword arguments to pass to DDGS.
+
+    Returns:
+        str: Formatted string containing search results.
+
+    Raises:
+        ImportError: If the duckduckgo_search or serpapi package is not installed.
+        Exception: If no results are found for the given query via both DuckDuckGo and SerpAPI, or if the SerpAPI key is not found.
+
+    Note:
+        For SerpAPI fallback, the SERPAPI_API_KEY environment variable must be set.
+    """
+    try:
+        ddgs_instance = DDGS()
+    except ImportError as e:
+        raise ImportError("You must install package `duckduckgo_search` to run this function: for instance run `pip install duckduckgo-search`.") from e
+
+    try:
+        query = kwargs['query']
+        results = ddgs_instance.text(query, max_results=max_results)
+        if len(results) == 0:
+            raise Exception("No results found via DuckDuckGo.")
+
+        postprocessed_results = [f"[{result['title']}]({result['href']})\n{result['body']}" for result in results]
+        
+        return "## Search Results (via DuckDuckGo)\n\n" + "\n\n".join(postprocessed_results)
+        
+    except Exception as e:
+        # print(f"DuckDuckGo search failed: {e}. Falling back to SerpAPI.")
+        # If the exception was the specific DDGS ImportError, we re-raise it directly if it wasn't caught above.
+        # However, the structure above should prevent it from reaching here.
+        # The primary purpose of this block is to catch runtime errors from ddgs.text or the "No results" exception.
+
+        api_key = os.environ.get("SERPAPI_API_KEY")
+        if not api_key:
+            raise Exception("SerpAPI key not found. Please set the SERPAPI_API_KEY environment variable.")
+
+        try:
+            client = SerpApiClient({"api_key": api_key})
+        except ImportError as serp_e:
+            raise ImportError("You must install package `serpapi` to run this function: for instance run `pip install google-search-results`.") from serp_e
+        
+        search_params = {
+            "engine": "google",
+            "q": query,
+            "num": max_results  # SerpAPI uses 'num' for number of results
+        }
+        serp_results = client.search(search_params)
+
+        if "organic_results" in serp_results and serp_results["organic_results"]:
+            organic_results = serp_results["organic_results"]
+            postprocessed_results = [f"[{result['title']}]({result['link']})\n{result.get('snippet', '')}" for result in organic_results]
+            return "## Search Results (via SerpAPI)\n\n" + "\n\n".join(postprocessed_results)
+        else:
+            raise Exception(f"No results found via DuckDuckGo or SerpAPI! Original error: {e}")

{pikoai-0.1.12 → pikoai-0.1.14}/Src/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.12 → pikoai-0.1.14}/setup.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 setup(
     name="PikoAi",
-    version="0.1.12",
+    version="0.1.14",
     packages=find_packages(where="Src"),
     py_modules=["cli", "OpenCopilot"],
     package_dir={"": "Src"},

pikoai-0.1.12/Src/Agents/Executor/prompts.py

@@ -1,83 +0,0 @@
-# This file contains the prompts used by the Executor agent.
-
-import platform
-
-def get_system_prompt(user_prompt: str, working_dir: str, tools_details: str) -> str:
-    """
-    Returns the system prompt for the Executor agent.
-    """
-    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}.
-
-Working Directory: {working_dir}
-Operating System: {os_name}
-
-You have access to the following tools:
-{tools_details}
-
-Your primary objective is to accomplish the user's goal by performing step-by-step actions. These actions can include:
-1. Calling a tool
-2. Providing a direct response
-
-You must break down the user's goal into smaller steps and perform one action at a time. After each action, carefully evaluate the output to determine the next step.
-
-### Action Guidelines:
-- **Tool Call**: Use when a specific tool can help with the current step. Format:
-  <<TOOL_CALL>>
-  {{
-    "tool_name": "name_of_tool",
-    "input": {{
-      "key": "value"   //Replace 'key' with the actual parameter name for the tool
-    }}
-  }}
-  <<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"}}
-- **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:
-
-        - 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
-
-"""

pikoai-0.1.12/Src/Tools/web_search.py

@@ -1,30 +0,0 @@
-from duckduckgo_search import DDGS
-
-def web_search(max_results: int = 10, **kwargs) -> str:
-    """
-    Performs a DuckDuckGo web search based on your query (think a Google search) then returns the top search results.
-
-    Args:
-        query (str): The search query to perform.
-        max_results (int, optional): Maximum number of results to return. Defaults to 10.
-        **kwargs: Additional keyword arguments to pass to DDGS.
-
-    Returns:
-        str: Formatted string containing search results.
-
-    Raises:
-        ImportError: If the duckduckgo_search package is not installed.
-        Exception: If no results are found for the given query.
-    """
-    try:
-        ddgs = DDGS()
-    except ImportError as e:
-        raise ImportError("You must install package `duckduckgo_search` to run this function: for instance run `pip install duckduckgo-search`."
-        ) from e
-    query = kwargs['query']
-    results = ddgs.text(query, max_results=max_results)
-    if len(results) == 0:
-        raise Exception("No results found! Try a less restrictive/shorter query.")
-
-    postprocessed_results = [f"[{result['title']}]({result['href']})\n{result['body']}" for result in results]
-    return "## Search Results\n\n" + "\n\n".join(postprocessed_results)