code-memory 1.0.10__tar.gz → 1.0.12__tar.gz

{code_memory-1.0.10 → code_memory-1.0.12}/.github/workflows/release-binaries.yml

@@ -53,7 +53,7 @@ jobs:
 
       - name: Download embedding model (cache for offline use)
         run: |
-          python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('jinaai/jina-code-embeddings-v3')"
+          python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('jinaai/jina-code-embeddings-0.5b', trust_remote_code=True)"
 
       - name: Build binary with PyInstaller (Linux/Windows)
         if: matrix.os != 'macos-latest' || matrix.target == 'macos-x86_64'

{code_memory-1.0.10 → code_memory-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-memory
-Version: 1.0.10
+Version: 1.0.12
 Summary: A deterministic, high-precision code intelligence MCP server
 Project-URL: Homepage, https://github.com/kapillamba4/code-memory
 Project-URL: Documentation, https://github.com/kapillamba4/code-memory#readme

{code_memory-1.0.10 → code_memory-1.0.12}/parser.py

@@ -47,22 +47,79 @@ def _load_gitignore_spec(root_dir: str) -> pathspec.PathSpec | None:
         return None
 
 
-def _should_skip_path(
-    rel_path: str,
-    is_dir: bool,
-    gitignore_spec: pathspec.PathSpec | None,
-) -> bool:
-    """Check if a path should be skipped based on .gitignore patterns."""
-    if gitignore_spec is None:
-        return False
+class GitignoreMatcher:
+    """Manages .gitignore matching with support for nested .gitignore files.
+
+    Git reads all .gitignore files in the directory tree, not just the root.
+    Each nested .gitignore applies patterns relative to its own directory.
+    """
+
+    def __init__(self, root_dir: str):
+        self.root_dir = root_dir
+        self._specs: dict[str, pathspec.PathSpec] = {}
 
-    # Check both the path as-is and with trailing slash for directories
-    if gitignore_spec.match_file(rel_path):
-        return True
-    if is_dir and gitignore_spec.match_file(rel_path + "/"):
-        return True
+        # Load root .gitignore if it exists
+        root_spec = _load_gitignore_spec(root_dir)
+        if root_spec:
+            self._specs["."] = root_spec
+
+    def _load_spec_for_dir(self, abs_dir: str, rel_dir: str) -> None:
+        """Load .gitignore for a directory if not already loaded."""
+        if rel_dir in self._specs:
+            return
+
+        spec = _load_gitignore_spec(abs_dir)
+        if spec:
+            self._specs[rel_dir] = spec
+
+    def _get_parent_specs(self, rel_path: str) -> list[tuple[str, pathspec.PathSpec]]:
+        """Get all applicable gitignore specs for a given path.
+
+        Returns list of (base_dir, spec) tuples for specs that apply to this path.
+        """
+        result = []
+        path_parts = rel_path.replace("\\", "/").split("/")
+
+        # Check all ancestor directories that have .gitignore files
+        for base_dir, spec in self._specs.items():
+            if base_dir == ".":
+                # Root spec applies to everything
+                result.append((base_dir, spec))
+            else:
+                # Nested spec only applies if path is under that directory
+                base_parts = base_dir.replace("\\", "/").split("/")
+                if path_parts[:len(base_parts)] == base_parts:
+                    result.append((base_dir, spec))
+
+        return result
+
+    def should_skip(self, rel_path: str, is_dir: bool) -> bool:
+        """Check if a path should be skipped based on all applicable .gitignore patterns."""
+        # Normalize path separators for matching
+        rel_path = rel_path.replace("\\", "/")
+
+        for base_dir, spec in self._get_parent_specs(rel_path):
+            # For nested gitignores, compute path relative to that gitignore's directory
+            if base_dir == ".":
+                check_path = rel_path
+            else:
+                base_prefix = base_dir.replace("\\", "/") + "/"
+                if rel_path.startswith(base_prefix):
+                    check_path = rel_path[len(base_prefix):]
+                else:
+                    continue
 
-    return False
+            # Check both the path as-is and with trailing slash for directories
+            if spec.match_file(check_path):
+                return True
+            if is_dir and spec.match_file(check_path + "/"):
+                return True
+
+        return False
+
+    def check_dir_for_gitignore(self, abs_dir: str, rel_dir: str) -> None:
+        """Check if directory contains a .gitignore and load it."""
+        self._load_spec_for_dir(abs_dir, rel_dir)
 
 # ── File extensions we consider "source code" ─────────────────────────
 _SOURCE_EXTENSIONS = frozenset({
@@ -397,8 +454,9 @@ def index_file(filepath: str, db) -> dict:
 def index_directory(dirpath: str, db) -> list[dict]:
     """Recursively index all source files under *dirpath*.
 
-    Skips directories in ``_SKIP_DIRS``, files matching ``.gitignore`` patterns,
-    and unchanged files.  Indexes any file with a recognised source-code extension.
+    Skips directories in ``_SKIP_DIRS``, files matching ``.gitignore`` patterns
+    (including nested .gitignore files), and unchanged files.  Indexes any file
+    with a recognised source-code extension.
 
     Args:
         dirpath: Root directory to scan.
@@ -413,32 +471,33 @@ def index_directory(dirpath: str, db) -> list[dict]:
     dirpath = os.path.abspath(dirpath)
     total_start = time.perf_counter()
 
-    # Load .gitignore patterns from the root directory
-    gitignore_spec = _load_gitignore_spec(dirpath)
-    if gitignore_spec:
-        logger.debug("Loaded .gitignore patterns from %s", dirpath)
+    # Initialize gitignore matcher (supports nested .gitignore files)
+    gitignore = GitignoreMatcher(dirpath)
+    logger.debug("Initialized gitignore matcher for %s", dirpath)
 
     for root, dirs, files in os.walk(dirpath, topdown=True):
         rel_root = os.path.relpath(root, dirpath)
 
+        # Check for .gitignore in current directory and load it
+        if rel_root != ".":
+            gitignore.check_dir_for_gitignore(root, rel_root)
+
         # Prune skipped directories in-place (always-skip + gitignore)
         def _should_keep_dir(d: str) -> bool:
             if d in _SKIP_DIRS or d.endswith(".egg-info"):
                 return False
-            if gitignore_spec:
-                rel_path = os.path.join(rel_root, d) if rel_root != "." else d
-                if _should_skip_path(rel_path, is_dir=True, gitignore_spec=gitignore_spec):
-                    return False
+            rel_path = os.path.join(rel_root, d) if rel_root != "." else d
+            if gitignore.should_skip(rel_path, is_dir=True):
+                return False
             return True
 
         dirs[:] = [d for d in dirs if _should_keep_dir(d)]
 
         for fname in sorted(files):
             # Skip files matching .gitignore patterns
-            if gitignore_spec:
-                rel_path = os.path.join(rel_root, fname) if rel_root != "." else fname
-                if _should_skip_path(rel_path, is_dir=False, gitignore_spec=gitignore_spec):
-                    continue
+            rel_path = os.path.join(rel_root, fname) if rel_root != "." else fname
+            if gitignore.should_skip(rel_path, is_dir=False):
+                continue
 
             ext = os.path.splitext(fname)[1].lower()
             # Accept files with known extensions, or files with a

{code_memory-1.0.10 → code_memory-1.0.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-memory"
-version = "1.0.10"
+version = "1.0.12"
 description = "A deterministic, high-precision code intelligence MCP server"
 readme = "README.md"
 license = "MIT"

{code_memory-1.0.10 → code_memory-1.0.12}/queries.py

@@ -156,7 +156,7 @@ def hybrid_search(query: str, db, top_k: int = 10) -> list[dict]:
 # ---------------------------------------------------------------------------
 
 
-def find_definition(symbol_name: str, db) -> list[dict]:
+def find_definition(symbol_name: str, db, include_context: bool = True) -> list[dict]:
     """Find where *symbol_name* is defined using hybrid search.
 
     Post-filters for exact name matches first; falls back to top hybrid
@@ -165,22 +165,89 @@ def find_definition(symbol_name: str, db) -> list[dict]:
     Args:
         symbol_name: The name of the symbol to find.
         db: An open ``sqlite3.Connection``.
+        include_context: If True, include docstrings and parent symbol info.
 
     Returns:
-        A list of result dicts.
+        A list of result dicts with enriched information.
     """
     results = hybrid_search(symbol_name, db, top_k=20)
 
     # Exact-match filter (case-sensitive)
     exact = [r for r in results if r["name"] == symbol_name]
-    if exact:
-        return exact
+    matched = exact if exact else results[:5]
 
-    # Fallback: return top results as best guesses
-    return results[:5]
+    if not include_context:
+        return matched
 
+    # Enrich results with docstrings and parent information
+    enriched = []
+    for r in matched:
+        symbol_id = r.get("symbol_id") or _get_symbol_id(r["name"], r["file_path"], db)
+        enriched_result = {
+            **r,
+            "docstring": None,
+            "parent": None,
+            "signature": _extract_signature(r.get("source_text", "")),
+        }
+
+        # Get parent symbol
+        if symbol_id:
+            parent_row = db.execute(
+                """
+                SELECT p.name, p.kind
+                FROM symbols s
+                LEFT JOIN symbols p ON p.id = s.parent_symbol_id
+                WHERE s.id = ?
+                """,
+                (symbol_id,),
+            ).fetchone()
+            if parent_row and parent_row[0]:
+                enriched_result["parent"] = {"name": parent_row[0], "kind": parent_row[1]}
+
+        # Get docstring from doc_chunks
+        doc_row = db.execute(
+            """
+            SELECT dc.content
+            FROM doc_chunks dc
+            JOIN doc_files df ON df.id = dc.doc_file_id
+            WHERE df.path = ? AND dc.line_start <= ? AND dc.line_end >= ?
+            AND df.doc_type = 'docstring'
+            LIMIT 1
+            """,
+            (r["file_path"], r["line_start"], r["line_start"]),
+        ).fetchone()
+        if doc_row:
+            enriched_result["docstring"] = doc_row[0]
+
+        enriched.append(enriched_result)
 
-def find_references(symbol_name: str, db) -> list[dict]:
+    return enriched
+
+
+def _get_symbol_id(name: str, file_path: str, db) -> int | None:
+    """Get symbol ID by name and file path."""
+    row = db.execute(
+        "SELECT id FROM symbols WHERE name = ? AND file_id = (SELECT id FROM files WHERE path = ?)",
+        (name, file_path),
+    ).fetchone()
+    return row[0] if row else None
+
+
+def _extract_signature(source_text: str) -> str | None:
+    """Extract the function/class signature from source text."""
+    if not source_text:
+        return None
+    lines = source_text.strip().split("\n")
+    if not lines:
+        return None
+    # Return first meaningful line (signature)
+    first_line = lines[0].strip()
+    if len(first_line) > 100:
+        return first_line[:100] + "..."
+    return first_line if first_line else None
+
+
+def find_references(symbol_name: str, db, include_context: bool = True) -> list[dict]:
     """Find all cross-references to *symbol_name*.
 
     Queries the ``references_`` table for exact matches.
@@ -188,9 +255,10 @@ def find_references(symbol_name: str, db) -> list[dict]:
     Args:
         symbol_name: The name of the symbol to find references for.
         db: An open ``sqlite3.Connection``.
+        include_context: If True, include source context and containing symbol.
 
     Returns:
-        A list of dicts with ``symbol_name``, ``file_path``, ``line_number``.
+        A list of dicts with enriched reference information.
     """
     rows = db.execute(
         """
@@ -203,10 +271,51 @@ def find_references(symbol_name: str, db) -> list[dict]:
         (symbol_name,),
     ).fetchall()
 
-    return [
-        {"symbol_name": r[0], "file_path": r[1], "line_number": r[2]}
-        for r in rows
-    ]
+    if not include_context:
+        return [
+            {"symbol_name": r[0], "file_path": r[1], "line_number": r[2]}
+            for r in rows
+        ]
+
+    # Enrich with context
+    enriched = []
+    for r in rows:
+        ref = {
+            "symbol_name": r[0],
+            "file_path": r[1],
+            "line_number": r[2],
+            "source_line": None,
+            "containing_symbol": None,
+        }
+
+        # Get the source line at this reference
+        try:
+            with open(r[1], "r") as f:
+                lines = f.readlines()
+                if 0 < r[2] <= len(lines):
+                    ref["source_line"] = lines[r[2] - 1].strip()
+        except Exception:
+            pass
+
+        # Find containing symbol
+        containing = db.execute(
+            """
+            SELECT s.name, s.kind
+            FROM symbols s
+            JOIN files f ON f.id = s.file_id
+            WHERE f.path = ?
+            AND s.line_start <= ? AND s.line_end >= ?
+            ORDER BY (s.line_end - s.line_start)
+            LIMIT 1
+            """,
+            (r[1], r[2], r[2]),
+        ).fetchone()
+        if containing:
+            ref["containing_symbol"] = {"name": containing[0], "kind": containing[1]}
+
+        enriched.append(ref)
+
+    return enriched
 
 
 def get_file_structure(file_path: str, db) -> list[dict]:
@@ -449,7 +558,7 @@ def _add_context_chunks(results: list[dict], db) -> list[dict]:
 # ---------------------------------------------------------------------------
 
 
-def discover_topic(topic_query: str, db, top_k: int = 15) -> list[dict]:
+def discover_topic(topic_query: str, db, top_k: int = 15, include_snippets: bool = True) -> list[dict]:
     """Discover files and code related to a high-level topic or feature.
 
     This function performs broad semantic search across both code symbols
@@ -465,6 +574,7 @@ def discover_topic(topic_query: str, db, top_k: int = 15) -> list[dict]:
                      Examples: "authentication", "workout tracking", "email notifications"
         db: An open ``sqlite3.Connection``.
         top_k: Maximum number of files to return (default 15).
+        include_snippets: If True, include code snippets for top symbols.
 
     Returns:
         A list of file-level results, each containing:
@@ -472,7 +582,9 @@ def discover_topic(topic_query: str, db, top_k: int = 15) -> list[dict]:
         - relevance_score: Combined semantic relevance score
         - matched_symbols: List of symbol names that matched the topic
         - matched_docs: List of doc section titles that matched
+        - symbol_kinds: Types of symbols found (function, class, etc.)
         - summary: Brief description of what in this file is relevant
+        - top_snippets: Code snippets from top-matching symbols (if include_snippets)
     """
     # Run parallel searches on both code symbols and documentation
     code_results = hybrid_search(topic_query, db, top_k=50)
@@ -492,10 +604,19 @@ def discover_topic(topic_query: str, db, top_k: int = 15) -> list[dict]:
                 "matched_symbols": [],
                 "matched_docs": [],
                 "symbol_kinds": set(),
+                "symbol_details": [],  # Store full details for snippets
             }
         file_aggregates[fp]["relevance_score"] += r.get("score", 0.5)
         file_aggregates[fp]["matched_symbols"].append(r.get("name", ""))
         file_aggregates[fp]["symbol_kinds"].add(r.get("kind", ""))
+        file_aggregates[fp]["symbol_details"].append({
+            "name": r.get("name"),
+            "kind": r.get("kind"),
+            "line_start": r.get("line_start"),
+            "line_end": r.get("line_end"),
+            "source_text": r.get("source_text"),
+            "score": r.get("score"),
+        })
 
     for r in doc_results:
         fp = r.get("source_file", "")
@@ -508,6 +629,7 @@ def discover_topic(topic_query: str, db, top_k: int = 15) -> list[dict]:
                 "matched_symbols": [],
                 "matched_docs": [],
                 "symbol_kinds": set(),
+                "symbol_details": [],
             }
         file_aggregates[fp]["relevance_score"] += r.get("score", 0.5)
         section = r.get("section_title", "")
