PikoAi 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

OpenCopilot.py

@@ -0,0 +1,256 @@
+import os
+import sys
+import json
+import re
+from prompt_toolkit import PromptSession, HTML
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.shortcuts import print_formatted_text
+from prompt_toolkit.formatted_text import FormattedText
+
+# Add the parent directory to the path to enable imports
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../')))
+
+from Src.Agents.Executor.executor import executor
+
+# sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../')))
+
+class FilePathCompleter(Completer):
+    def get_completions(self, document, complete_event):
+        text_before_cursor = document.text_before_cursor
+        path_match = self._find_at_path(text_before_cursor)
+        if not path_match:
+            return
+        current_path = path_match.group(1)
+        # Only consider files/dirs in current working directory
+        # Support completion for subdirectories and deeper paths
+        # Split current_path into directory and base name
+        dir_path, base_name = os.path.split(current_path)
+        if not dir_path:
+            dir_path = os.getcwd()
+        else:
+            # Expand user home and make absolute
+            dir_path = os.path.expanduser(dir_path)
+            if not os.path.isabs(dir_path):
+                dir_path = os.path.abspath(dir_path)
+        try:
+            items = os.listdir(dir_path)
+            matching_items = [item for item in items if item.lower().startswith(base_name.lower())]
+            matching_items.sort(key=lambda x: (not os.path.isdir(os.path.join(dir_path, x)), x.lower()))
+            for item in matching_items:
+                yield self._create_completion(text_before_cursor,dir_path, item)
+        except (OSError, PermissionError):
+            pass
+
+    def _find_at_path(self, text):
+        """Find the last @ symbol after whitespace and the path after it"""
+        return re.search(r'@([^@\s]*)$', text)
+
+    def _create_completion(self, text_before_cursor, dir_path, item):
+        """Create a Completion object for a given item in the current directory."""
+        full_path = os.path.join(dir_path, item)
+        # Only the completed path after '@' should be inserted
+        if os.path.isdir(full_path):
+            completion_text = f"{item}/"
+            display_text = f"{item}/ (directory)"
+        else:
+            _, ext = os.path.splitext(item)
+            completion_text = f"{item}"
+            if ext:
+                display_text = f"{item} ({ext[1:]} file)"
+            else:
+                display_text = f"{item}"
+        if '/' in text_before_cursor[text_before_cursor.rindex('@'):]:
+            start_position = -(len(text_before_cursor) - text_before_cursor.rindex('/') - 1)
+        else:
+            start_position = -(len(text_before_cursor) - text_before_cursor.rindex('@') - 1)
+        return Completion(
+            text=completion_text,
+            start_position=start_position,
+            display=display_text
+        )
+
+class OpenCopilot:
+    def __init__(self):
+        self.e1 = None  # Initialize as None, will be set in run()
+        self.session = PromptSession(completer=FilePathCompleter())
+
+    def extract_files_and_process_prompt(self, user_input):
+        """Extract file paths from @ commands and process the prompt."""
+        # Find all @file patterns
+        file_patterns = re.findall(r'@(\S+)', user_input)
+        file_contents = []
+        processed_prompt = user_input
+        
+        for file_path in file_patterns:
+            # Expand user home directory if needed
+            expanded_path = os.path.expanduser(file_path)
+            
+            # Convert to absolute path if it's relative
+            if not os.path.isabs(expanded_path):
+                expanded_path = os.path.abspath(expanded_path)
+            
+            if os.path.exists(expanded_path):
+                if os.path.isfile(expanded_path):
+                    try:
+                        with open(expanded_path, 'r', encoding='utf-8') as f:
+                            content = f.read()
+                        
+                        # Add file content with clear formatting
+                        file_contents.append(f"=== Content of file: {expanded_path} ===\n{content}\n=== End of file: {expanded_path} ===\n")
+                        print(f"=== Content of file: {expanded_path} ===\n{content}\n=== End of file: {expanded_path} ===\n")
+                        # Remove the @file pattern from the processed prompt
+                        processed_prompt = processed_prompt.replace(f"@{file_path}", "")
+                        
+                        print_formatted_text(FormattedText([
+                            ('class:success', f"✓ Loaded file: {expanded_path}")
+                        ]))
+                        
+                    except Exception as e:
+                        print_formatted_text(FormattedText([
+                            ('class:error', f"✗ Error reading file {expanded_path}: {str(e)}")
+                        ]))
+                else:
+                    # For directories, just append the path to the processed prompt
+                    processed_prompt = processed_prompt.replace(f"@{file_path}", expanded_path)
+                    print_formatted_text(FormattedText([
+                        ('class:success', f"✓ Added directory path: {expanded_path}")
+                    ]))
+            else:
+                print_formatted_text(FormattedText([
+                    ('class:warning', f"⚠ Path not found: {expanded_path}")
+                ]))
+        
+        # Combine file contents with the processed prompt. will have the files first content and then the user prompt
+        if file_contents:
+            final_prompt = "\n".join(file_contents) + "\n" + processed_prompt.strip()
+            print_formatted_text(FormattedText([
+                ('class:info', f"📁 Loaded {len(file_contents)} file(s) into context")
+            ]))
+        else:
+            final_prompt = processed_prompt.strip()
+        
+        return final_prompt
+
+    def display_help(self):
+        """Display help information about available commands."""
+        help_text = """
+🚀 TaskAutomator OpenCopilot Help
+
+Available Commands:
+  @<file_path>    - Include file content in your prompt
+                   Example: @config.json analyze this configuration
+                   Supports: relative paths, absolute paths, ~ for home directory
+                   Multiple files: @file1.py @file2.txt compare these files
+  
+  quit           - Exit the application
+  help           - Show this help message
+
+File Path Completion:
+  - Type @ followed by a file path
+  - Use arrow keys to navigate suggestions
+  - Press Tab or Enter to autocomplete
+  - Supports directories (shows with /) and files
+  - Case-insensitive matching
+
+Examples:
+  @src/main.py explain this code
+  @~/documents/data.csv @analysis.py analyze this data using this script
+  @config.json @logs/error.log debug the issue in these files
+"""
+        print_formatted_text(FormattedText([('class:info', help_text)]))
+
+    def run(self):
+        """Main conversation loop with enhanced @ command support."""
+        print_formatted_text(FormattedText([
+            ('class:title', '🚀 TaskAutomator OpenCopilot'),
+            ('class:subtitle', '\nType "help" for available commands or start with your prompt.\nUse @<file_path> to include files in your context.\n')
+        ]))
+        
+        try:
+            # Get initial prompt
+            user_input = self.session.prompt(HTML("<b>Please enter your prompt: </b>"))
+            
+            # Handle special commands
+            if user_input.lower() == 'help':
+                self.display_help()
+                user_input = self.session.prompt(HTML("<b>Please enter your prompt: </b>"))
+            elif user_input.lower() == 'quit':
+                print("Goodbye!")
+                return
+            
+            # Process the initial prompt
+            final_prompt = self.extract_files_and_process_prompt(user_input)
+            
+            # Initialize executor with the processed prompt
+            self.e1 = executor(final_prompt)
+            self.e1.executor_prompt_init()
+            self.e1.run()
+
+            # Continue conversation loop
+            while True:
+                try:
+                    user_input = self.session.prompt(HTML("<b>\nPlease enter your prompt (or 'quit' to exit): </b>"))
+                    
+                    # Handle special commands
+                    if user_input.lower() == 'quit':
+                        print("Goodbye!")
+                        break
+                    elif user_input.lower() == 'help':
+                        self.display_help()
+                        continue
+                    
+                    # Process the prompt and extract files
+                    final_prompt = self.extract_files_and_process_prompt(user_input)
+                    
+                    # Add to conversation
+                    self.e1.message.append({"role": "user", "content": final_prompt})
+                    self.e1.run()
+                    
+                except KeyboardInterrupt:
+                    print("\nGoodbye!")
+                    break
+                except Exception as e:
+                    print_formatted_text(FormattedText([
+                        ('class:error', f"An error occurred: {e}")
+                    ]))
+                    continue
+                    
+        except KeyboardInterrupt:
+            print("\nGoodbye!")
+        except Exception as e:
+            print_formatted_text(FormattedText([
+                ('class:error', f"Failed to start OpenCopilot: {e}")
+            ]))
+
+    def run_task(self, user_prompt, max_iter=10):
+        """One-shot task execution with @ command support."""
+        # Process @ commands in the prompt
+        final_prompt = self.extract_files_and_process_prompt(user_prompt)
+        
+        e1 = executor(final_prompt, max_iter=max_iter)
+        e1.executor_prompt_init()
+        e1.run()
+
+    @staticmethod
+    def list_available_tools():
+        """List all available tools."""
+        try:
+            tool_dir_path = os.path.join(os.path.dirname(__file__), 'Tools/tool_dir.json')
+            with open(tool_dir_path, 'r') as f:
+                tools = json.load(f)
+            return tools
+        except FileNotFoundError:
+            print("Tools directory not found.")
+            return {}
+        except json.JSONDecodeError:
+            print("Error reading tools configuration.")
+            return {}
+
+# To run the copilot
+if __name__ == "__main__":
+    copilot = OpenCopilot()
+    copilot.run()
+
+
+
+    

