npcsh 0.1.2__py3-none-any.whl → 1.1.13__py3-none-any.whl

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

@@ -0,0 +1,26 @@
+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(
+          port=int(port), # Ensure port is an integer
+          cors_origins=cors_origins,
+      )
+
+      context['output'] = "NPC Team server started. Execution of this jinx will pause until the server is stopped."
+      context['messages'] = output_messages

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

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

npcsh-1.1.13.data/data/npcsh/npc_team/sh.jinx

@@ -0,0 +1,34 @@
+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 os
+
+      cmd = '{{ bash_command }}'
+      output = ""
+
+      process = subprocess.Popen(
+          cmd,
+          shell=True,
+          stdout=subprocess.PIPE,
+          stderr=subprocess.PIPE
+      )
+      stdout, stderr = process.communicate()
+
+      # Only show debug output if NPCSH_DEBUG is set
+      if os.environ.get("NPCSH_DEBUG") == "1":
+          import sys
+          print(f"[sh] cmd: {cmd}", file=sys.stderr)
+          print(f"[sh] stdout: {stdout.decode('utf-8', errors='ignore')[:200]}", file=sys.stderr)
+
+      if stderr:
+          output = f"Error: {stderr.decode('utf-8')}"
+      else:
+          output = stdout.decode('utf-8')
+
+

npcsh-1.1.13.data/data/npcsh/npc_team/sibiji.npc

@@ -0,0 +1,3 @@
+name: sibiji
+primary_directive: You are a foundational AI assistant. Your role is to provide support and information. Respond to queries concisely and accurately. Help users with code and other processes. 
+jinxs: "*"

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

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

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

@@ -0,0 +1,161 @@
+jinx_name: spool
+description: Interactive chat mode - simple conversational interface with an NPC
+inputs:
+  - model: null
+  - provider: null
+  - attachments: null
+  - stream: true
+
+steps:
+  - name: spool_repl
+    engine: python
+    code: |
+      import os
+      import sys
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.npc_sysenv import get_system_message, render_markdown
+      from npcpy.data.load import load_file_contents
+      from npcpy.data.text import rag_search
+
+      npc = context.get('npc')
+      team = context.get('team')
+      messages = context.get('messages', [])
+      stream = context.get('stream', True)
+      attachments = context.get('attachments')
+
+      # Use NPC's model/provider or fallback
+      model = context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      # ASCII art
+      print("""
+       _____ ____   ____   ____  _
+      / ___/|  _ \ / __ \ / __ \| |
+      \___ \| |_) | |  | | |  | | |
+       ___) |  __/| |  | | |  | | |___
+      |____/|_|    \____/ \____/|_____|
+      """)
+
+      npc_name = npc.name if npc else "chat"
+      print(f"Entering spool mode (NPC: {npc_name}). Type '/sq' to exit.")
+
+      # Load attachments if provided
+      loaded_chunks = {}
+      if attachments:
+          if isinstance(attachments, str):
+              attachments = [f.strip() for f in attachments.split(',')]
+          for file_path in attachments:
+              file_path = os.path.expanduser(file_path)
+              if os.path.exists(file_path):
+                  try:
+                      chunks = load_file_contents(file_path)
+                      loaded_chunks[file_path] = chunks
+                      print(colored(f"Loaded {len(chunks)} chunks from: {file_path}", "green"))
+                  except Exception as e:
+                      print(colored(f"Error loading {file_path}: {e}", "red"))
+
+      # Ensure system message
+      if not messages or messages[0].get("role") != "system":
+          sys_msg = get_system_message(npc) if npc else "You are a helpful assistant."
+          messages.insert(0, {"role": "system", "content": sys_msg})
+
+      # REPL loop
+      while True:
+          try:
+              prompt_str = f"{npc_name}> "
+              user_input = input(prompt_str).strip()
+
+              if not user_input:
+                  continue
+
+              if user_input.lower() == "/sq":
+                  print("Exiting spool mode.")
+                  break
+
+              # Handle /ots for screenshots inline
+              if user_input.startswith("/ots"):
+                  from npcpy.data.image import capture_screenshot
+                  parts = user_input.split()
+                  image_paths = []
+                  if len(parts) > 1:
+                      for p in parts[1:]:
+                          fp = os.path.expanduser(p)
+                          if os.path.exists(fp):
+                              image_paths.append(fp)
+                  else:
+                      ss = capture_screenshot()
+                      if ss and "file_path" in ss:
+                          image_paths.append(ss["file_path"])
+                          print(colored(f"Screenshot: {ss['filename']}", "green"))
+
+                  if image_paths:
+                      vision_prompt = input("Prompt for image(s): ").strip() or "Describe these images."
+                      resp = get_llm_response(
+                          vision_prompt,
+                          model=npc.vision_model if hasattr(npc, 'vision_model') else model,
+                          provider=npc.vision_provider if hasattr(npc, 'vision_provider') else provider,
+                          messages=messages,
+                          images=image_paths,
+                          stream=stream,
+                          npc=npc
+                      )
+                      messages = resp.get('messages', messages)
+                      render_markdown(str(resp.get('response', '')))
+                  continue
+
+              # Add RAG context if files loaded
+              current_prompt = user_input
+              if loaded_chunks:
+                  context_content = ""
+                  for filename, chunks in loaded_chunks.items():
+                      full_text = "\n".join(chunks)
+                      retrieved = rag_search(user_input, full_text, similarity_threshold=0.3)
+                      if retrieved:
+                          context_content += f"\n\nContext from {filename}:\n{retrieved}\n"
+                  if context_content:
+                      current_prompt += f"\n\n--- Relevant context ---{context_content}"
+
+              # Get response
+              resp = get_llm_response(
+                  current_prompt,
+                  model=model,
+                  provider=provider,
+                  messages=messages,
+                  stream=stream,
+                  npc=npc
+              )
+
+              messages = resp.get('messages', messages)
+              response_text = resp.get('response', '')
+
+              # Handle streaming vs non-streaming
+              if hasattr(response_text, '__iter__') and not isinstance(response_text, str):
+                  full_response = ""
+                  for chunk in response_text:
+                      if hasattr(chunk, 'choices') and chunk.choices:
+                          delta = chunk.choices[0].delta
+                          if hasattr(delta, 'content') and delta.content:
+                              print(delta.content, end='', flush=True)
+                              full_response += delta.content
+                  print()
+              else:
+                  render_markdown(str(response_text))
+
+              # Track usage if available
+              if 'usage' in resp and npc and hasattr(npc, 'shared_context'):
+                  usage = resp['usage']
+                  npc.shared_context['session_input_tokens'] += usage.get('input_tokens', 0)
+                  npc.shared_context['session_output_tokens'] += usage.get('output_tokens', 0)
+                  npc.shared_context['turn_count'] += 1
+
+          except KeyboardInterrupt:
+              print("\nUse '/sq' to exit or continue.")
+              continue
+          except EOFError:
+              print("\nExiting spool mode.")
+              break
+
+      context['output'] = "Exited spool mode."
+      context['messages'] = messages

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