@@ -531,13 +653,46 @@ def discover_topic(topic_query: str, db, top_k: int = 15) -> list[dict]:
 
         kinds = ", ".join(k for k in item["symbol_kinds"] if k)
 
-        results.append({
+        result = {
             "file_path": item["file_path"],
             "relevance_score": round(item["relevance_score"], 4),
             "matched_symbols": item["matched_symbols"][:10],
             "matched_docs": item["matched_docs"][:5],
             "symbol_kinds": kinds,
             "summary": f"Contains {kinds}: {symbol_summary}" if kinds else f"Related symbols: {symbol_summary}",
-        })
+        }
+
+        # Add top snippets if requested
+        if include_snippets and item["symbol_details"]:
+            # Sort by score and take top 2
+            top_symbols = sorted(
+                item["symbol_details"],
+                key=lambda x: x.get("score", 0) or 0,
+                reverse=True
+            )[:2]
+            result["top_snippets"] = [
+                {
+                    "name": s["name"],
+                    "kind": s["kind"],
+                    "line_range": f"{s['line_start']}-{s['line_end']}",
+                    "code": _truncate_code(s.get("source_text", ""), max_lines=15),
+                }
+                for s in top_symbols if s.get("source_text")
+            ]
+
+        results.append(result)
 
     return results
