npcsh 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

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
@@ -681,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/alicanto.py

@@ -14,11 +14,11 @@ import subprocess
 import networkx as nx
 
 from npcpy.npc_compiler import NPC
-from npcpy.llm_funcs import get_llm_response
+from npcpy.llm_funcs import get_llm_response, extract_facts, identify_groups, assign_groups_to_fact
 from npcsh._state import NPCSH_CHAT_MODEL, NPCSH_CHAT_PROVIDER
 from npcpy.npc_sysenv import print_and_process_stream_with_markdown
-from npcpy.memory.deep_research import consolidate_research
-from npcpy.memory.knowledge_graph import extract_facts, identify_groups, assign_groups_to_fact
+
+
 
 def generate_random_npcs(num_npcs: int, model: str, provider: str, request: str) -> List[NPC]:
     """

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/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,
@@ -52,8 +54,6 @@ from npcpy.memory.command_history import (
     CommandHistory,
     save_conversation_message,
 )
-from npcpy.memory.knowledge_graph import breathe
-from npcpy.memory.sleep import sleep, forget
 from npcpy.npc_compiler import NPC, Team, load_jinxs_from_directory
 from npcpy.llm_funcs import check_llm_command, get_llm_response, execute_llm_command
 from npcpy.gen.embeddings import get_embeddings
@@ -83,7 +83,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 +404,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 +432,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 ---
@@ -455,10 +583,8 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
             result_dict = handler(command, **handler_kwargs)
 
             if isinstance(result_dict, dict):
-                #some respond with output, some with response, needs to be fixed upstream
-                output = result_dict.get("output") or result_dict.get("response")
                 state.messages = result_dict.get("messages", state.messages)
-                return state, output
+                return state, result_dict
             else:
                 return state, result_dict
 
@@ -572,7 +698,7 @@ def process_pipeline_command(
             images=state.attachments,
             stream=stream_final,
             context=info,
-            shell=True,
+
         )
         if isinstance(llm_result, dict):
             state.messages = llm_result.get("messages", state.messages)
@@ -729,8 +855,6 @@ def execute_command(
                     try:
                         bash_state, bash_output = handle_bash_command(cmd_parts, command, None, state)
                         return bash_state, bash_output
-                    except CommandNotFoundError:
-                        return state, colored(f"Command not found: {command_name}", "red")
                     except Exception as bash_err:
                         return state, colored(f"Bash execution failed: {bash_err}", "red")
             except Exception:
@@ -1007,12 +1131,13 @@ def execute_todo_item(todo: Dict[str, Any], ride_state: RideState, shell_state:
         team=shell_state.team,
         messages=[],
         stream=shell_state.stream_output,
-        shell=True,
+
     )
     
     output_payload = result.get("output", "")
     output_str = ""
 
+
     if isgenerator(output_payload):
         output_str = print_and_process_stream_with_markdown(output_payload, shell_state.chat_model, shell_state.chat_provider)
     elif isinstance(output_payload, dict):
@@ -1146,7 +1271,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)
@@ -1269,34 +1393,30 @@ def process_result(
     if user_input =='/help':
         render_markdown(output)
     elif result_state.stream_output:
-
-        try:
-            final_output_str = print_and_process_stream_with_markdown(output, result_state.chat_model, result_state.chat_provider)
-        except AttributeError as e:
-            if isinstance(output, str):
-                if len(output) > 0:
-                    final_output_str = output
-                    render_markdown(final_output_str) 
-        except TypeError as e:
-
-            if isinstance(output, str):
-                if len(output) > 0:
-                    final_output_str = output
-                    render_markdown(final_output_str)
-            elif isinstance(output, dict):
-                if 'output' in output:
-                    final_output_str = output['output']
-                    render_markdown(final_output_str)
+        
+        if isinstance(output, dict):
+            output_gen = output.get('output')
+            model = output.get('model', result_state.chat_model)
+            provider = output.get('provider', result_state.chat_provider)
+        else:
+            output_gen = output
+            model = result_state.chat_model
+            provider = result_state.chat_provider
+        print('processing stream output with markdown...')
+
+        final_output_str = print_and_process_stream_with_markdown(output_gen, 
+                                                                    model, 
+                                                                    provider)
                         
     elif output is not None:
         final_output_str = str(output)
-        render_markdown(final_output_str)
+        render_markdown('str not none: ', final_output_str)
     if final_output_str and result_state.messages and result_state.messages[-1].get("role") != "assistant":
         result_state.messages.append({"role": "assistant", "content": final_output_str})
 
     #print(result_state.messages)
 
-    print() # Add spacing after output
+
 
     if final_output_str:
         save_conversation_message(
@@ -1317,6 +1437,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 +1461,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 +1481,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/routes.py

@@ -24,6 +24,7 @@ from npcpy.llm_funcs import (
     get_llm_response,
     gen_image,
     gen_video,
+    breathe,
 )
 from npcpy.npc_compiler import NPC, Team, Jinx
 from npcpy.npc_compiler import initialize_npc_project
@@ -38,8 +39,8 @@ from npcpy.memory.search import execute_rag_command, execute_search_command, exe
 from npcpy.memory.command_history import CommandHistory
 
 
-from npcpy.memory.knowledge_graph import breathe
-from npcpy.memory.sleep import sleep, forget
+
+
 from npcpy.serve import start_flask_server
 
 
@@ -62,13 +63,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 +101,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 +118,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 +160,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 +258,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 +304,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']))}")
@@ -317,7 +337,7 @@ def ots_handler(command: str, **kwargs):
             api_url=safe_get(kwargs, 'api_url'),
             api_key=safe_get(kwargs, 'api_key')
         )
-        return {"output": response_data.get('response'), "messages": response_data.get('messages')}
+        return {"output": response_data.get('response'), "messages": response_data.get('messages'), "model": vision_model, "provider": vision_provider}
 
     except Exception as e:
         traceback.print_exc()
@@ -823,7 +843,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.8.dist-info → npcsh-1.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.8
+Version: 1.0.10
 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.10.dist-info/RECORD

@@ -0,0 +1,21 @@
+npcsh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+npcsh/_state.py,sha256=GCMUIwgIBlS7LEBLYlfBiPNKVaK19ZyxT833NFU-djU,31109
+npcsh/alicanto.py,sha256=F-zZGjBTo3a_PQHvPC8-DNF6t4mJELo_zx7gBGvDehg,44611
+npcsh/guac.py,sha256=Ocmk_c4NUtGsC3JOtmkbgLvD6u-XtBPRFRYcckpgUJU,33099
+npcsh/mcp_helpers.py,sha256=Ktd2yXuBnLL2P7OMalgGLj84PXJSzaucjqmJVvWx6HA,12723
+npcsh/mcp_npcsh.py,sha256=SfmplH62GS9iI6q4vuQLVUS6tkrok6L7JxODx_iH7ps,36158
+npcsh/mcp_server.py,sha256=l2Ra0lpFrUu334pvp0Q9ajF2n73KvZswFi0FgbDhh9k,5884
+npcsh/npc.py,sha256=7ujKrMQFgkeGJ4sX5Kn_dB5tjrPN58xeC91PNt453aM,7827
+npcsh/npcsh.py,sha256=xrDcmK3UlkTXF2tdR1Bxq7sqG62-AcUTf_IupJYt8U4,59237
+npcsh/plonk.py,sha256=U2e9yUJZN95Girzzvgrh-40zOdl5zO3AHPsIjoyLv2M,15261
+npcsh/pti.py,sha256=jGHGE5SeIcDkV8WlOEHCKQCnYAL4IPS-kUBHrUz0oDA,10019
+npcsh/routes.py,sha256=JNlRMk8WvGlR950Bl_LQMjm_gtdpPI0XMBQlj_YjI5I,37768
+npcsh/spool.py,sha256=GhnSFX9uAtrB4m_ijuyA5tufH12DrWdABw0z8FmiCHc,11497
+npcsh/wander.py,sha256=BiN6eYyFnEsFzo8MFLRkdZ8xS9sTKkQpjiCcy9chMcc,23225
+npcsh/yap.py,sha256=h5KNt9sNOrDPhGe_zfn_yFIeQhizX09zocjcPWH7m3k,20905
+npcsh-1.0.10.dist-info/licenses/LICENSE,sha256=IKBvAECHP-aCiJtE4cHGCE5Yl0tozYz02PomGeWS3y4,1070
+npcsh-1.0.10.dist-info/METADATA,sha256=kaQ9neGi6CVloTZFgFdudx_oQZ9MHhlEqnwBoUp47Os,22748
+npcsh-1.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcsh-1.0.10.dist-info/entry_points.txt,sha256=qxOYTm3ym3JWyWf2nv2Mk71uMcJIdUoNEJ8VYMkyHiY,214
+npcsh-1.0.10.dist-info/top_level.txt,sha256=kHSNgKMCkfjV95-DH0YSp1LLBi0HXdF3w57j7MQON3E,6
+npcsh-1.0.10.dist-info/RECORD,,

npcsh-1.0.8.dist-info/RECORD

@@ -1,21 +0,0 @@
-npcsh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-npcsh/_state.py,sha256=IsWS9uIOFv7X8vpcLjjErCaFoJFlrzqxTduAZ6qGpMs,30549
-npcsh/alicanto.py,sha256=zJF5YwSNvtbK2EUKXzG45WOCMsSFu5cek5jCR7FgiuE,44709
-npcsh/guac.py,sha256=Ocmk_c4NUtGsC3JOtmkbgLvD6u-XtBPRFRYcckpgUJU,33099
-npcsh/mcp_helpers.py,sha256=Ktd2yXuBnLL2P7OMalgGLj84PXJSzaucjqmJVvWx6HA,12723
-npcsh/mcp_npcsh.py,sha256=SfmplH62GS9iI6q4vuQLVUS6tkrok6L7JxODx_iH7ps,36158
-npcsh/mcp_server.py,sha256=l2Ra0lpFrUu334pvp0Q9ajF2n73KvZswFi0FgbDhh9k,5884
-npcsh/npc.py,sha256=nKgNg6BZsp40znH2wbSnd6td6pvOM82csn_6og0Bx58,7907
-npcsh/npcsh.py,sha256=yRpTvpy8OiVCyWpHfNGfuueojwy2ZHnoZii91S4fKaQ,55229
-npcsh/plonk.py,sha256=U2e9yUJZN95Girzzvgrh-40zOdl5zO3AHPsIjoyLv2M,15261
-npcsh/pti.py,sha256=jGHGE5SeIcDkV8WlOEHCKQCnYAL4IPS-kUBHrUz0oDA,10019
-npcsh/routes.py,sha256=ufQVc6aqgC14_YHV88iwV53TN1Pk095NB6gFDqQqfB4,37208
-npcsh/spool.py,sha256=GhnSFX9uAtrB4m_ijuyA5tufH12DrWdABw0z8FmiCHc,11497
-npcsh/wander.py,sha256=BiN6eYyFnEsFzo8MFLRkdZ8xS9sTKkQpjiCcy9chMcc,23225
-npcsh/yap.py,sha256=h5KNt9sNOrDPhGe_zfn_yFIeQhizX09zocjcPWH7m3k,20905
-npcsh-1.0.8.dist-info/licenses/LICENSE,sha256=IKBvAECHP-aCiJtE4cHGCE5Yl0tozYz02PomGeWS3y4,1070
-npcsh-1.0.8.dist-info/METADATA,sha256=dyfZu_kNq1aT4XAKz319ILVW12U8NLNBog4BG_o2ias,22747
-npcsh-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcsh-1.0.8.dist-info/entry_points.txt,sha256=qxOYTm3ym3JWyWf2nv2Mk71uMcJIdUoNEJ8VYMkyHiY,214
-npcsh-1.0.8.dist-info/top_level.txt,sha256=kHSNgKMCkfjV95-DH0YSp1LLBi0HXdF3w57j7MQON3E,6
-npcsh-1.0.8.dist-info/RECORD,,