npcsh 1.1.5__py3-none-any.whl → 1.1.6__py3-none-any.whl

npcsh/_state.py

@@ -88,12 +88,18 @@ from npcpy.llm_funcs import (
     breathe, 
     
 )
+
 from npcpy.memory.knowledge_graph import (
     kg_evolve_incremental, 
     
 )
 from npcpy.gen.embeddings import get_embeddings
 
+import inspect
+import sys
+from npcpy.memory.search import execute_rag_command, execute_brainblast_command
+from npcpy.data.load import load_file_contents
+from npcpy.data.web import search_web
 try:
     import readline
 except:
@@ -443,6 +449,138 @@ def get_team_ctx_path(team_path: str) -> Optional[str]:
     return str(ctx_files[0]) if ctx_files else None
 
 
+from npcpy.memory.memory_processor import  memory_approval_ui
+from npcpy.ft.memory_trainer import MemoryTrainer
+from npcpy.llm_funcs import get_facts
+
+def get_relevant_memories(
+    command_history: CommandHistory,
+    npc_name: str,
+    team_name: str,
+    path: str,
+    query: Optional[str] = None,
+    max_memories: int = 10,
+    state: Optional[ShellState] = None
+) -> List[Dict]:
+    
+    engine = command_history.engine
+    
+    all_memories = command_history.get_memories_for_scope(
+        npc=npc_name,
+        team=team_name,
+        directory_path=path,
+    )
+    
+    if not all_memories:
+        return []
+    
+    if len(all_memories) <= max_memories and not query:
+        return all_memories
+    
+    if query:
+        query_lower = query.lower()
+        keyword_matches = [
+            m for m in all_memories 
+            if query_lower in (m.get('final_memory') or m.get('initial_memory') or '').lower()
+        ]
+        
+        if keyword_matches:
+            return keyword_matches[:max_memories]
+
+    if state and state.embedding_model and state.embedding_provider:
+        try:
+            from npcpy.gen.embeddings import get_embeddings
+            
+            search_text = query if query else "recent context"
+            query_embedding = get_embeddings(
+                [search_text],
+                state.embedding_model,
+                state.embedding_provider
+            )[0]
+            
+            memory_texts = [
+                m.get('final_memory', '') for m in all_memories
+            ]
+            memory_embeddings = get_embeddings(
+                memory_texts,
+                state.embedding_model,
+                state.embedding_provider
+            )
+            
+            import numpy as np
+            similarities = []
+            for mem_emb in memory_embeddings:
+                similarity = np.dot(query_embedding, mem_emb) / (
+                    np.linalg.norm(query_embedding) * 
+                    np.linalg.norm(mem_emb)
+                )
+                similarities.append(similarity)
+            
+            sorted_indices = np.argsort(similarities)[::-1]
+            return [all_memories[i] for i in sorted_indices[:max_memories]]
+            
+        except Exception as e:
+            print(colored(
+                f"RAG search failed, using recent: {e}", 
+                "yellow"
+            ))
+    
+    return all_memories[-max_memories:]
+
+
+def search_kg_facts(
+    self,
+    npc: str,
+    team: str,
+    directory_path: str,
+    query: str
+) -> List[Dict]:
+    
+    kg = load_kg_from_db(
+        self.engine, 
+        team, 
+        npc, 
+        directory_path
+    )
+    
+    if not kg or 'facts' not in kg:
+        return []
+    
+    query_lower = query.lower()
+    matching_facts = []
+    
+    for fact in kg['facts']:
+        statement = fact.get('statement', '').lower()
+        if query_lower in statement:
+            matching_facts.append(fact)
+    
+    return matching_facts
+
+def format_memory_context(memory_examples):
+    if not memory_examples:
+        return ""
+    
+    context_parts = []
+    
+    approved_examples = memory_examples.get("approved", [])
+    rejected_examples = memory_examples.get("rejected", [])
+    
+    if approved_examples:
+        context_parts.append("EXAMPLES OF GOOD MEMORIES:")
+        for ex in approved_examples[:5]:
+            final = ex.get("final_memory") or ex.get("initial_memory")
+            context_parts.append(f"- {final}")
+    
+    if rejected_examples:
+        context_parts.append("\nEXAMPLES OF POOR MEMORIES TO AVOID:")
+        for ex in rejected_examples[:3]:
+            context_parts.append(f"- {ex.get('initial_memory')}")
+    
+    if context_parts:
+        context_parts.append("\nLearn from these examples to generate similar high-quality memories.")
+        return "\n".join(context_parts)
+    
+    return ""
 def add_npcshrc_to_shell_config() -> None:
     """
     Function Description:
@@ -1863,18 +2001,19 @@ 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, 
                           router) -> Tuple[ShellState, Any]:
-    """Executes slash commands using the router or checking NPC/Team jinxs."""
-    all_command_parts = shlex.split(command)
+    """Executes slash commands using the router."""
+    try:
+        all_command_parts = shlex.split(command)
+    except ValueError:
+        all_command_parts = command.split()
     command_name = all_command_parts[0].lstrip('/')
     
+    # --- NPC SWITCHING LOGIC ---
     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:
@@ -1884,129 +2023,35 @@ def execute_slash_command(command: str,
             available_npcs = list(state.team.npcs.keys()) if state.team else []
             return state, {"output": colored(f"NPC '{npc_to_switch_to}' not found. Available NPCs: {', '.join(available_npcs)}", "red"), "messages": state.messages}
     
+    # --- ROUTER LOGIC ---
     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 = {
-            'stream': stream,
-            'team': state.team,
-            'messages': state.messages,
-            'api_url': state.api_url,
-            'api_key': state.api_key,
-            'stdin_input': stdin_input,
-            'positional_args': positional_args,
-            'plonk_context': state.team.shared_context.get('PLONK_CONTEXT') if state.team and hasattr(state.team, 'shared_context') else None,
-            
+            'stream': stream, 'team': state.team, 'messages': state.messages, 'api_url': state.api_url,
+            'api_key': state.api_key, 'stdin_input': stdin_input,
             'model': state.npc.model if isinstance(state.npc, NPC) and state.npc.model else state.chat_model,
             'provider': state.npc.provider if isinstance(state.npc, NPC) and state.npc.provider else state.chat_provider,
-            'npc': state.npc,
-            
-            'sprovider': state.search_provider,
-            'emodel': state.embedding_model,
-            'eprovider': state.embedding_provider,
-            'igmodel': state.image_gen_model,
-            'igprovider': state.image_gen_provider,
-            'vgmodel': state.video_gen_model, 
-            'vgprovider': state.video_gen_provider,
-            'vmodel': state.vision_model,
-            'vprovider': state.vision_provider,
-            'rmodel': state.reasoning_model,
-            'rprovider': state.reasoning_provider,
+            'npc': state.npc, 'sprovider': state.search_provider, 'emodel': state.embedding_model,
+            'eprovider': state.embedding_provider, 'igmodel': state.image_gen_model, 'igprovider': state.image_gen_provider,
+            'vmodel': state.vision_model, 'vprovider': state.vision_provider, 'rmodel': state.reasoning_model, 
+            'rprovider': state.reasoning_provider, 'state': state
         }
-        
-        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 = ''
-
-        render_markdown(f'- Calling {command_name} handler {kwarg_part} ')
-        
-        if 'model' in normalized_flags and 'provider' not in normalized_flags:
-            inferred_provider = lookup_provider(normalized_flags['model'])
-            if inferred_provider:
-                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:
-            current_provider = lookup_provider(handler_kwargs['model'])
-            if current_provider != normalized_flags['provider']:
-                prov = normalized_flags['provider']
-                print(f'Please specify a model for the provider: {prov}')
-        
-        handler_kwargs.update(normalized_flags)
-        
         try:
             result = handler(command=command, **handler_kwargs)
-            
-            if isinstance(result, dict):
+            if isinstance(result, dict): 
                 state.messages = result.get("messages", state.messages)
-                return state, result
-            elif isinstance(result, str):
-                return state, {"output": result, "messages": state.messages}
-            else:
-                return state, {"output": str(result), "messages": state.messages}
-                
+            return state, result
         except Exception as e:
             import traceback
-            print(f"Error executing slash command '{command_name}':", file=sys.stderr)
             traceback.print_exc()
             return state, {"output": colored(f"Error executing slash command '{command_name}': {e}", "red"), "messages": state.messages}
-
-    active_npc = state.npc if isinstance(state.npc, NPC) else None
-    jinx_to_execute = None
-    executor = None
-    
-    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 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 = all_command_parts[1:]
-        try:
-            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]
-            
-            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:
-                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, jinx_output
-            elif isinstance(jinx_output, dict):
-                return state, jinx_output
-            else:
-                return state, {"output": str(jinx_output), "messages": state.messages}
-            
-        except Exception as e:
-            import traceback
-            print(f"Error executing jinx '{command_name}':", file=sys.stderr)
-            traceback.print_exc()
-            return state, {"output": colored(f"Error executing jinx '{command_name}': {e}", "red"), "messages": state.messages}
     
+    # Fallback for switching NPC by name
     if state.team and command_name in state.team.npcs:
-        new_npc = state.team.npcs[command_name]
-        state.npc = new_npc
-        return state, {"output": f"Switched to NPC: {new_npc.name}", "messages": state.messages}
+        state.npc = state.team.npcs[command_name]
+        return state, {"output": f"Switched to NPC: {state.npc.name}", "messages": state.messages}
 
-    return state, {"output": colored(f"Unknown slash command, jinx, or NPC: {command_name}", "red"), "messages": state.messages}
+    return state, {"output": colored(f"Unknown slash command or NPC: {command_name}", "red"), "messages": state.messages}
 
 
 def process_pipeline_command(
@@ -2017,15 +2062,14 @@ def process_pipeline_command(
     review = False, 
     router = None,
     ) -> Tuple[ShellState, Any]:
-    '''
-    Processing command 
-    '''
 
     if not cmd_segment:
         return state, stdin_input
 
     available_models_all = get_locally_available_models(state.current_path)
-    available_models_all_list = [item for key, item in available_models_all.items()]
+    available_models_all_list = [
+        item for key, item in available_models_all.items()
+    ]
 
     model_override, provider_override, cmd_cleaned = get_model_and_provider(
         cmd_segment, available_models_all_list
@@ -2034,18 +2078,33 @@ def process_pipeline_command(
     if not cmd_to_process:
          return state, stdin_input
 
-    npc_model = state.npc.model if isinstance(state.npc, NPC) and state.npc.model else None
-    npc_provider = state.npc.provider if isinstance(state.npc, NPC) and state.npc.provider else None
+    npc_model = (
+        state.npc.model 
+        if isinstance(state.npc, NPC) and state.npc.model 
+        else None
+    )
+    npc_provider = (
+        state.npc.provider 
+        if isinstance(state.npc, NPC) and state.npc.provider 
+        else None
+    )
 
     exec_model = model_override or npc_model or state.chat_model
     exec_provider = provider_override or npc_provider or state.chat_provider
 
     if cmd_to_process.startswith("/"):
-        return execute_slash_command(cmd_to_process, 
-                                     stdin_input, 
-                                     state, 
-                                     stream_final, 
-                                     router)
+        with SpinnerContext(
+            f"Routing to {cmd_to_process.split()[0]}", 
+            style="arrow"
+        ):
+            result = execute_slash_command(
+                cmd_to_process, 
+                stdin_input, 
+                state, 
+                stream_final, 
+                router
+            )
+        return result
     
     cmd_parts = parse_command_safely(cmd_to_process)
     if not cmd_parts:
@@ -2058,6 +2117,7 @@ def process_pipeline_command(
     
     if command_name in interactive_commands:
         return handle_interactive_command(cmd_parts, state)
+        
     if command_name in TERMINAL_EDITORS:
         print(f"Starting interactive editor: {command_name}...")
         full_command_str = " ".join(cmd_parts)
@@ -2065,46 +2125,107 @@ def process_pipeline_command(
         return state, output
 
     if validate_bash_command(cmd_parts):
-        success, result = handle_bash_command(cmd_parts, cmd_to_process, stdin_input, state)
+        with SpinnerContext(f"Executing {command_name}", style="line"):
+            success, result = handle_bash_command(
+                cmd_parts, 
+                cmd_to_process, 
+                stdin_input, 
+                state
+            )
+        
         if success:
             return state, result
         else:
-            print(colored(f"Bash command failed: {result}. Asking LLM for a fix...", "yellow"), file=sys.stderr)
-            fixer_prompt = f"The command '{cmd_to_process}' failed with the error: '{result}'. Provide the correct command."
-            response = execute_llm_command(
-                fixer_prompt, 
-                model=exec_model,
-                provider=exec_provider,
-                npc=state.npc, 
-                stream=stream_final, 
-                messages=state.messages
+            print(
+                colored(
+                    f"Command failed. Consulting {exec_model}...", 
+                    "yellow"
+                ), 
+                file=sys.stderr
+            )
+            fixer_prompt = (
+                f"The command '{cmd_to_process}' failed with error: "
+                f"'{result}'. Provide the correct command."
             )
+            
+            with SpinnerContext(
+                f"{exec_model} analyzing error", 
+                style="brain"
+            ):
+                response = execute_llm_command(
+                    fixer_prompt, 
+                    model=exec_model,
+                    provider=exec_provider,
+                    npc=state.npc, 
+                    stream=stream_final, 
+                    messages=state.messages
+                )
+            
             state.messages = response['messages']     
             return state, response['response']
     else:
-        full_llm_cmd = f"{cmd_to_process} {stdin_input}" if stdin_input else cmd_to_process
+        full_llm_cmd = (
+            f"{cmd_to_process} {stdin_input}" 
+            if stdin_input 
+            else cmd_to_process
+        )
         path_cmd = 'The current working directory is: ' + state.current_path
-        ls_files = 'Files in the current directory (full paths):\n' + "\n".join([os.path.join(state.current_path, f) for f in os.listdir(state.current_path)]) if os.path.exists(state.current_path) else 'No files found in the current directory.'
-        platform_info = f"Platform: {platform.system()} {platform.release()} ({platform.machine()})"
+        ls_files = (
+            'Files in the current directory (full paths):\n' + 
+            "\n".join([
+                os.path.join(state.current_path, f) 
+                for f in os.listdir(state.current_path)
+            ]) 
+            if os.path.exists(state.current_path) 
+            else 'No files found in the current directory.'
+        )
+        platform_info = (
+            f"Platform: {platform.system()} {platform.release()} "
+            f"({platform.machine()})"
+        )
         info = path_cmd + '\n' + ls_files + '\n' + platform_info + '\n' 
         state.messages.append({'role':'user', 'content':full_llm_cmd})
         
-        
-        llm_result = check_llm_command(
-            full_llm_cmd,
-            model=exec_model,      
-            provider=exec_provider, 
-            api_url=state.api_url,
-            api_key=state.api_key,
-            npc=state.npc,
-            team=state.team,
-            messages=state.messages,
-            images=state.attachments,
-            stream=stream_final,
-            context=info,
+        npc_name = (
+            state.npc.name 
+            if isinstance(state.npc, NPC) 
+            else "Assistant"
         )
-      
         
+        with SpinnerContext(
+            f"{npc_name} processing with {exec_model}", 
+            style="dots_pulse"
+        ):
+            # Build extra_globals for jinx execution
+            application_globals_for_jinx = {
+                "CommandHistory": CommandHistory, 
+                "load_kg_from_db": load_kg_from_db,
+                "execute_rag_command": execute_rag_command, 
+                "execute_brainblast_command": execute_brainblast_command,
+                "load_file_contents": load_file_contents, 
+                "search_web": search_web,
+                "get_relevant_memories": get_relevant_memories,
+                "search_kg_facts": search_kg_facts,
+                'state': state
+            }
+            current_module = sys.modules[__name__]
+            for name, func in inspect.getmembers(current_module, inspect.isfunction):
+                application_globals_for_jinx[name] = func
+
+            llm_result = check_llm_command(
+                full_llm_cmd,
+                model=exec_model,      
+                provider=exec_provider, 
+                api_url=state.api_url,
+                api_key=state.api_key,
+                npc=state.npc,
+                team=state.team,
+                messages=state.messages,
+                images=state.attachments,
+                stream=stream_final,
+                context=info,
+                extra_globals=application_globals_for_jinx  # NOW PASS IT
+            )
         if not review:
             if isinstance(llm_result, dict):
                 state.messages = llm_result.get("messages", state.messages)
@@ -2112,7 +2233,6 @@ def process_pipeline_command(
                 return state, output
             else:
                 return state, llm_result        
-            
         else:
             return review_and_iterate_command(
                 original_command=full_llm_cmd,
@@ -2123,6 +2243,8 @@ def process_pipeline_command(
                 stream_final=stream_final,
                 info=info
             )
+
+
 def review_and_iterate_command(
     original_command: str,
     initial_result: Any,
@@ -2181,6 +2303,71 @@ def check_mode_switch(command:str , state: ShellState):
         return True, state     
     return False, state
 
+import sys
+import time
+import threading
+from itertools import cycle
+
+class SpinnerContext:
+    def __init__(self, message="Processing", style="dots"):
+        self.message = message
+        self.spinning = False
+        self.thread = None
+        
+        styles = {
+            "dots": ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+            "line": ["-", "\\", "|", "/"],
+            "arrow": ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
+            "box": ["◰", "◳", "◲", "◱"],
+            "dots_pulse": ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"],
+            "brain": ["🧠", "💭", "🤔", "💡"],
+        }
+        self.frames = cycle(styles.get(style, styles["dots"]))
+    
+    def _spin(self):
+        while self.spinning:
+            sys.stdout.write(
+                f"\r{colored(next(self.frames), 'cyan')} "
+                f"{colored(self.message, 'yellow')}..."
+            )
+            sys.stdout.flush()
+            time.sleep(0.1)
+    
+    def __enter__(self):
+        self.spinning = True
+        self.thread = threading.Thread(target=self._spin)
+        self.thread.start()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.spinning = False
+        if self.thread:
+            self.thread.join()
+        sys.stdout.write("\r" + " " * 80 + "\r")
+        sys.stdout.flush()
+
+def show_thinking_animation(message="Thinking", duration=None):
+    frames = ["🤔", "💭", "🧠", "💡", "✨"]
+    colors = ["cyan", "blue", "magenta", "yellow", "green"]
+    
+    start = time.time()
+    i = 0
+    while duration is None or (time.time() - start) < duration:
+        frame = frames[i % len(frames)]
+        color = colors[i % len(colors)]
+        sys.stdout.write(
+            f"\r{colored(frame, color)} "
+            f"{colored(message, 'yellow')}..."
+        )
+        sys.stdout.flush()
+        time.sleep(0.3)
+        i += 1
+        if duration and (time.time() - start) >= duration:
+            break
+    
+    sys.stdout.write("\r" + " " * 80 + "\r")
+    sys.stdout.flush()
+
 def execute_command(
     command: str,
     state: ShellState,
@@ -2194,29 +2381,51 @@ def execute_command(
     
     mode_change, state = check_mode_switch(command, state)
     if mode_change:
+        print(colored(f"⚡ Switched to {state.current_mode} mode", "green"))
         return state, 'Mode changed.'
 
-    npc_name = state.npc.name if isinstance(state.npc, NPC) else "__none__"
+    npc_name = (
+        state.npc.name 
+        if isinstance(state.npc, NPC) 
+        else "__none__"
+    )
     team_name = state.team.name if state.team else "__none__"
     
-
     original_command_for_embedding = command
     commands = split_by_pipes(command)
 
     stdin_for_next = None
     final_output = None
     current_state = state 
-    npc_model = state.npc.model if isinstance(state.npc, NPC) and state.npc.model else None
-    npc_provider = state.npc.provider if isinstance(state.npc, NPC) and state.npc.provider else None
+    npc_model = (
+        state.npc.model 
+        if isinstance(state.npc, NPC) and state.npc.model 
+        else None
+    )
+    npc_provider = (
+        state.npc.provider 
+        if isinstance(state.npc, NPC) and state.npc.provider 
+        else None
+    )
     active_model = npc_model or state.chat_model
     active_provider = npc_provider or state.chat_provider
+    
     if state.current_mode == 'agent':
-      
-      
+        total_stages = len(commands)
+        
         for i, cmd_segment in enumerate(commands):
-            render_markdown(f'- Executing command {i+1}/{len(commands)}')
+            stage_num = i + 1
+            stage_emoji = ["🎯", "⚙️", "🔧", "✨", "🚀"][i % 5]
+            
+            print(colored(
+                f"\n{stage_emoji} Pipeline Stage {stage_num}/{total_stages}", 
+                "cyan", 
+                attrs=["bold"]
+            ))
+            
             is_last_command = (i == len(commands) - 1)
             stream_this_segment = state.stream_output and not is_last_command 
+            
             try:
                 current_state, output = process_pipeline_command(
                     cmd_segment.strip(),
@@ -2224,19 +2433,26 @@ def execute_command(
                     current_state, 
                     stream_final=stream_this_segment, 
                     review=review,
-                    router= router
+                    router=router
                 )
+                
                 if is_last_command:
+                    print(colored("✅ Pipeline complete", "green"))
                     return current_state, output
+                    
                 if isinstance(output, str):
                     stdin_for_next = output
                 elif not isinstance(output, str):
                     try:
                         if stream_this_segment:
-                            full_stream_output = print_and_process_stream_with_markdown(output, 
-                                                                                        state.npc.model, 
-                                                                                        state.npc.provider, 
-                                                                                        show=True)
+                            full_stream_output = (
+                                print_and_process_stream_with_markdown(
+                                    output, 
+                                    state.npc.model, 
+                                    state.npc.provider, 
+                                    show=True
+                                )
+                            )
                             stdin_for_next = full_stream_output
                             if is_last_command: 
                                 final_output = full_stream_output
@@ -2245,24 +2461,40 @@ def execute_command(
                             try: 
                                 stdin_for_next = str(output)
                             except Exception:
-                                print(f"Warning: Cannot convert output to string for piping: {type(output)}", file=sys.stderr)
+                                print(
+                                    f"Warning: Cannot convert output to "
+                                    f"string for piping: {type(output)}", 
+                                    file=sys.stderr
+                                )
                                 stdin_for_next = None
                         else: 
                             stdin_for_next = None
+                            
+                print(colored(
+                    f"  → Passing to stage {stage_num + 1}", 
+                    "blue"
+                ))
+                
             except Exception as pipeline_error:
                 import traceback
                 traceback.print_exc()
-                error_msg = colored(f"Error in pipeline stage {i+1} ('{cmd_segment[:50]}...'): {pipeline_error}", "red")
+                error_msg = colored(
+                    f"❌ Error in stage {stage_num} "
+                    f"('{cmd_segment[:50]}...'): {pipeline_error}", 
+                    "red"
+                )
                 return current_state, error_msg
 
         if final_output is not None and isinstance(final_output,str):
-            store_command_embeddings(original_command_for_embedding, final_output, current_state)
+            store_command_embeddings(
+                original_command_for_embedding, 
+                final_output, 
+                current_state
+            )
 
         return current_state, final_output
 
-
     elif state.current_mode == 'chat':
-      
         cmd_parts = parse_command_safely(command)
         is_probably_bash = (
             cmd_parts
@@ -2273,6 +2505,7 @@ def execute_command(
                 or command.strip().startswith("/")
             )
         )
+        
         if is_probably_bash:
             try:
                 command_name = cmd_parts[0]
@@ -2282,36 +2515,55 @@ def execute_command(
                     return handle_cd_command(cmd_parts, state)
                 else:
                     try:
-                        bash_state, bash_output = handle_bash_command(cmd_parts, command, None, state)
+                        bash_state, bash_output = handle_bash_command(
+                            cmd_parts, 
+                            command, 
+                            None, 
+                            state
+                        )
                         return state, bash_output
                     except Exception as bash_err:
-                        return state, colored(f"Bash execution failed: {bash_err}", "red")
+                        return state, colored(
+                            f"Bash execution failed: {bash_err}", 
+                            "red"
+                        )
             except Exception:
                 pass
 
-      
-        response = get_llm_response(
-            command, 
-            model=active_model,          
-            provider=active_provider,    
-            npc=state.npc,
-            stream=state.stream_output,
-            messages=state.messages
-        )
+        with SpinnerContext(
+            f"Chatting with {active_model}", 
+            style="brain"
+        ):
+            response = get_llm_response(
+                command, 
+                model=active_model,          
+                provider=active_provider,    
+                npc=state.npc,
+                stream=state.stream_output,
+                messages=state.messages
+            )
+        
         state.messages = response['messages']
         return state, response['response']
 
     elif state.current_mode == 'cmd':
-
-        response = execute_llm_command(command, 
-                                        model=active_model,          
-                                        provider=active_provider,  
-                                                 npc = state.npc, 
-                                                 stream = state.stream_output, 
-                                                 messages = state.messages) 
+        with SpinnerContext(
+            f"Executing with {active_model}", 
+            style="dots_pulse"
+        ):
+            response = execute_llm_command(
+                command, 
+                model=active_model,          
+                provider=active_provider,  
+                npc=state.npc, 
+                stream=state.stream_output, 
+                messages=state.messages
+            ) 
+        
         state.messages = response['messages']     
         return state, response['response']
 
+
 def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     setup_npcsh_config()
 
@@ -2445,139 +2697,6 @@ def initialize_router_with_jinxs(team, router):
     
     return router
                 
-from npcpy.memory.memory_processor import  memory_approval_ui
-from npcpy.ft.memory_trainer import MemoryTrainer
-from npcpy.llm_funcs import get_facts
-
-def get_relevant_memories(
-    command_history: CommandHistory,
-    npc_name: str,
-    team_name: str,
-    path: str,
-    query: Optional[str] = None,
-    max_memories: int = 10,
-    state: Optional[ShellState] = None
-) -> List[Dict]:
-    
-    engine = command_history.engine
-    
-    all_memories = command_history.get_memories_for_scope(
-        npc=npc_name,
-        team=team_name,
-        directory_path=path,
-        status='human-approved'
-    )
-    
-    if not all_memories:
-        return []
-    
-    if len(all_memories) <= max_memories and not query:
-        return all_memories
-    
-    if query:
-        query_lower = query.lower()
-        keyword_matches = [
-            m for m in all_memories 
-            if query_lower in (m.get('final_memory') or m.get('initial_memory') or '').lower()
-        ]
-        
-        if keyword_matches:
-            return keyword_matches[:max_memories]
-
-    if state and state.embedding_model and state.embedding_provider:
-        try:
-            from npcpy.gen.embeddings import get_embeddings
-            
-            search_text = query if query else "recent context"
-            query_embedding = get_embeddings(
-                [search_text],
-                state.embedding_model,
-                state.embedding_provider
-            )[0]
-            
-            memory_texts = [
-                m.get('final_memory', '') for m in all_memories
-            ]
-            memory_embeddings = get_embeddings(
-                memory_texts,
-                state.embedding_model,
-                state.embedding_provider
-            )
-            
-            import numpy as np
-            similarities = []
-            for mem_emb in memory_embeddings:
-                similarity = np.dot(query_embedding, mem_emb) / (
-                    np.linalg.norm(query_embedding) * 
-                    np.linalg.norm(mem_emb)
-                )
-                similarities.append(similarity)
-            
-            sorted_indices = np.argsort(similarities)[::-1]
-            return [all_memories[i] for i in sorted_indices[:max_memories]]
-            
-        except Exception as e:
-            print(colored(
-                f"RAG search failed, using recent: {e}", 
-                "yellow"
-            ))
-    
-    return all_memories[-max_memories:]
-
-
-def search_kg_facts(
-    self,
-    npc: str,
-    team: str,
-    directory_path: str,
-    query: str
-) -> List[Dict]:
-    
-    kg = load_kg_from_db(
-        self.engine, 
-        team, 
-        npc, 
-        directory_path
-    )
-    
-    if not kg or 'facts' not in kg:
-        return []
-    
-    query_lower = query.lower()
-    matching_facts = []
-    
-    for fact in kg['facts']:
-        statement = fact.get('statement', '').lower()
-        if query_lower in statement:
-            matching_facts.append(fact)
-    
-    return matching_facts
-
-def format_memory_context(memory_examples):
-    if not memory_examples:
-        return ""
-    
-    context_parts = []
-    
-    approved_examples = memory_examples.get("approved", [])
-    rejected_examples = memory_examples.get("rejected", [])
-    
-    if approved_examples:
-        context_parts.append("EXAMPLES OF GOOD MEMORIES:")
-        for ex in approved_examples[:5]:
-            final = ex.get("final_memory") or ex.get("initial_memory")
-            context_parts.append(f"- {final}")
-    
-    if rejected_examples:
-        context_parts.append("\nEXAMPLES OF POOR MEMORIES TO AVOID:")
-        for ex in rejected_examples[:3]:
-            context_parts.append(f"- {ex.get('initial_memory')}")
-    
-    if context_parts:
-        context_parts.append("\nLearn from these examples to generate similar high-quality memories.")
-        return "\n".join(context_parts)
-    
-    return ""
 
 def process_memory_approvals(command_history, memory_queue):
     pending_memories = memory_queue.get_approval_batch(max_items=5)