PikoAi 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

Agents/Executor/executor.py

@@ -4,6 +4,8 @@
 import os
 import sys
 import time
+import logging
+import json
 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
@@ -30,11 +32,28 @@ class executor:
         self.user_prompt = user_prompt
         self.max_iter = max_iter
         self.rate_limiter = RateLimiter(wait_time=3.0, max_retries=3)
+        
+        # Load environment configuration
+        self.environment = self.load_environment_config()
+        
+        # Setup logging if in development environment
+        if self.environment == "development":
+            self.setup_logging()
+        
         self.executor_prompt_init()  # Update system_prompt
         # self.python_executor = python_executor.PythonExecutor()  # Initialize PythonExecutor
         # self.shell_executor = ShellExecutor() # Initialize ShellExecutor
         self.message = [
             {"role": "system", "content": self.system_prompt},
+            {"role":"user","content":"Hi"},
+            {"role":"assistant","content":"""```json
+{
+    "tool_name": "get_user_input",
+     "input": {
+        "query": "Hi,im your terminal assistant. How can I help you?"
+    }
+}
+```"""},
             {"role": "user", "content": self.user_prompt}
         ]
         self.terminal = TerminalInterface()
@@ -74,6 +93,10 @@ class executor:
 
                 response = self.llm.chat(self.message) # LiteLLMInterface.chat() returns the full response string
 
+                # Log response in development environment
+                if self.environment == "development":
+                    self.logger.info(f"LLM Response: {response}")
+
                 # Streaming is handled within LiteLLMInterface.chat()
                 # and TerminalInterface.process_markdown_chunk()
                 if response.strip():
@@ -144,6 +167,48 @@ class executor:
     #     result = exec_env.execute(code)
     #     return result
 
+    def load_environment_config(self):
+        """Load environment configuration from config.json"""
+        try:
+            config_path = os.path.join(os.path.dirname(__file__), '../../../config.json')
+            with open(config_path, "r") as config_file:
+                config = json.load(config_file)
+                return config.get("environment", "production")
+        except Exception as e:
+            
+            return "production"
+
+    def setup_logging(self):
+        """Setup logging for development environment"""
+        try:
+            # Create logs directory if it doesn't exist
+            logs_dir = os.path.join(os.path.dirname(__file__), '../../../logs')
+            os.makedirs(logs_dir, exist_ok=True)
+            
+            # Create a specific logger for executor responses
+            self.logger = logging.getLogger('executor_responses')
+            self.logger.setLevel(logging.INFO)
+            
+            # Prevent propagation to parent loggers (this stops console output)
+            self.logger.propagate = False
+            
+            # Remove any existing handlers to avoid duplicates
+            for handler in self.logger.handlers[:]:
+                self.logger.removeHandler(handler)
+            
+            # Add file handler only (no console output)
+            log_file = os.path.join(logs_dir, 'executor_responses.log')
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+            self.logger.addHandler(file_handler)
+            
+            # Suppress LiteLLM's verbose logging
+            logging.getLogger('litellm').setLevel(logging.WARNING)
+            
+            self.logger.info("Development logging enabled for executor responses")
+        except Exception as e:
+            print(f"Warning: Could not setup logging: {e}")
+
 if __name__ == "__main__":
     # e1 = executor("") # Commenting out example usage for now as it might need adjustment
     # user_prompt = input("Please enter your prompt: ")
@@ -160,4 +225,4 @@ if __name__ == "__main__":
     #     e1.message.append({"role": "user", "content": user_prompt})
     #     # e1.message.append({"role":"user","content":e1.system_prompt})
     #     e1.run()
-    pass # Placeholder if main execution is commented out
+    pass 

Agents/Executor/prompts.py

@@ -23,22 +23,22 @@ Your primary objective is to accomplish the user's goal by performing step-by-st
 
 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>>
+## Action Guidelines:
+- **Tool Call**: Use when a specific tool can help with the current step. Format your tool calls as a JSON object within a markdown code block starting with ```json.
+ like this : 
+  ```json
   {{
     "tool_name": "name_of_tool",
     "input": {{
-      "key": "value"   //Replace 'key' with the actual parameter name for the tool
+      "key": "value"   // Replace 'key' with the actual parameter name for the tool
     }}
   }}
