emdash-core 0.1.33__py3-none-any.whl → 0.1.60__py3-none-any.whl

emdash_core/agent/tools/lsp.py

@@ -0,0 +1,361 @@
+"""LSP-based code navigation tools using cclsp MCP server.
+
+These tools provide IDE-level code intelligence using the Language Server Protocol
+via the cclsp MCP server. They offer real-time, accurate code navigation without
+requiring pre-indexing.
+
+Enable with USE_LSP=true (disabled by default).
+"""
+
+import os
+from typing import Optional
+
+from .base import BaseTool, ToolResult, ToolCategory
+from ...utils.logger import log
+
+
+def is_lsp_enabled() -> bool:
+    """Check if LSP tools should be used.
+
+    Returns:
+        True if USE_LSP is explicitly set to 'true' (disabled by default)
+    """
+    return os.getenv("USE_LSP", "false").lower() == "true"
+
+
+class LSPFindDefinitionTool(BaseTool):
+    """Find the definition of a symbol using LSP."""
+
+    name = "find_definition"
+    description = """Find where a symbol (function, class, variable) is defined.
+Uses Language Server Protocol for accurate, real-time results.
+Returns the file path and location of the definition."""
+    category = ToolCategory.TRAVERSAL
+
+    def __init__(self, mcp_manager, connection=None):
+        """Initialize the LSP tool.
+
+        Args:
+            mcp_manager: MCP server manager for calling cclsp
+            connection: Optional Kuzu connection (for compatibility)
+        """
+        super().__init__(connection)
+        self._mcp_manager = mcp_manager
+
+    def execute(
+        self,
+        file_path: str,
+        symbol_name: str,
+        symbol_kind: str = "function",
+    ) -> ToolResult:
+        """Find the definition of a symbol.
+
+        Args:
+            file_path: Path to the file containing the symbol reference
+            symbol_name: Name of the symbol to find definition for
+            symbol_kind: Kind of symbol (function, class, variable, method)
+
+        Returns:
+            ToolResult with definition location
+        """
+        try:
+            response = self._mcp_manager.call_tool("find_definition", {
+                "file": file_path,
+                "name": symbol_name,
+                "kind": symbol_kind,
+            })
+
+            if not response.content:
+                return ToolResult.error_result(
+                    f"No definition found for '{symbol_name}'",
+                    suggestions=["Check the symbol name spelling", "Try a different symbol_kind"],
+                )
+
+            # Parse response content
+            content = response.content[0] if response.content else {}
+            text = content.get("text", "") if isinstance(content, dict) else str(content)
+
+            return ToolResult.success_result(
+                data={
+                    "symbol": symbol_name,
+                    "kind": symbol_kind,
+                    "definition": text,
+                },
+            )
+
+        except Exception as e:
+            log.exception("LSP find_definition failed")
+            return ToolResult.error_result(f"Failed to find definition: {str(e)}")
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file containing the symbol reference",
+                },
+                "symbol_name": {
+                    "type": "string",
+                    "description": "Name of the symbol to find definition for",
+                },
+                "symbol_kind": {
+                    "type": "string",
+                    "enum": ["function", "class", "variable", "method", "interface", "type"],
+                    "description": "Kind of symbol",
+                    "default": "function",
+                },
+            },
+            required=["file_path", "symbol_name"],
+        )
+
+
+class LSPFindReferencesTool(BaseTool):
+    """Find all references to a symbol using LSP."""
+
+    name = "find_references"
+    description = """Find all usages/references of a symbol across the codebase.
+Uses Language Server Protocol for accurate, real-time results.
+Similar to 'Find All References' in an IDE."""
+    category = ToolCategory.TRAVERSAL
+
+    def __init__(self, mcp_manager, connection=None):
+        """Initialize the LSP tool.
+
+        Args:
+            mcp_manager: MCP server manager for calling cclsp
+            connection: Optional Kuzu connection (for compatibility)
+        """
+        super().__init__(connection)
+        self._mcp_manager = mcp_manager
+
+    def execute(
+        self,
+        file_path: str,
+        symbol_name: str,
+        symbol_kind: str = "function",
+        include_declaration: bool = True,
+    ) -> ToolResult:
+        """Find all references to a symbol.
+
+        Args:
+            file_path: Path to the file containing the symbol
+            symbol_name: Name of the symbol to find references for
+            symbol_kind: Kind of symbol (function, class, variable, method)
+            include_declaration: Whether to include the declaration itself
+
+        Returns:
+            ToolResult with list of references
+        """
+        try:
+            response = self._mcp_manager.call_tool("find_references", {
+                "file": file_path,
+                "name": symbol_name,
+                "kind": symbol_kind,
+                "includeDeclaration": include_declaration,
+            })
+
+            if not response.content:
+                return ToolResult.error_result(
+                    f"No references found for '{symbol_name}'",
+                    suggestions=["Check the symbol name spelling", "The symbol may not be used anywhere"],
+                )
+
+            content = response.content[0] if response.content else {}
+            text = content.get("text", "") if isinstance(content, dict) else str(content)
+
+            return ToolResult.success_result(
+                data={
+                    "symbol": symbol_name,
+                    "kind": symbol_kind,
+                    "references": text,
+                },
+            )
+
+        except Exception as e:
+            log.exception("LSP find_references failed")
+            return ToolResult.error_result(f"Failed to find references: {str(e)}")
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file containing the symbol",
+                },
+                "symbol_name": {
+                    "type": "string",
+                    "description": "Name of the symbol to find references for",
+                },
+                "symbol_kind": {
+                    "type": "string",
+                    "enum": ["function", "class", "variable", "method", "interface", "type"],
+                    "description": "Kind of symbol",
+                    "default": "function",
+                },
+                "include_declaration": {
+                    "type": "boolean",
+                    "description": "Whether to include the declaration in results",
+                    "default": True,
+                },
+            },
+            required=["file_path", "symbol_name"],
+        )
+
+
+class LSPRenameSymbolTool(BaseTool):
+    """Rename a symbol across the codebase using LSP."""
+
+    name = "rename_symbol"
+    description = """Safely rename a symbol (function, class, variable) across all files.
+Uses Language Server Protocol for semantic renaming that understands code structure.
+Much safer than find-and-replace."""
+    category = ToolCategory.TRAVERSAL
+
+    def __init__(self, mcp_manager, connection=None):
+        """Initialize the LSP tool.
+
+        Args:
+            mcp_manager: MCP server manager for calling cclsp
+            connection: Optional Kuzu connection (for compatibility)
+        """
+        super().__init__(connection)
+        self._mcp_manager = mcp_manager
+
+    def execute(
+        self,
+        file_path: str,
+        old_name: str,
+        new_name: str,
+        symbol_kind: str = "function",
+    ) -> ToolResult:
+        """Rename a symbol across the codebase.
+
+        Args:
+            file_path: Path to the file containing the symbol
+            old_name: Current name of the symbol
+            new_name: New name for the symbol
+            symbol_kind: Kind of symbol (function, class, variable, method)
+
+        Returns:
+            ToolResult with rename results
+        """
+        try:
+            response = self._mcp_manager.call_tool("rename_symbol", {
+                "file": file_path,
+                "name": old_name,
+                "newName": new_name,
+                "kind": symbol_kind,
+            })
+
+            if not response.content:
+                return ToolResult.error_result(
+                    f"Failed to rename '{old_name}' to '{new_name}'",
+                    suggestions=["Check the symbol name", "Try rename_symbol_strict for precise matching"],
+                )
+
+            content = response.content[0] if response.content else {}
+            text = content.get("text", "") if isinstance(content, dict) else str(content)
+
+            return ToolResult.success_result(
+                data={
+                    "old_name": old_name,
+                    "new_name": new_name,
+                    "kind": symbol_kind,
+                    "result": text,
+                },
+            )
+
+        except Exception as e:
+            log.exception("LSP rename_symbol failed")
+            return ToolResult.error_result(f"Failed to rename symbol: {str(e)}")
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file containing the symbol",
+                },
+                "old_name": {
+                    "type": "string",
+                    "description": "Current name of the symbol",
+                },
+                "new_name": {
+                    "type": "string",
+                    "description": "New name for the symbol",
+                },
+                "symbol_kind": {
+                    "type": "string",
+                    "enum": ["function", "class", "variable", "method", "interface", "type"],
+                    "description": "Kind of symbol",
+                    "default": "function",
+                },
+            },
+            required=["file_path", "old_name", "new_name"],
+        )
+
+
+class LSPGetDiagnosticsTool(BaseTool):
+    """Get diagnostics (errors, warnings) for a file using LSP."""
+
+    name = "get_diagnostics"
+    description = """Get errors, warnings, and other diagnostics for a file.
+Uses Language Server Protocol to provide real-time feedback without running the compiler.
+Useful for checking code health before making changes."""
+    category = ToolCategory.ANALYTICS
+
+    def __init__(self, mcp_manager, connection=None):
+        """Initialize the LSP tool.
+
+        Args:
+            mcp_manager: MCP server manager for calling cclsp
+            connection: Optional Kuzu connection (for compatibility)
+        """
+        super().__init__(connection)
+        self._mcp_manager = mcp_manager
+
+    def execute(
+        self,
+        file_path: str,
+    ) -> ToolResult:
+        """Get diagnostics for a file.
+
+        Args:
+            file_path: Path to the file to check
+
+        Returns:
+            ToolResult with diagnostics
+        """
+        try:
+            response = self._mcp_manager.call_tool("get_diagnostics", {
+                "file": file_path,
+            })
+
+            content = response.content[0] if response.content else {}
+            text = content.get("text", "") if isinstance(content, dict) else str(content)
+
+            return ToolResult.success_result(
+                data={
+                    "file": file_path,
+                    "diagnostics": text,
+                },
+            )
+
+        except Exception as e:
+            log.exception("LSP get_diagnostics failed")
+            return ToolResult.error_result(f"Failed to get diagnostics: {str(e)}")
+
+    def get_schema(self) -> dict:
+        """Get OpenAI function schema."""
+        return self._make_schema(
+            properties={
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file to check for diagnostics",
+                },
+            },
+            required=["file_path"],
+        )

