npcsh 0.1.2__py3-none-any.whl → 1.1.13__py3-none-any.whl

npcsh/npc_team/plonkjr.npc

@@ -0,0 +1,2 @@
+name: plonkjr
+primary_directive: You are junior automation specialist in the NPC Team.

npcsh/npc_team/sibiji.npc

@@ -0,0 +1,3 @@
+name: sibiji
+primary_directive: You are a foundational AI assistant. Your role is to provide support and information. Respond to queries concisely and accurately. Help users with code and other processes. 
+jinxs: "*"

npcsh/npcsh.py

@@ -1,135 +1,319 @@
-# npcsh.py
 import os
+import sys
+import argparse
+import importlib.metadata
 
-import readline
-import atexit
-from datetime import datetime
-import pandas as pd
+import platform
+try:
+    from termcolor import colored
+except: 
+    pass
+from npcpy.npc_sysenv import (
+    render_markdown,
+)
+from npcpy.memory.command_history import (
+    CommandHistory,
+    load_kg_from_db, 
+    save_kg_to_db, 
+)
+from npcpy.npc_compiler import NPC
+from npcpy.memory.knowledge_graph import (
+    kg_evolve_incremental
+)
 
-# Configure logging
+try:
+    import readline
+except:
+    print('no readline support, some features may not work as desired. ')
 
+try:
+    VERSION = importlib.metadata.version("npcsh")
+except importlib.metadata.PackageNotFoundError:
+    VERSION = "unknown"
 