-  <<END_TOOL_CALL>>
-  
-- **Direct Response**: Provide a direct answer if the task doesn't require tool calling
+  ```
+  Ensure your entire response for a tool call is *only* this markdown code block if a tool call is being made.
+- **Direct Response**: Provide a direct answer if the task doesn't require tool calling. If providing a direct response, do not use the markdown JSON code block.
 
 
-These are the things that you learned from the mistakes you made earlier :
+These are the points 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
@@ -56,7 +56,18 @@ These are the things that you learned from the mistakes you made earlier :
 - 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 without evaluating its output.
 - The best way to give output is to save it open the file using shell commands.
-- The tool call in json format should be done between the delimiters <<TOOL_CALL>> and <<END_TOOL_CALL>>.
+- The tool call in json format must be done between the delimiters <<TOOL_CALL>> and <<END_TOOL_CALL>>. This is non-negotiable.
+
+for e.g. User: what is the latest news on Ai.
+your response should be :
 
+```json
+{{
+  "tool_name": "web_search",
+  "input": {{
+    "query": "latest news"
+  }}
+}}
+```
 
 """

Env/__init__.py

@@ -1,5 +1 @@
-from .base_executor import BaseExecutor
-from .python_executor import PythonExecutor
-from .js_executor import JavaScriptExecutor
 
-__all__ = ["BaseExecutor", "PythonExecutor", "JavaScriptExecutor"]

Env/python_executor.py

@@ -1,20 +1,3 @@
-# from .base_executor import BaseExecutor
-
-# class PythonExecutor():
-#     def execute(self, code: str) -> str:
-#         """Executes Python code and returns the result or an error message."""
-
-#         # if not self.validate_code(code):
-#         #     return "Code validation failed: Unsafe code detected."
-
-#         local_vars = {}
-#         try:
-#             exec(code, {}, local_vars)  # Execute code in an isolated environment
-#             return local_vars.get("output", "Code executed successfully.")
-#         except Exception as e:
-#             # return self.handle_error(e)
-#             print("error in running python code", e)
-
 import subprocess
 import tempfile
 import os

OpenCopilot.py

@@ -257,7 +257,11 @@ Examples:
             print("\nGoodbye!")
         except Exception as e:
             print_formatted_text(FormattedText([
-                ('class:error', f"Failed to start OpenCopilot: {e}")
+                ('class:error', f"Failed to start OpenCopilot: {e.__class__.__name__}: {e}")
+            ]))
+            import traceback
+            print_formatted_text(FormattedText([
+                ('class:error', f"Error occurred at: {traceback.format_exc()}")
             ]))
 
     def run_task(self, user_prompt, max_iter=10):

Tools/tool_manager.py

@@ -9,10 +9,12 @@ from Tools.system_details import get_os_details, get_datetime, get_memory_usage,
 from Tools.userinp import get_user_input
 from Env.python_executor import PythonExecutor
 from Env.shell import ShellExecutor
+from Utils.ter_interface import TerminalInterface
 
 #need to transform it into map of dictionary
 #name : [function : xyz,description : blah bah]
 
+terminal = TerminalInterface()
 
 
 
@@ -20,9 +22,9 @@ def execute_python_code_tool(code: str) -> str:
     """ 
     Prompts for confirmation, then executes the given Python code and returns a formatted result string.
     """
-    user_confirmation = input(f"Do you want to execute this Python code snippet?\n```python\n{code}\n```\n(y/n): ")
+    terminal.code_log(code)
+    user_confirmation = input(f"Do you want to execute this Python code snippet?\n(y/n): ")
     if user_confirmation.lower() != 'y':
-        print("Python code execution skipped by the user.")
         return "User chose not to execute the Python code."
     executor = PythonExecutor()
     result = executor.execute(code)
@@ -48,9 +50,9 @@ def execute_shell_command_tool(command: str) -> str:
     """
     Prompts for confirmation, then executes the given shell command and returns a formatted result string.
     """
-    user_confirmation = input(f"Do you want to execute the shell command: '{command}'? (y/n): ")
+    terminal.code_log(command)
+    user_confirmation = input(f"Do you want to execute the shell command? (y/n): ")
     if user_confirmation.lower() != 'y':
-        print("Shell command execution skipped by the user.")
         return "User chose not to execute the shell command."
     executor = ShellExecutor()
     result = executor.execute(command)
@@ -73,11 +75,13 @@ def call_tool(tool_name, tool_input):
         tool_name (str): Name of the tool to call
         tool_input (dict): Input parameters for the tool
     """
+    
     if tool_name in tools_function_map:
         # Pass the tool_input dictionary as kwargs to the tool function
         return tools_function_map[tool_name](**tool_input)
-    else:
-        return f"This tool is invalid. Please check the tools available in the tool directory"
+    else: raise ValueError(f"This tool is invalid. Please check the tools available in the tool directory")
+    
+        
 
 tools_function_map = {
     "web_loader": load_data,

Tools/web_loader.py

@@ -125,7 +125,7 @@ def load_data(**kwargs):
     }
     content = ""
     try:
-        response = session.get(url, headers=headers, timeout=30)
+        response = session.get(url, headers=headers, timeout=3)
         response.raise_for_status()
         data = response.content
         # Check content type
@@ -138,6 +138,12 @@ 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()])
 
+    except requests.exceptions.Timeout:
+        logging.error(f"Timeout error loading data from {url}: The webpage didn't load in time")
+        content = f"Error: The webpage at {url} didn't load in time. Please try again later or check other urls for the task. use web_search tool to find other urls."
+    except requests.exceptions.RequestException as e:
+        logging.error(f"Request error loading data from {url}: {e}")
+        content = f"Error: Failed to load webpage at {url}. {str(e)}"
     except Exception as e:
         logging.error(f"Error loading data from {url}: {e}")
         content = ""

Utils/executor_utils.py

@@ -1,15 +1,32 @@
 import json
 from typing import Optional
 
+import re
+
 def parse_tool_call(response: str) -> Optional[dict]:
     """
-    Parses a tool call from the response.
+    Parses a tool call from the response, expecting it in a markdown JSON code block.
+    Example:
+    ```json
+    {
+        "tool_name": "tool_name",
+        "input": {"arg": "value"}
+    }
+    ```
     """
-    if "<<TOOL_CALL>>" in response and "<<END_TOOL_CALL>>" in response:
-        tool_call_str = response.split("<<TOOL_CALL>>")[1].split("<<END_TOOL_CALL>>")[0].strip()
+    # Regex to find ```json ... ``` blocks
+    # It captures the content within the fences.
+    # re.DOTALL allows '.' to match newlines, which is crucial for multi-line JSON.
+    match = re.search(r"```json\s*([\s\S]+?)\s*```", response, re.DOTALL)
+
+    if match:
+        json_str = match.group(1).strip()
         try:
-            tool_call = json.loads(tool_call_str)
-            return tool_call
+            tool_call = json.loads(json_str)
+            # Basic validation for the expected structure
+            if isinstance(tool_call, dict) and "tool_name" in tool_call and "input" in tool_call:
+                return tool_call
         except json.JSONDecodeError:
+            # Invalid JSON within the markdown block
             return None
     return None

Utils/ter_interface.py

@@ -5,6 +5,8 @@ from rich.panel import Panel
 from rich.text import Text
 from rich.markdown import Markdown
 from rich.syntax import Syntax
+from yaspin import yaspin
+import time
 
 import json
 
@@ -36,12 +38,7 @@ class TerminalInterface:
         elif not isinstance(message, str):
             message = str(message)
 
-        # Original code:
-        # panel = Panel(
-        #     Text(message, style="orange"),
-        #     title=f"[bold green]{tool_name} Output[/bold green]",
-        #     border_style="green"
-        # )
+      
         panel = Panel(
             Text(message, style="blue"),
             title=f"[bold green]{tool_name} Output[/bold green]",
@@ -49,6 +46,17 @@ class TerminalInterface:
         )
         self.console.print(panel)
 
+    def code_log(self, code: str):
+        """
+        Print a code snippet in a formatted panel.
+        """
+        panel = Panel(
+            Syntax(code, "python", theme="monokai", line_numbers=True),
+            title=f"[bold green]Code Snippet[/bold green]",
+            border_style="green"
+        )
+        self.console.print(panel)
+
     def process_markdown_chunk(self, chunk):
         """
         Process a chunk of markdown text, handling tool calls and regular markdown.
@@ -61,15 +69,19 @@ class TerminalInterface:
             line_stripped = line.strip()
 
             # Handle tool call opening delimiter - be more flexible with whitespace
-            if "<<TOOL_CALL>>" in line_stripped:
+            if "```json" in line_stripped:
                 self.inside_tool_call = True
                 self.tool_call_buffer = ""
