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

npcsh/routes.py

@@ -3,6 +3,10 @@
 from typing import Callable, Dict, Any, List, Optional, Union
 import functools
 import os
+import subprocess
+import sys
+from pathlib import Path
+
 import traceback
 import shlex
 import time
@@ -18,7 +22,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 +32,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
 
@@ -38,6 +40,7 @@ from npcpy.memory.knowledge_graph import kg_sleep_process, kg_dream_process
 from npcsh._state import (
     NPCSH_VISION_MODEL, 
     NPCSH_VISION_PROVIDER, 
+    set_npcsh_config_value,
     NPCSH_API_URL,
     NPCSH_CHAT_MODEL, 
     NPCSH_CHAT_PROVIDER, 
@@ -55,15 +58,20 @@ from npcsh._state import (
     normalize_and_expand_flags, 
     get_argument_help
 )
+from npcsh.corca import enter_corca_mode
 from npcsh.guac import enter_guac_mode
 from npcsh.plonk import execute_plonk_command, format_plonk_summary
 from npcsh.alicanto import alicanto
+from npcsh.pti import enter_pti_mode
 from npcsh.spool import enter_spool_mode
 from npcsh.wander import enter_wander_mode
 from npcsh.yap import enter_yap_mode
 
 
 
+NPC_STUDIO_DIR = Path.home() / ".npcsh" / "npc-studio"
+
+
 class CommandRouter:
     def __init__(self):
         self.routes = {}
@@ -222,6 +230,10 @@ def compile_handler(command: str, **kwargs):
 
 
 
+@router.route("corca", "Enter the Corca MCP-powered agentic shell. Usage: /corca [--mcp-server-path path]")
+def corca_handler(command: str, **kwargs):
+    return enter_corca_mode(command=command, **kwargs)
+    
 @router.route("flush", "Flush the last N messages")
 def flush_handler(command: str, **kwargs):
     messages = safe_get(kwargs, "messages", [])
@@ -279,7 +291,8 @@ def guac_handler(command,  **kwargs):
     team = Team(npc_team_dir, db_conn=db_conn)
 
     
-    enter_guac_mode(npc=npc, 
+    enter_guac_mode(workspace_dirs,
+                    npc=npc, 
                     team=team, 
                     config_dir=config_dir, 
                     plots_dir=plots_dir,
@@ -370,9 +383,77 @@ def init_handler(command: str, **kwargs):
         output = f"Error initializing project: {e}"
     return {"output": output, "messages": messages}
 
+def ensure_repo():
+    """Clone or update the npc-studio repo."""
+    if not NPC_STUDIO_DIR.exists():
+        os.makedirs(NPC_STUDIO_DIR.parent, exist_ok=True)
+        subprocess.check_call([
+            "git", "clone",
+            "https://github.com/npc-worldwide/npc-studio.git",
+            str(NPC_STUDIO_DIR)
+        ])
+    else:
+        subprocess.check_call(
+            ["git", "pull"],
+            cwd=NPC_STUDIO_DIR
+        )
 
+def install_dependencies():
+    """Install npm and pip dependencies."""
+    # Install frontend deps
+    subprocess.check_call(["npm", "install"], cwd=NPC_STUDIO_DIR)
 
+    # Install backend deps
+    req_file = NPC_STUDIO_DIR / "requirements.txt"
+    if req_file.exists():
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", str(req_file)])
+def launch_npc_studio(path_to_open: str = None):
+    """
+    Launch the NPC Studio backend + frontend.
+    Returns PIDs for processes.
+    """
+    ensure_repo()
+    install_dependencies()
+
+    # Start backend (Flask server)
+    backend = subprocess.Popen(
+        [sys.executable, "npc_studio_serve.py"],
+        cwd=NPC_STUDIO_DIR, 
+        shell = False
+    )
+
+    # Start server (Electron)
+    dev_server = subprocess.Popen(
+        ["npm", "run", "dev"],
+        cwd=NPC_STUDIO_DIR,
+        shell=False
+    )
+    
+    # Start frontend (Electron)
+    frontend = subprocess.Popen(
+        ["npm", "start"],
+        cwd=NPC_STUDIO_DIR,
+        shell=False
+    )
+
+    return backend, dev_server, frontend
+# ========== Router handler ==========
+@router.route("npc-studio", "Start npc studio")
+def npc_studio_handler(command: str, **kwargs):
+    messages = kwargs.get("messages", [])
+    user_command = " ".join(command.split()[1:])
 
+    try:
+        backend, electron, frontend = launch_npc_studio(user_command or None)
+        return {
+            "output": f"NPC Studio started!\nBackend PID={backend.pid}, Electron PID={electron.pid} Frontend PID={frontend.pid}",
+            "messages": messages
+        }
+    except Exception as e:
+        return {
+            "output": f"Failed to start NPC Studio: {e}",
+            "messages": messages
+        }
 @router.route("ots", "Take screenshot and analyze with vision model")
 def ots_handler(command: str, **kwargs):
     command_parts = command.split()
@@ -440,23 +521,25 @@ def ots_handler(command: str, **kwargs):
         return {"output": f"Error during /ots command: {e}", "messages": messages}
 
 
+
+
 @router.route("plan", "Execute a plan command")
 def plan_handler(command: str, **kwargs):
     messages = safe_get(kwargs, "messages", [])
     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)
 
-@router.route("pti", "Use pardon-the-interruption mode to interact with the LLM")
+    #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", "Enter Pardon-The-Interruption mode for human-in-the-loop reasoning.")
 def pti_handler(command: str, **kwargs):
-    return
+    return enter_pti_mode(command=command, **kwargs)
 
 @router.route("plonk", "Use vision model to interact with GUI. Usage: /plonk <task description>")
 def plonk_handler(command: str, **kwargs):
@@ -500,17 +583,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 +605,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}
@@ -831,29 +910,18 @@ def sleep_handler(command: str, **kwargs):
 @router.route("spool", "Enter interactive chat (spool) mode")
 def spool_handler(command: str, **kwargs):
     try:
-        # Handle NPC loading if npc is passed as a string (name)
         npc = safe_get(kwargs, 'npc')
         team = safe_get(kwargs, 'team')
         
-        # If npc is a string, try to load it from the team
         if isinstance(npc, str) and team:
             npc_name = npc
             if npc_name in team.npcs:
                 npc = team.npcs[npc_name]
             else:
                 return {"output": f"Error: NPC '{npc_name}' not found in team. Available NPCs: {', '.join(team.npcs.keys())}", "messages": safe_get(kwargs, "messages", [])}
-        
-        return enter_spool_mode(
-            model=safe_get(kwargs, 'model', NPCSH_CHAT_MODEL),
-            provider=safe_get(kwargs, 'provider', NPCSH_CHAT_PROVIDER),
-            npc=npc,  
-            team=team, 
-            messages=safe_get(kwargs, 'messages'),
-            conversation_id=safe_get(kwargs, 'conversation_id'),
-            stream=safe_get(kwargs, 'stream', NPCSH_STREAM_OUTPUT),
-            attachments=safe_get(kwargs, 'attachments'),
-            rag_similarity_threshold = safe_get(kwargs, 'rag_similarity_threshold', 0.3), 
-        )
+        kwargs['npc'] = npc
+        return enter_spool_mode(            
+                                **kwargs)
     except Exception as e:
         traceback.print_exc()
         return {"output": f"Error entering spool mode: {e}", "messages": safe_get(kwargs, "messages", [])}
@@ -913,13 +981,15 @@ def vixynt_handler(command: str, **kwargs):
     width = safe_get(kwargs, 'width', 1024)
     output_file = safe_get(kwargs, 'output_file')
     attachments = safe_get(kwargs, 'attachments')
+    if isinstance(attachments, str):
+        attachments = attachments.split(',')
+    
     messages = safe_get(kwargs, 'messages', [])
 
     user_prompt = " ".join(safe_get(kwargs, 'positional_args', []))
 
     if not user_prompt:
         return {"output": "Usage: /vixynt <prompt> [--output_file path] [--attachments path]", "messages": messages}
-
     try:
         image = gen_image(
             prompt=user_prompt,

npcsh/spool.py

@@ -4,174 +4,126 @@ from npcpy.data.image import capture_screenshot
 from npcpy.data.text import rag_search
 
 import os
+import sys
 from npcpy.npc_sysenv import (    
     print_and_process_stream_with_markdown,
+    get_system_message, 
+    render_markdown,
 )
-from npcpy.npc_sysenv import (
-        get_system_message, 
-        render_markdown,
-
-)
-from npcsh._state import    (
+from npcsh._state import (
     orange, 
-    NPCSH_VISION_MODEL, 
-    NPCSH_VISION_PROVIDER, 
-    NPCSH_CHAT_MODEL,
-    NPCSH_CHAT_PROVIDER,
-    NPCSH_STREAM_OUTPUT
+    ShellState,
+    execute_command,
+    get_multiline_input,
+    readline_safe_prompt,
+    setup_shell,
+    get_npc_path,
+    process_result,
+    initial_state,
 )
-from npcpy.llm_funcs import (get_llm_response,)
-
+from npcpy.llm_funcs import get_llm_response
 from npcpy.npc_compiler import NPC
 from typing import Any, List, Dict, Union
 from npcsh.yap import enter_yap_mode
-
-
+from termcolor import colored
+def print_spool_ascii():
+    spool_art = """
+ ██████╗██████╗  ████████╗   ████████╗  ██╗     
+██╔════╝██╔══██╗██╔🧵🧵🧵██ ██╔🧵🧵🧵██ ██║     
+╚█████╗ ██████╔╝██║🧵🔴🧵██ ██║🧵🔴🧵██ ██║     
+ ╚═══██╗██╔═══╝ ██║🧵🧵🧵██ ██║🧵🧵🧵██ ██║     
+██████╔╝██║     ██╚══════██ ██ ══════██ ██║
+╚═════╝ ╚═╝     ╚═████████   ███████═╝ █████████╗
+"""
+    print(spool_art)
 def enter_spool_mode(
     npc: NPC = None,    
     team = None,
     model: str = None, 
     provider: str = None,
-    vision_model:str = None,
-    vision_provider:str = None,
+    vmodel: str = None,
+    vprovider: str = None,
     attachments: List[str] = None,
     rag_similarity_threshold: float = 0.3,
     messages: List[Dict] = None,
     conversation_id: str = None,
-    stream: bool = NPCSH_STREAM_OUTPUT,
+    stream: bool = None,
     **kwargs,
 ) -> Dict:
+    print_spool_ascii()
+    # Initialize state using existing infrastructure
+    command_history, state_team, default_npc = setup_shell()
     
-    session_model = model or (npc.model if npc else NPCSH_CHAT_MODEL)
-    session_provider = provider or (npc.provider if npc else NPCSH_CHAT_PROVIDER)
-    session_vision_model = vision_model or NPCSH_VISION_MODEL
-    session_vision_provider = vision_provider or NPCSH_VISION_PROVIDER
-
-    npc_info = f" (NPC: {npc.name})" if npc else ""
-    print(f"Entering spool mode{npc_info}. Type '/sq' to exit spool mode.")
+    # Create spool state, inheriting from initial_state
+    spool_state = ShellState(
+        npc=npc or default_npc,
+        team=team or state_team,
+        messages=messages.copy() if messages else [],
+        conversation_id=conversation_id or start_new_conversation(),
+        current_path=os.getcwd(),
+        stream_output=stream if stream is not None else initial_state.stream_output,
+        attachments=None,
+    )
+    
+    # Override models/providers if specified
+    if model:
+        spool_state.chat_model = model
+    if provider:
+        spool_state.chat_provider = provider
+    if vmodel:
+        spool_state.vision_model = vmodel
+    if vprovider:
+        spool_state.vision_provider = vprovider
+
+    npc_info = f" (NPC: {spool_state.npc.name})" if spool_state.npc else ""
+    print(f"🧵 Entering spool mode{npc_info}. Type '/sq' to exit spool mode.")
     print("💡 Tip: Press Ctrl+C during streaming to interrupt and continue with a new message.")
 
-    spool_context = messages.copy() if messages else []
+    # Handle file loading
     loaded_chunks = {}
-
-    if not conversation_id:
-        conversation_id = start_new_conversation()
-
-    command_history = CommandHistory()
-    
-    files_to_load = attachments
-    if files_to_load:
-        if isinstance(files_to_load, str):
-            files_to_load = [f.strip() for f in files_to_load.split(',')]
+    if attachments:
+        if isinstance(attachments, str):
+            attachments = [f.strip() for f in attachments.split(',')]
         
-        for file_path in files_to_load:
+        for file_path in attachments:
             file_path = os.path.expanduser(file_path)
             if not os.path.exists(file_path):
-                print(f"Error: File not found at {file_path}")
+                print(colored(f"Error: File not found at {file_path}", "red"))
                 continue
             try:
                 chunks = load_file_contents(file_path)
                 loaded_chunks[file_path] = chunks
-                print(f"Loaded {len(chunks)} chunks from: {file_path}")
+                print(colored(f"Loaded {len(chunks)} chunks from: {file_path}", "green"))
             except Exception as e:
-                print(f"Error loading {file_path}: {str(e)}")
-
-    system_message = get_system_message(npc) if npc else "You are a helpful assistant."
-    if not spool_context or spool_context[0].get("role") != "system":
-        spool_context.insert(0, {"role": "system", "content": system_message})
-
-    if loaded_chunks:
-        initial_file_context = "\n\n--- The user has loaded the following files for this session ---\n"
-        for filename, chunks in loaded_chunks.items():
-            initial_file_context += f"\n\n--- Start of content from {filename} ---\n"
-            initial_file_context += "\n".join(chunks)
-            initial_file_context += f"\n--- End of content from {filename} ---\n"
-
-    def _handle_llm_interaction(
-        prompt, 
-        current_context, 
-        model_to_use, 
-        provider_to_use, 
-        images_to_use=None
-    ):
-        
-        current_context.append({"role": "user", "content": prompt})
+                print(colored(f"Error loading {file_path}: {str(e)}", "red"))
 
-        save_conversation_message(
-            command_history, 
-            conversation_id, 
-            "user", 
-            prompt,
-            wd=os.getcwd(), 
-            model=model_to_use, 
-            provider=provider_to_use,
-            npc=npc.name if npc else None, 
-            team=team.name if team else None,
-        )
-        
-        assistant_reply = ""
-        
-        try:
-            response = get_llm_response(
-                prompt,
-                model=model_to_use, 
-                provider=provider_to_use,
-                messages=current_context, 
-                images=images_to_use, 
-                stream=stream, 
-                npc=npc
-            )
-            assistant_reply = response.get('response')
-
-            if stream:
-                print(orange(f'{npc.name if npc else "🧵"}....> '), end='', flush=True)
-                
-                # The streaming function now handles KeyboardInterrupt internally
-                assistant_reply = print_and_process_stream_with_markdown(
-                    assistant_reply, 
-                    model=model_to_use, 
-                    provider=provider_to_use
-                )
-            else:
-                render_markdown(assistant_reply)
-        
-        except Exception as e:
-            assistant_reply = f"[Error during response generation: {str(e)}]"
-            print(f"\n❌ Error: {str(e)}")
-        
-        current_context.append({"role": "assistant", "content": assistant_reply})
-        
-        if assistant_reply and assistant_reply.count("```") % 2 != 0:
-            assistant_reply += "```"
-
-        save_conversation_message(
-            command_history, 
-            conversation_id, 
-            "assistant", 
-            assistant_reply,
-            wd=os.getcwd(), 
-            model=model_to_use, 
-            provider=provider_to_use,
-            npc=npc.name if npc else None, 
-            team=team.name if team else None,
-        )
-        
-        return current_context
+    # Initialize context with system message if needed
+    if not spool_state.messages or spool_state.messages[0].get("role") != "system":
+        system_message = get_system_message(spool_state.npc) if spool_state.npc else "You are a helpful assistant."
+        spool_state.messages.insert(0, {"role": "system", "content": system_message})
 
     while True:
         try:
-            prompt_text = orange(f"🧵:{npc.name if npc else 'chat'}:{session_model}> ")
-            user_input = input(prompt_text).strip()
+            # Use consistent prompt styling with npcsh
+            npc_name = spool_state.npc.name if spool_state.npc else "chat"
+            display_model = spool_state.npc.model if spool_state.npc and spool_state.npc.model else spool_state.chat_model
+            
+            prompt_str = f"{orange(npc_name)}:{display_model}🧵> "
+            prompt = readline_safe_prompt(prompt_str)
+            user_input = get_multiline_input(prompt).strip()
 
             if not user_input:
                 continue
+                
             if user_input.lower() == "/sq":
                 print("Exiting spool mode.")
                 break
+                
             if user_input.lower() == "/yap":
-                spool_context = enter_yap_mode(spool_context, npc)
+                spool_state.messages = enter_yap_mode(spool_state.messages, spool_state.npc)
                 continue
 
+            # Handle vision commands
             if user_input.startswith("/ots"):
                 command_parts = user_input.split()
                 image_paths = []
@@ -179,26 +131,42 @@ def enter_spool_mode(
                 if len(command_parts) > 1:
                     for img_path in command_parts[1:]:
                         full_path = os.path.expanduser(img_path)
-                        if os.path.exists(full_path): image_paths.append(full_path)
-                        else: print(f"Error: Image file not found at {full_path}")
+                        if os.path.exists(full_path): 
+                            image_paths.append(full_path)
+                        else: 
+                            print(colored(f"Error: Image file not found at {full_path}", "red"))
                 else:
                     screenshot = capture_screenshot()
                     if screenshot and "file_path" in screenshot:
                         image_paths.append(screenshot["file_path"])
-                        print(f"Screenshot captured: {screenshot['filename']}")
+                        print(colored(f"Screenshot captured: {screenshot['filename']}", "green"))
                 
-                if not image_paths: continue
+                if not image_paths: 
+                    continue
                 
                 vision_prompt = input("Prompt for image(s) (or press Enter): ").strip() or "Describe these images."
-                spool_context = _handle_llm_interaction(
-                    vision_prompt, 
-                    spool_context, 
-                    session_vision_model, 
-                    session_vision_provider, 
-                    images_to_use=image_paths
+                
+                # Use vision models for image processing
+                response = get_llm_response(
+                    vision_prompt,
+                    model=spool_state.vision_model,
+                    provider=spool_state.vision_provider,
+                    messages=spool_state.messages,
+                    images=image_paths,
+                    stream=spool_state.stream_output,
+                    npc=spool_state.npc, 
+                    **kwargs
+                    
                 )
+                
+                spool_state.messages = response.get('messages', spool_state.messages)
+                output = response.get('response')
+                
+                # Process and display the result
+                process_result(vision_prompt, spool_state, {'output': output}, command_history)
                 continue
             
+            # Handle RAG context if files are loaded
             current_prompt = user_input
             if loaded_chunks:
                 context_content = ""
@@ -214,24 +182,32 @@ def enter_spool_mode(
                 
                 if context_content:
                     current_prompt += f"\n\n--- Relevant context from loaded files ---\n{context_content}"
-                print(f'prepped  context_content : {context_content}')
             
-            spool_context = _handle_llm_interaction(
-                current_prompt, 
-                spool_context, 
-                session_model, 
-                session_provider
+            # Use standard LLM processing
+            response = get_llm_response(
+                current_prompt,
+                model=spool_state.npc.model if spool_state.npc and spool_state.npc.model else spool_state.chat_model,
+                provider=spool_state.npc.provider if spool_state.npc and spool_state.npc.provider else spool_state.chat_provider,
+                messages=spool_state.messages,
+                stream=spool_state.stream_output,
+                npc=spool_state.npc, 
+                **kwargs
             )
+            
+            spool_state.messages = response.get('messages', spool_state.messages)
+            output = response.get('response')
+            
+            # Use existing result processing
+            process_result(current_prompt, spool_state, {'output': output}, command_history)
 
         except (EOFError,):
             print("\nExiting spool mode.")
             break
         except KeyboardInterrupt:
-            # This handles Ctrl+C at the input prompt (not during streaming)
             print("\n🔄 Use '/sq' to exit or continue with a new message.")
             continue
 
-    return {"messages": spool_context, "output": "Exited spool mode."}
+    return {"messages": spool_state.messages, "output": "Exited spool mode."}
 
 
 def main():
@@ -241,14 +217,32 @@ def main():
     parser.add_argument("--provider", help="Provider to use")
     parser.add_argument("--attachments", nargs="*", help="Files to load into context")
     parser.add_argument("--stream", default="true", help="Use streaming mode")
-    parser.add_argument("--npc", type=str, default=os.path.expanduser('~/.npcsh/npc_team/sibiji.npc'), help="Path to NPC file")
+    parser.add_argument("--npc", type=str, help="NPC name or path to NPC file", default='sibiji',)
     
     args = parser.parse_args()
     
-    npc = NPC(file=args.npc) if os.path.exists(os.path.expanduser(args.npc)) else None
+    # Use existing infrastructure to get NPC
+    command_history, team, default_npc = setup_shell()
+    
+    npc = None
+    if args.npc:
+        if os.path.exists(os.path.expanduser(args.npc)):
+            npc = NPC(file=args.npc)
+        elif team and args.npc in team.npcs:
+            npc = team.npcs[args.npc]
+        else:
+            try:
+                npc_path = get_npc_path(args.npc, command_history.db_path)
+                npc = NPC(file=npc_path)
+            except ValueError:
+                print(colored(f"NPC '{args.npc}' not found. Using default.", "yellow"))
+                npc = default_npc
+    else:
+        npc = default_npc
 
     enter_spool_mode(
         npc=npc,
+        team=team,
         model=args.model,
         provider=args.provider,
         attachments=args.attachments,