npcpy 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

npcpy/build_funcs.py

@@ -0,0 +1,288 @@
+"""
+Build functions for NPC team deployment artifacts.
+"""
+import os
+import yaml
+from pathlib import Path
+
+
+def get_team_name(team_path):
+    """Get team name from ctx file or folder name."""
+    team_path = Path(team_path)
+    for ctx_file in team_path.glob("*.ctx"):
+        try:
+            with open(ctx_file, 'r') as f:
+                ctx = yaml.safe_load(f)
+            if ctx and ctx.get('name'):
+                return ctx['name']
+        except:
+            pass
+
+    name = team_path.name
+    if name == 'npc_team':
+        name = team_path.parent.name
+    return name
+
+
+def build_dockerfile(config, **kwargs):
+    """Generate a Dockerfile for serving an NPC team."""
+    team_path = config.get('team_path', './npc_team')
+    port = config.get('port', 5337)
+    team_name = get_team_name(team_path)
+
+    dockerfile = f'''FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install npcsh
+RUN pip install --no-cache-dir npcsh
+
+# Copy the NPC team
+COPY {os.path.basename(team_path)} /app/npc_team
+
+# Expose the port
+EXPOSE {port}
+
+# Set environment variables (override at runtime)
+ENV NPCSH_CHAT_MODEL=gpt-4o-mini
+ENV NPCSH_CHAT_PROVIDER=openai
+ENV OPENAI_API_KEY=""
+ENV ANTHROPIC_API_KEY=""
+
+# Run the serve command
+CMD ["npc", "serve", "--port", "{port}"]
+'''
+    return dockerfile
+
+
+def build_docker_compose(config, **kwargs):
+    """Generate Docker Compose setup for NPC team deployment."""
+    team_path = config.get('team_path', './npc_team')
+    output_dir = config.get('output_dir', './build')
+    port = config.get('port', 5337)
+    cors_origins = config.get('cors_origins', None)
+
+    team_name = get_team_name(team_path)
+    safe_name = team_name.lower().replace(' ', '_').replace('-', '_')
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Generate Dockerfile
+    dockerfile_content = build_dockerfile(config)
+    dockerfile_path = os.path.join(output_dir, 'Dockerfile')
+    with open(dockerfile_path, 'w') as f:
+        f.write(dockerfile_content)
+
+    # Generate docker-compose.yml
+    cors_env = f'\n      - CORS_ORIGINS={",".join(cors_origins)}' if cors_origins else ''
+
+    compose = f'''version: '3.8'
+
+services:
+  {safe_name}:
+    build: .
+    ports:
+      - "{port}:{port}"
+    environment:
+      - NPCSH_CHAT_MODEL=${{NPCSH_CHAT_MODEL:-gpt-4o-mini}}
+      - NPCSH_CHAT_PROVIDER=${{NPCSH_CHAT_PROVIDER:-openai}}
+      - OPENAI_API_KEY=${{OPENAI_API_KEY}}
+      - ANTHROPIC_API_KEY=${{ANTHROPIC_API_KEY}}
+      - GEMINI_API_KEY=${{GEMINI_API_KEY}}{cors_env}
+    volumes:
+      - ./{os.path.basename(team_path)}:/app/npc_team
+    restart: unless-stopped
+'''
+
+    compose_path = os.path.join(output_dir, 'docker-compose.yml')
+    with open(compose_path, 'w') as f:
+        f.write(compose)
+
+    # Generate .env.example
+    env_example = '''# NPC Team Environment Variables
+NPCSH_CHAT_MODEL=gpt-4o-mini
+NPCSH_CHAT_PROVIDER=openai
+
+# API Keys (set at least one)
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+GEMINI_API_KEY=
+'''
+
+    env_path = os.path.join(output_dir, '.env.example')
+    with open(env_path, 'w') as f:
+        f.write(env_example)
+
+    # Copy npc_team to output
+    import shutil
+    dest_team = os.path.join(output_dir, os.path.basename(team_path))
+    if os.path.exists(dest_team):
+        shutil.rmtree(dest_team)
+    shutil.copytree(team_path, dest_team)
+
+    return {
+        'output': f'''Docker deployment created in {output_dir}/
+
+Files generated:
+  - Dockerfile
+  - docker-compose.yml
+  - .env.example
+  - {os.path.basename(team_path)}/
+
+To deploy:
+  cd {output_dir}
+  cp .env.example .env
+  # Edit .env with your API keys
+  docker-compose up -d
+
+API will be available at http://localhost:{port}
+''',
+        'messages': kwargs.get('messages', [])
+    }
+
+
+def build_flask_server(config, **kwargs):
+    """Generate a standalone Flask server script."""
+    team_path = config.get('team_path', './npc_team')
+    output_dir = config.get('output_dir', './build')
+    port = config.get('port', 5337)
+    cors_origins = config.get('cors_origins', None)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    cors_line = f"cors_origins={cors_origins}" if cors_origins else "cors_origins=None"
+
+    server_script = f'''#!/usr/bin/env python3
+"""
+Auto-generated NPC Team server.
+Run with: python server.py
+"""
+from npcpy.serve import start_flask_server
+
+if __name__ == "__main__":
+    start_flask_server(
+        port={port},
+        {cors_line},
+    )
+'''
+
+    script_path = os.path.join(output_dir, 'server.py')
+    with open(script_path, 'w') as f:
+        f.write(server_script)
+    os.chmod(script_path, 0o755)
+
+    # Copy npc_team
+    import shutil
+    dest_team = os.path.join(output_dir, os.path.basename(team_path))
+    if os.path.exists(dest_team):
+        shutil.rmtree(dest_team)
+    shutil.copytree(team_path, dest_team)
+
+    return {
+        'output': f'''Flask server created in {output_dir}/
+
+Files generated:
+  - server.py
+  - {os.path.basename(team_path)}/
+
+To run:
+  cd {output_dir}
+  pip install npcsh
+  python server.py
+
+API will be available at http://localhost:{port}
+''',
+        'messages': kwargs.get('messages', [])
+    }
+
+
+def build_cli_executable(config, **kwargs):
+    """Generate CLI wrapper scripts for team NPCs."""
+    team_path = config.get('team_path', './npc_team')
+    output_dir = config.get('output_dir', './build')
+
+    team_path = Path(team_path)
+    os.makedirs(output_dir, exist_ok=True)
+
+    npc_files = list(team_path.glob("*.npc"))
+    scripts = []
+
+    for npc_file in npc_files:
+        name = npc_file.stem
+        script = f'''#!/usr/bin/env python3
+"""CLI wrapper for {name} NPC."""
+import sys
+from npcsh.npcsh import main
+sys.argv[0] = "{name}"
+main()
+'''
+        script_path = os.path.join(output_dir, name)
+        with open(script_path, 'w') as f:
+            f.write(script)
+        os.chmod(script_path, 0o755)
+        scripts.append(name)
+
+    return {
+        'output': f'''CLI scripts created in {output_dir}/
+
+Scripts: {", ".join(scripts)}
+
+To use, add {output_dir} to your PATH or run directly:
+  ./{scripts[0] if scripts else "npc_name"} "your prompt"
+''',
+        'messages': kwargs.get('messages', [])
+    }
+
+
+def build_static_site(config, **kwargs):
+    """Generate static site documentation for the team."""
+    team_path = config.get('team_path', './npc_team')
+    output_dir = config.get('output_dir', './build')
+
+    team_path = Path(team_path)
+    os.makedirs(output_dir, exist_ok=True)
+
+    team_name = get_team_name(team_path)
+
+    # Get NPCs
+    npcs = []
+    for npc_file in team_path.glob("*.npc"):
+        with open(npc_file, 'r') as f:
+            npc_data = yaml.safe_load(f)
+        npcs.append({
+            'name': npc_file.stem,
+            'directive': npc_data.get('primary_directive', '')[:200] + '...'
+        })
+
+    # Simple HTML page
+    npc_list = '\n'.join([
+        f'<li><strong>{n["name"]}</strong>: {n["directive"]}</li>'
+        for n in npcs
+    ])
+
+    html = f'''<!DOCTYPE html>
+<html>
+<head>
+    <title>{team_name} - NPC Team</title>
+    <style>
+        body {{ font-family: system-ui; max-width: 800px; margin: 0 auto; padding: 20px; }}
+        h1 {{ color: #333; }}
+        ul {{ line-height: 1.8; }}
+    </style>
+</head>
+<body>
+    <h1>{team_name}</h1>
+    <h2>Available NPCs</h2>
+    <ul>{npc_list}</ul>
+</body>
+</html>
+'''
+
+    html_path = os.path.join(output_dir, 'index.html')
+    with open(html_path, 'w') as f:
+        f.write(html)
+
+    return {
+        'output': f'Static site created at {html_path}',
+        'messages': kwargs.get('messages', [])
+    }