-                self.console.print("[bold cyan]Tool Call:[/bold cyan]")
+                # self.console.print("[bold cyan]Tool Call:[/bold cyan]")
+                self.spinner = yaspin(text="Tool Call...", color="yellow")
+                self.spinner.start()
 
             # Handle tool call closing delimiter - be more flexible with whitespace
-            elif "<<END_TOOL_CALL>>" in line_stripped:
-                self.console.print(self.tool_call_buffer)
-                # self.console.print(Syntax('{"status": "end_tool_call"}', "json", theme="monokai", line_numbers=False))
+            elif "```" in line_stripped and self.inside_tool_call:
+                if hasattr(self, 'spinner'):
+                    self.spinner.stop()
+                    delattr(self, 'spinner')
+                self._display_tool_call_content()
                 self.console.print("[bold cyan]--------------------------------[/bold cyan]")
                 self.inside_tool_call = False
                 self.tool_call_buffer = ""
@@ -82,14 +94,58 @@ class TerminalInterface:
             else:
                 self.console.print(Markdown(line))
 
+    def _display_tool_call_content(self):
+        """
+        Parse and display tool call JSON content in a simple key-value format.
+        """
+        try:
+            # Try to parse the JSON content
+            json_content = json.loads(self.tool_call_buffer.strip())
+            
+            # Check if tool_name is execute_python_code or execute_shell_command
+            if 'tool_name' in json_content and json_content['tool_name'] in ['execute_python_code', 'execute_shell_command']:
+                return
+            
+            # Build content for the panel
+            panel_content = ""
+            for key, value in json_content.items():
+                if isinstance(value, dict):
+                    panel_content += f"{key}:\n"
+                    for sub_key, sub_value in value.items():
+                        panel_content += f"  {sub_key}: {sub_value}\n"
+                else:
+                    panel_content += f"{key}: {value}\n"
+            
+            # Create and display panel
+            panel = Panel(
+                panel_content.strip(),
+                title="[yellow]Tool Call[/yellow]",
+                border_style="blue"
+            )
+            self.console.print(panel)
+        except json.JSONDecodeError:
+            # If JSON parsing fails, display the raw content in a panel
+            panel = Panel(
+                self.tool_call_buffer.strip(),
+                title="[bold red]Raw Tool Call Content[/bold red]",
+                border_style="red"
+            )
+            self.console.print(panel)
+
     def flush_markdown(self):
         """
         Flush any remaining markdown content in the buffer.
         """
         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]")