-from .command_history import CommandHistory
-from .llm_funcs import (
-    get_llm_response,
-    execute_llm_command,
-    check_llm_command,
-    execute_llm_question,
-    execute_llm_thought,
+from npcsh._state import (
+    initial_state,
+    orange,
+    ShellState,
+    execute_command,
+    make_completer,
+    process_result,
+    readline_safe_prompt,
+    setup_shell,
+    get_multiline_input,
 )
-from .modes import (
-    enter_bash_mode,
-    enter_whisper_mode,
-    enter_notes_mode,
-    enter_observation_mode,
-    enter_spool_mode,
-)
-from .helpers import log_action, list_directory, read_file
-from .npc_compiler import NPCCompiler
-
-
-def execute_command(command, command_history, db_path, npc_compiler):
-    subcommands = []
-    output = ""
-    location = os.getcwd()
-
-    if command.startswith("/"):
-        command = command[1:]
-        log_action("Command Executed", command)
-
-        command_parts = command.split()
-        command_name = command_parts[0]
-        args = command_parts[1:]
-
-        if (
-            command_name == "b"
-            or command_name == "bash"
-            or command_name == "zsh"
-            or command_name == "sh"
-        ):
-            output = enter_bash_mode()
-        if command_name == "compile" or command_name == "com":
-            try:
-                compiled_script = npc_compiler.compile(args[0])
-                output = f"Compiled NPC profile: {compiled_script}"
-                print(output)
-            except Exception as e:
-                output = f"Error compiling NPC profile: {str(e)}"
-                print(output)
-
-        elif command_name == "whisper":
-            output = enter_whisper_mode(command_history)
-        elif command_name == "notes":
-            output = enter_notes_mode(command_history)
-        elif command_name == "data":
-            print(db_path)
-            output = enter_observation_mode(command_history)
-        elif command_name == "cmd" or command_name == "command":
-            output = execute_llm_command(command, command_history)
-        elif command_name == "?":
-            output = execute_llm_question(command, command_history)
-        elif command_name == "th" or command_name == "thought":
-            output = execute_llm_thought(command, command_history)
-        elif command_name == "spool" or command_name == "sp":
-            inherit_last = int(args[0]) if args else 0
-
-            output = enter_spool_mode(command_history, inherit_last)
+
+
+def display_usage(state: ShellState):
+    """Display token usage and cost summary."""
+    inp = state.session_input_tokens
+    out = state.session_output_tokens
+    cost = state.session_cost_usd
+    turns = state.turn_count
+    total = inp + out
+
+    def fmt(n):
+        return f"{n/1000:.1f}k" if n >= 1000 else str(n)
+
+    def fmt_cost(c):
+        if c == 0:
+            return "free"
+        elif c < 0.01:
+            return f"${c:.4f}"
         else:
-            output = f"Unknown command: {command_name}"
+            return f"${c:.2f}"
 
-        subcommands = [f"/{command}"]
-    else:
-        output = check_llm_command(command, command_history)
+    print(colored("\n─────────────────────────────", "cyan"))
+    print(colored("📊 Session Usage", "cyan", attrs=["bold"]))
+    print(f"   Tokens: {fmt(inp)} in / {fmt(out)} out ({fmt(total)} total)")
+    print(f"   Cost:   {fmt_cost(cost)}")
+    print(f"   Turns:  {turns}")
+    print(colored("─────────────────────────────\n", "cyan"))
 
-    command_history.add(command, subcommands, output, location)
 
+def print_welcome_message():
+    print(
+            """
+___________________________________________          
+___________________________________________
+___________________________________________
 
-def setup_readline():
-    readline.set_history_length(1000)
-    readline.parse_and_bind("set editing-mode vi")
-    readline.parse_and_bind('"\e[A": history-search-backward')
-    readline.parse_and_bind('"\e[B": history-search-forward')
+Welcome to \033[1;94mnpc\033[0m\033[1;38;5;202msh\033[0m!
+\033[1;94m                    \033[0m\033[1;38;5;202m        _       \\\\
+\033[1;94m _ __   _ __    ___ \033[0m\033[1;38;5;202m  ___  | |___    \\\\
+\033[1;94m| '_ \\ | '_ \\  / __|\033[0m\033[1;38;5;202m / __/ | |_ _|    \\\\
+\033[1;94m| | | || |_) |( |__ \033[0m\033[1;38;5;202m \\_  \\ | | | |    //
+\033[1;94m|_| |_|| .__/  \\___|\033[0m\033[1;38;5;202m |___/ |_| |_|   //
+       \033[1;94m|🤖|          \033[0m\033[1;38;5;202m               //
+       \033[1;94m|🤖|
+       \033[1;94m|🤖|
+___________________________________________
+___________________________________________
+___________________________________________
 
-    readline.parse_and_bind('"\C-r": reverse-search-history')
+Begin by asking a question, issuing a bash command, or typing '/help' for more information.
 
+            """
+        )
 
-def save_readline_history():
-    readline.write_history_file(os.path.expanduser("~/.npcsh_readline_history"))
 
+def run_repl(command_history: CommandHistory, initial_state: ShellState, router):
+    state = initial_state
+        
+    print_welcome_message()
 
-def main():
-    # check if theres a set path to a local db in the os env
-    if "NPCSH_DB_PATH" in os.environ:
-        db_path = os.environ["NPCSH_DB_PATH"]
-        command_history = CommandHistory(db_path)
+    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()]))
+    render_markdown('\n- Here are the currently available Jinxs: ' + ', '.join([jinx_name for jinx_name in state.team.jinxs_dict.keys()]))
+    
+    is_windows = platform.system().lower().startswith("win")
+    try:
+        completer = make_completer(state, router)
+        readline.set_completer(completer)
+    except:
+        pass
+    session_scopes = set()
+
+    def exit_shell(current_state: ShellState):
+        print("\nGoodbye!")
+        print(colored("Processing and archiving all session knowledge...", "cyan"))
+        
+        engine = command_history.engine
+
+        for team_name, npc_name, path in session_scopes:
+            try:
+                print(f"  -> Archiving knowledge for: T='{team_name}', N='{npc_name}', P='{path}'")
+                
+                convo_id = current_state.conversation_id
+                all_messages = command_history.get_conversations_by_id(convo_id)
+                
+                scope_messages = [
+                    m for m in all_messages 
+                    if m.get('directory_path') == path and m.get('team') == team_name and m.get('npc') == npc_name
+                ]
+                
+                full_text = "\n".join([f"{m['role']}: {m['content']}" for m in scope_messages if m.get('content')])
+
+                if not full_text.strip():
+                    print("     ...No content for this scope, skipping.")
+                    continue
+
+                current_kg = load_kg_from_db(engine, team_name, npc_name, path)
+                
+                evolved_kg, _ = kg_evolve_incremental(
+                    existing_kg=current_kg,
+                    new_content_text=full_text,
+                    model=current_state.npc.model,
+                    provider=current_state.npc.provider, 
+                    npc= current_state.npc,
+                    get_concepts=True,
+                    link_concepts_facts = True, 
+                    link_concepts_concepts = True, 
+                    link_facts_facts = True, 
+                )
+                
+                save_kg_to_db(engine,
+                              evolved_kg,
+                              team_name, 
+                              npc_name, 
+                              path)
+
+            except Exception as e:
+                import traceback
+                print(colored(f"Failed to process KG for scope ({team_name}, {npc_name}, {path}): {e}", "red"))
+                traceback.print_exc()
+
+        sys.exit(0)
 
