npcsh 0.1.2__py3-none-any.whl → 1.1.13__py3-none-any.whl

npcsh/routes.py

@@ -0,0 +1,139 @@
+from typing import Callable, Dict, Any, List, Optional
+import functools
+import os
+import traceback
+import sys
+import inspect
+from pathlib import Path
+
+from npcpy.npc_compiler import Jinx, load_jinxs_from_directory, extract_jinx_inputs
+
+
+class CommandRouter:
+    def __init__(self):
+        self.routes = {}
+        self.help_info = {}
+        self.jinx_routes = {}
+
+    def route(self, command: str, help_text: str = "") -> Callable:
+        def wrapper(func):
+            self.routes[command] = func
+            self.help_info[command] = help_text
+
+            @functools.wraps(func)
+            def wrapped_func(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            return wrapped_func
+        return wrapper
+
+    def load_jinx_routes(self, jinxs_dir: str):
+        if not os.path.exists(jinxs_dir):
+            print(f"Jinxs directory not found: {jinxs_dir}")
+            return
+        
+        for root, dirs, files in os.walk(jinxs_dir):
+            for filename in files:
+                if filename.endswith('.jinx'):
+                    jinx_path = os.path.join(root, filename)
+                    try:
+                        jinx = Jinx(jinx_path=jinx_path)
+                        self.register_jinx(jinx)
+                    except Exception as e:
+                        print(f"Error loading jinx {filename}: {e}")
+    
+    def register_jinx(self, jinx: Jinx):
+        command_name = jinx.jinx_name
+        
+        def jinx_handler(command: str, **kwargs):
+            return self._execute_jinx(jinx, command, **kwargs)
+        
+        self.jinx_routes[command_name] = jinx_handler
+        self.help_info[command_name] = jinx.description or "Jinx command"
+    
+    def _execute_jinx(self, jinx: Jinx, command: str, **kwargs):
+        messages = kwargs.get("messages", [])
+        npc = kwargs.get('npc')
+        
+        try:
+            import shlex
+            
+            parts = shlex.split(command)
+            args = parts[1:] if len(parts) > 1 else []
+            
+            # Use extract_jinx_inputs
+            input_values = extract_jinx_inputs(args, jinx)
+            
+            # Build extra_globals for jinx execution
+            from npcpy.memory.command_history import CommandHistory, load_kg_from_db
+            from npcpy.memory.search import execute_rag_command, execute_brainblast_command
+            from npcpy.data.load import load_file_contents
+            from npcpy.data.web import search_web
+            
+            application_globals_for_jinx = {
+                "CommandHistory": CommandHistory,
+                "load_kg_from_db": load_kg_from_db,
+                "execute_rag_command": execute_rag_command,
+                "execute_brainblast_command": execute_brainblast_command,
+                "load_file_contents": load_file_contents,
+                "search_web": search_web,
+                'state': kwargs.get('state')
+            }
+            
+            # Add functions from _state module if available
+            try:
+                from npcsh import _state
+                for name, func in inspect.getmembers(_state, inspect.isfunction):
+                    application_globals_for_jinx[name] = func
+            except:
+                pass
+            
+            jinx_output = jinx.execute(
+                input_values=input_values,
+                npc=npc,
+                messages=messages,
+                extra_globals=application_globals_for_jinx
+            )
+            
+            if isinstance(jinx_output, dict):
+                return {
+                    "output": jinx_output.get('output', str(jinx_output)),
+                    "messages": jinx_output.get('messages', messages)
+                }
+            else:
+                return {"output": str(jinx_output), "messages": messages}
+                
+        except Exception as e:
+            traceback.print_exc()
+            return {
+                "output": f"Error executing jinx '{jinx.jinx_name}': {e}",
+                "messages": messages
+            }
+
+    def get_route(self, command: str) -> Optional[Callable]:
+        if command in self.routes:
+            return self.routes[command]
+        elif command in self.jinx_routes:
+            return self.jinx_routes[command]
+        return None
+
+    def execute(self, command_str: str, **kwargs) -> Any:
+        command_name = command_str.split()[0].lstrip('/')
+        route_func = self.get_route(command_name)
+        if route_func:
+            return route_func(command=command_str, **kwargs)
+        return None
+
+    def get_commands(self) -> List[str]:
+        all_commands = list(self.routes.keys()) + list(self.jinx_routes.keys())
+        return sorted(set(all_commands))
+
+    def get_help(self, command: str = None) -> Dict[str, str]:
+        if command:
+            if command in self.help_info:
+                return {command: self.help_info[command]}
+            return {}
+        return self.help_info
+
+
+router = CommandRouter()

npcsh/spool.py

@@ -0,0 +1,48 @@
+"""
+spool - Interactive chat mode CLI entry point
+
+This is a thin wrapper that executes the spool.jinx through the jinx mechanism.
+"""
+import argparse
+import os
+import sys
+
+from npcsh._state import setup_shell
+
+
+def main():
+    parser = argparse.ArgumentParser(description="spool - Interactive chat mode")
+    parser.add_argument("--model", "-m", type=str, help="LLM model to use")
+    parser.add_argument("--provider", "-p", type=str, help="LLM provider to use")
+    parser.add_argument("--files", "-f", nargs="*", help="Files to load for RAG context")
+    parser.add_argument("--no-stream", action="store_true", help="Disable streaming")
+    args = parser.parse_args()
+
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
+
+    if not team or "spool" not in team.jinxs_dict:
+        print("Error: spool jinx not found. Ensure npc_team/jinxs/modes/spool.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "model": args.model,
+        "provider": args.provider,
+        "attachments": ",".join(args.files) if args.files else None,
+        "stream": not args.no_stream,
+    }
+
+    # Execute the jinx
+    spool_jinx = team.jinxs_dict["spool"]
+    result = spool_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
+
+if __name__ == "__main__":
+    main()

npcsh/ui.py

@@ -0,0 +1,199 @@
+"""
+UI helpers for npcsh - spinners, colors, formatting
+"""
+import sys
+import threading
+import time
+from termcolor import colored
+
+
+class SpinnerContext:
+    """Context manager for showing a spinner during long operations.
+
+    Supports ESC key to interrupt (raises KeyboardInterrupt).
+    Tracks elapsed time and token counts.
+    """
+
+    SPINNER_CHARS = {
+        "dots": "⣾⣽⣻⢿⡿⣟⣯⣷",
+        "dots_pulse": "⣾⣽⣻⢿⡿⣟⣯⣷",
+        "line": "-\\|/",
+        "arrow": "←↖↑↗→↘↓↙",
+        "brain": "🧠💭💡✨",
+    }
+
+    def __init__(self, message: str, style: str = "dots", delay: float = 0.1):
+        self.message = message
+        self.style = style
+        self.delay = delay
+        self.spinner = self.SPINNER_CHARS.get(style, self.SPINNER_CHARS["dots"])
+        self._stop = False
+        self._thread = None
+        self._key_thread = None
+        self._interrupted = False
+        self._old_settings = None
+        self._start_time = None
+        self._tokens_in = 0
+        self._tokens_out = 0
+        self._status_msg = ""
+
+    def update_tokens(self, tokens_in: int = 0, tokens_out: int = 0):
+        """Update token counts displayed in spinner."""
+        self._tokens_in += tokens_in
+        self._tokens_out += tokens_out
+
+    def set_status(self, msg: str):
+        """Set additional status message."""
+        self._status_msg = msg
+
+    def __enter__(self):
+        self._stop = False
+        self._interrupted = False
+        self._start_time = time.time()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+        # Start key listener for ESC
+        self._key_thread = threading.Thread(target=self._listen_for_esc, daemon=True)
+        self._key_thread.start()
+        return self
+
+    def __exit__(self, *args):
+        self._stop = True
+        if self._thread:
+            self._thread.join(timeout=0.5)
+        # Clear spinner line
+        sys.stdout.write('\r' + ' ' * (len(self.message) + 20) + '\r')
+        sys.stdout.flush()
+        # Check if we were interrupted by ESC
+        if self._interrupted:
+            raise KeyboardInterrupt("ESC pressed")
+
+    def _listen_for_esc(self):
+        """Listen for ESC key press to interrupt processing."""
+        try:
+            import termios
+            import tty
+            import select
+
+            fd = sys.stdin.fileno()
+            self._old_settings = termios.tcgetattr(fd)
+            try:
+                tty.setcbreak(fd)
+                while not self._stop:
+                    # Check if input is available (non-blocking)
+                    if select.select([sys.stdin], [], [], 0.1)[0]:
+                        ch = sys.stdin.read(1)
+                        if ch == '\x1b':  # ESC key
+                            self._interrupted = True
+                            self._stop = True
+                            break
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, self._old_settings)
+        except Exception:
+            # If we can't set up terminal raw mode (e.g., not a tty), just skip ESC detection
+            pass
+
+    def _spin(self):
+        idx = 0
+        while not self._stop:
+            char = self.spinner[idx % len(self.spinner)]
+
+            # Build status line with timer
+            elapsed = time.time() - self._start_time if self._start_time else 0
+            mins, secs = divmod(int(elapsed), 60)
+            timer_str = f"{mins}:{secs:02d}" if mins else f"{secs}s"
+
+            # Token info if available
+            token_str = ""
+            if self._tokens_in or self._tokens_out:
+                token_str = colored(f" [{self._tokens_in}→{self._tokens_out} tok]", "cyan")
+
+            # Additional status
+            status_str = ""
+            if self._status_msg:
+                status_str = colored(f" {self._status_msg}", "yellow")
+
+            hint = colored(" (ESC to cancel)", "white", attrs=["dark"])
+            timer_display = colored(f" [{timer_str}]", "blue")
+
+            line = f'\r{char} {self.message}...{timer_display}{token_str}{status_str}{hint}'
+            # Clear rest of line
+            sys.stdout.write(line + ' ' * 10)
+            sys.stdout.flush()
+            idx += 1
+            time.sleep(self.delay)
+
+
+def show_thinking_animation(message="Thinking", duration=None):
+    """Show a thinking animation for a fixed duration or until interrupted"""
+    spinner = SpinnerContext(message)
+    with spinner:
+        if duration:
+            time.sleep(duration)
+        else:
+            # Run until interrupted
+            try:
+                while True:
+                    time.sleep(0.1)
+            except KeyboardInterrupt:
+                pass
+
+
+def orange(text: str) -> str:
+    """Return text colored orange using colorama"""
+    from colorama import Fore, Style
+    return f"{Fore.YELLOW}{text}{Style.RESET_ALL}"
+
+
+def get_file_color(filepath: str) -> tuple:
+    """Get color for file listing based on file type"""
+    import os
+    from colorama import Fore, Style
+
+    if os.path.isdir(filepath):
+        return Fore.BLUE, Style.BRIGHT
+    elif os.path.islink(filepath):
+        return Fore.CYAN, ""
+    elif os.access(filepath, os.X_OK):
+        return Fore.GREEN, Style.BRIGHT
+    elif filepath.endswith(('.py', '.sh', '.bash', '.zsh')):
+        return Fore.GREEN, ""
+    elif filepath.endswith(('.md', '.txt', '.rst')):
+        return Fore.WHITE, ""
+    elif filepath.endswith(('.json', '.yaml', '.yml', '.toml')):
+        return Fore.YELLOW, ""
+    elif filepath.endswith(('.jpg', '.png', '.gif', '.svg', '.ico')):
+        return Fore.MAGENTA, ""
+    else:
+        return "", ""
+
+
+def format_file_listing(output: str) -> str:
+    """Format file listing output with colors"""
+    import os
+    from colorama import Style
+
+    lines = output.strip().split('\n')
+    formatted = []
+
+    for line in lines:
+        if not line.strip():
+            formatted.append(line)
+            continue
+
+        # Try to color the file part
+        parts = line.rsplit('/', 1)
+        if len(parts) == 2:
+            path, filename = parts
+            fg, style = get_file_color(line)
+            formatted.append(f"{path}/{fg}{style}{filename}{Style.RESET_ALL}")
+        else:
+            formatted.append(line)
+
+    return '\n'.join(formatted)
+
+
+def wrap_text(text: str, width: int = 80) -> str:
+    """Wrap text to specified width"""
+    import textwrap
+    return textwrap.fill(text, width=width)

