npcsh 1.1.12__py3-none-any.whl → 1.1.14__py3-none-any.whl

npcsh/pti.py

@@ -1,214 +1,54 @@
+"""
+pti - Pardon-The-Interruption mode CLI entry point
+
+This is a thin wrapper that executes the pti.jinx through the jinx mechanism.
+"""
+import argparse
 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!
-
-{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:
-        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}
-
-    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)
+from npcsh._state import setup_shell
 
-    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
-                
-                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
-                )
-                stream = response_dict.get('response')
-                
-                response_chunks = []
-                request_found = False
-                
-                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
-
-        except KeyboardInterrupt:
-            print()
-            continue
-        except EOFError:
-            print("\nExiting PTI Mode.")
-            break
-
-    render_markdown("\n# Exiting PTI Mode")
-    return {"output": "", "messages": pti_messages}
 
 def main():
-    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.")
+    parser = argparse.ArgumentParser(description="pti - Human-in-the-loop reasoning mode")
+    parser.add_argument("prompt", nargs="*", help="Initial prompt to start with")
+    parser.add_argument("--model", "-m", type=str, help="LLM model to use")
+    parser.add_argument("--provider", "-p", type=str, help="LLM provider to use")
+    parser.add_argument("--files", "-f", nargs="*", help="Files to load into context")
+    parser.add_argument("--reasoning-model", type=str, help="Model for reasoning (may differ from chat)")
     args = parser.parse_args()
 
+    # Setup shell to get team and default NPC
     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
-    
-    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
+    if not team or "pti" not in team.jinxs_dict:
+        print("Error: pti jinx not found. Ensure npc_team/jinxs/modes/pti.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "model": args.model,
+        "provider": args.provider,
+        "files": ",".join(args.files) if args.files else None,
+        "reasoning_model": args.reasoning_model,
     }
-    
-    enter_pti_mode(**kwargs)
+
+    # If initial prompt provided, add it
+    if args.prompt:
+        initial = " ".join(args.prompt)
+        context["messages"] = [{"role": "user", "content": initial}]
+
+    # Execute the jinx
+    pti_jinx = team.jinxs_dict["pti"]
+    result = pti_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
 
 if __name__ == "__main__":
-    main()
+    main()

npcsh/spool.py

@@ -1,253 +1,48 @@
-from npcpy.memory.command_history import CommandHistory, start_new_conversation, save_conversation_message
-from npcpy.data.load import load_file_contents
-from npcpy.data.image import capture_screenshot
-from npcpy.data.text import rag_search
+"""
+spool - Interactive chat mode CLI entry point
 
+This is a thin wrapper that executes the spool.jinx through the jinx mechanism.
+"""
+import argparse
 import os
 import sys
-from npcpy.npc_sysenv import (    
-    print_and_process_stream_with_markdown,
-    get_system_message, 
-    render_markdown,
-)
-from npcsh._state import (
-    orange, 
-    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.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,
-    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 = None,
-    **kwargs,
-) -> Dict:
-    print_spool_ascii()
-  
-    command_history, state_team, default_npc = setup_shell()
-    
-  
-    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,
-    )
-    
-  
-    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.")
+from npcsh._state import setup_shell
 
-  
-    loaded_chunks = {}
-    if attachments:
-        if isinstance(attachments, str):
-            attachments = [f.strip() for f in attachments.split(',')]
-        
-        for file_path in attachments:
-            file_path = os.path.expanduser(file_path)
-            if not os.path.exists(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(colored(f"Loaded {len(chunks)} chunks from: {file_path}", "green"))
-            except Exception as e:
-                print(colored(f"Error loading {file_path}: {str(e)}", "red"))
 
-  
-    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:
-          
-            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_state.messages = enter_yap_mode(spool_state.messages, spool_state.npc)
-                continue
+def main():
+    parser = argparse.ArgumentParser(description="spool - Interactive chat mode")
+    parser.add_argument("--model", "-m", type=str, help="LLM model to use")
+    parser.add_argument("--provider", "-p", type=str, help="LLM provider to use")
+    parser.add_argument("--files", "-f", nargs="*", help="Files to load for RAG context")
+    parser.add_argument("--no-stream", action="store_true", help="Disable streaming")
+    args = parser.parse_args()
 
-          
-            if user_input.startswith("/ots"):
-                command_parts = user_input.split()
-                image_paths = []
-                
-                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(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(colored(f"Screenshot captured: {screenshot['filename']}", "green"))
-                
-                if not image_paths: 
-                    continue
-                
-                vision_prompt = input("Prompt for image(s) (or press Enter): ").strip() or "Describe these images."
-                
-              
-                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_result(vision_prompt, spool_state, {'output': output}, command_history)
-                continue
-            
-          
-            current_prompt = user_input
-            if loaded_chunks:
-                context_content = ""
-                for filename, chunks in loaded_chunks.items():
-                    full_content_str = "\n".join(chunks)
-                    retrieved_docs = rag_search(
-                        user_input,
-                        full_content_str,
-                        similarity_threshold=rag_similarity_threshold,
-                    )
-                    if retrieved_docs:
-                        context_content += f"\n\nContext from: {filename}\n{retrieved_docs}\n"
-                
-                if context_content:
-                    current_prompt += f"\n\n--- Relevant context from loaded files ---\n{context_content}"
-            
-          
-            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')
-            
-          
-            process_result(current_prompt, spool_state, {'output': output}, command_history)
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
 
-        except (EOFError,):
-            print("\nExiting spool mode.")
-            break
-        except KeyboardInterrupt:
-            print("\n🔄 Use '/sq' to exit or continue with a new message.")
-            continue
+    if not team or "spool" not in team.jinxs_dict:
+        print("Error: spool jinx not found. Ensure npc_team/jinxs/modes/spool.jinx exists.")
+        sys.exit(1)
 
-    return {"messages": spool_state.messages, "output": "Exited spool mode."}
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "model": args.model,
+        "provider": args.provider,
+        "attachments": ",".join(args.files) if args.files else None,
+        "stream": not args.no_stream,
+    }
 
+    # Execute the jinx
+    spool_jinx = team.jinxs_dict["spool"]
+    result = spool_jinx.execute(context=context, npc=default_npc)
 
-def main():
-    import argparse    
-    parser = argparse.ArgumentParser(description="Enter spool mode for chatting with an LLM")
-    parser.add_argument("--model", help="Model to use")
-    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, help="NPC name or path to NPC file", default='sibiji',)
-    
-    args = parser.parse_args()
-    
-  
-    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
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
 
-    enter_spool_mode(
-        npc=npc,
-        team=team,
-        model=args.model,
-        provider=args.provider,
-        attachments=args.attachments,
-        stream=args.stream.lower() == "true",
-    )
 
 if __name__ == "__main__":
-    main()
+    main()