luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/indexer.py

@@ -0,0 +1,280 @@
+"""Smart project indexing — scan project structure and inject into context."""
+
+import os
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+from .log import get_logger
+
+
+def _load_gitignore(path: Path) -> list[str]:
+    """Load .gitignore patterns."""
+    patterns = []
+    gitignore = path / ".gitignore"
+    if gitignore.exists():
+        try:
+            for line in gitignore.read_text(encoding="utf-8").splitlines():
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    patterns.append(line)
+        except Exception:
+            get_logger().warning("Could not load .gitignore", exc_info=True)
+    return patterns
+
+
+def _is_ignored(name: str, patterns: list[str]) -> bool:
+    """Check if a name matches gitignore patterns."""
+    for p in patterns:
+        if p.endswith("/") and name == p.rstrip("/"):
+            return True
+        if name == p:
+            return True
+        if p.startswith("*.") and name.endswith(p[1:]):
+            return True
+    return False
+
+
+IGNORED_DIRS = {
+    ".git", "__pycache__", "node_modules", ".venv", "venv", "env",
+    ".tox", ".eggs", "dist", "build", ".next", ".nuxt",
+    "target", "vendor", ".bundle", ".claude", ".vscode", ".idea",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache",
+}
+
+IGNORED_EXTS = {
+    ".pyc", ".pyo", ".so", ".o", ".class", ".jar",
+    ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg",
+    ".woff", ".woff2", ".ttf", ".eot",
+    ".zip", ".tar", ".gz", ".rar", ".7z",
+    ".exe", ".msi", ".dmg", ".pkg",
+    ".log", ".tmp",
+}
+
+
+def scan_project(root: Path, max_depth: int = 3, max_items: int = 80) -> dict:
+    """Scan a project directory and return structured metadata."""
+    root = root.resolve()
+    gitignore_patterns = _load_gitignore(root)
+
+    info: dict[str, Any] = {
+        "name": root.name,
+        "path": str(root),
+        "languages": set(),
+        "frameworks": [],
+        "config_files": {},
+        "file_tree": [],
+        "dependency_files": [],
+        "entry_points": [],
+        "total_files": 0,
+    }
+
+    dirs_to_scan = [(root, 0)]
+    scanned = 0
+
+    while dirs_to_scan and scanned < max_items:
+        current, depth = dirs_to_scan.pop(0)
+
+        if depth > max_depth:
+            continue
+
+        try:
+            entries = sorted(current.iterdir(), key=lambda x: (not x.is_dir(), x.name))
+        except PermissionError:
+            continue
+
+        indent = "  " * depth
+        for entry in entries:
+            if scanned >= max_items:
+                break
+
+            name = entry.name
+            if name in IGNORED_DIRS or _is_ignored(name, gitignore_patterns):
+                continue
+
+            if entry.is_dir():
+                if not name.startswith(".") and not name.endswith(".egg-info"):
+                    info["file_tree"].append(f"{indent}{name}/")
+                    dirs_to_scan.append((entry, depth + 1))
+                    scanned += 1
+            else:
+                ext = entry.suffix.lower()
+                if ext in IGNORED_EXTS:
+                    continue
+
+                info["file_tree"].append(f"{indent}{name}")
+                info["total_files"] += 1
+                scanned += 1
+
+                # Detect language
+                lang = _detect_language(ext)
+                if lang:
+                    info["languages"].add(lang)
+
+                # Detect dependency files
+                if name in ("package.json", "pyproject.toml", "Cargo.toml",
+                            "requirements.txt", "Gemfile", "go.mod", "CMakeLists.txt",
+                            "composer.json", "Pipfile", "build.gradle", "pom.xml"):
+                    info["dependency_files"].append(name)
+                    deps = _extract_deps(entry, name)
+                    if deps:
+                        info["config_files"][name] = deps
+
+                # Detect entry points
+                if name in ("main.py", "index.js", "app.js", "cli.py",
+                            "main.go", "main.rs", "index.ts", "app.ts"):
+                    info["entry_points"].append(str(entry.relative_to(root)))
+
+    # Detect framework
+    info["frameworks"] = _detect_frameworks(info["config_files"], info["dependency_files"])
+
+    # Convert languages set to sorted list
+    info["languages"] = sorted(info["languages"])
+
+    return info
+
+
+def _detect_language(ext: str) -> Optional[str]:
+    mapping = {
+        ".py": "Python", ".pyi": "Python",
+        ".js": "JavaScript", ".jsx": "JavaScript/JSX",
+        ".ts": "TypeScript", ".tsx": "TypeScript/TSX",
+        ".rs": "Rust",
+        ".go": "Go",
+        ".java": "Java",
+        ".kt": "Kotlin",
+        ".rb": "Ruby",
+        ".php": "PHP",
+        ".c": "C", ".h": "C",
+        ".cpp": "C++", ".hpp": "C++", ".cc": "C++",
+        ".cs": "C#",
+        ".swift": "Swift",
+        ".toml": "TOML", ".yaml": "YAML", ".yml": "YAML",
+        ".json": "JSON", ".html": "HTML", ".css": "CSS",
+        ".md": "Markdown",
+        ".sql": "SQL",
+        ".sh": "Shell", ".bat": "Batch",
+        ".pl": "Perl",
+        ".lua": "Lua",
+        ".r": "R",
+        ".scala": "Scala",
+    }
+    return mapping.get(ext)
+
+
+def _detect_frameworks(config_files: dict, dep_files: list) -> list[str]:
+    frameworks = []
+    for fname, deps in config_files.items():
+        deps_lower = {d.lower() for d in deps}
+        # Python
+        if "django" in deps_lower:
+            frameworks.append("Django")
+        if "flask" in deps_lower:
+            frameworks.append("Flask")
+        if "fastapi" in deps_lower:
+            frameworks.append("FastAPI")
+        # JS/TS
+        if "react" in deps_lower or "next" in deps_lower:
+            frameworks.append("React/Next.js")
+        if "vue" in deps_lower:
+            frameworks.append("Vue")
+        if "express" in deps_lower or "@nestjs/core" in deps_lower:
+            frameworks.append("Express/NestJS")
+        if "tailwindcss" in deps_lower:
+            frameworks.append("Tailwind CSS")
+        # Rust
+        if "actix-web" in deps_lower or "axum" in deps_lower:
+            frameworks.append("Actix/Axum")
+        # Other
+        if "spring-boot" in deps_lower:
+            frameworks.append("Spring Boot")
+
+    return list(set(frameworks))
+
+
+def _extract_deps(filepath: Path, name: str) -> list[str]:
+    """Extract dependency names from a config file."""
+    try:
+        if name == "package.json":
+            data = json.loads(filepath.read_text(encoding="utf-8"))
+            return list(data.get("dependencies", {}).keys()) + list(data.get("devDependencies", {}).keys())
+        elif name == "pyproject.toml":
+            content = filepath.read_text(encoding="utf-8")
+            deps = []
+            for line in content.splitlines():
+                line = line.strip()
+                if "=" in line and not line.startswith("[") and not line.startswith("#"):
+                    parts = line.split("=")
+                    key = parts[0].strip().strip('"').strip("'")
+                    if key and not key.startswith("_"):
+                        deps.append(key)
+            return deps[:30]
+        elif name == "requirements.txt":
+            content = filepath.read_text(encoding="utf-8")
+            deps = []
+            for line in content.splitlines():
+                line = line.strip()
+                if line and not line.startswith("#") and not line.startswith("-"):
+                    dep = line.split(">=")[0].split("==")[0].split("~=")[0].strip()
+                    deps.append(dep)
+            return deps[:30]
+        elif name == "Cargo.toml":
+            content = filepath.read_text(encoding="utf-8")
+            deps = []
+            in_deps = False
+            for line in content.splitlines():
+                line = line.strip()
+                if line == "[dependencies]":
+                    in_deps = True
+                    continue
+                if in_deps and line.startswith("["):
+                    break
+                if in_deps and "=" in line:
+                    dep = line.split("=")[0].strip().strip('"').strip("'")
+                    if dep:
+                        deps.append(dep)
+            return deps[:20]
+    except Exception:
+        get_logger().warning("Could not extract dependencies from %s", name, exc_info=True)
+    return []
+
+
+def format_project_context(info: dict) -> str:
+    """Format project info into a concise context string for the AI."""
+    parts = [f"# Project: {info['name']}"]
+
+    if info["languages"]:
+        parts.append(f"Languages: {', '.join(info['languages'])}")
+
+    if info["frameworks"]:
+        parts.append(f"Frameworks: {', '.join(info['frameworks'])}")
+
+    if info["entry_points"]:
+        parts.append(f"Entry points: {', '.join(info['entry_points'])}")
+
+    if info["dependency_files"]:
+        parts.append(f"Config files: {', '.join(info['dependency_files'])}")
+
+    if info["total_files"]:
+        parts.append(f"Total source files: {info['total_files']}")
+
+    # File tree
+    if info["file_tree"]:
+        parts.append("\nFile tree:")
+        parts.append("\n".join(info["file_tree"]))
+
+    return "\n".join(parts)
+
+
+def index_project(project_dir: str = None) -> str:
+    """Scan a project and return formatted context. Runs in <1s."""
+    if project_dir:
+        root = Path(project_dir).resolve()
+    else:
+        root = Path(os.getcwd()).resolve()
+
+    if not root.exists():
+        return ""
+
+    info = scan_project(root)
+    return format_project_context(info)