+
+            if hasattr(self, 'spinner'):
+                self.spinner.stop()
+                delattr(self, 'spinner')
+
+            if self.tool_call_buffer.strip():
+                self._display_tool_call_content()
+            self.console.print("[bold cyan]--------------------------------[/bold cyan]")
             self.inside_tool_call = False
         elif self.buffer:
             if "TASK_DONE" in self.buffer:

llm_interface/llm.py

@@ -51,6 +51,7 @@ class LiteLLMInterface:
                 model=self.model_name,
                 messages=messages,
                 stream=True,
+                temperature=0.2
             )
 
             for chunk in stream_response:

{pikoai-0.1.23.dist-info → pikoai-0.1.25.dist-info}/METADATA

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

pikoai-0.1.25.dist-info/RECORD

@@ -0,0 +1,32 @@
+OpenCopilot.py,sha256=WPorkGh0ffB4m47mXF6Tza47SVqPRCGcQCTeZQTfghY,12355
+cli.py,sha256=2UvmH74pcBFFezI0WHNyWTHMYasIM5NGnrUX6wsdveM,12945
+Agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Agents/Executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Agents/Executor/executor.py,sha256=0mskJv5ol4yPEhQytCJX_7rHzdoJmwI6aIwrUr4blpI,9765
+Agents/Executor/prompts.py,sha256=Q1b7WPdrUXYQZgj7l4M0Exz1Rr9b_SQUpRfV7uZRSkA,3447
+Env/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+Env/base_env.py,sha256=K4PoWwPXn3pKeu7_-JOlUuyNbyYQ9itMhQybFOm-3K4,1563
+Env/python_executor.py,sha256=g9I2A1vI7eLQJyN_ZByrRDL_yDcPoneCMMxwRXQzNOE,4018
+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
+Tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Tools/file_task.py,sha256=Sqn8GWB7UHljUmUniYbkTiC_63LkVIVU4aXgudtLNTI,12566
+Tools/system_details.py,sha256=RScVnhTpUOlNG0g5bGnwmtNr5nSJzOec8HJSFpbicds,2651
+Tools/tool_dir.json,sha256=RTawcanxIkJaUys6Y3yftXAT5uxMH0xPZYTtD1ilJl0,3119
+Tools/tool_manager.py,sha256=l_ZEFlPAfnkuz31-pH_pXclgTnxZU3NvVDUT42tHH2A,4109
+Tools/userinp.py,sha256=SK69fMEdUvNQor9V3BVckeDMJcq71g6H6EHPmNfsZD4,834
+Tools/web_loader.py,sha256=N2J_0kl-y-YHwqaoFr7EXppaa4AuhavsrbGvMcFFJNg,5060
+Tools/web_search.py,sha256=12_VhwJGXmn3oUNhTbQ5ENFG964t9DWkfCz3UtlxrbM,2261
+Utils/__init__.py,sha256=oukU0ufroPRd8_N8d2xiFes9CTxSaw4NA6p2nS1kkSg,16
+Utils/executor_utils.py,sha256=ikcgkXFlqM9pr7Jaq4eZj6_5XB48EE52A3b3kMK25ss,1005
+Utils/ter_interface.py,sha256=vB_Gj1vXyTI6iWqUmojb7RBaGcvMJn5hB2vvij76bBY,5852
+llm_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+llm_interface/llm.py,sha256=nnTfzW-wdWoRd_ZtGxCqv33qf5V2uni8nQpzXDN0A0Y,5112
+pikoai-0.1.25.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
+pikoai-0.1.25.dist-info/METADATA,sha256=lf9M5nmsN-Qet_v7GpImFd-LWDRXSCgWN6hjaGaAptM,2962
+pikoai-0.1.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pikoai-0.1.25.dist-info/entry_points.txt,sha256=xjZnheDymNDnQ0o84R0jZKEITrhNbzQWN-AhqfA_d6s,50
+pikoai-0.1.25.dist-info/top_level.txt,sha256=hWzBNE7UQsuNcENIOksGcJED08k3ZGRRn2X5jnStICU,53
+pikoai-0.1.25.dist-info/RECORD,,

