npcsh 1.0.7__tar.gz → 1.0.9__tar.gz

{npcsh-1.0.7 → npcsh-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.7
+Version: 1.0.9
 Summary: npcsh is a command-line toolkit for using AI agents in novel ways.
 Home-page: https://github.com/NPC-Worldwide/npcsh
 Author: Christopher Agostino

{npcsh-1.0.7 → npcsh-1.0.9}/npcsh/_state.py

@@ -12,6 +12,14 @@ from termcolor import colored
 
 
 from typing import Dict, List
+import subprocess
+import termios
+import tty
+import pty
+import select
+import signal
+import time
+import os
 import re
 import sqlite3
 from datetime import datetime
@@ -436,6 +444,7 @@ def start_interactive_session(command: list) -> int:
     """
     Starts an interactive session. Only works on Unix. On Windows, print a message and return 1.
     """
+    ON_WINDOWS = platform.system().lower().startswith("win")
     if ON_WINDOWS or termios is None or tty is None or pty is None or select is None or signal is None:
         print("Interactive terminal sessions are not supported on Windows.")
         return 1
@@ -552,6 +561,128 @@ def validate_bash_command(command_parts: list) -> bool:
             "flags": ["-a", "-e", "-t", "-f", "-F", "-W", "-n", "-g", "-h"],
             "requires_arg": True,
         },
+        "ls": {
+            "flags": [
+                "-a",
+                "-l",
+                "-h",
+                "-R",
+                "-t",
+                "-S",
+                "-r",
+                "-d",
+                "-F",
+                "-i",
+                "--color",
+            ],
+            "requires_arg": False,
+        },
+        "cp": {
+            "flags": [
+                "-r",
+                "-f",
+                "-i",
+                "-u",
+                "-v",
+                "--preserve",
+                "--no-preserve=mode,ownership,timestamps",
+            ],
+            "requires_arg": True,
+        },
+        "mv": {
+            "flags": ["-f", "-i", "-u", "-v", "--backup", "--no-clobber"],
+            "requires_arg": True,
+        },
+        "rm": {
+            "flags": ["-f", "-i", "-r", "-v", "--preserve-root", "--no-preserve-root"],
+            "requires_arg": True,
+        },
+        "mkdir": {
+            "flags": ["-p", "-v", "-m", "--mode", "--parents"],
+            "requires_arg": True,
+        },
+        "rmdir": {
+            "flags": ["-p", "-v", "--ignore-fail-on-non-empty"],
+            "requires_arg": True,
+        },
+        "touch": {
+            "flags": ["-a", "-c", "-m", "-r", "-d", "--date"],
+            "requires_arg": True,
+        },
+        "grep": {
+            "flags": [
+                "-i",
+                "-v",
+                "-r",
+                "-l",
+                "-n",
+                "-c",
+                "-w",
+                "-x",
+                "--color",
+                "--exclude",
+                "--include",
+            ],
+            "requires_arg": True,
+        },
+        "sed": {
+            "flags": [
+                "-e",
+                "-f",
+                "-i",
+                "-n",
+                "--expression",
+                "--file",
+                "--in-place",
+                "--quiet",
+                "--silent",
+            ],
+            "requires_arg": True,
+        },
+        "awk": {
+            "flags": [
+                "-f",
+                "-v",
+                "--file",
+                "--source",
+                "--assign",
+                "--posix",
+                "--traditional",
+            ],
+            "requires_arg": True,
+        },
+        "sort": {
+            "flags": [
+                "-b",
+                "-d",
+                "-f",
+                "-g",
+                "-i",
+                "-n",
+                "-r",
+                "-u",
+                "--check",
+                "--ignore-case",
+                "--numeric-sort",
+            ],
+            "requires_arg": False,
+        },
+        "uniq": {
+            "flags": ["-c", "-d", "-u", "-i", "--check-chars", "--skip-chars"],
+            "requires_arg": False,
+        },
+        "wc": {
+            "flags": ["-c", "-l", "-w", "-m", "-L", "--bytes", "--lines", "--words"],
+            "requires_arg": False,
+        },
+        "pwd": {
+            "flags": ["-L", "-P"],
+            "requires_arg": False,
+        },
+        "chmod": {
+            "flags": ["-R", "-v", "-c", "--reference"],
+            "requires_arg": True,
+        },
 
     }
 
