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

npcsh/npc.py

@@ -0,0 +1,323 @@
+import argparse
+import sys
+import os
+import traceback
+from typing import Optional
+
+from npcsh._state import (
+    NPCSH_CHAT_MODEL,
+    NPCSH_CHAT_PROVIDER,
+    NPCSH_API_URL, 
+    NPCSH_DB_PATH, 
+    NPCSH_STREAM_OUTPUT,
+    initial_state,
+)
+from npcpy.npc_sysenv import (
+    print_and_process_stream_with_markdown,
+    render_markdown,
+)
+from npcpy.npc_compiler import NPC, Team
+from npcsh.routes import router
+from npcpy.llm_funcs import check_llm_command
+from sqlalchemy import create_engine
+
+from npcsh._state import (
+    setup_shell,
+    execute_slash_command,
+    execute_command,
+)
+
+def load_npc_by_name(npc_name: str = "sibiji", db_path: str = NPCSH_DB_PATH) -> Optional[NPC]:
+    """Load NPC by name, with fallback logic matching npcsh"""
+    if not npc_name:
+        npc_name = "sibiji"
+
+    project_npc_path = os.path.abspath(f"./npc_team/{npc_name}.npc")
+    global_npc_path = os.path.expanduser(f"~/.npcsh/npc_team/{npc_name}.npc")
+
+    chosen_path = None
+    if os.path.exists(project_npc_path):
+        chosen_path = project_npc_path
+    elif os.path.exists(global_npc_path):
+        chosen_path = global_npc_path
+    elif os.path.exists(f"npcs/{npc_name}.npc"):
+         chosen_path = f"npcs/{npc_name}.npc"
+
+    if chosen_path:
+        try:
+            db_conn = create_engine(f'sqlite:///{NPCSH_DB_PATH}')
+            npc = NPC(file=chosen_path, db_conn=db_conn)
+            return npc
+        except Exception as e:
+            print(f"Warning: Failed to load NPC '{npc_name}' from {chosen_path}: {e}", file=sys.stderr)
+            return None
+    else:
+        print(f"Warning: NPC file for '{npc_name}' not found in project or global paths.", file=sys.stderr)
+        if npc_name != "sibiji":
+            return load_npc_by_name("sibiji", db_path)
+        return None
+def main():
+    from npcsh.routes import router
+    
+    parser = argparse.ArgumentParser(
+        description=(
+            "NPC Command Line Utilities. "
+            "Call a command or provide a prompt for the default NPC."
+        ),
+        usage=(
+            "npc <command> [command_args...] | "
+            "<prompt> [--npc NAME] [--model MODEL] [--provider PROV]"
+        )
+    )
+    parser.add_argument(
+        "--model", 
+        "-m", 
+        help="LLM model to use (overrides NPC/defaults)", 
+        type=str, 
+        default=None
+    )
+    parser.add_argument(
+        "--provider", 
+        "-pr", 
+        help="LLM provider to use (overrides NPC/defaults)", 
+        type=str, 
+        default=None
+    )
+    parser.add_argument(
+        "-n", 
+        "--npc", 
+        help="Name of the NPC to use (default: sibiji)", 
+        type=str, 
+        default="sibiji"
+    )
+
+    args, all_args = parser.parse_known_args()
+    global_model = args.model
+    global_provider = args.provider
+
+    is_valid_command = False
+    command_name = None
+    
+    if all_args:
+        first_arg = all_args[0]
+        if first_arg.startswith('/'):
+            is_valid_command = True
+            command_name = first_arg
+            all_args = all_args[1:]
+        elif first_arg in router.get_commands():
+            is_valid_command = True
+            command_name = '/' + first_arg
+            all_args = all_args[1:]
+
+    if is_valid_command:
+        subparsers = parser.add_subparsers(
+            dest="command", 
+            title="Available Commands",
+            help="Run 'npc <command> --help' for command-specific help"
+        )
+
+        for cmd_name, help_text in router.help_info.items():
+            cmd_parser = subparsers.add_parser(
+                cmd_name, 
+                help=help_text, 
+                add_help=False
+            )
+            cmd_parser.add_argument(
+                'command_args', 
+                nargs=argparse.REMAINDER,
+                help='Arguments passed directly to the command handler'
+            )
+
+        args = parser.parse_args([command_name.lstrip('/')] + all_args)
+        command_args = (
+            args.command_args 
+            if hasattr(args, 'command_args') 
+            else []
+        )
+        unknown_args = []
+    else:
+        args.command = None
+        command_args = []
+        unknown_args = all_args
+
+    if args.model is None:
+        args.model = global_model
+    if args.provider is None:
+        args.provider = global_provider
+
+    try:
+        command_history, team, forenpc_obj = setup_shell()
+    except Exception as e:
+        print(
+            f"Warning: Could not set up full npcsh environment: {e}", 
+            file=sys.stderr
+        )
+        print("Falling back to basic NPC loading...", file=sys.stderr)
+        team = None
+        forenpc_obj = load_npc_by_name(args.npc, NPCSH_DB_PATH)
+
+    npc_instance = None
+    if team and args.npc in team.npcs:
+        npc_instance = team.npcs[args.npc]
+    elif (
+        team 
+        and args.npc == team.forenpc.name 
+        if team.forenpc 
+        else False
+    ):
+        npc_instance = team.forenpc
+    else:
+        npc_instance = load_npc_by_name(args.npc, NPCSH_DB_PATH)
+
+    if not npc_instance:
+        print(f"Error: Could not load NPC '{args.npc}'", file=sys.stderr)
+        sys.exit(1)
+
+    if not is_valid_command and all_args:
+        first_arg = all_args[0]
+        
+        jinx_found = False
+        if team and first_arg in team.jinxs_dict:
+            jinx_found = True
+        elif (
+            isinstance(npc_instance, NPC) 
+            and hasattr(npc_instance, 'jinxs_dict') 
+            and first_arg in npc_instance.jinxs_dict
+        ):
+            jinx_found = True
+            
+        if jinx_found:
+            is_valid_command = True
+            command_name = '/' + first_arg
+            all_args = all_args[1:]
+            unknown_args = all_args
+
+    shell_state = initial_state
+    shell_state.npc = npc_instance
+    shell_state.team = team
+    shell_state.current_path = os.getcwd()
+    shell_state.stream_output = NPCSH_STREAM_OUTPUT
+
+    effective_model = (
+        args.model 
+        or (
+            npc_instance.model 
+            if npc_instance.model 
+            else NPCSH_CHAT_MODEL
+        )
+    )
+    effective_provider = (
+        args.provider 
+        or (
+            npc_instance.provider 
+            if npc_instance.provider 
+            else NPCSH_CHAT_PROVIDER
+        )
+    )
+    
+    if args.model:
+        npc_instance.model = effective_model
+    if args.provider:
+        npc_instance.provider = effective_provider
+        
+    try:
+        if is_valid_command:
+            full_command_str = command_name
+            if command_args:
+                full_command_str += " " + " ".join(command_args)
+            
+            print(f"Executing command: {full_command_str}")
+            
+            updated_state, result = execute_slash_command(
+                full_command_str, 
+                stdin_input=None, 
+                state=shell_state, 
+                stream=NPCSH_STREAM_OUTPUT, 
+                router=router
+            )
+
+            if isinstance(result, dict):
+                output = result.get("output") or result.get("response")
+                model_for_stream = result.get('model', effective_model)
+                provider_for_stream = result.get(
+                    'provider', 
+                    effective_provider
+                )
+                
+                if (
+                    NPCSH_STREAM_OUTPUT 
+                    and not isinstance(output, str)
+                ):
+                    print_and_process_stream_with_markdown(
+                        output, 
+                        model_for_stream, 
+                        provider_for_stream
+                    )
+                elif output is not None:
+                    render_markdown(str(output))
+            elif result is not None:
+                render_markdown(str(result))
+            else:
+                print(f"Command '{command_name}' executed.")
+
+        else:
+            prompt = " ".join(unknown_args)
+
+            if not prompt:
+                parser.print_help()
+                sys.exit(1)
+
+            print(
+                f"Processing prompt: '{prompt}' with NPC: '{args.npc}'..."
+            )
+            
+            shell_state.current_mode = 'chat'
+            updated_state, result = execute_command(
+                prompt, 
+                shell_state, 
+                router=router, 
+                command_history=command_history
+            )
+
+            if isinstance(result, dict):
+                output = result.get("output")
+                model_for_stream = result.get('model', effective_model)
+                provider_for_stream = result.get(
+                    'provider', 
+                    effective_provider
+                )
+                
+                if (
+                    hasattr(output, '__iter__') 
+                    and not isinstance(output, (str, bytes, dict, list))
+                ):
+                    final_output = print_and_process_stream_with_markdown(
+                        output, 
+                        model_for_stream, 
+                        provider_for_stream,
+                        show=True
+                    )
+                elif output is not None:
+                    render_markdown(str(output))
+            elif (
+                hasattr(result, '__iter__') 
+                and not isinstance(result, (str, bytes, dict, list))
+            ):
+                final_output = print_and_process_stream_with_markdown(
+                    result,
+                    effective_model,
+                    effective_provider,
+                    show=True
+                )
+            elif result is not None:
+                render_markdown(str(result))
+
+
+    except Exception as e:
+        print(f"Error executing command: {e}", file=sys.stderr)
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