-    else:
-        db_path = "~/npcsh_history.db"
-        command_history = CommandHistory()
-    # Initialize NPCCompiler
-    os.makedirs("./npc_profiles", exist_ok=True)
-    npc_directory = os.path.expanduser(
-        "./npc_profiles"
-    )  # You can change this to your preferred directory
-    npc_compiler = NPCCompiler(npc_directory)
-
-    setup_readline()
-    atexit.register(save_readline_history)
-    atexit.register(command_history.close)
-
-    print("Welcome to npcsh!")
     while True:
         try:
-            user_input = input("npcsh> ").strip()
-            if user_input.lower() in ["exit", "quit"]:
-                print("Goodbye!")
-                break
+            if state.messages is not None:
+                if len(state.messages) > 20:
+                    # Display usage before compacting
+                    display_usage(state)
+
+                    planning_state = {
+                        "goal": "ongoing npcsh session",
+                        "facts": [f"Working in {state.current_path}", f"Current mode: {state.current_mode}"],
+                        "successes": [],
+                        "mistakes": [],
+                        "todos": [],
+                        "constraints": ["Follow user requests", "Use appropriate mode for tasks"]
+                    }
+                    compressed_state = state.npc.compress_planning_state(planning_state)
+                    state.messages = [{"role": "system", "content": f"Session context: {compressed_state}"}]
+
+                try:
+                    completer = make_completer(state, router)
+                    readline.set_completer(completer)
+                except:
+                    pass
+
+            display_model = state.chat_model
+            if isinstance(state.npc, NPC) and state.npc.model:
+                display_model = state.npc.model
+
+            npc_name = state.npc.name if isinstance(state.npc, NPC) else "npcsh"
+            team_name = state.team.name if state.team else ""
+
+            # Check if model is local (ollama) or remote (has cost)
+            provider = state.chat_provider
+            if isinstance(state.npc, NPC) and state.npc.provider:
+                provider = state.npc.provider
+            is_local = provider and provider.lower() in ['ollama', 'transformers', 'local']
+
+            # Build token/cost string for hint line
+            if state.session_input_tokens > 0 or state.session_output_tokens > 0:
+                usage_str = f"📊 {state.session_input_tokens:,} in / {state.session_output_tokens:,} out"
+                if not is_local and state.session_cost_usd > 0:
+                    usage_str += f" | ${state.session_cost_usd:.4f}"
+                token_hint = colored(usage_str, "white", attrs=["dark"])
             else:
