luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/tools/agent_tools.py

@@ -0,0 +1,65 @@
+"""Sub-agent tool for spawning child agents."""
+
+from .registry import Tool
+
+
+# Reference to the Repl instance for config access
+_repl = None
+
+
+def set_repl(repl):
+    global _repl
+    _repl = repl
+
+
+class SubAgentTool(Tool):
+    name = "SubAgent"
+    description = "Spawn a child agent to work independently on a subtask. Use for research, exploration, or parallel work."
+    permission_risk = "medium"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "task": {
+                "type": "string",
+                "description": "The task for the sub-agent to complete",
+            },
+        },
+        "required": ["task"],
+    }
+
+    def run(self, task: str) -> str:  # type: ignore[override]
+        global _repl
+        if _repl is None:
+            return "Error: sub-agent not available (not initialized)"
+        from ..agent import SubAgent
+        agent = SubAgent(_repl.config, task, _repl.registry.list_tools())
+        return agent.run()
+
+
+class AgentHandoffTool(Tool):
+    name = "AgentHandoff"
+    description = "Hand off a subtask to a specialized agent role. Roles: researcher (gather info), coder (implement changes), reviewer (review code), tester (write/run tests). Use when a task needs a specialist."
+    permission_risk = "medium"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "role": {
+                "type": "string",
+                "enum": ["researcher", "coder", "reviewer", "tester"],
+                "description": "The specialist role to hand off to",
+            },
+            "task": {
+                "type": "string",
+                "description": "The specific task for the specialist agent",
+            },
+        },
+        "required": ["role", "task"],
+    }
+
+    def run(self, role: str, task: str) -> str:  # type: ignore[override]
+        global _repl
+        if _repl is None:
+            return "Error: handoff not available (not initialized)"
+        from ..orchestrator import AgentHandoff
+        handoff = AgentHandoff(_repl.config)
+        return handoff.handoff(role, task, _repl.registry.list_tools())

luckyd_code/tools/bash.py

