alita-sdk 0.3.497__py3-none-any.whl → 0.3.516__py3-none-any.whl

alita_sdk/tools/salesforce/__init__.py

@@ -5,7 +5,7 @@ from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER,get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.salesforce import SalesforceConfiguration
 
 name = "salesforce"
@@ -19,11 +19,9 @@ def get_tools(tool):
 
 class SalesforceToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         available_tools = {x['name']: x['args_schema'].schema() for x in SalesforceApiWrapper.model_construct().get_available_tools()}
-        SalesforceToolkit.toolkit_max_length = get_max_toolkit_length(available_tools)
         return create_model(
             name,
             api_version=(str, Field(description="Salesforce API Version", default='v59.0')),
@@ -31,7 +29,6 @@ class SalesforceToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(available_tools)]], Field(default=[], json_schema_extra={'args_schemas': available_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
                 "label": "Salesforce", "icon_url": "salesforce-icon.svg",
-                "max_length": SalesforceToolkit.toolkit_max_length,
                 "categories": ["other"],
                 "extra_categories": ["customer relationship management", "cloud computing", "marketing automation", "salesforce"]
                                                                   }})
@@ -48,18 +45,21 @@ class SalesforceToolkit(BaseToolkit):
             **kwargs.get('salesforce_configuration', {}),
         }
         api_wrapper = SalesforceApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
 
         for tool in api_wrapper.get_available_tools():
             if selected_tools and tool["name"] not in selected_tools:
                 continue
-
+            description = f"Salesforce Tool: {tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Salesforce Tool: {tool['description']}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
 
         return cls(tools=tools)

alita_sdk/tools/servicenow/__init__.py

@@ -7,7 +7,7 @@ from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.service_now import ServiceNowConfiguration
 
 
@@ -26,13 +26,11 @@ def get_tools(tool):
 
 class ServiceNowToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in
                           ServiceNowAPIWrapper.model_construct().get_available_tools()}
-        ServiceNowToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             name=(str, Field(description="Toolkit name")),
@@ -47,7 +45,6 @@ class ServiceNowToolkit(BaseToolkit):
                 'metadata': {
                     "label": "ServiceNow",
                     "icon_url": "service-now.svg",
-                    "max_length": ServiceNowToolkit.toolkit_max_length,
                     "hidden": False,
                     "sections": {
                         "auth": {
@@ -79,18 +76,23 @@ class ServiceNowToolkit(BaseToolkit):
             **kwargs['servicenow_configuration'],
         }
         servicenow_api_wrapper = ServiceNowAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = servicenow_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = f"ServiceNow: {servicenow_api_wrapper.base_url}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=servicenow_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"ServiceNow: {servicenow_api_wrapper.base_url} " + tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/sharepoint/__init__.py

@@ -5,7 +5,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import SharepointApiWrapper
 from ..base.tool import BaseAction
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.sharepoint import SharepointConfiguration
 
@@ -29,12 +29,10 @@ def get_tools(tool):
 
 class SharepointToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in SharepointApiWrapper.model_construct().get_available_tools()}
-        SharepointToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             sharepoint_configuration=(SharepointConfiguration, Field(description="SharePoint Configuration", json_schema_extra={'configuration_types': ['sharepoint']})),
@@ -48,7 +46,6 @@ class SharepointToolkit(BaseToolkit):
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "Sharepoint", "icon_url": "sharepoint.svg",
-                    "max_length": SharepointToolkit.toolkit_max_length,
                     "categories": ["office"],
                     "extra_categories": ["microsoft", "cloud storage", "team collaboration", "content management"]
         }})
@@ -65,18 +62,22 @@ class SharepointToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         sharepoint_api_wrapper = SharepointApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = sharepoint_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"Sharepoint {sharepoint_api_wrapper.site_url}\n{tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=sharepoint_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Sharepoint {sharepoint_api_wrapper.site_url}\n{tool['description']}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/slack/__init__.py

@@ -12,7 +12,7 @@ from pydantic import create_model, BaseModel, Field
 from ..base.tool import BaseAction
 
 from .api_wrapper import SlackApiWrapper
-from ..utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from slack_sdk.errors import SlackApiError
 from slack_sdk import WebClient
 
@@ -28,12 +28,10 @@ def get_tools(tool):
 
 class SlackToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
          selected_tools = {x['name']: x['args_schema'].schema() for x in SlackApiWrapper.model_construct().get_available_tools()}