-                execute_command(user_input, command_history, db_path, npc_compiler)
-        except (KeyboardInterrupt, EOFError):
-            print("\nGoodbye!")
-            break
+                token_hint = ""
+
+            if is_windows:
+                print(f"cwd: {state.current_path}")
+                status = f"{npc_name}"
+                if team_name:
+                    status += f" | {team_name}"
+                status += f" | {display_model}"
+                print(status)
+                prompt = "> "
+            else:
+                # Line 1: cwd (full path)
+                cwd_line = colored("📁 ", "blue") + colored(state.current_path, "blue")
+                print(cwd_line)
+
+                # Line 2: npc | team | model
+                npc_colored = orange(npc_name) if isinstance(state.npc, NPC) else colored("npcsh", "cyan")
+                parts = [colored("🤖 ", "yellow") + npc_colored]
+                if team_name:
+                    parts.append(colored("👥 ", "magenta") + colored(team_name, "magenta"))
+                parts.append(colored(display_model, "white", attrs=["dark"]))
+                print(" | ".join(parts))
 
+                prompt = colored("> ", "green")
 
+            user_input = get_multiline_input(prompt, state=state, router=router, token_hint=token_hint).strip()
+          
+            if user_input == "\x1a":
+                exit_shell(state)
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ["exit", "quit"]:
+                if isinstance(state.npc, NPC):
+                    print(f"Exiting {state.npc.name} mode.")
+                    state.npc = None
+                    continue
+                else:
+                    exit_shell(state)
+            
+            team_name = state.team.name if state.team else "__none__"
+            npc_name = state.npc.name if isinstance(state.npc, NPC) else "__none__"
+            session_scopes.add((team_name, npc_name, state.current_path))
+
+            state, output = execute_command(user_input, 
+                                            state, 
+                                            review = False, 
+                                            router=router, 
+                                            command_history=command_history)
+
+            process_result(user_input, 
+                           state, 
+                           output, 
+                           command_history, 
+                           )
+        
+        except KeyboardInterrupt:
+            print("^C")
+            if input("\nExit? (y/n): ").lower().startswith('y'):
+                exit_shell(state)
+            continue
+
+        except EOFError:
+            exit_shell(state)
+        except Exception as e:            
+            if is_windows and "EOF" in str(e).lower():
+                print("\nHint: On Windows, use Ctrl+Z then Enter for EOF, or type 'exit'")
+                continue
+            raise
+        
+
+def main() -> None:
+    from npcsh.routes import router
+    
+    parser = argparse.ArgumentParser(description="npcsh - An NPC-powered shell.")
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"npcsh version {VERSION}"
+    )
+    parser.add_argument(
+         "-c", "--command", type=str, help="Execute a single command and exit."
+    )
+    args = parser.parse_args()
+
+    command_history, team, default_npc = setup_shell()
+    
+    if team and hasattr(team, 'jinxs_dict'):
+        for jinx_name, jinx_obj in team.jinxs_dict.items():
+            router.register_jinx(jinx_obj)
+
+    initial_state.npc = default_npc 
+    initial_state.team = team    
+    if args.command:
+         state = initial_state
+         state.current_path = os.getcwd()
+         final_state, output = execute_command(args.command, state, router=router, command_history=command_history)
+         if final_state.stream_output:
+              for chunk in output: 
+                  print(str(chunk), end='')
+              print()
+         elif output is not None:
+              print(output)
+    else:
+        run_repl(command_history, initial_state, router)
+        
 if __name__ == "__main__":
-    main()
+    main()

npcsh/parsing.py

