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

npcsh/npc_team/jinxs/{python_executor.jinx → code/python.jinx}

@@ -1,4 +1,4 @@
-jinx_name: python_executor
+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. 

npcsh/npc_team/jinxs/{bash_executer.jinx → code/sh.jinx}

@@ -1,8 +1,7 @@
-jinx_name: bash_executor
+jinx_name: sh
 description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically.
 inputs:
 - bash_command
-- user_request
 steps:
   - engine: python
     code: |

npcsh/npc_team/jinxs/code/sql.jinx

@@ -0,0 +1,16 @@
+jinx_name: sql_executor
+description: Execute queries on the ~/npcsh_history.db to pull data. The database
+  contains only information about conversations and other user-provided data. It does
+  not store any information about individual files. Avoid using percent signs unless absolutely necessary.
+inputs:
+- sql_query
+steps:
+  - engine: python
+    code: |
+      import pandas as pd
+      query = "{{ sql_query }}"
+      try:
+        df = pd.read_sql_query(query, npc.db_conn)
+      except Exception as e:
+        df = pd.DataFrame({'Error': [str(e)]})
+      output = df.to_string()

npcsh/npc_team/jinxs/modes/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/npc_team/jinxs/modes/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/npc_team/jinxs/modes/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/npc_team/jinxs/modes/plonk.jinx

@@ -0,0 +1,57 @@
+jinx_name: "plonk"
+description: "Use vision model to interact with GUI. Usage: /plonk <task description>"
+inputs:
+  - task_description: "" # Required task description for GUI interaction.
+  - vmodel: "" # Vision model to use. Defaults to NPCSH_VISION_MODEL or NPC's model.
+  - vprovider: "" # Vision model provider. Defaults to NPCSH_VISION_PROVIDER or NPC's provider.
+steps:
+  - name: "execute_plonk"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.plonk import execute_plonk_command, format_plonk_summary
+      # Assuming NPCSH_VISION_MODEL and NPCSH_VISION_PROVIDER are accessible
+      
+      task_description = context.get('task_description')
+      vision_model = context.get('vmodel')
+      vision_provider = context.get('vprovider')
+      plonk_context = context.get('plonk_context') # Passed from original context
+      current_npc = context.get('npc')
+      output_messages = context.get('messages', [])
+      
+      if not task_description or not task_description.strip():
+          context['output'] = "Usage: /plonk <task_description> [--vmodel model_name] [--vprovider provider_name]"
+          context['messages'] = output_messages
+          exit()
+
+      # Fallback for model/provider if not explicitly set in Jinx inputs
+      if not vision_model and current_npc and current_npc.model:
+          vision_model = current_npc.model
+      if not vision_provider and current_npc and current_npc.provider:
+          vision_provider = current_npc.provider
+      
+      # Final fallbacks (these would ideally come from npcsh._state config)
+      if not vision_model: vision_model = "gemini-1.5-pro-vision" # Example default
+      if not vision_provider: vision_provider = "gemini" # Example default
+
+      try:
+          summary_data = execute_plonk_command(
+              request=task_description,
+              model=vision_model,
+              provider=vision_provider,
+              npc=current_npc,
+              plonk_context=plonk_context,
+              debug=True # Assuming debug is often desired for plonk
+          )        
+          
+          if summary_data and isinstance(summary_data, list):
+              output_report = format_plonk_summary(summary_data)
+              context['output'] = output_report
+          else:
+              context['output'] = "Plonk command did not complete within the maximum number of iterations."
+
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error executing plonk command: {e}"
+      
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/pti.jinx

@@ -0,0 +1,28 @@
+jinx_name: "pti"
+description: "Enter Pardon-The-Interruption mode for human-in-the-loop reasoning."
+inputs:
+  - command_args: "" # The full command string or specific arguments for PTI mode.
+steps:
+  - name: "enter_pti"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.pti import enter_pti_mode
+      
+      command_args = context.get('command_args', '') # The full command string from router
+      output_messages = context.get('messages', [])
+      
+      try:
+          # enter_pti_mode likely expects the full command string for its own parsing
+          result = enter_pti_mode(command=command_args, **context)
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Entered PTI mode.')
+              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 entering pti mode: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/spool.jinx