luckyd_code/init.py

@@ -0,0 +1,39 @@
+"""Project initialization tool."""
+
+import os
+from pathlib import Path
+
+
+MEMORY_FILENAMES = ["MEMORY.md", "CLAUDE.md"]  # check both for backward compat
+
+DEFAULT_MEMORY_MD = """# MEMORY.md
+
+## Project Overview
+<!-- Describe what this project does -->
+
+## Tech Stack
+<!-- List the key technologies used -->
+
+## Development Setup
+<!-- How to get started -->
+
+## Commands
+<!-- Common commands for dev, test, build, lint -->
+
+## Guidelines
+<!-- Project-specific coding conventions -->
+"""
+
+
+def init_project():
+    """Initialize the project memory file (MEMORY.md).
+
+    Creates MEMORY.md if neither MEMORY.md nor CLAUDE.md exists.
+    """
+    cwd = Path(os.getcwd())
+    for name in MEMORY_FILENAMES:
+        if (cwd / name).exists():
+            return f"{name} already exists."
+    path = cwd / "MEMORY.md"
+    path.write_text(DEFAULT_MEMORY_MD, encoding="utf-8")
+    return "Created MEMORY.md. Edit it with project-specific instructions."

luckyd_code/keybindings.py

@@ -0,0 +1,77 @@
+"""Custom keybinding support."""
+
+import json
+from pathlib import Path
+
+from .log import get_logger
+
+from prompt_toolkit.key_binding import KeyBindings
+
+
+DEFAULT_BINDINGS = {
+    "submit": "enter",
+    "newline": "alt-enter",
+    "cancel": "ctrl-c",
+    "history-up": "ctrl-p",
+    "history-down": "ctrl-n",
+}
+
+
+from ._data_dir import data_path
+
+
+def get_keybindings_path() -> Path:
+    return data_path("keybindings.json")
+
+
+def load_keybindings() -> dict:
+    path = get_keybindings_path()
+    if path.exists():
+        try:
+            data = json.loads(path.read_text())
+            if isinstance(data, dict):
+                return data
+        except Exception:
+            get_logger().warning("Could not load keybindings from %s", path, exc_info=True)
+    return {}
+
+
+def _parse_key_sequence(key: str) -> tuple:
+    """Convert a key string into a tuple of prompt_toolkit key names.
+
+    prompt_toolkit does not understand 'alt-X' — alt combos must be passed
+    as the two-key sequence ('escape', 'X').
+    """
+    if key.startswith("alt-"):
+        remainder = key[4:]  # e.g. 'enter', 'a', etc.
+        return ("escape", remainder)
+    return (key,)
+
+
+def apply_keybindings() -> KeyBindings:
+    """Create KeyBindings from config file, falling back to defaults."""
+    user = load_keybindings()
+    bindings = {**DEFAULT_BINDINGS, **user}
+
+    kb = KeyBindings()
+
+    submit_key = bindings.get("submit", "enter")
+    newline_key = bindings.get("newline", "alt-enter")
+
+    # Enter submits the prompt (works even in multiline mode)
+    try:
+        @kb.add(*_parse_key_sequence(submit_key))
+        def _submit(event):
+            event.current_buffer.validate_and_handle()
+    except Exception:
+        get_logger().warning("Failed to register submit keybinding '%s'", submit_key, exc_info=True)
+
+    # Alt+Enter inserts a newline
+    try:
+        @kb.add(*_parse_key_sequence(newline_key))
+        def _newline(event):
+            event.current_buffer.insert_text("\n")
+    except Exception:
+        get_logger().warning("Failed to register newline keybinding '%s'", newline_key, exc_info=True)
+
+    return kb

