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

npcsh/npc_team/jinxs/utils/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/npc_team/jinxs/utils/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

npcsh/npc_team/jinxs/utils/vixynt.jinx

@@ -0,0 +1,117 @@
+jinx_name: "vixynt"
+description: "Generates images from text descriptions or edits existing ones."
+inputs:
+  - prompt
+  - model: ""
+  - provider: ""
+  - output_name: ""
+  - attachments: ""
+  - n_images: 1
+  - height: 1024
+  - width: 1024
+steps:
+  - name: "generate_or_edit_image"
+    engine: "python"
+    code: |
+      import os
+      import base64
+      from io import BytesIO
+      from datetime import datetime
+      from PIL import Image
+      from npcpy.llm_funcs import gen_image
+      
+      # Extract inputs from context
+      image_prompt = context.get('prompt', '').strip()
+      output_name = context.get('output_name')
+      attachments_str = context.get('attachments')
+      n_images = int(context.get('n_images', 1))
+      height = int(context.get('height', 1024))
+      width = int(context.get('width', 1024))
+      model = context.get('model')
+      provider = context.get('provider')
+
+      input_images = []
+      if attachments_str and attachments_str.strip():
+          input_images = [p.strip() for p in attachments_str.split(',')]
+
+      # Use NPC's model/provider as fallback
+      if not model and npc and npc.model:
+          model = npc.model 
+      if not provider and npc and npc.provider:
+          provider = npc.provider
+      
+      # Final fallbacks
+      if not model:
+          model = "runwayml/stable-diffusion-v1-5"
+      if not provider:
+          provider = "diffusers"
+      
+      output_messages = context.get('messages', [])
+      
+      if not image_prompt:
+          context['output'] = "Error: No prompt provided for image generation."
+          context['messages'] = output_messages
+          exit()
+      
+      try:
+          # Generate image(s)
+          result = gen_image(
+              prompt=image_prompt,
+              model=model,
+              provider=provider,
+              npc=npc,
+              height=height,
+              width=width,
+              n_images=n_images, 
+              input_images=input_images if input_images else None
+          )
+          
+          # Ensure we have a list of images
+          if not isinstance(result, list):
+              images_list = [result] if result is not None else []
+          else:
+              images_list = result
+          
+          saved_files = []
+          
+          for i, image in enumerate(images_list):
+              if image is None:
+                  continue
+              
+              # Determine output filename
+              if output_name and output_name.strip():
+                  base_name, ext = os.path.splitext(os.path.expanduser(output_name))
+                  if not ext:
+                      ext = ".png"
+                  current_output_file = f"{base_name}_{i}{ext}" if len(images_list) > 1 else f"{base_name}{ext}"
+              else:
+                  os.makedirs(os.path.expanduser("~/.npcsh/images/"), exist_ok=True)
+                  current_output_file = (
+                      os.path.expanduser("~/.npcsh/images/")
+                      + f"image_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{i}.png"
+                  )
+              
+              # Save image to file
+              image.save(current_output_file)
+              saved_files.append(current_output_file)
+          
+          if saved_files:
+              if input_images:
+                  output = f"Image(s) edited and saved to: {', '.join(saved_files)}"
+              else:
+                  output = f"Image(s) generated and saved to: {', '.join(saved_files)}"
+              
+              # DO NOT include base64 data - just reference the file paths
+              output += f"\n\nThe image files have been saved and are ready to view."
+          else:
+              output = "No images were generated."
+              
+      except Exception as e:
+          import traceback
+          traceback.print_exc()
+          output = f"Error {'editing' if input_images else 'generating'} image: {str(e)}"
+      
+      context['output'] = output
+      context['messages'] = output_messages
+      context['model'] = model
+      context['provider'] = provider

npcsh/npcsh.py

@@ -21,7 +21,6 @@ from npcpy.memory.knowledge_graph import (
     kg_evolve_incremental
 )
 
-from npcsh.routes import router
 try:
     import readline
 except:
@@ -46,10 +45,6 @@ from npcsh._state import (
 
 
 def print_welcome_message():
-    '''
-    function for printing npcsh graphic
-    '''
-
     print(
             """
 ___________________________________________          
@@ -75,8 +70,9 @@ Begin by asking a question, issuing a bash command, or typing '/help' for more i
         )
 
 
-def run_repl(command_history: CommandHistory, initial_state: ShellState):
+def run_repl(command_history: CommandHistory, initial_state: ShellState, router):
     state = initial_state
+        
     print_welcome_message()
 
     render_markdown(f'- Using {state.current_mode} mode. Use /agent, /cmd, or /chat to switch to other modes')
@@ -85,7 +81,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
 
     is_windows = platform.system().lower().startswith("win")
     try:
-        completer = make_completer(state)
+        completer = make_completer(state, router)
         readline.set_completer(completer)
     except:
         pass
@@ -157,7 +153,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                 state.messages = [{"role": "system", "content": f"Session context: {compressed_state}"}]
 
             try:
-                completer = make_completer(state)
+                completer = make_completer(state, router)
                 readline.set_completer(completer)
             except:
                 pass
@@ -229,6 +225,8 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
         
 
 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}"
@@ -239,13 +237,17 @@ def main() -> None:
     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)
+         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='')
@@ -253,7 +255,7 @@ def main() -> None:
          elif output is not None:
               print(output)
     else:
-        run_repl(command_history, initial_state)
-
+        run_repl(command_history, initial_state, router)
+        
 if __name__ == "__main__":
     main()