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

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

@@ -0,0 +1,214 @@
+jinx_name: plonk
+description: Vision-based GUI automation - use vision model to interact with screen elements
+inputs:
+  - task: null
+  - vmodel: null
+  - vprovider: null
+  - max_iterations: 10
+  - debug: true
+
+steps:
+  - name: plonk_execute
+    engine: python
+    code: |
+      import os
+      import time
+      import platform
+      from termcolor import colored
+
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.data.image import capture_screenshot
+      from npcpy.work.desktop import perform_action
+
+      npc = context.get('npc')
+      messages = context.get('messages', [])
+
+      task = context.get('task')
+      vision_model = context.get('vmodel') or (npc.model if npc else 'gpt-4o')
+      vision_provider = context.get('vprovider') or (npc.provider if npc else 'openai')
+      max_iterations = int(context.get('max_iterations', 10))
+      debug = context.get('debug', True)
+
+      if not task:
+          context['output'] = """Usage: /plonk <task description>
+
+      Options:
+        --vmodel MODEL      Vision model to use (default: gpt-4o)
+        --vprovider PROV    Vision provider (default: openai)
+        --max-iterations N  Max steps (default: 10)
+
+      Example: /plonk Open Firefox and navigate to google.com"""
+          context['messages'] = messages
+          exit()
+
+      print(f"""
+      ██████╗ ██╗      ██████╗ ███╗   ██╗██╗  ██╗
+      ██╔══██╗██║     ██╔═══██╗████╗  ██║██║ ██╔╝
+      ██████╔╝██║     ██║   ██║██╔██╗ ██║█████╔╝
+      ██╔═══╝ ██║     ██║   ██║██║╚██╗██║██╔═██╗
+      ██║     ███████╗╚██████╔╝██║ ╚████║██║  ██╗
+      ╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝
+
+      Vision GUI Automation
+      Task: {task}
+      Model: {vision_model} | Max iterations: {max_iterations}
+      """)
+
+      # System-specific examples
+      system = platform.system()
+      if system == "Windows":
+          app_examples = "start firefox, notepad, calc"
+      elif system == "Darwin":
+          app_examples = "open -a Firefox, open -a TextEdit"
+      else:
+          app_examples = "firefox &, gedit &, gnome-calculator &"
+
+      # Action types
+      ACTION_SCHEMA = {
+          "type": "object",
+          "properties": {
+              "action": {
+                  "type": "string",
+                  "enum": ["click", "type", "key", "launch", "wait", "done", "fail"],
+                  "description": "Action to perform"
+              },
+              "x": {"type": "number", "description": "X coordinate (0-100 percentage)"},
+              "y": {"type": "number", "description": "Y coordinate (0-100 percentage)"},
+              "text": {"type": "string", "description": "Text to type or key to press"},
+              "command": {"type": "string", "description": "Command to launch"},
+              "duration": {"type": "number", "description": "Wait duration in seconds"},
+              "reason": {"type": "string", "description": "Explanation of action"}
+          },
+          "required": ["action", "reason"]
+      }
+
+      click_history = []
+      summary = []
+
+      for iteration in range(max_iterations):
+          print(colored(f"\n--- Iteration {iteration + 1}/{max_iterations} ---", "cyan"))
+
+          # Capture screenshot
+          ss = capture_screenshot()
+          if not ss or 'file_path' not in ss:
+              print(colored("Failed to capture screenshot", "red"))
+              break
+
+          screenshot_path = ss['file_path']
+          if debug:
+              print(colored(f"Screenshot: {screenshot_path}", "gray"))
+
+          # Build context from history
+          history_context = ""
+          if click_history:
+              history_context = f"\nPrevious actions ({len(click_history)}):\n"
+              for i, click in enumerate(click_history[-5:], 1):
+                  history_context += f"  {i}. {click.get('action', 'unknown')} at ({click.get('x', '?')}, {click.get('y', '?')}) - {click.get('reason', '')}\n"
+
+          prompt = f"""You are a GUI automation assistant. Analyze this screenshot and determine the next action to complete the task.
+
+      TASK: {task}
+
+      {history_context}
+
+      Available actions:
+      - click: Click at x,y coordinates (0-100 percentage of screen)
+      - type: Type text
+      - key: Press key (enter, tab, escape, etc.)
+      - launch: Launch application ({app_examples})
+      - wait: Wait for duration seconds
+      - done: Task completed successfully
+      - fail: Task cannot be completed
+
+      Respond with JSON: {{"action": "...", "x": N, "y": N, "text": "...", "command": "...", "duration": N, "reason": "..."}}"""
+
+          try:
+              resp = get_llm_response(
+                  prompt,
+                  model=vision_model,
+                  provider=vision_provider,
+                  images=[screenshot_path],
+                  format="json",
+                  npc=npc
+              )
+
+              action_response = resp.get('response', {})
+              if isinstance(action_response, str):
+                  import json
+                  try:
+                      action_response = json.loads(action_response)
+                  except:
+                      print(colored(f"Invalid JSON response: {action_response[:100]}", "red"))
+                      continue
+
+              action = action_response.get('action', 'fail')
+              reason = action_response.get('reason', 'No reason provided')
+
+              print(colored(f"Action: {action} - {reason}", "yellow"))
+
+              if action == 'done':
+                  print(colored("Task completed successfully!", "green"))
+                  summary.append({"iteration": iteration + 1, "action": "done", "reason": reason})
+                  break
+
+              if action == 'fail':
+                  print(colored(f"Task failed: {reason}", "red"))
+                  summary.append({"iteration": iteration + 1, "action": "fail", "reason": reason})
+                  break
+
+              # Execute action
+              if action == 'click':
+                  x, y = action_response.get('x', 50), action_response.get('y', 50)
+                  perform_action('click', x=x, y=y)
+                  click_history.append({"action": "click", "x": x, "y": y, "reason": reason})
+                  print(colored(f"Clicked at ({x}, {y})", "green"))
+
+              elif action == 'type':
+                  text = action_response.get('text', '')
+                  perform_action('type', text=text)
+                  click_history.append({"action": "type", "text": text[:20], "reason": reason})
+                  print(colored(f"Typed: {text[:30]}...", "green"))
+
+              elif action == 'key':
+                  key = action_response.get('text', 'enter')
+                  perform_action('key', key=key)
+                  click_history.append({"action": "key", "key": key, "reason": reason})
+                  print(colored(f"Pressed key: {key}", "green"))
+
+              elif action == 'launch':
+                  cmd = action_response.get('command', '')
+                  perform_action('launch', command=cmd)
+                  click_history.append({"action": "launch", "command": cmd, "reason": reason})
+                  print(colored(f"Launched: {cmd}", "green"))
+                  time.sleep(2)  # Wait for app to open
+
+              elif action == 'wait':
+                  duration = action_response.get('duration', 1)
+                  time.sleep(duration)
+                  click_history.append({"action": "wait", "duration": duration, "reason": reason})
+                  print(colored(f"Waited {duration}s", "green"))
+
+              summary.append({
+                  "iteration": iteration + 1,
+                  "action": action,
+                  "last_click_coords": f"({click_history[-1].get('x', 'N/A')}, {click_history[-1].get('y', 'N/A')})" if click_history else "N/A",
+                  "reason": reason
+              })
+
+              time.sleep(0.5)  # Brief pause between actions
+
+          except Exception as e:
+              print(colored(f"Error in iteration {iteration + 1}: {e}", "red"))
+              summary.append({"iteration": iteration + 1, "error": str(e)})
+
+      # Generate summary
+      print("\n" + "="*50)
+      print(colored("PLONK SESSION SUMMARY", "cyan", attrs=['bold']))
+      print("="*50)
+      for s in summary:
+          print(f"  Step {s.get('iteration', '?')}: {s.get('action', 'unknown')} - {s.get('reason', s.get('error', ''))[:60]}")
+
+      context['output'] = f"Plonk completed with {len(summary)} actions"
+      context['messages'] = messages
+      context['plonk_summary'] = summary
+      context['click_history'] = click_history

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

