luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/self_improve.py

@@ -0,0 +1,274 @@
+"""Self-improvement module — AI improves its own source code with git-based tracking."""
+
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+SELF_IMPROVE_PROMPT = """You are in SELF-IMPROVEMENT MODE. Your task is to analyze and improve the LuckyD Code project's own source code.
+
+You have full access to Read, Write, Edit, Glob, Grep, and Bash tools to explore and modify the codebase.
+
+CRITICAL RULES — FOLLOW EXACTLY:
+- NEVER write a file without running a syntax check immediately after
+- A syntax check failure means you MUST fix the file before proceeding
+- Do NOT make more than 3 files changes in a single session
+- Read a file BEFORE editing it, every time
+- If a test mock fails, first read the production code to verify it matches what the test expects before touching the test
+
+Follow this protocol strictly:
+
+STEP 1 — EXPLORE:
+- Use Glob and Grep to understand the project structure
+- Read key files to understand how modules work
+- Identify areas that need improvement
+
+STEP 2 — DIAGNOSE:
+- Find bugs, missing features, code quality issues, or performance problems
+- Check for error handling gaps, missing type hints, hardcoded values
+- Look for places where the web UI or CLI could be improved
+
+STEP 3 — PROPOSE:
+- State clearly what you want to change and why
+- Keep changes focused and minimal — max 3 files
+
+STEP 4 — IMPLEMENT:
+- Read the file first
+- Make the targeted change using Edit/Write
+- IMMEDIATELY run the syntax check (see STEP 5) — do NOT skip this
+
+STEP 5 — MANDATORY SYNTAX CHECK (after EVERY file write):
+  For each .py file you edited, run:
+    python -c "import py_compile; py_compile.compile('PATH_TO_FILE', doraise=True)"
+  If it fails: fix the file immediately before touching anything else.
+  Do NOT proceed to the next file until the current one passes.
+
+STEP 6 — REPORT:
+- Summarize what was changed and why
+- Note any follow-up improvements that could be made
+
+CHANGE TRACKING:
+- The system will automatically run tests and validate all changed files before committing
+- If tests fail, changes will NOT be committed — so getting syntax right is essential
+- You do NOT need to git commit — that is handled automatically
+
+Focus areas (in priority order):
+1. Bug fixes
+2. Missing error handling
+3. User-facing improvements (CLI + web UI)
+4. Performance
+5. Code quality (type hints, docs)
+"""
+
+
+def get_improvement_prompt(area: str = "") -> str:
+    """Get a targeted improvement prompt."""
+    if area == "web":
+        return "Focus on improving the web UI in web_app.py and templates/index.html. Add features, fix issues, improve the UX."
+    elif area == "cli":
+        return "Focus on improving the CLI experience in cli.py. Add commands, fix issues, improve UX."
+    elif area == "tools":
+        return "Focus on improving the tool implementations. Check for bugs, error handling, and missing features."
+    elif area == "refactor":
+        return (
+            "You are fixing a structural code smell (long function, deep nesting, too many parameters, "
+            "large class, high cyclomatic complexity, or large file). Your approach should be:\n"
+            "- For LONG FUNCTIONS: extract logical blocks into well-named helper functions\n"
+            "- For DEEP NESTING: use early returns, guard clauses, or extract nested logic\n"
+            "- For TOO MANY PARAMETERS: group related parameters into a dataclass or TypedDict\n"
+            "- For LARGE CLASSES: extract cohesive groups of methods into a new class using composition\n"
+            "- For HIGH COMPLEXITY: reduce branching (if/else chains → lookup dicts or polymorphism)\n"
+            "- For LARGE FILES: split into smaller modules by grouping related functions/classes\n"
+            "- Make MINIMAL changes — do NOT rewrite the whole file\n"
+            "- Preserve all existing behavior exactly — same logic, same return values\n"
+            "- After every edit, verify that imports are correct and all callers still work"
+        )
+    elif area == "perf":
+        return "Focus on performance improvements across the codebase. Look for caching opportunities, reduce API calls, optimize imports."
+    elif area == "cleanup":
+        return (
+            "You are fixing a lightweight code cleanliness issue. Your approach should be:\n"
+            "- For TODOs: remove stale ones, or replace with actionable comments linked to issues\n"
+            "- For empty files: remove them if genuinely dead code, or add a docstring explaining "
+            "why they exist (e.g., namespace package marker)\n"
+            "- For large non-code files: consider whether they can be compressed, split, or moved "
+            "out of the source tree\n"
+            "- Make MINIMAL changes — do NOT rewrite or refactor anything\n"
+            "- If removing a file, FIRST verify no other module imports or references it"
+        )
+    else:
+        return "Explore the codebase and find the most impactful improvements to make. Fix bugs first, then add value."
+
+
+# ------------------------------------------------------------------ #
+#  Git-based change tracking
+# ------------------------------------------------------------------ #
+
+@dataclass
+class ImprovementReport:
+    branch: str = ""
+    start_hash: str = ""
+    end_hash: str = ""
+    files_changed: list[str] = field(default_factory=list)
+    diff_summary: str = ""
+    commit_hash: str = ""
+    error: Optional[str] = None
+
+
+def _git(*args: str, cwd: Optional[str] = None) -> str:
+    """Run a git command and return stdout."""
+    try:
+        result = subprocess.run(
+            ["git"] + list(args),
+            capture_output=True,
+            text=True,
+            timeout=30,
+            cwd=cwd,
+        )
+        return result.stdout.strip()
+    except Exception as e:
+        return f"<error: {e}>"
+
+
+class ImprovementTracker:
+    """Track file changes made during a self-improvement session using git.
+
+    Usage::
+
+        tracker = ImprovementTracker(cwd)
+        before = tracker.snapshot()          # git stash of dirty files
+        # ... AI makes changes ...
+        report = tracker.report()            # git diff + optional commit
+    """
+
+    def __init__(self, cwd: Optional[str] = None):
+        self.cwd = cwd or str(Path.cwd())
+        self._branch = _git("rev-parse", "--abbrev-ref", "HEAD", cwd=self.cwd)
+        self._start_hash = _git("rev-parse", "--short", "HEAD", cwd=self.cwd)
+        self._stash_made = False
+        self._changes_before: set[str] = set()
+
+    def snapshot(self) -> str:
+        """Stash any uncommitted changes so the diff shows only AI-made changes.
+
+        Returns a status message.
+        """
+        # Record files that were dirty before AI starts
+        status = _git("status", "--porcelain", cwd=self.cwd)
+        if status:
+            self._changes_before = {
+                line.strip().split()[-1] for line in status.splitlines()
+                if line.strip()
+            }
+            # Stash to get a clean baseline
+            result = _git("stash", "push", "-m",
+                          "self-improve-before", cwd=self.cwd)
+            if "Saved" in result:
+                self._stash_made = True
+                stashed = len(self._changes_before)
+                return f"Stashed {stashed} dirty file(s) for clean diff"
+        return "Working tree was clean"
+
+    def report(self, commit: bool = False,
+               commit_msg: str = "") -> ImprovementReport:
+        """Generate a change report after the AI has made modifications.
+
+        Args:
+            commit: If True, commit the changes.
+            commit_msg: Commit message (auto-generated if empty).
+
+        Returns:
+            An ImprovementReport with diff, file list, and optional commit hash.
+        """
+        end_hash = _git("rev-parse", "--short", "HEAD", cwd=self.cwd)
+
+        # Get diff of unstaged + staged changes
+        unstaged = _git("diff", cwd=self.cwd)
+        staged = _git("diff", "--cached", cwd=self.cwd)
+        diff_text = unstaged + ("\n" if unstaged and staged else "") + staged
+
+        # Restore stashed dirty files so user doesn't lose them
+        if self._stash_made:
+            _git("stash", "pop", cwd=self.cwd)
+
+        # List changed files
+        changed = _git("diff", "--name-only", cwd=self.cwd)
+        files = [f for f in changed.splitlines() if f.strip()] if changed else []
+
+        # Filter out files that were already dirty before
+        new_files = [f for f in files if f not in self._changes_before]
+
+        # Build a concise summary
+        summary_lines = []
+        summary_lines.append(f"Branch: {self._branch}")
+        summary_lines.append(f"From:   {self._start_hash}")
+        summary_lines.append(f"To:     {end_hash}")
+        if new_files:
+            summary_lines.append(f"\nFiles changed ({len(new_files)}):")
+            for f in new_files:
+                # Show a one-line stat per file
+                stat = _git("diff", "--stat", "--", f, cwd=self.cwd)
+                short_stat = stat.split("\n")[-1].strip() if stat else f
+                summary_lines.append(f"  {short_stat}")
+        else:
+            summary_lines.append("\nNo new file changes detected")
+
+        if diff_text:
+            summary_lines.append(f"\n--- Diff ({len(diff_text)} chars) ---")
+            # Show first 30 lines of diff as preview
+            diff_lines = diff_text.splitlines()
+            preview = diff_lines[:30]
+            summary_lines.extend(preview)
+            if len(diff_lines) > 30:
+                summary_lines.append(f"... ({len(diff_lines) - 30} more lines)")
+
+        commit_hash = ""
+        if commit and new_files:
+            # Run verification pipeline on every changed Python file before committing.
+            # Any failure aborts the commit — changes stay as unstaged edits so
+            # nothing is lost, but main/branch history stays clean.
+            try:
+                from .verify import run_verify_pipeline, pipeline_all_passed, pipeline_feedback
+                for f in new_files:
+                    if f.endswith(".py"):
+                        abs_path = str(Path(self.cwd) / f)
+                        results = run_verify_pipeline(
+                            abs_path, self.cwd,
+                            run_lint=True, run_consistency=True, run_tests=False,
+                        )
+                        if not pipeline_all_passed(results):
+                            summary_lines.append(
+                                f"\n⚠ Verification failed for {f} — commit aborted"
+                            )
+                            summary_lines.append(pipeline_feedback(results))
+                            summary = "\n".join(summary_lines)
+                            return ImprovementReport(
+                                branch=self._branch,
+                                start_hash=self._start_hash,
+                                end_hash=end_hash,
+                                files_changed=new_files,
+                                diff_summary=summary,
+                                commit_hash="",
+                                error=f"Verification failed for {f}",
+                            )
+            except ImportError:
+                pass  # verify module unavailable — proceed without it
+
+            msg = commit_msg or f"self-improve: {', '.join(new_files[:3])}"
+            if len(new_files) > 3:
+                msg += f" (+{len(new_files) - 3} more)"
+            _git("add", *new_files, cwd=self.cwd)
+            _git("commit", "-m", msg, cwd=self.cwd)
+            commit_hash = _git("rev-parse", "--short", "HEAD", cwd=self.cwd)
+            summary_lines.append(f"\nCommitted as {commit_hash}")
+
+        summary = "\n".join(summary_lines)
+
+        return ImprovementReport(
+            branch=self._branch,
+            start_hash=self._start_hash,
+            end_hash=end_hash,
+            files_changed=new_files,
+            diff_summary=summary,
+            commit_hash=commit_hash,
+        )