npcpy/data/load.py

@@ -259,7 +259,7 @@ def load_file_contents(file_path, chunk_size=None):
     file_ext = os.path.splitext(file_path)[1].upper().lstrip('.')
     full_content = ""
     if not isinstance(chunk_size, int):
-        chunk_size=250
+        chunk_size=8000
     try:
         if file_ext == 'PDF':
             full_content = load_pdf(file_path)

npcpy/data/web.py

@@ -78,14 +78,15 @@ def search_perplexity(
     headers = {"Authorization": f"Bearer {api_key}", 
                "Content-Type": "application/json"}
 
-    
     response = requests.post(url,
                              json=payload,
                              headers=headers)
-    
-    response = response.json()
 
-    return [response["choices"][0]["message"]["content"], response["citations"]]
+    if response.status_code != 200:
+        raise Exception(f"Perplexity API error {response.status_code}: {response.text[:200]}")
+
+    data = response.json()
+    return [data["choices"][0]["message"]["content"], data.get("citations", [])]
 
 
 def search_web(

npcpy/gen/image_gen.py

@@ -160,11 +160,12 @@ def openai_image_gen(
     height: int = 1024,
     width: int = 1024,
     n_images: int = 1,
+    api_key: Optional[str] = None,
 ):
     """Generate or edit an image using the OpenAI API."""
     from openai import OpenAI
 
-    client = OpenAI()
+    client = OpenAI(api_key=api_key) if api_key else OpenAI()
 
     if height is None:
         height = 1024

npcpy/gen/response.py

@@ -4,15 +4,20 @@ from npcpy.data.image import compress_image
 from npcpy.npc_sysenv import get_system_message, lookup_provider, render_markdown
 import base64
 import json
+import yaml
 import uuid
-import os 
-try: 
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+try:
     import ollama
 except ImportError:
     pass
 except OSError:
-    
-    print("Ollama is not installed or not available. Please install it to use this feature.")
+    logger.warning("Ollama is not installed or not available.")
+
 try:
     import litellm
     from litellm import completion
@@ -277,16 +282,33 @@ def get_ollama_response(
             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 and messages[-1]["role"] == "user":
             if isinstance(messages[-1]["content"], list):
                 messages[-1]["content"].append({
-                    "type": "text", 
+                    "type": "text",
                     "text": json_instruction
                 })
             elif isinstance(messages[-1]["content"], str):
                 messages[-1]["content"] += "\n" + json_instruction
-                        
+
+    if format == "yaml" and not stream:
+        yaml_instruction = """Return your response as valid YAML. Do not include ```yaml markdown tags.
+            For multi-line strings like code, use the literal block scalar (|) syntax:
+            code: |
+              your code here
+              more lines here
+            The keys should be based on the ones requested by the user. Do not invent new ones."""
+
+        if messages and messages[-1]["role"] == "user":
+            if isinstance(messages[-1]["content"], list):
+                messages[-1]["content"].append({
+                    "type": "text",
+                    "text": yaml_instruction
+                })
+            elif isinstance(messages[-1]["content"], str):
+                messages[-1]["content"] += "\n" + yaml_instruction
+
     if image_paths:
         last_user_idx = -1
         for i, msg in enumerate(messages):
@@ -393,11 +415,25 @@ def get_ollama_response(
                         result["response"] = parsed_response
                 except json.JSONDecodeError:
                     result["error"] = f"Invalid JSON response: {response_content}"
-            
+
+            if format == "yaml":
+                try:
+                    if isinstance(response_content, str):
+                        if response_content.startswith("```yaml"):
+                            response_content = (
+                                response_content.replace("```yaml", "")
+                                .replace("```", "")
+                                .strip()
+                            )
+                        parsed_response = yaml.safe_load(response_content)
+                        result["response"] = parsed_response
+                except yaml.YAMLError:
+                    result["error"] = f"Invalid YAML response: {response_content}"
+
             return result
 
-    
-    print('Debug', api_params)
+
+    logger.debug(f"ollama api_params: {api_params}")
     res = ollama.chat(**api_params, options=options)
     result["raw_response"] = res
     
@@ -466,9 +502,10 @@ def get_ollama_response(
             
             result["response"] = ollama.chat(**stream_api_params, options=options)
         else:
-                        
+
             if format == "json":
                 try:
+                    llm_response = response_content
                     if isinstance(llm_response, str):
                         llm_response = llm_response.strip()
                         
@@ -505,14 +542,32 @@ def get_ollama_response(
                             result["response"] = parsed_json
                         
                 except (json.JSONDecodeError, TypeError) as e:
-                    print(f"JSON parsing error: {str(e)}")
-                    print(f"Raw response: {llm_response[:500]}")
+                    logger.debug(f"JSON parsing error: {str(e)}, raw response: {llm_response[:500]}")
                     result["response"] = {}
                     result["error"] = "Invalid JSON response"
 
+            if format == "yaml":
+                try:
+                    if isinstance(llm_response, str):
+                        llm_response = llm_response.strip()
+
+                        if '```yaml' in llm_response:
+                            start = llm_response.find('```yaml') + 7
+                            end = llm_response.rfind('```')
+                            if end > start:
+                                llm_response = llm_response[start:end].strip()
+
+                        parsed_yaml = yaml.safe_load(llm_response)
+                        result["response"] = parsed_yaml
+
+                except (yaml.YAMLError, TypeError) as e:
+                    logger.debug(f"YAML parsing error: {str(e)}, raw response: {llm_response[:500]}")
+                    result["response"] = {}
+                    result["error"] = "Invalid YAML response"
+
         return result
-    
-import time 
+
+import time
 
 
 def get_litellm_response(
@@ -631,13 +686,27 @@ def get_litellm_response(
             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 result["messages"] and result["messages"][-1]["role"] == "user":
             if isinstance(result["messages"][-1]["content"], list):
                 result["messages"][-1]["content"].append({"type": "text", "text": json_instruction})
             elif isinstance(result["messages"][-1]["content"], str):
                 result["messages"][-1]["content"] += "\n" + json_instruction
 
+    if format == "yaml" and not stream:
+        yaml_instruction = """Return your response as valid YAML. Do not include ```yaml markdown tags.
+            For multi-line strings like code, use the literal block scalar (|) syntax:
+            code: |
+              your code here
+              more lines here
+            The keys should be based on the ones requested by the user. Do not invent new ones."""
+
+        if result["messages"] and result["messages"][-1]["role"] == "user":
+            if isinstance(result["messages"][-1]["content"], list):
+                result["messages"][-1]["content"].append({"type": "text", "text": yaml_instruction})
+            elif isinstance(result["messages"][-1]["content"], str):
+                result["messages"][-1]["content"] += "\n" + yaml_instruction
+
     if images:
         last_user_idx = -1
         for i, msg in enumerate(result["messages"]):
@@ -684,7 +753,7 @@ def get_litellm_response(
             model = model.split('-npc')[0]
         provider = "openai"
 
-    if isinstance(format, BaseModel):
+    if isinstance(format, type) and issubclass(format, BaseModel):
         api_params["response_format"] = format
     if model is None:
         model = os.environ.get("NPCSH_CHAT_MODEL", "llama3.2")
@@ -777,11 +846,40 @@ def get_litellm_response(
                             result["response"] = parsed_json
                         
                 except (json.JSONDecodeError, TypeError) as e:
-                    print(f"JSON parsing error: {str(e)}")
-                    print(f"Raw response: {llm_response[:500]}")
+                    logger.debug(f"JSON parsing error: {str(e)}, raw response: {llm_response[:500]}")
                     result["response"] = {}
                     result["error"] = "Invalid JSON response"
-            
+
+            if format == "yaml":
+                try:
+                    if isinstance(llm_response, str):
+                        llm_response = llm_response.strip()
+
+                        # Strip ```yaml markdown if present
+                        if '```yaml' in llm_response:
+                            start = llm_response.find('```yaml') + 7
+                            end = llm_response.rfind('```')
+                            if end > start:
+                                llm_response = llm_response[start:end].strip()
+                        elif '```' in llm_response:
+                            # Generic code block
+                            start = llm_response.find('```') + 3
+                            # Skip any language identifier on the same line
+                            newline = llm_response.find('\n', start)
+                            if newline != -1:
+                                start = newline + 1
+                            end = llm_response.rfind('```')
+                            if end > start:
+                                llm_response = llm_response[start:end].strip()
+
+                        parsed_yaml = yaml.safe_load(llm_response)
+                        result["response"] = parsed_yaml
+
+                except (yaml.YAMLError, TypeError) as e:
+                    logger.debug(f"YAML parsing error: {str(e)}, raw response: {llm_response[:500]}")
+                    result["response"] = {}
+                    result["error"] = "Invalid YAML response"
+
             return result
 
     
@@ -792,8 +890,7 @@ def get_litellm_response(
     try:
         resp = completion(**initial_api_params)
     except Exception as e:
-        from termcolor import colored
-        print(colored(f"[litellm ERROR] completion() failed: {type(e).__name__}: {e}", "red"))
+        logger.error(f"litellm completion() failed: {type(e).__name__}: {e}")
         result["error"] = str(e)
         result["response"] = f"LLM call failed: {e}"
         return result
@@ -976,54 +1073,10 @@ def process_tool_calls(response_dict, tool_map, model, provider, messages, strea
             tool_result_str = ""
             serializable_result = None
 
-            # Show tool execution indicator with truncated args
-            # Store full args for Ctrl+O expansion
-            _last_tool_call = {"name": tool_name, "arguments": arguments}
-            try:
-                import builtins
-                builtins._npcsh_last_tool_call = _last_tool_call
-            except:
-                pass
-
-            try:
-                from termcolor import colored
-                # Format arguments nicely - show key=value pairs
-                is_truncated = False
-                if arguments:
-                    arg_parts = []
-                    for k, v in arguments.items():
-                        v_str = str(v)
-                        if len(v_str) > 40:
-                            v_str = v_str[:40] + "…"
-                            is_truncated = True
-                        arg_parts.append(f"{v_str}")
-                    args_display = " ".join(arg_parts)
-                    if len(args_display) > 60:
-                        args_display = args_display[:60] + "…"
-                        is_truncated = True
-                else:
-                    args_display = ""
-
-                if args_display:
-                    hint = colored(" [^O]", "white", attrs=["dark"]) if is_truncated else ""
-                    print(colored(f"  ⚡ {tool_name}", "cyan") + colored(f" {args_display}", "white", attrs=["dark"]) + hint, end="", flush=True)
-                else:
-                    print(colored(f"  ⚡ {tool_name}", "cyan"), end="", flush=True)
-            except:
-                pass
-
             try:
                 tool_result = tool_map[tool_name](**arguments)
-                try:
-                    print(colored(" ✓", "green"), flush=True)
-                except:
-                    pass
             except Exception as e:
                 tool_result = f"Error executing tool '{tool_name}': {str(e)}"
-                try:
-                    print(colored(f" ✗ {str(e)[:50]}", "red"), flush=True)
-                except:
-                    pass
 
             try:
                 tool_result_str = json.dumps(tool_result, default=str)