PikoAi 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

Agents/Executor/executor.py

@@ -9,16 +9,7 @@ from Utils.ter_interface import TerminalInterface
 from Utils.executor_utils import parse_tool_call
 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
-                                              # LiteLLM maps exceptions to OpenAI exceptions.
-                                              # We'll keep it for now and see if errors arise during testing.
-# from Env import python_executor # Will be replaced by BaseEnv
-# from Env.shell import ShellExecutor # Will be replaced by BaseEnv
-from Env.base_env import create_environment, BaseEnv # Added
-from Env import python_executor # Keep for type hint in the old execute method if needed, or remove if execute is fully removed
 from llm_interface.llm import LiteLLMInterface # Import LiteLLMInterface
-
 from Tools import tool_manager
 
 class RateLimiter:
@@ -93,12 +84,6 @@ class executor:
                     retries += 1
                     print(f"\nRate limit error detected. Waiting {self.rate_limiter.wait_time} seconds before retry {retries}/{self.rate_limiter.max_retries}")
                     time.sleep(self.rate_limiter.wait_time)
-                # Check if the error is an SDKError (though less likely with LiteLLM directly)
-                # or if it's any other exception that we should retry or raise.
-                elif isinstance(e, SDKError) and "429" in str(e) and retries < self.rate_limiter.max_retries: # Added SDKError check just in case
-                    retries += 1
-                    print(f"\nRate limit exceeded (SDKError). Waiting {self.rate_limiter.wait_time} seconds before retry {retries}/{self.rate_limiter.max_retries}")
-                    time.sleep(self.rate_limiter.wait_time)
                 else:
                     print(f"\nError occurred during inference: {str(e)}")
                     # You might want to log the full traceback here for debugging
@@ -130,7 +115,7 @@ class executor:
                     tool_output_result = tool_manager.call_tool(tool_name, tool_input)
                     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})
+                    self.message.append({"role": "user", "content": "Tool Output: " + str(tool_output_result)})
                 except ValueError as e:
                     error_msg = str(e)
                     print(f"Tool Error: {error_msg}")

Agents/Executor/prompts.py

@@ -33,9 +33,7 @@ You must break down the user's goal into smaller steps and perform one action at
     }}
   }}
   <<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.
+- **Direct Response**: Provide a direct answer if the task doesn't require tool calling
 
 
 These are the things that you learned from the mistakes you made earlier :
@@ -46,13 +44,13 @@ These are the things that you learned from the mistakes you made earlier :
   - 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.
+  - the python/shell code execution through 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.
+- You can only perform one tool call at a time.
+- Always evaluate the output of the tool call 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.
+- Do not end the task immediately after a tool call without evaluating its output.
 
 """

Tools/system_details.py

@@ -1,49 +1,64 @@
 import platform
 import psutil
 import datetime
-import json
 
 def get_os_details():
     """Get operating system details"""
-    return {
+    os_info = {
         "system": platform.system(),
         "release": platform.release(),
         "version": platform.version(),
         "machine": platform.machine(),
         "processor": platform.processor()
     }
+    
+    return f"""Operating System Details:
+System: {os_info['system']}
+Release: {os_info['release']}
+Version: {os_info['version']}
+Machine: {os_info['machine']}
+Processor: {os_info['processor']}"""
 
 def get_datetime():
     """Get current date and time"""
     now = datetime.datetime.now()
-    return {
-        "date": now.strftime("%Y-%m-%d"),
-        "time": now.strftime("%H:%M:%S"),
-        "timezone": datetime.datetime.now().astimezone().tzname()
-    }
+    date = now.strftime("%Y-%m-%d")
+    time = now.strftime("%H:%M:%S")
+    timezone = datetime.datetime.now().astimezone().tzname()
+    
+    return f"""Date and Time:
+Date: {date}
+Time: {time}
+Timezone: {timezone}"""
 
 def get_memory_usage():
     """Get memory usage details"""
     memory = psutil.virtual_memory()
-    return {
-        "total": f"{memory.total / (1024**3):.2f} GB",
-        "available": f"{memory.available / (1024**3):.2f} GB",
-        "used": f"{memory.used / (1024**3):.2f} GB",
-        "percent": f"{memory.percent}%"
-    }
+    total = f"{memory.total / (1024**3):.2f} GB"
+    available = f"{memory.available / (1024**3):.2f} GB"
+    used = f"{memory.used / (1024**3):.2f} GB"
+    percent = f"{memory.percent}%"
+    
+    return f"""Memory Usage:
+Total: {total}
+Available: {available}
+Used: {used}
+Usage Percent: {percent}"""
 
 def get_cpu_info():
     """Get CPU information"""
-    return {
-        "physical_cores": psutil.cpu_count(logical=False),
-        "total_cores": psutil.cpu_count(logical=True),
-        "cpu_freq": {
-            "current": f"{psutil.cpu_freq().current:.2f} MHz",
-            "min": f"{psutil.cpu_freq().min:.2f} MHz",
-            "max": f"{psutil.cpu_freq().max:.2f} MHz"
-        },
-        "cpu_usage": f"{psutil.cpu_percent()}%"
-    }
+    cpu_freq = psutil.cpu_freq()
+    current_freq = f"{cpu_freq.current:.2f} MHz" if cpu_freq else "N/A"
+    min_freq = f"{cpu_freq.min:.2f} MHz" if cpu_freq and cpu_freq.min else "N/A"
+    max_freq = f"{cpu_freq.max:.2f} MHz" if cpu_freq and cpu_freq.max else "N/A"
+    
+    return f"""CPU Information:
+Physical Cores: {psutil.cpu_count(logical=False)}
+Total Cores: {psutil.cpu_count(logical=True)}
+Current Frequency: {current_freq}
+Min Frequency: {min_freq}
+Max Frequency: {max_freq}
+CPU Usage: {psutil.cpu_percent()}%"""
 
 def system_details(detail_type="all"):
     """
