luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/cli_commands/sessions.py

@@ -0,0 +1,41 @@
+"""Handle /sessions commands."""
+
+
+def handle_sessions_command(repl, args):
+    """Handle /sessions list|save|load|delete commands."""
+    from ..cli_utils import console
+    from ..sessions import save_session, load_session, list_sessions, delete_session
+
+    if not args:
+        console.print("[yellow]Usage: /sessions list|save <name>|load <name>|delete <name>[/yellow]")
+        return
+
+    sub = args[0].lower()
+
+    if sub == "list":
+        result = list_sessions()
+        console.print(result)
+
+    elif sub == "save":
+        name = " ".join(args[1:]) if len(args) > 1 else "unnamed"
+        result = save_session(name, repl.context)
+        console.print(f"[green]{result}[/green]")
+
+    elif sub == "load":
+        if len(args) < 2:
+            console.print("[yellow]Usage: /sessions load <name>[/yellow]")
+            return
+        name = " ".join(args[1:])
+        result = load_session(name, repl.context)
+        console.print(f"[cyan]{result}[/cyan]")
+
+    elif sub == "delete":
+        if len(args) < 2:
+            console.print("[yellow]Usage: /sessions delete <name>[/yellow]")
+            return
+        name = " ".join(args[1:])
+        result = delete_session(name)
+        console.print(f"[yellow]{result}[/yellow]")
+
+    else:
+        console.print(f"[red]Unknown: /sessions {sub}[/red]")

luckyd_code/cli_entry.py

@@ -0,0 +1,147 @@
+"""CLI entry point — argument parsing, first-run wizard, and main dispatch."""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+# Patch asyncio to allow nested event loops. This is needed because
+# BackgroundAgent / KnowledgeGraph initialisation may start a loop before
+# prompt_toolkit's synchronous session.prompt() runs, which would otherwise
+# raise: RuntimeError: asyncio.run() cannot be called from a running event loop
+try:
+    import nest_asyncio
+    nest_asyncio.apply()
+except ImportError:
+    pass  # Installed below; safe to ignore on first import before pip install
+
+from .config import Config
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(
+        description="LuckyD Code — AI coding assistant in your terminal",
+    )
+    parser.add_argument("--model", default=None, help="Model to use (default: deepseek-v4-flash)")
+    parser.add_argument(
+        "--provider", default=None, choices=["deepseek"],
+        help="API provider (default: deepseek)",
+    )
+    parser.add_argument("--dir", default=None, help="Working directory (default: current)")
+    parser.add_argument("--temperature", type=float, default=None, help="Model temperature (default: 0.7)")
+    parser.add_argument("--system-prompt", default=None, help="Path to custom system prompt file")
+    parser.add_argument("--version", action="store_true", help="Show version and exit")
+    parser.add_argument("--update", action="store_true", help="Update to latest version and exit")
+    parser.add_argument("--web", action="store_true", help="Launch web UI server")
+    parser.add_argument("--port", type=int, default=8000, help="Web UI port (default: 8000)")
+    parser.add_argument("--host", default="0.0.0.0", help="Web UI host (default: 0.0.0.0)")
+    parser.add_argument(
+        "--daemon", action="store_true",
+        help="Start the background audit daemon alongside the REPL",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv=None):
+    args = parse_args(argv)
+
+    # Lazy imports — only load the heavy CLI/web modules when actually running
+    from .update import get_version, do_update
+
+    if args.version:
+        print(f"LuckyD Code v{get_version()}")
+        return 0
+
+    if args.update:
+        print("Updating LuckyD Code...")
+        print(do_update())
+        return 0
+
+    if args.web:
+        from .web_app import run_web
+        try:
+            run_web(host=args.host, port=args.port)
+        except ValueError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+        return 0
+
+    if args.dir:
+        os.chdir(args.dir)
+
+    config = Config.from_args(args)
+
+    if args.system_prompt:
+        try:
+            with open(args.system_prompt, encoding="utf-8") as f:
+                custom = f.read().strip()
+            if custom:
+                config.system_prompt = custom
+        except Exception as e:
+            print(f"Warning: could not load system prompt from {args.system_prompt}: {e}", file=sys.stderr)
+
+    # First-run wizard: interactive API key setup
+    if not config.api_key:
+        print()
+        print("=" * 50)
+        print("  Welcome to LuckyD Code!")
+        print("=" * 50)
+        print()
+        print("No API key found. Let's get you set up.")
+        print()
+        print("You'll need a DeepSeek API key.")
+        print("  Get one at: https://platform.deepseek.com")
+        print()
+        print("Paste your API key below (it will be saved to .env):")
+        try:
+            key = input("  DEEPSEEK_API_KEY = ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n\nSetup cancelled. Run again when you have an API key.")
+            return 1
+        if key:
+            env_path = Path(__file__).resolve().parent.parent / ".env"
+            if "DEEPSEEK_API_KEY=" in (env_path.read_text() if env_path.exists() else ""):
+                lines = env_path.read_text().splitlines()
+                new_lines = []
+                for line in lines:
+                    if line.startswith("DEEPSEEK_API_KEY="):
+                        new_lines.append(f"DEEPSEEK_API_KEY={key}")
+                    else:
+                        new_lines.append(line)
+                env_path.write_text("\n".join(new_lines) + "\n")
+            else:
+                with env_path.open("a") as f:
+                    f.write(f"\nDEEPSEEK_API_KEY={key}\n")
+            config.api_key = key
+            print("✓ API key saved to .env")
+        else:
+            print("No key entered. Set DEEPSEEK_API_KEY in .env and try again.")
+            return 1
+        print()
+
+    try:
+        config.validate()
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    from .cli import Repl
+    daemon_enabled = getattr(args, "daemon", False)
+    repl = Repl(config, daemon=daemon_enabled)
+    try:
+        repl.run()
+    except KeyboardInterrupt:
+        print("\nGoodbye!")
+        return 0
+    except Exception as exc:
+        # ── Error Reporter: safe, opt-in issue creation ──────────
+        # This only fires for *unexpected* exceptions (not KeyboardInterrupt).
+        # The user is prompted before anything is sent.  See error_reporter.py.
+        from .error_reporter import capture_unhandled
+        capture_unhandled(exc)
+        raise  # re-raise so the process exits with a non-zero code
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

