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

npcsh/pti.py

@@ -1,234 +1,214 @@
+import os
+import sys
+import shlex
+import argparse
+from typing import Dict, List, Any, Optional
+
+from termcolor import colored
+
+from npcpy.memory.command_history import CommandHistory, save_conversation_message
+from npcpy.npc_sysenv import (
+    render_markdown
+)
+from npcpy.llm_funcs import get_llm_response
+from npcpy.npc_compiler import NPC
+from npcpy.data.load import load_file_contents
+
+from npcsh._state import (
+    ShellState,
+    setup_shell,
+    get_multiline_input,
+    readline_safe_prompt, 
+    get_npc_path
+)
+
+ice = "🧊"
+bear = "🐻‍❄️"
+def print_pti_welcome_message():
+    
+    print(f"""
+Welcome to PTI Mode!
 
-# pti
-import json 
-from typing import Dict, List, Optional, Any, Generator 
-import os 
-from npcpy.memory.command_history import CommandHistory, save_attachment_to_message, start_new_conversation,save_conversation_message
-from npcpy.npc_sysenv import (NPCSH_REASONING_MODEL,
-                              NPCSH_REASONING_PROVIDER, 
-                              NPCSH_CHAT_MODEL, 
-                              NPCSH_CHAT_PROVIDER, 
-                              NPCSH_API_URL, 
-                              NPCSH_STREAM_OUTPUT,print_and_process_stream_with_markdown)
-from npcpy.llm_funcs import get_llm_response, handle_request_input
-
-from npcpy.npc_compiler import NPC 
-from npcpy.data.load import load_csv, load_pdf
-from npcpy.data.text import rag_search
-
-
-
-
-
-
-def enter_reasoning_human_in_the_loop(
-    user_input=None,
-    messages: List[Dict[str, str]] = None,
-    reasoning_model: str = NPCSH_REASONING_MODEL,
-    reasoning_provider: str = NPCSH_REASONING_PROVIDER,
-    files : List = None, 
-    npc: Any = None,
-    conversation_id : str= False,
-    answer_only: bool = False,
-    context=None,
-) :
-    """
-    Stream responses while checking for think tokens and handling human input when needed.
-
-    Args:
-        messages: List of conversation messages
-        model: LLM model to use
-        provider: Model provider
-        npc: NPC instance if applicable
-
-    """
-    # Get the initial stream
-    loaded_content = {}  # New dictionary to hold loaded content
-
-    # Create conversation ID if not provided
-    if not conversation_id:
-        conversation_id = start_new_conversation()
-
-    command_history = CommandHistory()
-    # Load specified files if any
-    if files:
-        for file in files:
-            extension = os.path.splitext(file)[1].lower()
-            try:
-                if extension == ".pdf":
-                    content = load_pdf(file)["texts"].iloc[0]
-                elif extension == ".csv":
-                    content = load_csv(file)
-                else:
-                    print(f"Unsupported file type: {file}")
-                    continue
-                loaded_content[file] = content
-                print(f"Loaded content from: {file}")
-            except Exception as e:
-                print(f"Error loading {file}: {str(e)}")
+{ice}{ice}{ice}   {ice}{ice}{ice}   {bear}
+{ice}  {ice}     {ice}     {bear}
+{ice}{ice}{ice}     {ice}     {bear}
+{ice}         {ice}     {bear}
+{ice}         {ice}     {bear}
+
+Pardon-The-Interruption for human-in-the-loop reasoning.
+Type 'exit' or 'quit' to return to the main shell.
+        """)
+
+def enter_pti_mode(command: str, **kwargs):
+    state: ShellState = kwargs.get('shell_state')
+    command_history: CommandHistory = kwargs.get('command_history')
 
+    if not state or not command_history:
+        return {"output": "Error: PTI mode requires shell state and history.", "messages": kwargs.get('messages', [])}
 