luckyd_code/log.py

@@ -0,0 +1,55 @@
+"""Structured logging for DeepSeek Code."""
+
+import sys
+import logging
+from pathlib import Path
+from datetime import datetime
+
+from ._data_dir import data_path
+
+_LOG_DIR = data_path("logs")
+_initialized = False
+
+
+def setup_logging(level: str = "INFO", log_file: str | None = None) -> logging.Logger:
+    """Initialize logging system. Safe to call multiple times."""
+    global _initialized
+
+    logger = logging.getLogger("luckyd_code")
+    if _initialized:
+        return logger
+
+    logger.setLevel(getattr(logging, level.upper(), logging.INFO))
+
+    # Console handler (warnings and above)
+    console = logging.StreamHandler(sys.stderr)
+    console.setLevel(logging.WARNING)
+    console.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+    logger.addHandler(console)
+
+    # File handler (all levels)
+    if log_file:
+        log_path = Path(log_file)
+    else:
+        _LOG_DIR.mkdir(parents=True, exist_ok=True)
+        log_path = _LOG_DIR / f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+
+    try:
+        fh = logging.FileHandler(str(log_path), encoding="utf-8")
+        fh.setLevel(getattr(logging, level.upper(), logging.INFO))
+        fh.setFormatter(logging.Formatter(
+            "%(asctime)s [%(levelname)s] %(message)s",
+            datefmt="%H:%M:%S",
+        ))
+        logger.addHandler(fh)
+        logger.info(f"Logging initialized: {log_path}")
+    except Exception as e:
+        logger.warning(f"Could not create log file: {e}")
+
+    _initialized = True
+    return logger
+
+
+def get_logger() -> logging.Logger:
+    """Get the project logger. Initializes with defaults if not already set up."""
+    return setup_logging()

