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

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/npc_team/jinxs/utils/core/build.jinx

@@ -0,0 +1,65 @@
+jinx_name: "build"
+description: "Build deployment artifacts for NPC team"
+inputs:
+  - target: "flask" # The type of deployment target (e.g., flask, docker, cli, static).
+  - output: "./build" # The output directory for built artifacts.
+  - team: "./npc_team" # The path to the NPC team directory.
+  - port: 5337 # The port for flask server builds.
+  - cors: "" # Comma-separated CORS origins for flask server builds.
+steps:
+  - name: "execute_build"
+    engine: "python"
+    code: |
+      import os
+      
+      # Assume these build functions are available in the execution environment
+      # from a larger project context, e.g., from npcpy.build_funcs
+      try:
+          from npcpy.build_funcs import (
+              build_flask_server,
+              build_docker_compose,
+              build_cli_executable,
+              build_static_site,
+          )
+      except ImportError:
+          # Provide mock functions for demonstration or error handling
+          def build_flask_server(config, **kwargs): return {"output": f"Mock build flask: {config}", "messages": []}
+          def build_docker_compose(config, **kwargs): return {"output": f"Mock build docker: {config}", "messages": []}
+          def build_cli_executable(config, **kwargs): return {"output": f"Mock build cli: {config}", "messages": []}
+          def build_static_site(config, **kwargs): return {"output": f"Mock build static: {config}", "messages": []}
+
+      target = context.get('target')
+      output_dir = context.get('output')
+      team_path = context.get('team')
+      port = context.get('port')
+      cors_origins_str = context.get('cors')
+      
+      cors_origins = [origin.strip() for origin in cors_origins_str.split(',')] if cors_origins_str.strip() else None
+
+      build_config = {
+          'team_path': os.path.abspath(os.path.expanduser(team_path)),
+          'output_dir': os.path.abspath(os.path.expanduser(output_dir)),
+          'target': target,
+          'port': port,
+          'cors_origins': cors_origins,
+      }
+      
+      builders = {
+          'flask': build_flask_server,
+          'docker': build_docker_compose,
+          'cli': build_cli_executable,
+          'static': build_static_site,
+      }
+      
+      output_messages = context.get('messages', [])
+      output_result = ""
+
+      if target not in builders:
+          output_result = f"Unknown target: {target}. Available: {list(builders.keys())}"
+      else:
+          result = builders[target](build_config, messages=output_messages)
+          output_result = result.get('output', 'Build command executed.')
+          output_messages = result.get('messages', output_messages) # Update messages from builder call
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/core/compile.jinx

@@ -0,0 +1,50 @@
+jinx_name: "compile"
+description: "Compile NPC profiles"
+inputs:
+  - npc_file_path: "" # Optional path to a specific NPC file to compile.
+  - npc_team_dir: "./npc_team" # Directory containing NPC profiles to compile, if no specific file is given.
+steps:
+  - name: "compile_npcs"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.npc_compiler import NPC, Team # Assuming Team might be needed for full directory compilation
+      
+      npc_file_path_arg = context.get('npc_file_path')
+      npc_team_dir = context.get('npc_team_dir')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      compiled_npc_object = None
+      
+      try:
+          if npc_file_path_arg and npc_file_path_arg.strip():
+              npc_full_path = os.path.abspath(os.path.expanduser(npc_file_path_arg))
+              if os.path.exists(npc_full_path):
+                  # Assuming NPC() constructor "compiles" it by loading its definition
+                  compiled_npc_object = NPC(file=npc_full_path, db_conn=context.get('db_conn'))
+                  output_result = f"Compiled NPC: {npc_full_path}"
+              else:
+                  output_result = f"Error: NPC file not found: {npc_full_path}"
+          else:
+              # Compile all NPCs in the directory. This would typically involve iterating and loading.
+              # For simplicity in this Jinx, we just acknowledge the directory.
+              # A more robust implementation would loop through .npc files and compile them.
+              abs_npc_team_dir = os.path.abspath(os.path.expanduser(npc_team_dir))
+              if os.path.exists(abs_npc_team_dir):
+                  output_result = f"Acknowledged compilation for all NPCs in directory: {abs_npc_team_dir}"
+                  # Example of loading a Team and setting the compiled_npc_object to its forenpc if available
+                  # team = Team(team_path=abs_npc_team_dir, db_conn=context.get('db_conn'))
+                  # if team.forenpc:
+                  #    compiled_npc_object = team.forenpc 
+              else:
+                  output_result = f"Error: NPC team directory not found: {npc_team_dir}"
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error compiling: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages
+      if compiled_npc_object:
+          context['compiled_npc_object'] = compiled_npc_object # Store the compiled NPC object if any

npcsh/npc_team/jinxs/utils/core/help.jinx