npcsh/npc_team/alicanto.npc

@@ -0,0 +1,2 @@
+name: alicanto
+primary_directive: You are Alicanto the mythical bird. You have been spotted and it is your job to lead users to explore the world. 

npcsh/npc_team/corca.npc

@@ -0,0 +1,12 @@
+name: corca
+primary_directive: |
+    You are corca, a distinguished member of the NPC team.
+    Your expertise is in the area of software development and
+    you have a knack for thinking through problems carefully.
+    You favor solutions that prioritize simplicity and clarity and
+    ought to always consider how some suggestion may increase rather than reduce tech debt
+    unnecessarily. Now, the key is in this last term, "unnecessarily".
+    You must distinguish carefully and when in doubt, opt to ask for further
+    information or clarification with concrete clear options that make it
+    easy for a user to choose.
+    

npcsh/npc_team/foreman.npc

@@ -0,0 +1,7 @@
+name: foreman
+primary_directive: You are the foreman of an NPC team. It is your duty
+    to delegate tasks to your team members or to other specialized teams
+    in order to complete the project. You are responsible for the
+    completion of the project and the safety of your team members.
+model: gpt-4o-mini
+provider: openai

npcsh/npc_team/frederic.npc

@@ -0,0 +1,6 @@
+name: frederic
+primary_directive: |
+    You are frederic the polar bear. Your job is help users think through problems and 
+    to provide straightforward ways forward on problems. Cut through the ice
+    to get to what matters and keep things simple. You are to respond in a
+    witty tone like richard feynman but with the romantic tambor of Frederic Chopin. 