luckyd_code/mcp/__init__.py

@@ -0,0 +1,6 @@
+"""Model Context Protocol (MCP) support — extend DeepSeek Code with custom tools."""
+from .client import MCPManager
+
+__all__ = [
+    "MCPManager",
+]

luckyd_code/mcp/client.py

@@ -0,0 +1,184 @@
+"""Basic MCP (Model Context Protocol) client.
+
+Connects to MCP servers via stdio JSON-RPC and registers their tools.
+MCP spec: https://modelcontextprotocol.io
+"""
+
+import json
+import logging
+import subprocess
+import time
+from typing import Any, Optional, cast
+
+logger = logging.getLogger("luckyd_code.mcp")
+
+
+class MCPServer:
+    """A connected MCP server with health checks and reconnection."""
+
+    def __init__(self, name: str, command: str, args: list[str] | None = None):
+        self.name = name
+        self.command = command
+        self.args = args or []
+        self.process: Optional[subprocess.Popen] = None
+        self.tools: list[dict] = []
+        self._request_id = 0
+        self._max_retries = 2
+
+    def connect(self):
+        """Start the MCP server process."""
+        try:
+            import sys
+            # On Windows, use shell=True for .cmd/.bat files (like npx, which is npx.cmd)
+            use_shell = sys.platform == "win32"
+            self.process = subprocess.Popen(
+                [self.command] + self.args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                shell=use_shell,
+            )
+            # Poll stderr in a non-blocking way — log any startup errors
+            import threading
+            def _log_stderr(proc):
+                for line in iter(proc.stderr.readline, ""):
+                    if line:
+                        logger.debug("[mcp:%s] %s", self.name, line.rstrip())
+            t = threading.Thread(target=_log_stderr, args=(self.process,), daemon=True)
+            t.start()
+        except Exception as e:
+            return f"Failed to start MCP server '{self.name}': {e}"
+        return None
+
+    def _ensure_running(self) -> bool:
+        """Check if the server is running and attempt reconnect if not."""
+        if self.process and self.process.poll() is None:
+            return True
+        # Attempt reconnection
+        for attempt in range(self._max_retries):
+            logger.info("Reconnecting MCP server '%s' (attempt %d/%d)",
+                        self.name, attempt + 1, self._max_retries)
+            self.process = None
+            error = self.connect()
+            if error is None:
+                # Rediscover tools
+                self.tools = self.list_tools()
+                return True
+            time.sleep(1)
+        return False
+
+    def _send_request(self, method: str, params: dict[str, object] | None = None) -> dict[str, object]:
+        """Send a JSON-RPC request and get response."""
+        if not self._ensure_running():
+            return {"error": "Server not running"}
+
+        self._request_id += 1
+        request = {
+            "jsonrpc": "2.0",
+            "id": self._request_id,
+            "method": method,
+            "params": params or {},
+        }
+
+        try:
+            if self.process is None or self.process.stdin is None or self.process.stdout is None:
+                return {"error": "Server process not available"}
+            self.process.stdin.write(json.dumps(request) + "\n")
+            self.process.stdin.flush()
+            line = self.process.stdout.readline()
+            if not line:
+                return {"error": "Empty response from server"}
+            result: dict[str, object] = json.loads(line)
+            return result
+        except Exception as e:
+            logger.warning("MCP request error for '%s': %s", self.name, e)
+            return {"error": str(e)}
+
+    def list_tools(self) -> list[dict[str, object]]:
+        """List available tools from this server."""
+        response = self._send_request("tools/list")
+        if "error" in response:
+            return []
+        result: dict[str, object] = cast(dict[str, object], response.get("result", {}))
+        tools: list[dict[str, object]] = cast(list[dict[str, object]], result.get("tools", []))
+        return tools
+
+    def call_tool(self, name: str, arguments: dict[str, Any]) -> str:
+        """Call a tool on this server."""
+        response = self._send_request("tools/call", {
+            "name": name,
+            "arguments": arguments,
+        })
+        if "error" in response:
+            return f"MCP error: {response['error']}"
+        result: dict[str, object] = cast(dict[str, object], response.get("result", {}))
+        content: list[dict[str, object]] = cast(list[dict[str, object]], result.get("content", []))
+        return "\n".join(
+            c.get("text", "") for c in content if c.get("type") == "text"
+        ) or json.dumps(content)
+
+    def close(self):
+        if self.process:
+            try:
+                self.process.terminate()
+                self.process.wait(timeout=5)
+            except Exception:
+                self.process.kill()
+            self.process = None
+
+
+class MCPManager:
+    """Manages MCP server connections."""
+
+    def __init__(self):
+        self.servers: list[MCPServer] = []
+
+    def load_from_config(self, config: dict):
+        """Load MCP servers from settings config."""
+        servers_config = config.get("mcpServers", {})
+        if not servers_config:
+            servers_config = config.get("mcp_servers", {})
+
+        for name, cfg in servers_config.items():
+            server = MCPServer(
+                name=name,
+                command=cfg.get("command", ""),
+                args=cfg.get("args", []),
+            )
+            error = server.connect()
+            if error:
+                logger.warning("Failed to start MCP server '%s': %s", name, error)
+                continue
+            server.tools = server.list_tools()
+            if server.tools:
+                self.servers.append(server)
+                logger.info("MCP server '%s' loaded with %d tools", name, len(server.tools))
+
+    def get_all_tools(self) -> list[dict]:
+        """Get all tools from all servers as OpenAI tool definitions."""
+        tools = []
+        for server in self.servers:
+            for tool in server.tools:
+                tools.append({
+                    "type": "function",
+                    "function": {
+                        "name": f"mcp_{tool['name']}",
+                        "description": tool.get("description", f"MCP tool: {tool['name']}"),
+                        "parameters": tool.get("inputSchema", {}),
+                    },
+                })
+        return tools
+
+    def execute(self, tool_name: str, arguments: dict) -> str:
+        """Execute a tool by its full name (mcp_<name>)."""
+        name = tool_name[len("mcp_"):] if tool_name.startswith("mcp_") else tool_name
+        for server in self.servers:
+            for tool in server.tools:
+                if tool["name"] == name:
+                    return server.call_tool(name, arguments)
+        return f"MCP tool '{name}' not found"
+
+    def close_all(self):
+        for server in self.servers:
+            server.close()

luckyd_code/memory/__init__.py

@@ -0,0 +1,19 @@
+from .manager import (
+    MemoryManager,
+    get_project_memory_dir,
+    load_claude_md,
+    save_claude_md,
+    load_memory_index,
+    save_memory,
+    list_memories,
+)
+
+__all__ = [
+    "MemoryManager",
+    "get_project_memory_dir",
+    "load_claude_md",
+    "save_claude_md",
+    "load_memory_index",
+    "save_memory",
+    "list_memories",
+]