Env/base_executor.py

@@ -1,24 +0,0 @@
-# mostly won't need this. there will be only one base env
-
-from abc import ABC, abstractmethod
-
-class BaseExecutor(ABC):
-    pass
-#     def __init__(self):
-#         pass
-
-#     @abstractmethod
-#     def execute(self, code: str):
-#         """Executes the given code and returns the output or error."""
-#         pass
-
-#     def validate_code(self, code: str) -> bool:
-#         """Basic validation to ensure code is safe to execute. Override for custom rules."""
-#         # Implement basic checks (e.g., preventing dangerous commands)
-#         if "import os" in code or "import sys" in code:
-#             return False  # Disallow potentially unsafe imports for security
-#         return True
-
-#     def handle_error(self, error: Exception) -> str:
-#         """Handles errors during execution and returns a standardized error message."""
-#         return f"Execution failed: {str(error)}"

Env/env.py

@@ -1,5 +0,0 @@
-#mostly won't need this. There will be only one base env
-
-# import base_env from base_env
-
-# class env(base_env):

Env/js_executor.py

@@ -1,63 +0,0 @@
-import subprocess
-import sys
-
-class JavaScriptExecutor():
-    def __init__(self):
-        super().__init__()
-        self.node_installed = self.check_node_installed()
-
-    def check_node_installed(self) -> bool:
-        """Checks if Node.js is installed on the system."""
-        try:
-            subprocess.run(["node", "-v"], capture_output=True, check=True)
-            return True
-        except subprocess.CalledProcessError:
-            return False
-        except FileNotFoundError:
-            return False
-
-    def install_node(self) -> bool:
-        """Attempts to install Node.js based on the operating system."""
-        try:
-            if sys.platform.startswith("linux"):
-                # Try to install Node.js using apt-get (for Debian/Ubuntu-based systems)
-                subprocess.run(["sudo", "apt-get", "update"], check=True)
-                subprocess.run(["sudo", "apt-get", "install", "-y", "nodejs"], check=True)
-            elif sys.platform == "darwin":
-                # Try to install Node.js using Homebrew on macOS
-                subprocess.run(["brew", "install", "node"], check=True)
-            elif sys.platform == "win32":
-                # Check if Chocolatey is installed, and install Node.js
-                subprocess.run(["choco", "install", "nodejs", "-y"], check=True)
-            else:
-                return False  # Unsupported OS for automatic installation
-            return True
-        except subprocess.CalledProcessError:
-            return False  # Installation failed
-
-    def execute(self, code: str) -> str:
-        """Executes JavaScript code using Node.js and returns the result or an error message."""
-        # Check if Node.js is installed, attempt installation if not
-        if not self.node_installed:
-            if not self.install_node():
-                return "Node.js is not installed, and automatic installation failed. Please install Node.js manually."
-
-        # Recheck after attempted installation
-        self.node_installed = self.check_node_installed()
-        if not self.node_installed:
-            return "Node.js is required but not installed. Please install Node.js manually."
-
-        # Proceed with code execution if Node.js is available
-        # if not self.validate_code(code):
-        #     return "Code validation failed: Unsafe code detected."
-
-        try:
-            result = subprocess.run(
-                ["node", "-e", code],
-                capture_output=True,
-                text=True,
-                check=True
-            )
-            return result.stdout if result.stdout else "Code executed successfully."
-        except subprocess.CalledProcessError as e:
-            print(e)

