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

npcsh-1.1.5.data/data/npcsh/npc_team/alicanto.jinx

@@ -0,0 +1,88 @@
+jinx_name: "alicanto"
+description: "Conduct deep research with multiple perspectives, identifying gold insights and cliff warnings"
+inputs:
+  - query: "" # Required research query.
+  - num_npcs: 5 # Number of NPCs to involve in research.
+  - depth: 3 # Depth of research.
+  - model: "" # LLM model to use. Defaults to NPCSH_CHAT_MODEL or NPC's model.
+  - provider: "" # LLM provider to use. Defaults to NPCSH_CHAT_PROVIDER or NPC's provider.
+  - max_steps: 20 # Maximum number of steps in Alicanto research.
+  - skip_research: True # Whether to skip the research phase.
+  - exploration: "" # Exploration factor (float).
+  - creativity: "" # Creativity factor (float).
+  - format: "" # Output format (report, summary, full).
+steps:
+  - name: "conduct_alicanto_research"
+    engine: "python"
+    code: |
+      import traceback
+      import logging
+      from npcsh.alicanto import alicanto
+      # Assuming NPCSH_CHAT_MODEL and NPCSH_CHAT_PROVIDER are accessible
+
+      query = context.get('query')
+      num_npcs = int(context.get('num_npcs', 5)) # Ensure int type
+      depth = int(context.get('depth', 3)) # Ensure int type
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      max_steps = int(context.get('max_steps', 20)) # Ensure int type
+      skip_research = context.get('skip_research', True)
+      exploration_factor = context.get('exploration')
+      creativity_factor = context.get('creativity')
+      output_format = context.get('format')
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      
+      if not query or not query.strip():
+          context['output'] = "Usage: /alicanto <research query> [--num-npcs N] [--depth N] [--exploration 0.3] [--creativity 0.5] [--format report|summary|full]"
+          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)
+      # Assuming NPCSH_CHAT_MODEL and NPCSH_CHAT_PROVIDER exist and are imported implicitly or set by environment
+      # Hardcoding defaults for demonstration if not available through NPC or _state
+      if not llm_model: llm_model = "gemini-1.5-pro" 
+      if not llm_provider: llm_provider = "gemini" 
+
+      try:
+          logging.info(f"Starting Alicanto research on: {query}")
+
+          alicanto_kwargs = {
+              'query': query,
+              'num_npcs': num_npcs,
+              'depth': depth,
+              'model': llm_model,
+              'provider': llm_provider, 
+              'max_steps': max_steps,
+              'skip_research': skip_research,
+          }
+
+          if exploration_factor: alicanto_kwargs['exploration_factor'] = float(exploration_factor)
+          if creativity_factor: alicanto_kwargs['creativity_factor'] = float(creativity_factor)
+          if output_format: alicanto_kwargs['output_format'] = output_format
+
+          result = alicanto(**alicanto_kwargs)
+          
+          output_result = ""
+          if isinstance(result, dict):
+              if "integration" in result:
+                  output_result = result["integration"]
+              else:
+                  output_result = "Alicanto research completed. Full results available in returned data."
+          else:
+              output_result = str(result)
+              
+          context['output'] = output_result
+          context['messages'] = output_messages
+          context['alicanto_result'] = result # Store full result in context
+      except Exception as e:
+          traceback.print_exc()
+          logging.error(f"Error during Alicanto research: {e}")
+          context['output'] = f"Error during Alicanto research: {e}"
+          context['messages'] = output_messages

npcsh-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/breathe.jinx

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

npcsh-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/corca.jinx

@@ -0,0 +1,28 @@
+jinx_name: "corca"
+description: "Enter the Corca MCP-powered agentic shell. Usage: /corca [--mcp-server-path path]"
+inputs:
+  - command: "/corca" # The full command string, e.g., "/corca --mcp-server-path /tmp/mcp"
+steps:
+  - name: "enter_corca"
+    engine: "python"
+    code: |
+      # Assume npcsh._state and enter_corca_mode are accessible in the environment
+
+      from npcsh._state import initial_state, setup_shell 
+      from npcsh.corca import enter_corca_mode
+
+
+      full_command_str = context.get('command')
+      output_messages = context.get('messages', [])
+      
+      command_history, team, default_npc = setup_shell()
+      
+      result = enter_corca_mode(
+          command=full_command_str, 
+          command_history=command_history, 
+          shell_state=initial_state,
+          **context # Pass all context as kwargs to enter_corca_mode as it expects
+      )
+      
+      context['output'] = result.get('output', 'Entered Corca mode.')
+      context['messages'] = result.get('messages', output_messages)

{npcsh-1.1.4.data → npcsh-1.1.5.data}/data/npcsh/npc_team/edit_file.jinx

@@ -1,4 +1,4 @@
-jinx_name: file_editor
+jinx_name: edit_file
 description: Examines a file, determines what changes are needed, and applies those
   changes.
 inputs:

npcsh-1.1.5.data/data/npcsh/npc_team/flush.jinx

