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

npcsh/npcsh.py

@@ -10,10 +10,6 @@ import importlib.metadata
 import textwrap
 from typing import Optional, List, Dict, Any, Tuple, Union
 from dataclasses import dataclass, field
-try:
-    from inspect import isgenerator
-except: 
-    pass
 import platform
 try:
     from termcolor import colored
@@ -30,7 +26,6 @@ import sqlite3
 import copy
 import yaml
 
-# Local Application Imports
 from npcsh._state import (
     setup_npcsh_config,
     initial_state, 
@@ -40,8 +35,11 @@ from npcsh._state import (
     ShellState,
     interactive_commands,
     BASH_COMMANDS,
+
     start_interactive_session,
-    validate_bash_command
+    validate_bash_command, 
+    normalize_and_expand_flags, 
+
     )
 
 from npcpy.npc_sysenv import (
@@ -49,6 +47,7 @@ from npcpy.npc_sysenv import (
     render_markdown,
     get_locally_available_models,
     get_model_and_provider,
+    lookup_provider
 )
 from npcsh.routes import router
 from npcpy.data.image import capture_screenshot
@@ -215,7 +214,7 @@ def get_slash_commands(state: ShellState) -> List[str]:
         completion_logger.debug(f"NPC commands: {npc_cmds}")
     
     # Mode switching commands
-    mode_cmds = ['/cmd', '/agent', '/chat', '/ride']
+    mode_cmds = ['/cmd', '/agent', '/chat']
     commands.extend(mode_cmds)
     completion_logger.debug(f"Mode commands: {mode_cmds}")
     
@@ -571,13 +570,107 @@ def handle_bash_command(
     except PermissionError:
         return False, f"Permission denied: {cmd_str}"
 
+def _try_convert_type(value: str) -> Union[str, int, float, bool]:
+    """Helper to convert string values to appropriate types."""
+    if value.lower() in ['true', 'yes']:
+        return True
+    if value.lower() in ['false', 'no']:
+        return False
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        pass
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        pass
+    return value
+
+def parse_generic_command_flags(parts: List[str]) -> Tuple[Dict[str, Any], List[str]]:
+    """
+    Parses a list of command parts into a dictionary of keyword arguments and a list of positional arguments.
+    Handles: -f val, --flag val, --flag=val, flag=val, --boolean-flag
+    """
+    parsed_kwargs = {}
+    positional_args = []
+    i = 0
+    while i < len(parts):
+        part = parts[i]
+        
+        if part.startswith('--'):
+            key_part = part[2:]
+            if '=' in key_part:
+                key, value = key_part.split('=', 1)
+                parsed_kwargs[key] = _try_convert_type(value)
+            else:
+                # Look ahead for a value
+                if i + 1 < len(parts) and not parts[i + 1].startswith('-'):
+                    parsed_kwargs[key_part] = _try_convert_type(parts[i + 1])
+                    i += 1 # Consume the value
+                else:
+                    parsed_kwargs[key_part] = True # Boolean flag
+        
+        elif part.startswith('-'):
+            key = part[1:]
+            # Look ahead for a value
+            if i + 1 < len(parts) and not parts[i + 1].startswith('-'):
+                parsed_kwargs[key] = _try_convert_type(parts[i + 1])
+                i += 1 # Consume the value
+            else:
+                parsed_kwargs[key] = True # Boolean flag
+        
+        elif '=' in part and not part.startswith('-'):
+             key, value = part.split('=', 1)
+             parsed_kwargs[key] = _try_convert_type(value)
+        
+        else:
+            positional_args.append(part)
+        
+        i += 1
+        
+    return parsed_kwargs, positional_args
+
+
+def should_skip_kg_processing(user_input: str, assistant_output: str) -> bool:
+    """Determine if this interaction is too trivial for KG processing"""
+    
+    # Skip if user input is too short or trivial
+    trivial_inputs = {
+        '/sq', '/exit', '/quit', 'exit', 'quit', 'hey', 'hi', 'hello', 
+        'fwah!', 'test', 'ping', 'ok', 'thanks', 'ty'
+    }
+    
+    if user_input.lower().strip() in trivial_inputs:
+        return True
+    
+    # Skip if user input is very short (less than 10 chars)
+    if len(user_input.strip()) < 10:
+        return True
+    
+    # Skip simple bash commands
+    simple_bash = {'ls', 'pwd', 'cd', 'mkdir', 'touch', 'rm', 'mv', 'cp'}
+    first_word = user_input.strip().split()[0] if user_input.strip() else ""
+    if first_word in simple_bash:
+        return True
+    
+    # Skip if assistant output is very short (less than 20 chars)
+    if len(assistant_output.strip()) < 20:
+        return True
+    
+    # Skip if it's just a mode exit message
+    if "exiting" in assistant_output.lower() or "exited" in assistant_output.lower():
+        return True
+    
+    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."""
-    command_parts = command.split()
-    command_name = command_parts[0].lstrip('/')
-
+    all_command_parts = shlex.split(command)
+    command_name = all_command_parts[0].lstrip('/')
     if command_name in ['n', 'npc']:
-        npc_to_switch_to = command_parts[1] if len(command_parts) > 1 else None
+        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:
             state.npc = state.team.npcs[npc_to_switch_to]
             return state, f"Switched to NPC: {npc_to_switch_to}"
@@ -585,38 +678,75 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
             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")
     handler = router.get_route(command_name)
-    #print(handler)
     if handler:
-        # Prepare kwargs for the 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,
-            'npc': state.npc, 
             'team': state.team,
             'messages': state.messages,
-            'model': state.chat_model, 
-            'provider': state.chat_provider,
             '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,
+            
+            # Default chat model/provider
+            '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,
+            
+            # All other specific defaults
+            '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,
         }
-        #print(handler_kwargs, command)
-        if stdin_input is not None:
-            handler_kwargs['stdin_input'] = stdin_input
-
+        
+        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} ')
+        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)
+        
+        
         try:
-            result_dict = handler(command, **handler_kwargs)
-
+            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
             else:
                 return state, result_dict
-
         except Exception as e:
             import traceback
             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")
-
     active_npc = state.npc if isinstance(state.npc, NPC) else None
     jinx_to_execute = None
     executor = None
@@ -650,6 +780,7 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
 
     return state, colored(f"Unknown slash command or jinx: {command_name}", "red")
 
+
 def process_pipeline_command(
     cmd_segment: str,
     stdin_input: Optional[str],
@@ -662,6 +793,7 @@ def process_pipeline_command(
 
     available_models_all = get_locally_available_models(state.current_path)
     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
     )
@@ -669,14 +801,11 @@ def process_pipeline_command(
     if not cmd_to_process:
          return state, stdin_input
 
-    # --- Corrected Model Resolution ---
-    # Priority: 1. Inline Override, 2. NPC Model, 3. Global Model
     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
-    # --- End of Correction ---
 
     if cmd_to_process.startswith("/"):
         return execute_slash_command(cmd_to_process, stdin_input, state, stream_final)
@@ -685,23 +814,25 @@ def process_pipeline_command(
     if not cmd_parts:
         return state, stdin_input
 
-    if validate_bash_command(cmd_parts):
-        command_name = cmd_parts[0]
-        if command_name in interactive_commands:
-            return handle_interactive_command(cmd_parts, state)
-        if command_name == "cd":
-            return handle_cd_command(cmd_parts, state)
+    command_name = cmd_parts[0]
+
+    if command_name == "cd":
+        return handle_cd_command(cmd_parts, state)
+    
+    if command_name in interactive_commands:
+        return handle_interactive_command(cmd_parts, state)
 
+    if validate_bash_command(cmd_parts):
         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. Asking LLM for a fix: {result}", "yellow"), file=sys.stderr)
+            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,      # Uses corrected model
-                provider=exec_provider, # Uses corrected provider
+                model=exec_model,
+                provider=exec_provider,
                 npc=state.npc, 
                 stream=stream_final, 
                 messages=state.messages
@@ -717,8 +848,8 @@ def process_pipeline_command(
 
         llm_result = check_llm_command(
             full_llm_cmd,
-            model=exec_model,       # Uses corrected model
-            provider=exec_provider, # Uses corrected provider
+            model=exec_model,      
+            provider=exec_provider, 
             api_url=state.api_url,
             api_key=state.api_key,
             npc=state.npc,
@@ -727,17 +858,15 @@ def process_pipeline_command(
             images=state.attachments,
             stream=stream_final,
             context=info,
-
         )
         if isinstance(llm_result, dict):
             state.messages = llm_result.get("messages", state.messages)
             output = llm_result.get("output")
             return state, output
         else:
-            return state, llm_result
-        
+            return state, llm_result        
 def check_mode_switch(command:str , state: ShellState):
-    if command in ['/cmd', '/agent', '/chat', '/ride']:
+    if command in ['/cmd', '/agent', '/chat',]:
         state.current_mode = command[1:]
         return True, state     
 
@@ -764,9 +893,13 @@ def execute_command(
     active_provider = npc_provider or state.chat_provider
 
     if state.current_mode == 'agent':
+        print(len(commands), 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(
@@ -777,27 +910,27 @@ 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 isgenerator(output):
-                    if not stream_this_segment: # If intermediate output is a stream, consume for piping
-                        full_stream_output = "".join(map(str, output))
-                        stdin_for_next = full_stream_output
-                        if is_last_command: 
-                            final_output = full_stream_output
-                    else: # Final output is a stream, don't consume, can't pipe
-                        stdin_for_next = None
-                        final_output = output
-                elif output is not None: # Try converting other types to string
-                    try: 
-                        stdin_for_next = str(output)
-                    except Exception:
-                        print(f"Warning: Cannot convert output to string for piping: {type(output)}", file=sys.stderr)
-                        stdin_for_next = None
-                else: # Output was None
-                    stdin_for_next = None
+                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)
+                            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: 
+                                stdin_for_next = str(output)
+                            except Exception:
+                                print(f"Warning: Cannot convert output to string for piping: {type(output)}", file=sys.stderr)
+                                stdin_for_next = None
+                        else: # Output was None
+                            stdin_for_next = None
 
 
             except Exception as pipeline_error:
@@ -808,7 +941,7 @@ def execute_command(
                 return current_state, error_msg
 
         # Store embeddings using the final state
-        if final_output is not None and not (isgenerator(final_output) and current_state.stream_output):
+        if final_output is not None and isinstance(final_output,str):
             store_command_embeddings(original_command_for_embedding, final_output, current_state)
 
         # Return the final state and the final output
@@ -866,6 +999,9 @@ def execute_command(
         state.messages = response['messages']     
         return state, response['response']
 
+    """    
+    # to be replaced with a standalone corca mode
+    
     elif state.current_mode == 'ride':
         # Allow bash commands in /ride mode
         cmd_parts = parse_command_safely(command)
@@ -896,379 +1032,8 @@ def execute_command(
 
         # Otherwise, run the agentic ride loop
         return agentic_ride_loop(command, state)
-@dataclass
-class RideState:
-    """Lightweight state tracking for /ride mode"""
-    todos: List[Dict[str, Any]] = field(default_factory=list)
-    constraints: List[str] = field(default_factory=list)
-    facts: List[str] = field(default_factory=list)
-    mistakes: List[str] = field(default_factory=list)
-    successes: List[str] = field(default_factory=list)
-    current_todo_index: int = 0
-    current_subtodo_index: int = 0
-    
-    def get_context_summary(self) -> str:
-        """Generate lightweight context for LLM prompts"""
-        context = []
-        if self.facts:
-            context.append(f"Facts: {'; '.join(self.facts[:5])}")  # Limit to 5 most recent
-        if self.mistakes:
-            context.append(f"Recent mistakes: {'; '.join(self.mistakes[-3:])}")
-        if self.successes:
-            context.append(f"Recent successes: {'; '.join(self.successes[-3:])}")
-        return "\n".join(context)
-
-def interactive_edit_list(items: List[str], item_type: str) -> List[str]:
-    """Interactive REPL for editing lists of items with regeneration options"""
-    while True:
-        print(f"\nCurrent {item_type}:")
-        for i, item in enumerate(items, 1):
-            print(f"{i}. {item}")
-        
-        choice = input(f"\nEdit {item_type} (e<num> to edit, d<num> to delete, a to add, r to regenerate, c to add context, ok to continue): ").strip()
-        
-        if choice.lower() == 'ok':
-            break
-        elif choice.lower() == 'r':
-            print("Regenerating list...")
-            return "REGENERATE"  # Special signal to regenerate
-        elif choice.lower() == 'c':
-            additional_context = input("Add more context: ").strip()
-            if additional_context:
-                return {"ADD_CONTEXT": additional_context, "items": items}
-        elif choice.lower() == 'a':
-            new_item = input(f"Enter new {item_type[:-1]}: ").strip()
-            if new_item:
-                items.append(new_item)
-        elif choice.lower().startswith('e'):
-            try:
-                idx = int(choice[1:]) - 1
-                if 0 <= idx < len(items):
-                    print(f"Current: {items[idx]}")
-                    new_item = input("New version: ").strip()
-                    if new_item:
-                        items[idx] = new_item
-            except ValueError:
-                print("Invalid format. Use e<number>")
-        elif choice.lower().startswith('d'):
-            try:
-                idx = int(choice[1:]) - 1
-                if 0 <= idx < len(items):
-                    items.pop(idx)
-            except ValueError:
-                print("Invalid format. Use d<number>")
-        else:
-            print("Invalid choice. Use: e<num>, d<num>, a, r (regenerate), c (add context), or ok")
-    
-    return items
-def generate_todos(user_goal: str, state: ShellState, additional_context: str = "") -> List[Dict[str, Any]]:
-    """Generate high-level todos for the user's goal"""
-    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()})"
-    info = path_cmd + '\n' + ls_files + '\n' + platform_info 
-
-
-    
-    high_level_planning_instruction = """
-    You are a high-level project planner. When a user asks to work on a file or code,
-    structure your plan using a simple, high-level software development lifecycle:
-    1. First, understand the current state (e.g., read the relevant file).
-    2. Second, make the required changes based on the user's goal.
-    3. Third, verify the changes work as intended (e.g., test the code).
-    Your generated todos should reflect this high-level thinking.
-
-
-    
-    """
-    
-    prompt = f"""
-    {high_level_planning_instruction}
-
-    User goal: {user_goal}
-    
-    {additional_context}
-    
-    Generate a list of 3 todos to accomplish this goal. Use specific actionable language based on the user request. 
-    Do not make assumptions about user needs. 
-    Every todo must be directly sourced from the user's request.     
-    If users request specific files to be incorporated, you MUST include the full path to the file in the todo.
-    Here is some relevant information for the current folder and working directory that may be relevant:
-    {info}
-
-    For example, if the user says "I need to add a new function to calculate the average of a list of numbers my research.py script" and the current working directory is /home/user/projects and one
-     of the available files in the current directory is /home/user/projects/research.py then one of the todos should be:
-    - "Add a new function to /home/user/projects/research.py to calculate the average of a list of numbers"
-    Do not truncate paths. Do not additional paths. Use them exactly as they are provided here.
-    
-    Each todo should be:
-    - Specific and actionable
-    - Independent where possible
-    - Focused on a single major component
-
-    Remember, it is critical to provide as much relevant information as possible. Even if the user only refers to a file or something by a relative path, it is
-    critical for operation that you provide the full path to the file in the todo item.
-
-    Return JSON with format:
-    {{
-        "todos": [
-            todo1, todo2, todo3,
-                    ]
-    }}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    todos_data = response.get("response", {}).get("todos", [])
-    return todos_data
-
-
-def generate_constraints(todos: List[Dict[str, Any]], user_goal: str, state: ShellState) -> List[str]:
-    """Generate constraints and requirements that define relationships between todos"""
-    prompt = f"""
-    User goal: {user_goal}
-    
-    Todos to accomplish:
-    {chr(10).join([f"- {todo}" for todo in todos])}
-    
-    Based ONLY on what the user explicitly stated in their goal, identify any constraints or requirements they mentioned.
-    Do NOT invent new constraints. Only extract constraints that are directly stated or clearly implied by the user's request.
-    
-    Examples of valid constraints:
-    - If user says "without breaking existing functionality" -> "Maintain existing functionality"
-    - If user says "must be fast" -> "Performance must be optimized"
-    - If user says "should integrate with X" -> "Must integrate with X"
-    
-    If the user didn't specify any constraints, return an empty list.
-    
-    Return JSON with format:
-    {{
-        "constraints": ["constraint 1", "constraint 2", ...]
-    }}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    constraints_data = response.get("response", {})
-    
-    if isinstance(constraints_data, dict):
-        constraints = constraints_data.get("constraints", [])
-        # Make sure we're getting strings, not dicts
-        cleaned_constraints = []
-        for c in constraints:
-            if isinstance(c, str):
-                cleaned_constraints.append(c)
-        return cleaned_constraints
-    else:
-        return []
-def should_break_down_todo(todo, state: ShellState) -> bool:
-    """Ask LLM if a todo needs breakdown, then ask user for confirmation"""
-    prompt = f"""
-    Todo: {todo}
-
-        
-    Does this todo need to be broken down into smaller, more atomic components?
-    Consider:
-    - Is it complex enough to warrant breakdown?
-    - Would breaking it down make execution clearer?
-    - Are there multiple distinct steps involved?
-    
-    Return JSON: {{"should_break_down": true/false, "reason": "explanation"}}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    result = response.get("response", {})
-    llm_suggests = result.get("should_break_down", False)
-    reason = result.get("reason", "No reason provided")
-    
-    if llm_suggests:
-        print(f"\nLLM suggests breaking down: '{todo}'")
-        print(f"Reason: {reason}")
-        user_choice = input("Break it down? [y/N]: ").strip().lower()
-        return user_choice in ['y', 'yes']
-    
-    return False
-
-def generate_subtodos(todo, state: ShellState) -> List[Dict[str, Any]]:
-    """Generate atomic subtodos for a complex todo"""
-    prompt = f"""
-    Parent todo: {todo}
-    
-    Break this down into atomic, executable subtodos. Each subtodo should be:
-    - A single, concrete action
-    - Executable in one step
-    - Clear and unambiguous
-    
-    Return JSON with format:
-    {{
-        "subtodos": [
-             "subtodo description",
-            ...
-        ]
-    }}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    return response.get("response", {}).get("subtodos", [])
-def execute_todo_item(todo: Dict[str, Any], ride_state: RideState, shell_state: ShellState) -> bool:
-    """Execute a single todo item using the existing jinx system"""
-    path_cmd = 'The current working directory is: ' + shell_state.current_path
-    ls_files = 'Files in the current directory (full paths):\n' + "\n".join([os.path.join(shell_state.current_path, f) for f in os.listdir(shell_state.current_path)]) if os.path.exists(shell_state.current_path) else 'No files found in the current directory.'
-    platform_info = f"Platform: {platform.system()} {platform.release()} ({platform.machine()})"
-    info = path_cmd + '\n' + ls_files + '\n' + platform_info 
-
-    command = f"""
-
-    General information:
-    {info}
-    
-    Execute this todo: {todo}
-    
-    Constraints to follow:
-    {chr(10).join([f"- {c}" for c in ride_state.constraints])}
     """
-    
-    print(f"\nExecuting: {todo}")
-    
 
-    result = check_llm_command(
-        command,
-        model=shell_state.chat_model,
-        provider=shell_state.chat_provider,
-        npc=shell_state.npc,
-        team=shell_state.team,
-        messages=[],
-        stream=shell_state.stream_output,
-
-    )
-    
-    output_payload = result.get("output", "")
-    output_str = ""
-
-
-    if isgenerator(output_payload):
-        output_str = print_and_process_stream_with_markdown(output_payload, shell_state.chat_model, shell_state.chat_provider)
-    elif isinstance(output_payload, dict):
-        output_str = output_payload.get('output', str(output_payload))
-        if 'output' in output_str:
-            output_str = output_payload['output']
-        elif 'response' in output_str:
-            output_str = output_payload['response']
-        render_markdown(output_str)
-    elif output_payload:
-        output_str = str(output_payload)
-        render_markdown(output_str)
-
-    user_feedback = input(f"\nTodo completed successfully? [y/N/notes]: ").strip()
-    
-    if user_feedback.lower() in ['y', 'yes']:
-        return True, output_str
-    elif user_feedback.lower() in ['n', 'no']:
-        mistake = input("What went wrong? ").strip()
-        ride_state.mistakes.append(f"Failed {todo}: {mistake}")
-        return False, output_str
-    else:
-        ride_state.facts.append(f"Re: {todo}: {user_feedback}")
-        success = input("Mark as completed? [y/N]: ").strip().lower() in ['y', 'yes']
-        return success, output_str
-
-def agentic_ride_loop(user_goal: str, state: ShellState) -> tuple:
-    """
-    New /ride mode: hierarchical planning with human-in-the-loop control
-    """
-    ride_state = RideState()
-    
-    # 1. Generate high-level todos
-    print("🚀 Generating high-level todos...")
-    todos = generate_todos(user_goal, state)
-    
-    # 2. User reviews/edits todos
-    print("\n📋 Review and edit todos:")
-    todo_descriptions = [todo for todo in todos]
-    edited_descriptions = interactive_edit_list(todo_descriptions, "todos")
-    
-
-    ride_state.todos = edited_descriptions
-    
-    # 3. Generate constraints
-    print("\n🔒 Generating constraints...")
-    constraints = generate_constraints(edited_descriptions, user_goal, state)
-    
-    # 4. User reviews/edits constraints
-    print("\n📐 Review and edit constraints:")
-    edited_constraints = interactive_edit_list(constraints, "constraints")
-    ride_state.constraints = edited_constraints
-    
-    # 5. Execution loop
-    print("\n⚡ Starting execution...")
-    
-    for i, todo in enumerate(edited_descriptions):
-        print(f"\n--- Todo {i+1}/{len(todos)}: {todo} ---")
-        
-        def attempt_execution(current_todo):
-            # This inner function handles the execution and retry logic
-            success, output_str = execute_todo_item(current_todo, ride_state, state)
-            if not success:
-                retry = input("Retry this todo? [y/N]: ").strip().lower()
-                if retry in ['y', 'yes']:
-                    success, output_str = execute_todo_item(current_todo, ride_state, state)
-            return success, output_str
-
-        if should_break_down_todo(todo, state):
-            print("Breaking down todo...")
-            subtodos = generate_subtodos(todo, state)
-            subtodo_descriptions = [st for st in subtodos]
-            edited_subtodos = interactive_edit_list(subtodo_descriptions, "subtodos")
-
-            for j, subtodo_desc in enumerate(edited_subtodos):
-                subtodo = {"description": subtodo_desc, "type": "atomic"}
-                success, output = attempt_execution(subtodo)
-                if success:
-                    ride_state.successes.append({"description": subtodo_desc, "output": output})
-                else:
-                    print("Subtodo failed. Continuing to next...")
-        else:
-            success, output = attempt_execution(todo)
-            if success:
-                ride_state.successes.append({"description": todo, "output": output})
-    # 6. Final summary
-    print("\n🎯 Execution Summary:")
-    print(f"Successes: {len(ride_state.successes)}")
-    print(f"Mistakes: {len(ride_state.mistakes)}")
-    print(f"Facts learned: {len(ride_state.facts)}")
-    
-    return state, {
-        "todos_completed": len(ride_state.successes),
-        "ride_state": ride_state,
-        "final_context": ride_state.get_context_summary()
-    }
-# --- Main Application Logic ---
 
 def check_deprecation_warnings():
     if os.getenv("NPCSH_MODEL"):
@@ -1305,6 +1070,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)
@@ -1470,20 +1242,24 @@ def process_result(
 
     final_output_str = None
     output_content = output.get('output') if isinstance(output, dict) else output
-    
-    if result_state.stream_output and isgenerator(output_content):
-        final_output_str = print_and_process_stream_with_markdown(output_content, active_npc.model, active_npc.provider)
+    model_for_stream = output.get('model', active_npc.model) if isinstance(output, dict) else active_npc.model
+    provider_for_stream = output.get('provider', active_npc.provider) if isinstance(output, dict) else active_npc.provider
+
+    print('\n')
+    if user_input =='/help':
+        render_markdown(output.get('output'))
+    elif result_state.stream_output:
+
+
+        final_output_str = print_and_process_stream_with_markdown(output_content, model_for_stream, provider_for_stream)
     elif output_content is not None:
         final_output_str = str(output_content)
         render_markdown(final_output_str)
 
-    # --- Part 2: Process Output and Evolve Knowledge ---
     if final_output_str:
-        # Append assistant message to state for context continuity
+
         if result_state.messages and (not result_state.messages or result_state.messages[-1].get("role") != "assistant"):
             result_state.messages.append({"role": "assistant", "content": final_output_str})
-
-        # Save assistant message to the database
         save_conversation_message(
             command_history,
             result_state.conversation_id,
@@ -1496,50 +1272,68 @@ def process_result(
             team=team_name,
         )
 
-        # --- Hierarchical Knowledge Graph Evolution ---
         conversation_turn_text = f"User: {user_input}\nAssistant: {final_output_str}"
-        conn = command_history.conn
+        engine = command_history.engine
 
-        try:
 
-            npc_kg = load_kg_from_db(conn, team_name, npc_name, "__npc_global__")
-            evolved_npc_kg, _ = kg_evolve_incremental(
-                existing_kg=npc_kg, new_content_text=conversation_turn_text,
-                model=active_npc.model, provider=active_npc.provider
-            )
-            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)
-                key_facts = summary.get('output', {}).get('facts', [])
+                summary = breathe(messages=result_state.messages[-20:], 
+                                npc=active_npc)
+                characterization = summary.get('output')
 
-                if key_facts and result_state.team:
+                if characterization and result_state.team:
                     team_ctx_path = os.path.join(result_state.team.team_path, "team.ctx")
                     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 these key topics: {key_facts},
+                    prompt = f"""Based on this characterization: {characterization},
+
                     suggest changes (additions, deletions, edits) to the team's context. 
                     Additions need not be fully formed sentences and can simply be equations, relationships, or other plain clear items.
                     
                     Current Context: "{current_context}". 
                     
-                    Respond with JSON: {{"suggestion": "Your sentence."}}"""
+                    Respond with JSON: {{"suggestion": "Your sentence."
+                    }}"""
                     response = get_llm_response(prompt, npc=active_npc, format="json")
                     suggestion = response.get("response", {}).get("suggestion")
 
                     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
@@ -1560,7 +1354,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
     print_welcome_message()
 
 
-    render_markdown(f'- Using {state.current_mode} mode. Use /agent, /cmd, /chat, or /ride to switch to other modes')
+    render_markdown(f'- Using {state.current_mode} mode. Use /agent, /cmd, or /chat to switch to other modes')
     render_markdown(f'- To switch to a different NPC, type /npc <npc_name> or /n <npc_name> to switch to that NPC.')
     render_markdown('\n- Here are the current NPCs available in your team: ' + ', '.join([npc_name for npc_name in state.team.npcs.keys()]))
 
@@ -1582,7 +1376,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
         print("\nGoodbye!")
         print(colored("Processing and archiving all session knowledge...", "cyan"))
         
-        conn = command_history.conn
+        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
@@ -1606,18 +1400,23 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                     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
+                    provider=integrator_npc.provider, 
+                    get_concepts=True,
+                    link_concepts_facts = True, 
+                    link_concepts_concepts = True, 
+                    link_facts_facts = True, 
+
                 )
                 
                 # 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
@@ -1675,7 +1474,9 @@ 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, output, command_history)
+            process_result(user_input, state, 
+                           output, 
+                           command_history)
         
         except KeyboardInterrupt:
             if is_windows:
@@ -1702,8 +1503,7 @@ def main() -> None:
 
     initial_state.npc = default_npc 
     initial_state.team = team
-    #import pdb 
-    #pdb.set_trace()
+
 
     # add a -g global command to indicate if to use the global or project, otherwise go thru normal flow
     
@@ -1711,8 +1511,9 @@ def main() -> None:
          state = initial_state
          state.current_path = os.getcwd()
          final_state, output = execute_command(args.command, state)
-         if final_state.stream_output and isgenerator(output):
-              for chunk in output: print(str(chunk), end='')
+         if final_state.stream_output:
+              for chunk in output: 
+                  print(str(chunk), end='')
               print()
          elif output is not None:
               print(output)