pikoai-0.1.23.dist-info/RECORD

@@ -1,35 +0,0 @@
-OpenCopilot.py,sha256=kPTs0-ly84h4dM7AmBlK4uwst5Sj2AM6UAlE3okkD8U,12157
-cli.py,sha256=2UvmH74pcBFFezI0WHNyWTHMYasIM5NGnrUX6wsdveM,12945
-Agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Agents/Executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Agents/Executor/executor.py,sha256=S83Rc1JVWuGvgnhV_fPMoCp8V4wwitbWy2MO_yV22X4,7212
-Agents/Executor/prompts.py,sha256=PNginWQYp5M4juNcmYiUOWlkIP4OU_5tguz5WK7wYQk,3000
-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=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
-Tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Tools/file_task.py,sha256=Sqn8GWB7UHljUmUniYbkTiC_63LkVIVU4aXgudtLNTI,12566
-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=8Oe5818MAYC21SfUxtfnV9HQFcQ49z8Q030jjPqNP_g,3889
-llm_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-llm_interface/llm.py,sha256=Am18eyEFYlgcackuYGz8_Y0L7lQ7SSUCpNAEjcyZaAU,5080
-pikoai-0.1.23.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
-pikoai-0.1.23.dist-info/METADATA,sha256=cV0qBMhVLSwLEcjlVk6Rt1GdyDa2rrOUH8QxwUEGMbM,2962
-pikoai-0.1.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pikoai-0.1.23.dist-info/entry_points.txt,sha256=xjZnheDymNDnQ0o84R0jZKEITrhNbzQWN-AhqfA_d6s,50
-pikoai-0.1.23.dist-info/top_level.txt,sha256=hWzBNE7UQsuNcENIOksGcJED08k3ZGRRn2X5jnStICU,53
-pikoai-0.1.23.dist-info/RECORD,,