code-memory 0.1.0__py3-none-any.whl

git_search.py

@@ -0,0 +1,313 @@
+"""
+Git history search module for code-memory.
+
+Provides structured access to local Git data (commits, diffs, blame) via
+the ``gitpython`` library.  All functions return plain dicts so the MCP
+layer can serialise them directly to JSON.
+
+Design rules
+------------
+- NO shell-outs — everything goes through ``git.Repo`` Python API.
+- Errors are returned as ``{"error": "…"}`` dicts, never raised.
+- Results are capped with sensible defaults to keep LLM context small.
+- All timestamps are ISO 8601.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import git
+from git.exc import InvalidGitRepositoryError, NoSuchPathError
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _commit_to_dict(commit: git.Commit, *, include_files_changed_count: bool = False) -> dict[str, Any]:
+    """Serialise a ``git.Commit`` to a flat dict.
+
+    Args:
+        include_files_changed_count: If True, compute the number of files
+            changed (triggers a diff — slow for bulk iteration).
+    """
+    dt = datetime.fromtimestamp(commit.committed_date, tz=timezone.utc)
+    result: dict[str, Any] = {
+        "hash": commit.hexsha[:7],
+        "full_hash": commit.hexsha,
+        "message": commit.message.strip(),
+        "author": str(commit.author),
+        "author_email": str(commit.author.email) if commit.author.email else "",
+        "date": dt.isoformat(),
+    }
+    if include_files_changed_count:
+        try:
+            result["files_changed"] = commit.stats.total["files"]
+        except Exception:
+            result["files_changed"] = 0
+    return result
+
+
+# ---------------------------------------------------------------------------
+# 1. Repository resolution
+# ---------------------------------------------------------------------------
+
+def get_repo(path: str = ".") -> git.Repo:
+    """Resolve the Git repository that contains *path*.
+
+    Searches upward from *path* for a ``.git`` directory so callers can
+    pass any file or subdirectory inside the repo.
+
+    Args:
+        path: A file or directory inside the repository.
+
+    Returns:
+        A ``git.Repo`` instance.
+
+    Raises:
+        InvalidGitRepositoryError: When no ``.git`` can be found.
+        NoSuchPathError: When *path* does not exist.
+    """
+    resolved = Path(path).resolve()
+    return git.Repo(str(resolved), search_parent_directories=True)
+
+
+# ---------------------------------------------------------------------------
+# 2. Commit message search
+# ---------------------------------------------------------------------------
+
+def search_commits(
+    repo: git.Repo,
+    query: str,
+    target_file: str | None = None,
+    max_results: int = 20,
+) -> list[dict[str, Any]]:
+    """Search commit messages for *query* (case-insensitive substring).
+
+    Args:
+        repo: An open ``git.Repo``.
+        query: Text to match against commit messages.
+        target_file: If given, restrict to commits that touched this file.
+        max_results: Maximum commits to return.
+
+    Returns:
+        A list of commit dicts, most-recent-first.
+    """
+    try:
+        query_lower = query.lower()
+        results: list[dict[str, Any]] = []
+
+        iter_kwargs: dict[str, Any] = {"max_count": max_results * 5}
+        if target_file:
+            iter_kwargs["paths"] = target_file
+
+        for commit in repo.iter_commits(**iter_kwargs):
+            if query_lower in commit.message.lower():
+                results.append(_commit_to_dict(commit))
+                if len(results) >= max_results:
+                    break
+
+        return results
+
+    except (InvalidGitRepositoryError, NoSuchPathError, ValueError) as exc:
+        return [{"error": str(exc)}]
+    except Exception as exc:
+        return [{"error": f"Unexpected error: {exc}"}]
+
+
+# ---------------------------------------------------------------------------
+# 3. Commit detail (with optional diff)
+# ---------------------------------------------------------------------------
+
+def get_commit_detail(
+    repo: git.Repo,
+    commit_hash: str,
+    target_file: str | None = None,
+) -> dict[str, Any]:
+    """Return detailed metadata (and optionally a diff) for one commit.
+
+    Args:
+        repo: An open ``git.Repo``.
+        commit_hash: Full or abbreviated SHA.
+        target_file: If given, include the unified diff for this file only.
+
+    Returns:
+        A dict with full commit info, file stats, and optional diff text.
+    """
+    try:
+        commit = repo.commit(commit_hash)
+    except Exception as exc:
+        return {"error": f"Could not resolve commit '{commit_hash}': {exc}"}
+
+    try:
+        dt = datetime.fromtimestamp(commit.committed_date, tz=timezone.utc)
+
+        parent_hashes = [p.hexsha[:7] for p in commit.parents]
+
+        # File-level stats
+        files_changed: list[dict[str, Any]] = []
+        try:
+            for fpath, stat in commit.stats.files.items():
+                files_changed.append({
+                    "path": fpath,
+                    "insertions": stat.get("insertions", 0),
+                    "deletions": stat.get("deletions", 0),
+                })
+        except Exception:
+            pass
+
+        # Optional diff for a specific file
+        diff_text: str | None = None
+        if target_file:
+            try:
+                if commit.parents:
+                    diffs = commit.parents[0].diff(commit, paths=[target_file], create_patch=True)
+                else:
+                    diffs = commit.diff(git.NULL_TREE, paths=[target_file], create_patch=True)
+
+                parts = []
+                for d in diffs:
+                    if d.diff:
+                        decoded = d.diff.decode("utf-8", errors="replace") if isinstance(d.diff, bytes) else d.diff
+                        parts.append(decoded)
+                diff_text = "\n".join(parts) if parts else None
+            except Exception:
+                diff_text = None
+
+        return {
+            "hash": commit.hexsha[:7],
+            "full_hash": commit.hexsha,
+            "message": commit.message.strip(),
+            "author": str(commit.author),
+            "author_email": str(commit.author.email) if commit.author.email else "",
+            "date": dt.isoformat(),
+            "parent_hashes": parent_hashes,
+            "files_changed": files_changed,
+            "diff": diff_text,
+        }
+
+    except (InvalidGitRepositoryError, NoSuchPathError, ValueError) as exc:
+        return {"error": str(exc)}
+    except Exception as exc:
+        return {"error": f"Unexpected error: {exc}"}
+
+
+# ---------------------------------------------------------------------------
+# 4. File history (git log --follow)
+# ---------------------------------------------------------------------------
+
+def get_file_history(
+    repo: git.Repo,
+    file_path: str,
+    max_results: int = 20,
+) -> list[dict[str, Any]]:
+    """Return the commit history for a single file, following renames.
+
+    Equivalent to ``git log --follow <file_path>``.
+
+    Args:
+        repo: An open ``git.Repo``.
+        file_path: Path to the file (relative to repo root).
+        max_results: Maximum commits to return.
+
+    Returns:
+        A list of commit dicts, most-recent-first.
+    """
+    try:
+        results: list[dict[str, Any]] = []
+        for commit in repo.iter_commits(paths=file_path, max_count=max_results, follow=True):
+            results.append(_commit_to_dict(commit))
+        return results
+
+    except (InvalidGitRepositoryError, NoSuchPathError, ValueError) as exc:
+        return [{"error": str(exc)}]
+    except Exception as exc:
+        return [{"error": f"Unexpected error: {exc}"}]
+
+
+# ---------------------------------------------------------------------------
+# 5. Blame
+# ---------------------------------------------------------------------------
+
+def get_blame(
+    repo: git.Repo,
+    file_path: str,
+    line_start: int | None = None,
+    line_end: int | None = None,
+) -> list[dict[str, Any]]:
+    """Run ``git blame`` on *file_path*, optionally limited to a line range.
+
+    Consecutive lines from the same commit are grouped into a single entry
+    with ``line_start`` / ``line_end`` and a merged ``line_content`` to keep
+    the output compact.
+
+    Args:
+        repo: An open ``git.Repo``.
+        file_path: Path to file (relative to repo root).
+        line_start: First line of interest (1-indexed, inclusive).
+        line_end: Last line of interest (1-indexed, inclusive).
+
+    Returns:
+        A list of grouped blame entry dicts.
+    """
+    try:
+        blame_data = repo.blame("HEAD", file_path)
+    except Exception as exc:
+        return [{"error": f"Blame failed for '{file_path}': {exc}"}]
+
+    try:
+        # Flatten blame into per-line entries
+        flat: list[dict[str, Any]] = []
+        current_line = 1
+        for commit, lines in blame_data:
+            for line in lines:
+                line_text = line.decode("utf-8", errors="replace") if isinstance(line, bytes) else line
+                flat.append({
+                    "line_number": current_line,
+                    "commit_hash": commit.hexsha[:7],
+                    "full_hash": commit.hexsha,
+                    "author": str(commit.author),
+                    "date": datetime.fromtimestamp(
+                        commit.committed_date, tz=timezone.utc
+                    ).isoformat(),
+                    "line_content": line_text,
+                    "commit_message": commit.message.strip().split("\n")[0],
+                })
+                current_line += 1
+
+        # Filter to requested line range
+        if line_start is not None:
+            flat = [e for e in flat if e["line_number"] >= line_start]
+        if line_end is not None:
+            flat = [e for e in flat if e["line_number"] <= line_end]
+
+        # Group consecutive lines from the same commit
+        grouped: list[dict[str, Any]] = []
+        for entry in flat:
+            if (
+                grouped
+                and grouped[-1]["commit_hash"] == entry["commit_hash"]
+                and grouped[-1]["line_end"] == entry["line_number"] - 1
+            ):
+                grouped[-1]["line_end"] = entry["line_number"]
+                grouped[-1]["line_content"] += "\n" + entry["line_content"]
+            else:
+                grouped.append({
+                    "line_start": entry["line_number"],
+                    "line_end": entry["line_number"],
+                    "commit_hash": entry["commit_hash"],
+                    "author": entry["author"],
+                    "date": entry["date"],
+                    "line_content": entry["line_content"],
+                    "commit_message": entry["commit_message"],
+                })
+
+        return grouped
+
+    except (InvalidGitRepositoryError, NoSuchPathError, ValueError) as exc:
+        return [{"error": str(exc)}]
+    except Exception as exc:
+        return [{"error": f"Unexpected error: {exc}"}]

logging_config.py

@@ -0,0 +1,191 @@
+"""
+Structured logging configuration for code-memory.
+
+Provides configurable logging with environment variable control.
+Log level can be set via CODE_MEMORY_LOG_LEVEL environment variable.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from datetime import datetime
+from typing import TextIO
+
+# Default log level from environment or INFO
+LOG_LEVEL = os.environ.get("CODE_MEMORY_LOG_LEVEL", "INFO").upper()
+
+# Log format with timestamp, module, level, and message
+LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+# Track if logging has been initialized
+_initialized = False
+
+
+def setup_logging(level: str = LOG_LEVEL, stream: TextIO = sys.stderr) -> logging.Logger:
+    """Configure structured logging for code-memory.
+
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        stream: Output stream for logs (default: stderr)
+
+    Returns:
+        Configured root logger for code_memory
+    """
+    global _initialized
+
+    logger = logging.getLogger("code_memory")
+
+    # Avoid adding duplicate handlers
+    if _initialized and logger.handlers:
+        return logger
+
+    # Parse log level
+    level_value = getattr(logging, level.upper(), logging.INFO)
+    logger.setLevel(level_value)
+
+    # Create handler with formatter
+    handler = logging.StreamHandler(stream)
+    handler.setLevel(level_value)
+    formatter = logging.Formatter(LOG_FORMAT, datefmt=DATE_FORMAT)
+    handler.setFormatter(formatter)
+
+    # Clear existing handlers and add new one
+    logger.handlers.clear()
+    logger.addHandler(handler)
+
+    # Prevent propagation to root logger
+    logger.propagate = False
+
+    _initialized = True
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger for a specific module.
+
+    Args:
+        name: Module name (e.g., "server", "db", "parser")
+
+    Returns:
+        Logger instance for the module
+    """
+    # Ensure logging is initialized
+    if not _initialized:
+        setup_logging()
+
+    return logging.getLogger(f"code_memory.{name}")
+
+
+class ToolLogger:
+    """Context manager for logging tool invocations with timing.
+
+    Usage:
+        with ToolLogger("search_code", query="test", search_type="definition") as log:
+            result = perform_search()
+            log.set_result_count(len(result))
+    """
+
+    def __init__(self, tool_name: str, **params):
+        self.tool_name = tool_name
+        self.params = params
+        self.logger = get_logger("tools")
+        self.start_time: datetime | None = None
+        self.result_count: int | None = None
+        self.error: str | None = None
+
+    def __enter__(self) -> "ToolLogger":
+        self.start_time = datetime.now()
+        # Sanitize params for logging (don't log sensitive data)
+        safe_params = {k: v for k, v in self.params.items() if v is not None}
+        self.logger.info(f"Tool invoked: {self.tool_name} params={safe_params}")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        duration_ms = (datetime.now() - self.start_time).total_seconds() * 1000 if self.start_time else 0
+
+        if exc_type is not None:
+            self.error = str(exc_val)
+            self.logger.error(
+                f"Tool failed: {self.tool_name} error={self.error} duration={duration_ms:.1f}ms"
+            )
+        else:
+            count_str = f" count={self.result_count}" if self.result_count is not None else ""
+            self.logger.info(
+                f"Tool completed: {self.tool_name}{count_str} duration={duration_ms:.1f}ms"
+            )
+
+        return False  # Don't suppress exceptions
+
+    def set_result_count(self, count: int) -> None:
+        """Set the number of results returned by the tool."""
+        self.result_count = count
+
+
+class IndexingLogger:
+    """Logger for indexing operations with progress tracking."""
+
+    def __init__(self, indexer_type: str):
+        self.indexer_type = indexer_type
+        self.logger = get_logger("indexing")
+        self.files_processed = 0
+        self.items_indexed = 0
+        self.files_skipped = 0
+        self.start_time: datetime | None = None
+
+    def start(self, directory: str) -> None:
+        """Log the start of an indexing operation."""
+        self.start_time = datetime.now()
+        self.logger.info(f"Starting {self.indexer_type} indexing: directory={directory}")
+
+    def file_indexed(self, filepath: str, items: int = 1) -> None:
+        """Log successful file indexing."""
+        self.files_processed += 1
+        self.items_indexed += items
+        self.logger.debug(f"Indexed {self.indexer_type}: {filepath} ({items} items)")
+
+    def file_skipped(self, filepath: str, reason: str) -> None:
+        """Log skipped file."""
+        self.files_skipped += 1
+        self.logger.debug(f"Skipped {self.indexer_type}: {filepath} ({reason})")
+
+    def complete(self) -> None:
+        """Log completion of indexing."""
+        duration_ms = (datetime.now() - self.start_time).total_seconds() * 1000 if self.start_time else 0
+        self.logger.info(
+            f"Completed {self.indexer_type} indexing: "
+            f"files={self.files_processed} items={self.items_indexed} "
+            f"skipped={self.files_skipped} duration={duration_ms:.1f}ms"
+        )
+
+    def error(self, filepath: str, error_msg: str) -> None:
+        """Log indexing error."""
+        self.logger.warning(f"Error indexing {filepath}: {error_msg}")
+
+
+# Pre-configured loggers for common modules
+def get_server_logger() -> logging.Logger:
+    """Get logger for server module."""
+    return get_logger("server")
+
+
+def get_db_logger() -> logging.Logger:
+    """Get logger for database module."""
+    return get_logger("db")
+
+
+def get_parser_logger() -> logging.Logger:
+    """Get logger for parser module."""
+    return get_logger("parser")
+
+
+def get_query_logger() -> logging.Logger:
+    """Get logger for query module."""
+    return get_logger("queries")
+
+
+def get_git_logger() -> logging.Logger:
+    """Get logger for git search module."""
+    return get_logger("git")