@@ -0,0 +1,52 @@
+jinx_name: help
+description: Show help for commands, NPCs, or Jinxs
+inputs:
+  - topic: null
+steps:
+  - name: show_help
+    engine: python
+    code: |
+      import json
+      from npcsh._state import CANONICAL_ARGS, get_argument_help
+      
+      topic = context.get('topic')
+      
+      if not topic:
+          output_lines = ["# Available Commands\n\n"]
+          
+          all_jinxs = {}
+          if hasattr(npc, 'team') and npc.team and hasattr(npc.team, 'jinxs_dict'):
+              all_jinxs.update(npc.team.jinxs_dict)
+          if hasattr(npc, 'jinxs_dict') and npc.jinxs_dict:
+              all_jinxs.update(npc.jinxs_dict)
+          
+          for cmd in sorted(all_jinxs.keys()):
+              jinx_obj = all_jinxs[cmd]
+              desc = getattr(jinx_obj, 'description', 'No description')
+              output_lines.append(f"/{cmd} - {desc}\n\n")
+          
+          arg_help_map = get_argument_help()
+          if arg_help_map:
+              output_lines.append("## Common Command-Line Flags\n\n")
+              output_lines.append("The shortest unambiguous prefix works.\n")
+              
+              for arg in sorted(CANONICAL_ARGS):
+                  aliases = arg_help_map.get(arg, [])
+                  alias_str = f"(-{min(aliases, key=len)})" if aliases else ""
+                  output_lines.append(f"--{arg:<20} {alias_str}\n")
+          
+          output = "".join(output_lines)
+      else:
+          jinx_obj = None
+          if hasattr(npc, 'team') and npc.team and hasattr(npc.team, 'jinxs_dict'):
+              jinx_obj = npc.team.jinxs_dict.get(topic)
+          if not jinx_obj and hasattr(npc, 'jinxs_dict'):
+              jinx_obj = npc.jinxs_dict.get(topic)
+          
+          if jinx_obj:
+              output = f"## Help for Jinx: `/{topic}`\n\n"
+              output += f"- **Description**: {jinx_obj.description}\n"
+              if hasattr(jinx_obj, 'inputs') and jinx_obj.inputs:
+                  output += f"- **Inputs**: {json.dumps(jinx_obj.inputs, indent=2)}\n"
+          else:
+              output = f"No help topic found for `{topic}`."

npcsh/npc_team/jinxs/utils/core/init.jinx

@@ -0,0 +1,41 @@
+jinx_name: "init"
+description: "Initialize NPC project"
+inputs:
+  - directory: "." # The directory where the NPC project should be initialized.
+  - templates: "" # Optional templates to use for initialization.
+  - context: "" # Optional context for project initialization.
+  - model: "" # Optional LLM model to set as default for the project.
+  - provider: "" # Optional LLM provider to set as default for the project.
+steps:
+  - name: "initialize_project"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.npc_compiler import initialize_npc_project
+      
+      directory = context.get('directory')
+      templates = context.get('templates')
+      context_param = context.get('context') # Renamed to avoid conflict with Jinx context
+      model = context.get('model')
+      provider = context.get('provider')
+      output_messages = context.get('messages', [])
+      
+      output_result = ""
+      try:
+          initialize_npc_project(
+              directory=directory,
+              templates=templates,
+              context=context_param, # Use the renamed context parameter
+              model=model,
+              provider=provider
+          )
+          output_result = f"NPC project initialized in {os.path.abspath(directory)}."
+      except NameError:
+          output_result = "Init function (initialize_npc_project) not available."
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Error initializing project: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/core/jinxs.jinx

@@ -0,0 +1,32 @@
+jinx_name: jinxs
+description: Show available jinxs for the current NPC/Team
+inputs: []
+steps:
+  - name: list_jinxs
+    engine: python
+    code: |
+      output_lines = ["Available Jinxs:\n"]
+      jinxs_listed = set()
+      
+      if hasattr(npc, 'team') and npc.team:
+          team = npc.team
+          
+          if hasattr(team, 'jinxs_dict') and team.jinxs_dict:
+              output_lines.append(f"\n--- Team Jinxs ---\n")
+              for name, jinx_obj in sorted(team.jinxs_dict.items()):
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if hasattr(npc, 'jinxs_dict') and npc.jinxs_dict:
+          output_lines.append(f"\n--- NPC Jinxs for {npc.name} ---\n")
+          for name, jinx_obj in sorted(npc.jinxs_dict.items()):
+              if name not in jinxs_listed:
+                  desc = getattr(jinx_obj, 'description', 'No description available.')
+                  output_lines.append(f"- /{name}: {desc}\n")
+                  jinxs_listed.add(name)
+      
+      if not jinxs_listed:
+          output = "No jinxs available for the current context."
+      else:
+          output = "".join(output_lines)

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