@@ -0,0 +1,2 @@
+name: plonk
+primary_directive: You are the superior automation specialist of the NPC team.

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

@@ -0,0 +1,2 @@
+name: plonkjr
+primary_directive: You are junior automation specialist in the NPC Team.

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

@@ -0,0 +1,170 @@
+jinx_name: pti
+description: Pardon-The-Interruption - human-in-the-loop reasoning with think tags and interruptible streaming
+npc: frederic
+inputs:
+  - model: null
+  - provider: null
+  - files: null
+  - reasoning_model: null
+
+steps:
+  - name: pti_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', [])
+      files = context.get('files')
+
+      # PTI uses reasoning model for deeper thinking
+      model = context.get('reasoning_model') or context.get('model') or (npc.model if npc else None)
+      provider = context.get('provider') or (npc.provider if npc else None)
+
+      print("""
+      ██████╗ ████████╗██╗
+      ██╔══██╗╚══██╔══╝██║
+      ██████╔╝   ██║   ██║
+      ██╔═══╝    ██║   ██║
+      ██║        ██║   ██║
+      ╚═╝        ╚═╝   ╚═╝
+
+      Pardon-The-Interruption
+      Human-in-the-loop reasoning mode
+      """)
+
+      npc_name = npc.name if npc else "pti"
+      print(f"Entering PTI mode (NPC: {npc_name}). Type '/pq' to exit.")
+      print("  - AI will use <think> tags for step-by-step reasoning")
+      print("  - Use <request_for_input> to pause and ask questions")
+      print("  - Ctrl+C interrupts stream for immediate feedback")
+
+      # Load files if provided
+      loaded_content = {}
+      if files:
+          if isinstance(files, str):
+              files = [f.strip() for f in files.split(',')]
+          for file_path in files:
+              file_path = os.path.expanduser(file_path)
+              if os.path.exists(file_path):
+                  try:
+                      chunks = load_file_contents(file_path)
+                      loaded_content[file_path] = "\n".join(chunks)
+                      print(colored(f"Loaded: {file_path}", "green"))
+                  except Exception as e:
+                      print(colored(f"Error loading {file_path}: {e}", "red"))
+
+      # System message for PTI mode
+      pti_system = """You are an AI assistant in PTI (Pardon-The-Interruption) mode.
+
+      IMPORTANT INSTRUCTIONS:
+      1. Think step-by-step using <think>...</think> tags to show your reasoning
+      2. When you need more information from the user, use <request_for_input>your question</request_for_input>
+      3. Be thorough but concise in your reasoning
+      4. The user can interrupt at any time to provide guidance
+
+      Example:
+      <think>
+      Let me break this down...
+      Step 1: First I need to understand X
+      Step 2: Then consider Y
+      </think>
+
+      <request_for_input>
+      I notice you mentioned Z. Could you clarify what you mean by that?
+      </request_for_input>"""
+
+      if not messages or messages[0].get("role") != "system":
+          messages.insert(0, {"role": "system", "content": pti_system})
+
+      # REPL loop
+      user_input = None
+      while True:
+          try:
+              if not user_input:
+                  prompt_str = f"{npc_name}:pti> "
+                  user_input = input(prompt_str).strip()
+
+              if not user_input:
+                  user_input = None
+                  continue
+
+              if user_input.lower() == "/pq":
+                  print("Exiting PTI mode.")
+                  break
+
+              # Build prompt with file context
+              prompt_for_llm = user_input
+              if loaded_content:
+                  context_str = "\n".join([f"--- {fname} ---\n{content}" for fname, content in loaded_content.items()])
+                  prompt_for_llm += f"\n\nContext:\n{context_str}"
+
+              prompt_for_llm += "\n\nThink step-by-step using <think> tags. Use <request_for_input> when you need clarification."
+
+              messages.append({"role": "user", "content": user_input})
+
+              try:
+                  resp = get_llm_response(
+                      prompt_for_llm,
+                      model=model,
+                      provider=provider,
+                      messages=messages[:-1],  # Don't duplicate the user message
+                      stream=True,
+                      npc=npc
+                  )
+
+                  response_stream = resp.get('response')
+                  full_response = ""
+                  request_found = False
+
+                  # Stream the response
+                  for chunk in response_stream:
+                      chunk_content = ""
+                      if hasattr(chunk, 'choices') and chunk.choices:
+                          delta = chunk.choices[0].delta
+                          if hasattr(delta, 'content') and delta.content:
+                              chunk_content = delta.content
+                      elif isinstance(chunk, dict):
+                          chunk_content = chunk.get("message", {}).get("content", "")
+
+                      if chunk_content:
+                          print(chunk_content, end='', flush=True)
+                          full_response += chunk_content
+
+                          # Check for request_for_input
+                          if "</request_for_input>" in full_response:
+                              request_found = True
+                              break
+
+                  print()  # newline after stream
+
+                  messages.append({"role": "assistant", "content": full_response})
+                  user_input = None  # Reset for next iteration
+
+              except KeyboardInterrupt:
+                  print(colored("\n\n--- Interrupted ---", "yellow"))
+                  interrupt_input = input("Your feedback: ").strip()
+                  if interrupt_input:
+                      user_input = interrupt_input
+                  else:
+                      user_input = None
+                  continue
+
+          except KeyboardInterrupt:
+              print("\nUse '/pq' to exit or continue.")
+              user_input = None
+              continue
+          except EOFError:
+              print("\nExiting PTI mode.")
+              break
+
+      context['output'] = "Exited PTI mode."
+      context['messages'] = messages

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

@@ -0,0 +1,11 @@
+jinx_name: python
+description: Execute scripts with python. You must set the ultimate result as the "output"
+  variable. It MUST be a string. 
+  Do not add unnecessary print statements. 
+  This jinx is intended for executing code snippets that are not 
+  accomplished by other jinxes. Use it only when the others are insufficient.
+inputs:
+- code
+steps:
+- code: '{{code}}'
+  engine: python

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

@@ -0,0 +1,68 @@
+jinx_name: "roll"
+description: "Generate a video from a text prompt."
+inputs:
+  - prompt: "" # Required text prompt for video generation.
+  - 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.
+  - 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.
+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-1.1.13.data/data/npcsh/npc_team/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-1.1.13.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: ""
+  - sprovider: ""
+  - memory: false
+  - kg: false
+  - rag: false
+  - brainblast: false
+  - file_paths: ""
+  - history_db_path: "~/npcsh_history.db"
+  - vector_db_path: "~/npcsh_chroma.db"
+  - 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") or "~/.npcsh/npcsh_history.db")
+          
+          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') or "~/.npcsh/npcsh_chroma.db"),
+                      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