luckyd_code/sessions.py

@@ -0,0 +1,114 @@
+"""Session save/load — persist and restore conversations."""
+
+import json
+import os
+from datetime import datetime
+
+from .context import ConversationContext
+
+from ._data_dir import data_path
+
+SESSIONS_DIR = data_path("sessions")
+
+
+def _ensure_dir():
+    SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _sanitize_name(name: str) -> str:
+    """Sanitize a session name for use as a filename."""
+    safe = "".join(c if c.isalnum() or c in " _-" else "_" for c in name)
+    return safe.strip() or "unnamed"
+
+
+def save_session(name: str, context: ConversationContext) -> str:
+    """Save current conversation to a session file."""
+    _ensure_dir()
+    safe = _sanitize_name(name)
+    path = SESSIONS_DIR / f"{safe}.json"
+
+    # Filter out the system prompt — it's re-applied from the live config on load,
+    # so storing it would restore a potentially stale prompt on future loads.
+    messages = [m for m in context.messages if m.get("role") != "system"]
+
+    data = {
+        "name": name,
+        "saved_at": datetime.now().isoformat(),
+        "message_count": len(messages),
+        "messages": messages,
+    }
+
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    return f"Session '{name}' saved ({len(messages)} messages)"
+
+
+def load_session(name: str, context: ConversationContext) -> str:
+    """Load a session into the current context."""
+    _ensure_dir()
+    safe = _sanitize_name(name)
+    path = SESSIONS_DIR / f"{safe}.json"
+
+    if not path.exists():
+        # Try partial match
+        matches = list(SESSIONS_DIR.glob(f"{safe}*.json"))
+        if not matches:
+            return f"Session '{name}' not found"
+        path = matches[0]
+
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as e:
+        return f"Error loading session: {e}"
+
+    messages = data.get("messages", [])
+    if not messages:
+        return "Session is empty"
+
+    # Preserve system prompt, replace everything else
+    system = context.messages[0] if context.messages else None
+    if messages[0].get("role") == "system":
+        context.messages = messages
+    else:
+        context.messages = [system] + messages if system else messages
+
+    # Re-apply max_messages
+    while len(context.messages) > context.max_messages:
+        context.messages.pop(1)
+
+    return f"Session '{data.get('name', name)}' loaded ({len(messages)} messages)"
+
+
+def list_sessions() -> str:
+    """List all saved sessions."""
+    _ensure_dir()
+    sessions = []
+    for path in sorted(SESSIONS_DIR.glob("*.json"), key=os.path.getmtime, reverse=True):
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            sessions.append({
+                "name": data.get("name", path.stem),
+                "saved_at": data.get("saved_at", "unknown"),
+                "count": data.get("message_count", 0),
+            })
+        except Exception:
+            sessions.append({"name": path.stem, "saved_at": "unknown", "count": 0})
+
+    if not sessions:
+        return "No saved sessions."
+
+    lines = []
+    for s in sessions:
+        time = s["saved_at"][:19] if s["saved_at"] != "unknown" else "unknown"
+        lines.append(f"  {s['name']:20s} ({s['count']} msgs, saved {time})")
+    return "\n".join(lines)
+
+
+def delete_session(name: str) -> str:
+    """Delete a saved session."""
+    _ensure_dir()
+    safe = _sanitize_name(name)
+    path = SESSIONS_DIR / f"{safe}.json"
+    if path.exists():
+        path.unlink()
+        return f"Session '{name}' deleted"
+    return f"Session '{name}' not found"