emdash_core/agent/tools/skill.py

@@ -88,6 +88,23 @@ Use list_skills to see available skills."""
                 "",
             ])
 
+        # Include available scripts
+        scripts_paths = []
+        if skill_obj.scripts:
+            response_parts.extend([
+                "**Available Scripts**:",
+                "",
+            ])
+            for script in skill_obj.scripts:
+                script_path = str(script)
+                scripts_paths.append(script_path)
+                response_parts.append(f"- `{script_path}` - Run with: `bash {script_path}` or `./{script.name}` from skill directory")
+            response_parts.extend([
+                "",
+                "*Scripts are self-contained executables. Run them using Bash tool when needed.*",
+                "",
+            ])
+
         response_parts.extend([
             "---",
             "",
@@ -100,6 +117,7 @@ Use list_skills to see available skills."""
                 "description": skill_obj.description,
                 "instructions": skill_obj.instructions,
                 "tools": skill_obj.tools,
+                "scripts": scripts_paths,
                 "args": args,
                 "message": "\n".join(response_parts),
             },
@@ -172,13 +190,15 @@ class ListSkillsTool(BaseTool):
                 "description": skill.description,
                 "user_invocable": skill.user_invocable,
                 "tools": skill.tools,
+                "scripts": [str(s) for s in skill.scripts] if skill.scripts else [],
             })
 
         # Build human-readable message
         lines = ["# Available Skills", ""]
         for s in skills_list:
             invocable = f" (invoke with /{s['name']})" if s["user_invocable"] else ""