@@ -53,17 +68,18 @@ def system_details(detail_type="all"):
         detail_type (str): Type of system detail to retrieve (os, datetime, memory, cpu, all)
     
     Returns:
-        dict: Requested system details
+        str: Requested system details as formatted string
     """
     detail_type = detail_type.lower()
     
     if detail_type == "all":
-        return {
-            "os": get_os_details(),
-            "datetime": get_datetime(),
-            "memory": get_memory_usage(),
-            "cpu": get_cpu_info()
-        }
+        return f"""{get_os_details()}
+
+{get_datetime()}
+
+{get_memory_usage()}
+
+{get_cpu_info()}"""
     elif detail_type == "os":
         return get_os_details()
     elif detail_type == "datetime":

Tools/tool_dir.json

@@ -68,7 +68,7 @@
         "summary": "Prompts the user for input and returns their response",
         "arguments": {
             "prompt": "The message to display to the user",
-            "input_type": "Type of input to validate (text, number, boolean, optional, defaults to text)"
+            "input_type": "Type of input to validate (text, number, optional, defaults to text)"
         }
     },
     {

Tools/tool_manager.py

@@ -77,7 +77,7 @@ def call_tool(tool_name, tool_input):
         # Pass the tool_input dictionary as kwargs to the tool function
         return tools_function_map[tool_name](**tool_input)
     else:
-        raise ValueError(f"Tool '{tool_name}' not found. Check the tools available in the tool directory")
+        return f"This tool is invalid. Please check the tools available in the tool directory"
 
 tools_function_map = {
     "web_loader": load_data,

Tools/userinp.py

@@ -17,15 +17,7 @@ def get_user_input(prompt="Enter input: ", input_type="text"):
                 return user_input
             elif input_type == "number":
                 return float(user_input)
-            elif input_type == "boolean":
-                user_input = user_input.lower()
-                if user_input in ["true", "yes", "y", "1"]:
-                    return True
-                elif user_input in ["false", "no", "n", "0"]:
-                    return False
-                else:
-                    print("Please enter 'yes' or 'no'")
-                    continue
+            
             else:
                 raise ValueError(f"Invalid input type: {input_type}")
                 

Tools/web_loader.py

@@ -123,7 +123,6 @@ def load_data(**kwargs):
     headers = {
         "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML like Gecko) Chrome/52.0.2743.116 Safari/537.36"
     }
-    web_data = {}
     content = ""
     try:
         response = session.get(url, headers=headers, timeout=30)
@@ -139,28 +138,11 @@ def load_data(**kwargs):
                 # Extract text from each page and combine it
                 content = "\n".join([page.extract_text() for page in pdf.pages if page.extract_text()])
 
-        meta_data = {"url": url}
-        doc_id = hashlib.sha256((content + url).encode()).hexdigest()
-        web_data = {
-            "doc_id": doc_id,
-            "data": [
-                {
-                    "content": content,
-                    "meta_data": meta_data,
-                }
-            ],
-        }
     except Exception as e:
         logging.error(f"Error loading data from {url}: {e}")
-        web_data = {
-            "data": [
-                {
-                    "content": "",
-                    "meta_data": "",
-                }
-            ],
-        }
-    return web_data
+        content = ""
+    
+    return content
 
 
 def close_session(session):

Tools/web_search.py

@@ -1,11 +1,14 @@
 import os
+from dotenv import load_dotenv
 from duckduckgo_search import DDGS
-from serpapi import SerpApiClient
+import requests
+
+load_dotenv()
 
 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.
+    Falls back to SerpAPI (Google) if DuckDuckGo fails or returns no results.
 
     Args:
         query (str): The search query to perform.
@@ -16,52 +19,40 @@ def web_search(max_results: int = 10, **kwargs) -> str:
         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.
+        ImportError: If neither duckduckgo_search nor SerpAPI is available.
+        Exception: If no results are found for the given query.
     """