luckyd_code/settings.py

@@ -0,0 +1,72 @@
+"""settings.json and hooks support."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .log import get_logger
+from ._data_dir import project_data_path
+
+
+def get_settings_dir() -> Path:
+    return project_data_path()
+
+
+def get_settings_path() -> Path:
+    return get_settings_dir() / "settings.json"
+
+
+def get_local_settings_path() -> Path:
+    return get_settings_dir() / "settings.local.json"
+
+
+def load_settings() -> dict[str, Any]:
+    settings = {}
+    for p in [get_settings_path(), get_local_settings_path()]:
+        if p.exists():
+            try:
+                data = json.loads(p.read_text())
+                settings.update(data)
+            except Exception:
+                get_logger().warning("Could not load settings from %s", str(p), exc_info=True)
+    return settings
+
+
+def save_setting(key: str, value):
+    path = get_local_settings_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    settings = {}
+    if path.exists():
+        try:
+            settings = json.loads(path.read_text())
+        except Exception:
+            get_logger().warning("Could not load existing settings from %s", str(path), exc_info=True)
+    settings[key] = value
+    path.write_text(json.dumps(settings, indent=2))
+
+
+def get_hooks() -> dict:
+    settings = load_settings()
+    return settings.get("hooks", {})
+
+
+def run_pre_hook(tool_name: str) -> list[str]:
+    hooks = get_hooks()
+    hook_cfg = hooks.get("preToolUse", "")
+    # Normalise: the hook may be a plain string or a dict with a 'script' key
+    if isinstance(hook_cfg, dict):
+        script = hook_cfg.get("script", "")
+        # 'tools' is nested inside the hook config, not at the top level
+        allowed_tools = hook_cfg.get("tools", ["all"])
+    else:
+        script = hook_cfg
+        allowed_tools = ["all"]
+    if script and ("all" in allowed_tools or tool_name in allowed_tools):
+        import subprocess
+        try:
+            r = subprocess.run(script, shell=True, capture_output=True, text=True, timeout=30)
+            if r.returncode != 0:
+                return [r.stderr.strip()]
+        except Exception as e:
+            return [str(e)]
+    return []

luckyd_code/skills/__init__.py

@@ -0,0 +1,8 @@
+"""Code review and security analysis skills."""
+from . import review
+from . import security
+
+__all__ = [
+    "review",
+    "security",
+]

luckyd_code/skills/review.py

@@ -0,0 +1,22 @@
+"""Code review skill."""
+
+import subprocess
+
+
+def review_changes() -> str:
+    """Review pending git changes."""
+    try:
+        diff = subprocess.run(
+            ["git", "diff", "HEAD"],
+            capture_output=True, text=True, timeout=30,
+        ).stdout
+        if not diff:
+            diff = subprocess.run(
+                ["git", "diff", "--cached"],
+                capture_output=True, text=True, timeout=30,
+            ).stdout
+        if not diff:
+            return "No changes to review."
+        return f"Changes to review:\n\n```diff\n{diff[:8000]}\n```"
+    except Exception as e:
+        return f"Error getting diff: {e}"

luckyd_code/skills/security.py

@@ -0,0 +1,17 @@
+"""Security review skill."""
+
+import subprocess
+
+
+def security_review() -> str:
+    """Analyze pending changes for security issues."""
+    try:
+        diff = subprocess.run(
+            ["git", "diff", "HEAD"],
+            capture_output=True, text=True, timeout=30,
+        ).stdout
+        if not diff:
+            return "No changes to review."
+        return f"Security review of changes:\n\n```diff\n{diff[:8000]}\n```"
+    except Exception as e:
+        return f"Error: {e}"

luckyd_code/tasks/__init__.py

@@ -0,0 +1 @@
+from .manager import create_task, update_task, list_tasks, get_task

luckyd_code/tasks/manager.py

@@ -0,0 +1,102 @@
+import uuid
+import json
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+_logger = logging.getLogger("luckyd_code.tasks")
+
+
+class Task:
+    def __init__(self, subject: str, description: str = "", task_id: str | None = None):
+        self.id = task_id or uuid.uuid4().hex[:8]
+        self.subject = subject
+        self.description = description
+        self.status = "pending"  # pending, in_progress, completed, deleted
+        self.blocked_by: list[str] = []
+        self.blocks: list[str] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "subject": self.subject,
+            "description": self.description,
+            "status": self.status,
+            "blocked_by": self.blocked_by,
+            "blocks": self.blocks,
+        }
+
+
+from .._data_dir import project_data_path
+
+
+def _get_db_path() -> Path:
+    p = project_data_path("tasks.json")
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _load_tasks() -> dict[str, dict[str, Any]]:
+    path = _get_db_path()
+    if path.exists():
+        try:
+            data: object = json.loads(path.read_text())
+            if isinstance(data, dict):
+                return data  # type: ignore[return-value]
+            return {}
+        except Exception:
+            _logger.warning("Failed to load tasks from %s", path, exc_info=True)
+            return {}
+    return {}
+
+
+def _save_tasks(tasks: dict[str, dict[str, Any]]) -> None:
+    path = _get_db_path()
+    path.write_text(json.dumps(tasks, indent=2))
+
+
+def create_task(subject: str, description: str = "", blocked_by: list[str] | None = None) -> Task:
+    tasks = _load_tasks()
+    task = Task(subject, description)
+    if blocked_by:
+        task.blocked_by = blocked_by
+    tasks[task.id] = task.to_dict()
+    _save_tasks(tasks)
+    return task
+
+
+def update_task(task_id: str, status: str | None = None, subject: str | None = None, description: str | None = None) -> str:
+    tasks = _load_tasks()
+    if task_id not in tasks:
+        return f"Error: task {task_id} not found"
+    if status:
+        tasks[task_id]["status"] = status
+    if subject:
+        tasks[task_id]["subject"] = subject
+    if description:
+        tasks[task_id]["description"] = description
+    _save_tasks(tasks)
+    return f"Task {task_id} updated: {status or 'ok'}"
+
+
+def list_tasks(status: str | None = None) -> str:
+    tasks = _load_tasks()
+    if not tasks:
+        return "No tasks."
+
+    items = []
+    for tid, t in tasks.items():
+        if status and t["status"] != status:
+            continue
+        blocked = f" [blocked by: {', '.join(t['blocked_by'])}]" if t.get("blocked_by") else ""
+        items.append(f"[{t['status']}] {tid}: {t['subject']}{blocked}")
+
+    return "\n".join(items) if items else "No matching tasks."
+
+
+def get_task(task_id: str) -> Optional[Task]:
+    tasks = _load_tasks()
+    if task_id not in tasks:
+        return None
+    d = tasks[task_id]
+    return Task(d["subject"], d.get("description", ""), task_id)