@@ -559,10 +690,21 @@ def validate_bash_command(command_parts: list) -> bool:
 
     if base_command == 'which':
         return False # disable which arbitrarily cause the command parsing for it is too finnicky.
+
+
+    # Allow interactive commands (ipython, python, sqlite3, r) as valid commands
+    INTERACTIVE_COMMANDS = ["ipython", "python", "sqlite3", "r"]
+    TERMINAL_EDITORS = ["vim", "nano", "emacs"]
+    if base_command in TERMINAL_EDITORS or base_command in INTERACTIVE_COMMANDS:
+        return True
+
     if base_command not in COMMAND_PATTERNS and base_command not in BASH_COMMANDS:
-        return False # Allow other commands to pass through
+        return False # Not a recognized command
+
+    pattern = COMMAND_PATTERNS.get(base_command)
+    if not pattern:
+        return True  # Allow commands in BASH_COMMANDS but not in COMMAND_PATTERNS
 
-    pattern = COMMAND_PATTERNS[base_command]
     args = []
     flags = []
 

{npcsh-1.0.7 → npcsh-1.0.9}/npcsh/npc.py

@@ -85,8 +85,6 @@ def main():
                                          help="Run 'npc <command> --help' for command-specific help")
 
         for cmd_name, help_text in router.help_info.items():