luckyd_code/cli_utils.py

@@ -0,0 +1,112 @@
+"""Shared I/O utilities for the CLI REPL."""
+
+import logging
+import sys
+import time as _time
+from typing import Optional
+
+from rich.console import Console
+
+from . import settings as cfg
+
+console = Console()
+_logger = logging.getLogger("luckyd_code.cli_utils")
+
+
+def play_completion_sound(success: bool = True):
+    """Play a notification sound when a response completes."""
+    try:
+        settings = cfg.load_settings()
+        enabled = settings.get("completion_sound", True)
+        if not enabled:
+            return
+
+        if sys.platform == "win32":
+            import winsound
+            if success:
+                winsound.PlaySound("SystemExclamation", winsound.SND_ALIAS | winsound.SND_ASYNC | winsound.SND_NODEFAULT)
+            else:
+                winsound.PlaySound("SystemHand", winsound.SND_ALIAS | winsound.SND_ASYNC | winsound.SND_NODEFAULT)
+        else:
+            if success:
+                sys.stdout.write("\a")
+            else:
+                for _ in range(3):
+                    sys.stdout.write("\a")
+                    _time.sleep(0.08)
+            sys.stdout.flush()
+    except Exception:
+        _logger.debug("Completion sound failed, falling back to terminal bell", exc_info=True)
+        try:
+            if success:
+                sys.stdout.write("\a")
+            else:
+                for _ in range(3):
+                    sys.stdout.write("\a")
+                    _time.sleep(0.08)
+            sys.stdout.flush()
+        except Exception:
+            _logger.debug("Terminal bell also failed")
+
+
+def init_prompt_session():
+    """Create prompt session with custom keybindings."""
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.history import FileHistory
+    from .keybindings import apply_keybindings
+
+    try:
+        return PromptSession(
+            history=FileHistory(".luckyd_history"),
+            key_bindings=apply_keybindings(),
+            multiline=True,
+        )
+    except Exception:
+        _logger.debug("PromptSession creation failed, trying fallback", exc_info=True)
+
+    try:
+        from prompt_toolkit.output.vt100 import Vt100_Output
+        from prompt_toolkit.data_structures import Size
+        import shutil
+
+        def _get_size():
+            ts = shutil.get_terminal_size()
+            return Size(rows=ts.lines, columns=ts.columns)
+
+        return PromptSession(
+            history=FileHistory(".luckyd_history"),
+            key_bindings=apply_keybindings(),
+            output=Vt100_Output(sys.stdout, get_size=_get_size),
+            multiline=True,
+        )
+    except Exception:
+        _logger.warning("Failed to create prompt session", exc_info=True)
+        return None
+
+
+def read_input(session) -> Optional[str]:
+    """Read a line of input from the user."""
+    if session:
+        try:
+            return session.prompt(">>> ")
+        except KeyboardInterrupt:
+            return None
+        except EOFError:
+            return "__EOF__"
+
+    try:
+        lines = []
+        while True:
+            line = input(">>> " if not lines else "... ")
+            if line.rstrip().endswith("\\"):
+                lines.append(line.rstrip()[:-1])
+            else:
+                lines.append(line)
+                break
+        return "\n".join(lines)
+    except EOFError:
+        if lines:
+            return "\n".join(lines)
+        return "__EOF__"
+    except KeyboardInterrupt:
+        return None

