luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/tools/browser.py

@@ -0,0 +1,369 @@
+"""Playwright browser automation tools.
+
+Provides a persistent browser session that the AI agent can use to
+navigate, click, type, screenshot, and extract content from web pages.
+
+Supports headless (default) and headed modes. Set via settings:
+  /config set browser_headless false
+"""
+
+import os
+import uuid
+
+from .registry import Tool
+from ..settings import load_settings
+
+
+class BrowserManager:
+    """Singleton browser session manager."""
+
+    _instance = None
+    _playwright = None
+    _browser = None
+    _context = None
+    _page = None
+    _headless = None
+
+    def _ensure(self, headless: bool | None = None):
+        if self._page is None:
+            try:
+                from playwright.sync_api import sync_playwright
+            except ImportError as exc:
+                raise RuntimeError(
+                    "Playwright is not installed. "
+                    "Install it with: pip install deepseek-code[browser]"
+                ) from exc
+            if headless is None:
+                settings = load_settings()
+                headless = settings.get("browser_headless", True)
+            BrowserManager._headless = headless
+            self._playwright = sync_playwright().start()
+            self._browser = self._playwright.chromium.launch(
+                headless=headless,
+                args=[
+                    "--no-sandbox",
+                    "--disable-blink-features=AutomationControlled",
+                ],
+            )
+            self._context = self._browser.new_context(
+                viewport={"width": 1280, "height": 720},
+                user_agent=(
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/120.0.0.0 Safari/537.36"
+                ),
+            )
+            self._page = self._context.new_page()
+        return self._page
+
+    def page(self):
+        return self._ensure()
+
+    def close(self):
+        if self._context:
+            self._context.close()
+            self._context = None
+        if self._browser:
+            self._browser.close()
+            self._browser = None
+        if self._playwright:
+            self._playwright.stop()
+            self._playwright = None
+        self._page = None
+
+    @classmethod
+    def get(cls):
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+
+_manager = None
+
+
+def _get_manager():
+    global _manager
+    if _manager is None:
+        _manager = BrowserManager()
+    return _manager
+
+
+def make_safe_snapshot(page, max_length=8000) -> str:
+    """Extract an accessibility-style snapshot from the page."""
+    try:
+        title = page.title()
+        url = page.url
+
+        parts: list[str] = [f"URL: {url}", f"Title: {title}", ""]
+
+        # Get all interactive elements via JavaScript
+        snapshot_js = """
+        () => {
+            const results = [];
+            const selectors = [
+                'a[href]', 'button', 'input:not([type="hidden"])',
+                'select', 'textarea', '[role="button"]',
+                '[role="link"]', '[role="option"]', '[role="tab"]',
+                '[role="menuitem"]', '[role="checkbox"]',
+                '[role="radio"]', '[role="switch"]',
+                'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+                'p', 'li', 'label', 'img[alt]',
+                '[tabindex]:not([tabindex="-1"])',
+            ];
+            const seen = new Set();
+            selectors.forEach(sel => {
+                document.querySelectorAll(sel).forEach(el => {
+                    const rect = el.getBoundingClientRect();
+                    if (rect.width === 0 || rect.height === 0) return;
+                    const tag = el.tagName.toLowerCase();
+                    const text = (el.textContent || '').trim().slice(0, 120);
+                    const aria = el.getAttribute('aria-label') || '';
+                    const placeholder = el.getAttribute('placeholder') || '';
+                    const value = el.getAttribute('value') || '';
+                    const href = el.getAttribute('href') || '';
+                    const name = el.getAttribute('name') || '';
+                    const alt = el.getAttribute('alt') || '';
+                    const type = el.getAttribute('type') || '';
+                    const role = el.getAttribute('role') || '';
+
+                    const key = tag + '|' + text + '|' + (href || '');
+                    if (seen.has(key)) return;
+                    seen.add(key);
+
+                    const info = [`<${tag}`];
+                    if (role) info.push(` role="${role}"`);
+                    if (aria) info.push(` aria="${aria}"`);
+                    if (name) info.push(` name="${name}"`);
+                    if (type) info.push(` type="${type}"`);
+                    if (placeholder) info.push(` placeholder="${placeholder}"`);
+                    if (href) info.push(` href="${href}"`);
+                    if (alt) info.push(` alt="${alt}"`);
+                    if (value) info.push(` value="${value}"`);
+                    info.push(`>[${text.slice(0, 80)}]`);
+                    info.push(` [box=${Math.round(rect.x)},${Math.round(rect.y)},${Math.round(rect.width)},${Math.round(rect.height)}]`);
+                    results.push(info.join(''));
+                });
+            });
+            return results.join('\\n');
+        }
+        """
+        elements = page.evaluate(snapshot_js)
+
+        if elements:
+            parts.append("--- Page Elements ---")
+            parts.append(elements)
+        else:
+            # Fallback: get body text
+            body_text = page.inner_text("body") or ""
+            parts.append(body_text[:5000])
+
+        result = "\n".join(parts)
+        if len(result) > max_length:
+            result = result[:max_length] + "\n... (truncated)"
+        return result
+    except Exception as e:
+        return f"Error taking snapshot: {e}"
+
+
+class BrowserNavigateTool(Tool):
+    name = "BrowserNavigate"
+    description = "Navigate the browser to a URL. Returns page title and summary of elements."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "url": {
+                "type": "string",
+                "description": "The URL to navigate to",
+            },
+        },
+        "required": ["url"],
+    }
+
+    def run(self, url: str) -> str:  # type: ignore[override]
+        manager = _get_manager()
+        page = manager.page()
+        try:
+            page.goto(url, wait_until="domcontentloaded", timeout=30000)
+            page.wait_for_timeout(1000)
+            snapshot = make_safe_snapshot(page)
+            return f"Navigated to {url}\n\n{snapshot}"
+        except Exception as e:
+            return f"Error navigating to {url}: {e}"
+
+
+class BrowserClickTool(Tool):
+    name = "BrowserClick"
+    description = "Click an element on the page by CSS selector."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "selector": {
+                "type": "string",
+                "description": "CSS selector of the element to click",
+            },
+        },
+        "required": ["selector"],
+    }
+
+    def run(self, selector: str) -> str:  # type: ignore[override]
+        manager = _get_manager()
+        page = manager.page()
+        try:
+            page.wait_for_selector(selector, timeout=5000)
+            page.click(selector)
+            page.wait_for_timeout(500)
+            snapshot = make_safe_snapshot(page)
+            return f"Clicked {selector}\n\n{snapshot}"
+        except Exception as e:
+            return f"Error clicking {selector}: {e}"
+
+
+class BrowserTypeTool(Tool):
+    name = "BrowserType"
+    description = "Type text into an input field."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "selector": {
+                "type": "string",
+                "description": "CSS selector of the input element",
+            },
+            "text": {
+                "type": "string",
+                "description": "Text to type",
+            },
+            "submit": {
+                "type": "boolean",
+                "description": "Press Enter after typing (default: false)",
+            },
+        },
+        "required": ["selector", "text"],
+    }
+
+    def run(self, selector: str, text: str, submit: bool = False) -> str:  # type: ignore[override]
+        manager = _get_manager()
+        page = manager.page()
+        try:
+            page.wait_for_selector(selector, timeout=5000)
+            page.fill(selector, "")
+            page.type(selector, text, delay=20)
+            if submit:
+                page.press(selector, "Enter")
+                page.wait_for_timeout(1000)
+            snapshot = make_safe_snapshot(page)
+            return f"Typed into {selector}\n\n{snapshot}"
+        except Exception as e:
+            return f"Error typing into {selector}: {e}"
+
+
+class BrowserSnapshotTool(Tool):
+    name = "BrowserSnapshot"
+    description = "Get a text snapshot of the current page (interactive elements, headings, links, etc.)."
+    parameters = {
+        "type": "object",
+        "properties": {},
+    }
+
+    def run(self) -> str:  # type: ignore[override]
+        manager = _get_manager()
+        page = manager.page()
+        try:
+            return make_safe_snapshot(page)
+        except Exception as e:
+            return f"Error taking snapshot: {e}"
+
+
+class BrowserScreenshotTool(Tool):
+    name = "BrowserScreenshot"
+    description = "Take a screenshot of the current page and save it to a file."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "path": {
+                "type": "string",
+                "description": "File path to save the screenshot (default: auto-generated in working dir)",
+            },
+            "full_page": {
+                "type": "boolean",
+                "description": "Capture full scrollable page (default: false)",
+            },
+        },
+    }
+
+    def run(self, path: str = "", full_page: bool = False) -> str:  # type: ignore[override]
+        manager = _get_manager()
+        page = manager.page()
+        try:
+            if not path:
+                path = os.path.join(os.getcwd(), f"screenshot_{uuid.uuid4().hex[:8]}.png")
+            page.screenshot(path=path, full_page=full_page)
+            return f"Screenshot saved to {path}"
+        except Exception as e:
+            return f"Error taking screenshot: {e}"
+
+
+class BrowserEvaluateTool(Tool):
+    name = "BrowserEvaluate"
+    description = "Run JavaScript on the current page and return the result."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "expression": {
+                "type": "string",
+                "description": "JavaScript expression to evaluate",
+            },
+        },
+        "required": ["expression"],
+    }
+
+    def run(self, expression: str) -> str:  # type: ignore[override]
+        manager = _get_manager()
+        page = manager.page()
+        try:
+            result = page.evaluate(expression)
+            return str(result)[:5000]
+        except Exception as e:
+            return f"Error evaluating JS: {e}"
+
+
+class BrowserCloseTool(Tool):
+    name = "BrowserClose"
+    description = "Close the browser session."
+    parameters = {
+        "type": "object",
+        "properties": {},
+    }
+
+    def run(self) -> str:  # type: ignore[override]
+        manager = _get_manager()
+        manager.close()
+        return "Browser session closed."
+
+
+class OpenInBrowserTool(Tool):
+    name = "OpenInBrowser"
+    description = "Open a URL in the user's default system browser (Chrome, Edge, etc.). Use this when the user wants to see a web page, watch a video, or interact with a site in their real browser."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "url": {
+                "type": "string",
+                "description": "The URL to open",
+            },
+        },
+        "required": ["url"],
+    }
+
+    def run(self, url: str) -> str:  # type: ignore[override]
+        import subprocess
+        import platform
+        try:
+            if platform.system() == "Windows":
+                subprocess.Popen(["start", url], shell=True)
+            elif platform.system() == "Darwin":
+                subprocess.Popen(["open", url])
+            else:
+                subprocess.Popen(["xdg-open", url])
+            return f"Opened {url} in your default browser."
+        except Exception as e:
+            return f"Error opening browser: {e}"

