npcsh 0.3.32__py3-none-any.whl → 1.0.0__py3-none-any.whl

npcsh/npc_team/tools/code_executor.tool

@@ -1,16 +0,0 @@
-tool_name: code_executor
-description: Execute scripts with a specified language. choose from python, bash, R, or javascript. Set the ultimate result as the "output" variable. It must be a string. Do not add unnecessary print statements.
-inputs:
-  - code
-  - language
-steps:
-  - engine: '{{ language }}'
-    code: |
-      {{code}}
-  - engine: natural
-    code: |
-      Here is the result of the code execution that an agent ran.
-      ```
-      {{ output }}
-      ```
-      please provide a response accordingly.

npcsh/npc_team/tools/generic_search.tool

@@ -1,27 +0,0 @@
-tool_name: "internet_search"
-description: Searches the web for information based on a query in order to verify timiely details (e.g. current events) or to corroborate information in uncertain situations. Should be mainly only used when users specifically request a search, otherwise an LLMs basic knowledge should be sufficient.
-inputs:
-  - query
-  - provider: ''
-steps:
-  - engine: "python"
-    code: |
-      from npcsh.search import search_web
-      from npcsh.npc_sysenv import NPCSH_SEARCH_PROVIDER
-      query = "{{ query }}"
-      provider = '{{ provider }}'
-      if provider.strip() != '':
-          results = search_web(query, num_results=5, provider = provider)
-      else:
-          results = search_web(query, num_results=5, provider = NPCSH_SEARCH_PROVIDER)
-
-      print('QUERY in tool', query)
-      results = search_web(query, num_results=5, provider = NPCSH_SEARCH_PROVIDER)
-      print('RESULTS in tool', results)
-  - engine: "natural"
-    code: |
-      Using the following information extracted from the web:
-
-      {{ results }}
-
-      Answer the users question: {{ query }}

npcsh/npc_team/tools/image_generation.tool

@@ -1,25 +0,0 @@
-tool_name: "image_generation_tool"
-description: |
-  Generates images based on a text prompt.
-inputs:
-  - prompt
-  - model: 'runwayml/stable-diffusion-v1-5'
-  - provider: 'diffusers'
-
-steps:
-  - engine: "python"
-    code: |
-      image_prompt = '{{prompt}}'.strip()
-
-      # Generate the image
-      filename = generate_image(
-          image_prompt,
-          npc=npc,
-          model='{{model}}',  # You can adjust the model as needed
-          provider='{{provider}}'
-      )
-      if filename:
-          image_generated = True
-      else:
-          image_generated = False
-

npcsh/npc_team/tools/local_search.tool

