PikoAi 0.1.23__tar.gz → 0.1.25__tar.gz

{pikoai-0.1.23/Src/PikoAi.egg-info → pikoai-0.1.25}/PKG-INFO

@@ -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.23 → pikoai-0.1.25}/Src/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 

{pikoai-0.1.23 → pikoai-0.1.25}/Src/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"
+  }}
+}}
+```
 
 """

{pikoai-0.1.23 → pikoai-0.1.25}/Src/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

{pikoai-0.1.23 → pikoai-0.1.25}/Src/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):

{pikoai-0.1.23 → pikoai-0.1.25/Src/PikoAi.egg-info}/PKG-INFO

@@ -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.23 → pikoai-0.1.25}/Src/PikoAi.egg-info/SOURCES.txt

@@ -9,9 +9,6 @@ Src/Agents/Executor/executor.py
 Src/Agents/Executor/prompts.py
 Src/Env/__init__.py
 Src/Env/base_env.py
-Src/Env/base_executor.py
-Src/Env/env.py
-Src/Env/js_executor.py
 Src/Env/python_executor.py
 Src/Env/shell.py
 Src/Env/tests/__init__.py
@@ -35,9 +32,4 @@ Src/Utils/__init__.py
 Src/Utils/executor_utils.py
 Src/Utils/ter_interface.py
 Src/llm_interface/__init__.py
-Src/llm_interface/llm.py
-test/test.py
-test/test_file_task.py
-test/test_opencopilot_file_integration.py
-test/testjs.py
-test/testscript.py
+Src/llm_interface/llm.py

pikoai-0.1.25/Src/PikoAi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

{pikoai-0.1.23 → pikoai-0.1.25}/Src/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,

{pikoai-0.1.23 → pikoai-0.1.25}/Src/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 = ""

pikoai-0.1.25/Src/Utils/executor_utils.py

@@ -0,0 +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, expecting it in a markdown JSON code block.
+    Example:
+    ```json
+    {
+        "tool_name": "tool_name",
+        "input": {"arg": "value"}
+    }
+    ```
+    """
+    # 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(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

{pikoai-0.1.23 → pikoai-0.1.25}/Src/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:

{pikoai-0.1.23 → pikoai-0.1.25}/Src/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 → pikoai-0.1.25}/setup.py

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

pikoai-0.1.23/Src/Env/__init__.py

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

pikoai-0.1.23/Src/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)}"

pikoai-0.1.23/Src/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):

pikoai-0.1.23/Src/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/Src/Utils/executor_utils.py

@@ -1,15 +0,0 @@
-import json
-from typing import Optional
-
-def parse_tool_call(response: str) -> Optional[dict]:
-    """
-    Parses a tool call from the response.
-    """
-    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()
-        try:
-            tool_call = json.loads(tool_call_str)
-            return tool_call
-        except json.JSONDecodeError:
-            return None
-    return None

pikoai-0.1.23/test/test.py

@@ -1,30 +0,0 @@
-import sys
-import os
-
-# Add the Src directory to the Python path
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../Src')))
-
-from Env.python_executor import PythonExecutor
-
-def read_test_script(filename):
-    """Read the content of a test script file"""
-    with open(filename, 'r') as file:
-        return file.read()
-
-def main():
-    # Initialize the Python executor
-    executor = PythonExecutor()
-    
-    # Get the full path to testscript1.txt
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    test_script_path = os.path.join(script_dir, 'testscript2.txt')
-    
-    # Read the test script
-    code = read_test_script(test_script_path)
-    
-    # Execute the code
-    result = executor.execute(code)
-    print(result)
-
-if __name__ == "__main__":
-    main()

pikoai-0.1.23/test/test_file_task.py

@@ -1,210 +0,0 @@
-import unittest
-import os
-import sys
-import shutil
-
-# Add Src directory to sys.path to allow direct import of file_reader
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../Src')))
-from Tools.file_task import file_reader
-
-class TestFileReader(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.assets_dir = os.path.join(os.path.dirname(__file__), "assets")
-        # Ensure assets_dir exists from the previous step, or re-create if needed by tests
-        if not os.path.exists(cls.assets_dir):
-            os.makedirs(cls.assets_dir)
-            # Re-create files if they are missing for some reason (e.g. if run standalone without prior step)
-            with open(os.path.join(cls.assets_dir, "test_sample.txt"), "w") as f:
-                f.write("This is a test TXT file.")
-            with open(os.path.join(cls.assets_dir, "test_sample.unknown_ext"), "w") as f:
-                f.write("This is an unknown extension test.")
-            with open(os.path.join(cls.assets_dir, "corrupted.pdf"), "w") as f:
-                f.write("This is not a PDF.")
-            with open(os.path.join(cls.assets_dir, "corrupted.docx"), "w") as f:
-                f.write("This is not a DOCX.")
-            with open(os.path.join(cls.assets_dir, "fake.pdf"), "w") as f:
-                f.write("This is a text file named fake.pdf.")
-            with open(os.path.join(cls.assets_dir, "fake.docx"), "w") as f:
-                f.write("This is a text file named fake.docx.")
-            open(os.path.join(cls.assets_dir, "empty.pdf"), "w").close()
-            open(os.path.join(cls.assets_dir, "empty.docx"), "w").close()
-            open(os.path.join(cls.assets_dir, "encrypted.pdf"), "w").close() # Simulate with empty file
-
-        # For home directory restriction testing
-        cls.test_home_dir = os.path.join(cls.assets_dir, "home_dir_test")
-        cls.sensitive_config_file_path = os.path.join(cls.test_home_dir, ".gitconfig") # Test with a file
-        cls.sensitive_ssh_dir_path = os.path.join(cls.test_home_dir, ".ssh") # Test with a dir
-        
-        os.makedirs(cls.test_home_dir, exist_ok=True)
-        os.makedirs(cls.sensitive_ssh_dir_path, exist_ok=True)
-        
-        with open(cls.sensitive_config_file_path, "w") as f:
-            f.write("sensitive test content")
-        
-        with open(os.path.join(cls.sensitive_ssh_dir_path, "config"), "w") as f:
-            f.write("ssh test content")
-
-    @classmethod
-    def tearDownClass(cls):
-        # Clean up the assets directory after all tests are done
-        # shutil.rmtree(cls.assets_dir) # Commented out to inspect files if needed
-        pass
-
-    def test_read_txt_successfully(self):
-        file_path = os.path.join(self.assets_dir, "test_sample.txt")
-        result = file_reader(file_path=file_path)
-        self.assertTrue(result["success"])
-        self.assertEqual(result["output"].strip(), "This is a test TXT file.")
-
-    def test_read_unknown_extension_as_text(self):
-        file_path = os.path.join(self.assets_dir, "test_sample.unknown_ext")
-        result = file_reader(file_path=file_path)
-        self.assertTrue(result["success"])
-        self.assertEqual(result["output"].strip(), "This is an unknown extension test.")
-
-    # Security - Forbidden Paths
-    def test_block_unix_forbidden_paths(self):
-        # Using a path that is guaranteed to be resolved by abspath and start with /etc/
-        # The security check for forbidden paths happens before os.path.isfile.
-        if os.name != "nt": # Only run this on non-Windows where /etc/ is common
-            # Path can be non-existent, check is on the string path
-            result = file_reader(file_path="/etc/some_non_existent_file_for_test")
-            self.assertFalse(result["success"])
-            self.assertIn("Access to system or restricted directory", result["output"])
-            self.assertIn("is not allowed", result["output"])
-        else:
-            self.skipTest("UNIX forbidden path test skipped on Windows.")
-
-    @unittest.skipIf(os.name != "nt", "Windows forbidden path test only applicable on Windows or needs refined path handling for x-platform testing.")
-    def test_block_windows_forbidden_paths(self):
-        # This test relies on the current OS being Windows or the file_reader's
-        # forbidden path logic correctly normalizing and matching Windows-style paths
-        # even when os.path.abspath produces a POSIX-style absolute path.
-        # As identified, the current file_reader might not do this robustly across OSes.
-        path_to_test = "C:\\Windows\\System.ini"
-        result = file_reader(file_path=path_to_test)
-        self.assertFalse(result["success"])
-        self.assertIn("Access to system or restricted directory", result["output"])
-        self.assertIn("is not allowed", result["output"])
-
-    @unittest.skipIf(os.name == "nt", "Test not applicable on Windows for POSIX sensitive paths")
-    def test_block_sensitive_home_file(self):
-        # Test reading a sensitive file like .gitconfig from the mocked home
-        original_expanduser = os.path.expanduser
-        try:
-            os.path.expanduser = lambda path: self.test_home_dir if path == "~" else original_expanduser(path)
-            # file_reader is expected to form path like "user_home/.gitconfig"
-            # We pass the absolute path to our test .gitconfig file
-            result = file_reader(file_path=self.sensitive_config_file_path)
-            self.assertFalse(result["success"])
-            self.assertIn("Access to sensitive user configuration file", result["output"])
-        finally:
-            os.path.expanduser = original_expanduser
-            
-    @unittest.skipIf(os.name == "nt", "Test not applicable on Windows for POSIX sensitive paths")
-    def test_block_sensitive_home_directory_access(self):
-        # Test reading a file within a sensitive directory like .ssh/config from the mocked home
-        original_expanduser = os.path.expanduser
-        try:
-            os.path.expanduser = lambda path: self.test_home_dir if path == "~" else original_expanduser(path)
-            # Path to a file within the .ssh directory
-            path_inside_sensitive_dir = os.path.join(self.sensitive_ssh_dir_path, "config")
-            result = file_reader(file_path=path_inside_sensitive_dir)
-            self.assertFalse(result["success"])
-            self.assertIn("Access to files within sensitive user directory", result["output"]) # Updated assertion
-        finally:
-            os.path.expanduser = original_expanduser
-
-
-    def test_path_traversal_attempt(self):
-        # Construct a path that tries to traverse up and then into /etc/
-        # Current working directory for tests is likely /app/Test/ or /app/
-        # If /app, then ../../../../../etc/hosts becomes /etc/hosts
-        # If /app/Test, then ../../../../../../etc/hosts becomes /etc/hosts
-        # os.path.abspath will resolve this.
-        malicious_path = os.path.join(self.assets_dir, "..", "..", "..", "..", "..", "..", "etc", "hosts")
-        # malicious_path = "../../../../../../../etc/hosts" # Simpler relative path
-        result = file_reader(file_path=malicious_path)
-        self.assertFalse(result["success"])
-        # The exact error message depends on whether /etc/ is in forbidden_dirs
-        # or if the path resolution itself is problematic for other reasons before that.
-        # Given current logic, it should be caught by forbidden_dirs.
-        self.assertIn("Access to system or restricted directory", result["output"])
-
-    # Error Handling Tests
-    def test_read_non_existent_file(self):
-        result = file_reader(file_path="non_existent_file.txt")
-        self.assertFalse(result["success"])
-        self.assertIn("does not exist", result["output"])
-
-    def test_read_corrupted_pdf(self): # Actually a text file named .pdf
-        file_path = os.path.join(self.assets_dir, "corrupted.pdf")
-        result = file_reader(file_path=file_path)
-        self.assertFalse(result["success"])
-        self.assertIn("Could not read PDF file", result["output"]) # From PyPDF2Errors.PdfReadError
-
-    def test_read_corrupted_docx(self): # Actually a text file named .docx
-        file_path = os.path.join(self.assets_dir, "corrupted.docx")
-        result = file_reader(file_path=file_path)
-        self.assertFalse(result["success"])
-        # Error: File '...' is not a valid DOCX file, is corrupted, or is not a compatible OOXML package.
-        self.assertIn("not a valid DOCX file", result["output"]) # From DocxOpcExceptions.PackageNotFoundError
-
-    def test_read_empty_pdf_as_corrupted(self): # An empty file is not a valid PDF
-        file_path = os.path.join(self.assets_dir, "empty.pdf")
-        result = file_reader(file_path=file_path)
-        self.assertFalse(result["success"])
-        self.assertIn("Could not read PDF file", result["output"])
-
-
-    def test_read_empty_docx_as_corrupted(self): # An empty file is not a valid DOCX
-        file_path = os.path.join(self.assets_dir, "empty.docx")
-        result = file_reader(file_path=file_path)
-        self.assertFalse(result["success"])
-        self.assertIn("not a valid DOCX file", result["output"])
-
-    def test_read_encrypted_pdf_simulated(self):
-        # Current file_reader checks `reader.is_encrypted`.
-        # An empty file (encrypted.pdf) will fail before this check, likely as a PdfReadError.
-        file_path = os.path.join(self.assets_dir, "encrypted.pdf")
-        result = file_reader(file_path=file_path)
-        self.assertFalse(result["success"])
-        # Expecting it to be caught by PdfReadError or similar, not the specific "encrypted" message unless it's a specially crafted PDF.
-        self.assertTrue(
-            "Could not read PDF file" in result["output"] or "encrypted" in result["output"]
-        )
-
-
-    def test_read_file_with_wrong_extension_pdf(self): # text file named fake.pdf
-        file_path = os.path.join(self.assets_dir, "fake.pdf")
-        result = file_reader(file_path=file_path)
-        self.assertFalse(result["success"])
-        self.assertIn("Could not read PDF file", result["output"])
-
-    def test_read_file_with_wrong_extension_docx(self): # text file named fake.docx
-        file_path = os.path.join(self.assets_dir, "fake.docx")
-        result = file_reader(file_path=file_path)
-        self.assertFalse(result["success"])
-        self.assertIn("not a valid DOCX file", result["output"])
-
-    # Skipped tests for actual PDF/DOCX content due to generation limitations
-    @unittest.skip("Skipping PDF content test: Cannot generate actual PDF with known content with available tools.")
-    def test_read_pdf_successfully(self):
-        pass
-
-    @unittest.skip("Skipping DOCX content test: Cannot generate actual DOCX with known content with available tools.")
-    def test_read_docx_successfully(self):
-        pass
-    
-    @unittest.skip("Skipping MacOS specific forbidden path for now.")
-    def test_block_macos_forbidden_paths(self):
-        # path_to_test = "/System/Library/Kernels"
-        # result = file_reader(file_path=path_to_test)
-        # self.assertFalse(result["success"])
-        # self.assertIn("Access to system or restricted directory", result["output"])
-        pass
-
-if __name__ == '__main__':
-    unittest.main(argv=['first-arg-is-ignored'], exit=False)

pikoai-0.1.23/test/test_opencopilot_file_integration.py

@@ -1,187 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock, call
-import os
-
-# Assuming OpenCopilot.py is in Src directory and uses:
-# from Tools.file_task import file_reader
-# from prompt_toolkit.shortcuts import print_formatted_text
-# So we patch them in Src.OpenCopilot context
-from Src.OpenCopilot import OpenCopilot, FormattedText
-
-class TestExtractFilesAndProcessPrompt(unittest.TestCase):
-
-    def setUp(self):
-        self.copilot = OpenCopilot()
-        # Default behavior for path functions to simplify tests
-        # These can be overridden in specific tests if needed
-        self.abspath_patcher = patch('os.path.abspath', side_effect=lambda x: '/abs/' + os.path.basename(x))
-        self.expanduser_patcher = patch('os.path.expanduser', side_effect=lambda x: x.replace('~', '/user/home'))
-        
-        self.mock_abspath = self.abspath_patcher.start()
-        self.mock_expanduser = self.expanduser_patcher.start()
-        
-        self.addCleanup(self.abspath_patcher.stop)
-        self.addCleanup(self.expanduser_patcher.stop)
-
-    @patch('Src.OpenCopilot.print_formatted_text')
-    @patch('Src.OpenCopilot.file_reader')
-    @patch('os.path.isfile')
-    @patch('os.path.exists')
-    def test_successful_text_file_load(self, mock_exists, mock_isfile, mock_file_reader, mock_print_formatted_text):
-        mock_exists.return_value = True
-        mock_isfile.return_value = True
-        mock_file_reader.return_value = {"success": True, "output": "Text content"}
-
-        user_input = "@test.txt explain this"
-        # Path seen by file_reader will be /abs/test.txt due to mock_abspath
-        expected_file_path_in_prompt = '/abs/test.txt'
-        
-        expected_final_prompt = f"=== Content of file: {expected_file_path_in_prompt} ===\nText content\n=== End of file: {expected_file_path_in_prompt} ===\n\nexplain this"
-        
-        result_prompt = self.copilot.extract_files_and_process_prompt(user_input)
-        
-        mock_file_reader.assert_called_once_with(file_path=expected_file_path_in_prompt)
-        
-        # Check that a success message was printed for the loaded file
-        # The first call to print_formatted_text is for loading, the second (if any) for total files.
-        args, _ = mock_print_formatted_text.call_args_list[0]
-        self.assertIsInstance(args[0], FormattedText)
-        self.assertEqual(args[0][0], ('class:success', f"✓ Loaded file: {expected_file_path_in_prompt}"))
-        
-        self.assertEqual(expected_final_prompt.strip(), result_prompt.strip())
-
-    @patch('Src.OpenCopilot.print_formatted_text')
-    @patch('Src.OpenCopilot.file_reader')
-    @patch('os.path.isfile')
-    @patch('os.path.exists')
-    def test_file_read_error_from_file_reader(self, mock_exists, mock_isfile, mock_file_reader, mock_print_formatted_text):
-        mock_exists.return_value = True
-        mock_isfile.return_value = True
-        mock_file_reader.return_value = {"success": False, "output": "Specific read error"}
-
-        user_input = "@error.txt explain this"
-        expected_file_path_in_error = '/abs/error.txt'
-        # If file_reader fails, @file directive is NOT removed from prompt currently
-        expected_final_prompt = "@error.txt explain this" 
-
-        result_prompt = self.copilot.extract_files_and_process_prompt(user_input)
-
-        mock_file_reader.assert_called_once_with(file_path=expected_file_path_in_error)
-        
-        args, _ = mock_print_formatted_text.call_args_list[0] # Error message for the specific file
-        self.assertIsInstance(args[0], FormattedText)
-        self.assertEqual(args[0][0], ('class:error', f"✗ Error reading file {expected_file_path_in_error}: Specific read error"))
-        
-        self.assertEqual(expected_final_prompt.strip(), result_prompt.strip())
-
-    @patch('Src.OpenCopilot.print_formatted_text')
-    @patch('Src.OpenCopilot.file_reader')
-    @patch('os.path.isfile') # Still need to patch isfile even if not called
-    @patch('os.path.exists')
-    def test_non_existent_file(self, mock_exists, mock_isfile, mock_file_reader, mock_print_formatted_text):
-        mock_exists.return_value = False
-        # mock_isfile should not be called if mock_exists is False
-
-        user_input = "@nonexistent.txt explain this"
-        # Path that os.path.exists will check
-        path_checked = '/abs/nonexistent.txt'
-        expected_final_prompt = "@nonexistent.txt explain this" # Unchanged as per current logic
-
-        result_prompt = self.copilot.extract_files_and_process_prompt(user_input)
-
-        mock_exists.assert_called_once_with(path_checked)
-        mock_isfile.assert_not_called() # Crucial check
-        mock_file_reader.assert_not_called()
-        
-        args, _ = mock_print_formatted_text.call_args_list[0] # Warning message
-        self.assertIsInstance(args[0], FormattedText)
-        self.assertEqual(args[0][0], ('class:warning', f"⚠ Path not found: {path_checked}"))
-        
-        self.assertEqual(expected_final_prompt.strip(), result_prompt.strip())
-
-    @patch('Src.OpenCopilot.print_formatted_text')
-    @patch('Src.OpenCopilot.file_reader')
-    @patch('os.path.isfile')
-    @patch('os.path.exists')
-    def test_directory_path(self, mock_exists, mock_isfile, mock_file_reader, mock_print_formatted_text):
-        mock_exists.return_value = True
-        mock_isfile.return_value = False # This indicates it's a directory (or not a file)
-
-        user_input = "@testdir explain this"
-        # Path that will be processed
-        processed_path = '/abs/testdir'
-        # In the prompt, @testdir is replaced by its absolute path
-        expected_final_prompt = f"{processed_path} explain this" 
-
-        result_prompt = self.copilot.extract_files_and_process_prompt(user_input)
-
-        mock_exists.assert_called_once_with(processed_path)
-        mock_isfile.assert_called_once_with(processed_path)
-        mock_file_reader.assert_not_called()
-        
-        args, _ = mock_print_formatted_text.call_args_list[0] # Directory message
-        self.assertIsInstance(args[0], FormattedText)
-        self.assertEqual(args[0][0],('class:success', f"✓ Added directory path: {processed_path}"))
-        
-        self.assertEqual(expected_final_prompt.strip(), result_prompt.strip())
-
-    @patch('Src.OpenCopilot.print_formatted_text')
-    @patch('Src.OpenCopilot.file_reader')
-    @patch('os.path.isfile')
-    @patch('os.path.exists')
-    def test_multiple_files_success_and_error(self, mock_exists, mock_isfile, mock_file_reader, mock_print_formatted_text):
-        # All paths will be prefixed with /abs/ by the mock_abspath
-        path_file1 = '/abs/file1.txt'
-        path_error_file = '/abs/error.txt'
-        path_file2 = '/abs/file2.txt'
-
-        mock_exists.return_value = True # For all files
-        mock_isfile.return_value = True # For all files
-
-        def file_reader_side_effect(file_path):
-            if file_path == path_file1:
-                return {"success": True, "output": "content1"}
-            elif file_path == path_error_file:
-                return {"success": False, "output": "read error"}
-            elif file_path == path_file2:
-                return {"success": True, "output": "content2"}
-            return {} # Should not happen
-        mock_file_reader.side_effect = file_reader_side_effect
-
-        user_input = "@file1.txt @error.txt @file2.txt go"
-        
-        # Each block in file_contents already ends with a newline.
-        # So "\n".join will put an additional newline between them.
-        # Then another "\n" is added before the processed_prompt.
-        block1_content = f"=== Content of file: {path_file1} ===\ncontent1\n=== End of file: {path_file1} ===\n"
-        block2_content = f"=== Content of file: {path_file2} ===\ncontent2\n=== End of file: {path_file2} ===\n"
-        remaining_prompt = "@error.txt  go" # After successful removals and stripping
-
-        expected_final_prompt = block1_content + "\n" + block2_content + "\n" + remaining_prompt
-        
-        result_prompt = self.copilot.extract_files_and_process_prompt(user_input)
-
-        # Check file_reader calls
-        mock_file_reader.assert_any_call(file_path=path_file1)
-        mock_file_reader.assert_any_call(file_path=path_error_file)
-        mock_file_reader.assert_any_call(file_path=path_file2)
-        self.assertEqual(mock_file_reader.call_count, 3)
-
-        # Check print_formatted_text calls
-        # Call 1: Success for file1.txt
-        args1, _ = mock_print_formatted_text.call_args_list[0]
-        self.assertEqual(args1[0][0], ('class:success', f"✓ Loaded file: {path_file1}"))
-        # Call 2: Error for error.txt
-        args2, _ = mock_print_formatted_text.call_args_list[1]
-        self.assertEqual(args2[0][0], ('class:error', f"✗ Error reading file {path_error_file}: read error"))
-        # Call 3: Success for file2.txt
-        args3, _ = mock_print_formatted_text.call_args_list[2]
-        self.assertEqual(args3[0][0], ('class:success', f"✓ Loaded file: {path_file2}"))
-        # Call 4: Summary message "Loaded 2 file(s) into context"
-        args4, _ = mock_print_formatted_text.call_args_list[3]
-        self.assertEqual(args4[0][0], ('class:info', f"📁 Loaded 2 file(s) into context"))
-
-        self.assertEqual(expected_final_prompt.strip(), result_prompt.strip())
-
-if __name__ == '__main__':
-    unittest.main()

pikoai-0.1.23/test/testjs.py

@@ -1,30 +0,0 @@
-import sys
-import os
-
-# Add the Src directory to the Python path
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../Src')))
-
-from Env.js_executor import JavaScriptExecutor  # Assuming js_executor handles Node.js execution
-
-def read_test_script(filename):
-    """Read the content of a test script file"""
-    with open(filename, 'r') as file:
-        return file.read()
-
-def main():
-    # Initialize the JavaScript executor
-    executor = JavaScriptExecutor()
-    
-    # Get the full path to testscript2.js
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    test_script_path = os.path.join(script_dir, 'testscriptjs.txt')
-    
-    # Read the test script
-    code = read_test_script(test_script_path)
-    
-    # Execute the JavaScript code
-    result = executor.execute(code)
-    print(result)
-
-if __name__ == "__main__":
-    main()

pikoai-0.1.23/test/testscript.py

@@ -1,29 +0,0 @@
-import matplotlib.pyplot as plt
-import numpy as np
-
-# Generate a range of x values from 0 to 10
-x = np.linspace(0, 10, 1000)
-
-# Calculate the corresponding y values using the formula for a circle
-y = np.sqrt(1 - x**2)
-
-# Create a figure and axis
-fig, ax = plt.subplots()
-
-# Plot the upper and lower halves of the circle
-ax.plot(x, y, label='Upper half')
-ax.plot(x, -y, label='Lower half')
-
-# Set the aspect ratio of the plot to be equal so the circle appears as a circle
-ax.set_aspect('equal')
-
-# Set the title and labels
-ax.set_title('Graphical Representation of Pi')
-ax.set_xlabel('x')
-ax.set_ylabel('y')
-
-# Add a legend
-ax.legend()
-
-# Show the plot
-plt.show()