+    all_command_parts = shlex.split(command)
+    parsed_args_list = all_command_parts[1:]
+    
+    parser = argparse.ArgumentParser(prog="/pti", description="Enter PTI mode for human-in-the-loop reasoning.")
+    parser.add_argument('initial_prompt', nargs='*', help="Initial prompt to start the session.")
+    parser.add_argument("-f", "--files", nargs="*", default=[], help="Files to load into context.")
+    
     try:
-        while True:
+        args = parser.parse_args(parsed_args_list)
+    except SystemExit:
+         return {"output": "Invalid arguments for /pti. Usage: /pti [initial prompt] [-f file1 file2 ...]", "messages": state.messages}
 
-            if loaded_content:
-                context_content = ""
-                for filename, content in loaded_content.items():
-                    retrieved_docs = rag_search(
-                        user_input,
-                        content,
-                    )
-                    if retrieved_docs:
-                        context_content += (
-                            f"\n\nLoaded content from: {filename}\n{content}\n\n"
-                        )
-                if len(context_content) > 0:
-                    user_input += f"""
-                    Here is the loaded content that may be relevant to your query:
-                        {context_content}
-                    Please reference it explicitly in your response and use it for answering.
-                    """
-            if answer_only:
-                response = get_llm_response(
-                user_input, 
-                model = reasoning_model, 
-                provider=reasoning_provider, 
-                messages=messages, 
-                stream=True,
-                )
-                assistant_reply, messages = response['response'], response['messages']
-                assistant_reply = print_and_process_stream_with_markdown(assistant_reply, reasoning_model, reasoning_provider)
-                messages.append({'role':'assistant', 'content':assistant_reply})
-                return enter_reasoning_human_in_the_loop(user_input = None, 
-                                                         messages=messages, 
-                                                         reasoning_model=reasoning_model, 
-                                                         reasoning_provider=reasoning_provider, answer_only=False)
-            else:
-                message= "Think first though and use <think> tags in your chain of thought. Once finished, either answer plainly or write a request for input by beginning with the <request_for_input> tag. and close it with a </request_for_input>"
-                if user_input is None:
-                    user_input = input('🐻‍❄️>')
+    print_pti_welcome_message()
+
+    frederic_path = get_npc_path("frederic", command_history.db_path)
+    state.npc = NPC(file=frederic_path)
+    print(colored("Defaulting to NPC: frederic", "cyan"))
+    state.npc = NPC(name="frederic")
+
+    pti_messages = list(state.messages)
+    loaded_content = {}
+    
+    if args.files:
+        for file_path in args.files:
+            try:
+                content_chunks = load_file_contents(file_path)
+                loaded_content[file_path] = "\n".join(content_chunks)
+                print(colored(f"Successfully loaded content from: {file_path}", "green"))
+            except Exception as e:
+                print(colored(f"Error loading {file_path}: {e}", "red"))
+    
+    user_input = " ".join(args.initial_prompt)
+
+    while True:
+        try:
+            if not user_input:
+                npc_name = state.npc.name if state.npc and isinstance(state.npc, NPC) else "frederic"
+                model_name = state.reasoning_model
                 