@@ -0,0 +1,39 @@
+jinx_name: "flush"
+description: "Flush the last N messages from the conversation history."
+inputs:
+  - n: 1 # The number of messages to flush (default to 1).
+steps:
+  - name: "flush_messages"
+    engine: "python"
+    code: |
+      n = int(context.get('n', 1))
+      output_messages = context.get('messages', [])
+      
+      if n <= 0:
+          context['output'] = "Error: Number of messages must be positive."
+          context['messages'] = output_messages
+          exit()
+
+      new_messages = list(output_messages)
+      original_len = len(new_messages)
+      removed_count = 0
+
+      if new_messages and new_messages[0].get("role") == "system":
+          system_message = new_messages[0]
+          working_messages = new_messages[1:]
+          num_to_remove = min(n, len(working_messages))
+          if num_to_remove > 0:
+              final_messages = [system_message] + working_messages[:-num_to_remove]
+              removed_count = num_to_remove
+          else:
+              final_messages = [system_message]
+      else:
+          num_to_remove = min(n, original_len)
+          if num_to_remove > 0:
+              final_messages = new_messages[:-num_to_remove]
+              removed_count = num_to_remove
+          else:
+              final_messages = []
+
+      context['output'] = f"Flushed {removed_count} message(s). Context is now {len(final_messages)} messages."
+      context['messages'] = final_messages

npcsh-1.1.5.data/data/npcsh/npc_team/guac.jinx

@@ -0,0 +1,46 @@
+jinx_name: "guac"
+description: "Enter guac mode for plotting and data visualization."
+inputs:
+  - config_dir: "" # Optional configuration directory.
+  - plots_dir: "" # Optional directory for plots.
+  - refresh_period: 100 # Refresh period for guac mode.
+  - lang: "" # Language setting for guac mode.
+steps:
+  - name: "enter_guac"
+    engine: "python"
+    code: |
+      import os
+      from sqlalchemy import create_engine
+      from npcpy.npc_compiler import NPC, Team
+      from npcsh.guac import enter_guac_mode
+      
+      config_dir = context.get('config_dir')
+      plots_dir = context.get('plots_dir')
+      refresh_period = context.get('refresh_period')
+      lang = context.get('lang')
+      output_messages = context.get('messages', [])
+      
+      db_path = os.path.expanduser('~/npcsh_history.db')
+      db_conn = create_engine(f'sqlite:///{db_path}')
+      
+      npc_file = os.path.expanduser('~/.npcsh/guac/npc_team/guac.npc')
+      npc_team_dir = os.path.expanduser('~/.npcsh/guac/npc_team/')
+      
+      # Ensure directories exist for guac NPC/Team
+      os.makedirs(os.path.dirname(npc_file), exist_ok=True)
+      
+      guac_npc = NPC(file=npc_file, db_conn=db_conn)
+      guac_team = Team(npc_team_dir, db_conn=db_conn)
+      
+      enter_guac_mode(
+          npc=guac_npc, 
+          team=guac_team, 
+          config_dir=config_dir, 
+          plots_dir=plots_dir,
+          npc_team_dir=npc_team_dir,
+          refresh_period=int(refresh_period), # Ensure int type
+          lang=lang
+      )
+      
+      context['output'] = 'Exiting Guac Mode'
+      context['messages'] = output_messages

npcsh-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/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-1.1.5.data/data/npcsh/npc_team/npc-studio.jinx

@@ -0,0 +1,82 @@
+jinx_name: "npc-studio"
+description: "Start npc studio"
+inputs:
+  - user_command: "" # Any additional arguments to pass to the npc studio launch.
+steps:
+  - name: "launch_npc_studio"
+    engine: "python"
+    code: |
+      import os
+      import subprocess
+      import sys
+      from pathlib import Path
+      import traceback
+      
+      NPC_STUDIO_DIR = Path.home() / ".npcsh" / "npc-studio"
+
+      def ensure_repo():
+          """Clone or update the npc-studio repo."""
+          if not NPC_STUDIO_DIR.exists():
+              os.makedirs(NPC_STUDIO_DIR.parent, exist_ok=True)
+              subprocess.check_call([
+                  "git", "clone",
+                  "https://github.com/npc-worldwide/npc-studio.git",
+                  str(NPC_STUDIO_DIR)
+              ])
+          else:
+              subprocess.check_call(
+                  ["git", "pull"],
+                  cwd=NPC_STUDIO_DIR
+              )
+
+      def install_dependencies():
+          """Install npm and pip dependencies."""
+          subprocess.check_call(["npm", "install"], cwd=NPC_STUDIO_DIR)
+
+          req_file = NPC_STUDIO_DIR / "requirements.txt"
+          if req_file.exists():
+              subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", str(req_file)])
+
+      def launch_npc_studio(path_to_open: str = None):
+          """
+          Launch the NPC Studio backend + frontend.
+          Returns PIDs for processes.
+          """
+          ensure_repo()
+          install_dependencies()
+
+          backend = subprocess.Popen(
+              [sys.executable, "npc_studio_serve.py"],
+              cwd=NPC_STUDIO_DIR, 
+              shell = False
+          )
+          
+          # npm run dev is typically for the frontend development server
+          dev_server = subprocess.Popen(
+              ["npm", "run", "dev"],
+              cwd=NPC_STUDIO_DIR,
+              shell=False
+          )
+          
+          # npm start is typically for electron or other packaged frontend
+          frontend = subprocess.Popen(
+              ["npm", "start"],
+              cwd=NPC_STUDIO_DIR,
+              shell=False
+          )
+
+          return backend, dev_server, frontend
+      
+      user_command = context.get('user_command')
+      output_messages = context.get('messages', [])
+      output_result = ""
+
+      try:
+          backend, electron, frontend = launch_npc_studio(user_command or None)
+          output_result = f"NPC Studio started!\nBackend PID={backend.pid}, Electron PID={electron.pid} Frontend PID={frontend.pid}"
+      except Exception as e:
+          traceback.print_exc()
+          output_result = f"Failed to start NPC Studio: {e}"
+      
+      context['output'] = output_result
+      context['messages'] = output_messages