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

npcsh-1.1.13.data/data/npcsh/npc_team/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
+      }

npcsh-1.1.13.data/data/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-1.1.13.data/data/npcsh/npc_team/build.jinx

@@ -0,0 +1,65 @@
+jinx_name: "build"
+description: "Build deployment artifacts for NPC team"
+inputs:
+  - target: "flask" # The type of deployment target (e.g., flask, docker, cli, static).
+  - output: "./build" # The output directory for built artifacts.
+  - team: "./npc_team" # The path to the NPC team directory.
+  - port: 5337 # The port for flask server builds.
+  - cors: "" # Comma-separated CORS origins for flask server builds.
+steps:
+  - name: "execute_build"
+    engine: "python"
+    code: |
+      import os
+      
+      # Assume these build functions are available in the execution environment
+      # from a larger project context, e.g., from npcpy.build_funcs
+      try:
+          from npcpy.build_funcs import (
+              build_flask_server,
+              build_docker_compose,
+              build_cli_executable,
+              build_static_site,
+          )
+      except ImportError:
+          # Provide mock functions for demonstration or error handling
+          def build_flask_server(config, **kwargs): return {"output": f"Mock build flask: {config}", "messages": []}
+          def build_docker_compose(config, **kwargs): return {"output": f"Mock build docker: {config}", "messages": []}
+          def build_cli_executable(config, **kwargs): return {"output": f"Mock build cli: {config}", "messages": []}
+          def build_static_site(config, **kwargs): return {"output": f"Mock build static: {config}", "messages": []}
+
+      target = context.get('target')
+      output_dir = context.get('output')
+      team_path = context.get('team')
+      port = context.get('port')
+      cors_origins_str = context.get('cors')
+      
+      cors_origins = [origin.strip() for origin in cors_origins_str.split(',')] if cors_origins_str.strip() else None
+
+      build_config = {
+          'team_path': os.path.abspath(os.path.expanduser(team_path)),
+          'output_dir': os.path.abspath(os.path.expanduser(output_dir)),
+          'target': target,
+          'port': port,
+          'cors_origins': cors_origins,
+      }
+      
+      builders = {
+          'flask': build_flask_server,
+          'docker': build_docker_compose,
+          'cli': build_cli_executable,
+          'static': build_static_site,
+      }
+      
+      output_messages = context.get('messages', [])
+      output_result = ""
+
+      if target not in builders:
+          output_result = f"Unknown target: {target}. Available: {list(builders.keys())}"
+      else:
+          result = builders[target](build_config, messages=output_messages)
+          output_result = result.get('output', 'Build command executed.')
+          output_messages = result.get('messages', output_messages) # Update messages from builder call
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh-1.1.13.data/data/npcsh/npc_team/chat.jinx

@@ -0,0 +1,44 @@
+jinx_name: chat
+description: Simple chat mode - LLM conversation without tool execution
+inputs:
+  - query: null
+  - model: null
+  - provider: null
+  - stream: true
+
+steps:
+  - name: chat_response
+    engine: python
+    code: |
+      from npcpy.llm_funcs import get_llm_response
+
+      npc = context.get('npc')
+      messages = context.get('messages', [])
+      query = context.get('query', '')
+      stream = context.get('stream', True)
+
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      if not query:
+          context['output'] = ''
+          context['messages'] = messages
+      else:
+          response = get_llm_response(
+              query,
+              model=model,
+              provider=provider,
+              npc=npc,
+              stream=stream,
+              messages=messages
+          )
+
+          context['output'] = response.get('response', '')
+          context['messages'] = response.get('messages', messages)
+
+          # Track usage
+          if 'usage' in response and npc and hasattr(npc, 'shared_context'):
+              usage = response['usage']
+              npc.shared_context['session_input_tokens'] += usage.get('input_tokens', 0)
+              npc.shared_context['session_output_tokens'] += usage.get('output_tokens', 0)
+              npc.shared_context['turn_count'] += 1

npcsh-1.1.13.data/data/npcsh/npc_team/cmd.jinx

