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

npcsh/npc_team/jinxs/utils/core/init.jinx

@@ -0,0 +1,41 @@
+jinx_name: "init"
+description: "Initialize NPC project"
+inputs:
+  - directory: "." # The directory where the NPC project should be initialized.
+  - templates: "" # Optional templates to use for initialization.
+  - context: "" # Optional context for project initialization.
+  - model: "" # Optional LLM model to set as default for the project.
+  - provider: "" # Optional LLM provider to set as default for the project.
+steps:
+  - name: "initialize_project"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.npc_compiler import initialize_npc_project
+      
+      directory = context.get('directory')
+      templates = context.get('templates')
+      context_param = context.get('context') # Renamed to avoid conflict with Jinx context
+      model = context.get('model')
+      provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      try:
+          initialize_npc_project(
+              directory=directory,
+              templates=templates,
+              context=context_param, # Use the renamed context parameter
+              model=model,
+              provider=provider
+          )
+          output_result = f"NPC project initialized in {os.path.abspath(directory)}."
+      except NameError:
+          output_result = "Init function (initialize_npc_project) not available."
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error initializing project: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/core/jinxs.jinx

@@ -0,0 +1,32 @@
+jinx_name: jinxs
+description: Show available jinxs for the current NPC/Team
+inputs: []
+steps:
+  - name: list_jinxs
+    engine: python
+    code: |
+      output_lines = ["Available Jinxs:\n"]
+      jinxs_listed = set()
+      
+      if hasattr(npc, 'team') and npc.team:
+          team = npc.team
+          
+          if hasattr(team, 'jinxs_dict') and team.jinxs_dict:
+              output_lines.append(f"\n--- Team Jinxs ---\n")
+              for name, jinx_obj in sorted(team.jinxs_dict.items()):
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if hasattr(npc, 'jinxs_dict') and npc.jinxs_dict:
+          output_lines.append(f"\n--- NPC Jinxs for {npc.name} ---\n")
+          for name, jinx_obj in sorted(npc.jinxs_dict.items()):
+              if name not in jinxs_listed:
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if not jinxs_listed:
+          output = "No jinxs available for the current context."
+      else:
+          output = "".join(output_lines)

npcsh/npc_team/jinxs/utils/core/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/npc_team/jinxs/{edit_file.jinx → utils/edit_file.jinx}

@@ -1,4 +1,4 @@
-jinx_name: file_editor
+jinx_name: edit_file
 description: Examines a file, determines what changes are needed, and applies those
   changes.
 inputs:

npcsh/npc_team/jinxs/utils/flush.jinx

@@ -0,0 +1,39 @@
+jinx_name: "flush"
+description: "Flush the last N messages from the conversation history."
+inputs:
+  - n: 1 # The number of messages to flush (default to 1).
+steps:
+  - name: "flush_messages"
+    engine: "python"
+    code: |
+      n = int(context.get('n', 1))
+      output_messages = context.get('messages', [])
+      
+      if n <= 0:
+          context['output'] = "Error: Number of messages must be positive."
+          context['messages'] = output_messages
+          exit()
+
+      new_messages = list(output_messages)
+      original_len = len(new_messages)
+      removed_count = 0
+
+      if new_messages and new_messages[0].get("role") == "system":
+          system_message = new_messages[0]
+          working_messages = new_messages[1:]
+          num_to_remove = min(n, len(working_messages))
+          if num_to_remove > 0:
+              final_messages = [system_message] + working_messages[:-num_to_remove]
+              removed_count = num_to_remove
+          else:
+              final_messages = [system_message]
+      else:
+          num_to_remove = min(n, original_len)
+          if num_to_remove > 0:
+              final_messages = new_messages[:-num_to_remove]
+              removed_count = num_to_remove
+          else:
+              final_messages = []
+
+      context['output'] = f"Flushed {removed_count} message(s). Context is now {len(final_messages)} messages."
+      context['messages'] = final_messages

npcsh/npc_team/jinxs/utils/npc-studio.jinx