@@ -0,0 +1,360 @@
+"""Bash tool with safety guards and optional Docker sandbox.
+
+Auto-detects the best available shell on Windows (Git Bash → WSL → cmd.exe)
+so the AI can use standard Unix commands like ls, grep, find, and curl.
+
+Cross-platform subprocess handling:
+  - Uses Popen with process groups for reliable timeout enforcement
+  - Proper Windows process isolation via creationflags
+  - Rewrites interactive commands into non-interactive equivalents
+  - Auto-detects .venv/pip/pytest and routes them through cmd.exe on Windows
+"""
+
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from .registry import Tool
+from .shell_detect import resolve_shell, ShellInfo
+from ..settings import load_settings
+from ..sandbox import get_sandbox
+
+# Default working directory for commands — evaluated at runtime so --dir flag works
+def _get_cwd() -> Path:
+    return Path.cwd()
+
+# Cached shell detection result (reset on /config set shell)
+_SHELL_CACHE: Optional[ShellInfo] = None
+
+
+def _get_shell() -> ShellInfo:
+    """Get cached shell info, detecting on first call."""
+    global _SHELL_CACHE
+    if _SHELL_CACHE is None:
+        settings = load_settings()
+        shell_setting = settings.get("shell", "auto")
+        _SHELL_CACHE = resolve_shell(shell_setting)
+    return _SHELL_CACHE
+
+
+def reset_shell_cache():
+    """Force re-detection on next call. Used by /config set shell."""
+    global _SHELL_CACHE
+    _SHELL_CACHE = None
+
+# Commands that are blocked for safety
+BLOCKED_PATTERNS = [
+    "rm -rf /",
+    "rm -rf ~",
+    "rm -rf .",
+    "> /dev/sda",
+    "mkfs.",
+    "dd if=",
+    ":(){ :|:& };:",  # fork bomb
+    "chmod 777",
+    "sudo ",
+    "su ",
+]
+
+# Interactive commands that will hang
+INTERACTIVE_COMMANDS = [
+    "vim", "vi", "nano", "emacs", "less", "more", "top", "htop",
+    "ssh", "telnet", "ftp", "python -i", "irb", "node -i",
+    # Windows cmd.exe commands that prompt for input when run without flags
+    "date", "time", "pause", "choice",
+    # stdin readers that block forever without a pipe
+    "clip",
+    # Additional commands that typically require a TTY
+    "watch", "tail -f", "journalctl -f", "docker attach",
+    "mysql", "psql", "sqlite3", "redis-cli", "mongo",
+]
+
+
+def _fix_windows_cmd(command: str) -> str:
+    """Rewrite bare Windows commands that are interactive into their
+    non-interactive equivalents so they never hang.
+
+    Examples
+    --------
+    ``date``       → ``date /T``   (print date, don't prompt to change it)
+    ``time``       → ``time /T``   (print time, don't prompt to change it)
+    ``ping host``  → ``ping -n 4 host``  (bounded ping instead of infinite)
+    ``choice``     → ``choice /N /T 0 /D Y``  (non-interactive choice, select default)
+    ``pause``      → ``echo.``  (skip pause)
+    """
+    import re
+    stripped = command.strip()
+
+    # 'date' alone or 'date ' with no flags → date /T
+    if re.fullmatch(r'date', stripped, re.IGNORECASE):
+        return 'date /T'
+    if re.match(r'date\s+(?!/)(.+)', stripped, re.IGNORECASE):
+        return 'date /T'
+
+    # 'time' alone → time /T
+    if re.fullmatch(r'time', stripped, re.IGNORECASE):
+        return 'time /T'
+    if re.match(r'time\s+(?!/)(.+)', stripped, re.IGNORECASE):
+        return 'time /T'
+
+    # 'ping host' without -n → add '-n 4' so it terminates
+    ping_match = re.match(r'(ping)\s+(?!.*-n\s+\d)(.+)', stripped, re.IGNORECASE)
+    if ping_match:
+        return f'ping -n 4 {ping_match.group(2)}'
+
+    # 'choice' without /T → add non-interactive defaults
+    if re.fullmatch(r'choice', stripped, re.IGNORECASE):
+        return 'choice /N /T 0 /D Y'
+
+    # 'pause' → skip
+    if re.fullmatch(r'pause', stripped, re.IGNORECASE):
+        return 'echo.'
+
+    # 'clip' without input → pipe nothing
+    if re.fullmatch(r'clip', stripped, re.IGNORECASE):
+        return 'echo.| clip'
+
+    return command
+
+
+def _fix_unix_ping(command: str) -> str:
+    """On Unix shells, bare 'ping host' runs forever — add '-c 4'."""
+    import re
+    stripped = command.strip()
+    ping_match = re.match(r'(ping)\s+(?!.*-c\s+\d)(.+)', stripped, re.IGNORECASE)
+    if ping_match:
+        return f'ping -c 4 {ping_match.group(2)}'
+    return command
+
+
+def _is_dangerous(command: str) -> str | None:
+    """Check if a command is potentially dangerous. Returns warning or None."""
+    cmd_lower = command.lower().strip()
+
+    for pattern in BLOCKED_PATTERNS:
+        if pattern in cmd_lower:
+            return f"Command blocked for safety: matches '{pattern}'"
+
+    # Check for interactive commands
+    for ic in INTERACTIVE_COMMANDS:
+        if cmd_lower.startswith(ic) or f" {ic} " in f" {cmd_lower} ":
+            return f"Interactive command '{ic}' is not supported in non-interactive shell — use the DateTime tool for date/time queries"
+
+    # Warn about pip install / npm install (can be slow or modify system)
+    if "pip install" in cmd_lower or "npm install" in cmd_lower:
+        pass  # These are generally useful, just warn via permission system
+
+    return None
+
+
+class _CommandTimeout(Exception):
+    """Raised when a command exceeds its timeout."""
+    def __init__(self, elapsed: float):
+        self.elapsed = elapsed
+        super().__init__(f"Command timed out after {elapsed:.0f}s")
+
+
+def _run_with_timeout(
+    cmd,
+    *,
+    shell: bool = False,
+    timeout_sec: float = 120,
+    cwd: str | Path | None = None,
+) -> tuple[str, str, int]:
+    """Execute a subprocess with reliable timeout enforcement.
+
+    Uses Popen with process groups so that on timeout the entire process
+    tree is terminated — no orphaned child processes.
+
+    On Windows, uses CREATE_NEW_PROCESS_GROUP for proper isolation.
+    On Unix, uses os.setsid to create a new session.
+
+    Returns (stdout, stderr, returncode).
+    Raises _CommandTimeout if the process doesn't finish in time.
+    """
+    cwd = str(cwd) if cwd else None
+
+    # On Windows, some commands (like 'where') can hang when searching
+    # network paths. Mitigate by ensuring system32 is prioritized.
+    env = os.environ.copy()
+    if sys.platform == "win32" and shell:
+        # Ensure system32 is first in PATH for cmd.exe reliability
+        system32 = r"C:\Windows\System32"
+        current_path = env.get("PATH", "")
+        if system32 not in current_path.split(os.pathsep)[:1]:
+            env["PATH"] = system32 + os.pathsep + current_path
+
+    # Build creation flags for proper process group handling
+    kwargs: dict = {
+        "stdout": subprocess.PIPE,
+        "stderr": subprocess.PIPE,
+        "text": True,
+        "cwd": cwd,
+        "env": env,
+    }
+
+    if sys.platform == "win32":
+        # CREATE_NEW_PROCESS_GROUP prevents Ctrl+C propagation
+        # CREATE_NO_WINDOW prevents a console window from popping up
+        CREATE_NEW_PROCESS_GROUP = 0x00000200
+        CREATE_NO_WINDOW = 0x08000000
+        kwargs["creationflags"] = CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
+    else:
+        # Create a new session so we can kill the full process tree.
+        # start_new_session=True makes the child a process group leader;
+        # preexec_fn=os.setsid would do the same thing but Python raises
+        # ValueError if both are set simultaneously — use only one.
+        kwargs["start_new_session"] = True
+
+    t0 = time.time()
+    proc = subprocess.Popen(cmd, shell=shell, **kwargs)
+
+    try:
+        stdout, stderr = proc.communicate(timeout=timeout_sec)
+        return stdout or "", stderr or "", proc.returncode or 0
+    except subprocess.TimeoutExpired:
+        elapsed = time.time() - t0
+
+        # Kill the full process tree
+        try:
+            if sys.platform == "win32":
+                # Terminate process tree on Windows
+                subprocess.run(
+                    ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                    capture_output=True,
+                    timeout=10,
+                )
+            else:
+                # Kill the process group on Unix
+                os.killpg(proc.pid, signal.SIGKILL)
+        except Exception:
+            pass
+
+        # Also try direct kill
+        try:
+            proc.kill()
+        except Exception:
+            pass
+
+        # Small wait for cleanup
+        try:
+            proc.wait(timeout=2)
+        except Exception:
+            pass
+
+        raise _CommandTimeout(elapsed)
+
+
+class BashTool(Tool):
+    name = "Bash"
+    description = "Execute a shell command and get its output."
+    permission_risk = "high"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "The shell command to execute",
+            },
+            "description": {
+                "type": "string",
+                "description": "Clear description of what this command does",
+            },
+            "timeout": {
+                "type": "integer",
+                "description": "Timeout in milliseconds (default 120000, max 600000)",
+            },
+        },
+        "required": ["command"],
+    }
+
+    def run(self, command: str, description: str = "", timeout: int = 120000) -> str:  # type: ignore[override]
+        # Safety check
+        warning = _is_dangerous(command)
+        if warning:
+            return f"Error: {warning}"
+
+        timeout_sec = min(timeout / 1000, 600)
+        # Minimum 1 second timeout
+        timeout_sec = max(timeout_sec, 1)
+
+        # Check if sandbox mode is enabled
+        settings = load_settings()
+        use_sandbox = settings.get("sandbox", False)
+
+        if use_sandbox:
+            sandbox = get_sandbox()
+            if sandbox.available:
+                stdout, stderr, rc = sandbox.run(command, timeout=int(timeout_sec))
+                output = stdout
+                if stderr:
+                    output += ("\n" + stderr) if output else stderr
+                if rc != 0 and not output:
+                    output = f"Command exited with code {rc}"
+                return (output.strip()[:10000]
+                        or f"(command completed with exit code {rc}, no output)")
+
+        try:
+            shell_info = _get_shell()
+
+            # On Windows, prefer cmd.exe for .venv/pip/pytest/python commands
+            # because Git Bash struggles with Windows-style paths and venv scripts.
+            use_cmd = False
+            if shell_info.unix_like and sys.platform == "win32":
+                cmd_lower = command.lower().strip()
+                win_indicators = (
+                    ".venv", "venv\\", "venv/",
+                    "pytest", "pip ", "pip3 ",
+                    ".bat", ".exe",
+                    "python -m", "python3 -m",
+                )
+                if any(ind in cmd_lower for ind in win_indicators):
+                    use_cmd = True
+
+            if use_cmd or not shell_info.unix_like:
+                # cmd.exe — rewrite any interactive-but-fixable commands first
+                command = _fix_windows_cmd(command)
+                stdout, stderr, rc = _run_with_timeout(
+                    command,
+                    shell=True,
+                    timeout_sec=timeout_sec,
+                    cwd=_get_cwd(),
+                )
+            else:
+                # Unix shell (Git Bash / WSL) — fix bare ping before running
+                command = _fix_unix_ping(command)
+                full_args = [shell_info.path] + shell_info.args + ["-c", command]
+                stdout, stderr, rc = _run_with_timeout(
+                    full_args,
+                    shell=False,
+                    timeout_sec=timeout_sec,
+                    cwd=_get_cwd(),
+                )
+
+            output = ""
+            if stdout:
+                output += stdout
+            if stderr:
+                if output:
+                    output += "\n"
+                output += stderr
+            if rc != 0 and not output:
+                output = f"Command exited with code {rc}"
+
+            # Truncate very long output
+            max_output = 10000
+            if len(output) > max_output:
+                output = output[:max_output] + f"\n... (truncated, {len(output)} total chars)"
+
+            return output.strip() or f"(command completed with exit code {rc}, no output)"
+
+        except _CommandTimeout as e:
+            return f"Error: command timed out after {e.elapsed:.0f}s: {command[:200]}"
+        except OSError as e:
+            return f"Error: system error executing command: {e}"
+        except Exception as e:
+            return f"Error executing command: {e}"

