npcsh 1.1.9__tar.gz → 1.1.11__tar.gz

{npcsh-1.1.9 → npcsh-1.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.1.9
+Version: 1.1.11
 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

{npcsh-1.1.9 → npcsh-1.1.11}/npcsh/_state.py

@@ -111,6 +111,7 @@ except importlib.metadata.PackageNotFoundError:
     VERSION = "unknown"
 
 
+from litellm import RateLimitError
 
 
 NPCSH_CHAT_MODEL = os.environ.get("NPCSH_CHAT_MODEL", "gemma3:4b")
@@ -2263,7 +2264,7 @@ def process_pipeline_command(
                 images=state.attachments,
                 stream=stream_final,
                 context=info,
-                extra_globals=application_globals_for_jinx  # NOW PASS IT
+                extra_globals=application_globals_for_jinx  
             )
         if not review:
             if isinstance(llm_result, dict):
@@ -2474,7 +2475,9 @@ def execute_command(
                     review=review,
                     router=router
                 )
-                
+                if isinstance(output, dict) and 'output' in output:
+                    output = output['output']
+
                 if is_last_command:
                     print(colored("✅ Pipeline complete", "green"))
                     return current_state, output
@@ -2513,7 +2516,23 @@ def execute_command(
                     f"  → Passing to stage {stage_num + 1}", 
                     "blue"
                 ))
-                
+            except RateLimitError:
+                print(colored('Rate Limit Exceeded'))
+                # wait 30 seconds then truncate messages/condense context with breathing mechanism
+                # for now just limit to first plus last 10
+                messages = current_state.messages[0:1] + current_state.messages[-2:]
+                current_state.messages = messages
+                #retry 
+                import time 
+                print('sleeping...')
+                print(current_state)
+                print(current_state.messages)
+                time.sleep(30)
+
+
+                return execute_command(command, current_state, review=review, router=router,)
+
+
             except Exception as pipeline_error:
                 import traceback
                 traceback.print_exc()
@@ -2665,10 +2684,12 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
                 if use_jinxs == "c":
                     global_jinxs_dir = os.path.expanduser("~/.npcsh/npc_team/jinxs")
                     if os.path.exists(global_jinxs_dir):
-                        shutil.copytree(global_jinxs_dir, team_dir, dirs_exist_ok=True)
+                        # Create the 'jinxs' subfolder within the new team's directory
+                        destination_jinxs_dir = os.path.join(team_dir, "jinxs")
+                        os.makedirs(destination_jinxs_dir, exist_ok=True)
+                        shutil.copytree(global_jinxs_dir, destination_jinxs_dir, dirs_exist_ok=True)
                 else:
                     team_ctx_data["use_global_jinxs"] = True
-
                 with open(ctx_path, "w") as f:
                     yaml.dump(team_ctx_data, f)
             else:
@@ -2802,7 +2823,6 @@ def process_memory_approvals(command_history, memory_queue):
                 approval['decision'], 
                 approval.get('final_memory')
             )