@@ -1,149 +0,0 @@
-tool_name: local_search
-description: |
-    Searches files in current and downstream directories to find items related to the user's query using fuzzy matching.
-    Returns only relevant snippets (10 lines around matches) to avoid including too much irrelevant content.
-    Intended for fuzzy searches, not for understanding file sizes.
-inputs:
-  - query
-  - summarize: false  # Optional - set to true to summarize the results
-  - file_filter: 'none'  # Optional - can be filename patterns or folder names
-  - depth: 2  # Optional - search depth for nested directories
-  - fuzzy_threshold: 70  # Optional - minimum fuzzy match score (0-100)
-steps:
-  - engine: python
-    code: |
-        # Search parameters are directly available
-        query = "{{ query }}"
-        file_filter = "{{ file_filter | default('None') }}"
-        if isinstance(file_filter, str) and file_filter.lower() == 'none':
-            file_filter = None
-        max_depth = {{ depth | default(2) }}
-        fuzzy_threshold = {{ fuzzy_threshold | default(70) }}
-
-        import os
-        import fnmatch
-        from pathlib import Path
-        from thefuzz import fuzz  # Fuzzy string matching library
-
-        def find_files(file_filter=None, max_depth=2):
-            default_extensions = ['.py', '.txt', '.md',
-                                '.json', '.yml', '.yaml',
-                                '.log', '.csv', '.html',
-                                '.js', '.css']
-            matches = []
-            root_path = Path('.').resolve()  # Resolve to absolute path
-
-            # First, check files in the current directory
-            for path in root_path.iterdir():
-                if path.is_file():
-                    # Skip hidden files
-                    if path.name.startswith('.'):
-                        continue
-
-                    # If no filter specified, include files with default extensions
-                    if file_filter is None:
-                        if path.suffix in default_extensions:
-                            matches.append(str(path))
-                    else:
-                        # If filter specified, check if file matches the filter
-                        filters = [file_filter] if isinstance(file_filter, str) else file_filter
-                        for f in filters:
-                            if (fnmatch.fnmatch(path.name, f) or
-                                fnmatch.fnmatch(str(path), f'*{f}*')):
-                                matches.append(str(path))
-                                break
-
-            # Then, check subdirectories with depth control
-            for path in root_path.rglob('*'):
-                # Skip hidden folders and common directories to ignore
-                if '/.' in str(path) or '__pycache__' in str(path) or '.git' in str(path) or 'node_modules' in str(path) or 'venv' in str(path):
-                    continue
-
-                # Skip if we've gone too deep
-                relative_depth = len(path.relative_to(root_path).parts)
-                if relative_depth > max_depth:
-                    continue
-
-                if path.is_file():
-                    # If no filter specified, include files with default extensions
-                    if file_filter is None:
-                        if path.suffix in default_extensions:
-                            matches.append(str(path))
-                    else:
-                        # If filter specified, check if file matches the filter
-                        filters = [file_filter] if isinstance(file_filter, str) else file_filter
-                        for f in filters:
-                            if (fnmatch.fnmatch(path.name, f) or
-                                fnmatch.fnmatch(str(path), f'*{f}*')):
-                                matches.append(str(path))
-                                break
-
-            return matches
-
-        # Find and load files
-        files = find_files(file_filter, max_depth)
-
-        # Process documents
-        relevant_chunks = []
-        for file_path in files:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                lines = f.readlines()  # Read file as lines
-            if lines:
-                # Join lines into a single string for fuzzy matching
-                content = ''.join(lines)
-                match_score = fuzz.partial_ratio(query.lower(), content.lower())
-                if match_score >= fuzzy_threshold:
-                    # Find the best matching line
-                    best_line_index = -1
-                    best_line_score = 0
-                    for i, line in enumerate(lines):
-                        line_score = fuzz.partial_ratio(query.lower(), line.lower())
-                        if line_score > best_line_score:
-                            best_line_score = line_score
-                            best_line_index = i
-
-                    # Extract 10 lines around the best matching line
-                    if best_line_index != -1:
-                        start = max(0, best_line_index - 5)  # 5 lines before
-                        end = min(len(lines), best_line_index + 6)  # 5 lines after
-                        snippet = ''.join(lines[start:end])
-                        relevant_chunks.append({
-                            'path': file_path,
-                            'snippet': snippet,
-                            'ext': Path(file_path).suffix.lower(),
-                            'score': match_score
-                        })
-
-        # Sort results by match score (highest first)
-        relevant_chunks.sort(key=lambda x: x['score'], reverse=True)
-
-        # Format results
-        if relevant_chunks:
-            context_text = "Here are the most relevant code sections:\n\n"
-            for chunk in relevant_chunks:
-                file_path = chunk['path'].replace('./', '')
-                context_text += f"File: {file_path} (match score: {chunk['score']})\n"
-                context_text += f"```{chunk['ext'][1:] if chunk['ext'] else ''}\n"
-                context_text += f"{chunk['snippet'].strip()}\n"
-                context_text += "```\n\n"
-        else:
-            context_text = "No relevant code sections found.\n"
-
-        output = context_text
-
-  - engine: natural
-    code: |
-        {% if summarize %}
-        You are a helpful coding assistant.
-        Please help with this query:
-
-        `{{ query }}`
-
-        The user is attempting to carry out a local search. This search returned the following results:
-
-        `{{ results }}`
-
-        Please analyze the code sections above and provide a clear, helpful response that directly addresses the query.
-        If you reference specific files or code sections in your response, indicate which file they came from.
-        Make sure to explain your reasoning and how the provided code relates to the query.
-        {% endif %}

npcsh/npc_team/tools/npcsh_executor.tool

@@ -1,9 +0,0 @@
-tool_name: npcsh_executor
-description: Execute npcsh commands. Use the macro commands.
-inputs:
-  - code
-  - language
-steps:
-  - engine: "{{language}}"
-    code: |
-      {{code}}

npcsh/npc_team/tools/screen_cap.tool

@@ -1,27 +0,0 @@
-tool_name: "screen_capture_analysis_tool"
-description: Captures the whole screen and sends the image for analysis
-inputs:
-  - "prompt"
-steps:
-  - engine: "python"
-    code: |
-      # Capture the screen
-      import pyautogui
-      import datetime
-      import os
-      from PIL import Image
-      import time
-      from npcsh.image import analyze_image_base, capture_screenshot
-
-      out = capture_screenshot(npc = npc, full = True)
-
-      llm_response = analyze_image_base( '{{prompt}}' + "\n\nAttached is a screenshot of my screen currently. Please use this to evaluate the situation. If the user asked for you to explain what's on their screen or something similar, they are referring to the details contained within the attached image. You do not need to actually view their screen. You do not need to mention that you cannot view or interpret images directly. You only need to answer the user's request based on the attached screenshot!",
-                                        out['file_path'],
-                                        out['filename'],
-                                        npc=npc,
-                                        **out['model_kwargs'])
-      # To this:
-      if isinstance(llm_response, dict):
-          llm_response = llm_response.get('response', 'No response from image analysis')
-      else:
-          llm_response = 'No response from image analysis'