+    query = kwargs['query']
+    # Try DuckDuckGo first
     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
-
+        ddgs = DDGS()
+        results = ddgs.text(query, max_results=max_results)
+        if results and len(results) > 0:
+            postprocessed_results = [f"[{result['title']}]({result['href']})\n{result['body']}" for result in results]          
+            return "## Search Results (DuckDuckGo)\n\n" + "\n\n".join(postprocessed_results)
+    except Exception:
+        pass  # Will try SerpAPI fallback
+
+    # Fallback to SerpAPI (Google)
+    SERP_API_KEY = os.getenv("SERP_API_KEY")
+    if not SERP_API_KEY:
+        raise ImportError("DuckDuckGo search failed and SERP_API_KEY is not set for SerpAPI fallback.")
+    url = "https://serpapi.com/search"
+    params = {
+        "q": query,
+        "api_key": SERP_API_KEY,
+        "engine": "google"
+    }
     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)
-        
+        response = requests.get(url, params=params)
+        data = response.json()
+        results = data.get("organic_results", [])
+        if not results:
+            raise Exception("No results found from SerpAPI either!")
+        simplified_results = [
+            f"[{result.get('title')}]({result.get('link')})\n{result.get('snippet', '')}"
+            for result in results[:max_results]
+        ]
+        return "## Search Results (Google via SerpAPI)\n\n" + "\n\n".join(simplified_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}")
+        raise Exception(f"No results found from DuckDuckGo or SerpAPI. Last error: {e}")

cli.py

@@ -43,320 +43,223 @@ API_KEYS = {
     "anthropic": "ANTHROPIC_API_KEY"
 }
 
+# --- Utility Functions ---
+
+def clear_terminal():
+    """Clear the terminal screen."""
+    os.system('cls' if os.name == 'nt' else 'clear')
+
 def get_provider_from_model_name(model_name: str) -> str:
     """Extracts the provider from a litellm model string (e.g., 'openai/gpt-4o' -> 'openai')."""
     if not model_name or '/' not in model_name:
-        # Fallback or error handling if model_name is not in expected format
-        # For now, try to return the model_name itself if it doesn't contain '/',
-        # as it might be a provider name already or an old format.
-        # This case should ideally be handled based on how robust the system needs to be.
         print(f"Warning: Model name '{model_name}' may not be in 'provider/model' format. Attempting to use as provider.")
         return model_name 
     return model_name.split('/')[0]
 
-def clear_terminal():
-    """Clear the terminal screen"""
-    os.system('cls' if os.name == 'nt' else 'clear')
+# --- Configuration Management ---
 
-def ensure_api_key(provider):
-    """Ensure API key exists for the given provider"""
-    env_path = os.path.join(os.path.dirname(__file__), '../.env')
-    env_var = API_KEYS.get(provider)
-    if not env_var:
-        raise ValueError(f"Unknown provider: {provider}")
-    
-    # Force reload of .env file
-    if os.path.exists(env_path):
-        load_dotenv(env_path, override=True)
-    
-    # Check if API key exists in environment
-    api_key = os.getenv(env_var)
-    
-    if not api_key:
-        # Ask for API key
-        questions = [
-            inquirer.Text('api_key',
-                message=f"Enter your {provider.upper()} API key",
-                validate=lambda _, x: len(x.strip()) > 0
-            )
-        ]
-        api_key = inquirer.prompt(questions)['api_key']
-        clear_terminal()
-        
-        # Save to .env file
-        if not os.path.exists(env_path):
-            with open(env_path, 'w') as f:
-                f.write(f"{env_var}={api_key}\n")
-        else:
-            # Read existing .env file
-            with open(env_path, 'r') as f:
-                lines = f.readlines()
-            
-            # Check if key already exists
-            key_exists = False
-            for i, line in enumerate(lines):
-                if line.strip().startswith(f"{env_var}=") or line.strip().startswith(f"#{env_var}="):
-                    lines[i] = f"{env_var}={api_key}\n"
-                    key_exists = True
-                    break
-            
-            # If key doesn't exist, append it
-            if not key_exists:
-                lines.append(f"{env_var}={api_key}\n")
-            
-            # Write back to .env file
-            with open(env_path, 'w') as f:
-                f.writelines(lines)
-        
-        # Reload environment with new key
-        load_dotenv(env_path, override=True)
-    
-    return api_key
-
-def ensure_config_exists():
-    """Ensure config.json exists and has required fields"""
-    config_path = os.path.join(os.path.dirname(__file__), '../config.json')
-    config = None
-    
+def load_config(config_path: str) -> dict:
+    """Load (or create) config.json and return its contents as a dict. If config.json does not exist, copy from config.example.json (or create a default) and update working_directory to os.getcwd()."""
     if not os.path.exists(config_path):