+
+
+def _truncate_code(source_text: str, max_lines: int = 15, max_chars: int = 500) -> str:
+    """Truncate source code to a reasonable preview size."""
+    if not source_text:
+        return ""
+    lines = source_text.strip().split("\n")
+    if len(lines) <= max_lines and len(source_text) <= max_chars:
+        return source_text.strip()
+    truncated = "\n".join(lines[:max_lines])
+    if len(truncated) > max_chars:
+        truncated = truncated[:max_chars]
+    return truncated + "\n// ... (truncated)"

{code_memory-1.0.10 → code_memory-1.0.12}/server.py

@@ -41,6 +41,15 @@ if the codebase has not been indexed. Always check if indexing is needed:
 2. THEN: Use search_code, search_docs, or search_history to find information
 3. RE-INDEX: If you modify files or haven't indexed recently, run index_codebase again
 
+TOOL SELECTION - USE THESE INSTEAD OF grep/glob/find:
+
+When you would normally use grep, rg, find, or glob, use search_code instead:
+- "grep -r pattern" → search_code(query="pattern", search_type="topic_discovery")
+- "find . -name '*.py' | xargs grep 'class X'" → search_code(query="X", search_type="definition")
+- "Show me files related to auth" → search_code(query="auth", search_type="topic_discovery")
+
+search_code provides SEMANTIC understanding - it finds related concepts, not just text matches.
+
 When to use each tool:
 - search_code: THE PREFERRED tool for finding code. Use "topic_discovery" for feature/domain searches (e.g., "workout related files"), "definition" for specific symbols, "references" for usages.
 - search_docs: Understanding architecture, reading documentation/READMEs
