luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/feedback_analyzer.py

@@ -0,0 +1,290 @@
+"""Feedback Analyzer — LLM-powered error diagnosis for autonomous self-improvement.
+
+Takes a sanitized error, gathers code context from the project, and uses the
+user's own DeepSeek API key to diagnose the root cause and suggest a fix.
+
+All analysis runs locally on the user's machine.  Nothing is sent to any
+central server.  The user's API key is used directly.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+import httpx
+
+from .error_reporter import sanitize_traceback, _clean_path
+
+# ------------------------------------------------------------------ #
+#  Data model
+# ------------------------------------------------------------------ #
+
+
+@dataclass
+class Diagnosis:
+    """Structured result of LLM-powered error analysis."""
+
+    error_type: str
+    error_message: str
+    root_cause: str            # Natural-language explanation of the root cause
+    affected_files: list[str]  # Relative paths of files that need changing
+    fix_suggestion: str        # Concrete fix description
+    confidence: str            # "high" | "medium" | "low"
+    raw_analysis: str = ""     # Full LLM response for debugging
+
+    def to_markdown(self) -> str:
+        """Format as a GitHub-issue-ready Markdown section."""
+        files_list = "\n".join(f"   - `{f}`" for f in self.affected_files) or "   - (none)"
+        return f"""\
+### 🤖 Autonomous Diagnosis
+
+**Root Cause:** {self.root_cause}
+
+**Affected files:**
+{files_list}
+
+**Suggested Fix:** {self.fix_suggestion}
+
+**Confidence:** `{self.confidence}`
+"""
+
+
+# ------------------------------------------------------------------ #
+#  LLM call helpers
+# ------------------------------------------------------------------ #
+
+ANALYSIS_SYSTEM_PROMPT = """You are a senior software engineer analyzing a bug in the **DeepSeek Code** project — an open-source AI coding assistant that runs in the terminal.
+
+You will receive:
+1. An error report (type, message, traceback)
+2. Relevant source code snippets from the project
+
+Your task: diagnose the ROOT CAUSE and propose a SPECIFIC, CONCRETE fix.
+
+CRITICAL:
+- Only suggest changes to DeepSeek Code's OWN source code (luckyd_code/ and tests/)
+- Do NOT suggest changes to the user's project or third-party libraries
+- Be precise about which file(s) and what lines need to change
+- Consider error handling gaps, edge cases, type issues, and import problems
+- If you cannot determine the root cause from the provided context, say so honestly
+
+Respond in this EXACT JSON format (no other text):
+```json
+{
+  "root_cause": "...",
+  "affected_files": ["path/relative/to/project/root.py"],
+  "fix_suggestion": "...",
+  "confidence": "high|medium|low"
+}
+```"""
+
+
+def _get_relevant_files(error_data: dict[str, str], project_root: str) -> dict[str, str]:
+    """Collect source files mentioned in the traceback or likely relevant.
+
+    Returns a dict of {relative_path: file_contents} — at most 5 files,
+    truncated to 200 lines each.
+    """
+    tb = error_data.get("traceback", "")
+    relevant: dict[str, str] = {}
+    root = Path(project_root).resolve()
+
+    # Extract file references from traceback
+    for line in tb.split("\n"):
+        if "luckyd_code" in line and ".py" in line:
+            # Try to extract a relative path
+            import re
+            m = re.search(r'([\w/.-]*luckyd_code/[\w/.-]+\.py)', line)
+            if m:
+                rel = m.group(1)
+                abs_path = root / rel
+                if abs_path.exists() and rel not in relevant:
+                    try:
+                        content = abs_path.read_text(encoding="utf-8")
+                        lines = content.split("\n")
+                        if len(lines) > 200:
+                            content = "\n".join(lines[:200]) + "\n... (file truncated)"
+                        relevant[rel] = content
+                    except Exception:
+                        pass
+
+    # If we found fewer than 3 files, try to read files referenced by error message
+    if len(relevant) < 3:
+        msg = error_data.get("error_message", "")
+        for part in msg.replace("'", " ").replace('"', " ").split():
+            if ".py" in part:
+                candidate = root / part
+                if candidate.exists() and str(candidate.relative_to(root)) not in relevant:
+                    try:
+                        content = candidate.read_text(encoding="utf-8")
+                        lines = content.split("\n")
+                        if len(lines) > 200:
+                            content = "\n".join(lines[:200]) + "\n... (file truncated)"
+                        relevant[str(candidate.relative_to(root))] = content
+                    except Exception:
+                        pass
+
+    return dict(list(relevant.items())[:5])
+
+
+def _call_llm(
+    system_prompt: str,
+    user_message: str,
+    api_key: str,
+    base_url: str = "https://api.deepseek.com/v1",
+    model: str = "deepseek-v4-flash",
+    timeout: float = 30.0,
+) -> str:
+    """Make a single synchronous (non-streaming) LLM call.
+
+    Returns the response text, or an error string starting with "ERROR:".
+    """
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_message},
+        ],
+        "max_tokens": 2048,
+        "temperature": 0.1,  # Low temperature for deterministic analysis
+        "stream": False,
+    }
+
+    try:
+        with httpx.Client(timeout=httpx.Timeout(timeout, connect=10.0)) as client:
+            resp = client.post(url, headers=headers, json=payload)
+            resp.raise_for_status()
+            data = resp.json()
+            content = data["choices"][0]["message"]["content"]
+            return content.strip()
+    except httpx.HTTPStatusError as e:
+        body = e.response.text[:500] if e.response else ""
+        return f"ERROR: HTTP {e.response.status_code if e.response else '?'}: {body}"
+    except httpx.TimeoutException:
+        return "ERROR: LLM request timed out"
+    except Exception as e:
+        return f"ERROR: {e}"
+
+
+def _parse_diagnosis_json(raw: str) -> Optional[dict[str, Any]]:
+    """Extract JSON from an LLM response that may have markdown fences."""
+    if not raw or raw.startswith("ERROR:"):
+        return None
+    # Try to extract JSON from ```json ... ``` fences
+    import re
+    m = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', raw, re.DOTALL)
+    if m:
+        try:
+            return json.loads(m.group(1))
+        except json.JSONDecodeError:
+            pass
+    # Try parsing the whole response as JSON
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        pass
+    # Try finding a bare JSON object
+    m = re.search(r'\{[^{}]*"root_cause"[^{}]*\}', raw, re.DOTALL)
+    if m:
+        try:
+            return json.loads(m.group(0))
+        except json.JSONDecodeError:
+            pass
+    return None
+
+
+# ------------------------------------------------------------------ #
+#  Main API
+# ------------------------------------------------------------------ #
+
+
+def analyze_error(
+    exc_or_data: BaseException | dict[str, str],
+    api_key: str,
+    base_url: str = "https://api.deepseek.com/v1",
+    model: str = "deepseek-v4-flash",
+    project_root: str = "",
+) -> Optional[Diagnosis]:
+    """Analyze an error with LLM-powered root cause diagnosis.
+
+    Args:
+        exc_or_data: Either a live exception or a sanitized traceback dict.
+        api_key: DeepSeek API key (the user's own).
+        base_url: API base URL.
+        model: Model name to use.
+        project_root: Root of the DeepSeek Code project (auto-detected if empty).
+
+    Returns:
+        A Diagnosis on success, None if analysis failed or no root cause found.
+    """
+    # Resolve project root
+    if not project_root:
+        project_root = str(Path(__file__).resolve().parent.parent)
+
+    # Sanitize if given a live exception
+    if isinstance(exc_or_data, BaseException):
+        error_data = sanitize_traceback(exc_or_data)
+    else:
+        error_data = exc_or_data
+
+    # Gather code context
+    file_context = _get_relevant_files(error_data, project_root)
+
+    # Build user message
+    context_section = ""
+    if file_context:
+        context_section = "## Relevant Source Code\n\n"
+        for fpath, content in file_context.items():
+            context_section += f"### {fpath}\n```python\n{content}\n```\n\n"
+    else:
+        context_section = "## Relevant Source Code\n(No relevant files could be extracted from the traceback.)\n"
+
+    user_message = f"""## Error Report
+
+**Error Type:** `{error_data['error_type']}`
+**Message:** `{error_data['error_message']}`
+**Python:** {error_data.get('python_version', 'unknown')}
+**OS:** {error_data.get('os', 'unknown')}
+
+## Traceback
+
+```
+{error_data['traceback']}
+```
+
+{context_section}"""
+
+    # Call LLM
+    raw = _call_llm(
+        system_prompt=ANALYSIS_SYSTEM_PROMPT,
+        user_message=user_message,
+        api_key=api_key,
+        base_url=base_url,
+        model=model,
+    )
+
+    if raw.startswith("ERROR:"):
+        return None
+
+    parsed = _parse_diagnosis_json(raw)
+    if not parsed:
+        return None
+
+    return Diagnosis(
+        error_type=error_data["error_type"],
+        error_message=error_data["error_message"],
+        root_cause=parsed.get("root_cause", "Unknown"),
+        affected_files=parsed.get("affected_files", []),
+        fix_suggestion=parsed.get("fix_suggestion", ""),
+        confidence=parsed.get("confidence", "low"),
+        raw_analysis=raw,
+    )

luckyd_code/file_watcher.py

@@ -0,0 +1,258 @@
+"""Auto-reindex on file changes — watchdog-based background file watcher.
+
+Usage::
+
+    from luckyd_code.file_watcher import FileWatcher
+
+    watcher = FileWatcher("/path/to/project")
+    watcher.start()
+    ...
+    watcher.stop()
+"""
+
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Callable, Optional
+
+from .log import get_logger
+
+
+class FileWatcher:
+    """Watch a project directory for source file changes and auto-reindex.
+
+    Uses watchdog if available; falls back to a polling timer otherwise.
+    Debounces rapid changes so reindex doesn't fire on every keystroke.
+    """
+
+    def __init__(self, root: str = "", debounce_seconds: float = 3.0,
+                 on_change: Optional[Callable[[list[str]], None]] = None):
+        self.root = Path(root or os.getcwd()).resolve()
+        self.debounce_seconds = debounce_seconds
+        self.on_change = on_change
+        self._watchdog = None
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._lock = threading.Lock()
+        self._pending: set[str] = set()
+        self._running = False
+        self._poll_interval = 1.0  # seconds between polls in fallback mode
+        self._use_watchdog = False
+        self._paused = False
+        self._debounce_timer: Optional[threading.Timer] = None
+
+        # Build the set of watched file extensions
+        self._watched_exts = {
+            ".py", ".pyi", ".js", ".jsx", ".ts", ".tsx",
+            ".rs", ".go", ".java", ".rb", ".php",
+            ".c", ".h", ".cpp", ".hpp", ".cs",
+            ".swift", ".kt", ".scala",
+            ".json", ".yaml", ".yml", ".toml",
+            ".md", ".sql", ".sh", ".bat",
+            ".html", ".css",
+        }
+
+    # ------------------------------------------------------------------ #
+    #  Public API
+    # ------------------------------------------------------------------ #
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def start(self):
+        """Start watching for file changes in a background thread."""
+        if self._running:
+            return
+
+        self._stop_event.clear()
+        self._pending.clear()
+
+        # Try watchdog first
+        watchdog_ok = self._try_watchdog()
+
+        if watchdog_ok:
+            self._running = True
+            get_logger().info("File watcher started (watchdog) on %s", self.root)
+        else:
+            # Fallback: poll for mtime changes
+            self._thread = threading.Thread(
+                target=self._poll_loop,
+                daemon=True,
+                name="file-watcher-poll",
+            )
+            self._thread.start()
+            self._running = True
+            get_logger().info("File watcher started (polling) on %s", self.root)
+
+    def stop(self):
+        """Stop watching."""
+        self._running = False
+        self._stop_event.set()
+
+        if self._watchdog is not None:
+            try:
+                self._watchdog.stop()
+                self._watchdog.join(timeout=3)
+            except Exception:
+                pass
+            self._watchdog = None
+
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=3)
+            self._thread = None
+
+        get_logger().info("File watcher stopped")
+
+    def pause(self):
+        """Temporarily pause reindex on changes."""
+        self._paused = True
+
+    def resume(self):
+        """Resume reindex after pause."""
+        self._paused = False
+
+    @property
+    def status(self) -> str:
+        if not self._running:
+            return "stopped"
+        mode = "watchdog" if self._use_watchdog else "polling"
+        paused = " (paused)" if self._paused else ""
+        pending = f" ({len(self._pending)} pending)" if self._pending else ""
+        return f"running [{mode}]{paused}{pending}"
+
+    # ------------------------------------------------------------------ #
+    #  Watchdog-based watching
+    # ------------------------------------------------------------------ #
+
+    def _try_watchdog(self) -> bool:
+        """Try to use watchdog for file watching. Returns True on success."""
+        try:
+            from watchdog.observers import Observer
+            from watchdog.events import FileSystemEventHandler
+
+            class _Handler(FileSystemEventHandler):
+                def __init__(self, watcher):
+                    self.watcher = watcher
+
+                def on_modified(self, event):
+                    if not event.is_directory:
+                        self.watcher._on_file_changed(event.src_path)
+
+                def on_created(self, event):
+                    if not event.is_directory:
+                        self.watcher._on_file_changed(event.src_path)
+
+            handler = _Handler(self)
+            observer = Observer()
+            observer.schedule(handler, str(self.root), recursive=True)
+            observer.daemon = True
+            observer.start()
+            self._watchdog = observer
+            self._use_watchdog = True
+            return True
+        except Exception as e:
+            get_logger().warning("watchdog init failed, falling back to polling: %s", e)
+            return False
+
+    # ------------------------------------------------------------------ #
+    #  Fallback polling
+    # ------------------------------------------------------------------ #
+
+    def _poll_loop(self):
+        """Polling fallback when watchdog is unavailable.
+
+        Tracks mtime/size of watched files and detects changes.
+        """
+        snapshot: dict[str, tuple[float, int]] = {}
+        last_trigger = 0.0
+
+        while not self._stop_event.is_set():
+            time.sleep(self._poll_interval)
+
+            if self._paused:
+                continue
+
+            now = time.time()
+            changed: list[str] = []
+
+            for dirpath, dirnames, filenames in os.walk(self.root):
+                dirnames[:] = [d for d in dirnames
+                               if not d.startswith(".") and d != "__pycache__"]
+                for fname in filenames:
+                    ext = Path(fname).suffix.lower()
+                    if ext not in self._watched_exts:
+                        continue
+                    fpath = Path(dirpath) / fname
+                    try:
+                        st = fpath.stat()
+                        key = str(fpath)
+                        prev = snapshot.get(key)
+                        cur = (st.st_mtime, st.st_size)
+                        if prev is not None and prev != cur:
+                            changed.append(key)
+                        snapshot[key] = cur
+                    except OSError:
+                        continue
+
+            if changed:
+                with self._lock:
+                    self._pending.update(changed)
+                    last_trigger = now
+
+            # Debounce: only trigger if no new changes for debounce_seconds
+            if self._pending and (now - last_trigger) >= self.debounce_seconds:
+                with self._lock:
+                    batch = list(self._pending)
+                    self._pending.clear()
+                self._fire(batch)
+
+    # ------------------------------------------------------------------ #
+    #  Shared change handling
+    # ------------------------------------------------------------------ #
+
+    def _on_file_changed(self, path: str):
+        """Called by watchdog on each file change event."""
+        if self._paused:
+            return
+
+        ext = Path(path).suffix.lower()
+        if ext not in self._watched_exts:
+            return
+
+        with self._lock:
+            self._pending.add(path)
+
+        # Start a debounce timer if not already running
+        if self._debounce_timer is None or not self._debounce_timer.is_alive():
+            self._debounce_timer = threading.Timer(
+                self.debounce_seconds,
+                self._debounce_fire,
+            )
+            self._debounce_timer.daemon = True
+            self._debounce_timer.start()
+
+    def _debounce_fire(self):
+        """Called after debounce window elapses (watchdog mode)."""
+        with self._lock:
+            batch = list(self._pending)
+            self._pending.clear()
+        if batch:
+            self._fire(batch)
+
+    def _fire(self, changed_files: list[str]):
+        """Trigger reindex with the list of changed files."""
+        if not changed_files:
+            return
+        try:
+            # Rel import to avoid circular dependency
+            from .brain import rebuild_project
+            result = rebuild_project(str(self.root))
+            stats = f"{result.get('chunks', 0)} chunks, {result.get('files', 0)} files"
+            get_logger().info("Auto-reindexed (%d files changed): %s",
+                              len(changed_files), stats)
+            if self.on_change:
+                self.on_change(changed_files)
+        except Exception as e:
+            get_logger().warning("Auto-reindex failed: %s", e)

luckyd_code/git/__init__.py

@@ -0,0 +1,11 @@
+from .tools import (
+    git_status,
+    git_diff,
+    git_log,
+    git_commit,
+    git_add,
+    git_branch,
+    git_create_pr,
+    git_push,
+)
+from .auto_commit import collect_modified_paths