npcsh 1.0.14__py3-none-any.whl → 1.0.16__py3-none-any.whl

npcsh/npc.py

@@ -1,7 +1,6 @@
 import argparse
 import sys
 import os
-import sqlite3
 import traceback
 from typing import Optional
 
@@ -11,7 +10,8 @@ from npcsh._state import (
     NPCSH_API_URL, 
     NPCSH_DB_PATH, 
     NPCSH_STREAM_OUTPUT,
-    )
+    initial_state,
+)
 from npcpy.npc_sysenv import (
     print_and_process_stream_with_markdown,
     render_markdown,
@@ -19,8 +19,18 @@ from npcpy.npc_sysenv import (
 from npcpy.npc_compiler import NPC, Team
 from npcsh.routes import router
 from npcpy.llm_funcs import check_llm_command
+from sqlalchemy import create_engine
+
+# Import the key functions from npcsh
+from npcsh.npcsh import (
+    setup_shell,
+    execute_slash_command,
+    execute_command,
+    process_pipeline_command,
+)
 
 def load_npc_by_name(npc_name: str = "sibiji", db_path: str = NPCSH_DB_PATH) -> Optional[NPC]:
+    """Load NPC by name, with fallback logic matching npcsh"""
     if not npc_name:
         npc_name = "sibiji"
 
@@ -37,7 +47,7 @@ def load_npc_by_name(npc_name: str = "sibiji", db_path: str = NPCSH_DB_PATH) ->
 
     if chosen_path:
         try:
-            db_conn = sqlite3.connect(db_path)
+            db_conn = create_engine(f'sqlite:///{NPCSH_DB_PATH}')
             npc = NPC(file=chosen_path, db_conn=db_conn)
             return npc
         except Exception as e:
@@ -64,34 +74,38 @@ def main():
         "-n", "--npc", help="Name of the NPC to use (default: sibiji)", type=str, default="sibiji"
     )
 
-    # No subparsers setup at first - we'll conditionally create them
-
-    # First, get any arguments without parsing commands
+    # Parse arguments
     args, all_args = parser.parse_known_args()
     global_model = args.model
     global_provider = args.provider
 
-    # Check if the first argument is a known command
     is_valid_command = False
     command_name = None
-    if all_args and all_args[0] in router.get_commands():
-        is_valid_command = True
-        command_name = all_args[0]
-        all_args = all_args[1:]  # Remove the command from arguments
+    
+    if all_args:
+        first_arg = all_args[0]
+        if first_arg.startswith('/'):
+            is_valid_command = True
+            command_name = first_arg
+            all_args = all_args[1:]
+        elif first_arg in router.get_commands():
+            is_valid_command = True
+            command_name = '/' + first_arg
+            all_args = all_args[1:]
+
+
 
-    # Only set up subparsers if we have a valid command
     if is_valid_command:
         subparsers = parser.add_subparsers(dest="command", title="Available Commands",
                                          help="Run 'npc <command> --help' for command-specific help")
 
         for cmd_name, help_text in router.help_info.items():
-
             cmd_parser = subparsers.add_parser(cmd_name, help=help_text, add_help=False)
             cmd_parser.add_argument('command_args', nargs=argparse.REMAINDER,
                                     help='Arguments passed directly to the command handler')
 
         # Re-parse with command subparsers
-        args = parser.parse_args([command_name] + all_args)
+        args = parser.parse_args([command_name.lstrip('/')] + all_args)
         command_args = args.command_args if hasattr(args, 'command_args') else []
         unknown_args = []
     else:
@@ -104,67 +118,86 @@ def main():
         args.model = global_model
     if args.provider is None:
         args.provider = global_provider
-    # --- END OF FIX ---
-    npc_instance = load_npc_by_name(args.npc, NPCSH_DB_PATH)
-
-    effective_model = args.model or NPCSH_CHAT_MODEL
-    effective_provider = args.provider or NPCSH_CHAT_PROVIDER
-
 
+    # Use npcsh's setup_shell to get proper team and NPC setup
+    try:
+        command_history, team, forenpc_obj = setup_shell()
+    except Exception as e:
+        print(f"Warning: Could not set up full npcsh environment: {e}", file=sys.stderr)
+        print("Falling back to basic NPC loading...", file=sys.stderr)
+        team = None
+        forenpc_obj = load_npc_by_name(args.npc, NPCSH_DB_PATH)
+
+    # Determine which NPC to use
+    npc_instance = None
+    if team and args.npc in team.npcs:
+        npc_instance = team.npcs[args.npc]
+    elif team and args.npc == team.forenpc.name if team.forenpc else False:
+        npc_instance = team.forenpc
+    else:
+        npc_instance = load_npc_by_name(args.npc, NPCSH_DB_PATH)
 
-    extras = {}
+    if not npc_instance:
+        print(f"Error: Could not load NPC '{args.npc}'", file=sys.stderr)
+        sys.exit(1)
 
-    # Process command args if we have a valid command
-    if is_valid_command:
-        # Parse command args properly
-        if command_args:
-            i = 0
-            while i < len(command_args):
-                arg = command_args[i]
-                if arg.startswith("--"):
-                    param = arg[2:]  # Remove --
-                    if "=" in param:
-                        param_name, param_value = param.split("=", 1)
-                        extras[param_name] = param_value
-                        i += 1
-                    elif i + 1 < len(command_args) and not command_args[i+1].startswith("--"):
-                        extras[param] = command_args[i+1]
-                        i += 2
-                    else:
-                        extras[param] = True
-                        i += 1
-                else:
-                    i += 1
-            
-        handler = router.get_route(command_name)
-        if not handler:
-            print(f"Error: Command '{command_name}' recognized but no handler found.", file=sys.stderr)
-            sys.exit(1)
-
-        full_command_str = command_name
-        if command_args:
-            full_command_str += " " + " ".join(command_args)
+    # Now check for jinxs if we haven't identified a command yet
+    if not is_valid_command and all_args:
+        first_arg = all_args[0]
         
-        handler_kwargs = {
-            "model": effective_model,
-            "provider": effective_provider,
-            "npc": npc_instance,
-            "api_url": NPCSH_API_URL,
-            "stream": NPCSH_STREAM_OUTPUT,
-            "messages": [],
-            "team": None,
-            "current_path": os.getcwd(),
-            **extras
-        }
-
-        try:
-            result = handler(command=full_command_str, **handler_kwargs)
+        # Check if first argument is a jinx name
+        jinx_found = False
+        if team and first_arg in team.jinxs_dict:
+            jinx_found = True
+        elif isinstance(npc_instance, NPC) and hasattr(npc_instance, 'jinxs_dict') and first_arg in npc_instance.jinxs_dict:
+            jinx_found = True
+            
+        if jinx_found:
+            is_valid_command = True
+            command_name = '/' + first_arg
+            all_args = all_args[1:]
+
+    # Create a shell state object similar to npcsh
+    shell_state = initial_state
+    shell_state.npc = npc_instance
+    shell_state.team = team
+    shell_state.current_path = os.getcwd()
+    shell_state.stream_output = NPCSH_STREAM_OUTPUT
+
+    # Override model/provider if specified
+    effective_model = args.model or (npc_instance.model if npc_instance.model else NPCSH_CHAT_MODEL)
+    effective_provider = args.provider or (npc_instance.provider if npc_instance.provider else NPCSH_CHAT_PROVIDER)
+    
+    # Update the NPC's model/provider for this session if overridden
+    if args.model:
+        npc_instance.model = effective_model
+    if args.provider:
+        npc_instance.provider = effective_provider
+
+    try:
+        if is_valid_command:
+            # Handle slash command using npcsh's execute_slash_command
+            full_command_str = command_name
+            if command_args:
+                full_command_str += " " + " ".join(command_args)
+            
+            print(f"Executing command: {full_command_str}")
+            
+            updated_state, result = execute_slash_command(
+                full_command_str, 
+                stdin_input=None, 
+                state=shell_state, 
+                stream=NPCSH_STREAM_OUTPUT
+            )
 
+            # Process and display the result
             if isinstance(result, dict):
                 output = result.get("output") or result.get("response")
+                model_for_stream = result.get('model', effective_model)
+                provider_for_stream = result.get('provider', effective_provider)
                 
                 if NPCSH_STREAM_OUTPUT and not isinstance(output, str):
-                     print_and_process_stream_with_markdown(output, effective_model, effective_provider)
+                     print_and_process_stream_with_markdown(output, model_for_stream, provider_for_stream)
                 elif output is not None:
                      render_markdown(str(output))
             elif result is not None:
@@ -172,45 +205,38 @@ def main():
             else:
                 print(f"Command '{command_name}' executed.")
 
-        except Exception as e:
-            print(f"Error executing command '{command_name}': {e}", file=sys.stderr)
-            traceback.print_exc()
-            sys.exit(1)
-    else:
-        # Process as a prompt
-        prompt = " ".join(unknown_args)
+        else:
+            # Process as a regular prompt using npcsh's execution logic
+            prompt = " ".join(unknown_args)
 
-        if not prompt:
-            # If no prompt and no command, show help
-            parser.print_help()
-            sys.exit(1)
+            if not prompt:
+                # If no prompt and no command, show help
+                parser.print_help()
+                sys.exit(1)
 
-        print(f"Processing prompt: '{prompt}' with NPC: '{args.npc}'...")
-        try:
-            response_data = check_llm_command(
-                command=prompt,
-                model=effective_model,
-                provider=effective_provider,
-                npc=npc_instance,
-                stream=NPCSH_STREAM_OUTPUT,
-                messages=[],
-                team=None,
-                api_url=NPCSH_API_URL,
-            )
+            print(f"Processing prompt: '{prompt}' with NPC: '{args.npc}'...")
+            
+            # Use npcsh's execute_command but force it to chat mode for simple prompts
+            shell_state.current_mode = 'chat'
+            updated_state, result = execute_command(prompt, shell_state)
 
-            if isinstance(response_data, dict):
-                output = response_data.get("output")
+            # Process and display the result
+            if isinstance(result, dict):
+                output = result.get("output")
+                model_for_stream = result.get('model', effective_model)
+                provider_for_stream = result.get('provider', effective_provider)
+                
                 if NPCSH_STREAM_OUTPUT and hasattr(output, '__iter__') and not isinstance(output, (str, bytes, dict, list)):
-                    print_and_process_stream_with_markdown(output, effective_model, effective_provider)
+                    print_and_process_stream_with_markdown(output, model_for_stream, provider_for_stream)
                 elif output is not None:
                     render_markdown(str(output))
-            elif response_data is not None:
-                 render_markdown(str(response_data))
+            elif result is not None:
+                 render_markdown(str(result))
 
-        except Exception as e:
-            print(f"Error processing prompt: {e}", file=sys.stderr)
-            traceback.print_exc()
-            sys.exit(1)
+    except Exception as e:
+        print(f"Error executing command: {e}", file=sys.stderr)
+        traceback.print_exc()
+        sys.exit(1)
 
 if __name__ == "__main__":
     main()

npcsh/npcsh.py

@@ -664,11 +664,12 @@ def should_skip_kg_processing(user_input: str, assistant_output: str) -> bool:
     return False
 
 
-
 def execute_slash_command(command: str, stdin_input: Optional[str], state: ShellState, stream: bool) -> Tuple[ShellState, Any]:
     """Executes slash commands using the router or checking NPC/Team jinxs."""
     all_command_parts = shlex.split(command)
     command_name = all_command_parts[0].lstrip('/')
+    
+    # Handle NPC switching commands
     if command_name in ['n', 'npc']:
         npc_to_switch_to = all_command_parts[1] if len(all_command_parts) > 1 else None
         if npc_to_switch_to and state.team and npc_to_switch_to in state.team.npcs:
@@ -677,10 +678,11 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
         else:
             available_npcs = list(state.team.npcs.keys()) if state.team else []
             return state, colored(f"NPC '{npc_to_switch_to}' not found. Available NPCs: {', '.join(available_npcs)}", "red")
+    
+    # Check router commands first
     handler = router.get_route(command_name)
     if handler:
         parsed_flags, positional_args = parse_generic_command_flags(all_command_parts[1:])
-
         normalized_flags = normalize_and_expand_flags(parsed_flags)
 
         handler_kwargs = {
@@ -705,38 +707,37 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
             'igmodel': state.image_gen_model,
             'igprovider': state.image_gen_provider,
             'vgmodel': state.video_gen_model, 
-            'vgprovider':state.video_gen_provider,
+            'vgprovider': state.video_gen_provider,
             'vmodel': state.vision_model,
             'vprovider': state.vision_provider,
             'rmodel': state.reasoning_model,
             'rprovider': state.reasoning_provider,
         }
         
-        if len(normalized_flags)>0:
+        if len(normalized_flags) > 0:
             kwarg_part = 'with kwargs: \n    -' + '\n    -'.join(f'{key}={item}' for key, item in normalized_flags.items())
         else:
             kwarg_part = ''
 
-        # 4. Merge the clean, normalized flags. This will correctly overwrite defaults.
         render_markdown(f'- Calling {command_name} handler {kwarg_part} ')
+        
+        # Handle model/provider inference
         if 'model' in normalized_flags and 'provider' not in normalized_flags:
-            # Call your existing, centralized lookup_provider function
             inferred_provider = lookup_provider(normalized_flags['model'])
             if inferred_provider:
-                # Update the provider that will be used for this command.
                 handler_kwargs['provider'] = inferred_provider
                 print(colored(f"Info: Inferred provider '{inferred_provider}' for model '{normalized_flags['model']}'.", "cyan"))
+        
         if 'provider' in normalized_flags and 'model' not in normalized_flags:
-            # loop up mhandler_kwargs model's provider
             current_provider = lookup_provider(handler_kwargs['model'])
             if current_provider != normalized_flags['provider']:
-                print(f'Please specify a model for the provider: {normalized_flags['provider']}')
-        handler_kwargs.update(normalized_flags)
+                prov = normalized_flags['provider']
+                print(f'Please specify a model for the provider: {prov}')
         
+        handler_kwargs.update(normalized_flags)
         
         try:
             result_dict = handler(command=command, **handler_kwargs)
-            # add the output model and provider for the print_and_process_stream downstream processing
             if isinstance(result_dict, dict):
                 state.messages = result_dict.get("messages", state.messages)
                 return state, result_dict
@@ -747,39 +748,64 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
             print(f"Error executing slash command '{command_name}':", file=sys.stderr)
             traceback.print_exc()
             return state, colored(f"Error executing slash command '{command_name}': {e}", "red")
+
+    # Check for jinxs in active NPC
     active_npc = state.npc if isinstance(state.npc, NPC) else None
     jinx_to_execute = None
     executor = None
-    if active_npc and command_name in active_npc.jinxs_dict:
+    
+    if active_npc and hasattr(active_npc, 'jinxs_dict') and command_name in active_npc.jinxs_dict:
         jinx_to_execute = active_npc.jinxs_dict[command_name]
         executor = active_npc
-    elif state.team and command_name in state.team.jinxs_dict:
+    elif state.team and hasattr(state.team, 'jinxs_dict') and command_name in state.team.jinxs_dict:
         jinx_to_execute = state.team.jinxs_dict[command_name]
         executor = state.team
-
     if jinx_to_execute:
-        args = command_parts[1:]
+        args = all_command_parts[1:]  # Fix: use all_command_parts instead of command_parts
         try:
-            jinx_output = jinx_to_execute.run(
-                *args,
-                state=state,
-                stdin_input=stdin_input,
-                messages=state.messages # Pass messages explicitly if needed
-            )
-            return state, jinx_output
+            # Create input dictionary from args based on jinx inputs
+            input_values = {}
+            if hasattr(jinx_to_execute, 'inputs') and jinx_to_execute.inputs:
+                for i, input_name in enumerate(jinx_to_execute.inputs):
+                    if i < len(args):
+                        input_values[input_name] = args[i]
+            
+            # Execute the jinx with proper parameters
+            if isinstance(executor, NPC):
+                jinx_output = jinx_to_execute.execute(
+                    input_values=input_values,
+                    jinxs_dict=executor.jinxs_dict if hasattr(executor, 'jinxs_dict') else {},
+                    npc=executor,
+                    messages=state.messages
+                )
+            else:  # Team executor
+                jinx_output = jinx_to_execute.execute(
+                    input_values=input_values,
+                    jinxs_dict=executor.jinxs_dict if hasattr(executor, 'jinxs_dict') else {},
+                    npc=active_npc or state.npc,
+                    messages=state.messages
+                )
+            if isinstance(jinx_output, dict) and 'messages' in jinx_output:
+                state.messages = jinx_output['messages']
+                return state, str(jinx_output.get('output', jinx_output))
+            elif isinstance(jinx_output, dict):
+                return state, str(jinx_output.get('output', jinx_output))
+            else:
+                return state, jinx_output
+            
         except Exception as e:
             import traceback
             print(f"Error executing jinx '{command_name}':", file=sys.stderr)
             traceback.print_exc()
             return state, colored(f"Error executing jinx '{command_name}': {e}", "red")
 
+    # Check if it's an NPC name for switching
     if state.team and command_name in state.team.npcs:
         new_npc = state.team.npcs[command_name]
-        state.npc = new_npc # Update state directly
+        state.npc = new_npc
         return state, f"Switched to NPC: {new_npc.name}"
 
-    return state, colored(f"Unknown slash command or jinx: {command_name}", "red")
-
+    return state, colored(f"Unknown slash command, jinx, or NPC: {command_name}", "red")
 
 def process_pipeline_command(
     cmd_segment: str,
@@ -893,7 +919,8 @@ def execute_command(
     active_provider = npc_provider or state.chat_provider
 
     if state.current_mode == 'agent':
-        print(len(commands), commands)
+        print('# of parsed commands: ', len(commands))
+        print('Commands:' '\n'.join(commands))
         for i, cmd_segment in enumerate(commands):
 
             render_markdown(f'- executing command {i+1}/{len(commands)}')
@@ -970,7 +997,7 @@ def execute_command(
                 else:
                     try:
                         bash_state, bash_output = handle_bash_command(cmd_parts, command, None, state)
-                        return bash_state, bash_output
+                        return state, bash_output
                     except Exception as bash_err:
                         return state, colored(f"Bash execution failed: {bash_err}", "red")
             except Exception:
@@ -1170,7 +1197,8 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     
     if os.path.exists(forenpc_path):
         forenpc_obj = NPC(file = forenpc_path, 
-                          jinxs=jinxs_list)
+                          jinxs=jinxs_list, 
+                          db_conn=command_history.engine)
         if forenpc_obj.model is None:
             forenpc_obj.model= team_ctx.get("model", initial_state.chat_model)
         if forenpc_obj.provider is None:
@@ -1213,9 +1241,7 @@ def process_result(
     output: Any,
     command_history: CommandHistory
 ):
-    # --- Part 1: Save Conversation & Determine Output ---
     
-    # Define team and NPC names early for consistent logging
     team_name = result_state.team.name if result_state.team else "__none__"
     npc_name = result_state.npc.name if isinstance(result_state.npc, NPC) else "__none__"
     
@@ -1223,9 +1249,8 @@ def process_result(
     active_npc = result_state.npc if isinstance(result_state.npc, NPC) else NPC(
         name="default", 
         model=result_state.chat_model, 
-        provider=result_state.chat_provider
-    )
-
+        provider=result_state.chat_provider, 
+        db_conn=command_history.engine)
     save_conversation_message(
         command_history,
         result_state.conversation_id,
@@ -1377,14 +1402,13 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
         print(colored("Processing and archiving all session knowledge...", "cyan"))
         
         engine = command_history.engine
-        integrator_npc = NPC(name="integrator", model=current_state.chat_model, provider=current_state.chat_provider)
 
-        # Process each unique scope that was active during the session
+
         for team_name, npc_name, path in session_scopes:
             try:
                 print(f"  -> Archiving knowledge for: T='{team_name}', N='{npc_name}', P='{path}'")
                 
-                # Get all messages for the current conversation that happened in this specific path
+
                 convo_id = current_state.conversation_id
                 all_messages = command_history.get_conversations_by_id(convo_id)
                 
@@ -1399,15 +1423,16 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                     print("     ...No content for this scope, skipping.")
                     continue
 
-                # Load the existing KG for this specific, real scope
+
                 current_kg = load_kg_from_db(engine, team_name, npc_name, path)
                 
-                # Evolve it with the full text from the session for this scope
+
                 evolved_kg, _ = kg_evolve_incremental(
                     existing_kg=current_kg,
                     new_content_text=full_text,
-                    model=integrator_npc.model,
-                    provider=integrator_npc.provider, 
+                    model=current_state.npc.model,
+                    provider=current_state.npc.provider, 
+                    npc= current_state.npc,
                     get_concepts=True,
                     link_concepts_facts = True, 
                     link_concepts_concepts = True, 
@@ -1416,7 +1441,11 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                 )
                 
                 # Save the updated KG back to the database under the same exact scope
-                save_kg_to_db(engine, evolved_kg, team_name, npc_name, path)
+                save_kg_to_db(engine,
+                              evolved_kg,
+                              team_name, 
+                              npc_name, 
+                              path)
 
             except Exception as e:
                 import traceback
@@ -1474,7 +1503,8 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
             session_scopes.add((team_name, npc_name, state.current_path))
 
             state, output = execute_command(user_input, state)
-            process_result(user_input, state, 
+            process_result(user_input, 
+                           state, 
                            output, 
                            command_history)
         

npcsh/routes.py

@@ -18,7 +18,6 @@ from npcpy.llm_funcs import (
     gen_video,
     breathe,
 )
-from npcpy.npc_compiler import NPC, Team, Jinx
 from npcpy.npc_compiler import initialize_npc_project
 from npcpy.npc_sysenv import render_markdown
 from npcpy.work.plan import execute_plan_command
@@ -29,8 +28,7 @@ from npcpy.memory.command_history import CommandHistory, load_kg_from_db, save_k
 from npcpy.serve import start_flask_server
 from npcpy.mix.debate import run_debate
 from npcpy.data.image import capture_screenshot
-from npcpy.npc_compiler import NPC, Team, Jinx
-from npcpy.npc_compiler import initialize_npc_project
+from npcpy.npc_compiler import NPC, Team, Jinx,initialize_npc_project
 from npcpy.data.web import search_web
 from npcpy.memory.knowledge_graph import kg_sleep_process, kg_dream_process
 
@@ -446,13 +444,13 @@ def plan_handler(command: str, **kwargs):
     user_command = " ".join(command.split()[1:])
     if not user_command:
         return {"output": "Usage: /plan <description_of_plan>", "messages": messages}
-    try:
-        return execute_plan_command(command=user_command, **kwargs)
-    except NameError:
-         return {"output": "Plan function (execute_plan_command) not available.", "messages": messages}
-    except Exception as e:
-        traceback.print_exc()
-        return {"output": f"Error executing plan: {e}", "messages": messages}
+    #try:
+    return execute_plan_command(command=user_command, **kwargs)
+
+    #return {"output": "Plan function (execute_plan_command) not available.", "messages": messages}
+    #except Exception as e:
+    #    traceback.print_exc()
+    #    return {"output": f"Error executing plan: {e}", "messages": messages}
 
 @router.route("pti", "Use pardon-the-interruption mode to interact with the LLM")
 def pti_handler(command: str, **kwargs):
@@ -500,17 +498,18 @@ def brainblast_handler(command: str, **kwargs):
     parts = shlex.split(command)
     search_query = " ".join(parts[1:]) if len(parts) > 1 else ""
     
-    
     if not search_query:
         return {"output": "Usage: /brainblast <search_terms>", "messages": messages}
     
     # Get the command history instance
     command_history = kwargs.get('command_history')
     if not command_history:
+        #print('no command history provided to brainblast')
         # Create a new one if not provided
         db_path = safe_get(kwargs, "history_db_path", os.path.expanduser('~/npcsh_history.db'))
         try:
             command_history = CommandHistory(db_path)
+            kwargs['command_history'] = command_history
         except Exception as e:
             return {"output": f"Error connecting to command history: {e}", "messages": messages}
     
@@ -521,13 +520,8 @@ def brainblast_handler(command: str, **kwargs):
             
         # Execute the brainblast command
         return execute_brainblast_command(
-            command=search_query,
-            command_history=command_history,
-            messages=messages,
-            top_k=safe_get(kwargs, 'top_k', 5),
-            **kwargs
-        )
-    
+                                    command=search_query,
+                                    **kwargs)   
     except Exception as e:
         traceback.print_exc()
         return {"output": f"Error executing brainblast command: {e}", "messages": messages}

{npcsh-1.0.14.dist-info → npcsh-1.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.14
+Version: 1.0.16
 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
@@ -16,6 +16,7 @@ Requires-Dist: litellm
 Requires-Dist: docx
 Requires-Dist: scipy
 Requires-Dist: numpy
+Requires-Dist: thefuzz
 Requires-Dist: imagehash
 Requires-Dist: requests
 Requires-Dist: matplotlib
@@ -40,6 +41,7 @@ Requires-Dist: flask_cors
 Requires-Dist: redis
 Requires-Dist: psycopg2-binary
 Requires-Dist: flask_sse
+Requires-Dist: wikipedia
 Provides-Extra: lite
 Requires-Dist: anthropic; extra == "lite"
 Requires-Dist: openai; extra == "lite"
@@ -150,11 +152,11 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
     ```
     <p align="center">
         <img src="https://raw.githubusercontent.com/npc-worldwide/npcsh/main/test_data/search_example.png" alt="example of search results", width=600>
-    </p>
+     </p>
 
   - **Computer Use**
     ```bash
-    /plonk -n 'npc_name' -sp 'task for plonk to carry out'
+    /plonk 'find out the latest news on cnn'
     ```
 
   - **Generate Image**
@@ -168,9 +170,10 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
     ```bash
     /roll 'generate a video of a hat riding a dog'
     ```
+    <!--
       <p align="center">
         <img src="https://raw.githubusercontent.com/npc-worldwide/npcsh/main/test_data/hat_video.mp4" alt="video of a hat riding a dog", width=250>
-      </p>
+      </p> -->
 
   - **Serve an NPC Team**
     ```bash
@@ -196,7 +199,8 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
     - `/init` - Initialize NPC project
     - `/jinxs` - Show available jinxs for the current NPC/Team
     - `/ots` - Take screenshot and analyze with vision model
-    - `/plan` - Execute a plan command\n\n/plonk - Use vision model to interact with GUI. Usage: /plonk <task description>
+    - `/plan` - Execute a plan command
+    - `/plonk` - Use vision model to interact with GUI. Usage: /plonk <task description>
     - `/pti` - Use pardon-the-interruption mode to interact with reasoning model LLM
     - `/rag` - Execute a RAG command using ChromaDB embeddings with optional file input (-f/--file)
     - `/roll` - generate a video with video generation model
@@ -211,13 +215,13 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
     - `/wander` - A method for LLMs to think on a problem by switching between states of high temperature and low temperature
     - `/yap` - Enter voice chat (yap) mode
     
-    ## Common Command-Line Flags\n\nThe shortest unambiguous prefix works (e.g., `-t` for `--temperature`).
+    ## Common Command-Line Flags:
     
     ```
     Flag              Shorthand    | Flag              Shorthand    | Flag              Shorthand    | Flag              Shorthand   
     ------------------------------ | ------------------------------ | ------------------------------ | ------------------------------
     --attachments     (-a)         | --height          (-h)         | --num_npcs        (-num_n)     | --team            (-tea)      
-    --config_dir      (-con)       | --igmodel         (-igm)       | --output_file     (-o)         | --temperature     (-tem)      
+    --config_dir      (-con)       | --igmodel         (-igm)       | --output_file     (-o)         | --temperature     (-t)      
     --cors            (-cor)       | --igprovider      (-igp)       | --plots_dir       (-pl)        | --top_k                       
     --creativity      (-cr)        | --lang            (-l)         | --port            (-po)        | --top_p                       
     --depth           (-d)         | --max_tokens      (-ma)        | --provider        (-pr)        | --vmodel          (-vm)       
@@ -228,7 +232,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
     ```
     '
 
-    - ## alicanto: a research exploration agent flow. 
+    - ## `/alicanto`: a research exploration agent flow. 
 
       <p align="center"><a href ="https://github.com/npc-worldwide/npcsh/blob/main/docs/alicanto.md"> 
         <img src="https://raw.githubusercontent.com/npc-worldwide/npcsh/main/npcsh/npc_team/alicanto.png" alt="logo for deep research", width=250></a>
@@ -245,41 +249,44 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
       # bash
       npc alicanto "What ethical considerations should guide AI development?" --max_facts_per_chain 0.5 --max_thematic_groups 3 --max_criticisms_per_group 3 max_conceptual_combinations 3 max_experiments 10 
 
-      npc alicanto "What is the future of remote work?" --format report
+      npc alicanto "What is the future of remote work?" --format report # NOTE: Report generation and formatting requires latex installed.
       ```
-    - ## Brainblast: searching through past messages:
+    - ## `/brainblast`: searching through past messages (soon to incorporate options for knowledge graph)
         ```bash
         # npcsh
         /brainblast 'subtle summer winds'  --top_k 10
         ```
         ```bash
         # bash
-        npc brainblast 'python dictionaries'                                        
+        npc brainblast 'executing a mirror in the wonderous moon'                                        
         ```
-    - ## Breathe: Condense conversation context (shell only):
+    - ## `/breathe`: Condense conversation context (shell only):
         ```bash
         # npcsh
         /breathe
         /breathe -p ollama -m qwen3:latest 
         ```
-    - ## Compile: render npcs for use without re-loading npcsh
+    - ## `/compile`: render npcs for use without re-loading npcsh
       ```bash
       # npcsh
-      /compile /path/to/npc
+      /compile ./npc_team/sibiji.npc      
       ```
-    - ## flush: flush context  (shell only):
+    - ## `/flush`: flush context  (shell only):
+      If you're in the NPC shell and have been in a conversation thats going nowhere and you want to start over... just flush theh contexf.
       ```bash
       /flush
       ```
 
 
-    - ## `guac`
+    - ## `/guac`
 
     <p align="center"><a href ="https://github.com/npc-worldwide/npcsh/blob/main/docs/guac.md"> 
       <img src="https://raw.githubusercontent.com/npc-worldwide/npcsh/main/npcsh/npc_team/guac.png" alt="npcsh logo of a solarpunk sign", width=250></a>
     </p> 
 
-    - a replacement shell for interpreters like python/r/node/julia with an avocado input marker 🥑 that brings a pomodoro-like approach to interactive coding. 
+    - a replacement shell for interpreters like python/r/node/julia with an avocado input marker 🥑 that brings a pomodoro-like approach to interactive coding.
+    - available as a standalone program runnable via the `guac` command after `npcsh` has been installed via pip.
+   
         - Simulation:      
             `🥑 Make a markov chain simulation of a random walk in 2D space with 1000 steps and visualize`
             ```
@@ -342,13 +349,61 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         A guac session progresses through a series of stages, each of equal length. Each stage adjusts the emoji input prompt. Once the stages have passed, it is time to refresh. Stage 1: `🥑`, Stage 2: `🥑🔪` Stage 3: `🥑🥣` Stage:4 `🥑🥣🧂`, `Stage 5: 🥘 TIME TO REFRESH`. At stage 5, the user is reminded to refresh with the /refresh macro. This will evaluate the session so farand suggest and implement new functions or automations that will aid in future sessions, with the ultimate approval of the user.
 
 
-    - ## help:/ Show help for commands, NPCs, or Jinxs. 
-       ```bash
-       /help 
-       ```
-    - ## init - Initialize NPC project        
-    - ## jinxs : show available jinxs                                                                                                                     
-    - ## ots: Over-the-shoulder screen shot analysis
+    - ## `/help`: Show help for commands, NPCs, or Jinxs. 
+         ```bash
+         /help 
+         ```
+         ```
+         npc help
+         ```
+    - ## `/init` - Initialize NPC project    
+        -set up bare bones infra for an npc team
+        ```bash
+        # npcsh 
+        /init
+        ```
+        ```bash
+        # bash 
+        npc init
+        ```
+    
+
+    - ## `/jinxs` : show available jinxs for team
+        Jinxs are Jinja execution templates that let users develop small programs that can build on each other and reference each other through jinja templating. Jinx methods allow us to give smaller LLMs the scaffolding to perform `tool calling`, so to speak, reliably
+        ```bash
+        # npcsh 
+        /jinxs
+        # bash 
+        npc jinxs
+        ```
+
+        ```python
+        Available Jinxs:     
+        --- Jinxs for NPC: sibiji ---                                                                                                                                                                                                           
+
+        • /bash_executor: Execute bash queries.                                                                                                                                                                                                
+
+        • /calc: A jinx to simplify and evaluate mathematical expressions   (/calc 1+5, /calc 47233*234234)                                                                                                                
+
+        • /data_pull: Execute queries on the ~/npcsh_history.db to pull data. The database contains only information about conversations and other user-provided data. It does not store any information about individual files (/data_pull 'select * from conversation_history limit 10')
+
+
+        • /file_editor: Examines a file, determines what changes are needed, and applies those changes. (/file_editor filename.py 'instructions for carrying out the editing')                                                                                                                                   
+
+        • /image_generation_jinx: Generates images based on a text prompt. (/image_generation_jinx 'prompt for llm' output_name )                                                                                                                                       
+
+        • /internet_search: Searches the web for information based on a query in order to verify timiely details (e.g. current events) or to corroborate information in uncertain situations. Should be mainly only used when users            
+          specifically request a search, otherwise an LLMs basic knowledge should be sufficient. ( /internet_search 'cost of cubs tickets' )
+        • /local_search: Searches files in current and downstream directories to find items related to the users query using fuzzy matching. (/local_search 'class NPC')
+        Returns only relevant snippets (10 lines around matches) to avoid including too much irrelevant content. Intended for fuzzy searches, not for understanding file sizes.                                                                                                                                                                          
+
+        • /python_executor: Execute scripts with python. Set the ultimate result as the "output" variable. It must be a string. Do not add unnecessary print statements. (/python_executor 'import numpy as np; print(np.arange(1000))')
+        • /screen_capture_analysis_jinx: Captures the whole screen and sends the image for analysis  (mostly redundant with /ots.)  
+        ```
+
+
+
+    - ## `/ots`: Over-the-shoulder screen shot analysis
         - Screenshot analysis:     
         ```bash
         #npcsh
@@ -359,17 +414,17 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         #bash
         npc ots ...
         ```
-    - ## `plan`: set up cron jobs:
+    - ## `/plan`: set up cron jobs:
         ```bash
         # npcsh
-        /plan 'a description of a cron job to implement' -m gemma3:27b -p ollama 
+        /plan 'set up a cron job that reminds me to stretch every thirty minutes' -m gemma3:27b -p ollama 
         ```
         ```bash
         # bash
-        npc plan
+        npc plan 'record my cpu usage percentage every 45 minutes' 
         ```
 
-    - ## `plonk`: Computer use:     
+    - ## `/plonk`: Computer use:     
         ```bash
         # npcsh
         /plonk -n 'npc_name' -sp 'task for plonk to carry out '
@@ -377,7 +432,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         #bash
         npc plonk
         ```
-    - ## `pti`: a reasoning REPL loop with interruptions
+    - ## `/pti`: a reasoning REPL loop with interruptions
       
         ```npcsh
         /pti  -n frederic -m qwen3:latest -p ollama 
@@ -391,14 +446,14 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         <img src="https://raw.githubusercontent.com/npc-worldwide/npcsh/main/npcsh/npc_team/frederic4.png" alt="npcsh logo of frederic the bear and the pti logo", width=250></a>
       </p>
 
-    - ## `rag`: embedding search through chroma db, optional file input
-    - ## `roll`: your video generation assistant
+    - ## `/rag`: embedding search through chroma db, optional file input
+    - ## `/roll`: your video generation assistant
       - 
         ```npcsh
         /roll --provider ollama --model llama3
         ```
 
-    - ## sample: one-shot sampling from LLMs with specific parameters
+    - ## `/sample`: one-shot sampling from LLMs with specific parameters
         ```bash
         # npcsh
         /sample 'prompt'
@@ -417,7 +472,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         npc sample model=gpt-4o-mini "What are the primary colors?" --provider openai
         ```
 
-    - ## search: use an internet search provider     
+    - ## `/search`: use an internet search provider     
         ```npcsh
         /search -sp perplexity 'cal bears football schedule'
         /search --sprovider duckduckgo 'beef tongue'        
@@ -429,7 +484,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         ```
     
 
-    - ## serve: serve an npc team     
+    - ## `/serve`: serve an npc team     
         ```bash
         /serve 
         /serve ....    
@@ -440,7 +495,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         npc serve
         ```
 
-    - ## set: change current model, env params
+    - ## `/set`: change current model, env params
         ```bash
         /set model ... 
         /set provider ...
@@ -450,7 +505,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         ```bash
         npc set ...
         ```
-    - ## sleep: prune and evolve the current knowledge graph 
+    - ## `/sleep`: prune and evolve the current knowledge graph 
         ```bash
         /sleep
         /sleep --dream
@@ -460,7 +515,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         ```bash
         npc sleep
         ```
-    - ## `spool`
+    - ## `/spool`
     <p align="center"><a href ="https://github.com/npc-worldwide/npcsh/blob/main/docs/spool.md"> 
       <img src="https://raw.githubusercontent.com/npc-worldwide/npcsh/main/npcsh/npc_team/spool.png" alt="logo for spool", width=250></a>
     </p>
@@ -489,7 +544,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
 
     
 
-    - ## Vixynt: Image generation and editing:   
+    - ## `/vixynt`: Image generation and editing:   
         ```bash
         npcsh
         /vixynt 'an image of a dog eating a hat'
@@ -508,7 +563,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
 
 
 
-    - ## `wander`: daydreaming for LLMs
+    - ## `/wander`: daydreaming for LLMs
 
       <p align="center"><a href ="https://github.com/npc-worldwide/npcsh/blob/main/docs/wander.md">
         <img src="https://raw.githubusercontent.com/npc-worldwide/npcsh/main/npcsh/npc_team/kadiefa.png" alt="logo for wander", width=250></a>
@@ -544,7 +599,7 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         interruption-likelihood=.1
         ```
 
-    - ## `yap`: an agentic voice control loop
+    - ## `/yap`: an agentic voice control loop
 
 
     <p align="center"><a href ="https://github.com/npc-worldwide/npcsh/blob/main/docs/yap.md"> 
@@ -562,20 +617,9 @@ Once installed, the following CLI tools will be available: `npcsh`, `guac`, `npc
         yap
         npc yap
         ```
-    - Show available Jinja Execution Templates:
-        ```bash
-        # npcsh
-        /jinxs
-        ```
-        ```bash
-        # bash
-        npc jinxs 
-        ```
-
-
 
 ## Inference Capabilities
-- `npcsh` works with local and enterprise LLM providers through its LiteLLM integration, allowing users to run inference from Ollama, LMStudio, OpenAI, Anthropic, Gemini, and Deepseek, making it a versatile tool for both simple commands and sophisticated AI-driven tasks. 
+- `npcsh` works with local and enterprise LLM providers through its LiteLLM integration, allowing users to run inference from Ollama, LMStudio, vLLM, MLX, OpenAI, Anthropic, Gemini, and Deepseek, making it a versatile tool for both simple commands and sophisticated AI-driven tasks. 
 
 ## Read the Docs
 
@@ -751,6 +795,10 @@ export PERPLEXITY_API_KEY='your_perplexity_key'
 ├── npc_team/           # Global NPCs
 │   ├── jinxs/          # Global tools
 │   └── assembly_lines/ # Workflow pipelines
+│   └── example.npc  # globally available npc 
+│   └── global.ctx  # global context file
+
+
 
 ```
 For cases where you wish to set up a project specific set of NPCs, jinxs, and assembly lines, add a `npc_team` directory to your project and `npcsh` should be able to pick up on its presence, like so:

{npcsh-1.0.14.dist-info → npcsh-1.0.16.dist-info}/RECORD

@@ -5,17 +5,17 @@ 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=uxs_5k-zmuDjdvKMxoBZwdefdgKGESd-EIGCXYNgx0Y,59571
+npcsh/npc.py,sha256=4RI1pI85dU65ARIOwPX6bYfTDVjg-0EFmIb-QlAxYqg,9068
+npcsh/npcsh.py,sha256=bpysELlhR1R_0hIXwo25odBCvfQgjK6I9qcaH2CAV5k,60575
 npcsh/plonk.py,sha256=7w7J2bht5QXOyV2UK045nAPDmrSrTGLX-sh56KQ3-k0,14653
 npcsh/pti.py,sha256=jGHGE5SeIcDkV8WlOEHCKQCnYAL4IPS-kUBHrUz0oDA,10019
-npcsh/routes.py,sha256=gsKHhdbzcZnE91w86ydr3ABNTxL12Ta0Oa9z3qwEh54,44470
+npcsh/routes.py,sha256=033Lh0vEO3jQ3kSVT64XfFYqN7FL4K99VkY4YdgiZA8,44391
 npcsh/spool.py,sha256=QF1SuIhj_PWiOYNkAK31f1W_wS8yYxC5XvM2GU7VJMM,9495
 npcsh/wander.py,sha256=BiN6eYyFnEsFzo8MFLRkdZ8xS9sTKkQpjiCcy9chMcc,23225
 npcsh/yap.py,sha256=ipkY3uMDw8gNrPSZ9qJFWVQ_fXtLmQ2oz_6_WZt2hew,21097
-npcsh-1.0.14.dist-info/licenses/LICENSE,sha256=IKBvAECHP-aCiJtE4cHGCE5Yl0tozYz02PomGeWS3y4,1070
-npcsh-1.0.14.dist-info/METADATA,sha256=W0GyU5aR_MP9qUrp7BHWV54p0cgNNrY6E7wzChyvU_4,31027
-npcsh-1.0.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcsh-1.0.14.dist-info/entry_points.txt,sha256=qxOYTm3ym3JWyWf2nv2Mk71uMcJIdUoNEJ8VYMkyHiY,214
-npcsh-1.0.14.dist-info/top_level.txt,sha256=kHSNgKMCkfjV95-DH0YSp1LLBi0HXdF3w57j7MQON3E,6
-npcsh-1.0.14.dist-info/RECORD,,
+npcsh-1.0.16.dist-info/licenses/LICENSE,sha256=IKBvAECHP-aCiJtE4cHGCE5Yl0tozYz02PomGeWS3y4,1070
+npcsh-1.0.16.dist-info/METADATA,sha256=UQikBr7efMSpf-2swWyvPBeUJ_mgTr6kmGTUvr47GWQ,34873
+npcsh-1.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcsh-1.0.16.dist-info/entry_points.txt,sha256=qxOYTm3ym3JWyWf2nv2Mk71uMcJIdUoNEJ8VYMkyHiY,214
+npcsh-1.0.16.dist-info/top_level.txt,sha256=kHSNgKMCkfjV95-DH0YSp1LLBi0HXdF3w57j7MQON3E,6
+npcsh-1.0.16.dist-info/RECORD,,