-         SlackToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
 
          @check_connection_response
          def check_connection(self):
@@ -59,7 +57,6 @@ class SlackToolkit(BaseToolkit):
                 'metadata': {
                     "label": "Slack",
                     "icon_url": "slack-icon.svg",
-                    "max_length": SlackToolkit.toolkit_max_length,
                     "categories": ["communication"],
                     "extra_categories": ["slack", "chat", "messaging", "collaboration"],
                 }
@@ -79,17 +76,21 @@ class SlackToolkit(BaseToolkit):
             **kwargs['slack_configuration'],
         }
         slack_api_wrapper = SlackApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = slack_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = f"Slack Tool: {tool['description']}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(                
                 api_wrapper=slack_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Slack Tool: {tool['description']}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/sql/__init__.py

@@ -7,7 +7,7 @@ from .api_wrapper import SQLApiWrapper
 from ..base.tool import BaseAction
 from .models import SQLDialect
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.sql import SqlConfiguration
 
 name = "sql"
@@ -24,12 +24,10 @@ def get_tools(tool):
 
 class SQLToolkit(BaseToolkit):
     tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in SQLApiWrapper.model_construct().get_available_tools()}
-        SQLToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         supported_dialects = (d.value for d in SQLDialect)
         return create_model(
             name,
@@ -42,7 +40,6 @@ class SQLToolkit(BaseToolkit):
                                       'metadata':
                                           {
                                               "label": "SQL", "icon_url": "sql-icon.svg",
-                                              "max_length": SQLToolkit.toolkit_max_length,
                                               "categories": ["development"],
                                               "extra_categories": ["sql", "data management", "data analysis"]}})
         )
@@ -57,17 +54,21 @@ class SQLToolkit(BaseToolkit):
             **kwargs.get('sql_configuration', {}),
         }
         sql_api_wrapper = SQLApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = sql_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = f"{tool['description']}\nDatabase: {sql_api_wrapper.database_name}. Host: {sql_api_wrapper.host}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=sql_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nDatabase: {sql_api_wrapper.database_name}. Host: {sql_api_wrapper.host}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/testio/__init__.py

@@ -6,7 +6,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .api_wrapper import TestIOApiWrapper
 from ..base.tool import BaseAction
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.testio import TestIOConfiguration
 
 name = "testio"
@@ -19,8 +19,6 @@ def get_tools(tool):
     ).get_tools()
 
 
-TOOLKIT_MAX_LENGTH = 25
-
 class TestIOToolkit(BaseToolkit):
     tools: list[BaseTool] = []
     
@@ -33,7 +31,6 @@ class TestIOToolkit(BaseToolkit):
             testio_configuration=(TestIOConfiguration, Field(description="TestIO Configuration", json_schema_extra={'configuration_types': ['testio']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "TestIO", "icon_url": "testio-icon.svg",
-                                                                  "max_length": TOOLKIT_MAX_LENGTH,
                                                                   "categories": ["testing"],
                                                                   "extra_categories": ["test automation", "test case management", "test planning"]}})
         )
@@ -48,17 +45,21 @@ class TestIOToolkit(BaseToolkit):
             **kwargs.get('testio_configuration', {}),
         }
         testio_api_wrapper = TestIOApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, TOOLKIT_MAX_LENGTH) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = testio_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=testio_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/testrail/__init__.py

@@ -7,7 +7,7 @@ import requests
 from .api_wrapper import TestrailAPIWrapper
 from ..base.tool import BaseAction
 from ..elitea_base import filter_missconfigured_index_tools
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.testrail import TestRailConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
@@ -31,12 +31,10 @@ def get_tools(tool):
 
 class TestrailToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in TestrailAPIWrapper.model_construct().get_available_tools()}
-        TestrailToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             testrail_configuration=(Optional[TestRailConfiguration], Field(description="TestRail Configuration", json_schema_extra={'configuration_types': ['testrail']})),
@@ -47,7 +45,6 @@ class TestrailToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata':
                                                          {"label": "Testrail", "icon_url": "testrail-icon.svg",
-                                                          "max_length": TestrailToolkit.toolkit_max_length,
                                                           "categories": ["test management"],
                                                           "extra_categories": ["quality assurance", "test case management", "test planning"]
                                                           }})
@@ -77,18 +74,23 @@ class TestrailToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         testrail_api_wrapper = TestrailAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = testrail_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description + "\nTestrail instance: " + testrail_api_wrapper.url
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=testrail_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + "\nTestrail instance: " + testrail_api_wrapper.url,
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/utils/__init__.py