@@ -0,0 +1,44 @@
+jinx_name: cmd
+description: Command mode - LLM generates and executes shell commands
+inputs:
+  - query: null
+  - model: null
+  - provider: null
+  - stream: true
+
+steps:
+  - name: cmd_execute
+    engine: python
+    code: |
+      from npcpy.llm_funcs import execute_llm_command
+
+      npc = context.get('npc')
+      messages = context.get('messages', [])
+      query = context.get('query', '')
+      stream = context.get('stream', True)
+
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      if not query:
+          context['output'] = ''
+          context['messages'] = messages
+      else:
+          response = execute_llm_command(
+              query,
+              model=model,
+              provider=provider,
+              npc=npc,
+              stream=stream,
+              messages=messages
+          )
+
+          context['output'] = response.get('response', '')
+          context['messages'] = response.get('messages', messages)
+
+          # Track usage
+          if 'usage' in response and npc and hasattr(npc, 'shared_context'):
+              usage = response['usage']
+              npc.shared_context['session_input_tokens'] += usage.get('input_tokens', 0)
+              npc.shared_context['session_output_tokens'] += usage.get('output_tokens', 0)
+              npc.shared_context['turn_count'] += 1

npcsh-1.1.13.data/data/npcsh/npc_team/compile.jinx

@@ -0,0 +1,50 @@
+jinx_name: "compile"
+description: "Compile NPC profiles"
+inputs:
+  - npc_file_path: "" # Optional path to a specific NPC file to compile.
+  - npc_team_dir: "./npc_team" # Directory containing NPC profiles to compile, if no specific file is given.
+steps:
+  - name: "compile_npcs"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.npc_compiler import NPC, Team # Assuming Team might be needed for full directory compilation
+      
+      npc_file_path_arg = context.get('npc_file_path')
+      npc_team_dir = context.get('npc_team_dir')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      compiled_npc_object = None
+      
+      try:
+          if npc_file_path_arg and npc_file_path_arg.strip():
+              npc_full_path = os.path.abspath(os.path.expanduser(npc_file_path_arg))
+              if os.path.exists(npc_full_path):
+                  # Assuming NPC() constructor "compiles" it by loading its definition
+                  compiled_npc_object = NPC(file=npc_full_path, db_conn=context.get('db_conn'))
+                  output_result = f"Compiled NPC: {npc_full_path}"
+              else:
+                  output_result = f"Error: NPC file not found: {npc_full_path}"
+          else:
+              # Compile all NPCs in the directory. This would typically involve iterating and loading.
+              # For simplicity in this Jinx, we just acknowledge the directory.
+              # A more robust implementation would loop through .npc files and compile them.
+              abs_npc_team_dir = os.path.abspath(os.path.expanduser(npc_team_dir))
+              if os.path.exists(abs_npc_team_dir):
+                  output_result = f"Acknowledged compilation for all NPCs in directory: {abs_npc_team_dir}"
+                  # Example of loading a Team and setting the compiled_npc_object to its forenpc if available
+                  # team = Team(team_path=abs_npc_team_dir, db_conn=context.get('db_conn'))
+                  # if team.forenpc:
+                  #    compiled_npc_object = team.forenpc 
+              else:
+                  output_result = f"Error: NPC team directory not found: {npc_team_dir}"
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error compiling: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages
+      if compiled_npc_object:
+          context['compiled_npc_object'] = compiled_npc_object # Store the compiled NPC object if any

npcsh-1.1.13.data/data/npcsh/npc_team/compress.jinx