npcsh/npc_team/tools/sql_executor.tool

@@ -1,26 +0,0 @@
-tool_name: data_pull
-description: Execute queries on the ~/npcsh_history.db to pull data. The database contains only information about conversations and other user-provided data. It does not store any information about individual files.
-inputs:
-  - sql_query
-  - interpret: false  # Note that this is not a boolean, but a string
-
-steps:
-  - engine: python
-    code: |
-      import pandas as pd
-      try:
-        df = pd.read_sql_query('{{sql_query}}', npc.db_conn)
-      except pandas.errors.DatabaseError as e:
-        df = pd.DataFrame({'Error': [str(e)]})
-
-
-      output = df.to_string()
-
-  - engine: natural
-    code: |
-      {% if interpret %}
-      Here is the result of the SQL query:
-      ```
-      {{ df.to_string() }}  # Convert DataFrame to string for a nicer display
-      ```
-      {% endif %}

npcsh/response.py

@@ -1,272 +0,0 @@
-import json
-import requests
-import base64
-import os
-from PIL import Image
-from typing import Any, Dict, Generator, List, Union
-
-from pydantic import BaseModel
-from npcsh.npc_sysenv import (
-    get_system_message,
-    compress_image,
-    available_chat_models,
-    available_reasoning_models,
-)
-
-from litellm import completion
-
-# import litellm
-
-# litellm._turn_on_debug()
-
-try:
-    import ollama
-except:
-    pass
-
-
-def get_ollama_response(
-    prompt: str,
-    model: str,
-    images: List[Dict[str, str]] = None,
-    npc: Any = None,
-    tools: list = None,
-    format: Union[str, BaseModel] = None,
-    messages: List[Dict[str, str]] = None,
-    **kwargs,
-) -> Dict[str, Any]:
-    """
-    Generates a response using the Ollama API.
-
-    Args:
-        prompt (str): Prompt for generating the response.
-        model (str): Model to use for generating the response.
-        images (List[Dict[str, str]], optional): List of image data. Defaults to None.
-        npc (Any, optional): Optional NPC object. Defaults to None.
-        format (Union[str, BaseModel], optional): Response format or schema. Defaults to None.
-        messages (List[Dict[str, str]], optional): Existing messages to append responses. Defaults to None.
-
-    Returns:
-        Dict[str, Any]: The response, optionally including updated messages.
-    """
-    import ollama
-
-    # try:
-    # Prepare the message payload
-    system_message = get_system_message(npc) if npc else "You are a helpful assistant."
-    if messages is None or len(messages) == 0:
-        messages = [
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": prompt},
-        ]
-
-    if images:
-        messages[-1]["images"] = [image["file_path"] for image in images]
-
-    # Prepare format
-    if isinstance(format, type):
-        schema = format.model_json_schema()
-        res = ollama.chat(model=model, messages=messages, format=schema)
-
-    elif isinstance(format, str):
-        if format == "json":
-            res = ollama.chat(model=model, messages=messages, format=format)
-        else:
-            res = ollama.chat(model=model, messages=messages)
-    else:
-        res = ollama.chat(model=model, messages=messages)
-    response_content = res.get("message", {}).get("content")
-
-    # Prepare the return dictionary
-    result = {"response": response_content}
-
-    # Append response to messages if provided
-    if messages is not None:
-        messages.append({"role": "assistant", "content": response_content})
-        result["messages"] = messages
-
-    # Handle JSON format if specified
-    if format == "json":
-        if model in available_reasoning_models:
-            raise NotImplementedError("Reasoning models do not support JSON output.")
-        try:
-            if isinstance(response_content, str):
-                if response_content.startswith("```json"):
-                    response_content = (
-                        response_content.replace("```json", "")
-                        .replace("```", "")
-                        .strip()
-                    )
-                response_content = json.loads(response_content)
-            # print(response_content, type(response_content))
-            result["response"] = response_content
-        except json.JSONDecodeError:
-            return {"error": f"Invalid JSON response: {response_content}"}
-
-    return result
-
-
-def get_litellm_response(
-    prompt: str,
-    model: str,
-    provider: str = None,
-    images: List[Dict[str, str]] = None,
-    npc: Any = None,
-    tools: list = None,
-    format: Union[str, BaseModel] = None,
-    messages: List[Dict[str, str]] = None,
-    api_key: str = None,
-    api_url: str = None,
-    tool_choice: Dict = None,
-    **kwargs,
-) -> Dict[str, Any]:
-    """
-    Improved version with consistent JSON parsing
-    """
-    if provider == "ollama":
-        return get_ollama_response(
-            prompt, model, images, npc, tools, format, messages, **kwargs
-        )
-
-    system_message = get_system_message(npc) if npc else "You are a helpful assistant."
-    if format == "json":
-        prompt += """If you are a returning a json object, begin directly with the opening {.
-            If you are returning a json array, begin directly with the opening [.
-            Do not include any additional markdown formatting or leading
-            ```json tags in your response. The item keys should be based on the ones provided
-            by the user. Do not invent new ones.
-
-        """
-    if messages is None or len(messages) == 0:
-        messages = [
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": [{"type": "text", "text": prompt}]},
-        ]
-
-    if images:
-        for image in images:
-            with open(image["file_path"], "rb") as image_file:
-                image_data = base64.b64encode(compress_image(image_file.read())).decode(
-                    "utf-8"
-                )
-                messages[-1]["content"].append(
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
-                    }
-                )
-    api_params = {
-        "messages": messages,
-    }
-    if provider is None:
-        split = model.split("/")
-        if len(split) == 2:
-            provider = split[0]
-        # if provider == "ollama":
-        # uncomment the two lines below once litellm works better with ollama
-        # litellm works better with ollama_chat
-        # api_params["api_base"] = "http://localhost:11434"
-        # provider = "ollama_chat"
-        api_params["format"] = format
-
-    # else:
-    if api_url is not None:
-        # the default api_url is for npcsh's NPCSH_API_URL
-        # for an openai-like provider.
-        # so the proviuder should only ever be openai-like
-        if provider == "openai-like":
-            api_params["api_base"] = api_url
-
-    if format == "json":
-        api_params["response_format"] = {"type": "json_object"}
-    elif format is not None:
-        # pydantic model
-        api_params["response_format"] = format
-
-    if "/" not in model:  # litellm expects provder/model so let ppl provide like that
-        model_str = f"{provider}/{model}"
-    else:
-        model_str = model
-    api_params["model"] = model_str
-    if api_key is not None:
-        api_params["api_key"] = api_key
-    # Add tools if provided
-    if tools:
-        api_params["tools"] = tools
-    # Add tool choice if specified
-    if tool_choice:
-        api_params["tool_choice"] = tool_choice
-    if kwargs:
-        for key, value in kwargs.items():
-            # minimum parameter set for anthropic to work
-            if key in [
-                "stream",
-                "stop",
-                "temperature",
-                "top_p",
-                "max_tokens",
-                "max_completion_tokens",
-                "tools",
-                "tool_choice",
-                "extra_headers",
-                "parallel_tool_calls",
-                "response_format",
-                "user",
-            ]:
-                api_params[key] = value
-
-    try:
-        # print(api_params)
-        # litellm completion appears to have some
-        # ollama issues, so will default to our
-        # custom implementation until we can revisit
-        # when its likely more better supported
-        resp = completion(
-            **api_params,
-        )
-
-        # Get the raw response content
-        llm_response = resp.choices[0].message.content
-
-        # Prepare return dict
-        items_to_return = {
-            "response": llm_response,
-            "messages": messages,
-            "raw_response": resp,  # Include the full response for debugging
-        }
-
-        # Handle JSON format requests
-        print(format)
-        if format == "json":
-            try:
-                if isinstance(llm_response, str):
-                    print("converting the json")
-                    loaded = json.loads(llm_response)
-                else:
-                    loaded = llm_response  # Assume it's already parsed
-                if "json" in loaded:
-                    items_to_return["response"] = loaded["json"]
-                else:
-                    items_to_return["response"] = loaded
-
-            except (json.JSONDecodeError, TypeError) as e:
-                print(f"JSON parsing error: {str(e)}")
-                print(f"Raw response: {llm_response}")
-                items_to_return["error"] = "Invalid JSON response"
-                return items_to_return
-
-        # Add assistant response to message history
-        items_to_return["messages"].append(
-            {
-                "role": "assistant",
-                "content": (
-                    llm_response if isinstance(llm_response, str) else str(llm_response)
-                ),
-            }
-        )
-
-        return items_to_return
-
-    except Exception as e:
-        print(f"Error in get_litellm_response: {str(e)}")
-        return {"error": str(e), "messages": messages, "response": None}