npcsh 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

npcsh-1.1.6.data/data/npcsh/npc_team/plonk.jinx

@@ -0,0 +1,57 @@
+jinx_name: "plonk"
+description: "Use vision model to interact with GUI. Usage: /plonk <task description>"
+inputs:
+  - task_description: "" # Required task description for GUI interaction.
+  - vmodel: "" # Vision model to use. Defaults to NPCSH_VISION_MODEL or NPC's model.
+  - vprovider: "" # Vision model provider. Defaults to NPCSH_VISION_PROVIDER or NPC's provider.
+steps:
+  - name: "execute_plonk"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.plonk import execute_plonk_command, format_plonk_summary
+      # Assuming NPCSH_VISION_MODEL and NPCSH_VISION_PROVIDER are accessible
+      
+      task_description = context.get('task_description')
+      vision_model = context.get('vmodel')
+      vision_provider = context.get('vprovider')
+      plonk_context = context.get('plonk_context') # Passed from original context
+      current_npc = context.get('npc')
+      output_messages = context.get('messages', [])
+      
+      if not task_description or not task_description.strip():
+          context['output'] = "Usage: /plonk <task_description> [--vmodel model_name] [--vprovider provider_name]"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not vision_model and current_npc and current_npc.model:
+          vision_model = current_npc.model
+      if not vision_provider and current_npc and current_npc.provider:
+          vision_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not vision_model: vision_model = "gemini-1.5-pro-vision" # Example default
+      if not vision_provider: vision_provider = "gemini" # Example default
+
+      try:
+          summary_data = execute_plonk_command(
+              request=task_description,
+              model=vision_model,
+              provider=vision_provider,
+              npc=current_npc,
+              plonk_context=plonk_context,
+              debug=True # Assuming debug is often desired for plonk
+          )        
+          
+          if summary_data and isinstance(summary_data, list):
+              output_report = format_plonk_summary(summary_data)
+              context['output'] = output_report
+          else:
+              context['output'] = "Plonk command did not complete within the maximum number of iterations."
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error executing plonk command: {e}"
+      
+      context['messages'] = output_messages

npcsh-1.1.6.data/data/npcsh/npc_team/pti.jinx

@@ -0,0 +1,28 @@
+jinx_name: "pti"
+description: "Enter Pardon-The-Interruption mode for human-in-the-loop reasoning."
+inputs:
+  - command_args: "" # The full command string or specific arguments for PTI mode.
+steps:
+  - name: "enter_pti"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.pti import enter_pti_mode
+      
+      command_args = context.get('command_args', '') # The full command string from router
+      output_messages = context.get('messages', [])
+      
+      try:
+          # enter_pti_mode likely expects the full command string for its own parsing
+          result = enter_pti_mode(command=command_args, **context)
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Entered PTI mode.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error entering pti mode: {e}"
+          context['messages'] = output_messages

npcsh-1.1.4.data/data/npcsh/npc_team/python_executor.jinx → npcsh-1.1.6.data/data/npcsh/npc_team/python.jinx

@@ -1,4 +1,4 @@
-jinx_name: python_executor
+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. 

npcsh-1.1.6.data/data/npcsh/npc_team/roll.jinx