-
 def process_result(
     user_input: str,
     result_state: ShellState,
@@ -2835,10 +2855,17 @@ def process_result(
 
     final_output_str = None
     
+    # FIX: Handle dict output properly
     if isinstance(output, dict):
         output_content = output.get('output')
         model_for_stream = output.get('model', active_npc.model)
         provider_for_stream = output.get('provider', active_npc.provider)
+        
+        # If output_content is still a dict or None, convert to string
+        if isinstance(output_content, dict):
+            output_content = str(output_content)
+        elif output_content is None:
+            output_content = "Command completed with no output"
     else:
         output_content = output
         model_for_stream = active_npc.model
@@ -2851,15 +2878,21 @@ def process_result(
         else:
             render_markdown(str(output_content))
     elif result_state.stream_output:
-        final_output_str = print_and_process_stream_with_markdown(
-            output_content, 
-            model_for_stream, 
-            provider_for_stream, 
-            show=True
-        )
+        # FIX: Only stream if output_content is a generator, not a string
+        if isinstance(output_content, str):
+            final_output_str = output_content
+            render_markdown(final_output_str)
+        else:
+            final_output_str = print_and_process_stream_with_markdown(
+                output_content, 
+                model_for_stream, 
+                provider_for_stream, 
+                show=True
+            )
     elif output_content is not None:
         final_output_str = str(output_content)
         render_markdown(final_output_str)
+        
 
     if final_output_str:
         if result_state.messages:

{npcsh-1.1.9 → npcsh-1.1.11}/npcsh/guac.py

@@ -1376,10 +1376,12 @@ def get_guac_prompt_char(command_count: int, guac_refresh_period = 100) -> str:
 def execute_guac_command(command: str, state: ShellState, locals_dict: Dict[str, Any], project_name: str, src_dir: Path, router) -> Tuple[ShellState, Any]:
     stripped_command = command.strip()
     output = None 
-    cmd_parts = shlex.split(stripped_command)
-    if cmd_parts and cmd_parts[0] in ["cd", "ls", "pwd"]:
-        return execute_command(stripped_command, state, review=False, router=router)
-
+    try:
+        cmd_parts = shlex.split(stripped_command)
+        if cmd_parts and cmd_parts[0] in ["cd", "ls", "pwd"]:
+            return execute_command(stripped_command, state, review=False, router=router)
+    except Exception as e:
+        pass
     npc_team_dir = Path(state.team.team_path) if state.team and hasattr(state.team, 'team_path') else Path.cwd() / "npc_team"
 
     if not stripped_command:

npcsh-1.1.11/npcsh/npc_team/jinxs/code/sh.jinx

@@ -0,0 +1,38 @@
+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
+steps:
+  - name: execute_bash
+    engine: python
+    code: |
+      import subprocess
+      import sys # Import sys to explicitly write to stderr for visibility
+
+      # Force a simple print to see if anything comes out
+      print("--- Jinx 'sh' code started ---", file=sys.stderr) 
+
+      cmd = '{{ bash_command }}'
+      
+      # Initialize output to an empty string to ensure it always exists
+      output = "" 
+
+
+      process = subprocess.Popen(
+          cmd, 
+          shell=True, 
+          stdout=subprocess.PIPE, 
+          stderr=subprocess.PIPE
+      )
+      stdout, stderr = process.communicate()
+      
+      # Print raw stdout/stderr to sys.stderr for better visibility in some environments
+      print(f"Jinx 'sh' raw stdout: {stdout.decode('utf-8', errors='ignore')}", file=sys.stderr)
+      print(f"Jinx 'sh' raw stderr: {stderr.decode('utf-8', errors='ignore')}", file=sys.stderr)
+
+      if stderr:
+          output = f"Error: {stderr.decode('utf-8')}"
+      else:
+          output = stdout.decode('utf-8')
+
+

{npcsh-1.1.9 → npcsh-1.1.11}/npcsh/npc_team/jinxs/code/sql.jinx

@@ -1,4 +1,4 @@
-jinx_name: sql_executor
+jinx_name: sql
 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.
@@ -13,4 +13,4 @@ steps:
         df = pd.read_sql_query(query, npc.db_conn)
       except Exception as e:
         df = pd.DataFrame({'Error': [str(e)]})
-      output = df.to_string()
+      output = df.to_string()

npcsh-1.1.11/npcsh/npc_team/jinxs/utils/agent.jinx

@@ -0,0 +1,17 @@
+jinx_name: agent
+description: Provides an LLM response with tool use enabled.
+inputs:
+  - query
+  - auto_process_tool_calls: True
+  - use_core_tools: True
+steps:
+  - name: get_agent_response
+    engine: python
+    code: |
+      response = npc.get_llm_response(
+          request=query,
+          messages=context.get('messages', []),
+          auto_process_tool_calls={{ auto_process_tool_calls | default(True) }},
+          use_core_tools={{ use_core_tools | default(True) }}
+      )
+      output = response.get('response', '')

npcsh-1.1.11/npcsh/npc_team/jinxs/utils/chat.jinx

@@ -0,0 +1,17 @@
+jinx_name: chat
+description: Provides a direct LLM response without tool use.
+inputs:
+  - query
+  - auto_process_tool_calls: False
+  - use_core_tools: False
+steps:
+  - name: get_chat_response
+    engine: python
+    code: |
+      response = npc.get_llm_response(
+          request=query,
+          messages=context.get('messages', []),
+          auto_process_tool_calls={{ auto_process_tool_calls | default(False) }},
+          use_core_tools={{ use_core_tools | default(False) }}
+      )
+      output = response.get('response', '')

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

npcsh-1.1.11/npcsh/npc_team/jinxs/utils/load_file.jinx

@@ -0,0 +1,35 @@
+jinx_name: load_file
+description: Loads and returns the contents of a file using npcpy's file loaders
+inputs:
+- file_path
+steps:
+  - name: "load_file"
+    engine: "python"
+    code: |
+      import os
+      from npcpy.data.load import load_file_contents
+      
+      # Expand user path and get absolute path
+      file_path = os.path.expanduser("{{ file_path }}")
+      
+      # Check if file exists
+      if not os.path.exists(file_path):
+          output = f"Error: File not found at {file_path}"
+      else:
+          try:
+              # Load file contents using npcpy's loader
+              # Returns chunks by default with chunk_size=250
+              chunks = load_file_contents(file_path)
+              
+              # Join chunks back together for full content
+              if isinstance(chunks, list):
+                  if chunks and chunks[0].startswith("Error"):
+                      output = chunks[0]
+                  else:
+                      file_content = "\n".join(chunks)
+                      output = f"File: {file_path}\n\n{file_content}"
+              else:
+                  output = f"File: {file_path}\n\n{chunks}"
+                  
+          except Exception as e:
+              output = f"Error reading file {file_path}: {str(e)}"

{npcsh-1.1.9 → npcsh-1.1.11}/npcsh/npc_team/jinxs/utils/serve.jinx

@@ -17,9 +17,6 @@ steps:
       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,

npcsh-1.1.11/npcsh/npc_team/jinxs/utils/trigger.jinx

@@ -0,0 +1,61 @@
+jinx_name: "trigger"
+description: "Creates a persistent listener (--listen) or a scheduled task (--cron)."
+inputs:
+  - listen: "" # The description for a persistent, event-driven listener.
+  - cron: ""   # The description for a scheduled, time-based task.
+steps:
+  - name: "execute_command"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.work.trigger import execute_trigger_command # For --listen
+      from npcpy.work.plan import execute_plan_command      # For --cron
+      
+      listen_description = context.get('listen')
+      cron_description = context.get('cron')
+      output_messages = context.get('messages', [])
+      
+      USAGE = 'Usage: /trigger --listen "<description>" OR /trigger --cron "<description>"'
+      
+      # Determine which command was used and set the appropriate variables
+      subcommand = None
+      description = None
+      executor_func = None
+      
+      # --- Argument Validation ---
+      # Ensure mutual exclusivity
+      if listen_description and cron_description:
+          context['output'] = f"Error: --listen and --cron are mutually exclusive. {USAGE}"
+          context['messages'] = output_messages
+          exit()
+          
+      # --- Command Dispatch ---
+      if listen_description:
+          subcommand = 'listen'
+          description = listen_description
+          executor_func = execute_trigger_command
+      elif cron_description:
+          subcommand = 'cron'
+          description = cron_description
+          executor_func = execute_plan_command
+      else:
+          # Handle case where no arguments were provided
+          context['output'] = f"Error: You must provide either --listen or --cron. {USAGE}"
+          context['messages'] = output_messages
+          exit()
+      
+      # --- Execution ---
+      try:
+          result = executor_func(command=description, **context)
+          
+          if isinstance(result, dict):
+              output_key = 'Listener' if subcommand == 'listen' else 'Cron job'
+              context['output'] = result.get('output', f'{output_key} created successfully.')
+              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 creating {subcommand}: {e}"
+          context['messages'] = output_messages

npcsh-1.1.11/npcsh/npc_team/jinxs/utils/vixynt.jinx

@@ -0,0 +1,144 @@
+jinx_name: "vixynt"
+description: "Generates images from text descriptions or edits existing ones."
+inputs:
+  - prompt
+  - model: null
+  - provider: null
+  - output_name: null
+  - attachments: null
+  - n_images: null
+  - height: null
+  - width: null
+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 with proper type conversion
+      image_prompt = str(context.get('prompt', '')).strip()
+      output_name = context.get('output_name')
+      attachments_str = context.get('attachments')
+      
+      # Handle integer inputs - they may come as strings or ints
+      try:
+          n_images = int(context.get('n_images', 1))
+      except (ValueError, TypeError):
+          n_images = 1
+      
+      try:
+          height = int(context.get('height', 1024))
+      except (ValueError, TypeError):
+          height = 1024
+      
+      try:
+          width = int(context.get('width', 1024))
+      except (ValueError, TypeError):
+          width = 1024
+      
+      # Get model and provider, prioritizing context, then NPC, then environment variables
+      model = context.get('model')
+      provider = context.get('provider')
+      
+      # Use NPC's model/provider as fallback
+      if not model and npc and hasattr(npc, 'model') and npc.model:
+          model = npc.model 
+      if not provider and npc and hasattr(npc, 'provider') and npc.provider:
+          provider = npc.provider
+      
+      # Fallback to environment variables
+      if not model:
+          model = os.getenv('NPCSH_IMAGE_GEN_MODEL')
+      if not provider:
+          provider = os.getenv('NPCSH_IMAGE_GEN_PROVIDER')
+
+      # Final hardcoded fallbacks if nothing else is set
+      if not model:
+          model = "runwayml/stable-diffusion-v1-5"
+      if not provider:
+          provider = "diffusers"
+      
+      # Parse attachments
+      input_images = []
+      if attachments_str and str(attachments_str).strip():
+          input_images = [p.strip() for p in str(attachments_str).split(',')]
+      
+      output_messages = context.get('messages', [])
+      
+      if not image_prompt:
+          output = "Error: No prompt provided for image generation."
+      else:
+          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 = []
+              html_image_tags = [] # This list will store the raw HTML <img> tags
+              
+              for i, image in enumerate(images_list):
+                  if image is None:
+                      continue
+                  
+                  # Determine output filename
+                  if output_name and str(output_name).strip():
+                      base_name, ext = os.path.splitext(os.path.expanduser(str(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)
+
+                  # Convert image to base64 and create an HTML <img> tag
+                  with open(current_output_file, 'rb') as f:
+                      img_data = base64.b64encode(f.read()).decode()
+                      # Using raw HTML <img> tag with data URI
+                      html_image_tags.append(f'<img src="data:image/png;base64,{img_data}" alt="Generated Image {i+1}" style="max-width: 100%; display: block; margin-top: 10px;">')
+              
+              if saved_files:
+                  output_text_message = f"Image(s) generated and saved to: {', '.join(saved_files)}"
+                  if input_images:
+                      output_text_message = f"Image(s) edited and saved to: {', '.join(saved_files)}"
+                  
+                  output = output_text_message # Keep the text message clean
+                  output += f"\n\nThe image files have been saved and are ready to view."
+                  output += "\n\n" + "\n".join(html_image_tags) # Append all HTML <img> tags to the output
+              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-1.1.9 → npcsh-1.1.11}/npcsh/npcsh.py

@@ -78,7 +78,8 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState, router)
     render_markdown(f'- Using {state.current_mode} mode. Use /agent, /cmd, or /chat to switch to other modes')
     render_markdown(f'- To switch to a different NPC, type /npc <npc_name> or /n <npc_name> to switch to that NPC.')
     render_markdown('\n- Here are the current NPCs available in your team: ' + ', '.join([npc_name for npc_name in state.team.npcs.keys()]))
-
+    render_markdown('\n- Here are the currently available Jinxs: ' + ', '.join([jinx_name for jinx_name in state.team.jinxs_dict.keys()]))
+    
     is_windows = platform.system().lower().startswith("win")
     try:
         completer = make_completer(state, router)

{npcsh-1.1.9 → npcsh-1.1.11}/npcsh/routes.py

@@ -90,7 +90,6 @@ class CommandRouter:
             
             jinx_output = jinx.execute(
                 input_values=input_values,
-                jinxs_dict=kwargs.get('jinxs_dict', {}),
                 npc=npc,
                 messages=messages,
                 extra_globals=application_globals_for_jinx

{npcsh-1.1.9 → npcsh-1.1.11}/npcsh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.1.9
+Version: 1.1.11
 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

{npcsh-1.1.9 → npcsh-1.1.11}/npcsh.egg-info/SOURCES.txt

@@ -55,12 +55,13 @@ npcsh/npc_team/jinxs/modes/pti.jinx
 npcsh/npc_team/jinxs/modes/spool.jinx
 npcsh/npc_team/jinxs/modes/wander.jinx
 npcsh/npc_team/jinxs/modes/yap.jinx
-npcsh/npc_team/jinxs/utils/breathe.jinx
+npcsh/npc_team/jinxs/npc_studio/npc-studio.jinx
+npcsh/npc_team/jinxs/utils/agent.jinx
+npcsh/npc_team/jinxs/utils/chat.jinx
+npcsh/npc_team/jinxs/utils/compress.jinx
 npcsh/npc_team/jinxs/utils/edit_file.jinx
-npcsh/npc_team/jinxs/utils/flush.jinx
-npcsh/npc_team/jinxs/utils/npc-studio.jinx
+npcsh/npc_team/jinxs/utils/load_file.jinx
 npcsh/npc_team/jinxs/utils/ots.jinx
-npcsh/npc_team/jinxs/utils/plan.jinx
 npcsh/npc_team/jinxs/utils/roll.jinx
 npcsh/npc_team/jinxs/utils/sample.jinx
 npcsh/npc_team/jinxs/utils/search.jinx

{npcsh-1.1.9 → npcsh-1.1.11}/setup.py

@@ -78,7 +78,7 @@ extra_files = package_files("npcsh/npc_team/")
 
 setup(
     name="npcsh",
-    version="1.1.9",
+    version="1.1.11",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  # Only install base requirements by default
     extras_require={

npcsh-1.1.9/npcsh/npc_team/jinxs/code/sh.jinx

@@ -1,19 +0,0 @@
-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
-steps:
-  - engine: python
-    code: |
-      import subprocess
-      import os
-      cmd = '{{bash_command}}'
-      def run_command(cmd):
-        process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        stdout, stderr = process.communicate()
-        if stderr:
-          print(f"Error: {stderr.decode('utf-8')}")
-          return stderr
-        return stdout
-      result = run_command(cmd)
-      output = result.decode('utf-8')

npcsh-1.1.9/npcsh/npc_team/jinxs/utils/breathe.jinx

@@ -1,20 +0,0 @@
-jinx_name: "breathe"
-description: "Condense context on a regular cadence"
-inputs: [] # The breathe command takes all relevant context from the NPC's environment
-steps:
-  - name: "condense_context"
-    engine: "python"
-    code: |
-      from npcpy.llm_funcs import breathe
-      
-      output_messages = context.get('messages', [])
-
-      # Pass all current context as kwargs to breathe
-      result = breathe(**context) 
-      
-      if isinstance(result, dict):
-          context['output'] = result.get('output', 'Context condensed.')
-          context['messages'] = result.get('messages', output_messages)
-      else:
-          context['output'] = "Context condensation process initiated."
-          context['messages'] = output_messages

npcsh-1.1.9/npcsh/npc_team/jinxs/utils/flush.jinx

@@ -1,39 +0,0 @@
-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-1.1.9/npcsh/npc_team/jinxs/utils/plan.jinx

@@ -1,33 +0,0 @@
-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-1.1.9/npcsh/npc_team/jinxs/utils/trigger.jinx

@@ -1,36 +0,0 @@
-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-1.1.9/npcsh/npc_team/jinxs/utils/vixynt.jinx

@@ -1,117 +0,0 @@
-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