@@ -7,6 +7,8 @@ import requests
 from pydantic import create_model, Field
 
 
+# DEPRECATED: Tool names no longer use prefixes
+# Kept for backward compatibility only
 TOOLKIT_SPLITTER = "___"
 TOOL_NAME_LIMIT = 64
 
@@ -22,10 +24,13 @@ def clean_string(s: str, max_length: int = 0):
 
 
 def get_max_toolkit_length(selected_tools: Any):
-    """Calculates the maximum length of the toolkit name based on the selected tools per toolkit."""
-
-    longest_tool_name_length = max(len(tool_name) for tool_name in selected_tools.keys())
-    return TOOL_NAME_LIMIT - longest_tool_name_length - len(TOOLKIT_SPLITTER)
+    """DEPRECATED: Calculates the maximum length of the toolkit name.
+    
+    This function is deprecated as tool names no longer use prefixes.
+    Returns a fixed value for backward compatibility.
+    """
+    # Return a reasonable default since we no longer use prefixes
+    return 50
 
 
 def parse_list(list_str: str = None) -> List[str]:

alita_sdk/tools/utils/text_operations.py

@@ -0,0 +1,254 @@
+"""
+Shared text operations utilities for file manipulation across toolkits.
+
+Provides common functionality for:
+- Parsing OLD/NEW marker-based edits
+- Text file validation
+- Line-based slicing and partial reads
+- Content searching with context
+"""
+import re
+import logging
+from typing import List, Tuple, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+# Text file extensions that support editing
+TEXT_EDITABLE_EXTENSIONS = {
+    '.md', '.txt', '.csv', '.json', '.xml', '.html', 
+    '.yaml', '.yml', '.ini', '.conf', '.log', '.sh',
+    '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go',
+    '.rb', '.php', '.c', '.cpp', '.h', '.hpp', '.cs',
+    '.sql', '.r', '.m', '.swift', '.kt', '.rs', '.scala'
+}
+
+
+def parse_old_new_markers(file_query: str) -> List[Tuple[str, str]]:
+    """
+    Parse OLD/NEW marker-based edit instructions.
+    
+    Extracts pairs of old and new content from a file query using markers:
+    - OLD <<<< ... >>>> OLD
+    - NEW <<<< ... >>>> NEW
+    
+    Args:
+        file_query: String containing marked old and new content sections
+        
+    Returns:
+        List of tuples (old_content, new_content) for each edit pair
+        
+    Example:
+        >>> query = '''
+        ... OLD <<<<
+        ... Hello World
+        ... >>>> OLD
+        ... NEW <<<<
+        ... Hello Mars
+        ... >>>> NEW
+        ... '''
+        >>> parse_old_new_markers(query)
+        [('Hello World', 'Hello Mars')]
+    """
+    # Split the file content by lines
+    code_lines = file_query.split("\n")
+
+    # Initialize lists to hold the contents of OLD and NEW sections
+    old_contents = []
+    new_contents = []
+
+    # Initialize variables to track whether the current line is within an OLD or NEW section
+    in_old_section = False
+    in_new_section = False
+
+    # Temporary storage for the current section's content
+    current_section_content = []
+
+    # Iterate through each line in the file content
+    for line in code_lines:
+        # Check for OLD section start
+        if "OLD <<<" in line:
+            in_old_section = True
+            current_section_content = []  # Reset current section content
+            continue  # Skip the line with the marker
+
+        # Check for OLD section end
+        if ">>>> OLD" in line:
+            in_old_section = False
+            old_contents.append("\n".join(current_section_content).strip())  # Add the captured content
+            current_section_content = []  # Reset current section content
+            continue  # Skip the line with the marker
+
+        # Check for NEW section start
+        if "NEW <<<" in line:
+            in_new_section = True
+            current_section_content = []  # Reset current section content
+            continue  # Skip the line with the marker
+
+        # Check for NEW section end
+        if ">>>> NEW" in line:
+            in_new_section = False
+            new_contents.append("\n".join(current_section_content).strip())  # Add the captured content
+            current_section_content = []  # Reset current section content
+            continue  # Skip the line with the marker
+
+        # If currently in an OLD or NEW section, add the line to the current section content
+        if in_old_section or in_new_section:
+            current_section_content.append(line)
+
+    # Pair the OLD and NEW contents
+    paired_contents = list(zip(old_contents, new_contents))
+
+    return paired_contents
+
+
+def is_text_editable(filename: str) -> bool:
+    """
+    Check if a file is editable as text based on its extension.
+    
+    Args:
+        filename: Name or path of the file to check
+        
+    Returns:
+        True if file extension is in the text-editable whitelist
+        
+    Example:
+        >>> is_text_editable("config.json")
+        True
+        >>> is_text_editable("image.png")
+        False
+    """
+    from pathlib import Path
+    ext = Path(filename).suffix.lower()
+    return ext in TEXT_EDITABLE_EXTENSIONS
+
+
+def apply_line_slice(
+    content: str, 
+    offset: Optional[int] = None,
+    limit: Optional[int] = None,
+    head: Optional[int] = None,
+    tail: Optional[int] = None
+) -> str:
+    """
+    Apply line-based slicing to text content.
+    
+    Supports multiple modes:
+    - offset + limit: Read from line `offset` for `limit` lines (1-indexed)
+    - head: Read only first N lines
+    - tail: Read only last N lines
+    - No params: Return full content
+    
+    Args:
+        content: Text content to slice
+        offset: Starting line number (1-indexed, inclusive)
+        limit: Number of lines to read from offset
+        head: Return only first N lines
+        tail: Return only last N lines
+        
+    Returns:
+        Sliced content as string
+        
+    Example:
+        >>> text = "line1\\nline2\\nline3\\nline4\\nline5"
+        >>> apply_line_slice(text, offset=2, limit=2)
+        'line2\\nline3'
+        >>> apply_line_slice(text, head=2)
+        'line1\\nline2'
+        >>> apply_line_slice(text, tail=2)
+        'line4\\nline5'
+    """
+    if not content:
+        return content
+        
+    lines = content.splitlines(keepends=True)
+    
+    # Head mode: first N lines
+    if head is not None:
+        return ''.join(lines[:head])
+    
+    # Tail mode: last N lines
+    if tail is not None:
+        return ''.join(lines[-tail:] if tail > 0 else lines)
+    
+    # Offset + limit mode: slice from offset for limit lines
+    if offset is not None:
+        start_idx = max(0, offset - 1)  # Convert 1-indexed to 0-indexed
+        if limit is not None:
+            end_idx = start_idx + limit
+            return ''.join(lines[start_idx:end_idx])
+        else:
+            return ''.join(lines[start_idx:])
+    
+    # No slicing parameters: return full content
+    return content
+
+
+def search_in_content(
+    content: str,
+    pattern: str,
+    is_regex: bool = True,
+    context_lines: int = 2
+) -> List[Dict[str, any]]:
+    """
+    Search for pattern in content with context lines.
+    
+    Args:
+        content: Text content to search
+        pattern: Search pattern (regex if is_regex=True, else literal string)
+        is_regex: Whether to treat pattern as regex (default True)
+        context_lines: Number of lines before/after match to include (default 2)
+        
+    Returns:
+        List of match dictionaries with keys:
+            - line_number: 1-indexed line number of match
+            - line_content: The matching line
+            - match_text: The actual matched text
+            - context_before: List of lines before match
+            - context_after: List of lines after match
+            
+    Example:
+        >>> text = "line1\\nHello World\\nline3"
+        >>> matches = search_in_content(text, "Hello", is_regex=False)
+        >>> matches[0]['line_number']
+        2
+        >>> matches[0]['match_text']
+        'Hello'
+    """
+    if not content:
+        return []
+    
+    lines = content.splitlines()
+    matches = []
+    
+    # Compile regex pattern or escape for literal search
+    if is_regex:
+        try:
+            regex = re.compile(pattern, re.IGNORECASE)
+        except re.error as e:
+            logger.warning(f"Invalid regex pattern '{pattern}': {e}")
+            return []
+    else:
+        regex = re.compile(re.escape(pattern), re.IGNORECASE)
+    
+    # Search each line
+    for line_idx, line in enumerate(lines):
+        match = regex.search(line)
+        if match:
+            line_number = line_idx + 1  # Convert to 1-indexed
+            
+            # Get context lines
+            context_start = max(0, line_idx - context_lines)
+            context_end = min(len(lines), line_idx + context_lines + 1)
+            
+            context_before = lines[context_start:line_idx]
+            context_after = lines[line_idx + 1:context_end]
+            
+            matches.append({
+                'line_number': line_number,
+                'line_content': line,
+                'match_text': match.group(0),
+                'context_before': context_before,
+                'context_after': context_after,
+            })
+    
+    return matches