luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/tools/web.py

@@ -0,0 +1,89 @@
+import httpx
+from urllib.parse import quote as url_quote
+from bs4 import BeautifulSoup
+
+from .registry import Tool
+
+
+class WebFetchTool(Tool):
+    name = "WebFetch"
+    description = "Fetch content from a URL and extract its text content."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "url": {
+                "type": "string",
+                "description": "The URL to fetch",
+            },
+        },
+        "required": ["url"],
+    }
+
+    def run(self, url: str) -> str:  # type: ignore[override]
+        try:
+            response = httpx.get(url, follow_redirects=True, timeout=30)
+            response.raise_for_status()
+            content_type = response.headers.get("content-type", "")
+            if "text/html" in content_type:
+                soup = BeautifulSoup(response.text, "html.parser")
+                for tag in soup(["script", "style", "nav", "footer", "header"]):
+                    tag.decompose()
+                text = soup.get_text(separator="\n", strip=True)
+                lines = [line.strip() for line in text.splitlines() if line.strip()]
+                text = "\n".join(lines)
+            else:
+                text = response.text
+
+            if len(text) > 15000:
+                text = text[:15000] + f"\n... (truncated, {len(text)} total chars)"
+            return text
+        except httpx.HTTPStatusError as e:
+            return f"HTTP error {e.response.status_code}: {e.response.text[:500]}"
+        except Exception as e:
+            return f"Error fetching URL: {e}"
+
+
+class WebSearchTool(Tool):
+    name = "WebSearch"
+    description = "Search the web and get results."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "The search query",
+            },
+        },
+        "required": ["query"],
+    }
+
+    def run(self, query: str) -> str:  # type: ignore[override]
+        # Simple DuckDuckGo-like search via a public endpoint
+        try:
+            url = f"https://html.duckduckgo.com/html/?q={url_quote(query)}"
+            response = httpx.get(
+                url,
+                headers={
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+                },
+                follow_redirects=True,
+                timeout=30,
+            )
+            response.raise_for_status()
+
+            soup = BeautifulSoup(response.text, "html.parser")
+            results = []
+            for result in soup.select(".result")[:10]:
+                title_el = result.select_one(".result__title a")
+                snippet_el = result.select_one(".result__snippet")
+                if title_el:
+                    title = title_el.get_text(strip=True)
+                    link = title_el.get("href", "")
+                    snippet = snippet_el.get_text(strip=True) if snippet_el else ""
+                    results.append(f"{title}\n  URL: {link}\n  {snippet}")
+
+            if not results:
+                return f"No results found for '{query}'"
+            return "\n\n".join(results)
+        except Exception as e:
+            return f"Search error: {e}"

luckyd_code/tools/youtube.py