@@ -0,0 +1,77 @@
+jinx_name: "npc-studio"
+description: "Start npc studio"
+inputs:
+  - user_command: ""
+steps:
+  - name: "launch_npc_studio"
+    engine: "python"
+    code: |
+      import os
+      import subprocess
+      import sys
+      from pathlib import Path
+      import traceback
+      
+      NPC_STUDIO_DIR = Path.home() / ".npcsh" / "npc-studio"
+      
+      user_command = context.get('user_command')
+      output_messages = context.get('messages', [])
+      output_result = ""
+      
+      try:
+          if not NPC_STUDIO_DIR.exists():
+              os.makedirs(NPC_STUDIO_DIR.parent, exist_ok=True)
+              subprocess.check_call([
+                  "git", "clone",
+                  "https://github.com/npc-worldwide/npc-studio.git",
+                  str(NPC_STUDIO_DIR)
+              ])
+          else:
+              subprocess.check_call(
+                  ["git", "pull"],
+                  cwd=NPC_STUDIO_DIR
+              )
+          
+          subprocess.check_call(
+              ["npm", "install"], 
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          req_file = NPC_STUDIO_DIR / "requirements.txt"
+          if req_file.exists():
+              subprocess.check_call([
+                  sys.executable, 
+                  "-m", 
+                  "pip", 
+                  "install", 
+                  "-r", 
+                  str(req_file)
+              ])
+          
+          backend = subprocess.Popen(
+              [sys.executable, "npc_studio_serve.py"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          dev_server = subprocess.Popen(
+              ["npm", "run", "dev"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          frontend = subprocess.Popen(
+              ["npm", "start"],
+              cwd=NPC_STUDIO_DIR
+          )
+          
+          output_result = (
+              f"NPC Studio started!\n"
+              f"Backend PID={backend.pid}, "
+              f"Dev Server PID={dev_server.pid}, "
+              f"Frontend PID={frontend.pid}"
+          )
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Failed to start NPC Studio: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/ots.jinx

@@ -0,0 +1,61 @@
+jinx_name: "ots"
+description: "Take screenshot and analyze with vision model. Usage: /ots <prompt>"
+inputs:
+  - prompt
+  - image_paths_args: ""
+  - vmodel: ""
+  - vprovider: ""
+steps:
+  - name: "analyze_screenshot_or_image"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.data.image import capture_screenshot
+      
+      user_prompt = context.get('prompt') or ""
+      image_paths_args_str = context.get('image_paths_args') or ""
+      vision_model = context.get('vmodel') or ""
+      vision_provider = context.get('vprovider') or ""
+      stream_output = context.get('stream') or False
+      api_url = context.get('api_url') or ""
+      api_key = context.get('api_key') or ""
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      image_paths = []
+      if image_paths_args_str.strip():
+          for img_path_arg in image_paths_args_str.split(','):
+              full_path = os.path.abspath(os.path.expanduser(img_path_arg.strip()))
+              if os.path.exists(full_path):
+                  image_paths.append(full_path)
+      
+      if not image_paths:
+          screenshot_info = capture_screenshot(full=False)
+          if screenshot_info and "file_path" in screenshot_info:
+              image_paths.append(screenshot_info["file_path"])
+              print(f"📸 Screenshot captured: {screenshot_info.get('filename', os.path.basename(screenshot_info['file_path']))}")
+
+      if not vision_model:
+          vision_model = getattr(current_npc, 'model', 'gpt-4o-mini')
+      
+      if not vision_provider:
+          vision_provider = getattr(current_npc, 'provider', 'openai')
+
+      response_data = get_llm_response(
+          prompt=user_prompt,
+          model=vision_model,
+          provider=vision_provider,
+          messages=output_messages,
+          images=image_paths,
+          stream=stream_output,
+          npc=current_npc,
+          api_url=api_url or None,
+          api_key=api_key or None
+      )
+      
+      context['output'] = response_data.get('response', 'No response received')
+      context['messages'] = response_data.get('messages', output_messages)
+      context['model'] = vision_model
+      context['provider'] = vision_provider

npcsh/npc_team/jinxs/utils/plan.jinx

@@ -0,0 +1,33 @@
+jinx_name: "plan"
+description: "Execute a plan command"
+inputs:
+  - plan_description: "" # Description of the plan to execute.
+steps:
+  - name: "execute_plan"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.work.plan import execute_plan_command
+      
+      plan_description = context.get('plan_description')
+      output_messages = context.get('messages', [])
+      
+      if not plan_description or not plan_description.strip():
+          context['output'] = "Usage: /plan <description_of_plan>"
+          context['messages'] = output_messages
+          exit()
+      
+      try:
+          # Pass all current context as kwargs to execute_plan_command
+          result = execute_plan_command(command=plan_description, **context)
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Plan executed.')
+              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 executing plan: {e}"
+          context['messages'] = output_messages

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