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

npcsh/npc_team/jinxs/utils/sample.jinx

@@ -0,0 +1,56 @@
+jinx_name: "sample"
+description: "Send a prompt directly to the LLM."
+inputs:
+  - prompt: "" # Required text prompt to send to the LLM.
+  - model: "" # LLM model to use. Defaults to NPC's model.
+  - provider: "" # LLM provider to use. Defaults to NPC's provider.
+steps:
+  - name: "send_prompt_to_llm"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      
+      prompt = context.get('prompt')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      if not prompt or not prompt.strip():
+          context['output'] = "Usage: /sample <your prompt> [-m --model] model  [-p --provider] provider"
+          context['messages'] = output_messages
+          exit()
+      
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not llm_model and current_npc and current_npc.model:
+          llm_model = current_npc.model
+      if not llm_provider and current_npc and current_npc.provider:
+          llm_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not llm_model: llm_model = "gemini-1.5-pro" # Example default
+      if not llm_provider: llm_provider = "gemini" # Example default
+
+      try:
+          result = get_llm_response(
+              prompt=prompt,
+              model=llm_model,
+              provider=llm_provider,
+              npc=current_npc,
+              **{k:v for k,v in context.items() if k not in ['messages', 'prompt', 'model', 'provider']} # Pass other context
+          )
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('response')
+              context['messages'] = result.get('messages', output_messages)
+              context['model'] = llm_model
+              context['provider'] = llm_provider
+          else:
+              context['output'] = str(result)
+              context['messages'] = output_messages
+      
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error sampling LLM: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/search/brainblast.jinx

@@ -0,0 +1,51 @@
+jinx_name: "brainblast"
+description: "Execute an advanced chunked search on command history"
+inputs:
+  - search_query: "" # Required search terms.
+  - history_db_path: "~/npcsh_history.db" # Path to the command history database.
+steps:
+  - name: "execute_brainblast"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.memory.command_history import CommandHistory
+      from npcpy.memory.search import execute_brainblast_command
+      
+      search_query = context.get('search_query')
+      history_db_path = context.get('history_db_path')
+      output_messages = context.get('messages', [])
+      
+      if not search_query or not search_query.strip():
+          context['output'] = "Usage: /brainblast <search_terms>"
+          context['messages'] = output_messages
+          exit()
+      
+      command_history = context.get('command_history')
+      if not command_history:
+          try:
+              command_history = CommandHistory(os.path.expanduser(history_db_path))
+              context['command_history'] = command_history # Add to context for potential reuse
+          except Exception as e:
+              context['output'] = f"Error connecting to command history: {e}"
+              context['messages'] = output_messages
+              exit()
+      
+      try:
+          # The original handler passed **kwargs, so we pass current context
+          # The execute_brainblast_command might filter out 'messages' itself
+          result = execute_brainblast_command(
+                                      command=search_query,
+                                      command_history=command_history,
+                                      **{k:v for k,v in context.items() if k != 'messages'}) # Exclude messages if not expected
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Brainblast search 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 brainblast command: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/search/rag.jinx

@@ -0,0 +1,70 @@
+jinx_name: "rag"
+description: "Execute a RAG command using ChromaDB embeddings with optional file input (-f/--file)"
+inputs:
+  - query: "" # Required search query for RAG.
+  - file_paths: "" # Optional comma-separated file paths to include in RAG.
+  - vector_db_path: "~/npcsh_chroma.db" # Path to the ChromaDB vector database.
+  - emodel: "" # Embedding model to use. Defaults to NPCSH_EMBEDDING_MODEL or NPC's model.
+  - eprovider: "" # Embedding provider to use. Defaults to NPCSH_EMBEDDING_PROVIDER or NPC's provider.
+steps:
+  - name: "execute_rag"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.data.load import load_file_contents
+      from npcpy.memory.search import execute_rag_command
+      # Assuming NPCSH_EMBEDDING_MODEL and NPCSH_EMBEDDING_PROVIDER are accessible
+      
+      query = context.get('query')
+      file_paths_str = context.get('file_paths')
+      vector_db_path = context.get('vector_db_path')
+      embedding_model = context.get('emodel')
+      embedding_provider = context.get('eprovider')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      file_paths = []
+      if file_paths_str and file_paths_str.strip():
+          file_paths = [os.path.abspath(os.path.expanduser(p.strip())) for p in file_paths_str.split(',')]
+      
+      if not query and not file_paths:
+          context['output'] = "Usage: /rag [-f file_path] <query>"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not embedding_model and current_npc and current_npc.model:
+          embedding_model = current_npc.model
+      if not embedding_provider and current_npc and current_npc.provider:
+          embedding_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not embedding_model: embedding_model = "nomic-ai/nomic-embed-text-v1.5" # Example default
+      if not embedding_provider: embedding_provider = "ollama" # Example default
+
+      try:
+          file_contents = []
+          for file_path in file_paths:
+              try:
+                  chunks = load_file_contents(file_path)
+                  file_name = os.path.basename(file_path)
+                  file_contents.extend([f"[{file_name}] {chunk}" for chunk in chunks])
+              except Exception as file_err:
+                  file_contents.append(f"Error processing file {file_path}: {str(file_err)}")
+          
+          result = execute_rag_command(
+              command=query,
+              vector_db_path=os.path.expanduser(vector_db_path),
+              embedding_model=embedding_model,
+              embedding_provider=embedding_provider,
+              file_contents=file_contents if file_paths else None,
+              **{k:v for k,v in context.items() if k not in ['messages', 'query', 'file_paths']} # Pass other context
+          )
+          context['output'] = result.get('response')
+          context['messages'] = result.get('messages', output_messages)
+      
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error executing RAG command: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/search/search.jinx