@@ -0,0 +1,40 @@
+jinx_name: "spool"
+description: "Enter interactive chat (spool) mode"
+inputs: [] # Spool mode typically takes its parameters directly from the environment/kwargs
+steps:
+  - name: "enter_spool"
+    engine: "python"
+    code: |
+      import traceback
+      from npcpy.npc_compiler import NPC, Team
+      from npcsh.spool import enter_spool_mode
+      
+      output_messages = context.get('messages', [])
+      current_npc = context.get('npc')
+      current_team = context.get('team')
+
+      try:
+          # Handle potential string NPC name if passed from CLI
+          if isinstance(current_npc, str) and current_team:
+              npc_name = current_npc
+              if npc_name in current_team.npcs:
+                  current_npc = current_team.npcs[npc_name]
+              else:
+                  context['output'] = f"Error: NPC '{npc_name}' not found in team. Available NPCs: {', '.join(current_team.npcs.keys())}"
+                  context['messages'] = output_messages
+                  exit()
+          context['npc'] = current_npc # Ensure the NPC object is updated in context
+          
+          result = enter_spool_mode(**context) # Pass all context as kwargs
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Exited Spool Mode.')
+              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 entering spool mode: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/wander.jinx

@@ -0,0 +1,81 @@
+jinx_name: "wander"
+description: "Enter wander mode (experimental)"
+inputs:
+  - problem: "" # The problem to wander about.
+  - environment: "" # Optional environment for wander mode.
+  - low_temp: 0.5 # Low temperature setting for LLM.
+  - high_temp: 1.9 # High temperature setting for LLM.
+  - interruption_likelihood: 1.0 # Likelihood of interruption.
+  - sample_rate: 0.4 # Sample rate.
+  - n_high_temp_streams: 5 # Number of high temperature streams.
+  - include_events: False # Whether to include events.
+  - num_events: 3 # Number of events to include.
+steps:
+  - name: "enter_wander"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.wander import enter_wander_mode
+      
+      problem = context.get('problem')
+      environment = context.get('environment')
+      low_temp = float(context.get('low_temp', 0.5)) # Ensure float type
+      high_temp = float(context.get('high_temp', 1.9)) # Ensure float type
+      interruption_likelihood = float(context.get('interruption_likelihood', 1.0)) # Ensure float type
+      sample_rate = float(context.get('sample_rate', 0.4)) # Ensure float type
+      n_high_temp_streams = int(context.get('n_high_temp_streams', 5)) # Ensure int type
+      include_events = context.get('include_events', False) # Boolean type
+      num_events = int(context.get('num_events', 3)) # Ensure int type
+      
+      current_npc = context.get('npc')
+      llm_model = context.get('model')
+      llm_provider = context.get('provider')
+      output_messages = context.get('messages', [])
+
+      if not problem or not problem.strip():
+          context['output'] = "Usage: /wander <problem> [key=value...]"
+          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:
+          mode_args = {
+              'problem': problem,
+              'npc': current_npc,
+              'model': llm_model,
+              'provider': llm_provider,
+              'environment': environment,
+              'low_temp': low_temp,
+              'high_temp': high_temp,
+              'interruption_likelihood': interruption_likelihood,
+              'sample_rate': sample_rate,
+              'n_high_temp_streams': n_high_temp_streams,
+              'include_events': include_events,
+              'num_events': num_events
+          }
+          
+          result = enter_wander_mode(**mode_args)
+          
+          output_result = ""
+          if isinstance(result, list) and result:
+              output_result = result[-1].get("insight", "Wander mode session complete.")
+          else:
+              output_result = str(result) if result else "Wander mode session complete."
+              
+          output_messages.append({"role": "assistant", "content": output_result})
+          context['output'] = output_result
+          context['messages'] = output_messages
+          
+      except Exception as e:
+          traceback.print_exc()
+          context['output'] = f"Error during wander mode: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/modes/yap.jinx

@@ -0,0 +1,25 @@
+jinx_name: "yap"
+description: "Enter voice chat (yap) mode"
+inputs: [] # Yap mode takes its parameters directly from the environment/kwargs
+steps:
+  - name: "enter_yap"
+    engine: "python"
+    code: |
+      import traceback
+      from npcsh.yap import enter_yap_mode
+      
+      output_messages = context.get('messages', [])
+
+      try:
+          result = enter_yap_mode(**context) # Pass all context as kwargs
+          
+          if isinstance(result, dict):
+              context['output'] = result.get('output', 'Exited Yap Mode.')
+              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 entering yap mode: {e}"
+          context['messages'] = output_messages

npcsh/npc_team/jinxs/utils/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/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}`."