@@ -0,0 +1,118 @@
+"""
+Command parsing utilities for npcsh
+"""
+import shlex
+from typing import List
+
+
+def split_by_pipes(command: str) -> List[str]:
+    """
+    Split a command by pipes, preserving quoted strings.
+
+    Examples:
+        'foo | bar' -> ['foo', 'bar']
+        'foo "hello|world" | bar' -> ['foo "hello|world"', 'bar']
+    """
+    result = []
+    current = []
+    in_single_quote = False
+    in_double_quote = False
+    i = 0
+
+    while i < len(command):
+        char = command[i]
+
+        if char == "'" and not in_double_quote:
+            in_single_quote = not in_single_quote
+            current.append(char)
+        elif char == '"' and not in_single_quote:
+            in_double_quote = not in_double_quote
+            current.append(char)
+        elif char == '|' and not in_single_quote and not in_double_quote:
+            result.append(''.join(current).strip())
+            current = []
+        else:
+            current.append(char)
+
+        i += 1
+
+    # Add final segment
+    if current:
+        result.append(''.join(current).strip())
+
+    return [s for s in result if s]
+
+
+def parse_command_safely(cmd: str) -> List[str]:
+    """
+    Safely parse a command string into parts using shlex.
+
+    Returns an empty list on parse errors.
+    """
+    try:
+        return shlex.split(cmd)
+    except ValueError:
+        # Handle unmatched quotes, etc
+        return cmd.split()
+
+
+def parse_generic_command_flags(parts: List[str]) -> tuple:
+    """
+    Parse command flags in a generic way.
+
+    Returns:
+        Tuple of (parsed_flags dict, remaining_parts list)
+    """
+    parsed_flags = {}
+    remaining = []
+
+    i = 0
+    while i < len(parts):
+        part = parts[i]
+
+        if part.startswith('--'):
+            key = part[2:]
+            if '=' in key:
+                key, value = key.split('=', 1)
+                parsed_flags[key] = _try_convert_type(value)
+            elif i + 1 < len(parts) and not parts[i + 1].startswith('-'):
+                parsed_flags[key] = _try_convert_type(parts[i + 1])
+                i += 1
+            else:
+                parsed_flags[key] = True
+        elif part.startswith('-') and len(part) == 2:
+            key = part[1]
+            if i + 1 < len(parts) and not parts[i + 1].startswith('-'):
+                parsed_flags[key] = _try_convert_type(parts[i + 1])
+                i += 1
+            else:
+                parsed_flags[key] = True
+        else:
+            remaining.append(part)
+
+        i += 1
+
+    return parsed_flags, remaining
+
+
+def _try_convert_type(value: str):
+    """Try to convert string value to appropriate Python type"""
+    # Try int
+    try:
+        return int(value)
+    except ValueError:
+        pass
+
+    # Try float
+    try:
+        return float(value)
+    except ValueError:
+        pass
+
+    # Try bool
+    if value.lower() in ('true', 'yes', '1'):
+        return True
+    if value.lower() in ('false', 'no', '0'):
+        return False
+
+    return value

npcsh/plonk.py

@@ -0,0 +1,54 @@
+"""
+plonk - Vision-based GUI automation CLI entry point
+
+This is a thin wrapper that executes the plonk.jinx through the jinx mechanism.
+"""
+import argparse
+import os
+import sys
+
+from npcsh._state import setup_shell
+
+
+def main():
+    parser = argparse.ArgumentParser(description="plonk - Vision-based GUI automation")
+    parser.add_argument("task", nargs="*", help="Task description for GUI automation")
+    parser.add_argument("--vmodel", type=str, help="Vision model to use (default: gpt-4o)")
+    parser.add_argument("--vprovider", type=str, help="Vision provider (default: openai)")
+    parser.add_argument("--max-iterations", type=int, default=10, help="Maximum iterations")
+    parser.add_argument("--no-debug", action="store_true", help="Disable debug output")
+    args = parser.parse_args()
+
+    if not args.task:
+        parser.print_help()
+        sys.exit(1)
+
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
+
+    if not team or "plonk" not in team.jinxs_dict:
+        print("Error: plonk jinx not found. Ensure npc_team/jinxs/modes/plonk.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "task": " ".join(args.task),
+        "vmodel": args.vmodel,
+        "vprovider": args.vprovider,
+        "max_iterations": args.max_iterations,
+        "debug": not args.no_debug,
+    }
+
+    # Execute the jinx
+    plonk_jinx = team.jinxs_dict["plonk"]
+    result = plonk_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
+
+if __name__ == "__main__":
+    main()

npcsh/pti.py

@@ -0,0 +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
+
+from npcsh._state import setup_shell
+
+
+def main():
+    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()
+
+    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,
+    }
+
+    # 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()