@@ -0,0 +1,66 @@
+jinx_name: "roll"
+description: "Generate a video from a text prompt."
+inputs:
+  - prompt: "" # Required text prompt for video generation.
+  - num_frames: 125 # Number of frames for the video.
+  - width: 256 # Width of the video.
+  - height: 256 # Height of the video.
+  - output_path: "output.mp4" # Output file path for the video.
+  - vgmodel: "" # Video generation model to use. Defaults to NPCSH_VIDEO_GEN_MODEL or NPC's model.
+  - vgprovider: "" # Video generation provider to use. Defaults to NPCSH_VIDEO_GEN_PROVIDER or NPC's provider.
+steps:
+  - name: "generate_video"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.llm_funcs import gen_video
+      # Assuming NPCSH_VIDEO_GEN_MODEL and NPCSH_VIDEO_GEN_PROVIDER are accessible
+      
+      prompt = context.get('prompt')
+      num_frames = int(context.get('num_frames', 125)) # Ensure int type
+      width = int(context.get('width', 256)) # Ensure int type
+      height = int(context.get('height', 256)) # Ensure int type
+      output_path = context.get('output_path')
+      video_gen_model = context.get('vgmodel')
+      video_gen_provider = context.get('vgprovider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      
+      if not prompt or not prompt.strip():
+          context['output'] = "Usage: /roll <your prompt>"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not video_gen_model and current_npc and current_npc.model:
+          video_gen_model = current_npc.model
+      if not video_gen_provider and current_npc and current_npc.provider:
+          video_gen_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not video_gen_model: video_gen_model = "stable-video-diffusion" # Example default
+      if not video_gen_provider: video_gen_provider = "diffusers" # Example default
+
+      try:
+          result = gen_video(
+              prompt=prompt,
+              model=video_gen_model,
+              provider=video_gen_provider,
+              npc=current_npc,
+              num_frames=num_frames,
+              width=width,
+              height=height,
+              output_path=output_path,
+              **context.get('api_kwargs', {}) # Assuming api_kwargs might be passed
+          )
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Video generated.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error generating video: {e}"
+          context['messages'] = output_messages

npcsh-1.1.6.data/data/npcsh/npc_team/sample.jinx

@@ -0,0 +1,56 @@
+jinx_name: "sample"
+description: "Send a prompt directly to the LLM."
+inputs:
+  - prompt: "" # Required text prompt to send to the LLM.
+  - model: "" # LLM model to use. Defaults to NPC's model.
+  - provider: "" # LLM provider to use. Defaults to NPC's provider.
+steps:
+  - name: "send_prompt_to_llm"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      
+      prompt = context.get('prompt')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      if not prompt or not prompt.strip():
+          context['output'] = "Usage: /sample <your prompt> [-m --model] model  [-p --provider] provider"
+          context['messages'] = output_messages
+          exit()
+      
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not llm_model and current_npc and current_npc.model:
+          llm_model = current_npc.model
+      if not llm_provider and current_npc and current_npc.provider:
+          llm_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not llm_model: llm_model = "gemini-1.5-pro" # Example default
+      if not llm_provider: llm_provider = "gemini" # Example default
+
+      try:
+          result = get_llm_response(
+              prompt=prompt,
+              model=llm_model,
+              provider=llm_provider,
+              npc=current_npc,
+              **{k:v for k,v in context.items() if k not in ['messages', 'prompt', 'model', 'provider']} # Pass other context
+          )
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('response')
+              context['messages'] = result.get('messages', output_messages)
+              context['model'] = llm_model
+              context['provider'] = llm_provider
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error sampling LLM: {e}"
+          context['messages'] = output_messages

npcsh-1.1.6.data/data/npcsh/npc_team/search.jinx

@@ -0,0 +1,130 @@
+jinx_name: "search"
+description: >
+  Executes a search across various sources.
+  Usage:
+    /search <query>                         (Default: Web Search)
+    /search --memory <query>                (Search approved memories)
+    /search --kg <query>                    (Search the knowledge graph)
+    /search --rag [-f <paths>] <query>      (Execute a RAG search)
+    /search --brainblast <query>            (Advanced history search)
+inputs:
+  - query: ""
+  - memory: false
+  - kg: false
+  - rag: false
+  - brainblast: false
+  - file_paths: ""
+  - history_db_path: "~/npcsh_history.db"
+  - vector_db_path: "~/npcsh_chroma.db"
+  - sprovider: ""
+  - emodel: ""
+  - eprovider: ""
+steps:
+  - name: "execute_unified_search"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      
+      # Access query from context
+      query = context.get('query')
+      if not query or not query.strip():
+          context['output'] = "Usage: /search [--memory|--kg|--rag|--brainblast] <query>"
+      else:
+          # state is available as a GLOBAL variable (from extra_globals)
+          # Access it directly, not from context
+          try:
+              current_state = state  # This should work now
+          except NameError:
+              context['output'] = "Error: Shell state not available in jinx context"
+              raise
+          
+          current_npc = current_state.npc
+          current_team = current_state.team
+          
+          npc_name = getattr(current_npc, 'name', '__none__') if current_npc else '__none__'
+          team_name = getattr(current_team, 'name', '__none__') if current_team else '__none__'
+          current_path = os.getcwd()
+          db_path = os.path.expanduser(context.get("history_db_path"))
+          
+          try:
+              cmd_history = CommandHistory(db_path)
+              
+              if context.get('memory'):
+                  memories = get_relevant_memories(
+                      command_history=cmd_history, 
+                      npc_name=npc_name, 
+                      team_name=team_name,
+                      path=current_path, 
+                      query=query, 
+                      max_memories=10, 
+                      state=current_state  # Pass the state object
+                  )
+                  print(memories)
+                  
+                  if not memories:
+                      output = f"No memories found for query: '{query}'"
+                  else:
+                      output = f"Found {len(memories)} memories:\n\n" + "\n".join(
+                          f"{i}. [{mem.get('timestamp', 'unknown')}] {mem.get('final_memory') or mem.get('initial_memory')}" 
+                          for i, mem in enumerate(memories, 1)
+                      )
+              
+              elif context.get('kg'):
+                  facts = search_kg_facts(
+                      cmd_history, 
+                      npc_name, 
+                      team_name, 
+                      current_path, 
+                      query
+                  )
+                  print(facts)
+                  
+                  if not facts:
+                      output = f"No KG facts found for query: '{query}'"
+                  else:
+                      output = f"Found {len(facts)} KG facts:\n\n" + "\n".join(
+                          f"{i}. {fact.get('statement')}" for i, fact in enumerate(facts, 1)
+                      )
+
+              elif context.get('rag'):
+                  file_paths_str = context.get('file_paths', '')
+                  file_paths = [os.path.abspath(os.path.expanduser(p.strip())) for p in file_paths_str.split(',') if p.strip()]
+                  emodel = context.get('emodel') or current_state.embedding_model
+                  eprovider = context.get('eprovider') or current_state.embedding_provider
+                  
+                  file_contents = []
+                  for path in file_paths:
+                      chunks = load_file_contents(path)
+                      basename = os.path.basename(path)
+                      file_contents.extend([f"{basename}: {chunk}" for chunk in chunks])
+
+                  result = execute_rag_command(
+                      command=query,
+                      vector_db_path=os.path.expanduser(context.get('vector_db_path')),
+                      embedding_model=emodel,
+                      embedding_provider=eprovider,
+                      file_contents=file_contents or None
+                  )
+                  print(result)
+                  output = result.get('response', 'No response from RAG.')
+
+              elif context.get('brainblast'):
+                  result = execute_brainblast_command(
+                      command=query, 
+                      command_history=cmd_history, 
+                      **context
+                  )
+                  print(result)
+                  output = result.get('output', 'Brainblast search executed.')
+
+              else:
+                  # Default to web search
+                  provider = context.get('sprovider') or current_state.search_provider
+                  results = search_web(query, provider=provider)
+                  output = "\n".join([f"- {res}" for res in results]) if results else "No web results found."
+
+          except Exception as e:
+              output = f"An error occurred in the search jinx: {e}\n{traceback.format_exc()}"
+
+          context['output'] = output

npcsh-1.1.6.data/data/npcsh/npc_team/serve.jinx

@@ -0,0 +1,29 @@
+jinx_name: "serve"
+description: "Serve an NPC Team"
+inputs:
+  - port: 5337 # The port to run the Flask server on.
+  - cors: "" # Comma-separated CORS origins.
+steps:
+  - name: "start_flask_server"
+    engine: "python"
+    code: |
+      from npcpy.serve import start_flask_server
+      
+      port = context.get('port')
+      cors_str = context.get('cors')
+      output_messages = context.get('messages', [])
+
+      cors_origins = None
+      if cors_str and cors_str.strip():
+          cors_origins = [origin.strip() for origin in cors_str.split(",")]
+
+      # start_flask_server blocks, so this will hold the Jinx until the server is stopped.
+      # In a real-world scenario, you might want to run this in a separate process
+      # or have a non-blocking server start.
+      start_flask_server(
+          port=int(port), # Ensure port is an integer
+          cors_origins=cors_origins,
+      )
+
+      context['output'] = "NPC Team server started. Execution of this jinx will pause until the server is stopped."
+      context['messages'] = output_messages

npcsh-1.1.6.data/data/npcsh/npc_team/set.jinx

@@ -0,0 +1,40 @@
+jinx_name: "set"
+description: "Set configuration values"
+inputs:
+  - key: "" # The configuration key to set.
+  - value: "" # The value to set for the configuration key.
+steps:
+  - name: "set_config_value"
+    engine: "python"
+    code: |
+      import traceback
+      # Assuming set_npcsh_config_value is accessible
+      try:
+          from npcsh._state import set_npcsh_config_value
+      except ImportError:
+          def set_npcsh_config_value(key, value):
+              print(f"Mock: Setting config '{key}' to '{value}'")
+              # In a real scenario, this might write to a config file or global state
+              pass
+
+      key = context.get('key')
+      value = context.get('value')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      if not key or not value:
+          context['output'] = "Usage: /set <key>=<value>"
+          context['messages'] = output_messages
+          exit()
+
+      try:
+          set_npcsh_config_value(key, value)
+          output_result = f"Configuration value '{key}' set."
+      except NameError:
+          output_result = "Set function (set_npcsh_config_value) not available."
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error setting configuration '{key}': {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh-1.1.4.data/data/npcsh/npc_team/bash_executer.jinx → npcsh-1.1.6.data/data/npcsh/npc_team/sh.jinx

@@ -1,8 +1,7 @@
-jinx_name: bash_executor
+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
-- user_request
 steps:
   - engine: python
     code: |

npcsh-1.1.6.data/data/npcsh/npc_team/sleep.jinx

@@ -0,0 +1,116 @@
+jinx_name: "sleep"
+description: "Evolve knowledge graph. Use --dream to also run creative synthesis."
+inputs:
+  - dream: False # Boolean flag to also run creative synthesis (dream process).
+  - ops: "" # Comma-separated list of operations to configure KG sleep process.
+  - model: "" # LLM model to use for KG evolution. Defaults to NPC's model.
+  - provider: "" # LLM provider to use for KG evolution. Defaults to NPC's provider.
+steps:
+  - name: "evolve_knowledge_graph"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      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
+      # Assuming render_markdown is available if needed for logging progress
+
+      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', [])
+      current_npc = context.get('npc')
+      current_team = context.get('team')
+
+      operations_config = None
+      if operations_str and isinstance(operations_str, str):
+          operations_config = [op.strip() for op in operations_str.split(',')]
+      
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not llm_model and current_npc and current_npc.model:
+          llm_model = current_npc.model
+      if not llm_provider and current_npc and current_npc.provider:
+          llm_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not llm_model: llm_model = "gemini-1.5-pro" # Example default
+      if not llm_provider: llm_provider = "gemini" # Example default
+
+      team_name = current_team.name if current_team else "__none__"
+      npc_name = current_npc.name if isinstance(current_npc, type(None).__class__) else "__none__"
+      current_path = os.getcwd()
+      scope_str = f"Team: '{team_name}', NPC: '{npc_name}', Path: '{current_path}'"
+
+      # Assume render_markdown exists
+      # render_markdown(f"- Checking knowledge graph for scope: {scope_str}")
+
+      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
+      except Exception as e:
+          context['output'] = f"Error connecting to history database for KG access: {e}"
+          context['messages'] = output_messages
+          exit()
+
+      output_result = ""
+      try:
+          current_kg = load_kg_from_db(engine, team_name, npc_name, current_path)
+
+          if not current_kg or not current_kg.get('facts'):
+              output_msg = f"Knowledge graph for the current scope is empty. Nothing to process.\n"
+              output_msg += f"  - Scope Checked: {scope_str}\n\n"
+              output_msg += "**Hint:** Have a conversation or run some commands first to build up knowledge in this specific context. The KG is unique to each combination of Team, NPC, and directory."
+              context['output'] = output_msg
+              context['messages'] = output_messages
+              exit()
+
+          original_facts = len(current_kg.get('facts', []))
+          original_concepts = len(current_kg.get('concepts', []))
+          
+          process_type = "Sleep"
+          ops_display = f"with operations: {operations_config}" if operations_config else "with random operations"
+          # render_markdown(f"- Initiating sleep process {ops_display}")
+          
+          evolved_kg, _ = kg_sleep_process(
+              existing_kg=current_kg,
+              model=llm_model,
+              provider=llm_provider,
+              npc=current_npc,
+              operations_config=operations_config
+          )
+
+          if is_dreaming:
+              process_type += " & Dream"
+              # render_markdown(f"- Initiating dream process on the evolved KG...")
+              evolved_kg, _ = kg_dream_process(
+                  existing_kg=evolved_kg,
+                  model=llm_model,
+                  provider=llm_provider,
+                  npc=current_npc
+              )
+
+          save_kg_to_db(engine, evolved_kg, team_name, npc_name, current_path) # Changed conn to engine
+
+          new_facts = len(evolved_kg.get('facts', []))
+          new_concepts = len(evolved_kg.get('concepts', []))
+
+          output_result = f"{process_type} process complete.\n"
+          output_result += f"- Facts: {original_facts} -> {new_facts} ({new_facts - original_facts:+})\n"
+          output_result += f"- Concepts: {original_concepts} -> {new_concepts} ({new_concepts - original_concepts:+})"
+          
+          print('Evolved facts:', evolved_kg.get('facts'))
+          print('Evolved concepts:', evolved_kg.get('concepts'))
+          
+          context['output'] = output_result
+          context['messages'] = output_messages
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error during KG evolution process: {e}"
+          context['messages'] = output_messages
+      finally:
+          if command_history: # Check if it was successfully initialized
+              command_history.close()

npcsh-1.1.6.data/data/npcsh/npc_team/spool.jinx

@@ -0,0 +1,40 @@
+jinx_name: "spool"
+description: "Enter interactive chat (spool) mode"
+inputs: [] # Spool mode typically takes its parameters directly from the environment/kwargs
+steps:
+  - name: "enter_spool"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.npc_compiler import NPC, Team
+      from npcsh.spool import enter_spool_mode
+      
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      current_team = context.get('team')
+
+      try:
+          # Handle potential string NPC name if passed from CLI
+          if isinstance(current_npc, str) and current_team:
+              npc_name = current_npc
+              if npc_name in current_team.npcs:
+                  current_npc = current_team.npcs[npc_name]
+              else:
+                  context['output'] = f"Error: NPC '{npc_name}' not found in team. Available NPCs: {', '.join(current_team.npcs.keys())}"
+                  context['messages'] = output_messages
+                  exit()
+          context['npc'] = current_npc # Ensure the NPC object is updated in context
+          
+          result = enter_spool_mode(**context) # Pass all context as kwargs
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Exited Spool Mode.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error entering spool mode: {e}"
+          context['messages'] = output_messages

npcsh-1.1.6.data/data/npcsh/npc_team/sql.jinx

@@ -0,0 +1,16 @@
+jinx_name: sql_executor
+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-1.1.6.data/data/npcsh/npc_team/trigger.jinx

@@ -0,0 +1,36 @@
+jinx_name: "trigger"
+description: "Execute a trigger command"
+inputs:
+  - trigger_description: "" # Required description of the trigger to execute.
+steps:
+  - name: "execute_trigger"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.work.trigger import execute_trigger_command
+      
+      trigger_description = context.get('trigger_description')
+      output_messages = context.get('messages', [])
+      
+      if not trigger_description or not trigger_description.strip():
+          context['output'] = "Usage: /trigger <trigger_description>"
+          context['messages'] = output_messages
+          exit()
+      
+      try:
+          # Pass all current context as kwargs to execute_trigger_command
+          result = execute_trigger_command(command=trigger_description, **context)
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Trigger executed.')
+              context['messages'] = result.get('messages', output_messages)
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      except NameError:
+          context['output'] = "Trigger function (execute_trigger_command) not available."
+          context['messages'] = output_messages
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error executing trigger: {e}"
+          context['messages'] = output_messages