luckyd_code/tools/brain_tools.py

@@ -0,0 +1,137 @@
+"""Brain tools — query the codebase knowledge graph and RAG index."""
+
+from ..brain import KnowledgeGraph, Retriever, ContextAssembler
+from .registry import Tool
+
+
+# Global instances that persist across tool calls
+_graph: KnowledgeGraph | None = None
+_retriever: Retriever | None = None
+_assembler: ContextAssembler | None = None
+
+
+def _get_graph() -> KnowledgeGraph:
+    """Get the shared graph instance, loading from disk if needed."""
+    global _graph
+    if _graph is None:
+        _graph = KnowledgeGraph()
+        _graph.load()
+    return _graph
+
+
+def _get_retriever() -> Retriever:
+    """Get the shared retriever instance."""
+    global _retriever
+    if _retriever is None:
+        _retriever = Retriever()
+    return _retriever
+
+
+def _get_assembler() -> ContextAssembler:
+    """Get the shared context assembler instance."""
+    global _assembler
+    if _assembler is None:
+        _assembler = ContextAssembler()
+    return _assembler
+
+
+class BrainSearchTool(Tool):
+    name = "BrainSearch"
+    description = "Search the codebase for functions, classes, and code patterns using semantic understanding. Use this INSTEAD of Grep when you need to find code by concept or behavior (e.g., 'authentication flow', 'database retry logic') rather than exact name matches."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "Search term — natural language description of what you're looking for (e.g., 'user authentication', 'database connection', 'error handling')",
+            },
+            "max_results": {
+                "type": "integer",
+                "description": "Maximum results to return (default 10)",
+                "default": 10,
+            },
+            "file_filter": {
+                "type": "string",
+                "description": "Optional file path filter (e.g., 'auth.py', 'src/api/')",
+            },
+        },
+        "required": ["query"],
+    }
+    permission_risk = "safe"
+
+    def run(self, query: str, max_results: int = 10, file_filter: str = "") -> str:  # type: ignore[override]
+        retriever = _get_retriever()
+
+        results = retriever.search(
+            query,
+            k=max_results,
+            file_filter=file_filter or None,
+        )
+        if not results:
+            # Check if old graph has anything
+            graph = _get_graph()
+            if not graph.nodes:
+                return "Codebase index is empty. Run `/brain rebuild` first to index your codebase."
+            return f"No results found for '{query}'."
+
+        lines = [f"Brain search results for '{query}':", ""]
+        for r in results:
+            file_path = r.get("file_path", "?")
+            start = r.get("start_line", 0)
+            end = r.get("end_line", 0)
+            score = r.get("score", 0)
+            name = r.get("name", "")
+            chunk_type = r.get("type", "?")
+            lang = r.get("language", "")
+
+            loc = f"{file_path}:{start}-{end}" if start else file_path
+            label = f"[{chunk_type}] {name} ({lang})" if name else f"[{chunk_type}] ({lang})"
+            lines.append(f"  {label} — {loc}  (score: {score:.2f})")
+
+        return "\n".join(lines)
+
+
+class BrainStatusTool(Tool):
+    name = "BrainStatus"
+    description = "Show the current state of the codebase index — vector index stats, knowledge graph stats, languages found, and last indexed time."
+    parameters = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
+    permission_risk = "safe"
+
+    def run(self) -> str:  # type: ignore[override]
+        retriever = _get_retriever()
+        info = retriever.stats()
+
+        lines = ["=== Vector Index ==="]
+        vec = info.get("vector", {})
+        if vec.get("available"):
+            lines.append(f"  Chunks: {vec.get('chunks', 0)}")
+            lines.append(f"  Files: {vec.get('files', 0)}")
+            languages = vec.get("languages", {})
+            if languages:
+                lang_str = ", ".join(f"{k}={v}" for k, v in sorted(languages.items()))
+                lines.append(f"  Languages: {lang_str}")
+            last = vec.get("last_indexed", 0)
+            if last:
+                import time
+                last_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(last))
+                lines.append(f"  Last indexed: {last_str}")
+            stale = info.get("stale_files", 0)
+            if stale:
+                lines.append(f"  [yellow]Stale files: {stale} (run /brain rebuild)[/yellow]")
+        else:
+            lines.append("  Not available (install faiss-cpu + sentence-transformers for vector search)")
+
+        lines.append("\n=== Knowledge Graph (Fallback) ===")
+        graph_data = info.get("graph", {})
+        if graph_data.get("nodes"):
+            lines.append(f"  Symbols: {graph_data.get('nodes', 0)}")
+            lines.append(f"  Relations: {graph_data.get('edges', 0)}")
+            lines.append(f"  Files: {graph_data.get('files_parsed', 0)}")
+        else:
+            lines.append("  Empty")
+
+        return "\n".join(lines)