@@ -0,0 +1,192 @@
+jinx_name: "search"
+description: "Execute web search or memory/KG search. Usage: /search [-m/-mem | -kg] <query>"
+inputs:
+  - query: "" # Required search query.
+  - search_type: "web" # Type of search: "web", "memory", or "kg".
+  - sprovider: "" # Search provider for web search. Defaults to NPCSH_SEARCH_PROVIDER.
+  - history_db_path: "~/npcsh_history.db" # Path to the command history database for memory/KG search.
+steps:
+  - name: "execute_search"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.data.web import search_web
+      from npcpy.memory.command_history import CommandHistory, load_kg_from_db, save_kg_to_db # For KG search
+      from npcsh._state import get_relevant_memories # For memory search
+      # Assuming NPCSH_SEARCH_PROVIDER is accessible
+
+      query = context.get('query')
+      search_type = context.get('search_type')
+      search_provider = context.get('sprovider')
+      history_db_path = context.get('history_db_path')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      current_team = context.get('team')
+      
+      if not query or not query.strip():
+          context['output'] = (
+              "Usage:\n"
+              "  /search <query>              - Web search\n"
+              "  /search -m <query>           - Memory search\n"
+              "  /search -kg <query>          - Knowledge graph search"
+          )
+          context['messages'] = output_messages
+          exit()
+
+      def search_memories(query_str, current_context, output_msgs):
+          command_history = current_context.get('command_history')
+          if not command_history:
+              db_path = os.path.expanduser(current_context.get("history_db_path", "~/npcsh_history.db"))
+              try:
+                  command_history = CommandHistory(db_path)
+                  current_context['command_history'] = command_history
+              except Exception as e:
+                  return {"output": f"Error connecting to history: {e}", "messages": output_msgs}
+          
+          npc_name = current_context.get('npc_name', '__none__')
+          team_name = current_context.get('team_name', '__none__')
+          current_path = current_context.get('current_path', os.getcwd())
+          state = current_context.get('state')
+          
+          try:
+              memories = get_relevant_memories(
+                  command_history=command_history,
+                  npc_name=npc_name,
+                  team_name=team_name,
+                  path=current_path,
+                  query=query_str,
+                  max_memories=10,
+                  state=state
+              )
+              
+              if not memories:
+                  output = f"No memories found for query: '{query_str}'"
+              else:
+                  output = f"Found {len(memories)} memories:\n\n"
+                  for i, mem in enumerate(memories, 1):
+                      final_mem = (
+                          mem.get('final_memory') or 
+                          mem.get('initial_memory')
+                      )
+                      timestamp = mem.get('timestamp', 'unknown')
+                      output += f"{i}. [{timestamp}] {final_mem}\n"
+              
+              return {"output": output, "messages": output_msgs}
+              
+          except Exception as e:
+              traceback.print_exc()
+              return {"output": f"Error searching memories: {e}", "messages": output_msgs}
+
+      def search_knowledge_graph(query_str, current_context, output_msgs):
+          command_history = current_context.get('command_history')
+          if not command_history:
+              db_path = os.path.expanduser(current_context.get("history_db_path", "~/npcsh_history.db"))
+              try:
+                  command_history = CommandHistory(db_path)
+                  current_context['command_history'] = command_history
+              except Exception as e:
+                  return {"output": f"Error connecting to history: {e}", "messages": output_msgs}
+          
+          npc_name = current_context.get('npc_name', '__none__')
+          team_name = current_context.get('team_name', '__none__')
+          current_path = current_context.get('current_path', os.getcwd())
+          
+          try:
+              engine = command_history.engine
+              kg = load_kg_from_db(
+                  engine, 
+                  team_name, 
+                  npc_name, 
+                  current_path
+              )
+              
+              if not kg or not kg.get('facts'):
+                  return {
+                      "output": (
+                          f"No knowledge graph found for current scope.\n"
+                          f"Scope: Team='{team_name}', "
+                          f"NPC='{npc_name}', Path='{current_path}'"
+                      ),
+                      "messages": output_msgs
+                  }
+              
+              query_lower = query_str.lower()
+              matching_facts = []
+              matching_concepts = []
+              
+              for fact in kg.get('facts', []):
+                  statement = fact.get('statement', '').lower()
+                  if query_lower in statement:
+                      matching_facts.append(fact)
+              
+              for concept in kg.get('concepts', []):
+                  name = concept.get('name', '').lower()
+                  desc = concept.get('description', '').lower()
+                  if query_lower in name or query_lower in desc:
+                      matching_concepts.append(concept)
+              
+              output = f"Knowledge Graph Search Results for '{query_str}':\n\n"
+              
+              if matching_facts:
+                  output += f"## Facts ({len(matching_facts)}):\n"
+                  for i, fact in enumerate(matching_facts, 1):
+                      output += f"{i}. {fact.get('statement')}\n"
+                  output += "\n"
+              
+              if matching_concepts:
+                  output += f"## Concepts ({len(matching_concepts)}):\n"
+                  for i, concept in enumerate(matching_concepts, 1):
+                      name = concept.get('name')
+                      desc = concept.get('description', '')
+                      output += f"{i}. {name}: {desc}\n"
+              
+              if not matching_facts and not matching_concepts:
+                  output += "No matching facts or concepts found."
+              
+              return {"output": output, "messages": output_msgs}
+              
+          except Exception as e:
+              traceback.print_exc()
+              return {"output": f"Error searching KG: {e}", "messages": output_msgs}
+
+      def search_web_default(query_str, current_context, output_msgs):
+          # Fallback for search_provider if not explicitly set in Jinx inputs
+          current_search_provider = current_context.get('sprovider')
+          # If NPCSH_SEARCH_PROVIDER is accessible, use it. Otherwise, a default.
+          # For Jinx, let's just use a hardcoded default if not provided.
+          if not current_search_provider:
+              current_search_provider = "google" # Example default
+
+          # Assuming render_markdown is accessible
+          # render_markdown(f'- Searching {current_search_provider} for "{query_str}"') # Not directly supported in Jinx steps
+
+          try:
+              search_results = search_web(query_str, provider=current_search_provider)
+              output = (
+                  "\n".join([f"- {res}" for res in search_results]) 
+                  if search_results 
+                  else "No results found."
+              )
+          except Exception as e:
+              traceback.print_exc()
+              output = f"Error during web search: {e}"
+          
+          return {"output": output, "messages": output_msgs}
+
+
+      # Populate npc_name, team_name, current_path for search functions
+      context['npc_name'] = current_npc.name if isinstance(current_npc, type(None).__class__) else "__none__"
+      context['team_name'] = current_team.name if current_team else "__none__"
+      context['current_path'] = os.getcwd() # Or get from context if available
+
+      final_result = None
+      if search_type == 'memory':
+          final_result = search_memories(query, context, output_messages)
+      elif search_type == 'kg':
+          final_result = search_knowledge_graph(query, context, output_messages)
+      else:
+          final_result = search_web_default(query, context, output_messages)
+
+      context['output'] = final_result.get('output')
+      context['messages'] = final_result.get('messages', output_messages)

npcsh/npc_team/jinxs/utils/serve.jinx

@@ -0,0 +1,29 @@
+jinx_name: "serve"
+description: "Serve an NPC Team"
+inputs:
+  - port: 5337 # The port to run the Flask server on.
+  - cors: "" # Comma-separated CORS origins.
+steps:
+  - name: "start_flask_server"
+    engine: "python"
+    code: |
+      from npcpy.serve import start_flask_server
+      
+      port = context.get('port')
+      cors_str = context.get('cors')
+      output_messages = context.get('messages', [])
+
+      cors_origins = None
+      if cors_str and cors_str.strip():
+          cors_origins = [origin.strip() for origin in cors_str.split(",")]
+
+      # start_flask_server blocks, so this will hold the Jinx until the server is stopped.
+      # In a real-world scenario, you might want to run this in a separate process
+      # or have a non-blocking server start.
+      start_flask_server(
+          port=int(port), # Ensure port is an integer
+          cors_origins=cors_origins,
+      )
+
+      context['output'] = "NPC Team server started. Execution of this jinx will pause until the server is stopped."
+      context['messages'] = output_messages

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

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