@@ -125,7 +134,9 @@ def search_code(
     search_type: Literal["topic_discovery", "definition", "references", "file_structure"],
     directory: str,
 ) -> dict:
-    """THE PREFERRED TOOL for discovering code and files in this codebase. Use this when you need to find files or code related to ANY feature, domain, topic, or concept - even if the exact keywords don't appear in filenames.
+    """USE THIS INSTEAD OF grep/glob/find for ANY code search. This tool provides SEMANTIC code understanding - it finds related concepts, not just text matches.
+
+    STOP: Before using grep, rg, find, or glob, use this tool instead. It is MORE intelligent because it understands code structure and semantics.
 
     PREREQUISITE: This tool requires indexing. If results are empty or you haven't indexed this session, call index_codebase(directory) first.
 
@@ -169,6 +180,12 @@ def search_code(
     - "references": "send_email", "validate_token"
     - "file_structure": "src/services/auth.py"
 
+    INSTEAD OF GREP EXAMPLES:
+    - Instead of: grep -r "auth" . → Use: search_code(query="auth", search_type="topic_discovery")
+    - Instead of: grep -r "class User" → Use: search_code(query="User", search_type="definition")
+    - Instead of: grep -r "import.*auth" → Use: search_code(query="auth", search_type="references")
+    - Instead of: find . -name "*.py" | xargs grep "login" → Use: search_code(query="login", search_type="topic_discovery")
+
     Do NOT use this tool for:
     - Reading full file contents (use your built-in file reader)
     - Git history queries (use search_history)
@@ -183,7 +200,25 @@ def search_code(
         directory: Path to the project directory to search.
 
     Returns:
-        Dict with status, search_type, query, and results array. Result format varies by search_type.
+        Dict with status, search_type, query, and results array.
+
+        For topic_discovery, each result includes:
+        - file_path, relevance_score, matched_symbols, matched_docs, symbol_kinds, summary
+        - top_snippets: Code snippets from top-matching symbols
+
+        For definition, each result includes:
+        - name, kind, file_path, line_start, line_end, source_text, score
+        - docstring: Extracted docstring (if available)
+        - parent: {name, kind} of containing class/module
+        - signature: First line of the symbol (function signature or class declaration)
+
+        For references, each result includes:
+        - symbol_name, file_path, line_number
+        - source_line: The actual line of code with the reference
+        - containing_symbol: {name, kind} of the function/class containing this reference
+
+        For file_structure, each result includes:
+        - name, kind, line_start, line_end, parent
     """
     with logging_config.ToolLogger("search_code", query=query, search_type=search_type) as log:
         try: