luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/git/auto_commit.py

@@ -0,0 +1,157 @@
+"""Auto-commit — stage and commit agent-modified files after each completed turn.
+
+Behaviour
+---------
+* Only runs when inside a git repository.
+* Only commits files that the agent actually wrote or edited this turn.
+* Skips the commit if there are no staged changes (e.g. the write was a no-op).
+* Commit message is derived from the user's prompt (first 72 chars) so the
+  git log stays readable — same approach as Aider.
+* Can be disabled globally with:  /config set auto_commit false
+"""
+
+import subprocess
+
+from ..log import get_logger
+
+# Tool names whose arguments contain the path of a file that was changed.
+# The argument key that holds the path is listed alongside.
+_WRITE_TOOLS: dict[str, str] = {
+    "Write":     "file_path",
+    "Edit":      "file_path",
+    "MultiEdit": "file_path",
+}
+
+_logger = get_logger()
+
+
+def _in_git_repo(cwd: str | None = None) -> bool:
+    """Return True if cwd (or the process cwd) is inside a git repository."""
+    try:
+        r = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            capture_output=True, text=True, timeout=5,
+            cwd=cwd,
+        )
+        return r.returncode == 0
+    except Exception:
+        return False
+
+
+def _stage_files(paths: list[str], cwd: str | None = None) -> bool:
+    """Stage specific files. Returns True if at least one file was staged."""
+    if not paths:
+        return False
+    try:
+        r = subprocess.run(
+            ["git", "add", "--"] + paths,
+            capture_output=True, text=True, timeout=10,
+            cwd=cwd,
+        )
+        if r.returncode != 0:
+            _logger.warning("git add failed: %s", r.stderr.strip())
+            return False
+        return True
+    except Exception as e:
+        _logger.warning("git add error: %s", e)
+        return False
+
+
+def _has_staged_changes(cwd: str | None = None) -> bool:
+    """Return True if there is anything in the index to commit."""
+    try:
+        r = subprocess.run(
+            ["git", "diff", "--cached", "--quiet"],
+            capture_output=True, timeout=5,
+            cwd=cwd,
+        )
+        # exit 1 means differences exist
+        return r.returncode == 1
+    except Exception:
+        return False
+
+
+def _make_commit_message(user_prompt: str) -> str:
+    """Build a short, readable commit message from the user's prompt."""
+    first_line = user_prompt.strip().splitlines()[0] if user_prompt.strip() else "agent changes"
+    # Truncate to 72 chars (git convention)
+    subject = first_line[:72].rstrip()
+    return f"agent: {subject}"
+
+
+def _commit(message: str, cwd: str | None = None) -> str | None:
+    """Create a commit. Returns the short SHA on success, None on failure."""
+    try:
+        r = subprocess.run(
+            ["git", "commit", "-m", message],
+            capture_output=True, text=True, timeout=15,
+            cwd=cwd,
+        )
+        if r.returncode != 0:
+            _logger.warning("git commit failed: %s", r.stderr.strip())
+            return None
+        # Parse the short SHA from the output line like "[main abc1234] ..."
+        for line in r.stdout.splitlines():
+            if line.startswith("["):
+                parts = line.split()
+                if len(parts) >= 2:
+                    return parts[1].rstrip("]")
+        return "ok"
+    except Exception as e:
+        _logger.warning("git commit error: %s", e)
+        return None
+
+
+def collect_modified_paths(tool_calls: list[dict], tool_args_map: dict[str, dict]) -> list[str]:
+    """Extract file paths that were written or edited this turn.
+
+    Args:
+        tool_calls:    List of tool-call dicts (id, function.name, function.arguments).
+        tool_args_map: Mapping of tool_call_id → parsed args dict (populated during execution).
+
+    Returns:
+        Deduplicated list of absolute/relative file path strings.
+    """
+    seen: set[str] = set()
+    paths: list[str] = []
+    for tc in tool_calls:
+        name = tc.get("function", {}).get("name", "")
+        arg_key = _WRITE_TOOLS.get(name)
+        if not arg_key:
+            continue
+        args = tool_args_map.get(tc.get("id", ""), {})
+        fp = args.get(arg_key, "")
+        if fp and fp not in seen:
+            seen.add(fp)
+            paths.append(fp)
+    return paths
+
+
+def auto_commit(
+    user_prompt: str,
+    modified_paths: list[str],
+    cwd: str | None = None,
+    enabled: bool = True,
+) -> str | None:
+    """Stage modified_paths and commit if inside a git repo and enabled.
+
+    Returns the short commit SHA on success, None if skipped or failed.
+    """
+    if not enabled or not modified_paths:
+        return None
+
+    if not _in_git_repo(cwd):
+        return None
+
+    # Only stage the files the agent actually touched
+    if not _stage_files(modified_paths, cwd):
+        return None
+
+    if not _has_staged_changes(cwd):
+        return None
+
+    message = _make_commit_message(user_prompt)
+    sha = _commit(message, cwd)
+    if sha:
+        _logger.info("Auto-committed %d file(s): %s [%s]", len(modified_paths), message, sha)
+    return sha

luckyd_code/git/tools.py

@@ -0,0 +1,85 @@
+import subprocess
+
+
+def git_status() -> str:
+    try:
+        r = subprocess.run(["git", "status"], capture_output=True, text=True, timeout=30)
+        return r.stdout.strip() or r.stderr.strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def git_diff(staged: bool = False) -> str:
+    try:
+        cmd = ["git", "diff", "--cached"] if staged else ["git", "diff"]
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        out = r.stdout.strip()
+        if not out:
+            return "No changes"
+        return out[:5000]
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def git_log(count: int = 10) -> str:
+    try:
+        r = subprocess.run(
+            ["git", "log", f"--max-count={count}", "--oneline"],
+            capture_output=True, text=True, timeout=30,
+        )
+        return r.stdout.strip() or r.stderr.strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def git_commit(message: str) -> str:
+    try:
+        r = subprocess.run(
+            ["git", "commit", "-m", message],
+            capture_output=True, text=True, timeout=30,
+        )
+        return r.stdout.strip() or r.stderr.strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def git_add(files: list[str] | None = None) -> str:
+    try:
+        cmd = ["git", "add"] + (files if files else ["-A"])
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        return r.stdout.strip() or r.stderr.strip() or "Staged"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def git_branch() -> str:
+    try:
+        r = subprocess.run(
+            ["git", "branch", "-a"],
+            capture_output=True, text=True, timeout=30,
+        )
+        return r.stdout.strip() or r.stderr.strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def git_create_pr(title: str, body: str = "", draft: bool = True) -> str:
+    try:
+        cmd = ["gh", "pr", "create", "--title", title, "--body", body]
+        if draft:
+            cmd.append("--draft")
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        return r.stdout.strip() or r.stderr.strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def git_push(branch: str | None = None) -> str:
+    try:
+        cmd = ["git", "push", "-u", "origin"]
+        if branch:
+            cmd.append(branch)
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        return r.stdout.strip() or r.stderr.strip()
+    except Exception as e:
+        return f"Error: {e}"

luckyd_code/hooks.py

@@ -0,0 +1,236 @@
+"""Lifecycle hooks system — pre/post tool use, pre/post chat, session events.
+
+Hooks are shell scripts defined in .deepseek-code/settings.local.json:
+
+    {
+      "hooks": {
+        "preToolUse": {
+          "script": "echo 'About to run $DSC_TOOL_NAME'",
+          "tools": ["all"]
+        },
+        "postToolUse": "npm run lint-changed",
+        "preChat": "echo 'Sending request to $DSC_MODEL'",
+        "postChat": "echo 'Response received'",
+        "onSessionStart": "echo 'Session started at $DSC_TIME'",
+        "onSessionEnd": "echo 'Session ended'"
+      }
+    }
+
+Hooks can return JSON on their first line to control execution:
+  {"allow": false}     — block the tool call (preToolUse only)
+  {"env": {"K": "v"}} — update environment variables
+"""
+
+import json
+import os
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from .settings import load_settings, get_settings_dir
+
+
+HOOK_EVENTS = [
+    "preToolUse",
+    "postToolUse",
+    "preChat",
+    "postChat",
+    "onSessionStart",
+    "onSessionEnd",
+]
+
+
+@dataclass
+class HookResult:
+    success: bool = True
+    output: str = ""
+    error: Optional[str] = None
+    allow: bool = True           # preToolUse: block or allow the tool call
+    env_updates: dict = field(default_factory=dict)
+
+
+class HookRunner:
+    """Execute shell-based hooks for lifecycle events."""
+
+    def __init__(self):
+        self.settings = load_settings()
+
+    def run_hook(self, event: str, context: Optional[dict] = None) -> list[HookResult]:
+        """Run all hooks configured for an event.
+
+        Args:
+            event: One of HOOK_EVENTS.
+            context: Dict of extra env vars to pass (e.g. tool_name, tool_args).
+
+        Returns:
+            List of HookResult, one per hook script.
+        """
+        if event not in HOOK_EVENTS:
+            return [HookResult(success=False, error=f"Unknown hook event: {event}")]
+
+        scripts = self._get_hook_scripts(event)
+        results = []
+        for hook_cfg in scripts:
+            script = hook_cfg.get("script", "")
+            if not script:
+                continue
+            # Check tool filter if present
+            tool_filter = hook_cfg.get("tools", ["all"])
+            if "all" not in tool_filter:
+                tool_name = (context or {}).get("tool_name", "")
+                if tool_name not in tool_filter:
+                    continue
+            result = self._execute_script(script, event, context)
+            results.append(result)
+        return results
+
+    def _get_hook_scripts(self, event: str) -> list[dict]:
+        """Get all hook scripts for an event from settings.
+
+        Returns empty for unknown (not in HOOK_EVENTS) event types
+        even if hooks are configured — prevents misconfiguration.
+        """
+        if event not in HOOK_EVENTS:
+            return []
+        hooks = self.settings.get("hooks", {})
+        raw = hooks.get(event, "")
+        if isinstance(raw, str):
+            return [{"script": raw, "tools": ["all"]}] if raw else []
+        elif isinstance(raw, dict):
+            # Single hook config
+            if "script" in raw:
+                return [raw]
+            # Multiple hook configs keyed by name
+            return list(raw.values())
+        elif isinstance(raw, list):
+            return raw
+        return []
+
+    def _execute_script(self, script: str, event: str,
+                        context: Optional[dict] = None) -> HookResult:
+        """Execute a single hook script and return the result.
+
+        Supports both shell commands and ``.py`` scripts.  Python scripts
+        are launched via ``sys.executable`` with the same environment
+        variables, so they work portably across platforms.
+        """
+        env = {
+            "DSC_HOOK_EVENT": event,
+            "DSC_PROJECT_DIR": str(get_settings_dir().parent),
+            "DSC_TIME": __import__("datetime").datetime.now().isoformat(),
+        }
+        if context:
+            for k, v in context.items():
+                env[f"DSC_{k.upper()}"] = str(v)
+
+        full_env = {**os.environ, **env}
+
+        # Detect Python hook scripts
+        script_path = Path(script)
+        if script_path.suffix == ".py":
+            return self._run_python_script(script_path, event, full_env)
+
+        try:
+            proc = subprocess.run(
+                script,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                env=full_env,
+            )
+            output = proc.stdout.strip()
+            if proc.returncode != 0 and proc.stderr.strip():
+                return HookResult(
+                    success=False,
+                    error=proc.stderr.strip(),
+                    output=output,
+                )
+
+            # Parse optional JSON directive from first line
+            if output:
+                first_line = output.split("\n")[0]
+                if first_line.startswith("{"):
+                    try:
+                        data = json.loads(first_line)
+                        output = "\n".join(output.split("\n")[1:])
+                        return HookResult(
+                            success=True,
+                            output=output,
+                            allow=data.get("allow", True),
+                            env_updates=data.get("env", {}),
+                        )
+                    except json.JSONDecodeError:
+                        pass
+
+            return HookResult(success=True, output=output)
+
+        except subprocess.TimeoutExpired:
+            return HookResult(success=False, error=f"Hook '{event}' timed out after 30s")
+        except FileNotFoundError:
+            return HookResult(success=False, error=f"Hook '{event}' command not found: {script[:100]}")
+        except Exception as e:
+            return HookResult(success=False, error=f"Hook '{event}' error: {e}")
+
+    def _run_python_script(self, script_path: Path, event: str,
+                           full_env: dict) -> HookResult:
+        """Execute a ``.py`` hook script with the current Python interpreter.
+
+        The script receives all ``DSC_*`` environment variables and can
+        return JSON on its first stdout line for execution control
+        (same protocol as shell hooks).
+        """
+        # Merge with os.environ so the child process inherits essential
+        # system variables (PATH, SYSTEMROOT, etc.) – required on Windows.
+        merged_env = {**os.environ, **full_env}
+        try:
+            proc = subprocess.run(
+                [sys.executable, str(script_path)],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                env=merged_env,
+            )
+            output = proc.stdout.strip()
+            if proc.returncode != 0 and proc.stderr.strip():
+                return HookResult(
+                    success=False,
+                    error=proc.stderr.strip(),
+                    output=output,
+                )
+
+            # Parse optional JSON directive from first line
+            if output:
+                first_line = output.split("\n")[0]
+                if first_line.startswith("{"):
+                    try:
+                        data = json.loads(first_line)
+                        output = "\n".join(output.split("\n")[1:])
+                        return HookResult(
+                            success=True,
+                            output=output,
+                            allow=data.get("allow", True),
+                            env_updates=data.get("env", {}),
+                        )
+                    except json.JSONDecodeError:
+                        pass
+
+            return HookResult(success=True, output=output)
+
+        except subprocess.TimeoutExpired:
+            return HookResult(success=False, error=f"Python hook '{script_path.name}' timed out after 30s")
+        except Exception as e:
+            return HookResult(success=False, error=f"Python hook '{script_path.name}' error: {e}")
+
+
+# Global singleton access
+_hook_runner: Optional[HookRunner] = None
+
+
+def get_hook_runner() -> HookRunner:
+    global _hook_runner
+    if _hook_runner is None:
+        _hook_runner = HookRunner()
+    return _hook_runner