@@ -0,0 +1,187 @@
+"""YouTube playlist generator tool.
+
+Converts a list of YouTube URLs or video IDs into a temporary playlist URL
+that works without a YouTube account (YouTube's watch_videos endpoint).
+Supports up to 50 videos per playlist (YouTube's hard limit for this endpoint).
+
+Integrated into the tool registry so the AI agent can generate playlists
+on demand during a coding/automation session.
+"""
+
+import re
+from urllib.parse import urlencode, urlparse, parse_qs
+from typing import Optional
+
+from .registry import Tool
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+PLAYLIST_BASE = "https://www.youtube.com/watch_videos"
+MAX_VIDEOS = 50  # YouTube's limit for the watch_videos endpoint
+
+# Regex patterns for extracting video IDs from various URL formats.
+# Handles: youtu.be/<id>, youtube.com/watch?v=<id>, /embed/<id>, /shorts/<id>
+_YT_ID_PATTERN = re.compile(
+    r"(?:youtu\.be/|youtube\.com/(?:watch\?.*?v=|embed/|shorts/|v/))"
+    r"([A-Za-z0-9_-]{11})"
+)
+# A bare 11-character video ID with no URL wrapper
+_BARE_ID_PATTERN = re.compile(r"^[A-Za-z0-9_-]{11}$")
+
+
+# ---------------------------------------------------------------------------
+# Core extraction logic (reused by both Tool and CLI script)
+# ---------------------------------------------------------------------------
+
+def extract_video_id(raw: str) -> Optional[str]:
+    """Extract an 11-character YouTube video ID from a URL or bare ID string.
+
+    Returns the ID string on success, or None if the input is not recognised
+    as a valid YouTube reference.
+    """
+    raw = raw.strip()
+    if not raw:
+        return None
+
+    # Try URL-based regex extraction first (covers youtu.be, /embed, /shorts)
+    match = _YT_ID_PATTERN.search(raw)
+    if match:
+        return match.group(1)
+
+    # Handle youtube.com/watch?v=ID where v= may not be the first parameter
+    try:
+        parsed = urlparse(raw)
+        if "youtube.com" in parsed.netloc:
+            qs = parse_qs(parsed.query)
+            if "v" in qs:
+                vid = qs["v"][0]
+                if len(vid) == 11:
+                    return vid
+    except Exception:
+        pass
+
+    # Fall back: accept a bare 11-char ID (only valid YouTube ID characters)
+    if _BARE_ID_PATTERN.match(raw):
+        return raw
+
+    return None
+
+
+def build_playlist_url(video_ids: list) -> str:
+    """Construct a YouTube watch_videos URL from a list of video IDs.
+
+    Uses safe="," to prevent urlencode from percent-encoding the commas
+    between video IDs — YouTube's watch_videos endpoint expects literal commas.
+    """
+    if not video_ids:
+        raise ValueError("No video IDs provided — cannot build a playlist URL.")
+    params = urlencode({"video_ids": ",".join(video_ids)}, safe=",")
+    return f"{PLAYLIST_BASE}?{params}"
+
+
+def process_inputs(raw_inputs: list, cap: int = MAX_VIDEOS) -> tuple:
+    """Parse raw input strings into (valid_ids, skipped_inputs).
+
+    Deduplicates IDs while preserving order. Enforces the video cap and
+    records a warning entry in *skipped* for any videos over the limit.
+
+    Args:
+        raw_inputs: Raw URL/ID strings to process.
+        cap: Maximum number of videos to accept (default: MAX_VIDEOS = 50).
+    """
+    seen: set = set()
+    valid: list = []
+    skipped: list = []
+
+    for raw in raw_inputs:
+        vid = extract_video_id(raw)
+        if vid is None:
+            skipped.append(f"Invalid: {raw!r}")
+            continue
+        if vid in seen:
+            skipped.append(f"Duplicate: {raw!r}")
+            continue
+        if len(valid) >= cap:
+            skipped.append(f"Over {cap}-video limit: {raw!r}")
+            continue
+        seen.add(vid)
+        valid.append(vid)
+
+    return valid, skipped
+
+
+# ---------------------------------------------------------------------------
+# Tool class — integrates with the DeepSeek Code tool registry
+# ---------------------------------------------------------------------------
+
+class YouTubePlaylistTool(Tool):
+    """Generate a temporary YouTube playlist URL from a list of video URLs or IDs.
+
+    Use this tool whenever the user asks to:
+      - Create or build a YouTube playlist
+      - Combine multiple YouTube videos into a single watchable link
+      - Generate a shareable playlist without a YouTube account
+      - Produce a playlist URL from a list of video URLs or IDs
+
+    The playlist URL opens immediately in any browser — no login required.
+    """
+
+    name = "YouTubePlaylist"
+    description = (
+        "Use when the user wants to combine YouTube videos into a playlist or generate "
+        "a shareable playlist URL. Accepts any mix of YouTube URL formats (full URLs, "
+        "youtu.be short links, embed/shorts URLs, or bare 11-char video IDs) and returns "
+        "a ready-to-open playlist link. No YouTube account required. Supports up to 50 videos. "
+        "Also reports any invalid or duplicate inputs that were skipped."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "videos": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": (
+                    "List of YouTube video URLs (any format: full URL, youtu.be short "
+                    "link, embed URL, shorts URL) or bare 11-character video IDs."
+                ),
+            },
+            "max_videos": {
+                "type": "integer",
+                "description": (
+                    f"Maximum number of videos to include (1–{MAX_VIDEOS}). "
+                    f"Defaults to {MAX_VIDEOS}. Videos beyond this cap are reported as skipped."
+                ),
+            },
+        },
+        "required": ["videos"],
+    }
+    permission_risk = "safe"
+
+    def run(self, videos: list, max_videos: int = MAX_VIDEOS) -> str:  # type: ignore[override]
+        if not videos:
+            return "Error: no videos provided."
+
+        # Clamp max_videos to the hard YouTube limit
+        cap = max(1, min(max_videos, MAX_VIDEOS))
+
+        valid_ids, skipped = process_inputs(videos, cap=cap)
+        lines: list = []
+
+        if not valid_ids:
+            lines.append("Error: no valid YouTube video IDs found.")
+            if skipped:
+                lines.append(f"Skipped {len(skipped)} input(s):")
+                lines.extend(f"  • {s}" for s in skipped)
+            return "\n".join(lines)
+
+        url = build_playlist_url(valid_ids)
+        lines.append(f"Playlist URL ({len(valid_ids)} video(s)):")
+        lines.append(url)
+
+        if skipped:
+            lines.append(f"\nSkipped {len(skipped)} input(s):")
+            lines.extend(f"  • {s}" for s in skipped)
+
+        return "\n".join(lines)