@@ -0,0 +1,140 @@
+jinx_name: "compress"
+description: "Manages conversation and knowledge context. Defaults to compacting context. Use flags for other operations."
+inputs:
+  - flush: ""       # The number of recent messages to flush.
+  - sleep: False    # If true, evolves the knowledge graph.
+  - dream: False    # Used with --sleep. Runs creative synthesis.
+  - ops: ""         # Used with --sleep. Comma-separated list of KG operations.
+  - model: ""       # Used with --sleep. LLM model for KG evolution.
+  - provider: ""    # Used with --sleep. LLM provider for KG evolution.
+steps:
+  - name: "manage_context_and_memory"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.llm_funcs import breathe
+      from npcpy.memory.command_history import CommandHistory, load_kg_from_db, save_kg_to_db
+      from npcpy.memory.knowledge_graph import kg_sleep_process, kg_dream_process
+
+      # --- Get all inputs from context ---
+      flush_n_str = context.get('flush')
+      is_sleeping = context.get('sleep')
+      is_dreaming = context.get('dream')
+      operations_str = context.get('ops')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      
+      USAGE = """Usage:
+        /compress                       (Compacts conversation context)
+        /compress --flush <number>        (Removes the last N messages)
+        /compress --sleep [...]         (Evolves the knowledge graph)
+          --dream                       (With --sleep: enables creative synthesis)
+          --ops "op1,op2"               (With --sleep: specifies KG operations)
+          --model <name>                (With --sleep: specifies LLM model)
+          --provider <name>             (With --sleep: specifies LLM provider)"""
+
+      # --- Argument Validation: Ensure mutual exclusivity ---
+      is_flushing = flush_n_str is not None and flush_n_str.strip() != ''
+      if is_sleeping and is_flushing:
+          context['output'] = f"Error: --sleep and --flush are mutually exclusive.\n{USAGE}"
+          context['messages'] = output_messages
+          exit()
+
+      # --- Dispatcher: Route to the correct functionality ---
+
+      # 1. SLEEP: Evolve the Knowledge Graph
+      if is_sleeping:
+          current_npc = context.get('npc')
+          current_team = context.get('team')
+          
+          # Parameter setup for KG process
+          operations_config = [op.strip() for op in operations_str.split(',')] if operations_str else None
+          if not llm_model and current_npc: llm_model = current_npc.model
+          if not llm_provider and current_npc: llm_provider = current_npc.provider
+          if not llm_model: llm_model = "gemini-1.5-pro"
+          if not llm_provider: llm_provider = "gemini"
+
+          team_name = current_team.name if current_team else "__none__"
+          npc_name = current_npc.name if current_npc else "__none__"
+          current_path = os.getcwd()
+          scope_str = f"Team: '{team_name}', NPC: '{npc_name}', Path: '{current_path}'"
+          
+          command_history = None
+          try:
+              db_path = os.getenv("NPCSH_DB_PATH", os.path.expanduser("~/npcsh_history.db"))
+              command_history = CommandHistory(db_path)
+              engine = command_history.engine
+              current_kg = load_kg_from_db(engine, team_name, npc_name, current_path)
+
+              if not current_kg or not current_kg.get('facts'):
+                  context['output'] = f"Knowledge graph for the current scope is empty. Nothing to process.\n- Scope: {scope_str}"
+                  exit()
+
+              original_facts = len(current_kg.get('facts', []))
+              original_concepts = len(current_kg.get('concepts', []))
+              
+              evolved_kg, _ = kg_sleep_process(existing_kg=current_kg, model=llm_model, provider=llm_provider, npc=current_npc, operations_config=operations_config)
+              process_type = "Sleep"
+
+              if is_dreaming:
+                  evolved_kg, _ = kg_dream_process(existing_kg=evolved_kg, model=llm_model, provider=llm_provider, npc=current_npc)
+                  process_type += " & Dream"
+
+              save_kg_to_db(engine, evolved_kg, team_name, npc_name, current_path)
+              
+              new_facts = len(evolved_kg.get('facts', []))
+              new_concepts = len(evolved_kg.get('concepts', []))
+              
+              context['output'] = (f"{process_type} process complete.\n"
+                                   f"- Facts: {original_facts} -> {new_facts} ({new_facts - original_facts:+})\n"
+                                   f"- Concepts: {original_concepts} -> {new_concepts} ({new_concepts - original_concepts:+})")
+          except Exception as e:
+              traceback.print_exc()
+              context['output'] = f"Error during KG evolution: {e}"
+          finally:
+              if command_history: command_history.close()
+              context['messages'] = output_messages
+
+      # 2. FLUSH: Remove messages from context
+      elif is_flushing:
+          try:
+              n = int(flush_n_str)
+              if n <= 0:
+                  context['output'] = "Error: Number of messages to flush must be positive."
+                  exit()
+          except ValueError:
+              context['output'] = f"Error: Invalid number '{flush_n_str}'. {USAGE}"
+              exit()
+
+          messages_list = list(output_messages)
+          original_len = len(messages_list)
+          final_messages = []
+          
+          if messages_list and messages_list[0].get("role") == "system":
+              system_message = messages_list.pop(0)
+              num_to_remove = min(n, len(messages_list))
+              final_messages = [system_message] + messages_list[:-num_to_remove]
+          else:
+              num_to_remove = min(n, original_len)
+              final_messages = messages_list[:-num_to_remove]
+          
+          removed_count = original_len - len(final_messages)
+          context['output'] = f"Flushed {removed_count} message(s). Context is now {len(final_messages)} messages."
+          context['messages'] = final_messages
+
+      # 3. DEFAULT: Compact conversation context
+      else:
+          try:
+              result = breathe(**context)
+              if isinstance(result, dict):
+                  context['output'] = result.get('output', 'Context compressed.')
+                  context['messages'] = result.get('messages', output_messages)
+              else:
+                  context['output'] = "Context compression process initiated."
+                  context['messages'] = output_messages
+          except Exception as e:
+              traceback.print_exc()
+              context['output'] = f"Error during context compression: {e}"
+              context['messages'] = output_messages