-            if router.shell_only.get(cmd_name, False):
-                continue
 
             cmd_parser = subparsers.add_parser(cmd_name, help=help_text, add_help=False)
             cmd_parser.add_argument('command_args', nargs=argparse.REMAINDER,

{npcsh-1.0.7 → npcsh-1.0.9}/npcsh/npcsh.py

@@ -31,9 +31,11 @@ import yaml
 # Local Application Imports
 from npcsh._state import (
     setup_npcsh_config,
+    initial_state, 
     is_npcsh_initialized,
     initialize_base_npcs_if_needed,
     orange,
+    ShellState,
     interactive_commands,
     BASH_COMMANDS,
     start_interactive_session,
@@ -83,7 +85,178 @@ except Exception as e:
 
 
 
-from npcsh._state import initial_state, ShellState
+
+def get_path_executables() -> List[str]:
+    """Get executables from PATH (cached for performance)"""
+    if not hasattr(get_path_executables, '_cache'):
+        executables = set()
+        path_dirs = os.environ.get('PATH', '').split(os.pathsep)
+        for path_dir in path_dirs:
+            if os.path.isdir(path_dir):
+                try:
+                    for item in os.listdir(path_dir):
+                        item_path = os.path.join(path_dir, item)
+                        if os.path.isfile(item_path) and os.access(item_path, os.X_OK):
+                            executables.add(item)
+                except (PermissionError, OSError):
+                    continue
+        get_path_executables._cache = sorted(list(executables))
+    return get_path_executables._cache
+
+
+import logging
+
+# Set up completion logger
+completion_logger = logging.getLogger('npcsh.completion')
+completion_logger.setLevel(logging.WARNING)  # Default to WARNING (quiet)
+
+# Add handler if not already present
+if not completion_logger.handlers:
+    handler = logging.StreamHandler(sys.stderr)
+    formatter = logging.Formatter('[%(name)s] %(message)s')
+    handler.setFormatter(formatter)
+    completion_logger.addHandler(handler)
+
+def make_completer(shell_state: ShellState):
+    def complete(text: str, state_index: int) -> Optional[str]:
+        """Main completion function"""
+        try:
+            buffer = readline.get_line_buffer()
+            begidx = readline.get_begidx()
+            endidx = readline.get_endidx()
+            
+            completion_logger.debug(f"text='{text}', buffer='{buffer}', begidx={begidx}, endidx={endidx}, state_index={state_index}")
+            
+            matches = []
+            
+            # Check if we're completing a slash command
+            if begidx > 0 and buffer[begidx-1] == '/':
+                completion_logger.debug(f"Slash command completion - text='{text}'")
+                slash_commands = get_slash_commands(shell_state)
+                completion_logger.debug(f"Available slash commands: {slash_commands}")
+                
+                if text == '':
+                    matches = [cmd[1:] for cmd in slash_commands]
+                else:
+                    full_text = '/' + text
+                    matching_commands = [cmd for cmd in slash_commands if cmd.startswith(full_text)]
+                    matches = [cmd[1:] for cmd in matching_commands]
+                
+                completion_logger.debug(f"Slash command matches: {matches}")
+                
+            elif is_command_position(buffer, begidx):
+                completion_logger.debug("Command position detected")
+                bash_matches = [cmd for cmd in BASH_COMMANDS if cmd.startswith(text)]
+                matches.extend(bash_matches)
+                
+                interactive_matches = [cmd for cmd in interactive_commands.keys() if cmd.startswith(text)]
+                matches.extend(interactive_matches)
+                
+                if len(text) >= 1:
+                    path_executables = get_path_executables()
+                    exec_matches = [cmd for cmd in path_executables if cmd.startswith(text)]
+                    matches.extend(exec_matches[:20])
+            else:
+                completion_logger.debug("File completion")
+                matches = get_file_completions(text)
+            
+            matches = sorted(list(set(matches)))
+            completion_logger.debug(f"Final matches: {matches}")
+            
+            if state_index < len(matches):
+                result = matches[state_index]
+                completion_logger.debug(f"Returning: '{result}'")
+                return result
+            else:
+                completion_logger.debug(f"No match for state_index {state_index}")
+            
+        except Exception as e:
+            completion_logger.error(f"Exception in completion: {e}")
+            completion_logger.debug("Exception details:", exc_info=True)
+        
+        return None
+    
+    return complete
+
+def get_slash_commands(state: ShellState) -> List[str]:
+    """Get available slash commands from router and team"""
+    commands = []
+    
+    completion_logger.debug("Getting slash commands...")
+    
+    # Router commands
+    if router and hasattr(router, 'routes'):
+        router_cmds = [f"/{cmd}" for cmd in router.routes.keys()]
+        commands.extend(router_cmds)
+        completion_logger.debug(f"Router commands: {router_cmds}")
+    
+    # Team jinxs
+    if state.team and hasattr(state.team, 'jinxs_dict'):
+        jinx_cmds = [f"/{jinx}" for jinx in state.team.jinxs_dict.keys()]
+        commands.extend(jinx_cmds)
+        completion_logger.debug(f"Jinx commands: {jinx_cmds}")
+    
+    # NPC names for switching
+    if state.team and hasattr(state.team, 'npcs'):
+        npc_cmds = [f"/{npc}" for npc in state.team.npcs.keys()]
+        commands.extend(npc_cmds)
+        completion_logger.debug(f"NPC commands: {npc_cmds}")
+    
+    # Mode switching commands
+    mode_cmds = ['/cmd', '/agent', '/chat', '/ride']
+    commands.extend(mode_cmds)
+    completion_logger.debug(f"Mode commands: {mode_cmds}")
+    
+    result = sorted(commands)
+    completion_logger.debug(f"Final slash commands: {result}")
+    return result
+def get_file_completions(text: str) -> List[str]:
+    """Get file/directory completions"""
+    try:
+        if text.startswith('/'):
+            basedir = os.path.dirname(text) or '/'
+            prefix = os.path.basename(text)
+        elif text.startswith('./') or text.startswith('../'):
+            basedir = os.path.dirname(text) or '.'
+            prefix = os.path.basename(text)
+        else:
+            basedir = '.'
+            prefix = text
+        
+        if not os.path.exists(basedir):
+            return []
+        
+        matches = []
+        try:
+            for item in os.listdir(basedir):
+                if item.startswith(prefix):
+                    full_path = os.path.join(basedir, item)
+                    if basedir == '.':
+                        completion = item
+                    else:
+                        completion = os.path.join(basedir, item)
+                    
+                    # Just return the name, let readline handle spacing/slashes
+                    matches.append(completion)
+        except (PermissionError, OSError):
+            pass
+        
+        return sorted(matches)
+    except Exception:
+        return []
+def is_command_position(buffer: str, begidx: int) -> bool:
+    """Determine if cursor is at a command position"""
+    # Get the part of buffer before the current word
+    before_word = buffer[:begidx]
+    
+    # Split by command separators 
+    parts = re.split(r'[|;&]', before_word)
+    current_command_part = parts[-1].strip()
+    
+    # If there's nothing before the current word in this command part,
+    # or only whitespace, we're at command position
+    return len(current_command_part) == 0
+
 
 def readline_safe_prompt(prompt: str) -> str:
     ansi_escape = re.compile(r"(\033\[[0-9;]*[a-zA-Z])")
@@ -233,29 +406,27 @@ def wrap_text(text: str, width: int = 80) -> str:
 # --- Readline Setup and Completion ---
 
 def setup_readline() -> str:
+    """Setup readline with history and completion"""
     try:
         readline.read_history_file(READLINE_HISTORY_FILE)
-
         readline.set_history_length(1000)
+        
+        # Don't set completer here - it will be set in run_repl with state
+        readline.parse_and_bind("tab: complete")
+        
         readline.parse_and_bind("set enable-bracketed-paste on")
-        #readline.parse_and_bind('"\e[A": history-search-backward')
-        #readline.parse_and_bind('"\e[B": history-search-forward')
         readline.parse_and_bind(r'"\C-r": reverse-search-history')
         readline.parse_and_bind(r'"\C-e": end-of-line')
         readline.parse_and_bind(r'"\C-a": beginning-of-line')
-        #if sys.platform == "darwin":
-        #    readline.parse_and_bind("bind ^I rl_complete")
-        #else:
-        #    readline.parse_and_bind("tab: complete")
-
+        
         return READLINE_HISTORY_FILE
-
-
+        
     except FileNotFoundError:
         pass
     except OSError as e:
         print(f"Warning: Could not read readline history file {READLINE_HISTORY_FILE}: {e}")
 
+
 def save_readline_history():
     try:
         readline.write_history_file(READLINE_HISTORY_FILE)
@@ -263,52 +434,11 @@ def save_readline_history():
         print(f"Warning: Could not write readline history file {READLINE_HISTORY_FILE}: {e}")
 
 
-# --- Placeholder for actual valid commands ---
-# This should be populated dynamically based on router, builtins, and maybe PATH executables
-valid_commands_list = list(router.routes.keys()) + list(interactive_commands.keys()) + ["cd", "exit", "quit"] + BASH_COMMANDS
 
-def complete(text: str, state: int) -> Optional[str]:
-    try:
-        buffer = readline.get_line_buffer()
-    except:
-        print('couldnt get readline buffer')
-    line_parts = parse_command_safely(buffer) # Use safer parsing
-    word_before_cursor = ""
-    if len(line_parts) > 0 and not buffer.endswith(' '):
-         current_word = line_parts[-1]
-    else:
-         current_word = "" # Completing after a space
 
-    try:
-        # Command completion (start of line or after pipe/semicolon)
-        # This needs refinement to detect context better
-        is_command_start = not line_parts or (len(line_parts) == 1 and not buffer.endswith(' ')) # Basic check
-        if is_command_start and not text.startswith('-'): # Don't complete options as commands
-            cmd_matches = [cmd + ' ' for cmd in valid_commands_list if cmd.startswith(text)]
-            # Add executables from PATH? (Can be slow)
-            # path_executables = [f + ' ' for f in shutil.get_exec_path() if os.path.basename(f).startswith(text)]
-            # cmd_matches.extend(path_executables)
-            return cmd_matches[state]
-
-        # File/Directory completion (basic)
-        # Improve context awareness (e.g., after 'cd', 'ls', 'cat', etc.)
-        if text and (not text.startswith('/') or os.path.exists(os.path.dirname(text))):
-             basedir = os.path.dirname(text)
-             prefix = os.path.basename(text)
-             search_dir = basedir if basedir else '.'
-             try:
-                 matches = [os.path.join(basedir, f) + ('/' if os.path.isdir(os.path.join(search_dir, f)) else ' ')
-                            for f in os.listdir(search_dir) if f.startswith(prefix)]
-                 return matches[state]
-             except OSError: # Handle permission denied etc.
-                  return None
-
-    except IndexError:
-        return None
-    except Exception: # Catch broad exceptions during completion
-        return None
+valid_commands_list = list(router.routes.keys()) + list(interactive_commands.keys()) + ["cd", "exit", "quit"] + BASH_COMMANDS
+
 
-    return None
 
 
 # --- Command Execution Logic ---
@@ -1146,7 +1276,6 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     command_history = CommandHistory(db_path)
 
     try:
-        readline.set_completer(complete)
         history_file = setup_readline()
         atexit.register(save_readline_history)
         atexit.register(command_history.close)
@@ -1317,6 +1446,11 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
     print(f'Using {state.current_mode} mode. Use /agent, /cmd, /chat, or /ride to switch to other modes')
     print(f'To switch to a different NPC, type /<npc_name>')
     is_windows = platform.system().lower().startswith("win")
+    try:
+        completer = make_completer(state)
+        readline.set_completer(completer)
+    except:
+        pass
 
     def exit_shell(state):
         print("\nGoodbye!")
@@ -1336,6 +1470,12 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
 
     while True:
         try:
+            try:
+                completer = make_completer(state)
+                readline.set_completer(completer)
+            except:
+                pass
+
             if is_windows:
                 cwd_part = os.path.basename(state.current_path)
                 if isinstance(state.npc, NPC):
@@ -1350,12 +1490,6 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                 else:
                     prompt_end = f":🤖{colored('npc', 'blue', attrs=['bold'])}{colored('sh', 'yellow')}> "
                 prompt = readline_safe_prompt(f"{cwd_colored}{prompt_end}")
-            cwd_colored = colored(os.path.basename(state.current_path), "blue")
-            if isinstance(state.npc, NPC):
-                prompt_end = f":🤖{orange(state.npc.name)}> "
-            else:
-                prompt_end = f":🤖{colored('npc', 'blue', attrs=['bold'])}{colored('sh', 'yellow')}> "
-            prompt = readline_safe_prompt(f"{cwd_colored}{prompt_end}")
 
             user_input = get_multiline_input(prompt).strip()
             # Handle Ctrl+Z (ASCII SUB, '\x1a') as exit (Windows and Unix)

{npcsh-1.0.7 → npcsh-1.0.9}/npcsh/routes.py

@@ -62,13 +62,11 @@ class CommandRouter:
     def __init__(self):
         self.routes = {}
         self.help_info = {}
-        self.shell_only = {}
 
-    def route(self, command: str, help_text: str = "", shell_only: bool = False) -> Callable:
+    def route(self, command: str, help_text: str = "") -> Callable:
         def wrapper(func):
             self.routes[command] = func
             self.help_info[command] = help_text
-            self.shell_only[command] = shell_only
 
             @functools.wraps(func)
             def wrapped_func(*args, **kwargs):
@@ -102,13 +100,12 @@ router = CommandRouter()
 def get_help_text():
     commands = router.get_commands()
     help_info = router.help_info
-    shell_only = router.shell_only
+
     commands.sort()
     output = "# Available Commands\n\n"
     for cmd in commands:
         help_text = help_info.get(cmd, "")
-        shell_only_text = " (Shell only)" if shell_only.get(cmd, False) else ""
-        output += f"/{cmd}{shell_only_text} - {help_text}\n\n"
+        output += f"/{cmd} - {help_text}\n\n"
     output += """
 # Note
 - Bash commands and programs can be executed directly (try bash first, then LLM).
@@ -120,7 +117,7 @@ def get_help_text():
 def safe_get(kwargs, key, default=None):
     return kwargs.get(key, default)
 
-@router.route("breathe", "Condense context on a regular cadence", shell_only=True)
+@router.route("breathe", "Condense context on a regular cadence")
 def breathe_handler(command: str, **kwargs):
     messages = safe_get(kwargs, "messages", [])
     npc = safe_get(kwargs, "npc")
@@ -162,7 +159,7 @@ def compile_handler(command: str, **kwargs):
 
 
 
-@router.route("flush", "Flush the last N messages", shell_only=True)
+@router.route("flush", "Flush the last N messages")
 def flush_handler(command: str, **kwargs):
     messages = safe_get(kwargs, "messages", [])
     try:
@@ -260,6 +257,28 @@ def init_handler(command: str, **kwargs):
         traceback.print_exc()
         output = f"Error initializing project: {e}"
     return {"output": output, "messages": messages}
+# Add these route handlers after the existing imports (around line 50):
+@router.route("n")
+@router.route("npc")
+def switch_npc_handler(command: str, **kwargs) -> dict:
+    """Switch to a different NPC"""
+    team = kwargs.get('team')
+    parts = command.split()
+    
+    if len(parts) < 2:
+        if team:
+            available_npcs = list(team.npcs.keys())
+            return {"output": f"Available NPCs: {', '.join(available_npcs)}"}
+        return {"output": "No team loaded or no NPC specified"}
+    
+    npc_name = parts[1]
+    if team and npc_name in team.npcs:
+        # We can't directly modify the state here, so return a special signal
+        return {"output": f"SWITCH_NPC:{npc_name}"}
+    else:
+        available_npcs = list(team.npcs.keys()) if team else []
+        return {"output": f"NPC '{npc_name}' not found. Available: {', '.join(available_npcs)}"}
+
 
 
 @router.route("ots", "Take screenshot and optionally analyze with vision model")
@@ -284,7 +303,7 @@ def ots_handler(command: str, **kwargs):
                 else:
                     return {"output": f"Error: Image file not found at {full_path}", "messages": messages}
         else:
-            screenshot_info = capture_screenshot(npc=npc)
+            screenshot_info = capture_screenshot(full=False)
             if screenshot_info and "file_path" in screenshot_info:
                 image_paths.append(screenshot_info["file_path"])
                 print(f"Screenshot captured: {screenshot_info.get('filename', os.path.basename(screenshot_info['file_path']))}")
@@ -823,7 +842,7 @@ def wander_handler(command: str, **kwargs):
         traceback.print_exc()
         return {"output": f"Error during wander mode: {e}", "messages": messages}
 
-@router.route("yap", "Enter voice chat (yap) mode", shell_only=True)
+@router.route("yap", "Enter voice chat (yap) mode")
 def whisper_handler(command: str, **kwargs):
     try:
         return enter_yap_mode(

{npcsh-1.0.7 → npcsh-1.0.9}/npcsh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.7
+Version: 1.0.9
 Summary: npcsh is a command-line toolkit for using AI agents in novel ways.
 Home-page: https://github.com/NPC-Worldwide/npcsh
 Author: Christopher Agostino

{npcsh-1.0.7 → npcsh-1.0.9}/setup.py

@@ -84,7 +84,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcsh",
-    version="1.0.7",
+    version="1.0.9",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  # Only install base requirements by default
     extras_require={