npcsh/wander.py

@@ -0,0 +1,62 @@
+"""
+wander - Experimental wandering mode CLI entry point
+
+This is a thin wrapper that executes the wander.jinx through the jinx mechanism.
+"""
+import argparse
+import os
+import sys
+
+from npcsh._state import setup_shell
+
+
+def main():
+    parser = argparse.ArgumentParser(description="wander - Creative exploration with varied temperatures")
+    parser.add_argument("problem", nargs="*", help="Problem to explore through wandering")
+    parser.add_argument("--model", "-m", type=str, help="LLM model to use")
+    parser.add_argument("--provider", "-p", type=str, help="LLM provider to use")
+    parser.add_argument("--environment", type=str, help="Metaphorical environment for wandering")
+    parser.add_argument("--low-temp", type=float, default=0.5, help="Low temperature setting")
+    parser.add_argument("--high-temp", type=float, default=1.9, help="High temperature setting")
+    parser.add_argument("--n-streams", type=int, default=5, help="Number of exploration streams")
+    parser.add_argument("--include-events", action="store_true", help="Include random events")
+    parser.add_argument("--num-events", type=int, default=3, help="Number of events per stream")
+    args = parser.parse_args()
+
+    if not args.problem:
+        parser.print_help()
+        sys.exit(1)
+
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
+
+    if not team or "wander" not in team.jinxs_dict:
+        print("Error: wander jinx not found. Ensure npc_team/jinxs/modes/wander.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "problem": " ".join(args.problem),
+        "model": args.model,
+        "provider": args.provider,
+        "environment": args.environment,
+        "low_temp": args.low_temp,
+        "high_temp": args.high_temp,
+        "n_streams": args.n_streams,
+        "include_events": args.include_events,
+        "num_events": args.num_events,
+    }
+
+    # Execute the jinx
+    wander_jinx = team.jinxs_dict["wander"]
+    result = wander_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
+
+if __name__ == "__main__":
+    main()