-            lines.append(f"- **{s['name']}**: {s['description']}{invocable}")
+            scripts_note = f" [has {len(s['scripts'])} script(s)]" if s["scripts"] else ""
+            lines.append(f"- **{s['name']}**: {s['description']}{invocable}{scripts_note}")
 
         return ToolResult.success_result(
             data={

emdash_core/agent/tools/task.py

@@ -14,6 +14,7 @@ from typing import Optional
 from .base import BaseTool, ToolResult, ToolCategory
 from ..toolkits import list_agent_types
 from ..inprocess_subagent import run_subagent, run_subagent_async
+from ..background import BackgroundTaskManager
 from ...utils.logger import log
 
 
@@ -87,11 +88,15 @@ Multiple sub-agents can be launched in parallel."""
                 suggestions=["Provide a clear task description in 'prompt'"],
             )
 
-        available_types = list_agent_types()
+        available_types = list_agent_types(self.repo_root)
+        log.info(f"TaskTool: repo_root={self.repo_root}, available_types={available_types}")
         if subagent_type not in available_types:
             return ToolResult.error_result(
                 f"Unknown agent type: {subagent_type}",
-                suggestions=[f"Available types: {available_types}"],
+                suggestions=[
+                    f"Available types: {available_types}",
+                    f"Searched in: {self.repo_root / '.emdash' / 'agents'}",
+                ],
             )
 
         # Log current mode for debugging
@@ -116,7 +121,7 @@ Multiple sub-agents can be launched in parallel."""
             })
 
         if run_in_background:
-            return self._run_background(subagent_type, prompt, max_turns, thoroughness)
+            return self._run_background(subagent_type, prompt, max_turns, thoroughness, description)
         else:
             return self._run_sync(subagent_type, prompt, max_turns, thoroughness)
 
@@ -180,6 +185,7 @@ Multiple sub-agents can be launched in parallel."""
         prompt: str,
         max_turns: int,
         thoroughness: str = "medium",
+        description: str = "",
     ) -> ToolResult:
         """Run sub-agent in background using a thread.
 
@@ -188,17 +194,11 @@ Multiple sub-agents can be launched in parallel."""
             prompt: Task prompt
             max_turns: Maximum API round-trips
             thoroughness: Search thoroughness level
+            description: Short task description
 
         Returns:
             ToolResult with task info
         """
-        agent_id = str(uuid.uuid4())[:8]
-
-        # Output file for results
-        output_dir = self.repo_root / ".emdash" / "agents"
-        output_dir.mkdir(parents=True, exist_ok=True)
-        output_file = output_dir / f"{agent_id}.output"
-
         try:
             # Start async execution
             future = run_subagent_async(
@@ -210,25 +210,26 @@ Multiple sub-agents can be launched in parallel."""
                 thoroughness=thoroughness,
             )
 
-            # Store future for later retrieval (attach to class for now)
-            if not hasattr(self, "_background_tasks"):
-                self._background_tasks = {}
-            self._background_tasks[agent_id] = {
-                "future": future,
-                "output_file": output_file,
-            }
+            # Register with BackgroundTaskManager for notification support
+            manager = BackgroundTaskManager.get_instance()
+            task_id = manager.start_subagent(
+                future=future,
+                agent_type=subagent_type,
+                description=description or prompt[:50],
+            )
 
-            log.info(f"Started background agent {agent_id}")
+            log.info(f"Started background agent {task_id}")
 
             return ToolResult.success_result(
                 data={
-                    "agent_id": agent_id,
+                    "task_id": task_id,
                     "status": "running",
                     "agent_type": subagent_type,
-                    "output_file": str(output_file),
+                    "message": "Sub-agent started in background. You'll be notified when it completes.",
                 },
                 suggestions=[
-                    f"Use task_output(agent_id='{agent_id}') to check results",
+                    f"Use task_output(task_id='{task_id}') to check results",
+                    f"Use kill_task(task_id='{task_id}') to stop it",
                 ],
             )
 
@@ -254,6 +255,9 @@ Multiple sub-agents can be launched in parallel."""
 
     def get_schema(self) -> dict:
         """Get OpenAI function schema."""
+        # Get available agent types dynamically (includes custom agents)
+        available_types = list_agent_types(self.repo_root)
+
         return self._make_schema(
             properties={
                 "description": {
@@ -266,8 +270,8 @@ Multiple sub-agents can be launched in parallel."""
                 },
                 "subagent_type": {
                     "type": "string",
-                    "enum": ["Explore", "Plan"],
-                    "description": "Type of specialized agent",
+                    "enum": available_types,
+                    "description": f"Type of specialized agent. Available: {', '.join(available_types)}",
                     "default": "Explore",
                 },
                 "model_tier": {