holmesgpt 0.12.3__py3-none-any.whl → 0.12.4__py3-none-any.whl

holmes/core/tools.py

@@ -155,8 +155,9 @@ class Tool(ABC, BaseModel):
             else str(result)
         )
         show_hint = f"/show {tool_number}" if tool_number else "/show"
+        line_count = output_str.count("\n") + 1 if output_str else 0
         logging.info(
-            f"  [dim]Finished {tool_number_str}in {elapsed:.2f}s, output length: {len(output_str):,} characters - {show_hint} to view contents[/dim]"
+            f"  [dim]Finished {tool_number_str}in {elapsed:.2f}s, output length: {len(output_str):,} characters ({line_count:,} lines) - {show_hint} to view contents[/dim]"
         )
         return result
 

holmes/core/tools_utils/tool_executor.py

@@ -15,6 +15,7 @@ from holmes.core.tools_utils.toolset_utils import filter_out_default_logging_too
 
 class ToolExecutor:
     def __init__(self, toolsets: List[Toolset]):
+        # TODO: expose function for this instead of callers accessing directly
         self.toolsets = toolsets
 
         enabled_toolsets: list[Toolset] = list(

holmes/core/toolset_manager.py

@@ -7,12 +7,13 @@ from typing import Any, List, Optional
 from benedict import benedict
 from pydantic import FilePath
 
+from holmes.core.config import config_path_dir
 from holmes.core.supabase_dal import SupabaseDal
 from holmes.core.tools import Toolset, ToolsetStatusEnum, ToolsetTag, ToolsetType
 from holmes.plugins.toolsets import load_builtin_toolsets, load_toolsets_from_config
 from holmes.utils.definitions import CUSTOM_TOOLSET_LOCATION
 
-DEFAULT_TOOLSET_STATUS_LOCATION = os.path.expanduser("~/.holmes/toolsets_status.json")
+DEFAULT_TOOLSET_STATUS_LOCATION = os.path.join(config_path_dir, "toolsets_status.json")
 
 
 class ToolsetManager:
@@ -25,11 +26,17 @@ class ToolsetManager:
     def __init__(
         self,
         toolsets: Optional[dict[str, dict[str, Any]]] = None,
+        mcp_servers: Optional[dict[str, dict[str, Any]]] = None,
         custom_toolsets: Optional[List[FilePath]] = None,
         custom_toolsets_from_cli: Optional[List[FilePath]] = None,
         toolset_status_location: Optional[FilePath] = None,
     ):
         self.toolsets = toolsets
+        self.toolsets = toolsets or {}
+        if mcp_servers is not None:
+            for _, mcp_server in mcp_servers.items():
+                mcp_server["type"] = ToolsetType.MCP.value
+        self.toolsets.update(mcp_servers or {})
         self.custom_toolsets = custom_toolsets
 
         if toolset_status_location is None:
@@ -254,7 +261,7 @@ class ToolsetManager:
                 toolset.error = cached_status.get("error", None)
                 toolset.enabled = cached_status.get("enabled", True)
                 toolset.type = ToolsetType(
-                    cached_status.get("type", ToolsetType.BUILTIN)
+                    cached_status.get("type", ToolsetType.BUILTIN.value)
                 )
                 toolset.path = cached_status.get("path", None)
             # check prerequisites for only enabled toolset when the toolset is loaded from cache. When the toolset is
@@ -354,7 +361,7 @@ class ToolsetManager:
             mcp_config: dict[str, dict[str, Any]] = parsed_yaml.get("mcp_servers", {})
 
             for server_config in mcp_config.values():
-                server_config["type"] = ToolsetType.MCP
+                server_config["type"] = ToolsetType.MCP.value
 
             for toolset_config in toolsets_config.values():
                 toolset_config["path"] = toolset_path

holmes/core/tracing.py

@@ -1,12 +1,24 @@
 import os
 import logging
-from typing import Optional, Any, Union
+import platform
+import pwd
+import socket
+from datetime import datetime
+from typing import Optional, Any, Union, Dict
+from pathlib import Path
 from enum import Enum
 
+BRAINTRUST_API_KEY = os.environ.get("BRAINTRUST_API_KEY")
+BRAINTRUST_ORG = os.environ.get("BRAINTRUST_ORG", "robustadev")
+BRAINTRUST_PROJECT = os.environ.get(
+    "BRAINTRUST_PROJECT", "HolmesGPT"
+)  # only for evals - for CLI it's set differently
+
 try:
     import braintrust
     from braintrust import Span, SpanTypeAttribute
 
+    logging.info("Braintrust package imported successfully")
     BRAINTRUST_AVAILABLE = True
 except ImportError:
     BRAINTRUST_AVAILABLE = False
@@ -20,6 +32,56 @@ except ImportError:
         SpanTypeAttribute = Any
 
 
+session_timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def readable_timestamp():
+    return session_timestamp
+
+
+def get_active_branch_name():
+    try:
+        # First check if .git is a file (worktree case)
+        git_path = Path(".git")
+        if git_path.is_file():
+            # Read the worktree git directory path
+            with git_path.open("r") as f:
+                content = f.read().strip()
+                if content.startswith("gitdir:"):
+                    worktree_git_dir = Path(content.split("gitdir:", 1)[1].strip())
+                    head_file = worktree_git_dir / "HEAD"
+                else:
+                    return "Unknown"
+        else:
+            # Regular .git directory
+            head_file = git_path / "HEAD"
+
+        with head_file.open("r") as f:
+            content = f.read().splitlines()
+            for line in content:
+                if line[0:4] == "ref:":
+                    return line.partition("refs/heads/")[2]
+    except Exception:
+        pass
+
+    return "Unknown"
+
+
+def get_machine_state_tags() -> Dict[str, str]:
+    return {
+        "username": pwd.getpwuid(os.getuid()).pw_name,
+        "branch": get_active_branch_name(),
+        "platform": platform.platform(),
+        "hostname": socket.gethostname(),
+    }
+
+
+def get_experiment_name():
+    if os.environ.get("EXPERIMENT_ID"):
+        return os.environ.get("EXPERIMENT_ID")
+    return readable_timestamp()  # should never happen in evals (we set EXPERIMENT_ID in conftest.py), but can happen with holmesgpt cli
+
+
 def _is_noop_span(span) -> bool:
     """Check if a span is a Braintrust NoopSpan (inactive span)."""
     return span is None or str(type(span)).endswith("_NoopSpan'>")
@@ -76,14 +138,16 @@ class DummyTracer:
 class BraintrustTracer:
     """Braintrust implementation of tracing."""
 
-    def __init__(self, project: str = "HolmesGPT-CLI"):
+    def __init__(self, project: str):
         if not BRAINTRUST_AVAILABLE:
             raise ImportError("braintrust package is required for BraintrustTracer")
 
         self.project = project
 
     def start_experiment(
-        self, experiment_name: Optional[str] = None, metadata: Optional[dict] = None
+        self,
+        experiment_name: Optional[str] = None,
+        additional_metadata: Optional[dict] = None,
     ):
         """Create and start a new Braintrust experiment.
 
@@ -97,10 +161,17 @@ class BraintrustTracer:
         if not os.environ.get("BRAINTRUST_API_KEY"):
             return None
 
+        if experiment_name is None:
+            experiment_name = get_experiment_name()
+
+        metadata = get_machine_state_tags()
+        if additional_metadata is not None:
+            metadata.update(additional_metadata)
+
         return braintrust.init(
             project=self.project,
             experiment=experiment_name,
-            metadata=metadata or {},
+            metadata=metadata,
             update=True,
         )
 
@@ -143,7 +214,6 @@ class BraintrustTracer:
             logging.warning("BRAINTRUST_API_KEY not set, cannot get trace URL")
             return None
 
-        # Get current experiment from Braintrust context
         current_experiment = braintrust.current_experiment()
         if not current_experiment:
             logging.warning("No current experiment found in Braintrust context")
@@ -156,10 +226,7 @@ class BraintrustTracer:
 
         current_span = braintrust.current_span()
         if not _is_noop_span(current_span):
-            span_id = getattr(current_span, "span_id", None)
-            id_attr = getattr(current_span, "id", None)
-            if span_id and id_attr:
-                return f"https://www.braintrust.dev/app/robustadev/p/{self.project}/experiments/{experiment_name}?c=&tg=false&r={id_attr}&s={span_id}"
+            current_span.link()
         else:
             logging.warning("No active span found in Braintrust context")
 
@@ -193,7 +260,7 @@ class TracingFactory:
     """Factory for creating tracer instances."""
 
     @staticmethod
-    def create_tracer(trace_type: Optional[str], project: str):
+    def create_tracer(trace_type: Optional[str], project: str = BRAINTRUST_PROJECT):
         """Create a tracer instance based on the trace type.
 
         Args:

holmes/interactive.py

@@ -19,17 +19,29 @@ from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.layout import Layout
 from prompt_toolkit.layout.containers import HSplit, Window
 from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.shortcuts.prompt import CompleteStyle
 from prompt_toolkit.styles import Style
 from prompt_toolkit.widgets import TextArea
+from pygments.lexers import guess_lexer
 from rich.console import Console
 from rich.markdown import Markdown, Panel
 
+from holmes.core.config import config_path_dir
 from holmes.core.prompt import build_initial_ask_messages
 from holmes.core.tool_calling_llm import ToolCallingLLM, ToolCallResult
 from holmes.core.tools import pretty_print_toolset_status
-from holmes.version import check_version_async
 from holmes.core.tracing import DummyTracer
+from holmes.utils.colors import (
+    AI_COLOR,
+    ERROR_COLOR,
+    HELP_COLOR,
+    STATUS_COLOR,
+    TOOLS_COLOR,
+    USER_COLOR,
+)
+from holmes.utils.console.consts import agent_name
+from holmes.version import check_version_async
 
 
 class SlashCommands(Enum):
@@ -139,14 +151,49 @@ class ConditionalExecutableCompleter(Completer):
                         )
 
 