cli.py

@@ -0,0 +1,300 @@
+import click
+import json
+import os
+import inquirer
+import shutil
+from OpenCopilot import OpenCopilot
+from dotenv import load_dotenv
+
+# Define available models for each provider using litellm compatible strings
+AVAILABLE_MODELS = {
+    "openai": [
+        "openai/gpt-3.5-turbo",
+        "openai/gpt-4",
+        "openai/gpt-4-turbo-preview",
+        "openai/gpt-4o" 
+    ],
+    "mistral": [
+        "mistral/mistral-tiny",
+        "mistral/mistral-small",
+        "mistral/mistral-medium",
+        "mistral/mistral-large-latest"
+    ],
+    "groq": [
+        "groq/llama2-70b-4096", 
+        "groq/mixtral-8x7b-32768",
+        "groq/gemma-7b-it"
+    ],
+    "anthropic": [
+        "anthropic/claude-3-opus-20240229",
+        "anthropic/claude-3-sonnet-20240229",
+        "anthropic/claude-3-haiku-20240307"
+    ]
+}
+
+# Define API key environment variables for each provider (matching litellm conventions)
+API_KEYS = {
+    "openai": "OPENAI_API_KEY",
+    "mistral": "MISTRAL_API_KEY",
+    "groq": "GROQ_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY"
+}
+
+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')
+
+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
+    
+    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"
+            }
+    else:
+        # Read existing config
+        with open(config_path, 'r') as f:
+            try:
+                config = json.load(f)
+            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
+                }
+
+    # Ensure 'working_directory' exists, default if not
+    if "working_directory" not in config or not config["working_directory"]:
+        config["working_directory"] = os.getcwd()
+
+    # 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']
+        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}'")
+
+    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)
+
+        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.")
+
+
+    # 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
+
+@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.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()
+    
+    # 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()
+
+        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)
+    
+    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 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
+
+    copilot = OpenCopilot()
+    if ctx.invoked_subcommand is None:
+        if task:
+            copilot.run_task(user_prompt=task, max_iter=max_iter)
+        else:
+            copilot.run()
+
+@cli.command('list-tools')
+def list_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']}")
+
+@cli.command('list-models')
+def list_models():
+    """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}")
+
+if __name__ == '__main__':
+    cli() 

{pikoai-0.1.0.dist-info → pikoai-0.1.1.dist-info}/METADATA

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

{pikoai-0.1.0.dist-info → pikoai-0.1.1.dist-info}/RECORD

@@ -1,3 +1,5 @@
+OpenCopilot.py,sha256=BfAsnIRaruu6naN4OcE2vuJzpIBTQAE0H5f8UQ-v3FU,10695
+cli.py,sha256=o2V_DETYXEiYm6617Xg8rDcAgb0ofmojPvdlOpNHwMY,11809
 Agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Agents/Executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Agents/Executor/executor.py,sha256=OpaZCTVl9o0WcOM50Y4W-4RR6XClwlY1OTUwwhZxsh8,12516
@@ -18,9 +20,9 @@ Tools/web_loader.py,sha256=PyZk2g7WngZT0tCLs9Danx20dYspnaZwy4rlVE9Sx_4,5054
 Tools/web_search.py,sha256=4EGq1VZqfDgG-_yXTd4_Ha1iEUcR-szdlgRV7oFPru4,1259
 llm_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 llm_interface/llm.py,sha256=4ny7punKBXfXfBuYrGpdp7DW2jbhHHksrPkydHSqnxU,5189
-pikoai-0.1.0.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
-pikoai-0.1.0.dist-info/METADATA,sha256=68B0uut29umBRzeRX7RWE8wqnWVBNPpNDCcHGeCDcMs,2961
-pikoai-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pikoai-0.1.0.dist-info/entry_points.txt,sha256=QVeDO6N3nO3UScMb2ksusQWPgcVn86vXosgL-8gu6fo,33
-pikoai-0.1.0.dist-info/top_level.txt,sha256=BdpmoBrO5mzJyrLfIpeh-gw0SFY9k8V8f2jsnzGsg9c,31
-pikoai-0.1.0.dist-info/RECORD,,
+pikoai-0.1.1.dist-info/licenses/LICENSE,sha256=cELUVOboOAderKFp8bdtcM5VyJi61YH1oDbRhOuoQZw,1067
+pikoai-0.1.1.dist-info/METADATA,sha256=fWSDED7hFnQxzCMdPn164Zc6amGtETQyDo9HKGLelWo,2961
+pikoai-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pikoai-0.1.1.dist-info/entry_points.txt,sha256=QVeDO6N3nO3UScMb2ksusQWPgcVn86vXosgL-8gu6fo,33
+pikoai-0.1.1.dist-info/top_level.txt,sha256=_xQTtTA77f_GF7zdtD6C3gMyPP8GqRZvuhOSTVvSePU,47
+pikoai-0.1.1.dist-info/RECORD,,

{pikoai-0.1.0.dist-info → pikoai-0.1.1.dist-info}/top_level.txt

@@ -1,4 +1,6 @@
 Agents
 Env
+OpenCopilot
 Tools
+cli
 llm_interface