-                message_id = save_conversation_message(
-                    command_history,
-                    conversation_id,
-                    "user",
-                    user_input,
-                    wd=os.getcwd(),
-                    model=reasoning_model,
-                    provider=reasoning_provider,
-                    npc=npc.name if npc else None,
-                    
-                )                    
-                response = get_llm_response(
-                    user_input+message, 
-                    model = reasoning_model, 
-                    provider=reasoning_provider, 
-                    messages=messages, 
+                prompt_str = f"{colored(os.path.basename(state.current_path), 'blue')}:{npc_name}:{model_name}{bear}> "
+                prompt = readline_safe_prompt(prompt_str)
+                user_input = get_multiline_input(prompt).strip()
+
+            if user_input.lower() in ["exit", "quit", "done"]:
+                break
+            
+            if not user_input:
+                continue
+            
+            prompt_for_llm = user_input
+            if loaded_content:
+                context_str = "\n".join([f"--- Content from {fname} ---\n{content}" for fname, content in loaded_content.items()])
+                prompt_for_llm += f"\n\nUse the following context to inform your answer:\n{context_str}"
+            
+            prompt_for_llm += "\n\nThink step-by-step using <think> tags. When you need more information from me, enclose your question in <request_for_input> tags."
+
+            save_conversation_message(
+                command_history,
+                state.conversation_id,
+                "user",
+                user_input,
+                wd=state.current_path,
+                model=state.reasoning_model,
+                provider=state.reasoning_provider,
+                npc=state.npc.name if isinstance(state.npc, NPC) else None,
+            )
+            pti_messages.append({"role": "user", "content": user_input})
+
+            try:
+                response_dict = get_llm_response(
+                    prompt=prompt_for_llm,
+                    model=state.reasoning_model,
+                    provider=state.reasoning_provider,
+                    messages=pti_messages,
                     stream=True,
+                    npc=state.npc
                 )
-
-                assistant_reply, messages = response['response'], response['messages']
-                thoughts = []
+                stream = response_dict.get('response')
+                
                 response_chunks = []
-                in_think_block = False # the thinking chain generated after reasoning
+                request_found = False
                 
-                thinking = False # the reasoning content 
+                for chunk in stream:
+                    chunk_content = ""
+                    if state.reasoning_provider == "ollama":
+                        chunk_content = chunk.get("message", {}).get("content", "")
+                    else:
+                        chunk_content = "".join(
+                            choice.delta.content
+                            for choice in chunk.choices
+                            if choice.delta.content is not None
+                        )
+
+                    print(chunk_content, end='')
+                    sys.stdout.flush()
+                    response_chunks.append(chunk_content)
+                    
+                    combined_text = "".join(response_chunks)
+                    if "</request_for_input>" in combined_text:
+                        request_found = True
+                        break
+
+                full_response_text = "".join(response_chunks)
+
+                save_conversation_message(
+                    command_history,
+                    state.conversation_id,
+                    "assistant",
+                    full_response_text,
+                    wd=state.current_path,
+                    model=state.reasoning_model,
+                    provider=state.reasoning_provider,
+                    npc=state.npc.name if isinstance(state.npc, NPC) else None,
+                )
+                pti_messages.append({"role": "assistant", "content": full_response_text})
                 
+                print() 
+                user_input = None 
+                continue
+
+            except KeyboardInterrupt:
+                print(colored("\n\n--- Stream Interrupted ---", "yellow"))
+                interrupt_text = input('🐻‍❄️> ').strip()
+                if interrupt_text:
+                    user_input = interrupt_text
+                else:
+                    user_input = None
+                continue
 
-                for chunk in assistant_reply:       
-                    if thinking:
-                        if not in_think_block:
-                            in_think_block = True
-                    try:
-                        
-                        if reasoning_provider == "ollama":
-                            chunk_content = chunk.get("message", {}).get("content", "")
-                        else:
-                            chunk_content = ''
-                            reasoning_content = ''
-                            for c in chunk.choices:
-                                if hasattr(c.delta, "reasoning_content"):
-                                    
-                                    reasoning_content += c.delta.reasoning_content
-                                    
-                            if reasoning_content:
-                                thinking = True
-                                chunk_content = reasoning_content
-                            chunk_content += "".join(
-                                choice.delta.content
-                                for choice in chunk.choices
-                                if choice.delta.content is not None
-                            )
-                        response_chunks.append(chunk_content)
-                        print(chunk_content, end='')
-                        combined_text = "".join(response_chunks)
-
-                        if in_think_block:
-                            if '</thinking>' in combined_text:
-                                in_think_block = False
-                            thoughts.append(chunk_content)
-                            
-                        if "</request_for_input>" in combined_text:
-                            # Process the LLM's input request
-                            request_text = "".join(thoughts)
-
-                            print("\nPlease provide the requested information: ")
-
-                            user_input = input('🐻‍❄️>')
-
-                            messages.append({"role": "assistant", "content": request_text})
-
-                            print("\n[Continuing with provided information...]\n")
-                            return enter_reasoning_human_in_the_loop( user_input = user_input,
-                                                                     messages=messages, 
-                                                                     reasoning_model=reasoning_model,
-                                                                     reasoning_provider=reasoning_provider,
-                                                                     npc=npc, 
-                                                                     answer_only=True)
-                            
-                        
-                    except KeyboardInterrupt:        
-                        user_interrupt = input("\n[Stream interrupted by user]\n Enter your additional input: ")
-                        
-
-                        # Add the interruption to messages and restart stream
-                        messages.append(
-                            {"role": "user", "content": f"[INTERRUPT] {user_interrupt}"}
-                        )
-                        print(f"\n[Continuing with added context...]\n")        
-                        
-    except KeyboardInterrupt:
-        user_interrupt = input("\n[Stream interrupted by user]\n 🔴🔴🔴🔴\nEnter your additional input: ")
-        
+        except KeyboardInterrupt:
+            print()
+            continue
+        except EOFError:
+            print("\nExiting PTI Mode.")
+            break
 
-        # Add the interruption to messages and restart stream
-        messages.append(
-            {"role": "user", "content": f"[INTERRUPT] {user_interrupt}"}
-        )
-        print(f"\n[Continuing with added context...]\n")        
-        
-    return {'messages':messages, }
-        
+    render_markdown("\n# Exiting PTI Mode")
+    return {"output": "", "messages": pti_messages}
 
 def main():
-    # Example usage
-    import argparse    
-    parser = argparse.ArgumentParser(description="Enter PTI mode for chatting with an LLM")
-    parser.add_argument("--npc", default='~/.npcsh/npc_team/frederic.npc', help="Path to NPC File")    
-    parser.add_argument("--model", default=NPCSH_REASONING_MODEL, help="Model to use")
-    parser.add_argument("--provider", default=NPCSH_REASONING_PROVIDER, help="Provider to use")
-    parser.add_argument("--files", nargs="*", help="Files to load into context")
+    parser = argparse.ArgumentParser(description="PTI - Pardon-The-Interruption human-in-the-loop shell.")
+    parser.add_argument('initial_prompt', nargs='*', help="Initial prompt to start the session.")
+    parser.add_argument("-f", "--files", nargs="*", default=[], help="Files to load into context.")
     args = parser.parse_args()
+
+    command_history, team, default_npc = setup_shell()
+
+    from npcsh._state import initial_state
+    initial_shell_state = initial_state
+    initial_shell_state.team = team
+    initial_shell_state.npc = default_npc
     
-    npc = NPC(file=args.npc)
-    enter_reasoning_human_in_the_loop(
-        messages = [],
-        npc=npc,
-        reasoning_model=args.model,
-        reasoning_provider=args.provider,
-        files=args.files,
-    )
+    fake_command_str = "/pti " + " ".join(args.initial_prompt)
+    if args.files:
+        fake_command_str += " --files " + " ".join(args.files)
+        
+    kwargs = {
+        'command': fake_command_str,
+        'shell_state': initial_shell_state,
+        'command_history': command_history
+    }
+    
+    enter_pti_mode(**kwargs)
 
 if __name__ == "__main__":
-    main()
-    
+    main()

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
@@ -36,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, 
@@ -53,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 = {}
@@ -220,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", [])
@@ -277,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,
@@ -368,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()
@@ -438,6 +521,8 @@ 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", [])
@@ -452,9 +537,9 @@ def plan_handler(command: str, **kwargs):
     #    traceback.print_exc()
     #    return {"output": f"Error executing plan: {e}", "messages": messages}
 
-@router.route("pti", "Use pardon-the-interruption mode to interact with the LLM")
+@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):
@@ -825,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", [])}
@@ -907,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,