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

npcsh/npcsh.py

@@ -35,6 +35,7 @@ from npcsh._state import (
     ShellState,
     interactive_commands,
     BASH_COMMANDS,
+
     start_interactive_session,
     validate_bash_command, 
     normalize_and_expand_flags, 
@@ -663,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:
@@ -676,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 = {
@@ -704,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
@@ -746,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,
@@ -892,9 +919,14 @@ def execute_command(
     active_provider = npc_provider or state.chat_provider
 
     if state.current_mode == 'agent':
+        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)}')
             is_last_command = (i == len(commands) - 1)
-            stream_this_segment = is_last_command and state.stream_output # Use state's stream setting
+
+            stream_this_segment = state.stream_output and not is_last_command 
 
             try:
                 current_state, output = process_pipeline_command(
@@ -905,17 +937,18 @@ def execute_command(
                 )
 
                 if is_last_command:
-                    final_output = output # Capture the output of the last command
+                    return current_state, output
                 if isinstance(output, str):
                     stdin_for_next = output
                 elif not isinstance(output, str):
                     try:
-                        full_stream_output = print_and_process_stream_with_markdown(output, 
-                                                                                    state.npc.model, 
-                                                                                    state.npc.provider)
-                        stdin_for_next = full_stream_output
-                        if is_last_command: 
-                            final_output = full_stream_output
+                        if stream_this_segment:
+                            full_stream_output = print_and_process_stream_with_markdown(output, 
+                                                                                        state.npc.model, 
+                                                                                        state.npc.provider)
+                            stdin_for_next = full_stream_output
+                            if is_last_command: 
+                                final_output = full_stream_output
                     except:
                         if output is not None: # Try converting other types to string
                             try: 
@@ -964,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:
@@ -1064,6 +1097,13 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     command_history = CommandHistory(db_path)
 
 
+    if not is_npcsh_initialized():
+        print("Initializing NPCSH...")
+        initialize_base_npcs_if_needed(db_path)
+        print("NPCSH initialization complete. Restart or source ~/.npcshrc.")
+
+
+
     try:
         history_file = setup_readline()
         atexit.register(save_readline_history)
@@ -1157,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:
@@ -1200,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__"
     
@@ -1210,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,
@@ -1260,39 +1298,42 @@ def process_result(
         )
 
         conversation_turn_text = f"User: {user_input}\nAssistant: {final_output_str}"
-        conn = command_history.conn
+        engine = command_history.engine
 
-        try:
-            if not should_skip_kg_processing(user_input, final_output_str):
-
-                npc_kg = load_kg_from_db(conn, team_name, npc_name, result_state.current_path)
-                evolved_npc_kg, _ = kg_evolve_incremental(
-                    existing_kg=npc_kg, 
-                    new_content_text=conversation_turn_text,
-                    model=active_npc.model, 
-                    provider=active_npc.provider, 
-                    get_concepts=True,
-                    link_concepts_facts = False, 
-                    link_concepts_concepts = False, 
-                    link_facts_facts = False, 
 
-                    
-                )
-                save_kg_to_db(conn,
-                              evolved_npc_kg, 
-                              team_name, 
-                              npc_name, 
-                              result_state.current_path)
-        except Exception as e:
-            print(colored(f"Error during real-time KG evolution: {e}", "red"))
+        if result_state.build_kg:
+            try:
+                if not should_skip_kg_processing(user_input, final_output_str):
+
+                    npc_kg = load_kg_from_db(engine, team_name, npc_name, result_state.current_path)
+                    evolved_npc_kg, _ = kg_evolve_incremental(
+                        existing_kg=npc_kg, 
+                        new_content_text=conversation_turn_text,
+                        model=active_npc.model, 
+                        provider=active_npc.provider, 
+                        get_concepts=True,
+                        link_concepts_facts = False, 
+                        link_concepts_concepts = False, 
+                        link_facts_facts = False, 
+
+                        
+                    )
+                    save_kg_to_db(engine,
+                                evolved_npc_kg, 
+                                team_name, 
+                                npc_name, 
+                                result_state.current_path)
+            except Exception as e:
+                print(colored(f"Error during real-time KG evolution: {e}", "red"))
 
         # --- Part 3: Periodic Team Context Suggestions ---
         result_state.turn_count += 1
+
         if result_state.turn_count > 0 and result_state.turn_count % 10 == 0:
             print(colored("\nChecking for potential team improvements...", "cyan"))
             try:
                 summary = breathe(messages=result_state.messages[-20:], 
-                                  npc=active_npc)
+                                npc=active_npc)
                 characterization = summary.get('output')
 
                 if characterization and result_state.team:
@@ -1300,7 +1341,7 @@ def process_result(
                     ctx_data = {}
                     if os.path.exists(team_ctx_path):
                         with open(team_ctx_path, 'r') as f:
-                           ctx_data = yaml.safe_load(f) or {}
+                            ctx_data = yaml.safe_load(f) or {}
                     current_context = ctx_data.get('context', '')
 
                     prompt = f"""Based on this characterization: {characterization},
@@ -1317,7 +1358,7 @@ def process_result(
 
                     if suggestion:
                         new_context = (current_context + " " + suggestion).strip()
-                        print(colored("AI suggests updating team context:", "yellow"))
+                        print(colored(f"{result_state.npc.name} suggests updating team context:", "yellow"))
                         print(f"  - OLD: {current_context}\n  + NEW: {new_context}")
                         if input("Apply? [y/N]: ").strip().lower() == 'y':
                             ctx_data['context'] = new_context
@@ -1360,15 +1401,14 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
         print("\nGoodbye!")
         print(colored("Processing and archiving all session knowledge...", "cyan"))
         
-        conn = command_history.conn
-        integrator_npc = NPC(name="integrator", model=current_state.chat_model, provider=current_state.chat_provider)
+        engine = command_history.engine
+
 
-        # 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)
                 
@@ -1383,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(conn, team_name, npc_name, path)
+
+                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, 
@@ -1400,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(conn, 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
@@ -1458,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)
         
@@ -1488,6 +1534,7 @@ def main() -> None:
     initial_state.npc = default_npc 
     initial_state.team = team
 
+
     # add a -g global command to indicate if to use the global or project, otherwise go thru normal flow
     
     if args.command:

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}
@@ -757,12 +751,12 @@ def sleep_handler(command: str, **kwargs):
     try:
         db_path = os.getenv("NPCSH_DB_PATH", os.path.expanduser("~/npcsh_history.db"))
         command_history = CommandHistory(db_path)
-        conn = command_history.conn
+        engine = command_history.engine
     except Exception as e:
         return {"output": f"Error connecting to history database for KG access: {e}", "messages": messages}
 
     try:
-        current_kg = load_kg_from_db(conn, team_name, npc_name, current_path)
+        current_kg = load_kg_from_db(engine, team_name, npc_name, current_path)
 
         # FIXED: Provide a detailed and helpful message when the KG is empty
         if not current_kg or not current_kg.get('facts'):
@@ -1031,16 +1025,10 @@ def wander_handler(command: str, **kwargs):
         return {"output": f"Error during wander mode: {e}", "messages": messages}
 
 @router.route("yap", "Enter voice chat (yap) mode")
-def whisper_handler(command: str, **kwargs):
+def yap_handler(command: str, **kwargs):
     try:
         return enter_yap_mode(
-            messages=safe_get(kwargs, 'messages'),
-            npc=safe_get(kwargs, 'npc'),
-            model=safe_get(kwargs, 'model', NPCSH_CHAT_MODEL),
-            provider=safe_get(kwargs, 'provider', NPCSH_CHAT_PROVIDER),
-            team=safe_get(kwargs, 'team'),
-            stream=safe_get(kwargs, 'stream', NPCSH_STREAM_OUTPUT),
-            conversation_id=safe_get(kwargs, 'conversation_id')
+            ** kwargs
             )
     except Exception as e:
         traceback.print_exc()