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

{npcsh-1.1.5.data → npcsh-1.1.6.data}/data/npcsh/npc_team/npc-studio.jinx

@@ -1,7 +1,7 @@
 jinx_name: "npc-studio"
 description: "Start npc studio"
 inputs:
-  - user_command: "" # Any additional arguments to pass to the npc studio launch.
+  - user_command: ""
 steps:
   - name: "launch_npc_studio"
     engine: "python"
@@ -13,9 +13,12 @@ steps:
       import traceback
       
       NPC_STUDIO_DIR = Path.home() / ".npcsh" / "npc-studio"
-
-      def ensure_repo():
-          """Clone or update the npc-studio repo."""
+      
+      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([
@@ -28,55 +31,47 @@ steps:
                   ["git", "pull"],
                   cwd=NPC_STUDIO_DIR
               )
-
-      def install_dependencies():
-          """Install npm and pip dependencies."""
-          subprocess.check_call(["npm", "install"], 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)])
-
-      def launch_npc_studio(path_to_open: str = None):
-          """
-          Launch the NPC Studio backend + frontend.
-          Returns PIDs for processes.
-          """
-          ensure_repo()
-          install_dependencies()
-
+              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, 
-              shell = False
+              cwd=NPC_STUDIO_DIR
           )
           
-          # npm run dev is typically for the frontend development server
           dev_server = subprocess.Popen(
               ["npm", "run", "dev"],
-              cwd=NPC_STUDIO_DIR,
-              shell=False
+              cwd=NPC_STUDIO_DIR
           )
           
-          # npm start is typically for electron or other packaged frontend
           frontend = subprocess.Popen(
               ["npm", "start"],
-              cwd=NPC_STUDIO_DIR,
-              shell=False
+              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}"
           )
-
-          return backend, dev_server, frontend
-      
-      user_command = context.get('user_command')
-      output_messages = context.get('messages', [])
-      output_result = ""
-
-      try:
-          backend, electron, frontend = launch_npc_studio(user_command or None)
-          output_result = f"NPC Studio started!\nBackend PID={backend.pid}, Electron PID={electron.pid} 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
+      context['messages'] = output_messages

npcsh-1.1.6.data/data/npcsh/npc_team/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-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.5.data → npcsh-1.1.6.data}/data/npcsh/npc_team/sh.jinx

@@ -2,7 +2,6 @@ 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.5.data → npcsh-1.1.6.data}/data/npcsh/npc_team/sql.jinx

@@ -1,11 +1,9 @@
 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. Returns a LLM summary so no post-summary is required
+  not store any information about individual files. Avoid using percent signs unless absolutely necessary.
 inputs:
 - sql_query
-- user_query
-- interpret: true
 steps:
   - engine: python
     code: |

{npcsh-1.1.5.data → npcsh-1.1.6.data}/data/npcsh/npc_team/vixynt.jinx

@@ -1,14 +1,14 @@
 jinx_name: "vixynt"
 description: "Generates images from text descriptions or edits existing ones."
 inputs:
-  - prompt # Required, the text description for image generation or editing.
-  - output_file_base: "" # Optional string, e.g., './my_image', used as base for output file name.
-  - attachments: "" # Optional string, comma-separated image paths for editing existing images.
-  - n_images: 1 # Optional integer, number of images to generate.
-  - height: 1024 # Optional integer, height of the generated image.
-  - width: 1024 # Optional integer, width of the generated image.
-  - model: "" # Optional string, specific model to use for image generation. Defaults to NPC's model or 'runwayml/stable-diffusion-v1-5'.
-  - provider: "" # Optional string, specific provider for image generation. Defaults to NPC's provider or 'diffusers'.
+  - prompt
+  - model: ""
+  - provider: ""
+  - output_name: ""
+  - attachments: ""
+  - n_images: 1
+  - height: 1024
+  - width: 1024
 steps:
   - name: "generate_or_edit_image"
     engine: "python"
@@ -20,13 +20,13 @@ steps:
       from PIL import Image
       from npcpy.llm_funcs import gen_image
       