npcsh/yap.py

@@ -0,0 +1,50 @@
+"""
+yap - Voice chat mode CLI entry point
+
+This is a thin wrapper that executes the yap.jinx through the jinx mechanism.
+"""
+import argparse
+import os
+import sys
+
+from npcsh._state import setup_shell
+
+
+def main():
+    parser = argparse.ArgumentParser(description="yap - Voice chat mode")
+    parser.add_argument("--model", "-m", type=str, help="LLM model to use")
+    parser.add_argument("--provider", "-p", type=str, help="LLM provider to use")
+    parser.add_argument("--files", "-f", nargs="*", help="Files to load for RAG context")
+    parser.add_argument("--tts-model", type=str, default="kokoro", help="TTS model to use")
+    parser.add_argument("--voice", type=str, default="af_heart", help="Voice for TTS")
+    args = parser.parse_args()
+
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
+
+    if not team or "yap" not in team.jinxs_dict:
+        print("Error: yap jinx not found. Ensure npc_team/jinxs/modes/yap.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "model": args.model,
+        "provider": args.provider,
+        "files": ",".join(args.files) if args.files else None,
+        "tts_model": args.tts_model,
+        "voice": args.voice,
+    }
+
+    # Execute the jinx
+    yap_jinx = team.jinxs_dict["yap"]
+    result = yap_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
+
+if __name__ == "__main__":
+    main()

npcsh-1.1.13.data/data/npcsh/npc_team/agent.jinx

@@ -0,0 +1,17 @@
+jinx_name: agent
+description: Provides an LLM response with tool use enabled.
+inputs:
+  - query
+  - auto_process_tool_calls: True
+  - use_core_tools: True
+steps:
+  - name: get_agent_response
+    engine: python
+    code: |
+      response = npc.get_llm_response(
+          request=query,
+          messages=context.get('messages', []),
+          auto_process_tool_calls={{ auto_process_tool_calls | default(True) }},
+          use_core_tools={{ use_core_tools | default(True) }}
+      )
+      output = response.get('response', '')