npcsh/npc_team/jinxs/code/python.jinx

@@ -0,0 +1,11 @@
+jinx_name: python
+description: Execute scripts with python. You must set the ultimate result as the "output"
+  variable. It MUST be a string. 
+  Do not add unnecessary print statements. 
+  This jinx is intended for executing code snippets that are not 
+  accomplished by other jinxes. Use it only when the others are insufficient.
+inputs:
+- code
+steps:
+- code: '{{code}}'
+  engine: python

npcsh/npc_team/jinxs/code/sh.jinx

@@ -0,0 +1,34 @@
+jinx_name: sh
+description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically.
+inputs:
+  - bash_command
+steps:
+  - name: execute_bash
+    engine: python
+    code: |
+      import subprocess
+      import os
+
+      cmd = '{{ bash_command }}'
+      output = ""
+
+      process = subprocess.Popen(
+          cmd,
+          shell=True,
+          stdout=subprocess.PIPE,
+          stderr=subprocess.PIPE
+      )
+      stdout, stderr = process.communicate()
+
+      # Only show debug output if NPCSH_DEBUG is set
+      if os.environ.get("NPCSH_DEBUG") == "1":
+          import sys
+          print(f"[sh] cmd: {cmd}", file=sys.stderr)
+          print(f"[sh] stdout: {stdout.decode('utf-8', errors='ignore')[:200]}", file=sys.stderr)
+
+      if stderr:
+          output = f"Error: {stderr.decode('utf-8')}"
+      else:
+          output = stdout.decode('utf-8')
+
+