-        # Copy config from example if it doesn't exist
         example_path = os.path.join(os.path.dirname(__file__), '../config.example.json')
         if os.path.exists(example_path):
             shutil.copy2(example_path, config_path)
             with open(config_path, 'r') as f:
                 config = json.load(f)
         else:
-            # Create a default config if example is missing
-            config = {
-                "working_directory": os.getcwd(),
-                "llm_provider": None, # Will store the provider part, e.g., "openai"
-                "model_name": None    # Will store the full litellm string, e.g., "openai/gpt-4o"
-            }
+            config = { "working_directory": os.getcwd(), "llm_provider": None, "model_name": None }
     else:
-        # Read existing config
         with open(config_path, 'r') as f:
             try:
                 config = json.load(f)
+                config["working_directory"] = os.getcwd()
             except json.JSONDecodeError:
                 print("Error reading config.json. File might be corrupted. Re-creating default.")
-                config = {
-                    "working_directory": os.getcwd(),
-                    "llm_provider": None,
-                    "model_name": None
-                }
+                config = { "working_directory": os.getcwd(), "llm_provider": None, "model_name": None }
+    # Always update working_directory to current directory
+    config["working_directory"] = os.getcwd()
+    return config
 
-    # Ensure 'working_directory' exists, default if not
-    if "working_directory" not in config or not config["working_directory"]:
-        config["working_directory"] = os.getcwd()
+def save_config(config_path: str, config: dict) -> None:
+    """Save config dict (with updated working_directory) to config_path."""
+    with open(config_path, 'w') as f:
+        json.dump(config, f, indent=4)
 
-    # Check if model configuration is needed
-    if not config.get("model_name") or not config.get("llm_provider"):
-        print("LLM provider or model not configured.")
-        questions = [
-            inquirer.List('provider_key',
-                message="Select LLM Provider",
-                choices=list(AVAILABLE_MODELS.keys()) # User selects "openai", "mistral", etc.
-            )
-        ]
-        selected_provider_key = inquirer.prompt(questions)['provider_key']
-        clear_terminal()
-        
-        # Ensure API key exists for the selected provider
-        ensure_api_key(selected_provider_key) # Uses "openai", "mistral", etc.
-        
-        questions = [
-            inquirer.List('model_name_full',
-                message=f"Select {selected_provider_key} Model",
-                choices=AVAILABLE_MODELS[selected_provider_key] # Shows "openai/gpt-3.5-turbo", etc.
-            )
-        ]
-        selected_model_name_full = inquirer.prompt(questions)['model_name_full']
+# --- API Key Management ---
+
+def ensure_api_key(provider: str):
+    """Ensure that an API key for the given provider (e.g. "openai") is available (via .env or prompt) and return it. Raise an error if unknown provider."""
+    env_path = os.path.join(os.path.dirname(__file__), '../.env')
+    env_var = API_KEYS.get(provider)
+    if not env_var:
+        raise ValueError(f"Unknown provider: {provider}")
+
+    # Force reload .env (if it exists) so that any new key is picked up.
+    if os.path.exists(env_path):
+        load_dotenv(env_path, override=True)
+
+    api_key = os.getenv(env_var)
+    if not api_key:
+        questions = [ inquirer.Text("api_key", message=f"Enter your {provider.upper()} API key", validate=lambda _, x: len(x.strip()) > 0) ]
+        api_key = inquirer.prompt(questions)["api_key"]
         clear_terminal()
