npcsh 1.0.14__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()