npcsh/npc_team/jinxs/code/sql.jinx

@@ -0,0 +1,16 @@
+jinx_name: sql
+description: Execute queries on the ~/npcsh_history.db to pull data. The database
+  contains only information about conversations and other user-provided data. It does
+  not store any information about individual files. Avoid using percent signs unless absolutely necessary.
+inputs:
+- sql_query
+steps:
+  - engine: python
+    code: |
+      import pandas as pd
+      query = "{{ sql_query }}"
+      try:
+        df = pd.read_sql_query(query, npc.db_conn)
+      except Exception as e:
+        df = pd.DataFrame({'Error': [str(e)]})
+      output = df.to_string()

npcsh/npc_team/jinxs/modes/alicanto.jinx

@@ -0,0 +1,194 @@
+jinx_name: alicanto
+description: Deep research mode - multi-perspective exploration with gold insights and cliff warnings
+npc: forenpc
+inputs:
+  - query: null
+  - num_npcs: 5
+  - depth: 3
+  - model: null
+  - provider: null
+  - max_steps: 20
+  - skip_research: true
+  - exploration: 0.3
+  - creativity: 0.5
+  - format: report
+
+steps:
+  - name: alicanto_research
+    engine: python
+    code: |
+      import os
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.data.web import search_web
+      from npcpy.npc_compiler import NPC
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
+
+      query = context.get('query')
+      num_npcs = int(context.get('num_npcs', 5))
+      depth = int(context.get('depth', 3))
+      max_steps = int(context.get('max_steps', 20))
+      skip_research = context.get('skip_research', True)
+      exploration = float(context.get('exploration', 0.3))
+      creativity = float(context.get('creativity', 0.5))
+      output_format = context.get('format', 'report')
+
+      model = context.get('model') or (npc.model if npc else 'gemini-1.5-pro')
+      provider = context.get('provider') or (npc.provider if npc else 'gemini')
+
+      if not query:
+          context['output'] = """Usage: /alicanto <research query>
+
+      Options:
+        --num-npcs N      Number of research perspectives (default: 5)
+        --depth N         Research depth (default: 3)
+        --max-steps N     Maximum research steps (default: 20)
+        --exploration F   Exploration factor 0-1 (default: 0.3)
+        --creativity F    Creativity factor 0-1 (default: 0.5)
+        --format FORMAT   Output: report|summary|full (default: report)
+
+      Example: /alicanto What are the latest advances in quantum computing?"""
+          context['messages'] = messages
+          exit()
+
+      print(f"""
+       █████╗ ██╗     ██╗ ██████╗ █████╗ ███╗   ██╗████████╗ ██████╗
+      ██╔══██╗██║     ██║██╔════╝██╔══██╗████╗  ██║╚══██╔══╝██╔═══██╗
+      ███████║██║     ██║██║     ███████║██╔██╗ ██║   ██║   ██║   ██║
+      ██╔══██║██║     ██║██║     ██╔══██║██║╚██╗██║   ██║   ██║   ██║
+      ██║  ██║███████╗██║╚██████╗██║  ██║██║ ╚████║   ██║   ╚██████╔╝
+      ╚═╝  ╚═╝╚══════╝╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝
+
+      Deep Research Mode
+      Query: {query}
+      Perspectives: {num_npcs} | Depth: {depth} | Max Steps: {max_steps}
+      """)
+
+      # Generate research perspectives
+      perspectives_prompt = f"""Generate {num_npcs} distinct research perspectives for investigating: "{query}"
+
+      For each perspective, provide:
+      1. Name (a descriptive title)
+      2. Approach (how this perspective would investigate)
+      3. Key questions to explore
+
+      Return as a numbered list."""
+
+      print(colored("Generating research perspectives...", "cyan"))
+      resp = get_llm_response(
+          perspectives_prompt,
+          model=model,
+          provider=provider,
+          npc=npc
+      )
+      perspectives = str(resp.get('response', ''))
+      print(perspectives)
+
+      # Conduct web research if not skipped
+      research_findings = ""
+      if not skip_research:
+          print(colored("\nConducting web research...", "cyan"))
+          try:
+              search_results = search_web(query, n_results=5)
+              if search_results:
+                  research_findings = "\n\nWeb Research Findings:\n"
+                  for i, result in enumerate(search_results[:5], 1):
+                      title = result.get('title', 'No title')
+                      snippet = result.get('snippet', result.get('body', ''))[:200]
+                      research_findings += f"\n{i}. {title}\n   {snippet}...\n"
+                  print(colored(f"Found {len(search_results)} sources", "green"))
+          except Exception as e:
+              print(colored(f"Web search error: {e}", "yellow"))
+
+      # Multi-step exploration from each perspective
+      all_insights = []
+      gold_insights = []  # Key valuable findings
+      cliff_warnings = []  # Potential pitfalls or caveats
+
+      for step in range(min(depth, max_steps)):
+          print(colored(f"\n--- Research Depth {step + 1}/{depth} ---", "cyan"))
+
+          explore_prompt = f"""Research query: "{query}"
+
+      Perspectives generated:
+      {perspectives}
+
+      {research_findings}
+
+      Previous insights: {all_insights[-3:] if all_insights else 'None yet'}
+
+      For depth level {step + 1}:
+      1. Explore deeper implications from each perspective
+      2. Identify GOLD insights (valuable, non-obvious findings) - mark with [GOLD]
+      3. Identify CLIFF warnings (pitfalls, caveats, risks) - mark with [CLIFF]
+      4. Connect insights across perspectives
+
+      Exploration factor: {exploration} (higher = more diverse exploration)
+      Creativity factor: {creativity} (higher = more novel connections)"""
+
+          resp = get_llm_response(
+              explore_prompt,
+              model=model,
+              provider=provider,
+              temperature=creativity,
+              npc=npc
+          )
+
+          step_insights = str(resp.get('response', ''))
+          print(step_insights)
+
+          # Extract gold and cliff markers
+          if '[GOLD]' in step_insights:
+              gold_insights.extend([line.strip() for line in step_insights.split('\n') if '[GOLD]' in line])
+          if '[CLIFF]' in step_insights:
+              cliff_warnings.extend([line.strip() for line in step_insights.split('\n') if '[CLIFF]' in line])
+
+          all_insights.append(step_insights)
+
+      # Generate final synthesis
+      print(colored("\n--- Synthesizing Research ---", "cyan"))
+
+      synthesis_prompt = f"""Synthesize research on: "{query}"
+
+      All insights gathered:
+      {chr(10).join(all_insights)}
+
+      Gold insights identified:
+      {chr(10).join(gold_insights) if gold_insights else 'None explicitly marked'}
+
+      Cliff warnings identified:
+      {chr(10).join(cliff_warnings) if cliff_warnings else 'None explicitly marked'}
+
+      Generate a {output_format} that:
+      1. Summarizes key findings
+      2. Highlights the most valuable insights (gold)
+      3. Notes important caveats and risks (cliffs)
+      4. Provides actionable conclusions"""
+
+      resp = get_llm_response(
+          synthesis_prompt,
+          model=model,
+          provider=provider,
+          npc=npc
+      )
+
+      final_report = str(resp.get('response', ''))
+      print("\n" + "="*60)
+      print(colored("ALICANTO RESEARCH REPORT", "green", attrs=['bold']))
+      print("="*60)
+      print(final_report)
+
+      context['output'] = final_report
+      context['messages'] = messages
+      context['alicanto_result'] = {
+          'query': query,
+          'perspectives': perspectives,
+          'insights': all_insights,
+          'gold': gold_insights,
+          'cliffs': cliff_warnings,
+          'report': final_report
+      }