@@ -0,0 +1,94 @@
+jinx_name: edit_file
+description: Examines a file, determines what changes are needed, and applies those
+  changes.
+inputs:
+- file_path
+- edit_instructions
+- backup: true
+steps:
+  - name: "edit_file"
+    engine: "python"
+    code: |
+      import os
+      from npcpy.llm_funcs import get_llm_response
+      
+    
+      file_path = os.path.expanduser("{{ file_path }}")
+      edit_instructions = "{{ edit_instructions }}"
+      backup_str = "{{ backup }}"
+      create_backup = backup_str.lower() not in ('false', 'no', '0', '')
+      
+    
+      with open(file_path, 'r') as f:
+          original_content = f.read()
+      
+    
+      if create_backup:
+          backup_path = file_path + ".bak"
+          with open(backup_path, 'w') as f:
+              f.write(original_content)
+      
+    
+      prompt = """You are a code editing assistant. Analyze this file and make the requested changes.
+
+        File content:
+        """ + original_content + """
+
+        Edit instructions: """ + edit_instructions + """
+
+        Return a JSON object with these fields:
+        1. "modifications": An array of modification objects, where each object has:
+        - "type": One of "replace", "insert_after", "insert_before", or "delete"
+        - "target": For "insert_after" and "insert_before", the text to insert after/before
+                    For "delete", the text to delete
+        - "original": For "replace", the text to be replaced
+        - "replacement": For "replace", the text to replace with
+        - "insertion": For "insert_after" and "insert_before", the text to insert
+        2. "explanation": Brief explanation of the changes made
+        """
+    
+      response = get_llm_response(prompt, model=npc.model, provider=npc.provider, npc=npc, format="json")
+      
+      result = response.get("response", {})
+      modifications = result.get("modifications", [])
+      explanation = result.get("explanation", "No explanation provided")
+      
+    
+      updated_content = original_content
+      changes_applied = 0
+      
+      for mod in modifications:
+          print(mod)
+          mod_type = mod.get("type")
+          
+          if mod_type == "replace":
+              original = mod.get("original")
+              replacement = mod.get("replacement")
+              if original in updated_content:
+                  updated_content = updated_content.replace(original, replacement)
+                  changes_applied += 1
+          
+          elif mod_type == "insert_after":
+              target = mod.get("target")
+              insertion = mod.get("insertion")
+              if target in updated_content:
+                  updated_content = updated_content.replace(target, target + insertion)
+                  changes_applied += 1
+          
+          elif mod_type == "insert_before":
+              target = mod.get("target")
+              insertion = mod.get("insertion")
+              if target in updated_content:
+                  updated_content = updated_content.replace(target, insertion + target)
+                  changes_applied += 1
+          
+          elif mod_type == "delete":
+              target = mod.get("target")
+              if target in updated_content:
+                  updated_content = updated_content.replace(target, "")
+                  changes_applied += 1
+      
+      with open(file_path, 'w') as f:
+          f.write(updated_content)
+      
+      output = "Applied " + str(changes_applied) + " changes to " + file_path + "\n\n" + explanation

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

@@ -0,0 +1,61 @@
+jinx_name: "ots"
+description: "Take screenshot and analyze with vision model. Usage: /ots <prompt>"
+inputs:
+  - prompt
+  - image_paths_args: ""
+  - vmodel: ""
+  - vprovider: ""
+steps:
+  - name: "analyze_screenshot_or_image"
+    engine: "python"
+    code: |
+      import os
+      import traceback
+      from npcpy.llm_funcs import get_llm_response
+      from npcpy.data.image import capture_screenshot
+      
+      user_prompt = context.get('prompt') or ""
+      image_paths_args_str = context.get('image_paths_args') or ""
+      vision_model = context.get('vmodel') or ""
+      vision_provider = context.get('vprovider') or ""
+      stream_output = context.get('stream') or False
+      api_url = context.get('api_url') or ""
+      api_key = context.get('api_key') or ""
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+
+      image_paths = []
+      if image_paths_args_str.strip():
+          for img_path_arg in image_paths_args_str.split(','):
+              full_path = os.path.abspath(os.path.expanduser(img_path_arg.strip()))
+              if os.path.exists(full_path):
+                  image_paths.append(full_path)
+      
+      if not image_paths:
+          screenshot_info = capture_screenshot(full=False)
+          if screenshot_info and "file_path" in screenshot_info:
+              image_paths.append(screenshot_info["file_path"])
+              print(f"📸 Screenshot captured: {screenshot_info.get('filename', os.path.basename(screenshot_info['file_path']))}")
+
+      if not vision_model:
+          vision_model = getattr(current_npc, 'model', 'gemma3:4b')
+      
+      if not vision_provider:
+          vision_provider = getattr(current_npc, 'provider', 'ollama')
+
+      response_data = get_llm_response(
+          prompt=user_prompt,
+          model=vision_model,
+          provider=vision_provider,
+          messages=output_messages,
+          images=image_paths,
+          stream=stream_output,
+          npc=current_npc,
+          api_url=api_url or None,
+          api_key=api_key or None
+      )
+      
+      context['output'] = response_data.get('response', 'No response received')
+      context['messages'] = response_data.get('messages', output_messages)
+      context['model'] = vision_model
+      context['provider'] = vision_provider