@@ -0,0 +1,16 @@
+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.
+inputs:
+- sql_query
+steps:
+  - engine: python
+    code: |
+      import pandas as pd
+      query = "{{ sql_query }}"
+      try:
+        df = pd.read_sql_query(query, npc.db_conn)
+      except Exception as e:
+        df = pd.DataFrame({'Error': [str(e)]})
+      output = df.to_string()

npcsh-1.1.13.data/data/npcsh/npc_team/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.13.data/data/npcsh/npc_team/usage.jinx

@@ -0,0 +1,33 @@
+jinx_name: usage
+description: Display current session token usage and cost
+inputs: []
+steps:
+  - name: show_usage
+    engine: python
+    code: |
+      state = context.get('state')
+      if not state:
+          output = "No state available"
+      else:
+          inp = getattr(state, 'session_input_tokens', 0)
+          out = getattr(state, 'session_output_tokens', 0)
+          cost = getattr(state, 'session_cost_usd', 0.0)
+          turns = getattr(state, 'turn_count', 0)
+          total = inp + out
+
+          def fmt(n):
+              return f"{n/1000:.1f}k" if n >= 1000 else str(n)
+
+          def fmt_cost(c):
+              if c == 0:
+                  return "free (local)"
+              elif c < 0.01:
+                  return f"${c:.4f}"
+              else:
+                  return f"${c:.2f}"
+
+          output = f"Session Usage\n"
+          output += f"Tokens: {fmt(inp)} in / {fmt(out)} out ({fmt(total)} total)\n"
+          output += f"Cost:   {fmt_cost(cost)}\n"
+          output += f"Turns:  {turns}"
+      context['output'] = output

npcsh-1.1.13.data/data/npcsh/npc_team/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