luckyd_code/tools/datetime_tool.py

@@ -0,0 +1,34 @@
+"""DateTime tool — returns the current local date/time without touching the shell.
+
+Using 'date' or 'time' in a Bash tool on Windows cmd.exe launches an
+interactive prompt that hangs forever. This tool avoids the shell entirely.
+"""
+
+from datetime import datetime
+from .registry import Tool
+
+
+class DateTimeTool(Tool):
+    name = "DateTime"
+    description = (
+        "Get the current local date and time. "
+        "Always use this instead of running 'date' or 'time' in a shell."
+    )
+    permission_risk = "safe"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "format": {
+                "type": "string",
+                "description": (
+                    "Optional strftime format string "
+                    "(e.g. '%Y-%m-%d %H:%M:%S'). "
+                    "Defaults to a human-readable format."
+                ),
+            }
+        },
+        "required": [],
+    }
+
+    def run(self, format: str = "%A, %B %d %Y  %I:%M:%S %p") -> str:  # type: ignore[override]
+        return datetime.now().strftime(format)

luckyd_code/tools/dockerfile_gen.py

@@ -0,0 +1,212 @@
+"""Dockerfile & docker-compose generator tool.
+
+Scans the project to detect the stack, then generates a production-ready
+Dockerfile (and optionally a docker-compose.yml) using the DeepSeek model.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from pathlib import Path
+
+from .registry import Tool
+
+# ---------------------------------------------------------------------------
+# Prompts
+# ---------------------------------------------------------------------------
+
+_SYSTEM_PROMPT = """\
+You are a senior DevOps engineer specialising in Docker.
+
+Given a list of project files and their contents, generate a production-ready
+Dockerfile and, if the project has external dependencies (database, cache,
+message broker, etc.), a docker-compose.yml too.
+
+OUTPUT FORMAT — respond with ONLY a JSON object:
+{
+  "dockerfile": "<full Dockerfile content>",
+  "compose":    "<full docker-compose.yml content or empty string if not needed>",
+  "notes":      "<optional short notes: port, env vars, commands to know>"
+}
+
+RULES:
+1. Output ONLY the JSON. No markdown fences, no prose.
+2. Use multi-stage builds for compiled languages.
+3. Run as a non-root user in the final stage.
+4. Use .dockerignore best practices (hint in notes if needed).
+5. Use ARG/ENV for configurable values; never hard-code secrets.
+6. Pin base image versions (e.g. python:3.12-slim, node:20-alpine).
+7. Install only production dependencies in the final image.
+8. If compose is generated: use named volumes, health checks, depends_on.
+"""
+
+_MAX_FILE_CHARS = 2000
+_PRIORITY_FILES = {
+    "requirements.txt", "pyproject.toml", "setup.py", "Pipfile",
+    "package.json", "yarn.lock", "pnpm-lock.yaml",
+    "go.mod", "go.sum", "Cargo.toml",
+    "Gemfile", "build.gradle", "pom.xml",
+    "main.py", "app.py", "server.py", "index.js", "index.ts",
+    "main.go", "main.rs", ".env.example",
+}
+_SKIP_DIRS = {
+    ".git", ".venv", "venv", "node_modules", "__pycache__",
+    "dist", "build", "target",
+}
+_SKIP_EXTS = {".pyc", ".pyo", ".so", ".dll", ".exe", ".png", ".jpg", ".lock"}
+
+
+def _collect_context(root: Path) -> str:
+    parts: list[str] = []
+    seen: set[str] = set()
+
+    for name in _PRIORITY_FILES:
+        p = root / name
+        if p.exists() and p.is_file():
+            rel = str(p.relative_to(root))
+            try:
+                text = p.read_text(encoding="utf-8", errors="replace")[:_MAX_FILE_CHARS]
+                parts.append(f"=== {rel} ===\n{text}")
+                seen.add(rel)
+            except Exception:
+                pass
+
+    count = 0
+    for p in sorted(root.rglob("*")):
+        if count >= 10:
+            break
+        if any(part in _SKIP_DIRS for part in p.parts):
+            continue
+        if p.suffix in _SKIP_EXTS or not p.is_file():
+            continue
+        rel = str(p.relative_to(root))
+        if rel in seen:
+            continue
+        try:
+            text = p.read_text(encoding="utf-8", errors="replace")[:_MAX_FILE_CHARS]
+            parts.append(f"=== {rel} ===\n{text}")
+            seen.add(rel)
+            count += 1
+        except Exception:
+            pass
+
+    return "\n\n".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Tool
+# ---------------------------------------------------------------------------
+
+class DockerfileGenTool(Tool):
+    """Generate a production-ready Dockerfile (and docker-compose.yml if needed).
+
+    Use this tool when the user asks to:
+      - Dockerise or containerise their project
+      - Write a Dockerfile for any language / framework
+      - Set up docker-compose with services (database, cache, etc.)
+    """
+
+    name = "DockerfileGen"
+    description = (
+        "Scan the current project and generate a production-ready Dockerfile "
+        "and docker-compose.yml. Works with any language or framework. "
+        "Auto-detects the stack from dependency files and source code."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "project_dir": {
+                "type": "string",
+                "description": "Root directory of the project. Defaults to cwd.",
+                "default": ".",
+            },
+            "overwrite": {
+                "type": "boolean",
+                "description": "Overwrite existing Dockerfile / docker-compose.yml.",
+                "default": False,
+            },
+        },
+        "required": [],
+    }
+    permission_risk = "medium"
+
+    def _call_model(self, context: str) -> dict[str, Any]:
+        user_msg = f"Project files:\n\n{context}\n\nGenerate the Dockerfile and compose file."
+        raw = self._call_model_direct(user_msg)
+        raw = raw.strip()
+        if raw.startswith("```"):
+            raw = "\n".join(ln for ln in raw.splitlines() if not ln.startswith("```")).strip()
+        return json.loads(raw)
+
+    def _call_model_direct(self, user_msg: str) -> str:
+        from ..config import get_api_key, get_base_url  # noqa: PLC0415
+        payload = {
+            "model": "deepseek-chat",
+            "max_tokens": 4096,
+            "temperature": 0.2,
+            "messages": [
+                {"role": "system", "content": _SYSTEM_PROMPT},
+                {"role": "user", "content": user_msg},
+            ],
+        }
+        req = urllib.request.Request(
+            f"{get_base_url()}/chat/completions",
+            data=json.dumps(payload).encode(),
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {get_api_key()}",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=90) as resp:
+            data = json.loads(resp.read())
+        return data["choices"][0]["message"]["content"]
+
+    def run(self, project_dir: str = ".", overwrite: bool = False) -> str:  # type: ignore[override]
+        root = Path(project_dir).expanduser().resolve()
+        if not root.is_dir():
+            return f"Error: '{root}' is not a directory."
+
+        df_path = root / "Dockerfile"
+        compose_path = root / "docker-compose.yml"
+
+        if df_path.exists() and not overwrite:
+            return "Dockerfile already exists. Pass overwrite=true to replace it."
+
+        context = _collect_context(root)
+        if not context:
+            return "Error: no readable source files found."
+
+        try:
+            result = self._call_model(context)
+        except json.JSONDecodeError as e:
+            return f"Error: model returned invalid JSON — {e}"
+        except Exception as e:
+            return f"Error: model call failed — {e}"
+
+        dockerfile = result.get("dockerfile", "").strip()
+        compose = result.get("compose", "").strip()
+        notes = result.get("notes", "")
+
+        written: list[str] = []
+
+        if dockerfile:
+            try:
+                df_path.write_text(dockerfile, encoding="utf-8")
+                written.append(str(df_path))
+            except OSError as e:
+                return f"Error writing Dockerfile: {e}"
+
+        if compose:
+            try:
+                compose_path.write_text(compose, encoding="utf-8")
+                written.append(str(compose_path))
+            except OSError as e:
+                return f"Error writing docker-compose.yml: {e}"
+
+        lines = [f"Generated {len(written)} file(s):"]
+        lines.extend(f"  {w}" for w in written)
+        if notes:
+            lines += ["", f"Notes: {notes}"]
+        return "\n".join(lines)