luckyd_code/tools_bridge.py

@@ -0,0 +1,144 @@
+"""Tools Bridge — exposes all tools as CLI commands.
+
+This makes every tool in the registry callable via:
+    python -m luckyd_code.tools_bridge <tool> [args...]
+
+Examples:
+    python -m luckyd_code.tools_bridge browser navigate --url https://example.com
+    python -m luckyd_code.tools_bridge bash --command "dir /b"
+    python -m luckyd_code.tools_bridge brain search --query "authentication"
+"""
+import json
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+# Ensure the project root is on sys.path
+_project_root = Path(__file__).resolve().parent.parent
+if str(_project_root) not in sys.path:
+    sys.path.insert(0, str(_project_root))
+
+_console = Console()
+
+
+def _parse_args(raw_args: list[str]) -> dict:
+    """Parse KEY=VALUE or --flag VALUE pairs into a dict."""
+    result = {}
+    key = None
+    for item in raw_args:
+        if item.startswith("--"):
+            if key is not None:
+                result[key] = True  # flag
+            key = item.removeprefix("--")
+        elif key is not None:
+            try:
+                result[key] = json.loads(item)
+            except (json.JSONDecodeError, TypeError):
+                result[key] = item
+            key = None
+        elif "=" in item:
+            k, v = item.split("=", 1)
+            try:
+                result[k] = json.loads(v)
+            except (json.JSONDecodeError, TypeError):
+                result[k] = v
+    if key is not None:
+        result[key] = True
+    return result
+
+
+def _import_tool(tool_name: str):
+    """Import and return a tool instance by name."""
+    from luckyd_code.tools import get_default_registry
+    registry = get_default_registry()
+    tool = registry.get(tool_name)
+    if tool is None:
+        _console.print(f"Unknown tool: {tool_name}", style="red")
+        _console.print("\nAvailable tools:")
+        for t in sorted(registry._tools.keys()):
+            _console.print(f"  - {t}")
+        sys.exit(1)
+    return tool
+
+
+def cmd_info(tool_name: str):
+    """Show info about a tool."""
+    tool = _import_tool(tool_name)
+    _console.print(f"Tool: {tool.name}")
+    _console.print(f"Risk:  {tool.permission_risk}")
+    _console.print(f"Desc:  {tool.description}")
+    _console.print("Params:")
+    props = tool.parameters.get("properties", {})
+    required = tool.parameters.get("required", [])
+    for name, schema in props.items():
+        req = " (required)" if name in required else ""
+        desc = schema.get("description", "")
+        _console.print(f"  --{name}: {desc}{req}")
+
+
+def cmd_run(tool_name: str, *args):
+    """Run a tool with given arguments."""
+    tool = _import_tool(tool_name)
+    kwargs = _parse_args(list(args))
+    result = tool.run(**kwargs)
+    _console.print(result)
+
+
+def cmd_list():
+    """List all registered tools."""
+    from luckyd_code.tools import get_default_registry
+    registry = get_default_registry()
+    _console.print("=" * 60)
+    _console.print("Available Tools (via luckyd_code.tools_bridge)")
+    _console.print("=" * 60)
+    for name, tool in sorted(registry._tools.items()):
+        risk_icon = {"safe": "[SAFE]", "medium": "[MED]", "high": "[HIGH]"}.get(tool.permission_risk, "[?]")
+        _console.print(f"\n{risk_icon} {name}")
+        _console.print(f"   {tool.description[:120]}")
+    _console.print(f"\n{'=' * 60}")
+    _console.print("Usage: python -m luckyd_code.tools_bridge run <ToolName> [--key value ...]")
+    _console.print("         python -m luckyd_code.tools_bridge info <ToolName>")
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help"):
+        _console.print("deepseek-code Tools Bridge — expose internal tools as CLI")
+        _console.print()
+        _console.print("Usage:")
+        _console.print("  python -m luckyd_code.tools_bridge list")
+        _console.print("  python -m luckyd_code.tools_bridge info <ToolName>")
+        _console.print("  python -m luckyd_code.tools_bridge run <ToolName> [--key value ...]")
+        _console.print()
+        _console.print("Examples:")
+        _console.print('  python -m luckyd_code.tools_bridge run Bash --command "dir /b"')
+        _console.print('  python -m luckyd_code.tools_bridge run WebFetch --url https://example.com')
+        _console.print('  python -m luckyd_code.tools_bridge run BrowserNavigate --url https://github.com')
+        _console.print('  python -m luckyd_code.tools_bridge run BrainSearch --query "auth"')
+        _console.print('  python -m luckyd_code.tools_bridge run GitStatus')
+        return
+
+    command = sys.argv[1]
+    rest = sys.argv[2:]
+
+    if command == "list":
+        cmd_list()
+    elif command == "info":
+        if not rest:
+            _console.print("Usage: tools_bridge info <ToolName>", style="yellow")
+            sys.exit(1)
+        cmd_info(rest[0])
+    elif command == "run":
+        if not rest:
+            _console.print("Usage: tools_bridge run <ToolName> [--key value ...]", style="yellow")
+            sys.exit(1)
+        tool_name = rest[0]
+        cmd_run(tool_name, *rest[1:])
+    else:
+        _console.print(f"Unknown command: {command}", style="red")
+        _console.print("Available: list, info, run")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