-USER_COLOR = "#DEFCC0"  # light green
-AI_COLOR = "#00FFFF"  # cyan
-TOOLS_COLOR = "magenta"
-HELP_COLOR = "cyan"  # same as AI_COLOR for now
-ERROR_COLOR = "red"
-STATUS_COLOR = "yellow"
+class ShowCommandCompleter(Completer):
+    """Completer that provides suggestions for /show command based on tool call history"""
+
+    def __init__(self):
+        self.tool_calls_history = []
 
-WELCOME_BANNER = f"[bold {HELP_COLOR}]Welcome to HolmesGPT:[/bold {HELP_COLOR}] Type '{SlashCommands.EXIT.command}' to exit, '{SlashCommands.HELP.command}' for commands."
+    def update_history(self, tool_calls_history: List[ToolCallResult]):
+        """Update the tool calls history for completion suggestions"""
+        self.tool_calls_history = tool_calls_history
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+
+        # Only provide completion if the line starts with /show
+        if text.startswith("/show "):
+            # Extract the argument part after "/show "
+            show_part = text[6:]  # Remove "/show "
+
+            # Don't complete if there are already multiple words
+            words = show_part.split()
+            if len(words) > 1:
+                return
+
+            # Provide completions based on available tool calls
+            if self.tool_calls_history:
+                for i, tool_call in enumerate(self.tool_calls_history):
+                    tool_index = str(i + 1)  # 1-based index
+                    tool_description = tool_call.description
+
+                    # Complete tool index numbers (show all if empty, or filter by what user typed)
+                    if (
+                        not show_part
+                        or tool_index.startswith(show_part)
+                        or show_part.lower() in tool_description.lower()
+                    ):
+                        yield Completion(
+                            tool_index,
+                            start_position=-len(show_part),
+                            display=f"{tool_index} - {tool_description}",
+                        )
+
+
+WELCOME_BANNER = f"[bold {HELP_COLOR}]Welcome to {agent_name}:[/bold {HELP_COLOR}] Type '{SlashCommands.EXIT.command}' to exit, '{SlashCommands.HELP.command}' for commands."
 
 
 def format_tool_call_output(
@@ -185,6 +232,28 @@ def build_modal_title(tool_call: ToolCallResult, wrap_status: str) -> str:
     return f"{tool_call.description} (exit: q, nav: ↑↓/j/k/g/G/d/u/f/b/space, wrap: w [{wrap_status}])"
 
 
+def detect_lexer(content: str) -> Optional[PygmentsLexer]:
+    """
+    Detect appropriate lexer for content using Pygments' built-in detection.
+
+    Args:
+        content: String content to analyze
+
+    Returns:
+        PygmentsLexer instance if content type is detected, None otherwise
+    """
+    if not content.strip():
+        return None
+
+    try:
+        # Use Pygments' built-in lexer guessing
+        lexer = guess_lexer(content)
+        return PygmentsLexer(lexer.__class__)
+    except Exception:
+        # If detection fails, return None for no syntax highlighting
+        return None
+
+
 def handle_show_command(
     show_arg: str, all_tool_calls_history: List[ToolCallResult], console: Console
 ) -> None:
@@ -246,6 +315,9 @@ def show_tool_output_modal(tool_call: ToolCallResult, console: Console) -> None:
         output = tool_call.result.get_stringified_data()
         title = build_modal_title(tool_call, "off")  # Word wrap starts disabled
 
+        # Detect appropriate syntax highlighting
+        lexer = detect_lexer(output)
+
         # Create text area with the output
         text_area = TextArea(
             text=output,
@@ -253,6 +325,7 @@ def show_tool_output_modal(tool_call: ToolCallResult, console: Console) -> None:
             scrollbar=True,
             line_numbers=False,
             wrap_lines=False,  # Disable word wrap by default
+            lexer=lexer,
         )
 
         # Create header
@@ -275,15 +348,18 @@ def show_tool_output_modal(tool_call: ToolCallResult, console: Console) -> None:
         # Create key bindings
         bindings = KeyBindings()
 
-        # Exit commands
+        # Track exit state to prevent double exits
+        exited = False
+
+        # Exit commands (q, escape, or ctrl+c to exit)
         @bindings.add("q")
         @bindings.add("escape")
-        def _(event):
-            event.app.exit()
-
         @bindings.add("c-c")
         def _(event):
-            event.app.exit()
+            nonlocal exited
+            if not exited:
+                exited = True
+                event.app.exit()
 
         # Vim/less-like navigation
         @bindings.add("j")
@@ -596,7 +672,7 @@ def handle_shell_command(
         Formatted user input string if user chooses to share, None otherwise
     """
     console.print(
-        f"[bold {STATUS_COLOR}]Starting interactive shell. Type 'exit' to return to HolmesGPT.[/bold {STATUS_COLOR}]"
+        f"[bold {STATUS_COLOR}]Starting interactive shell. Type 'exit' to return to {agent_name}.[/bold {STATUS_COLOR}]"
     )
     console.print(
         "[dim]Shell session will be recorded and can be shared with LLM when you exit.[/dim]"
@@ -714,12 +790,14 @@ def display_recent_tool_outputs(
 def run_interactive_loop(
     ai: ToolCallingLLM,
     console: Console,
-    system_prompt_rendered: str,
     initial_user_input: Optional[str],
     include_files: Optional[List[Path]],
     post_processing_prompt: Optional[str],
     show_tool_output: bool,
     tracer=None,
+    runbooks=None,
+    system_prompt_additions: Optional[str] = None,
+    check_version: bool = True,
 ) -> None:
     # Initialize tracer - use DummyTracer if no tracer provided
     if tracer is None:
@@ -733,17 +811,19 @@ def run_interactive_loop(
         }
     )
 
-    # Create merged completer with slash commands, conditional executables, and smart paths
+    # Create merged completer with slash commands, conditional executables, show command, and smart paths
     slash_completer = SlashCommandCompleter()
     executable_completer = ConditionalExecutableCompleter()
+    show_completer = ShowCommandCompleter()
     path_completer = SmartPathCompleter()
 
     command_completer = merge_completers(
-        [slash_completer, executable_completer, path_completer]
+        [slash_completer, executable_completer, show_completer, path_completer]
     )
 
     # Use file-based history
-    history_file = os.path.expanduser("~/.holmes/history")
+    history_file = os.path.join(config_path_dir, "history")
+
     os.makedirs(os.path.dirname(history_file), exist_ok=True)
     history = FileHistory(history_file)
     if initial_user_input:
@@ -816,7 +896,8 @@ def run_interactive_loop(
     )  # type: ignore
 
     # Start background version check
-    check_version_async(on_version_check_complete)
+    if check_version:
+        check_version_async(on_version_check_complete)
 
     input_prompt = [("class:prompt", "User: ")]
 
@@ -870,6 +951,8 @@ def run_interactive_loop(
                     messages = None
                     last_response = None
                     all_tool_calls_history.clear()
+                    # Reset the show completer history
+                    show_completer.update_history([])
                     continue
                 elif command == SlashCommands.TOOLS_CONFIG.command:
                     pretty_print_toolset_status(ai.tool_executor.toolsets, console)
@@ -915,7 +998,12 @@ def run_interactive_loop(
 
             if messages is None:
                 messages = build_initial_ask_messages(
-                    console, system_prompt_rendered, user_input, include_files
+                    console,
+                    user_input,
+                    include_files,
+                    ai.tool_executor,
+                    runbooks,
+                    system_prompt_additions,
                 )
             else:
                 messages.append({"role": "user", "content": user_input})
@@ -944,6 +1032,8 @@ def run_interactive_loop(
 
             if response.tool_calls:
                 all_tool_calls_history.extend(response.tool_calls)
+                # Update the show completer with the latest tool call history
+                show_completer.update_history(all_tool_calls_history)
 
             if show_tool_output and response.tool_calls:
                 display_recent_tool_outputs(

holmes/main.py

@@ -3,6 +3,7 @@ import os
 import sys
 
 from holmes.utils.cert_utils import add_custom_certificate
+from holmes.utils.colors import USER_COLOR
 
 ADDITIONAL_CERTIFICATE: str = os.environ.get("CERTIFICATE", "")
 if add_custom_certificate(ADDITIONAL_CERTIFICATE):
@@ -16,7 +17,6 @@ import json
 import logging
 import socket
 import uuid
-from datetime import datetime
 from pathlib import Path
 from typing import List, Optional
 
@@ -180,10 +180,6 @@ def ask(
     destination: Optional[DestinationType] = opt_destination,
     slack_token: Optional[str] = opt_slack_token,
     slack_channel: Optional[str] = opt_slack_channel,
-    # advanced options for this command
-    system_prompt: Optional[str] = typer.Option(
-        "builtin://generic_ask.jinja2", help=system_prompt_help
-    ),
     show_tool_output: bool = typer.Option(
         False,
         "--show-tool-output",
@@ -214,6 +210,11 @@ def ask(
         "--trace",
         help="Enable tracing to the specified provider (e.g., 'braintrust')",
     ),
+    system_prompt_additions: Optional[str] = typer.Option(
+        None,
+        "--system-prompt-additions",
+        help="Additional content to append to the system prompt",
+    ),
 ):
     """
     Ask any question and answer using available tools
@@ -245,22 +246,13 @@ def ask(
 
     # Create tracer if trace option is provided
     tracer = TracingFactory.create_tracer(trace, project="HolmesGPT-CLI")
-    experiment_name = f"holmes-ask-{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-    tracer.start_experiment(
-        experiment_name=experiment_name, metadata={"prompt": prompt or "holmes-ask"}
-    )
+    tracer.start_experiment()
 
     ai = config.create_console_toolcalling_llm(
         dal=None,  # type: ignore
         refresh_toolsets=refresh_toolsets,  # flag to refresh the toolset status
         tracer=tracer,
     )
-    template_context = {
-        "toolsets": ai.tool_executor.toolsets,
-        "runbooks": config.get_runbook_catalog(),
-    }
-
-    system_prompt_rendered = load_and_render_prompt(system_prompt, template_context)  # type: ignore
 
     if prompt_file and prompt:
         raise typer.BadParameter(
@@ -289,26 +281,29 @@ def ask(
             prompt = f"Here's some piped output:\n\n{piped_data}\n\nWhat can you tell me about this output?"
 
     if echo_request and not interactive and prompt:
-        console.print("[bold yellow]User:[/bold yellow] " + prompt)
+        console.print(f"[bold {USER_COLOR}]User:[/bold {USER_COLOR}] {prompt}")
 
     if interactive:
         run_interactive_loop(
             ai,
             console,
-            system_prompt_rendered,
             prompt,
             include_file,
             post_processing_prompt,
             show_tool_output,
             tracer,
+            config.get_runbook_catalog(),
+            system_prompt_additions,
         )
         return
 
     messages = build_initial_ask_messages(
         console,
-        system_prompt_rendered,
         prompt,  # type: ignore
         include_file,
+        ai.tool_executor,
+        config.get_runbook_catalog(),
+        system_prompt_additions,
     )
 
     with tracer.start_trace(

holmes/plugins/destinations/slack/plugin.py

@@ -85,10 +85,13 @@ class SlackDestination(DestinationPlugin):
         text = "*AI used info from alert and the following tools:*"
         for tool in result.tool_calls:
             file_response = self.client.files_upload_v2(
-                content=tool.result, title=f"{tool.description}"
+                content=tool.result.get_stringified_data(), title=f"{tool.description}"
             )
-            permalink = file_response["file"]["permalink"]
-            text += f"\n• `<{permalink}|{tool.description}>`"
+            if file_response and "file" in file_response:
+                permalink = file_response["file"]["permalink"]
+                text += f"\n• `<{permalink}|{tool.description}>`"
+            else:
+                text += f"\n• {tool.description} (file upload failed)"
 
         self.client.chat_postMessage(
             channel=self.channel,
@@ -108,10 +111,13 @@ class SlackDestination(DestinationPlugin):
 
         text = "*🐞 DEBUG: messages with OpenAI*"
         file_response = self.client.files_upload_v2(
-            content=result.prompt, title="ai-prompt"
+            content=str(result.prompt) if result.prompt else "", title="ai-prompt"
         )
-        permalink = file_response["file"]["permalink"]
-        text += f"\n`<{permalink}|ai-prompt>`"
+        if file_response and "file" in file_response:
+            permalink = file_response["file"]["permalink"]
+            text += f"\n`<{permalink}|ai-prompt>`"
+        else:
+            text += "\nai-prompt (file upload failed)"
 
         self.client.chat_postMessage(
             channel=self.channel,
@@ -132,9 +138,13 @@ class SlackDestination(DestinationPlugin):
         filename = f"{issue.name}"
         issue_json = issue.model_dump_json()
         file_response = self.client.files_upload_v2(content=issue_json, title=filename)
-        permalink = file_response["file"]["permalink"]
-        text = issue.presentation_all_metadata
-        text += f"\n<{permalink}|{filename}>\n"
+        if file_response and "file" in file_response:
+            permalink = file_response["file"]["permalink"]
+            text = issue.presentation_all_metadata
+            text += f"\n<{permalink}|{filename}>\n"
+        else:
+            text = issue.presentation_all_metadata
+            text += f"\n{filename} (file upload failed)\n"
 
         self.client.chat_postMessage(
             channel=self.channel,

holmes/plugins/prompts/_fetch_logs.jinja2

@@ -5,7 +5,7 @@
 {%- set opensearch_ts = toolsets | selectattr("name", "equalto", "opensearch/logs") | first -%}
 {%- set datadog_ts = toolsets | selectattr("name", "equalto", "datadog/logs") | first -%}
 
-# Logs
+## Logs
 {% if loki_ts and loki_ts.status == "enabled" -%}
 * For any logs, including for investigating kubernetes problems, use Loki
 * Use the tool fetch_loki_logs_for_resource to get the logs of any kubernetes pod or node
@@ -17,12 +17,22 @@
 ** If there are too many logs, or not enough, narrow or widen the timestamps
 * If you are not provided with time information. Ignore start_timestamp and end_timestamp. Loki will default to the latest logs.
 {%- elif coralogix_ts and coralogix_ts.status == "enabled" -%}
+### coralogix/logs
+#### Coralogix Logs Toolset
+Tools to search and fetch logs from Coralogix.
 {% include '_default_log_prompt.jinja2' %}
 {%- elif k8s_base_ts and k8s_base_ts.status == "enabled" -%}
 {% include '_default_log_prompt.jinja2' %}
 {%- elif datadog_ts and datadog_ts.status == "enabled" -%}
+* If you are not sure what is the pod namespace, search for the logs only by pod name.
+### datadog/logs
+#### Datadog Logs Toolset
+Tools to search and fetch logs from Datadog.
 {% include '_default_log_prompt.jinja2' %}
 {%- elif k8s_yaml_ts and k8s_yaml_ts.status == "enabled" -%}
+### kubernetes/logs
+#### Kubernetes Logs Toolset
+Tools to search and fetch logs from Kubernetes.
 * if the user wants to find a specific term in a pod's logs, use kubectl_logs_grep
 * use both kubectl_previous_logs and kubectl_logs when reading logs. Treat the output of both as a single unified logs stream
 * if a pod has multiple containers, make sure you fetch the logs for either all or relevant containers using one of the containers log functions like kubectl_logs_all_containers, kubectl_logs_all_containers_grep or any other.