-        
-        config["llm_provider"] = selected_provider_key # Store "openai"
-        config["model_name"] = selected_model_name_full # Store "openai/gpt-4o"
-        
-        with open(config_path, 'w') as f:
-            json.dump(config, f, indent=4)
-        print(f"Configuration saved: Provider '{selected_provider_key}', Model '{selected_model_name_full}'")
+        # Save (or update) the key in .env
+        lines = []
+        if os.path.exists(env_path):
+             with open(env_path, 'r') as f:
+                 lines = f.readlines()
+        key_line = f"{env_var}={api_key}\n"
+        key_exists = False
+        for (i, line) in enumerate(lines):
+             if (line.strip().startswith(f"{env_var}=") or line.strip().startswith(f"#{env_var}=")):
+                 lines[i] = key_line
+                 key_exists = True
+                 break
+        if not key_exists:
+             lines.append(key_line)
+        with open(env_path, 'w') as f:
+             f.writelines(lines)
+        # Reload .env (override) so that the new key is available.
+        load_dotenv(env_path, override=True)
+    
 
-    else:
-        # Config exists, ensure API key for the stored provider
-        # llm_provider should already be the provider part, e.g., "openai"
-        # If old config only had model_name, try to parse provider from it
-        provider_to_check = config.get("llm_provider")
-        if not provider_to_check and config.get("model_name"):
-            provider_to_check = get_provider_from_model_name(config["model_name"])
-            # Optionally, update config if llm_provider was missing
-            if provider_to_check != config.get("llm_provider"): # Check if it's different or was None
-                config["llm_provider"] = provider_to_check
-                with open(config_path, 'w') as f:
-                    json.dump(config, f, indent=4)
+# --- Model / Provider Management ---
 
-        if provider_to_check:
-             ensure_api_key(provider_to_check)
-        else:
-            # This case should ideally be handled by the initial setup logic
-            print("Warning: Could not determine LLM provider from config to ensure API key.")
+def prompt_model_selection() -> tuple:
+    """Prompt the user (via inquirer) to select a provider (from AVAILABLE_MODELS) and then a model (from that provider's list). Return (provider, model_name_full)."""
+    questions = [ inquirer.List("provider_key", message="Select LLM Provider", choices=list(AVAILABLE_MODELS.keys())) ]
+    selected_provider_key = inquirer.prompt(questions)["provider_key"]
+    clear_terminal()
+    # (Ensure API key for the selected provider.)
+    ensure_api_key(selected_provider_key)
+    questions = [ inquirer.List("model_name_full", message=f"Select {selected_provider_key} Model", choices=AVAILABLE_MODELS[selected_provider_key]) ]
+    selected_model_name_full = inquirer.prompt(questions)["model_name_full"]
+    clear_terminal()
+    return (selected_provider_key, selected_model_name_full)
 
+def update_model_config(config_path: str, provider_key: str, model_name_full: str) -> None:
+    """Update config (at config_path) so that "llm_provider" is provider_key and "model_name" is model_name_full. (Also update "working_directory" to os.getcwd() if missing.)"""
+    config = load_config(config_path)
+    config["llm_provider"] = provider_key
+    config["model_name"] = model_name_full
+    if "working_directory" not in config or not config["working_directory"]:
+         config["working_directory"] = os.getcwd()
+    save_config(config_path, config)
 
-    # Create config file if it was created from scratch without example
-    if not os.path.exists(config_path):
-        with open(config_path, 'w') as f:
-            json.dump(config, f, indent=4)
-            
-    return config_path
+# --- CLI Commands ---
 
 @click.group(invoke_without_command=True)
-@click.option('--task', '-t', help='The task to automate')
-@click.option('--max-iter', '-m', default=10, help='Maximum number of iterations for the task')
-@click.option('--change-model', is_flag=True, help='Change the LLM provider and model')
+@click.option("--task", "-t", help="The task to automate")
+@click.option("--max-iter", "-m", default=10, help="Maximum number of iterations for the task")
+@click.option("--change-model", is_flag=True, help="Change the LLM provider and model")
 @click.pass_context
 def cli(ctx, task, max_iter, change_model):
-    """TaskAutomator - Your AI Task Automation Tool"""
-    # Ensure config exists and has required fields
-    config_path = ensure_config_exists()
-    clear_terminal()
+    """TaskAutomator – Your AI Task Automation Tool"""
+    config_path = os.path.join(os.path.dirname(__file__), '../config.json')
+    config = load_config(config_path)
+    save_config(config_path, config)
     