luckyd_code/undo.py

@@ -0,0 +1,126 @@
+"""Undo support — track file changes and reverse them, with persistence."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Optional
+
+from ._data_dir import data_path
+
+UNDO_FILE = data_path("undo.json")
+
+_logger = logging.getLogger("luckyd_code.undo")
+
+
+class UndoEntry:
+    def __init__(self, file_path: str, original_content: str | None = None, action: str = ""):
+        self.file_path = file_path
+        self.original_content = original_content
+        self.action = action
+
+    def to_dict(self) -> dict:
+        return {
+            "file_path": self.file_path,
+            "original_content": self.original_content,
+            "action": self.action,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "UndoEntry":
+        return cls(
+            file_path=d.get("file_path", ""),
+            original_content=d.get("original_content"),
+            action=d.get("action", ""),
+        )
+
+
+_undo_stack: list[UndoEntry] = []
+
+
+def _save():
+    """Persist the undo stack to disk."""
+    try:
+        data = [e.to_dict() for e in _undo_stack]
+        UNDO_FILE.parent.mkdir(parents=True, exist_ok=True)
+        UNDO_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    except Exception:
+        _logger.warning("Failed to save undo history", exc_info=True)
+
+
+def _load():
+    """Load the undo stack from disk."""
+    global _undo_stack
+    try:
+        if UNDO_FILE.exists():
+            data = json.loads(UNDO_FILE.read_text(encoding="utf-8"))
+            _undo_stack = [UndoEntry.from_dict(d) for d in data]
+        else:
+            _undo_stack = []
+    except Exception:
+        _logger.warning("Failed to load undo history", exc_info=True)
+        _undo_stack = []
+
+
+def push(file_path: str, original_content: str | None = None, action: str = ""):
+    """Push an undo entry and persist."""
+    _undo_stack.append(UndoEntry(file_path, original_content, action))
+    _save()
+
+
+def pop() -> Optional[UndoEntry]:
+    """Pop and return the last undo entry."""
+    if _undo_stack:
+        entry = _undo_stack.pop()
+        _save()
+        return entry
+    return None
+
+
+def peek() -> Optional[UndoEntry]:
+    """Peek at the last undo entry without popping."""
+    if _undo_stack:
+        return _undo_stack[-1]
+    return None
+
+
+def clear():
+    """Clear all undo history."""
+    _undo_stack.clear()
+    _save()
+
+
+def undo_last() -> str:
+    """Undo the last file operation. Returns status message."""
+    entry = pop()
+    if not entry:
+        return "Nothing to undo."
+
+    path = Path(entry.file_path)
+    if not path.exists() and entry.original_content is None:
+        return f"Cannot undo: {entry.file_path} no longer exists (was created)"
+
+    try:
+        if entry.original_content is None:
+            path.unlink()
+            return f"Undone: deleted {entry.file_path} (was created by {entry.action})"
+        else:
+            path.write_text(entry.original_content, encoding="utf-8")
+            return f"Undone: restored {entry.file_path} to before {entry.action}"
+    except Exception as e:
+        return f"Undo failed: {e}"
+
+
+def get_history() -> list[dict]:
+    """Return readable history of undo entries."""
+    return [
+        {"file": e.file_path, "action": e.action}
+        for e in reversed(_undo_stack[-20:])
+    ]
+
+
+def count() -> int:
+    return len(_undo_stack)
+
+
+# Load existing history on import
+_load()

luckyd_code/update.py

@@ -0,0 +1,60 @@
+"""Auto-update module."""
+
+import subprocess
+
+def get_version() -> str:
+    from luckyd_code import __version__
+    return __version__
+
+
+def check_for_updates() -> str:
+    """Check if updates are available via git fetch."""
+    try:
+        subprocess.run(
+            ["git", "fetch", "--quiet"],
+            capture_output=True, text=True, timeout=30,
+        )
+        r = subprocess.run(
+            ["git", "rev-list", "--count", "HEAD..origin/HEAD"],
+            capture_output=True, text=True, timeout=30,
+        )
+        if r.returncode == 0 and r.stdout.strip():
+            count = int(r.stdout.strip())
+            if count > 0:
+                return f"{count} commit(s) behind. Run `/update` to pull."
+        r = subprocess.run(
+            ["git", "remote", "-v"],
+            capture_output=True, text=True, timeout=10,
+        )
+        if r.returncode == 0 and r.stdout.strip():
+            return "Up to date."
+        return "Not a git repository or no remote configured"
+    except Exception as e:
+        return f"Cannot check for updates: {e}"
+
+
+def do_update() -> str:
+    """Pull latest changes from git."""
+    try:
+        # Only stash if there are actual uncommitted changes, so we don't
+        # pop a stash the user created manually.
+        status = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True, text=True, timeout=15,
+        )
+        has_changes = bool(status.returncode == 0 and status.stdout.strip())
+
+        if has_changes:
+            subprocess.run(["git", "stash"], capture_output=True, text=True, timeout=30)
+
+        r = subprocess.run(
+            ["git", "pull"],
+            capture_output=True, text=True, timeout=60,
+        )
+
+        if has_changes:
+            subprocess.run(["git", "stash", "pop"], capture_output=True, text=True, timeout=30)
+
+        return r.stdout.strip() or r.stderr.strip() or "Updated successfully"
+    except Exception as e:
+        return f"Update failed: {e}"