-      # Extract inputs from context (Jinx execution environment passes them here)
+      # Extract inputs from context
       image_prompt = context.get('prompt', '').strip()
-      output_file_base = context.get('output_file_base')
+      output_name = context.get('output_name')
       attachments_str = context.get('attachments')
-      n_images = int(context.get('n_images', 1)) # Ensure it's an integer
-      height = int(context.get('height', 1024)) # Ensure it's an integer
-      width = int(context.get('width', 1024)) # Ensure it's an integer
+      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')
 
@@ -34,29 +34,28 @@ steps:
       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 explicitly provided in jinx inputs
+      # 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 still not set
+      # 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'] = "Usage: /vixynt <prompt> [--output_file path] [--attachments path] [--n_images num]"
+          context['output'] = "Error: No prompt provided for image generation."
           context['messages'] = output_messages
-          exit() # Exit the jinx execution early
+          exit()
       
       try:
-          # Generate image(s) or edit
-          images_list = gen_image(
+          # Generate image(s)
+          result = gen_image(
               prompt=image_prompt,
               model=model,
               provider=provider,
@@ -67,20 +66,22 @@ steps:
               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 = []
-          compressed_images = []
           
-          if not isinstance(images_list, list):
-              images_list = [images_list] if images_list is not None else []
-
           for i, image in enumerate(images_list):
               if image is None:
                   continue
               
               # Determine output filename
-              if output_file_base and output_file_base.strip():
-                  base_name, ext = os.path.splitext(os.path.expanduser(output_file_base))
-                  if not ext: # No extension provided, default to .png
+              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:
@@ -93,16 +94,6 @@ steps:
               # Save image to file
               image.save(current_output_file)
               saved_files.append(current_output_file)
-              
-              # Create compressed base64 image for HTML rendering
-              img_buffer = BytesIO()
-              img_copy = image.copy()
-              img_copy.thumbnail((800, 600), Image.Resampling.LANCZOS)
-              img_copy.save(img_buffer, format='PNG', optimize=True, quality=85)
-              img_buffer.seek(0)
-              
-              img_base64 = base64.b64encode(img_buffer.getvalue()).decode('utf-8')
-              compressed_images.append(f"data:image/png;base64,{img_base64}")
           
           if saved_files:
               if input_images:
@@ -110,20 +101,17 @@ steps:
               else:
                   output = f"Image(s) generated and saved to: {', '.join(saved_files)}"
               
-              html_images = ""
-              for img_b64 in compressed_images:
-                  html_images += f'<img src="{img_b64}" style="max-width: 400px; margin: 10px;" /><br/>'
-              
-              output += f"\n\nGenerated Images:\n{html_images}"
+              # 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 generated."
+              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 # Store output in context
-      context['messages'] = output_messages # Ensure messages are returned
+      context['output'] = output
+      context['messages'] = output_messages
       context['model'] = model
       context['provider'] = provider

{npcsh-1.1.5.dist-info → npcsh-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.1.5
+Version: 1.1.6
 Summary: npcsh is a command-line toolkit for using AI agents in novel ways.
 Home-page: https://github.com/NPC-Worldwide/npcsh
 Author: Christopher Agostino
@@ -142,15 +142,6 @@ and you will enter the NPC shell. Additionally, the pip installation includes th
       npcsh>please read through the markdown files in the docs folder and suggest changes based on the current implementation in the src folder
       ```
 
-  - **Ask a Generic Question**
-    ```bash
-    npcsh> has there ever been a better pasta shape than bucatini?
-    ```
-    ```                              
-    Bucatini is certainly a favorite for many due to its unique hollow center, which holds sauces beautifully. Whether it's "better" is subjective and depends on the dish and personal        
-    preference. Shapes like orecchiette, rigatoni, or trofie excel in different recipes. Bucatini stands out for its versatility and texture, making it a top contender among pasta shapes!    
-    ```
-
 
   - **Search the Web**
     ```bash