-    # If change-model flag is set, update the model
-    if change_model:
-        with open(config_path, 'r') as f:
-            config = json.load(f)
-        
-        print("Current configuration: Provider: {}, Model: {}".format(config.get("llm_provider"), config.get("model_name")))
-        questions = [
-            inquirer.List('provider_key',
-                message="Select LLM Provider",
-                choices=list(AVAILABLE_MODELS.keys()) # User selects "openai", "mistral", etc.
-            )
-        ]
-        selected_provider_key = inquirer.prompt(questions)['provider_key']
-        clear_terminal()
-        
-        # Ensure API key exists for the selected provider
-        ensure_api_key(selected_provider_key)
-        
-        questions = [
-            inquirer.List('model_name_full',
-                message=f"Select {selected_provider_key} Model",
-                choices=AVAILABLE_MODELS[selected_provider_key] # Shows "openai/gpt-3.5-turbo", etc.
-            )
-        ]
-        selected_model_name_full = inquirer.prompt(questions)['model_name_full']
-        clear_terminal()
-        
-        config["llm_provider"] = selected_provider_key # Store "openai"
-        config["model_name"] = selected_model_name_full # Store "openai/gpt-4o"
-        
-        # Ensure working_directory is preserved or set
-        if "working_directory" not in config or not config["working_directory"]:
-            config["working_directory"] = os.getcwd()
+    clear_terminal()
 
-        with open(config_path, 'w') as f:
-            json.dump(config, f, indent=4)
-        
-        click.echo(f"Model changed to {selected_model_name_full}")
-        return
-    
-    # Ensure API key for the configured model before running OpenCopilot
-    # This is a bit redundant if ensure_config_exists already did it, but good for safety
-    with open(config_path, 'r') as f:
-        config = json.load(f)
-    
+    if change_model or not config.get("model_name"):
+         (provider, model) = prompt_model_selection()
+         update_model_config(config_path, provider, model)
+         click.echo(f"Model changed to {model}")
+         if not change_model:  # Only return if this was triggered by missing model
+              return
+
+    # Ensure API key for the configured model (or derive provider from model_name if missing) before running OpenCopilot.
     current_provider = config.get("llm_provider")
-    if not current_provider and config.get("model_name"): # If llm_provider is missing, try to derive it
-        current_provider = get_provider_from_model_name(config["model_name"])
-    
+    if not current_provider and config.get("model_name"):
+         current_provider = get_provider_from_model_name(config["model_name"])
     if current_provider:
-        ensure_api_key(current_provider)
+         ensure_api_key(current_provider)
     else:
-        click.echo("Error: LLM provider not configured. Please run with --change-model to set it up.", err=True)
-        return
+         click.echo("Error: LLM provider not configured. Please run with --change-model to set it up.", err=True)
+         return
 
     copilot = OpenCopilot()
     if ctx.invoked_subcommand is None:
-        if task:
-            copilot.run_task(user_prompt=task, max_iter=max_iter)
-        else:
-            copilot.run()
+         if task:
+             copilot.run_task(user_prompt=task, max_iter=max_iter)
+         else:
+             copilot.run()
 
-@cli.command('list-tools')
+@cli.command("list-tools")
 def list_tools():
-    """List all available automation tools"""
+    """List all available automation tools."""
     tools = OpenCopilot.list_available_tools()
     click.echo("Available Tools:")
     for tool in tools:
-        click.echo(f"- {tool['name']}: {tool['summary']}")
-        if tool.get('arguments'):
-            click.echo(f"    Arguments: {tool['arguments']}")
+         click.echo(f"- {tool['name']}: {tool['summary']}")
+         if tool.get("arguments"):
+             click.echo(f"    Arguments: {tool['arguments']}")
 
-@cli.command('list-models')
+@cli.command("list-models")
 def list_models():
-    """List all available LLM providers and their models (litellm compatible)"""
+    """List all available LLM providers and their models (litellm compatible)."""
     click.echo("Available LLM Providers and Models (litellm compatible):")
-    for provider_key, model_list in AVAILABLE_MODELS.items():
-        click.echo(f"\n{provider_key.upper()}:") # provider_key is "openai", "mistral", etc.
-        for model_name_full in model_list: # model_name_full is "openai/gpt-4o", etc.
-            click.echo(f"  - {model_name_full}")
+    for (provider_key, model_list) in AVAILABLE_MODELS.items():
+         click.echo(f"\n{provider_key.upper()}:")
+         for model_name_full in model_list:
+             click.echo(f"  - {model_name_full}")
 
-@cli.command('set-api-key')
-@click.option('--provider', '-p', type=click.Choice(list(AVAILABLE_MODELS.keys())), 
-              help='The LLM provider to set API key for')
-@click.option('--key', '-k', help='The API key to set (if not provided, will prompt for it)')
+@cli.command("set-api-key")
+@click.option("--provider", "-p", type=click.Choice(list(AVAILABLE_MODELS.keys())), help="The LLM provider to set API key for")
+@click.option("--key", "-k", help="The API key to set (if not provided, will prompt for it)")
 def set_api_key(provider, key):
-    """Set or update API key for a specific LLM provider"""
+    """Set or update API key for a specific LLM provider."""
     if not provider:
-        # If no provider specified, ask user to choose
-        questions = [
-            inquirer.List('provider_key',
-                message="Select LLM Provider to update API key",
-                choices=list(AVAILABLE_MODELS.keys())
-            )
-        ]
-        provider = inquirer.prompt(questions)['provider_key']
-    
-    # Get the environment variable name for this provider
+         questions = [ inquirer.List("provider_key", message="Select LLM Provider to update API key", choices=list(AVAILABLE_MODELS.keys())) ]
+         provider = inquirer.prompt(questions)["provider_key"]
     env_var = API_KEYS.get(provider)
     if not env_var:
-        raise ValueError(f"Unknown provider: {provider}")
-    
-    # Get the API key (either from command line or prompt)
+         raise ValueError(f"Unknown provider: {provider}")
     if not key:
-        questions = [
-            inquirer.Text('api_key',
-                message=f"Enter your {provider.upper()} API key",
-                validate=lambda _, x: len(x.strip()) > 0
-            )
-        ]
-        key = inquirer.prompt(questions)['api_key']
-    
-    # Get the path to .env file
+         questions = [ inquirer.Text("api_key", message=f"Enter your {provider.upper()} API key", validate=lambda _, x: len(x.strip()) > 0) ]
+         key = inquirer.prompt(questions)["api_key"]
     env_path = os.path.join(os.path.dirname(__file__), '../.env')
-    
-    # Read existing .env file if it exists
     lines = []
     if os.path.exists(env_path):
-        with open(env_path, 'r') as f:
-            lines = f.readlines()
-    
-    # Update or add the API key
+         with open(env_path, 'r') as f:
+             lines = f.readlines()
     key_line = f"{env_var}={key}\n"
     key_exists = False
-    
-    for i, line in enumerate(lines):
-        if line.strip().startswith(f"{env_var}=") or line.strip().startswith(f"#{env_var}="):
-            lines[i] = key_line
-            key_exists = True
-            break
-    
+    for (i, line) in enumerate(lines):
+         if (line.strip().startswith(f"{env_var}=") or line.strip().startswith(f"#{env_var}=")):
+             lines[i] = key_line
+             key_exists = True
+             break
     if not key_exists:
-        lines.append(key_line)
-    
-    # Write back to .env file
+         lines.append(key_line)
     with open(env_path, 'w') as f:
-        f.writelines(lines)
-    
+         f.writelines(lines)
     click.echo(f"API key for {provider.upper()} has been updated successfully in {env_path}")
 
+@cli.command("set-serp-key")
+@click.option("--key", "-k", help="The SERP API key to set (if not provided, will prompt for it)")
+def set_serp_key(key):
+    """Set or update the SERP API key used for web search functionality."""
+    if not key:
+         questions = [ inquirer.Text("api_key", message="Enter your SERP API key", validate=lambda _, x: len(x.strip()) > 0) ]
+         key = inquirer.prompt(questions)["api_key"]
+    env_path = os.path.join(os.path.dirname(__file__), '../.env')
+    lines = []
+    if os.path.exists(env_path):
+         with open(env_path, 'r') as f:
+             lines = f.readlines()
+    key_line = f"SERP_API_KEY={key}\n"
+    key_exists = False
+    for (i, line) in enumerate(lines):
+         if (line.strip().startswith("SERP_API_KEY=") or line.strip().startswith("#SERP_API_KEY=")):
+             lines[i] = key_line
+             key_exists = True
+             break
+    if not key_exists:
+         lines.append(key_line)
+    with open(env_path, 'w') as f:
+         f.writelines(lines)
+    click.echo(f"SERP API key has been updated successfully in {env_path}")
+
 if __name__ == '__main__':
     cli() 

{pikoai-0.1.15.dist-info → pikoai-0.1.17.dist-info}/METADATA

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

{pikoai-0.1.15.dist-info → pikoai-0.1.17.dist-info}/RECORD

@@ -1,9 +1,9 @@
 OpenCopilot.py,sha256=kPTs0-ly84h4dM7AmBlK4uwst5Sj2AM6UAlE3okkD8U,12157
-cli.py,sha256=qDWlKyOUkhDHSBxQ2wjy1e6KGRsDxE7pjxUZKjQFC3k,13959
+cli.py,sha256=MJSassshPDTHrvdw3kRDob7CK1CeEir_TgJvMv4cxyw,11229
 Agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Agents/Executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Agents/Executor/executor.py,sha256=NHdPXL_jhSHqgXxbkCfvkxI-M2I-cRcv_y77i_szpow,8232