luckyd_code/config.py

@@ -0,0 +1,205 @@
+"""Configuration management with validation and file persistence."""
+
+import os
+import json
+from pathlib import Path
+from typing import Any
+
+from .log import get_logger
+from ._data_dir import data_path, legacy_path
+
+DEFAULT_SYSTEM_PROMPT = """You are LuckyD Code, an AI coding assistant in a terminal.
+
+You can answer ANY question — coding, general knowledge, everyday questions, or anything else the user asks. You are a helpful general-purpose assistant who happens to specialise in code.
+
+## Core Rules
+- For coding tasks: use Bash/Read/Write/Edit/Glob/Grep tools as needed, working directory is the project root
+- For general questions: answer directly and concisely from your knowledge
+- Think step by step, but only show the final answer
+- No unnecessary padding, greetings, or filler — just useful output
+
+## Pre-Edit Checklist (MANDATORY before any Write/Edit)
+1. **Read the file first** — Never edit a file you haven't read this turn
+2. **Understand the context** — Check how the code is used elsewhere (Grep for callers/imports)
+3. **Match existing patterns** — Follow the project's conventions, naming, style
+4. **Plan the minimal change** — Only touch what's necessary; no refactoring sprees
+5. **Preview mentally** — What will break? What edge cases exist?
+
+## Post-Edit Verification
+After every Write or Edit:
+- Your changes will be automatically verified (syntax, consistency, tests)
+- If verification fails, you MUST fix the issues — don't ignore them
+- Tests failing after your change? Fix them immediately
+
+## Self-Critique
+Before presenting your final answer, review it:
+- Did I actually solve the user's problem?
+- Could this be done more simply?
+- Are there edge cases I missed?
+- Is the code safe (no injection, no leaked secrets)?
+
+## Quality Standards
+- **Correctness over cleverness** — Working code beats elegant code
+- **Minimal diffs** — Small, focused changes are easier to review and revert
+- **Error handling** — Don't let errors pass silently
+- **No dead code** — Remove unused imports, variables, functions
+- **Type safety** — Use type hints where the project uses them"""
+
+CONFIG_FILE = data_path("config.json")
+_LEGACY_CONFIG_FILE = legacy_path("config.json")
+
+
+def load_config_file() -> dict[str, Any]:
+    """Load persistent config from the data directory.
+
+    Checks the primary location first, then falls back to the legacy
+    location for backward compatibility.
+    """
+    for path in (CONFIG_FILE, _LEGACY_CONFIG_FILE):
+        if path.exists():
+            try:
+                return json.loads(path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError) as e:
+                get_logger().warning(f"Could not load config file: {e}")
+    return {}
+
+
+def save_config_file(config: dict):
+    """Save config to the data directory."""
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        CONFIG_FILE.write_text(json.dumps(config, indent=2), encoding="utf-8")
+    except OSError as e:
+        get_logger().warning(f"Could not save config file: {e}")
+
+
+class Config:
+    """Application configuration with validation."""
+
+    def __init__(self):
+        saved = load_config_file()
+
+        self.provider: str = saved.get("provider", "deepseek")
+        self.base_url: str = saved.get("base_url", "https://api.deepseek.com/v1")
+        self.api_key: str = self._resolve_api_key()
+        self.model: str = saved.get("model", "deepseek-v4-flash")
+        self.max_tokens: int = saved.get("max_tokens", 4096)
+        self.temperature: float = saved.get("temperature", 0.7)
+        self.system_prompt: str = saved.get("system_prompt", DEFAULT_SYSTEM_PROMPT)
+        self.working_directory: str = saved.get("working_directory", os.getcwd())
+        self.max_context_messages: int = saved.get("max_context_messages", 100)
+        self.log_level: str = saved.get("log_level", "INFO")
+
+    def _resolve_api_key(self) -> str:
+        provider_env = f"{self.provider.upper()}_API_KEY"
+        for path in (Path(__file__).parent.parent / ".env", Path(".env")):
+            if path.exists():
+                try:
+                    lines = path.read_text().splitlines()
+                    for line in lines:
+                        line = line.strip()
+                        # Match both DEEPSEEK_API_KEY and <PROVIDER>_API_KEY
+                        if line.startswith(f"{provider_env}="):
+                            return line.split("=", 1)[1].strip("\"'")
+                        if line.startswith("DEEPSEEK_API_KEY=") and self.provider == "deepseek":
+                            return line.split("=", 1)[1].strip("\"'")
+                except Exception:
+                    get_logger().warning("Could not read .env file: %s", path, exc_info=True)
+
+        # Fallback: environment variables (provider-specific first, then legacy)
+        key = os.environ.get(provider_env) or os.environ.get("DEEPSEEK_API_KEY")
+        if key:
+            return key
+        return ""
+
+    def validate(self):
+        """Validate config and raise ValueError with clear message on failure."""
+        errors = []
+
+        # Supported providers (must match _provider_urls in from_args)
+        _valid_providers = {"deepseek"}
+        if self.provider not in _valid_providers:
+            errors.append(
+                f"provider must be one of {sorted(_valid_providers)} (got: {self.provider})"
+            )
+
+        if not self.api_key:
+            key_env = f"{self.provider.upper()}_API_KEY"
+            errors.append(
+                f"{key_env} is not set. "
+                "Set it as an environment variable or in a .env file."
+            )
+
+        if not self.base_url:
+            errors.append("base_url is not set")
+        elif not self.base_url.startswith(("http://", "https://")):
+            errors.append(f"base_url must start with http:// or https:// (got: {self.base_url})")
+
+        if self.max_tokens < 1 or self.max_tokens > 32000:
+            errors.append(f"max_tokens must be between 1 and 32000 (got: {self.max_tokens})")
+
+        if self.temperature < 0 or self.temperature > 2:
+            errors.append(f"temperature must be between 0 and 2 (got: {self.temperature})")
+
+        if self.max_context_messages < 2:
+            errors.append(f"max_context_messages must be at least 2 (got: {self.max_context_messages})")
+
+        if errors:
+            raise ValueError("\n".join(errors))
+
+    def to_dict(self) -> dict:
+        """Export config as dict (excluding API key)."""
+        return {
+            "provider": self.provider,
+            "base_url": self.base_url,
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "max_context_messages": self.max_context_messages,
+            "log_level": self.log_level,
+        }
+
+    def save(self):
+        """Persist current config (excluding API key) to config file."""
+        save_config_file(self.to_dict())
+
+    @classmethod
+    def from_args(cls, args=None):
+        cfg = cls()
+        if args:
+            if hasattr(args, "model") and args.model:
+                cfg.model = args.model
+            if hasattr(args, "temperature") and args.temperature is not None:
+                cfg.temperature = args.temperature
+            if hasattr(args, "system_prompt") and args.system_prompt:
+                cfg.system_prompt = args.system_prompt
+            if hasattr(args, "dir") and args.dir:
+                cfg.working_directory = args.dir
+            if hasattr(args, "provider") and args.provider:
+                cfg.provider = args.provider
+                # Only override base_url if none was persisted — derive it
+                # from the provider name rather than hardcoding DeepSeek.
+                if "base_url" not in load_config_file():
+                    _provider_urls = {
+                        "deepseek": "https://api.deepseek.com/v1",
+                    }
+                    cfg.base_url = _provider_urls.get(
+                        cfg.provider, cfg.base_url
+                    )
+                # Re-resolve key now that provider is set from args
+                cfg.api_key = cfg._resolve_api_key()
+        return cfg
+
+
+# ---------------------------------------------------------------------------
+# Module-level convenience helpers (used by generator tools)
+# ---------------------------------------------------------------------------
+
+def get_api_key() -> str:
+    """Return the resolved DeepSeek API key."""
+    return Config()._resolve_api_key()
+
+
+def get_base_url() -> str:
+    """Return the configured API base URL."""
+    return Config().base_url