-Agents/Executor/prompts.py,sha256=dWmUiAloNN_NKwWgaG_IqHDhCX1O-VhwbadUL-16gZw,2903
+Agents/Executor/executor.py,sha256=kk5TpfTUrunIl1gv5ZZO2UIm5PC4ZygeiB4z0YAJ_PY,7018
+Agents/Executor/prompts.py,sha256=pGY4uXNGYiw_TnTUsRjrVsWc9CV657q3916eui0oulU,2688
 Env/__init__.py,sha256=KLe7UcNV5L395SxhMwbYGyu7KPrSNaoV_9QJo3mLop0,196
 Env/base_env.py,sha256=K4PoWwPXn3pKeu7_-JOlUuyNbyYQ9itMhQybFOm-3K4,1563
 Env/base_executor.py,sha256=awTwJ44CKWV4JO2KUHfHDX0p1Ujw55hlaL5oNYTEW9M,893
@@ -16,20 +16,20 @@ Env/tests/test_python_executor.py,sha256=5kfs0cOf-RgWTOers_1wB0yvYSF-HrHPsraJ-Px
 Env/tests/test_shell_executor.py,sha256=-RcCdSUMoRAXHISIh0IR5MCutco80fX2S3sQBcinc_Q,1034
 Tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Tools/file_task.py,sha256=VUhWq_G-SWvGahQo8PG7TOpElHUW3BGLUabrTdJS89o,12151
-Tools/system_details.py,sha256=7-mTm3CG4NoatHcvcosalEgEcpWlNsCsZ7kuS3y_EmY,2262
-Tools/tool_dir.json,sha256=pEqI-1rKud-VEWHYLF2Pbv6xwQZWy62HUF_1hjcdhCY,3128
-Tools/tool_manager.py,sha256=86qwREw5an12dweIGCS1NNgINwHikyTxUpbjPWoLbt0,4118
-Tools/userinp.py,sha256=vUhEj3y1W1_ZFHqo2xQwvqDyeOg3VsisSKTI0EurUH8,1205
-Tools/web_loader.py,sha256=PyZk2g7WngZT0tCLs9Danx20dYspnaZwy4rlVE9Sx_4,5054
-Tools/web_search.py,sha256=mdbqWSJgMjxedrdFocHGfvOGsAq4R1H13yVev71UHkM,3164
+Tools/system_details.py,sha256=RScVnhTpUOlNG0g5bGnwmtNr5nSJzOec8HJSFpbicds,2651
+Tools/tool_dir.json,sha256=RTawcanxIkJaUys6Y3yftXAT5uxMH0xPZYTtD1ilJl0,3119
+Tools/tool_manager.py,sha256=xrjrGmLI1hXqCfALBRBuMFCgXwc7pb5TpKMBH_4tCzs,4106
+Tools/userinp.py,sha256=SK69fMEdUvNQor9V3BVckeDMJcq71g6H6EHPmNfsZD4,834
+Tools/web_loader.py,sha256=_oP48uwveTaCKU7G5ju2zsJGTcZd1ScXTKOvHDFtZJU,4564
+Tools/web_search.py,sha256=12_VhwJGXmn3oUNhTbQ5ENFG964t9DWkfCz3UtlxrbM,2261
 Utils/__init__.py,sha256=oukU0ufroPRd8_N8d2xiFes9CTxSaw4NA6p2nS1kkSg,16
 Utils/executor_utils.py,sha256=WwK3TKgw_hG_crg7ijRaqfidYnnNXYbbs37vKZRYK-0,491
 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.15.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
-pikoai-0.1.15.dist-info/METADATA,sha256=kWctaTcc3FCoOqkr-bS_lRCy4OK4HsIYvzd_dOqt9Jc,2962
-pikoai-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pikoai-0.1.15.dist-info/entry_points.txt,sha256=xjZnheDymNDnQ0o84R0jZKEITrhNbzQWN-AhqfA_d6s,50
-pikoai-0.1.15.dist-info/top_level.txt,sha256=hWzBNE7UQsuNcENIOksGcJED08k3ZGRRn2X5jnStICU,53
-pikoai-0.1.15.dist-info/RECORD,,
+pikoai-0.1.17.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
+pikoai-0.1.17.dist-info/METADATA,sha256=6RNL3fe8b177XNA4YfqQKC9o8YFe--RQ5DKBafQfhpg,2962
+pikoai-0.1.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pikoai-0.1.17.dist-info/entry_points.txt,sha256=xjZnheDymNDnQ0o84R0jZKEITrhNbzQWN-AhqfA_d6s,50
+pikoai-0.1.17.dist-info/top_level.txt,sha256=hWzBNE7UQsuNcENIOksGcJED08k3ZGRRn2X5jnStICU,53
+pikoai-0.1.17.dist-info/RECORD,,